Finalize scheduled recurrent function delay logic.

Author: dok-net

cores/esp8266/Schedule.cpp

@@ -47,7 +47,7 @@ struct recurrent_fn_t
 
 static recurrent_fn_t* rFirst = nullptr;
 static recurrent_fn_t* rLast = nullptr;
-static uint32_t rScheduleTarget = 0;
+static uint32_t rTarget;
 
 // Returns a pointer to an unused sched_fn_t,
 // or if none are available allocates a new one,
@@ -118,10 +118,13 @@ 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();
-//    }
+
+    // prevent new item overwriting an already expired rTarget.
+    const int32_t rRemaining = rTarget - millis();
+    if (!rFirst || (rRemaining > 0 && static_cast<uint32_t>(rRemaining) > item->callNow.remaining()))
+    {
+        rTarget = millis() + item->callNow.remaining();
+    }
 
     esp8266::InterruptLock lockAllInterruptsInThisScope;
 
@@ -138,9 +141,12 @@ bool schedule_recurrent_function_us(const std::function<bool(void)>& fn,
     return true;
 }
 
-uint32_t compute_scheduled_recurrent_grain()
+uint32_t get_scheduled_recurrent_delay()
 {
-    return 0;
+    if (!rFirst) return ~static_cast<uint32_t>(0);
+    // handle already expired rTarget.
+    const int32_t rRemaining = rTarget - millis();
+    return (rRemaining > 0) ? static_cast<uint32_t>(rRemaining) : 0;
 }
 
 void run_scheduled_functions()
@@ -203,6 +209,7 @@ void run_scheduled_recurrent_functions()
         fence = true;
     }
 
+    rTarget = millis() + current->callNow.remaining();
     recurrent_fn_t* prev = nullptr;
     // prevent scheduling of new functions during this run
     auto stop = rLast;
@@ -241,6 +248,12 @@ void run_scheduled_recurrent_functions()
         {
             prev = current;
             current = current->mNext;
+            // prevent current item overwriting an already expired rTarget.
+            const int32_t rRemaining = rTarget - millis();
+            if (rRemaining > 0 && static_cast<uint32_t>(rRemaining) > current->callNow.remaining())
+            {
+                rTarget = millis() + current->callNow.remaining();
+            }
         }
 
         if (yieldNow)

cores/esp8266/Schedule.h

@@ -39,10 +39,10 @@
 // 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
+// get_scheduled_recurrent_delay() is used by delay() to give a chance to
 // all recurrent functions to run per their timing requirement.
 
-uint32_t compute_scheduled_recurrent_grain ();
+uint32_t get_scheduled_recurrent_delay();
 
 // scheduled functions called once:
 //

cores/esp8266/core_esp8266_main.cpp

@@ -173,12 +173,10 @@ bool esp_try_delay(const uint32_t start_ms, const uint32_t timeout_ms, const uin
     }
 
     // compute greatest delay interval with respect to scheduled recurrent functions
-    uint32_t grain_ms = std::min(intvl_ms, compute_scheduled_recurrent_grain());
+    const uint32_t max_delay_ms = std::min(intvl_ms, get_scheduled_recurrent_delay());
 
     // 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));
+    esp_delay(std::min((timeout_ms - expired), max_delay_ms));
 
     return false; // expiration must be checked again
 }