diff --git a/esp-wifi/build.rs b/esp-wifi/build.rs index e552a8e2e..eb2ffaf17 100644 --- a/esp-wifi/build.rs +++ b/esp-wifi/build.rs @@ -164,7 +164,7 @@ fn main() -> Result<(), Box> { ( "country_code", "Country code. See [ESP-IDF Programming Guide](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/wifi.html#wi-fi-country-code)", - Value::String("CN".to_owned()), + Value::String("CA".to_owned()), None ), ( diff --git a/examples/src/bin/cat.rs b/examples/src/bin/cat.rs index d00305ec8..140be3865 100644 --- a/examples/src/bin/cat.rs +++ b/examples/src/bin/cat.rs @@ -13,20 +13,14 @@ #![no_std] #![no_main] -use core::net::Ipv4Addr; - use bincode::Decode; // use cyw43::JoinOptions; // use cyw43_pio::PioSpi; +use embassy_net::{Runner, StackResources}; use embassy_net::udp::{PacketMetadata, UdpSocket}; -use embassy_net::{tcp::TcpSocket, Runner, StackResources}; use embassy_executor::Spawner; -use blocking_network_stack::Stack; - use embassy_time::{Duration, Timer}; -use embassy_sync::{blocking_mutex::raw::NoopRawMutex, mutex::Mutex}; -use embassy_futures::select::{select, Either}; use esp_alloc as _; use esp_backtrace as _; use esp_hal::{clock::CpuClock, @@ -43,7 +37,6 @@ use esp_hal::{clock::CpuClock, time::RateExtU32, gpio::{Level, Output}, }; -use esp_hal::timer::systimer::SystemTimer; use esp_hal_embassy::InterruptExecutor; use esp_println::println; use esp_wifi::{ @@ -59,11 +52,8 @@ use esp_wifi::{ }, EspWifiController, }; -use esp_println::print; -use smoltcp::{ - iface::{SocketSet, SocketStorage}, - wire::{DhcpOption, IpAddress}, -}; +use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, signal::Signal}; +use esp_hal::timer::systimer::SystemTimer; use ws2812_async::{ColorOrder, Ws2812}; @@ -77,7 +67,7 @@ const CLIENT_ID: &str = env!("CLIENT_ID"); //static mut LEDSTRIP: &mut [u8] = &mut [0u8; NUM_LEDS * 3]; -static mut RGBARRAY: [RGB8; NUM_LEDS] = [RGB8::new(0, 0, 0); NUM_LEDS]; +//static mut RGBARRAY: [RGB8; NUM_LEDS] = [RGB8::new(0, 0, 0); NUM_LEDS]; // When you are okay with using a nightly compiler it's better to use https://docs.rs/static_cell/2.1.0/static_cell/macro.make_static.html macro_rules! mk_static { @@ -123,8 +113,8 @@ async fn main(spawner: Spawner) -> ! { let executor = InterruptExecutor::new(sw_ints.software_interrupt2); let executor = EXECUTOR.init(executor); - // let spawner = executor.start(Priority::Priority3); - // spawner.must_spawn(led_ctrl_core_task(sclk, miso, mosi, cs, peripherals.SPI2)); + static LED_ARRAY_DATA:StaticCell> = StaticCell::new(); + let led_array_signal = &*LED_ARRAY_DATA.init(Signal::new()); /////////////////////////// WIFI //////////////////////////////// @@ -132,16 +122,8 @@ async fn main(spawner: Spawner) -> ! { let (wifi_interface, controller) = esp_wifi::wifi::new_with_mode(&init, wifi, WifiStaDevice).unwrap(); - cfg_if::cfg_if! { - if #[cfg(feature = "esp32")] { - let timg1 = TimerGroup::new(peripherals.TIMG1); - esp_hal_embassy::init(timg1.timer0); - } else { - use esp_hal::timer::systimer::SystemTimer; - let systimer = SystemTimer::new(peripherals.SYSTIMER); - esp_hal_embassy::init(systimer.alarm0); - } - } + let systimer = SystemTimer::new(peripherals.SYSTIMER); + esp_hal_embassy::init(systimer.alarm0); let config = embassy_net::Config::dhcpv4(Default::default()); @@ -157,7 +139,11 @@ async fn main(spawner: Spawner) -> ! { spawner.spawn(connection(controller)).ok(); spawner.spawn(net_task(runner)).ok(); - spawner.spawn(led_ctrl_core_task(sclk, miso, mosi, cs, peripherals.SPI2)).ok(); + + //let spawner = executor.start(Priority::Priority3); + //spawner.must_spawn(led_ctrl_core_task(sclk, miso, mosi, cs, peripherals.SPI2)); + + spawner.spawn(led_ctrl_core_task(sclk, miso, mosi, cs, peripherals.SPI2, led_array_signal)).ok(); let mut rx_buffer = [0; 4096]; let mut tx_buffer = [0; 4096]; @@ -178,60 +164,78 @@ async fn main(spawner: Spawner) -> ! { Timer::after(Duration::from_millis(500)).await; } + // Then we can use it! + let mut rx_buffer = [0; 312]; + let mut tx_buffer = [0; 312]; + let mut rx_meta = [PacketMetadata::EMPTY; 16]; + let mut tx_meta = [PacketMetadata::EMPTY; 16]; + let mut buf = [0; 312]; + let mut socket = UdpSocket::new( + stack, + &mut rx_meta, + &mut rx_buffer, + &mut tx_meta, + &mut tx_buffer, + ); + + let mut cur_message_count: u32 = 0; + + socket.bind(1234).unwrap(); + let mut err_count: i32 = 0; + loop { - Timer::after(Duration::from_millis(1_000)).await; + println!("Start loop"); + match socket.recv_from(&mut buf).await { + Ok((n, ep)) => { + println!("Start cat"); - let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer); + match bincode::decode_from_slice::( + &buf, + bincode::config::standard(), + ) { + Ok(decoded) => { + //println!("Decoded cat correctly {:?}", decoded); - socket.set_timeout(Some(embassy_time::Duration::from_secs(10))); + let ledcontainer = decoded.0; + //if ledcontainer.message_count > cur_message_count { + println!("updating cat"); - let remote_endpoint = (Ipv4Addr::new(142, 250, 185, 115), 80); - println!("connecting..."); - let r = socket.connect(remote_endpoint).await; - if let Err(e) = r { - println!("connect error: {:?}", e); - continue; - } - println!("connected!"); - let mut buf = [0; 1024]; - loop { - use embedded_io_async::Write; - let r = socket - .write_all(b"GET / HTTP/1.0\r\nHost: www.mobile-j.de\r\n\r\n") - .await; - if let Err(e) = r { - println!("write error: {:?}", e); - break; + //ledcontainer.ledstrip.to_array(); + led_array_signal.signal(ledcontainer.ledstrip.to_array()); + //cur_message_count = ledcontainer.message_count; + //} + + println!("[RECEIVED] Got message!"); + } + Err(_e) => { + println!("DOG ERROR"); + } + } } - let n = match socket.read(&mut buf).await { - Ok(0) => { - println!("read EOF"); + Err(_) => { + err_count += 1; + println!("[RECEIVER] Could not get message with error: {:?}", buf); + + // if we receive 10 error messages in a row with errors, we reconnect to wifi and restart all! + if err_count > 10 { break; } - Ok(n) => n, - Err(e) => { - println!("read error: {:?}", e); - break; - } - }; - println!("{}", core::str::from_utf8(&buf[..n]).unwrap()); + } } - Timer::after(Duration::from_millis(3000)).await; + Timer::after(Duration::from_millis(30)).await; } + loop { + println!("Infinite loop"); + } } // highest priority task #[embassy_executor::task] -async fn led_ctrl_core_task(sclk: Output<'static>, miso: Output<'static>, mosi: Output<'static>, cs: Output<'static>, spi2: esp_hal::peripherals::SPI2) { +async fn led_ctrl_core_task(sclk: Output<'static>, miso: Output<'static>, mosi: Output<'static>, cs: Output<'static>, + spi2: esp_hal::peripherals::SPI2, led_array_signal: &'static Signal,) { esp_println::println!("Hello world from embassy using esp-hal-async!"); - // Spi configuration for the neopixel - // let mut spi_config = Config::default(); - // spi_config.frequency = 3_800_000; - - //let peripherals = esp_hal::init(esp_hal::Config::default()); - let mut spi = Spi::new( spi2, Config::default() @@ -248,40 +252,31 @@ async fn led_ctrl_core_task(sclk: Output<'static>, miso: Output<'static>, mosi: let mut np: Ws2812<_, { 12 * NUM_LEDS }> = Ws2812::new(spi); np.set_color_order(ColorOrder::GRB); - let mut data = [RGB8::default(); NUM_LEDS]; + //let mut data = [RGB8::default(); NUM_LEDS]; + + // for led in data.iter_mut().step_by(1) { + // led.r = 0; // blue + // led.g = 0; // red + // led.b = 100; // green + // } + + //np.write(data.iter().cloned()).await.ok(); loop { - println!("Writing led!"); - for led in data.iter_mut().step_by(1) { - led.r = 0; // blue - led.g = 0; // red - led.b = 20; // green - } - - np.write(data.iter().cloned()).await.ok(); - - Timer::after(embassy_time::Duration::from_millis(5)).await; + println!("Waiting to write led"); - for led in data.iter_mut().step_by(1) { - led.r = 20; // blue - led.g = 0; // red - led.b = 0; // green + // unsafe { + // np.write(data.iter().cloned()).await.ok(); + // } + + //let mut data = [RGB8::new(0, 0, 0); NUM_LEDS]; + + while let data = led_array_signal.wait().await { + np.write(data.iter().cloned()); + println!("LED written!") } - np.write(data.iter().cloned()).await.ok(); - - Timer::after(embassy_time::Duration::from_millis(5)).await; - - for led in data.iter_mut().step_by(1) { - led.r = 0; // blue - led.g = 20; // red - led.b = 0; // green - } - - np.write(data.iter().cloned()).await.ok(); - - Timer::after(embassy_time::Duration::from_millis(5)).await; - + Timer::after(embassy_time::Duration::from_millis(50)).await; } } @@ -345,10 +340,13 @@ impl LedStrip { LedStrip { leds: arr } } - pub fn to_array(&self) { + + pub fn to_array(&self) -> [RGB8; NUM_LEDS]{ + let mut data = [RGB8::new(0, 0, 0); NUM_LEDS]; for i in 0..NUM_LEDS { - unsafe { RGBARRAY[i] = RGB8::new(self.leds[i].g, self.leds[i].r, self.leds[i].b) } + data[i] = RGB8::new(self.leds[i].g, self.leds[i].r, self.leds[i].b) } + data } }