explore: esp-now communication

Author: filipton

Cargo.lock

@@ -40,7 +40,7 @@ dyn-smooth = "0.2.0"
 esp-hal-ota = { version = "0.4.0", features = [] }
 esp32c3 = { version = "0.28.0", optional = true }
 esp32 = { version = "0.36.0", optional = true }
-anyhow = { version = "1.0.97", default-features = false }
+anyhow = { version = "1.0.98", default-features = false }
 embedded-hal-bus = { version = "0.3.0", features = ["async"] }
 embedded-tls = { version = "0.17.0", default-features = false, features = ["alloc", "embedded-io-adapters", "log"] }
 rand_core = { version = "0.6.4", features = ["getrandom"] }
@@ -54,6 +54,7 @@ mfrc522-02 = { version = "0.2.1", features = ["embassy-time"], package = "esp-ha
 default = ["esp32c3", "sleep"]
 esp32 = ["esp-backtrace/esp32", "esp-hal/esp32", "esp-println/esp32", "esp-wifi/esp32", "esp-hal-embassy/esp32", "esp-storage/esp32", "esp-hal-wifimanager/esp32", "esp-hal-ota/esp32", "dep:esp32", "dep:mfrc522-01", "dep:port-expander", "ag-lcd-async/i2c"]
 esp32c3 = ["esp-backtrace/esp32c3", "esp-hal/esp32c3", "esp-println/esp32c3", "esp-wifi/esp32c3", "esp-hal-embassy/esp32c3", "esp-storage/esp32c3", "esp-hal-wifimanager/esp32c3", "esp-hal-ota/esp32c3", "dep:esp32c3", "dep:mfrc522-02"]
+esp_now = ["esp-wifi/esp-now"]
 gen_version = []
 bat_dev_lcd = []
 release_build = ["sleep"]

Cargo.toml

@@ -14,6 +14,7 @@ use embassy_time::{Instant, Timer};
 use esp_backtrace as _;
 use esp_hal_wifimanager::{Nvs, WIFI_NVS_KEY};
 use esp_storage::FlashStorage;
+use esp_wifi::esp_now::{EspNowManager, EspNowSender};
 use state::{ota_state, sleep_state, GlobalState, GlobalStateInner, SavedGlobalState, Scene};
 use structs::ConnSettings;
 use utils::{logger::FkmLogger, set_brownout_detection};
@@ -52,6 +53,16 @@ pub fn custom_rng(buf: &mut [u8]) -> Result<(), getrandom::Error> {
 }
 getrandom::register_custom_getrandom!(custom_rng);
 
+const ESP_NOW_DST: &[u8; 6] = &[156, 158, 110, 52, 70, 200];
+macro_rules! mk_static {
+    ($t:ty,$val:expr) => {{
+        static STATIC_CELL: static_cell::StaticCell<$t> = static_cell::StaticCell::new();
+        #[deny(unused_attributes)]
+        let x = STATIC_CELL.uninit().write(($val));
+        x
+    }};
+}
+
 #[esp_hal_embassy::main]
 async fn main(spawner: Spawner) {
     let peripherals = esp_hal::init({
@@ -176,101 +187,142 @@ async fn main(spawner: Spawner) {
         }
     }
 
-    let wifi_res = esp_hal_wifimanager::init_wm(
-        wm_settings,
-        &spawner,
-        #[cfg(feature = "qa")]
-        None,
-        #[cfg(not(feature = "qa"))]
-        Some(&nvs),
-        board.rng,
-        board.timg0.timer0,
-        board.radio_clk,
-        board.wifi,
-        board.bt,
-        Some(wifi_setup_sig),
-    )
-    .await;
-
-    let Ok(mut wifi_res) = wifi_res else {
-        log::error!("WifiManager failed!!! Restarting in 1s!");
-        Timer::after_millis(1000).await;
-        esp_hal::system::software_reset();
-    };
+    #[cfg(feature = "esp_now")]
+    {
+        let init = &*mk_static!(
+            esp_wifi::EspWifiController<'static>,
+            esp_wifi::init(board.timg0.timer0, board.rng.clone(), board.radio_clk).unwrap()
+        );
+
+        let (manager, tx, mut rx) = esp_wifi::esp_now::EspNow::new(&init, board.wifi)
+            .unwrap()
+            .split();
+
+        _ = manager.set_power_saving(esp_wifi::config::PowerSaveMode::None);
+        //_ = manager.set_rate(esp_wifi::esp_now::WifiPhyRate::RateMax);
+        _ = manager.set_pmk(&[69, 4, 2, 0, 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+
+        spawner.must_spawn(bc_test_task(tx, manager));
+        let mut last_counter = 0;
+        loop {
+            let recv = rx.receive_async().await;
+            log::info!("ESP_NOW frame recv: {:?}", recv.info);
+            log::info!("{:?}", recv.data());
+
+            if &recv.info.dst_address == ESP_NOW_DST {
+                if recv.data().len() == 16 {
+                    let counter = u128::from_be_bytes(recv.data().try_into().unwrap());
+                    if counter - last_counter == 0 {
+                        log::warn!("First packet?");
+                    } else if counter - last_counter > 1 {
+                        log::error!("PACKET LOST!");
+                    }
+
+                    last_counter = counter;
+                }
+            }
+        }
+    }
 
-    #[cfg(feature = "qa")]
-    crate::qa::send_qa_resp(crate::qa::QaSignal::WifiSetup);
-
-    let conn_settings: ConnSettings = wifi_res
-        .data
-        .take()
-        .and_then(|d| serde_json::from_value(d).ok())
-        .unwrap_or_default();
-
-    let mut parse_retry_count = 0;
-    let ws_url = loop {
-        let url = if conn_settings.mdns || conn_settings.ws_url.is_none() || parse_retry_count > 0 {
-            log::info!("Starting mdns lookup...");
-            global_state.state.lock().await.scene = Scene::MdnsWait;
-            let mdns_res = mdns::mdns_query(wifi_res.sta_stack).await;
-            log::info!("Mdns result: {:?}", mdns_res);
-
-            mdns_res.to_string()
-        } else {
-            conn_settings.ws_url.clone().expect("")
+    #[cfg(not(feature = "esp_now"))]
+    {
+        let wifi_res = esp_hal_wifimanager::init_wm(
+            wm_settings,
+            &spawner,
+            #[cfg(feature = "qa")]
+            None,
+            #[cfg(not(feature = "qa"))]
+            Some(&nvs),
+            board.rng,
+            board.timg0.timer0,
+            board.radio_clk,
+            board.wifi,
+            board.bt,
+            Some(wifi_setup_sig),
+        )
+        .await;
+
+        let Ok(mut wifi_res) = wifi_res else {
+            log::error!("WifiManager failed!!! Restarting in 1s!");
+            Timer::after_millis(1000).await;
+            esp_hal::system::software_reset();
         };
 
-        let ws_url = WsUrl::from_str(&url);
-        match ws_url {
-            Some(ws_url) => break WsUrlOwned::new(&ws_url),
-            None => {
-                parse_retry_count += 1;
-                log::error!("Mdns parse failed! Retry ({parse_retry_count})..");
-                Timer::after_millis(1000).await;
-                if parse_retry_count > 3 {
-                    log::error!("Cannot parse wsurl! Reseting wifi configuration!");
-                    _ = nvs.invalidate_key(WIFI_NVS_KEY).await;
+        #[cfg(feature = "qa")]
+        crate::qa::send_qa_resp(crate::qa::QaSignal::WifiSetup);
+
+        let conn_settings: ConnSettings = wifi_res
+            .data
+            .take()
+            .and_then(|d| serde_json::from_value(d).ok())
+            .unwrap_or_default();
+
+        let mut parse_retry_count = 0;
+        let ws_url = loop {
+            let url =
+                if conn_settings.mdns || conn_settings.ws_url.is_none() || parse_retry_count > 0 {
+                    log::info!("Starting mdns lookup...");
+                    global_state.state.lock().await.scene = Scene::MdnsWait;
+                    let mdns_res = mdns::mdns_query(wifi_res.sta_stack).await;
+                    log::info!("Mdns result: {:?}", mdns_res);
+
+                    mdns_res.to_string()
+                } else {
+                    conn_settings.ws_url.clone().expect("")
+                };
+
+            let ws_url = WsUrl::from_str(&url);
+            match ws_url {
+                Some(ws_url) => break WsUrlOwned::new(&ws_url),
+                None => {
+                    parse_retry_count += 1;
+                    log::error!("Mdns parse failed! Retry ({parse_retry_count})..");
                     Timer::after_millis(1000).await;
+                    if parse_retry_count > 3 {
+                        log::error!("Cannot parse wsurl! Reseting wifi configuration!");
+                        _ = nvs.invalidate_key(WIFI_NVS_KEY).await;
+                        Timer::after_millis(1000).await;
 
-                    esp_hal::system::software_reset();
-                }
+                        esp_hal::system::software_reset();
+                    }
 
-                continue;
+                    continue;
+                }
             }
-        }
-    };
+        };
 
-    utils::backtrace_store::read_saved_backtrace().await;
+        utils::backtrace_store::read_saved_backtrace().await;
+
+        let ws_sleep_sig = Rc::new(Signal::new());
+        spawner.must_spawn(ws::ws_task(
+            wifi_res.sta_stack,
+            ws_url,
+            global_state.clone(),
+            ws_sleep_sig.clone(),
+        ));
+        spawner.must_spawn(logger_task(global_state.clone()));
+
+        set_brownout_detection(true);
+        global_state.state.lock().await.scene = Scene::WaitingForCompetitor;
+        if let Some(saved_state) = SavedGlobalState::from_nvs(&nvs).await {
+            global_state
+                .state
+                .lock()
+                .await
+                .parse_saved_state(saved_state);
+        }
 
-    let ws_sleep_sig = Rc::new(Signal::new());
-    spawner.must_spawn(ws::ws_task(
-        wifi_res.sta_stack,
-        ws_url,
-        global_state.clone(),
-        ws_sleep_sig.clone(),
-    ));
-    spawner.must_spawn(logger_task(global_state.clone()));
-
-    set_brownout_detection(true);
-    global_state.state.lock().await.scene = Scene::WaitingForCompetitor;
-    if let Some(saved_state) = SavedGlobalState::from_nvs(&nvs).await {
-        global_state
-            .state
-            .lock()
-            .await
-            .parse_saved_state(saved_state);
-    }
+        let mut last_sleep = false;
+        loop {
+            Timer::after_millis(100).await;
+            if sleep_state() != last_sleep {
+                last_sleep = sleep_state();
+                ws_sleep_sig.signal(last_sleep);
 
-    let mut last_sleep = false;
-    loop {
-        Timer::after_millis(100).await;
-        if sleep_state() != last_sleep {
-            last_sleep = sleep_state();
-            ws_sleep_sig.signal(last_sleep);
-
-            match last_sleep {
-                true => wifi_res.stop_radio(),
-                false => wifi_res.restart_radio(),
+                match last_sleep {
+                    true => wifi_res.stop_radio(),
+                    false => wifi_res.restart_radio(),
+                }
             }
         }
     }
@@ -313,3 +365,25 @@ async fn logger_task(global_state: GlobalState) {
         }
     }
 }
+
+#[cfg(feature = "esp_now")]
+#[embassy_executor::task]
+async fn bc_test_task(mut tx: EspNowSender<'static>, manager: EspNowManager<'static>) {
+    let mut counter = 0u128;
+    loop {
+        manager
+            .add_peer(esp_wifi::esp_now::PeerInfo {
+                peer_address: *ESP_NOW_DST,
+                lmk: None,
+                channel: None,
+                encrypt: false,
+            })
+            .unwrap();
+
+        let r = tx.send_async(ESP_NOW_DST, &counter.to_be_bytes()).await;
+        manager.remove_peer(ESP_NOW_DST).unwrap();
+
+        counter += 1;
+        Timer::after_millis(1000).await;
+    }
+}