LED data gets transmitted using signal but not stable yet

esp-wifi/build.rs

@@ -164,7 +164,7 @@ fn main() -> Result<(), Box<dyn Error>> {
             (
                 "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
             ),
             (

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<Signal<CriticalSectionRawMutex, [RGB8; NUM_LEDS]>> = 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::<LedContainer, bincode::config::Configuration>(
+                    &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<CriticalSectionRawMutex, [RGB8; NUM_LEDS]>,) {
     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
     }
 }