wip

Author: dok-net

cores/esp8266/Schedule.cpp

@@ -47,6 +47,7 @@ struct recurrent_fn_t
 
 static recurrent_fn_t* rFirst = nullptr;
 static recurrent_fn_t* rLast = nullptr;
+static uint32_t rScheduleTarget = 0;
 
 // Returns a pointer to an unused sched_fn_t,
 // or if none are available allocates a new one,
@@ -117,6 +118,10 @@ bool schedule_recurrent_function_us(const std::function<bool(void)>& fn,
 
     item->mFunc = fn;
     item->alarm = alarm;
+//    if (!rScheduleTarget || rScheduleTarget > item.callNow.remaining())
+//    {
+//        rScheduleTarget = item.callNow.remaining();
+//    }
 
     esp8266::InterruptLock lockAllInterruptsInThisScope;
 
@@ -133,6 +138,11 @@ bool schedule_recurrent_function_us(const std::function<bool(void)>& fn,
     return true;
 }
 
+uint32_t compute_scheduled_recurrent_grain()
+{
+    return 0;
+}
+
 void run_scheduled_functions()
 {
     // prevent scheduling of new functions during this run

cores/esp8266/Schedule.h

@@ -39,6 +39,11 @@
 // scheduled function happen more often: every yield() (vs every loop()),
 // and time resolution is microsecond (vs millisecond). Details are below.
 
+// compute_scheduled_recurrent_grain() is used by delay() to give a chance to
+// all recurrent functions to run per their timing requirement.
+
+uint32_t compute_scheduled_recurrent_grain ();
+
 // scheduled functions called once:
 //
 // * internal queue is FIFO.

cores/esp8266/core_esp8266_main.cpp

@@ -171,8 +171,16 @@ bool esp_try_delay(const uint32_t start_ms, const uint32_t timeout_ms, const uin
     if (expired >= timeout_ms) {
         return true; // expired
     }
-    esp_delay(std::min((timeout_ms - expired), intvl_ms));
-    return false;
+
+    // compute greatest delay interval with respect to scheduled recurrent functions
+    uint32_t grain_ms = std::min(intvl_ms, compute_scheduled_recurrent_grain());
+
+    // recurrent scheduled functions will be called from esp_delay()->esp_suspend()
+    esp_delay(grain_ms > 0 ?
+        std::min((timeout_ms - expired), grain_ms) :
+        (timeout_ms - expired));
+
+    return false; // expiration must be checked again
 }
 
 extern "C" void __yield() {