Update to embedded-hal-1.0.0-alpha.5

eldruin · eldruin · commit 18d704d362db · 2021-09-11T23:59:33.000+02:00
diff --git a/Cargo.toml b/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 }
 
diff --git a/examples/transactional-i2c.rs b/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]))
     }
 }
 
diff --git a/src/cdev_pin.rs b/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)
     }
 }
 
diff --git a/src/delay.rs b/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(())
     }
diff --git a/src/i2c.rs b/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],
diff --git a/src/serial.rs b/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]);
diff --git a/src/spi.rs b/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()
diff --git a/src/sysfs_pin.rs b/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)
     }
 }
 
diff --git a/src/timer.rs b/src/timer.rs

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use embedded_hal::blocking::i2c::{Operation as I2cOperation, Transactional};`
	`1`	`+use embedded_hal::i2c::blocking::{Operation as I2cOperation, Transactional};`
`2`	`2`	`use linux_embedded_hal::I2cdev;`
`3`	`3`
`4`	`4`	`const ADDR: u8 = 0x12;`
`@@ -21,7 +21,7 @@ where`
`21`	`21`	`I2cOperation::Write(&[0xAB]),`
`22`	`22`	`I2cOperation::Read(&mut read_buffer),`
`23`	`23`	`];`
`24`		`- self.i2c.try_exec(ADDR, &mut ops).and(Ok(read_buffer[0]))`
	`24`	`+ self.i2c.exec(ADDR, &mut ops).and(Ok(read_buffer[0]))`
`25`	`25`	`}`
`26`	`26`	`}`
`27`	`27`
Original file line number	Diff line number	Diff line change
`@@ -17,18 +17,18 @@ impl CdevPin {`
`17`	`17`	`}`
`18`	`18`	`}`
`19`	`19`
`20`		`-impl embedded_hal::digital::OutputPin for CdevPin {`
	`20`	`+impl embedded_hal::digital::blocking::OutputPin for CdevPin {`
`21`	`21`	`type Error = gpio_cdev::errors::Error;`
`22`	`22`
`23`		`- fn try_set_low(&mut self) -> Result<(), Self::Error> {`
	`23`	`+ fn set_low(&mut self) -> Result<(), Self::Error> {`
`24`	`24`	`if self.1 {`
`25`	`25`	`self.0.set_value(1)`
`26`	`26`	`} else {`
`27`	`27`	`self.0.set_value(0)`
`28`	`28`	`}`
`29`	`29`	`}`
`30`	`30`
`31`		`- fn try_set_high(&mut self) -> Result<(), Self::Error> {`
	`31`	`+ fn set_high(&mut self) -> Result<(), Self::Error> {`
`32`	`32`	`if self.1 {`
`33`	`33`	`self.0.set_value(0)`
`34`	`34`	`} else {`
`@@ -37,19 +37,19 @@ impl embedded_hal::digital::OutputPin for CdevPin {`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`
`40`		`-impl embedded_hal::digital::InputPin for CdevPin {`
	`40`	`+impl embedded_hal::digital::blocking::InputPin for CdevPin {`
`41`	`41`	`type Error = gpio_cdev::errors::Error;`
`42`	`42`
`43`		`- fn try_is_high(&self) -> Result<bool, Self::Error> {`
	`43`	`+ fn is_high(&self) -> Result<bool, Self::Error> {`
`44`	`44`	`if !self.1 {`
`45`	`45`	`self.0.get_value().map(\|val\| val != 0)`
`46`	`46`	`} else {`
`47`	`47`	`self.0.get_value().map(\|val\| val == 0)`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`
`51`		`- fn try_is_low(&self) -> Result<bool, Self::Error> {`
`52`		`- self.try_is_high().map(\|val\| !val)`
	`51`	`+ fn is_low(&self) -> Result<bool, Self::Error> {`
	`52`	`+ self.is_high().map(\|val\| !val)`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`
Original file line number	Diff line number	Diff line change
`@@ -28,18 +28,18 @@ impl SysfsPin {`
`28`	`28`	`}`
`29`	`29`	`}`
`30`	`30`
`31`		`-impl embedded_hal::digital::OutputPin for SysfsPin {`
	`31`	`+impl embedded_hal::digital::blocking::OutputPin for SysfsPin {`
`32`	`32`	`type Error = sysfs_gpio::Error;`
`33`	`33`
`34`		`- fn try_set_low(&mut self) -> Result<(), Self::Error> {`
	`34`	`+ fn set_low(&mut self) -> Result<(), Self::Error> {`
`35`	`35`	`if self.0.get_active_low()? {`
`36`	`36`	`self.0.set_value(1)`
`37`	`37`	`} else {`
`38`	`38`	`self.0.set_value(0)`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
`42`		`- fn try_set_high(&mut self) -> Result<(), Self::Error> {`
	`42`	`+ fn set_high(&mut self) -> Result<(), Self::Error> {`
`43`	`43`	`if self.0.get_active_low()? {`
`44`	`44`	`self.0.set_value(0)`
`45`	`45`	`} else {`
`@@ -48,19 +48,19 @@ impl embedded_hal::digital::OutputPin for SysfsPin {`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`
`51`		`-impl embedded_hal::digital::InputPin for SysfsPin {`
	`51`	`+impl embedded_hal::digital::blocking::InputPin for SysfsPin {`
`52`	`52`	`type Error = sysfs_gpio::Error;`
`53`	`53`
`54`		`- fn try_is_high(&self) -> Result<bool, Self::Error> {`
	`54`	`+ fn is_high(&self) -> Result<bool, Self::Error> {`
`55`	`55`	`if !self.0.get_active_low()? {`
`56`	`56`	`self.0.get_value().map(\|val\| val != 0)`
`57`	`57`	`} else {`
`58`	`58`	`self.0.get_value().map(\|val\| val == 0)`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`
`62`		`- fn try_is_low(&self) -> Result<bool, Self::Error> {`
`63`		`- self.try_is_high().map(\|val\| !val)`
	`62`	`+ fn is_low(&self) -> Result<bool, Self::Error> {`
	`63`	`+ self.is_high().map(\|val\| !val)`
`64`	`64`	`}`
`65`	`65`	`}`
`66`	`66`