Switch to embedded-hal SPI, GPIO traits.

examples/rpi-pico-w/src/main.rs

@@ -1,8 +1,9 @@
 #![no_std]
 #![no_main]
-#![feature(type_alias_impl_trait, concat_bytes)]
+#![feature(generic_associated_types, type_alias_impl_trait)]
 
-use core::slice;
+use core::convert::Infallible;
+use core::future::Future;
 
 use defmt::{assert, assert_eq, panic, *};
 use embassy::executor::Spawner;
@@ -13,8 +14,9 @@ use embassy_net::{Ipv4Address, Ipv4Cidr, Stack, StackResources};
 use embassy_rp::gpio::{Flex, Level, Output, Pin};
 use embassy_rp::peripherals::{PIN_23, PIN_24, PIN_25, PIN_29};
 use embassy_rp::Peripherals;
+use embedded_hal_1::spi::ErrorType;
+use embedded_hal_async::spi::{ExclusiveDevice, SpiBusFlush, SpiBusRead, SpiBusWrite};
 use embedded_io::asynch::{Read, Write};
-use heapless::Vec;
 use {defmt_rtt as _, panic_probe as _};
 
 macro_rules! forever {
@@ -26,7 +28,9 @@ macro_rules! forever {
 }
 
 #[embassy::task]
-async fn wifi_task(runner: cyw43::Runner<'static, PIN_23, PIN_25, PIN_29, PIN_24>) -> ! {
+async fn wifi_task(
+    runner: cyw43::Runner<'static, Output<'static, PIN_23>, ExclusiveDevice<MySpi, Output<'static, PIN_25>>>,
+) -> ! {
     runner.run().await
 }
 
@@ -39,25 +43,25 @@ async fn net_task(stack: &'static Stack<cyw43::NetDevice<'static>>) -> ! {
 async fn main(spawner: Spawner, p: Peripherals) {
     info!("Hello World!");
 
-    let (pwr, cs, clk, dio) = (p.PIN_23, p.PIN_25, p.PIN_29, p.PIN_24);
-    //let (pwr, cs, clk, dio) = (p.PIN_23, p.PIN_0, p.PIN_1, p.PIN_2);
+    let pwr = Output::new(p.PIN_23, Level::Low);
+    let cs = Output::new(p.PIN_25, Level::High);
+    let clk = Output::new(p.PIN_29, Level::Low);
+    let mut dio = Flex::new(p.PIN_24);
+    dio.set_low();
+    dio.set_as_output();
+
+    let bus = MySpi { clk, dio };
+    let spi = ExclusiveDevice::new(bus, cs);
 
     let state = forever!(cyw43::State::new());
-    let (mut control, runner) = cyw43::new(
-        state,
-        Output::new(pwr, Level::Low),
-        Output::new(cs, Level::High),
-        Output::new(clk, Level::Low),
-        Flex::new(dio),
-    )
-    .await;
+    let (mut control, runner) = cyw43::new(state, pwr, spi).await;
 
     spawner.spawn(wifi_task(runner)).unwrap();
 
     let net_device = control.init().await;
 
-    control.join_open("MikroTik-951589").await;
-    //control.join_wpa2("MikroTik-951589", "asdfasdfasdfasdf").await;
+    //control.join_open("MikroTik-951589").await;
+    control.join_wpa2("DirbaioWifi", "HelloWorld").await;
 
     let config = embassy_net::ConfigStrategy::Dhcp;
     //let config = embassy_net::ConfigStrategy::Static(embassy_net::Config {
@@ -122,3 +126,92 @@ async fn main(spawner: Spawner, p: Peripherals) {
         }
     }
 }
+
+struct MySpi {
+    /// SPI clock
+    clk: Output<'static, PIN_29>,
+
+    /// 4 signals, all in one!!
+    /// - SPI MISO
+    /// - SPI MOSI
+    /// - IRQ
+    /// - strap to set to gSPI mode on boot.
+    dio: Flex<'static, PIN_24>,
+}
+
+impl ErrorType for MySpi {
+    type Error = Infallible;
+}
+
+impl SpiBusFlush for MySpi {
+    type FlushFuture<'a> = impl Future<Output = Result<(), Self::Error>>
+    where
+        Self: 'a;
+
+    fn flush<'a>(&'a mut self) -> Self::FlushFuture<'a> {
+        async move { Ok(()) }
+    }
+}
+
+impl SpiBusRead for MySpi {
+    type ReadFuture<'a> = impl Future<Output = Result<(), Self::Error>>
+    where
+        Self: 'a;
+
+    fn read<'a>(&'a mut self, words: &'a mut [u8]) -> Self::ReadFuture<'a> {
+        async move {
+            self.dio.set_as_input();
+            for word in words {
+                let mut w = 0;
+                for _ in 0..8 {
+                    w = w << 1;
+
+                    // rising edge, sample data
+                    if self.dio.is_high() {
+                        w |= 0x01;
+                    }
+                    self.clk.set_high();
+
+                    // falling edge
+                    self.clk.set_low();
+                }
+                *word = w
+            }
+
+            Ok(())
+        }
+    }
+}
+
+impl SpiBusWrite for MySpi {
+    type WriteFuture<'a> = impl Future<Output = Result<(), Self::Error>>
+    where
+        Self: 'a;
+
+    fn write<'a>(&'a mut self, words: &'a [u8]) -> Self::WriteFuture<'a> {
+        async move {
+            self.dio.set_as_output();
+            for word in words {
+                let mut word = *word;
+                for _ in 0..8 {
+                    // falling edge, setup data
+                    self.clk.set_low();
+                    if word & 0x80 == 0 {
+                        self.dio.set_low();
+                    } else {
+                        self.dio.set_high();
+                    }
+
+                    // rising edge
+                    self.clk.set_high();
+
+                    word = word << 1;
+                }
+            }
+            self.clk.set_low();
+
+            self.dio.set_as_input();
+            Ok(())
+        }
+    }
+}