Initial

Cargo.toml

@@ -0,0 +1,46 @@
+[package]
+name    = "esp-now-slave"
+version = "0.0.2"
+edition = "2024"
+publish = false
+
+[dependencies]
+embassy-executor = "0.10.0"
+embassy-sync = "0.8"
+embassy-time = "0.5.0"
+esp-alloc = { path = "../../esp-alloc" }
+esp-backtrace = { path = "../../esp-backtrace", features = [
+    "panic-handler",
+    "println",
+] }
+esp-bootloader-esp-idf = { path = "../../esp-bootloader-esp-idf" }
+esp-hal = { path = "../../esp-hal", features = ["log-04", "unstable"] }
+esp-println = { path = "../../esp-println", features = ["log-04"] }
+esp-rtos = { path = "../../esp-rtos", features = ["esp-radio", "embassy", "log-04"] }
+esp-radio = { path = "../../esp-radio", features = [
+    "esp-now",
+    "log-04",
+    "unstable",
+    "wifi",
+] }
+static_cell = "2.1.0"
+
+embedded-dht-rs = { version = "0.5.0", features = ["dht22"] }
+
+[features]
+esp32 = [
+    "esp-backtrace/esp32",
+    "esp-bootloader-esp-idf/esp32",
+    "esp-hal/esp32",
+    "esp-rtos/esp32",
+    "esp-radio/esp32",
+]
+
+
+[profile.release]
+debug            = true
+debug-assertions = true
+lto              = "fat"
+codegen-units    = 1
+
+# cargo xtask run example esp_now_slave --chip=esp32

src/main.rs

@@ -0,0 +1,181 @@
+//! ESP-NOW Temperature Slave
+//!
+//! Asynchronously broadcasts, sends messages via esp-now in
+#![no_std]
+#![no_main]
+
+extern crate alloc;
+
+use alloc::string::ToString;
+
+use embassy_executor::Spawner;
+use embassy_sync::{blocking_mutex::raw::NoopRawMutex, mutex::Mutex};
+use embassy_time::{Duration, Ticker};
+use esp_backtrace as _;
+use esp_hal::{
+    clock::CpuClock,
+    delay::Delay,
+    gpio::{DriveMode, Flex, OutputConfig, Pull},
+    interrupt::software::SoftwareInterruptControl,
+    rtc_cntl::{Rtc, reset_reason, sleep::TimerWakeupSource, wakeup_cause},
+    system::Cpu,
+    timer::timg::TimerGroup,
+};
+use esp_println::println;
+
+// firebeetle
+pub const PEER_ADDRESS: [u8; 6] = [0xd4u8, 0x8cu8, 0x49u8, 0xc9u8, 0x13u8, 0x14u8];
+
+// elecrow 5.79
+// pub const PEER_ADDRESS: [u8; 6] = [0x48u8, 0xCAu8, 0x43u8, 0x99u8, 0x6Cu8, 0xACu8 ];
+
+pub const HOME: &str = "FRITZ!Box 7590 FP DK";
+
+pub const HOHENWALDECK: &str = "COSMOTE-C90C60";
+
+pub const KEFALOVRYSO: &str = "WLAN-732533";
+
+use embedded_dht_rs::dht22::Dht22;
+use esp_radio::{
+    esp_now::{EspNowManager, EspNowSender, PeerInfo},
+    wifi::scan::ScanConfig,
+};
+
+esp_bootloader_esp_idf::esp_app_desc!();
+
+// 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 {
+    ($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::main]
+async fn main(_spawner: Spawner) -> ! {
+    // let accessPoints = vec![ "FRITZ!Box 7590 FP DK","COSMOTE-C90C60", "WLAN-732533" ];
+
+    esp_println::logger::init_logger_from_env();
+    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
+    let peripherals = esp_hal::init(config);
+
+    // DHT22 sensor setup (GPIO26)
+    let mut dht22_pin = Flex::new(peripherals.GPIO26);
+    dht22_pin.apply_output_config(
+        &OutputConfig::default()
+            .with_drive_mode(DriveMode::OpenDrain)
+            .with_pull(Pull::None),
+    );
+    dht22_pin.set_output_enable(true);
+    dht22_pin.set_input_enable(true);
+    dht22_pin.set_high();
+    let mut dht22 = Dht22::new(dht22_pin, Delay::new());
+
+    esp_alloc::heap_allocator!(size: 72 * 1024);
+
+    let sw_int = SoftwareInterruptControl::new(peripherals.SW_INTERRUPT);
+    let timg0 = TimerGroup::new(peripherals.TIMG0);
+    esp_rtos::start(timg0.timer0, sw_int.software_interrupt0);
+
+    let controller: &mut esp_radio::wifi::WifiController<'static> = mk_static!(
+        esp_radio::wifi::WifiController<'static>,
+        esp_radio::wifi::new(peripherals.WIFI, Default::default()).unwrap()
+    );
+
+    let esp_now = controller.esp_now();
+    println!("esp-now version {}", esp_now.version().unwrap());
+    match controller.channel() {
+        Ok(channel_reading) => {
+            println!("Channel Router: {:?}", channel_reading);
+            esp_now.set_channel(channel_reading.0).unwrap();
+        }
+        Err(error) => {
+            esp_println::dbg!(
+                "An error occurred while trying to read channel: {:?}",
+                error
+            );
+        }
+    }
+
+    // println!("Scan");
+    // let scan_config = ScanConfig::default().with_max(10);
+    // let result = controller.scan_async(&scan_config).await.unwrap();
+    // for ap in result {
+    //     if ap.ssid.as_str() == HOME {
+    //         println!("{:?} {:?}", ap.ssid, ap.channel);
+    //     }
+    // }
+
+    
+
+    let (manager, sender, _receiver) = esp_now.split();
+    let manager = mk_static!(EspNowManager<'static>, manager);
+    let sender = mk_static!(
+        Mutex::<NoopRawMutex, EspNowSender<'static>>,
+        Mutex::<NoopRawMutex, _>::new(sender)
+    );
+
+    manager
+        .add_peer(PeerInfo {
+            interface: esp_radio::esp_now::EspNowWifiInterface::Station,
+            peer_address: PEER_ADDRESS,
+            lmk: None,
+            channel: None,
+            encrypt: false,
+        })
+        .unwrap();
+
+    let delay = Delay::new();
+    let mut rtc = Rtc::new(peripherals.LPWR);
+
+    let reason = reset_reason(Cpu::ProCpu);
+    let wake_reason = wakeup_cause();
+
+    println!("{:?} {:?}", reason, wake_reason);
+
+    let timer = TimerWakeupSource::new(core::time::Duration::from_secs(30));
+
+    let mut ticker = Ticker::every(Duration::from_millis(500));
+    loop {
+        ticker.next().await;
+
+        let mut temp: f32 = 0.0;
+
+        match dht22.read() {
+            Ok(sensor_reading) => {
+                esp_println::println!(
+                    "DHT 22 Sensor - Temperature: {} °C, humidity: {} %",
+                    sensor_reading.temperature,
+                    sensor_reading.humidity
+                );
+                temp = sensor_reading.temperature;
+            }
+            Err(error) => {
+                esp_println::dbg!("An error occurred while trying to read sensor: {:?}", error);
+            }
+        }
+
+        let peer = match manager.fetch_peer(false) {
+            Ok(peer) => peer,
+            Err(_) => {
+                if let Ok(peer) = manager.fetch_peer(true) {
+                    peer
+                } else {
+                    continue;
+                }
+            }
+        };
+
+        println!("Send temperature to peer {:?}", peer.peer_address);
+        let mut sender = sender.lock().await;
+        let status = sender
+            .send_async(&peer.peer_address, temp.to_string().as_bytes())
+            .await;
+        println!("Send status: {:?}", status);
+        println!("Going sleep: {:?} seconds", 30);
+        delay.delay_millis(100);
+        rtc.sleep_deep(&[&timer]);
+    }
+}