Update to use try_ functions

maxekman · maxekman · commit 207d67fe6d40 · 2020-04-28T19:36:46.000+02:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -47,8 +47,10 @@ default-features = false
 version = "1.0.2"
 
 [dependencies.embedded-hal]
-features = ["unproven"]
-version = "0.2.3"
+# TODO: Update version on next release.
+# version = "0.2.3"
+git = "https://github.com/rust-embedded/embedded-hal/"
+branch = "master"
 
 [dev-dependencies]
 panic-semihosting = "0.5.3"
diff --git a/src/adc.rs b/src/adc.rs
@@ -26,7 +26,7 @@ macro_rules! adc_pins {
         $(
             impl Channel<stm32::$adc> for $pin {
                 type ID = u8;
-                fn channel() -> u8 { $chan }
+                const CHANNEL: Self::ID = $chan;
             }
         )+
     };
@@ -668,7 +668,7 @@ macro_rules! adc {
                     }
 
                     let vref_cal = VrefCal::get().read();
-                    let vref_samp = self.read(&mut Vref).unwrap(); //This can't actually fail, it's just in a result to satisfy hal trait
+                    let vref_samp = self.try_read(&mut Vref).unwrap(); //This can't actually fail, it's just in a result to satisfy hal trait
 
                     self.calibrated_vdda = (VDDA_CALIB * u32::from(vref_cal)) / u32::from(vref_samp);
                     if !vref_en {
@@ -876,7 +876,7 @@ macro_rules! adc {
                         }
                     });
 
-                    let channel = CHANNEL::channel();
+                    let channel = CHANNEL::CHANNEL;
 
                     //Set the channel in the right sequence field
                     match sequence {
@@ -979,7 +979,7 @@ macro_rules! adc {
             {
                 type Error = ();
 
-                fn read(&mut self, pin: &mut PIN) -> nb::Result<u16, Self::Error> {
+                fn try_read(&mut self, pin: &mut PIN) -> nb::Result<u16, Self::Error> {
                     let enabled = self.is_enabled();
                     if !enabled {
                         self.enable();
diff --git a/src/delay.rs b/src/delay.rs
@@ -1,6 +1,8 @@
 //! Delays
 
 use cast::u32;
+use core::convert::Infallible;
+
 use cortex_m::peripheral::syst::SystClkSource;
 use cortex_m::peripheral::SYST;
 
@@ -28,25 +30,33 @@ impl Delay {
 }
 
 impl DelayMs<u32> for Delay {
-    fn delay_ms(&mut self, ms: u32) {
-        self.delay_us(ms * 1_000);
+    type Error = Infallible;
+
+    fn try_delay_ms(&mut self, ms: u32) -> Result<(), Self::Error> {
+        self.try_delay_us(ms * 1_000)
     }
 }
 
 impl DelayMs<u16> for Delay {
-    fn delay_ms(&mut self, ms: u16) {
-        self.delay_ms(u32(ms));
+    type Error = Infallible;
+
+    fn try_delay_ms(&mut self, ms: u16) -> Result<(), Self::Error> {
+        self.try_delay_ms(u32(ms))
     }
 }
 
 impl DelayMs<u8> for Delay {
-    fn delay_ms(&mut self, ms: u8) {
-        self.delay_ms(u32(ms));
+    type Error = Infallible;
+
+    fn try_delay_ms(&mut self, ms: u8) -> Result<(), Self::Error> {
+        self.try_delay_ms(u32(ms))
     }
 }
 
 impl DelayUs<u32> for Delay {
-    fn delay_us(&mut self, us: u32) {
+    type Error = Infallible;
+
+    fn try_delay_us(&mut self, us: u32) -> Result<(), Self::Error> {
         // The SysTick Reload Value register supports values between 1 and 0x00FFFFFF.
         const MAX_RVR: u32 = 0x00FF_FFFF;
 
@@ -70,17 +80,23 @@ impl DelayUs<u32> for Delay {
 
             self.syst.disable_counter();
         }
+
+        Ok(())
     }
 }
 
 impl DelayUs<u16> for Delay {
-    fn delay_us(&mut self, us: u16) {
-        self.delay_us(u32(us))
+    type Error = Infallible;
+
+    fn try_delay_us(&mut self, us: u16) -> Result<(), Self::Error> {
+        self.try_delay_us(u32(us))
     }
 }
 
 impl DelayUs<u8> for Delay {
-    fn delay_us(&mut self, us: u8) {
-        self.delay_us(u32(us))
+    type Error = Infallible;
+
+    fn try_delay_us(&mut self, us: u8) -> Result<(), Self::Error> {
+        self.try_delay_us(u32(us))
     }
 }
diff --git a/src/gpio.rs b/src/gpio.rs
@@ -101,7 +101,7 @@ macro_rules! gpio {
             use core::marker::PhantomData;
             use core::convert::Infallible;
 
-            use embedded_hal::digital::v2::{InputPin, OutputPin, StatefulOutputPin, toggleable};
+            use embedded_hal::digital::{InputPin, OutputPin, StatefulOutputPin, toggleable};
             use crate::stm32::$GPIOX;
 
             use crate::stm32::{RCC, EXTI, SYSCFG};
@@ -150,25 +150,25 @@ macro_rules! gpio {
             impl<MODE> OutputPin for $PXx<Output<MODE>> {
                 type Error = Infallible;
 
-                fn set_high(&mut self) -> Result<(), Self::Error> {
+                fn try_set_high(&mut self) -> Result<(), Self::Error> {
                     // NOTE(unsafe) atomic write to a stateless register
                     unsafe { (*$GPIOX::ptr()).bsrr.write(|w| w.bits(1 << self.i)) };
                     Ok(())
                 }
 
-                fn set_low(&mut self) -> Result<(), Self::Error> {
+                fn try_set_low(&mut self) -> Result<(), Self::Error> {
                     // NOTE(unsafe) atomic write to a stateless register
                     unsafe { (*$GPIOX::ptr()).bsrr.write(|w| w.bits(1 << (self.i + 16))) };
                     Ok(())
                 }
             }
 
             impl<MODE> StatefulOutputPin for $PXx<Output<MODE>> {
-                fn is_set_high(&self) -> Result<bool, Self::Error> {
-                    self.is_set_low().map(|v| !v)
+                fn try_is_set_high(&self) -> Result<bool, Self::Error> {
+                    self.try_is_set_low().map(|v| !v)
                 }
 
-                fn is_set_low(&self) -> Result<bool, Self::Error> {
+                fn try_is_set_low(&self) -> Result<bool, Self::Error> {
                     // NOTE(unsafe) atomic read with no side effects
                     Ok(unsafe { (*$GPIOX::ptr()).odr.read().bits() & (1 << self.i) == 0 })
                 }
@@ -179,11 +179,11 @@ macro_rules! gpio {
             impl<MODE> InputPin for $PXx<Output<MODE>> {
                 type Error = Infallible;
 
-                fn is_high(&self) -> Result<bool, Self::Error> {
-                    self.is_low().map(|v| !v)
+                fn try_is_high(&self) -> Result<bool, Self::Error> {
+                    self.try_is_low().map(|v| !v)
                 }
 
-                fn is_low(&self) -> Result<bool, Self::Error> {
+                fn try_is_low(&self) -> Result<bool, Self::Error> {
                     // NOTE(unsafe) atomic read with no side effects
                     Ok(unsafe { (*$GPIOX::ptr()).idr.read().bits() & (1 << self.i) == 0 })
                 }
@@ -192,11 +192,11 @@ macro_rules! gpio {
             impl<MODE> InputPin for $PXx<Input<MODE>> {
                 type Error = Infallible;
 
-                fn is_high(&self) -> Result<bool, Self::Error> {
-                    self.is_low().map(|v| !v)
+                fn try_is_high(&self) -> Result<bool, Self::Error> {
+                    self.try_is_low().map(|v| !v)
                 }
 
-                fn is_low(&self) -> Result<bool, Self::Error> {
+                fn try_is_low(&self) -> Result<bool, Self::Error> {
                     // NOTE(unsafe) atomic read with no side effects
                     Ok(unsafe { (*$GPIOX::ptr()).idr.read().bits() & (1 << self.i) == 0 })
                 }
@@ -670,25 +670,25 @@ macro_rules! gpio {
                 impl<MODE> OutputPin for $PXi<Output<MODE>> {
                     type Error = Infallible;
 
-                    fn set_high(&mut self) -> Result<(), Self::Error> {
+                    fn try_set_high(&mut self) -> Result<(), Self::Error> {
                         // NOTE(unsafe) atomic write to a stateless register
                         unsafe { (*$GPIOX::ptr()).bsrr.write(|w| w.bits(1 << $i)) };
                         Ok(())
                     }
 
-                    fn set_low(&mut self) -> Result<(), Self::Error> {
+                    fn try_set_low(&mut self) -> Result<(), Self::Error> {
                         // NOTE(unsafe) atomic write to a stateless register
                         unsafe { (*$GPIOX::ptr()).bsrr.write(|w| w.bits(1 << ($i + 16))) };
                         Ok(())
                     }
                 }
 
                 impl<MODE> StatefulOutputPin for $PXi<Output<MODE>> {
-                    fn is_set_high(&self) -> Result<bool, Self::Error> {
-                        self.is_set_low().map(|v| !v)
+                    fn try_is_set_high(&self) -> Result<bool, Self::Error> {
+                        self.try_is_set_low().map(|v| !v)
                     }
 
-                    fn is_set_low(&self) -> Result<bool, Self::Error> {
+                    fn try_is_set_low(&self) -> Result<bool, Self::Error> {
                         // NOTE(unsafe) atomic read with no side effects
                         Ok(unsafe { (*$GPIOX::ptr()).odr.read().bits() & (1 << $i) == 0 })
                     }
@@ -699,11 +699,11 @@ macro_rules! gpio {
                 impl<MODE> InputPin for $PXi<Output<MODE>> {
                     type Error = Infallible;
 
-                    fn is_high(&self) -> Result<bool, Self::Error> {
-                        self.is_low().map(|v| !v)
+                    fn try_is_high(&self) -> Result<bool, Self::Error> {
+                        self.try_is_low().map(|v| !v)
                     }
 
-                    fn is_low(&self) -> Result<bool, Self::Error> {
+                    fn try_is_low(&self) -> Result<bool, Self::Error> {
                         // NOTE(unsafe) atomic read with no side effects
                         Ok(unsafe { (*$GPIOX::ptr()).idr.read().bits() & (1 << $i) == 0 })
                     }
@@ -712,11 +712,11 @@ macro_rules! gpio {
                 impl<MODE> InputPin for $PXi<Input<MODE>> {
                     type Error = Infallible;
 
-                    fn is_high(&self) -> Result<bool, Self::Error> {
-                        self.is_low().map(|v| !v)
+                    fn try_is_high(&self) -> Result<bool, Self::Error> {
+                        self.try_is_low().map(|v| !v)
                     }
 
-                    fn is_low(&self) -> Result<bool, Self::Error> {
+                    fn try_is_low(&self) -> Result<bool, Self::Error> {
                         // NOTE(unsafe) atomic read with no side effects
                         Ok(unsafe { (*$GPIOX::ptr()).idr.read().bits() & (1 << $i) == 0 })
                     }
diff --git a/src/i2c.rs b/src/i2c.rs
@@ -739,9 +739,14 @@ where
 {
     type Error = Error;
 
-    fn write_read(&mut self, addr: u8, bytes: &[u8], buffer: &mut [u8]) -> Result<(), Self::Error> {
-        self.write(addr, bytes)?;
-        self.read(addr, buffer)?;
+    fn try_write_read(
+        &mut self,
+        addr: u8,
+        bytes: &[u8],
+        buffer: &mut [u8],
+    ) -> Result<(), Self::Error> {
+        self.try_write(addr, bytes)?;
+        self.try_read(addr, buffer)?;
 
         Ok(())
     }
@@ -753,7 +758,7 @@ where
 {
     type Error = Error;
 
-    fn write(&mut self, addr: u8, bytes: &[u8]) -> Result<(), Self::Error> {
+    fn try_write(&mut self, addr: u8, bytes: &[u8]) -> Result<(), Self::Error> {
         // Send a START condition
         self.i2c.cr1.modify(|_, w| w.start().set_bit());
 
@@ -793,7 +798,7 @@ where
 {
     type Error = Error;
 
-    fn read(&mut self, addr: u8, buffer: &mut [u8]) -> Result<(), Self::Error> {
+    fn try_read(&mut self, addr: u8, buffer: &mut [u8]) -> Result<(), Self::Error> {
         if let Some((last, buffer)) = buffer.split_last_mut() {
             // Send a START condition and set ACK bit
             self.i2c
diff --git a/src/prelude.rs b/src/prelude.rs
@@ -1,7 +1,7 @@
-pub use embedded_hal::digital::v2::InputPin as _embedded_hal_digital_v2_InputPin;
-pub use embedded_hal::digital::v2::OutputPin as _embedded_hal_digital_v2_OutputPin;
-pub use embedded_hal::digital::v2::StatefulOutputPin as _embedded_hal_digital_v2_StatefulOutputPin;
-pub use embedded_hal::digital::v2::ToggleableOutputPin as _embedded_hal_digital_v2_ToggleableOutputPin;
+pub use embedded_hal::digital::InputPin as _embedded_hal_digital_v2_InputPin;
+pub use embedded_hal::digital::OutputPin as _embedded_hal_digital_v2_OutputPin;
+pub use embedded_hal::digital::StatefulOutputPin as _embedded_hal_digital_v2_StatefulOutputPin;
+pub use embedded_hal::digital::ToggleableOutputPin as _embedded_hal_digital_v2_ToggleableOutputPin;
 pub use embedded_hal::prelude::*;
 
 pub use crate::gpio::GpioExt as _stm32f4xx_hal_gpio_GpioExt;
diff --git a/src/qei.rs b/src/qei.rs
@@ -1,6 +1,7 @@
 //! # Quadrature Encoder Interface
-use crate::hal::{self, Direction};
+use crate::hal::{self, qei::Direction};
 use crate::stm32::RCC;
+use core::convert::Infallible;
 
 use crate::gpio::gpioa::*;
 #[cfg(any(
@@ -825,18 +826,19 @@ macro_rules! hal {
                 }
             }
 
-            impl<PINS> hal::Qei for Qei<$TIM, PINS> {
+            impl<PINS> hal::qei::Qei for Qei<$TIM, PINS> {
+                type Error = Infallible;
                 type Count = $bits;
 
-                fn count(&self) -> $bits {
-                    self.tim.cnt.read().bits() as $bits
+                fn try_count(&self) -> Result<Self::Count, Self::Error> {
+                    Ok(self.tim.cnt.read().bits() as $bits)
                 }
 
-                fn direction(&self) -> Direction {
+                fn try_direction(&self) -> Result<Direction, Self::Error> {
                     if self.tim.cr1.read().dir().bit_is_clear() {
-                        hal::Direction::Upcounting
+                        Ok(Direction::Upcounting)
                     } else {
-                        hal::Direction::Downcounting
+                        Ok(Direction::Downcounting)
                     }
                 }
             }
diff --git a/src/rng.rs b/src/rng.rs
@@ -93,7 +93,7 @@ impl Rng {
 impl rng::Read for Rng {
     type Error = rand_core::Error;
 
-    fn read(&mut self, buffer: &mut [u8]) -> Result<(), Self::Error> {
+    fn try_read(&mut self, buffer: &mut [u8]) -> Result<(), Self::Error> {
         self.try_fill_bytes(buffer)
     }
 }
diff --git a/src/serial.rs b/src/serial.rs
diff --git a/src/spi.rs b/src/spi.rs
diff --git a/src/timer.rs b/src/timer.rs
diff --git a/src/watchdog.rs b/src/watchdog.rs

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,8 @@`
`1`	`1`	`//! Delays`
`2`	`2`
`3`	`3`	`use cast::u32;`
	`4`	`+use core::convert::Infallible;`
	`5`	`+`
`4`	`6`	`use cortex_m::peripheral::syst::SystClkSource;`
`5`	`7`	`use cortex_m::peripheral::SYST;`
`6`	`8`
`@@ -28,25 +30,33 @@ impl Delay {`
`28`	`30`	`}`
`29`	`31`
`30`	`32`	`impl DelayMs<u32> for Delay {`
`31`		`- fn delay_ms(&mut self, ms: u32) {`
`32`		`- self.delay_us(ms * 1_000);`
	`33`	`+ type Error = Infallible;`
	`34`	`+`
	`35`	`+ fn try_delay_ms(&mut self, ms: u32) -> Result<(), Self::Error> {`
	`36`	`+ self.try_delay_us(ms * 1_000)`
`33`	`37`	`}`
`34`	`38`	`}`
`35`	`39`
`36`	`40`	`impl DelayMs<u16> for Delay {`
`37`		`- fn delay_ms(&mut self, ms: u16) {`
`38`		`- self.delay_ms(u32(ms));`
	`41`	`+ type Error = Infallible;`
	`42`	`+`
	`43`	`+ fn try_delay_ms(&mut self, ms: u16) -> Result<(), Self::Error> {`
	`44`	`+ self.try_delay_ms(u32(ms))`
`39`	`45`	`}`
`40`	`46`	`}`
`41`	`47`
`42`	`48`	`impl DelayMs<u8> for Delay {`
`43`		`- fn delay_ms(&mut self, ms: u8) {`
`44`		`- self.delay_ms(u32(ms));`
	`49`	`+ type Error = Infallible;`
	`50`	`+`
	`51`	`+ fn try_delay_ms(&mut self, ms: u8) -> Result<(), Self::Error> {`
	`52`	`+ self.try_delay_ms(u32(ms))`
`45`	`53`	`}`
`46`	`54`	`}`
`47`	`55`
`48`	`56`	`impl DelayUs<u32> for Delay {`
`49`		`- fn delay_us(&mut self, us: u32) {`
	`57`	`+ type Error = Infallible;`
	`58`	`+`
	`59`	`+ fn try_delay_us(&mut self, us: u32) -> Result<(), Self::Error> {`
`50`	`60`	`// The SysTick Reload Value register supports values between 1 and 0x00FFFFFF.`
`51`	`61`	`const MAX_RVR: u32 = 0x00FF_FFFF;`
`52`	`62`
`@@ -70,17 +80,23 @@ impl DelayUs<u32> for Delay {`
`70`	`80`
`71`	`81`	`self.syst.disable_counter();`
`72`	`82`	`}`
	`83`	`+`
	`84`	`+ Ok(())`
`73`	`85`	`}`
`74`	`86`	`}`
`75`	`87`
`76`	`88`	`impl DelayUs<u16> for Delay {`
`77`		`- fn delay_us(&mut self, us: u16) {`
`78`		`- self.delay_us(u32(us))`
	`89`	`+ type Error = Infallible;`
	`90`	`+`
	`91`	`+ fn try_delay_us(&mut self, us: u16) -> Result<(), Self::Error> {`
	`92`	`+ self.try_delay_us(u32(us))`
`79`	`93`	`}`
`80`	`94`	`}`
`81`	`95`
`82`	`96`	`impl DelayUs<u8> for Delay {`
`83`		`- fn delay_us(&mut self, us: u8) {`
`84`		`- self.delay_us(u32(us))`
	`97`	`+ type Error = Infallible;`
	`98`	`+`
	`99`	`+ fn try_delay_us(&mut self, us: u8) -> Result<(), Self::Error> {`
	`100`	`+ self.try_delay_us(u32(us))`
`85`	`101`	`}`
`86`	`102`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`//! # Quadrature Encoder Interface`
`2`		`-use crate::hal::{self, Direction};`
	`2`	`+use crate::hal::{self, qei::Direction};`
`3`	`3`	`use crate::stm32::RCC;`
	`4`	`+use core::convert::Infallible;`
`4`	`5`
`5`	`6`	`use crate::gpio::gpioa::*;`
`6`	`7`	`#[cfg(any(`
`@@ -825,18 +826,19 @@ macro_rules! hal {`
`825`	`826`	`}`
`826`	`827`	`}`
`827`	`828`
`828`		`- impl<PINS> hal::Qei for Qei<$TIM, PINS> {`
	`829`	`+ impl<PINS> hal::qei::Qei for Qei<$TIM, PINS> {`
	`830`	`+ type Error = Infallible;`
`829`	`831`	`type Count = $bits;`
`830`	`832`
`831`		`- fn count(&self) -> $bits {`
`832`		`- self.tim.cnt.read().bits() as $bits`
	`833`	`+ fn try_count(&self) -> Result<Self::Count, Self::Error> {`
	`834`	`+ Ok(self.tim.cnt.read().bits() as $bits)`
`833`	`835`	`}`
`834`	`836`
`835`		`- fn direction(&self) -> Direction {`
	`837`	`+ fn try_direction(&self) -> Result<Direction, Self::Error> {`
`836`	`838`	`if self.tim.cr1.read().dir().bit_is_clear() {`
`837`		`- hal::Direction::Upcounting`
	`839`	`+ Ok(Direction::Upcounting)`
`838`	`840`	`} else {`
`839`		`- hal::Direction::Downcounting`
	`841`	`+ Ok(Direction::Downcounting)`
`840`	`842`	`}`
`841`	`843`	`}`
`842`	`844`	`}`
Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ impl Rng {`
`93`	`93`	`impl rng::Read for Rng {`
`94`	`94`	`type Error = rand_core::Error;`
`95`	`95`
`96`		`- fn read(&mut self, buffer: &mut [u8]) -> Result<(), Self::Error> {`
	`96`	`+ fn try_read(&mut self, buffer: &mut [u8]) -> Result<(), Self::Error> {`
`97`	`97`	`self.try_fill_bytes(buffer)`
`98`	`98`	`}`
`99`	`99`	`}`