wip

esp8266 · d-a-v · Jan 14, 2023 · Jan 10, 2023 · Jan 11, 2023 · Jan 13, 2023
commit 0effb78cdee6f9b517c70d90372816757d57b32c
diff --git a/cores/esp8266/core_esp8266_main.cpp b/cores/esp8266/core_esp8266_main.cpp
@@ -162,11 +162,22 @@ extern "C" void __esp_delay(unsigned long ms) {
 
 extern "C" void esp_delay(unsigned long ms) __attribute__((weak, alias("__esp_delay")));
 
-bool esp_try_delay(const uint32_t start_ms, const uint32_t timeout_ms, const uint32_t intvl_ms) {
+bool esp_try_delay(const uint32_t start_ms, const uint32_t timeout_ms, uint32_t intvl_ms) {
     uint32_t expired = millis() - start_ms;
     if (expired >= timeout_ms) {
         return true;
     }
+
+    if (intvl_ms == 0)
+    {
+        // run_recurrent_scheduled_functions() is called from esp_delay()->esp_suspend()
+        // intvl_ms is set according to recurrent schedule functions
+        // intervals based on their respective requirements
+        if (recurrent_max_grain_mS == 0)
+            update_recurrent_grain();
+        intvl_ms = recurrent_max_grain_mS;
+    }
+
     esp_delay(std::min((timeout_ms - expired), intvl_ms));
     return false;
 }

diff --git a/cores/esp8266/core_esp8266_wiring.cpp b/cores/esp8266/core_esp8266_wiring.cpp
@@ -34,17 +34,8 @@ static uint32_t micros_overflow_count = 0;
 #define REPEAT 1
 
 void __delay(unsigned long ms) {
-
-    // default "userland" delay() will call recurrent scheduled functions
-    // based on best effort according to their respective requirements
-
-    if (recurrent_max_grain_mS == 0)
-        update_recurrent_grain();
-    const auto start_ms = millis();
-    do
-    {
-        run_scheduled_recurrent_functions();
-    } while (!esp_try_delay(start_ms, ms, recurrent_max_grain_mS));
+    // use API letting recurrent scheduled functions run in background
+    esp_delay(ms, [](){ return true; });
 }
 
 void delay(unsigned long ms) __attribute__ ((weak, alias("__delay"))); 

diff --git a/cores/esp8266/coredecls.h b/cores/esp8266/coredecls.h
@@ -54,7 +54,8 @@ inline void esp_suspend(T&& blocked) {
 // Otherwise returns false after delaying for the relative
 // remainder of timeout_ms, or an absolute intvl_ms, whichever is shorter.
 // The delay may be asynchronously cancelled, before that timeout is reached.
-bool esp_try_delay(const uint32_t start_ms, const uint32_t timeout_ms, const uint32_t intvl_ms);
+// intvl_ms==0 will adapt to recurrent scheduled functions and run them accordingly
+bool esp_try_delay(const uint32_t start_ms, const uint32_t timeout_ms, 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
@@ -72,7 +73,7 @@ inline void esp_delay(const uint32_t timeout_ms, T&& blocked, const uint32_t int
 // it keeps delaying for the remainder of the original timeout_ms period.
 template <typename T>
 inline void esp_delay(const uint32_t timeout_ms, T&& blocked) {
-    esp_delay(timeout_ms, std::forward<T>(blocked), timeout_ms);
+    esp_delay(timeout_ms, std::forward<T>(blocked), 0);
 }
 
 template <typename T>

diff --git a/libraries/ESP8266WiFi/src/ESP8266WiFiGeneric.cpp b/libraries/ESP8266WiFi/src/ESP8266WiFiGeneric.cpp
@@ -646,7 +646,7 @@ static int hostByNameImpl(const char* aHostname, IPAddress& aResult, uint32_t ti
         esp_delay(timeout_ms,
             [&]() {
                 return !pending->done;
-            }, 10);
+            });
 
         if (pending->done) {
             if ((pending->addr).isSet()) {