wip

cores/esp8266/Schedule.cpp

@@ -35,6 +35,8 @@ static scheduled_fn_t* sLast = nullptr;
 static scheduled_fn_t* sUnused = nullptr;
 static int sCount = 0;
 
+uint32_t recurrent_max_grain_mS = 0;
+
 typedef std::function<bool(void)> mRecFuncT;
 struct recurrent_fn_t
 {
@@ -130,9 +132,31 @@ bool schedule_recurrent_function_us(const std::function<bool(void)>& fn,
     }
     rLast = item;
 
+    // grain needs to be recomputed
+    recurrent_max_grain_mS = 0;
+
     return true;
 }
 
+void update_recurrent_grain ()
+{
+    if (recurrent_max_grain_mS == 0)
+    {
+        if (rFirst)
+        {
+            uint32_t recurrent_max_grain_uS = rFirst->callNow.getTimeout();
+            for (auto it = rFirst->mNext; it; it = it->mNext)
+                recurrent_max_grain_uS = compute_gcd(recurrent_max_grain_uS, it->callNow.getTimeout());
+            if (recurrent_max_grain_uS)
+                // round to the upper millis
+                recurrent_max_grain_mS = recurrent_max_grain_uS <= 1000? 1: (recurrent_max_grain_uS + 999) / 1000;
+        }
+        if (recurrent_max_grain_mS == 0)
+            // no recurrent function, set grain to max
+            recurrent_max_grain_mS = std::numeric_limits<decltype(recurrent_max_grain_mS)>::max();
+    }
+}
+
 void run_scheduled_functions()
 {
     // prevent scheduling of new functions during this run
@@ -226,6 +250,9 @@ void run_scheduled_recurrent_functions()
             }
 
             delete(to_ditch);
+
+            // grain needs to be recomputed
+            recurrent_max_grain_mS = 0;
         }
         else
         {

cores/esp8266/Schedule.h

@@ -39,6 +39,13 @@
 // scheduled function happen more often: every yield() (vs every loop()),
 // and time resolution is microsecond (vs millisecond). Details are below.
 
+// recurrent_max_grain_mS is used by delay() to let a chance to all
+// recurrent functions to accomplish their duty per their timing
+// requirement.
+// When it is 0, update_recurrent_grain() can be called to recalculate it
+extern uint32_t recurrent_max_grain_mS;
+void update_recurrent_grain ();
+
 // scheduled functions called once:
 //
 // * internal queue is FIFO.

cores/esp8266/core_esp8266_wiring.cpp

@@ -34,7 +34,17 @@ static uint32_t micros_overflow_count = 0;
 #define REPEAT 1
 
 void __delay(unsigned long ms) {
-    esp_delay(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));
 }
 
 void delay(unsigned long ms) __attribute__ ((weak, alias("__delay"))); 

cores/esp8266/coredecls.h

@@ -1,6 +1,5 @@
 
-#ifndef __COREDECLS_H
-#define __COREDECLS_H
+#pragma once
 
 #include "core_esp8266_features.h"
 
@@ -76,6 +75,16 @@ inline void esp_delay(const uint32_t timeout_ms, T&& blocked) {
     esp_delay(timeout_ms, std::forward<T>(blocked), timeout_ms);
 }
 
-#endif // __cplusplus
+template <typename T>
+auto compute_gcd (T a, T b)
+{
+    while (b)
+    {
+        auto t = b;
+        b = a % b;
+        a = t;
+    }
+    return a;
+}
 
-#endif // __COREDECLS_H
+#endif // __cplusplus