Adapt embedded-hal v1.0.0-alpha.1

Author: luojia65

Cargo.toml

@@ -13,7 +13,7 @@ edition = "2018"
 targets = ["riscv64gc-unknown-none-elf"]
 
 [dependencies]
-embedded-hal = { version = "0.2.3", features = ["unproven"] }
+embedded-hal = "1.0.0-alpha.1"
 nb = "0.1.1"
 k210-pac = "0.2.0"
 bitflags = "1.2.1"

src/gpio.rs

@@ -5,7 +5,7 @@ use crate::pac;
 use crate::sysctl::{self, APB0};
 use crate::fpioa::{IoPin, Pull, Mode};
 use crate::bit_utils::{u32_set_bit, u32_toggle_bit, u32_bit_is_set, u32_bit_is_clear};
-use embedded_hal::digital::v2::{OutputPin, StatefulOutputPin, InputPin, ToggleableOutputPin};
+use embedded_hal::digital::{OutputPin, StatefulOutputPin, InputPin, ToggleableOutputPin};
 
 /// Extension trait to split a GPIO peripheral into independent pins
 pub trait GpioExt {
@@ -169,14 +169,14 @@ impl<GPIO: GpioIndex, PIN: IoPin, MODE: Active> Gpio<GPIO, PIN, MODE> {
 impl<GPIO: GpioIndex, PIN, MODE> InputPin for Gpio<GPIO, PIN, Input<MODE>> {
     type Error = core::convert::Infallible;
 
-    fn is_high(&self) -> Result<bool, Self::Error> { 
+    fn try_is_high(&self) -> Result<bool, Self::Error> { 
         Ok(unsafe { 
             let p = &(*pac::GPIO::ptr()).data_input as *const _ as *const _;
             u32_bit_is_set(p, GPIO::INDEX as usize)
         })
     }
 
-    fn is_low(&self) -> Result<bool, Self::Error> { 
+    fn try_is_low(&self) -> Result<bool, Self::Error> { 
         Ok(unsafe { 
             let p = &(*pac::GPIO::ptr()).data_input as *const _ as *const _;
             u32_bit_is_clear(p, GPIO::INDEX as usize)
@@ -187,15 +187,15 @@ impl<GPIO: GpioIndex, PIN, MODE> InputPin for Gpio<GPIO, PIN, Input<MODE>> {
 impl<GPIO: GpioIndex, PIN> OutputPin for Gpio<GPIO, PIN, Output> {
     type Error = core::convert::Infallible;
 
-    fn set_high(&mut self) -> Result<(), Self::Error> {
+    fn try_set_high(&mut self) -> Result<(), Self::Error> {
         unsafe { 
             let p = &(*pac::GPIO::ptr()).data_output as *const _ as *mut _;
             u32_set_bit(p, true, GPIO::INDEX as usize);
         }
         Ok(())
     }
 
-    fn set_low(&mut self) -> Result<(), Self::Error> {
+    fn try_set_low(&mut self) -> Result<(), Self::Error> {
         unsafe { 
             let p = &(*pac::GPIO::ptr()).data_output as *const _ as *mut _;
             u32_set_bit(p, false, GPIO::INDEX as usize);
@@ -205,14 +205,14 @@ impl<GPIO: GpioIndex, PIN> OutputPin for Gpio<GPIO, PIN, Output> {
 }
 
 impl<GPIO: GpioIndex, PIN> StatefulOutputPin for Gpio<GPIO, PIN, Output> {
-    fn is_set_high(&self) -> Result<bool, Self::Error> {
+    fn try_is_set_high(&self) -> Result<bool, Self::Error> {
         Ok(unsafe { 
             let p = &(*pac::GPIO::ptr()).data_output as *const _ as *const _;
             u32_bit_is_set(p, GPIO::INDEX as usize)
         })
     }
 
-    fn is_set_low(&self) -> Result<bool, Self::Error> { 
+    fn try_is_set_low(&self) -> Result<bool, Self::Error> { 
         Ok(unsafe { 
             let p = &(*pac::GPIO::ptr()).data_output as *const _ as *const _;
             u32_bit_is_clear(p, GPIO::INDEX as usize)
@@ -223,7 +223,7 @@ impl<GPIO: GpioIndex, PIN> StatefulOutputPin for Gpio<GPIO, PIN, Output> {
 impl<GPIO: GpioIndex, PIN> ToggleableOutputPin for Gpio<GPIO, PIN, Output> {
     type Error = core::convert::Infallible;
 
-    fn toggle(&mut self) -> Result<(), Self::Error> { 
+    fn try_toggle(&mut self) -> Result<(), Self::Error> { 
         unsafe { 
             let p = &(*pac::GPIO::ptr()).data_output as *const _ as *mut _;
             u32_toggle_bit(p, GPIO::INDEX as usize);

src/gpiohs.rs

@@ -3,7 +3,7 @@
 use crate::pac::GPIOHS;
 use core::marker::PhantomData;
 use crate::bit_utils::{u32_set_bit, u32_toggle_bit, u32_bit_is_set, u32_bit_is_clear};
-use embedded_hal::digital::v2::{InputPin, OutputPin};
+use embedded_hal::digital::{InputPin, OutputPin};
 
 // todo: verify
 
@@ -117,14 +117,14 @@ impl<MODE> Gpiohs0<MODE> {
 impl<MODE> InputPin for Gpiohs0<Input<MODE>> {
     type Error = core::convert::Infallible;
 
-    fn is_high(&self) -> Result<bool, Self::Error> { 
+    fn try_is_high(&self) -> Result<bool, Self::Error> { 
         Ok(unsafe { 
             let p = &(*GPIOHS::ptr()).input_val as *const _ as *const _;
             u32_bit_is_set(p, 0)
         })
     }
 
-    fn is_low(&self) -> Result<bool, Self::Error> { 
+    fn try_is_low(&self) -> Result<bool, Self::Error> { 
         Ok(unsafe { 
             let p = &(*GPIOHS::ptr()).input_val as *const _ as *const _;
             u32_bit_is_clear(p, 0)
@@ -135,15 +135,15 @@ impl<MODE> InputPin for Gpiohs0<Input<MODE>> {
 impl<MODE> OutputPin for Gpiohs0<Output<MODE>> {
     type Error = core::convert::Infallible;
 
-    fn set_high(&mut self) -> Result<(), Self::Error> {
+    fn try_set_high(&mut self) -> Result<(), Self::Error> {
         unsafe { 
             let p = &(*GPIOHS::ptr()).output_val as *const _ as *mut _;
             u32_set_bit(p, true, 0);
         }
         Ok(())
     }
 
-    fn set_low(&mut self) -> Result<(), Self::Error> {
+    fn try_set_low(&mut self) -> Result<(), Self::Error> {
         unsafe { 
             let p = &(*GPIOHS::ptr()).output_val as *const _ as *mut _;
             u32_set_bit(p, false, 0);

src/lib.rs

@@ -27,12 +27,6 @@ pub mod time;
 /// Prelude
 pub mod prelude {
     pub use embedded_hal::prelude::*;
-    pub use embedded_hal::digital::v2::{
-        InputPin as _embedded_hal_digital_v2_InputPin,
-        OutputPin as _embedded_hal_digital_v2_OutputPin,
-        StatefulOutputPin as _embedded_hal_digital_v2_StatefulOutputPin,
-        ToggleableOutputPin as _embedded_hal_digital_v2_ToggleableOutputPin,
-    };
     pub use crate::serial::SerialExt as _k210_hal_serial_SerialExt;
     pub use crate::stdout::Write as _k210_hal_stdout_Write;
     pub use crate::time::U32Ext as _k210_hal_time_U32Ext;

src/serial.rs

@@ -100,7 +100,7 @@ impl Serial<UARTHS> {
 impl serial::Read<u8> for Rx<UARTHS> {
     type Error = Infallible;
 
-    fn read(&mut self) -> nb::Result<u8, Infallible> {
+    fn try_read(&mut self) -> nb::Result<u8, Infallible> {
         let rxdata = self.uart.rxdata.read();
 
         if rxdata.empty().bit_is_set() {
@@ -114,7 +114,7 @@ impl serial::Read<u8> for Rx<UARTHS> {
 impl serial::Write<u8> for Tx<UARTHS> {
     type Error = Infallible;
 
-    fn write(&mut self, byte: u8) -> nb::Result<(), Infallible> {
+    fn try_write(&mut self, byte: u8) -> nb::Result<(), Infallible> {
         let txdata = self.uart.txdata.read();
 
         if txdata.full().bit_is_set() {
@@ -127,7 +127,7 @@ impl serial::Write<u8> for Tx<UARTHS> {
         }
     }
 
-    fn flush(&mut self) -> nb::Result<(), Infallible> {
+    fn try_flush(&mut self) -> nb::Result<(), Infallible> {
         let txdata = self.uart.txdata.read();
 
         if txdata.full().bit_is_set() {
@@ -200,7 +200,7 @@ impl<UART: UartX> Serial<UART> {
 impl<UART: UartX> serial::Read<u8> for Rx<UART> {
     type Error = Infallible;
 
-    fn read(&mut self) -> nb::Result<u8, Infallible> {
+    fn try_read(&mut self) -> nb::Result<u8, Infallible> {
         let lsr = self.uart.lsr.read();
 
         if (lsr.bits() & (1<<0)) == 0 { // Data Ready bit
@@ -215,7 +215,7 @@ impl<UART: UartX> serial::Read<u8> for Rx<UART> {
 impl<UART: UartX> serial::Write<u8> for Tx<UART> {
     type Error = Infallible;
 
-    fn write(&mut self, byte: u8) -> nb::Result<(), Infallible> {
+    fn try_write(&mut self, byte: u8) -> nb::Result<(), Infallible> {
         let lsr = self.uart.lsr.read();
 
         if (lsr.bits() & (1<<5)) != 0 { // Transmit Holding Register Empty bit
@@ -228,7 +228,7 @@ impl<UART: UartX> serial::Write<u8> for Tx<UART> {
         }
     }
 
-    fn flush(&mut self) -> nb::Result<(), Infallible> {
+    fn try_flush(&mut self) -> nb::Result<(), Infallible> {
         // TODO
         Ok(())
     }

src/stdout.rs

@@ -13,14 +13,14 @@ impl<'p, T> Write for Stdout<'p, T>
     fn write_str(&mut self, s: &str) -> core::fmt::Result {
         for byte in s.as_bytes() {
             if *byte == b'\n' {
-                let res = block!(self.0.write(b'\r'));
+                let res = block!(self.0.try_write(b'\r'));
 
                 if res.is_err() {
                     return Err(core::fmt::Error);
                 }
             }
 
-            let res = block!(self.0.write(*byte));
+            let res = block!(self.0.try_write(*byte));
 
             if res.is_err() {
                 return Err(core::fmt::Error);