feat: waiter and some small wrappers

src/lib.rs

@@ -25,6 +25,7 @@ pub mod httpd;
 #[cfg(feature = "alloc")]
 // TODO: Ideally should not need "alloc" (also for performance reasons)
 pub mod log;
+pub mod misc;
 #[cfg(esp_idf_config_lwip_ipv4_napt)]
 pub mod napt;
 pub mod netif;
@@ -43,6 +44,7 @@ pub mod nvs_storage;
 pub mod ota;
 pub mod ping;
 pub mod sysloop;
+pub mod time;
 #[cfg(feature = "alloc")] // TODO: Expose a subset which does not require "alloc"
 pub mod wifi;
 

src/misc.rs

@@ -0,0 +1,11 @@
+use esp_idf_sys::*;
+
+pub fn get_default_efuse_mac() -> Result<[u8; 6], EspError> {
+    let mut mac = [0; 6];
+    unsafe { esp!(esp_efuse_mac_get_default(mac.as_mut_ptr()))? }
+    Ok(mac)
+}
+
+pub fn restart() {
+    unsafe { esp_restart() };
+}

src/private/cstr.rs

@@ -12,6 +12,7 @@ extern crate alloc;
 
 #[cfg(feature = "alloc")]
 pub fn set_str(buf: &mut [u8], s: &str) {
+    assert!(s.len() < buf.len());
     let cs = CString::new(s).unwrap();
     let ss: &[u8] = cs.as_bytes_with_nul();
     buf[..ss.len()].copy_from_slice(ss);

src/private/mod.rs

@@ -1,6 +1,7 @@
 pub mod common;
 pub mod cstr;
 pub mod net;
+pub mod wait;
 
 mod stubs;
 

src/private/wait.rs

@@ -0,0 +1,97 @@
+use core::time::Duration;
+#[cfg(feature = "std")]
+use std::sync::{Condvar, Mutex};
+
+use embedded_svc::mutex::Mutex as _;
+#[cfg(not(feature = "std"))]
+use esp_idf_sys::*;
+
+#[cfg(not(feature = "std"))]
+use super::time::micros_since_boot;
+
+pub struct Waiter {
+    #[cfg(feature = "std")]
+    cvar: Condvar,
+    #[cfg(feature = "std")]
+    running: Mutex<bool>,
+    #[cfg(not(feature = "std"))]
+    running: EspMutex<bool>,
+}
+
+impl Waiter {
+    pub fn new() -> Self {
+        Waiter {
+            #[cfg(feature = "std")]
+            cvar: Condvar::new(),
+            #[cfg(feature = "std")]
+            running: Mutex::new(false),
+            #[cfg(not(feature = "std"))]
+            running: EspMutex::new(false),
+        }
+    }
+
+    pub fn start(&self) {
+        self.running.with_lock(|running| *running = true);
+    }
+
+    #[cfg(feature = "std")]
+    pub fn wait(&self) {
+        if !self.running.with_lock(|running| *running) {
+            return;
+        }
+
+        let _running = self
+            .cvar
+            .wait_while(self.running.lock().unwrap(), |running| *running)
+            .unwrap();
+    }
+
+    #[cfg(not(feature = "std"))]
+    pub fn wait(&self) {
+        while self.running.with_lock(|running| *running) {
+            unsafe { vTaskDelay(500) };
+        }
+    }
+
+    /// return = !timeout (= success)
+    #[cfg(feature = "std")]
+    pub fn wait_timeout(&self, dur: Duration) -> bool {
+        if !self.running.with_lock(|running| *running) {
+            return true;
+        }
+
+        let (_running, res) = self
+            .cvar
+            .wait_timeout_while(self.running.lock().unwrap(), dur, |running| *running)
+            .unwrap();
+
+        return !res.timed_out();
+    }
+
+    /// return = !timeout (= success)
+    #[cfg(not(feature = "std"))]
+    pub fn wait_timeout(&self, dur: Duration) {
+        let now = micros_since_boot();
+        let end = now + dur.as_micros();
+
+        while self.running.with_lock(|running| *running) {
+            if micros_since_boot() > end {
+                return false;
+            }
+            unsafe { vTaskDelay(500) };
+        }
+
+        return true;
+    }
+
+    #[cfg(feature = "std")]
+    pub fn notify(&self) {
+        *self.running.lock().unwrap() = false;
+        self.cvar.notify_all();
+    }
+
+    #[cfg(not(feature = "std"))]
+    pub fn notify(&self) {
+        self.running.with_lock(|running| *running = false);
+    }
+}

src/time.rs

@@ -0,0 +1,7 @@
+use core::convert::TryInto;
+
+use esp_idf_sys::*;
+
+pub fn micros_since_boot() -> u64 {
+    unsafe { esp_timer_get_time() }.try_into().unwrap()
+}