Merge #627

627: Update Rust nightly, embedded-hal 1.0, embedded-hal-async. r=Dirbaio a=Dirbaio Includes the SpiDevice/SpiBus split. rust-embedded/embedded-hal#351 Includes the GAT where clause location change. rust-lang/rust#89122 Co-authored-by: Dario Nieuwenhuis <dirbaio@dirbaio.net>
embassy-rs · Mar 10, 2022 · fa4c914 · fa4c914
2 parents 828cdb2 + cbb7ca3
commit fa4c914
Show file tree

Hide file tree

Showing 33 changed files with 719 additions and 842 deletions.
diff --git a/embassy-hal-common/src/peripheral.rs b/embassy-hal-common/src/peripheral.rs
@@ -97,7 +97,7 @@ impl<'a, S: PeripheralState> PeripheralMutex<'a, S> {
             //   Interrupts' priorities can only be changed with raw embassy `Interrupts`,
             //   which can't safely store a `PeripheralMutex` across invocations.
             // - We can't have preempted a with() call because the irq is disabled during it.
-            let state = unsafe { &mut *(p as *mut S) };
+            let state = &mut *(p as *mut S);
             state.on_interrupt();
         });
         irq.set_handler_context(state_ptr as *mut ());

diff --git a/embassy-lora/Cargo.toml b/embassy-lora/Cargo.toml
@@ -18,8 +18,8 @@ log = { version = "0.4.14", optional = true }
 
 embassy = { version = "0.1.0", path = "../embassy", default-features = false }
 embassy-stm32 = { version = "0.1.0", path = "../embassy-stm32", default-features = false, optional = true }
-embedded-hal-1 = { package = "embedded-hal", version = "1.0.0-alpha.6", git = "https://github.com/embassy-rs/embedded-hal", branch = "embassy", optional = true}
-embedded-hal-async = { version = "0.0.1", git = "https://github.com/embassy-rs/embedded-hal", branch = "embassy"}
+embedded-hal-1 = { package = "embedded-hal", version = "1.0.0-alpha.7", git = "https://github.com/embassy-rs/embedded-hal", branch = "embassy2", optional = true}
+embedded-hal-async = { version = "0.0.1", git = "https://github.com/embassy-rs/embedded-hal", branch = "embassy2"}
 embassy-hal-common = { version = "0.1.0", path = "../embassy-hal-common", default-features = false }
 futures = { version = "0.3.17", default-features = false, features = [ "async-await" ] }
 embedded-hal = { version = "0.2", features = ["unproven"] }

diff --git a/embassy-lora/src/stm32wl/mod.rs b/embassy-lora/src/stm32wl/mod.rs
@@ -78,7 +78,7 @@ impl<'a> SubGhzRadio<'a> {
             // This is safe because we only get interrupts when configured for, so
             // the radio will be awaiting on the signal at this point. If not, the ISR will
             // anyway only adjust the state in the IRQ signal state.
-            let state = unsafe { &mut *(p as *mut StateInner<'a>) };
+            let state = &mut *(p as *mut StateInner<'a>);
             state.on_interrupt();
         });
         irq.set_handler_context(state_ptr as *mut ());

diff --git a/embassy-lora/src/sx127x/mod.rs b/embassy-lora/src/sx127x/mod.rs
@@ -20,7 +20,7 @@ pub trait RadioSwitch {
 /// Semtech Sx127x radio peripheral
 pub struct Sx127xRadio<SPI, CS, RESET, E, I, RFS>
 where
-    SPI: ReadWrite<u8, Error = E> + 'static,
+    SPI: SpiBus<u8, Error = E> + 'static,
     E: 'static,
     CS: OutputPin + 'static,
     RESET: OutputPin + 'static,
@@ -42,7 +42,7 @@ pub enum State {
 
 impl<SPI, CS, RESET, E, I, RFS> Sx127xRadio<SPI, CS, RESET, E, I, RFS>
 where
-    SPI: ReadWrite<u8, Error = E> + 'static,
+    SPI: SpiBus<u8, Error = E> + 'static,
     CS: OutputPin + 'static,
     RESET: OutputPin + 'static,
     I: Wait + 'static,
@@ -64,7 +64,7 @@ where
 
 impl<SPI, CS, RESET, E, I, RFS> Timings for Sx127xRadio<SPI, CS, RESET, E, I, RFS>
 where
-    SPI: ReadWrite<u8, Error = E> + 'static,
+    SPI: SpiBus<u8, Error = E> + 'static,
     CS: OutputPin + 'static,
     RESET: OutputPin + 'static,
     I: Wait + 'static,
@@ -80,7 +80,7 @@ where
 
 impl<SPI, CS, RESET, E, I, RFS> PhyRxTx for Sx127xRadio<SPI, CS, RESET, E, I, RFS>
 where
-    SPI: ReadWrite<u8, Error = E> + 'static,
+    SPI: SpiBus<u8, Error = E> + 'static,
     CS: OutputPin + 'static,
     E: 'static,
     RESET: OutputPin + 'static,
@@ -89,15 +89,14 @@ where
 {
     type PhyError = Sx127xError;
 
-    type TxFuture<'m>
+    type TxFuture<'m> = impl Future<Output = Result<u32, Self::PhyError>> + 'm
     where
         SPI: 'm,
         CS: 'm,
         RESET: 'm,
         E: 'm,
         I: 'm,
-        RFS: 'm,
-    = impl Future<Output = Result<u32, Self::PhyError>> + 'm;
+        RFS: 'm;
 
     fn tx<'m>(&'m mut self, config: TxConfig, buf: &'m [u8]) -> Self::TxFuture<'m> {
         trace!("TX START");
@@ -137,15 +136,14 @@ where
         }
     }
 
-    type RxFuture<'m>
+    type RxFuture<'m> = impl Future<Output = Result<(usize, RxQuality), Self::PhyError>> + 'm
     where
         SPI: 'm,
         CS: 'm,
         RESET: 'm,
         E: 'm,
         I: 'm,
-        RFS: 'm,
-    = impl Future<Output = Result<(usize, RxQuality), Self::PhyError>> + 'm;
+        RFS: 'm;
 
     fn rx<'m>(&'m mut self, config: RfConfig, buf: &'m mut [u8]) -> Self::RxFuture<'m> {
         trace!("RX START");

diff --git a/embassy-lora/src/sx127x/sx127x_lora/mod.rs b/embassy-lora/src/sx127x/sx127x_lora/mod.rs
@@ -8,7 +8,7 @@
 use bit_field::BitField;
 use embassy::time::{Duration, Timer};
 use embedded_hal::digital::v2::OutputPin;
-use embedded_hal_async::spi::ReadWrite;
+use embedded_hal_async::spi::SpiBus;
 
 mod register;
 use self::register::PaConfig;
@@ -48,7 +48,7 @@ const VERSION_CHECK: u8 = 0x09;
 
 impl<SPI, CS, RESET, E> LoRa<SPI, CS, RESET>
 where
-    SPI: ReadWrite<u8, Error = E>,
+    SPI: SpiBus<u8, Error = E>,
     CS: OutputPin,
     RESET: OutputPin,
 {

diff --git a/embassy-nrf/Cargo.toml b/embassy-nrf/Cargo.toml
@@ -63,8 +63,8 @@ embassy-macros = { version = "0.1.0", path = "../embassy-macros", features = ["n
 embassy-hal-common = {version = "0.1.0", path = "../embassy-hal-common" }
 
 embedded-hal-02 = { package = "embedded-hal", version = "0.2.6", features = ["unproven"] }
-embedded-hal-1 = { package = "embedded-hal", version = "1.0.0-alpha.6", git = "https://github.com/embassy-rs/embedded-hal", branch = "embassy", optional = true}
-embedded-hal-async = { version = "0.0.1", git = "https://github.com/embassy-rs/embedded-hal", branch = "embassy", optional = true}
+embedded-hal-1 = { package = "embedded-hal", version = "1.0.0-alpha.7", git = "https://github.com/embassy-rs/embedded-hal", branch = "embassy2", optional = true}
+embedded-hal-async = { version = "0.0.1", git = "https://github.com/embassy-rs/embedded-hal", branch = "embassy2", optional = true}
 
 defmt = { version = "0.3", optional = true }
 log = { version = "0.4.14", optional = true }

diff --git a/embassy-nrf/src/gpiote.rs b/embassy-nrf/src/gpiote.rs
@@ -108,7 +108,7 @@ unsafe fn handle_gpiote_interrupt() {
 
     for i in 0..CHANNEL_COUNT {
         if g.events_in[i].read().bits() != 0 {
-            g.intenclr.write(|w| unsafe { w.bits(1 << i) });
+            g.intenclr.write(|w| w.bits(1 << i));
             CHANNEL_WAKERS[i].wake();
         }
     }
@@ -481,102 +481,72 @@ mod eh1 {
     }
 }
 
-#[cfg(all(feature = "unstable-traits", feature = "nightly"))]
-mod eh1a {
-    use super::*;
-    use futures::FutureExt;
+cfg_if::cfg_if! {
+    if #[cfg(all(feature = "unstable-traits", feature = "nightly"))] {
+        use futures::FutureExt;
 
-    impl<'d, T: GpioPin> embedded_hal_async::digital::Wait for Input<'d, T> {
-        type WaitForHighFuture<'a>
-        where
-            Self: 'a,
-        = impl Future<Output = Result<(), Self::Error>> + 'a;
+        impl<'d, T: GpioPin> embedded_hal_async::digital::Wait for Input<'d, T> {
+            type WaitForHighFuture<'a> = impl Future<Output = Result<(), Self::Error>> + 'a where Self: 'a;
 
-        fn wait_for_high<'a>(&'a mut self) -> Self::WaitForHighFuture<'a> {
-            self.wait_for_high().map(Ok)
-        }
+            fn wait_for_high<'a>(&'a mut self) -> Self::WaitForHighFuture<'a> {
+                self.wait_for_high().map(Ok)
+            }
 
-        type WaitForLowFuture<'a>
-        where
-            Self: 'a,
-        = impl Future<Output = Result<(), Self::Error>> + 'a;
+            type WaitForLowFuture<'a> = impl Future<Output = Result<(), Self::Error>> + 'a where Self: 'a;
 
-        fn wait_for_low<'a>(&'a mut self) -> Self::WaitForLowFuture<'a> {
-            self.wait_for_low().map(Ok)
-        }
+            fn wait_for_low<'a>(&'a mut self) -> Self::WaitForLowFuture<'a> {
+                self.wait_for_low().map(Ok)
+            }
 
-        type WaitForRisingEdgeFuture<'a>
-        where
-            Self: 'a,
-        = impl Future<Output = Result<(), Self::Error>> + 'a;
+            type WaitForRisingEdgeFuture<'a> = impl Future<Output = Result<(), Self::Error>> + 'a where Self: 'a;
 
-        fn wait_for_rising_edge<'a>(&'a mut self) -> Self::WaitForRisingEdgeFuture<'a> {
-            self.wait_for_rising_edge().map(Ok)
-        }
+            fn wait_for_rising_edge<'a>(&'a mut self) -> Self::WaitForRisingEdgeFuture<'a> {
+                self.wait_for_rising_edge().map(Ok)
+            }
 
-        type WaitForFallingEdgeFuture<'a>
-        where
-            Self: 'a,
-        = impl Future<Output = Result<(), Self::Error>> + 'a;
+            type WaitForFallingEdgeFuture<'a> = impl Future<Output = Result<(), Self::Error>> + 'a where Self: 'a;
 
-        fn wait_for_falling_edge<'a>(&'a mut self) -> Self::WaitForFallingEdgeFuture<'a> {
-            self.wait_for_falling_edge().map(Ok)
-        }
+            fn wait_for_falling_edge<'a>(&'a mut self) -> Self::WaitForFallingEdgeFuture<'a> {
+                self.wait_for_falling_edge().map(Ok)
+            }
 
-        type WaitForAnyEdgeFuture<'a>
-        where
-            Self: 'a,
-        = impl Future<Output = Result<(), Self::Error>> + 'a;
+            type WaitForAnyEdgeFuture<'a> = impl Future<Output = Result<(), Self::Error>> + 'a where Self: 'a;
 
-        fn wait_for_any_edge<'a>(&'a mut self) -> Self::WaitForAnyEdgeFuture<'a> {
-            self.wait_for_any_edge().map(Ok)
+            fn wait_for_any_edge<'a>(&'a mut self) -> Self::WaitForAnyEdgeFuture<'a> {
+                self.wait_for_any_edge().map(Ok)
+            }
         }
-    }
 
-    impl<'d, T: GpioPin> embedded_hal_async::digital::Wait for Flex<'d, T> {
-        type WaitForHighFuture<'a>
-        where
-            Self: 'a,
-        = impl Future<Output = Result<(), Self::Error>> + 'a;
+        impl<'d, T: GpioPin> embedded_hal_async::digital::Wait for Flex<'d, T> {
+            type WaitForHighFuture<'a> = impl Future<Output = Result<(), Self::Error>> + 'a where Self: 'a;
 
-        fn wait_for_high<'a>(&'a mut self) -> Self::WaitForHighFuture<'a> {
-            self.wait_for_high().map(Ok)
-        }
+            fn wait_for_high<'a>(&'a mut self) -> Self::WaitForHighFuture<'a> {
+                self.wait_for_high().map(Ok)
+            }
 
-        type WaitForLowFuture<'a>
-        where
-            Self: 'a,
-        = impl Future<Output = Result<(), Self::Error>> + 'a;
+            type WaitForLowFuture<'a> = impl Future<Output = Result<(), Self::Error>> + 'a where Self: 'a;
 
-        fn wait_for_low<'a>(&'a mut self) -> Self::WaitForLowFuture<'a> {
-            self.wait_for_low().map(Ok)
-        }
+            fn wait_for_low<'a>(&'a mut self) -> Self::WaitForLowFuture<'a> {
+                self.wait_for_low().map(Ok)
+            }
 
-        type WaitForRisingEdgeFuture<'a>
-        where
-            Self: 'a,
-        = impl Future<Output = Result<(), Self::Error>> + 'a;
+            type WaitForRisingEdgeFuture<'a> = impl Future<Output = Result<(), Self::Error>> + 'a where Self: 'a;
 
-        fn wait_for_rising_edge<'a>(&'a mut self) -> Self::WaitForRisingEdgeFuture<'a> {
-            self.wait_for_rising_edge().map(Ok)
-        }
+            fn wait_for_rising_edge<'a>(&'a mut self) -> Self::WaitForRisingEdgeFuture<'a> {
+                self.wait_for_rising_edge().map(Ok)
+            }
 
-        type WaitForFallingEdgeFuture<'a>
-        where
-            Self: 'a,
-        = impl Future<Output = Result<(), Self::Error>> + 'a;
+            type WaitForFallingEdgeFuture<'a> = impl Future<Output = Result<(), Self::Error>> + 'a where Self: 'a;
 
-        fn wait_for_falling_edge<'a>(&'a mut self) -> Self::WaitForFallingEdgeFuture<'a> {
-            self.wait_for_falling_edge().map(Ok)
-        }
+            fn wait_for_falling_edge<'a>(&'a mut self) -> Self::WaitForFallingEdgeFuture<'a> {
+                self.wait_for_falling_edge().map(Ok)
+            }
 
-        type WaitForAnyEdgeFuture<'a>
-        where
-            Self: 'a,
-        = impl Future<Output = Result<(), Self::Error>> + 'a;
+            type WaitForAnyEdgeFuture<'a> = impl Future<Output = Result<(), Self::Error>> + 'a where Self: 'a;
 
-        fn wait_for_any_edge<'a>(&'a mut self) -> Self::WaitForAnyEdgeFuture<'a> {
-            self.wait_for_any_edge().map(Ok)
+            fn wait_for_any_edge<'a>(&'a mut self) -> Self::WaitForAnyEdgeFuture<'a> {
+                self.wait_for_any_edge().map(Ok)
+            }
         }
     }
-}
+}