Use function template syntax to save using std::function objects.

Author: dok-net

cores/esp8266/core_esp8266_main.cpp

@@ -162,13 +162,15 @@ extern "C" void __esp_delay(unsigned long ms) {
 
 extern "C" void esp_delay(unsigned long ms) __attribute__((weak, alias("__esp_delay")));
 
-void esp_delay(const uint32_t timeout_ms, const IsBlockedCB& blocked, const uint32_t intvl_ms) {
-    const auto start = millis();
+bool try_esp_delay(const uint32_t start_ms, const uint32_t timeout_ms, const uint32_t intvl_ms) {
     decltype(millis()) expired;
-    while ((expired = millis() - start) < timeout_ms && blocked()) {
-        auto remaining = timeout_ms - expired;
-        esp_delay(remaining <= intvl_ms ? remaining : intvl_ms);
+
+    if ((expired = millis() - start_ms) >= timeout_ms) {
+        return true;
     }
+    const auto remaining = timeout_ms - expired;
+    esp_delay(remaining <= intvl_ms ? remaining : intvl_ms);
+    return false;
 }
 
 extern "C" void __yield() {

cores/esp8266/coredecls.h

@@ -4,6 +4,8 @@
 
 #define HAVE_ESP_SUSPEND 1
 
+#include "core_esp8266_features.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -40,27 +42,34 @@ void settimeofday_cb (BoolCB&& cb);
 void settimeofday_cb (const BoolCB& cb);
 void settimeofday_cb (const TrivialCB& cb);
 
-using IsBlockedCB = std::function<bool()>;
-
 // This overload of esp_suspend() performs the blocked callback whenever it is resumed,
 // and if that returns true, it immediately suspends again.
-inline void esp_suspend(const IsBlockedCB& blocked) {
+template <typename T>
+inline void esp_suspend(T&& blocked) {
     do {
         esp_suspend();
     } while (blocked());
 }
 
+bool try_esp_delay(const uint32_t start_ms, const uint32_t timeout_ms, const uint32_t intvl_ms);
+
 // This overload of esp_delay() delays for a duration of at most timeout_ms milliseconds.
 // Whenever it is resumed, as well as every intvl_ms millisconds, it performs
 // the blocked callback, and if that returns true, it keeps delaying for the remainder
 // of the original timeout_ms period.
-void esp_delay(const uint32_t timeout_ms, const IsBlockedCB& blocked, const uint32_t intvl_ms);
+template <typename T>
+inline void esp_delay(const uint32_t timeout_ms, T&& blocked, const uint32_t intvl_ms) {
+    const auto start_ms = millis();
+    while (!try_esp_delay(start_ms, timeout_ms, intvl_ms) && blocked()) {
+    }
+}
 
 // This overload of esp_delay() delays for a duration of at most timeout_ms milliseconds.
 // Whenever it is resumed, it performs the blocked callback, and if that returns true,
 // it keeps delaying for the remainder of the original timeout_ms period.
-inline void esp_delay(const uint32_t timeout_ms, const IsBlockedCB& blocked) {
-    esp_delay(timeout_ms, blocked, timeout_ms);
+template <typename T>
+inline void esp_delay(const uint32_t timeout_ms, T&& blocked) {
+    esp_delay(timeout_ms, std::forward<T>(blocked), timeout_ms);
 }
 
 #endif // __cplusplus

tests/host/common/Arduino.cpp

@@ -71,13 +71,15 @@ extern "C" void esp_delay (unsigned long ms)
     usleep(ms * 1000);
 }
 
-using IsBlockedCB = std::function<bool()>;
-
-void esp_delay(const uint32_t timeout_ms, const IsBlockedCB& blocked, const uint32_t intvl_ms)
-{
-    (void)blocked;
-    (void)intvl_ms;
-    usleep(timeout_ms * 1000);
+bool try_esp_delay(const uint32_t start_ms, const uint32_t timeout_ms, const uint32_t intvl_ms) {
+    decltype(millis()) expired;
+
+    if ((expired = millis() - start_ms) >= timeout_ms) {
+        return true;
+    }
+    const auto remaining = timeout_ms - expired;
+    esp_delay(remaining <= intvl_ms ? remaining : intvl_ms);
+    return false;
 }
 
 extern "C" void __panic_func(const char* file, int line, const char* func) {