add regular scheduled functions, now also callable on yield()

cores/esp8266/Esp.h

@@ -213,7 +213,8 @@ uint32_t EspClass::getCycleCount()
     __asm__ __volatile__("esync; rsr %0,ccount":"=a" (ccount));
     return ccount;
 }
-#endif
+
+#endif // !defined(CORE_MOCK)
 
 extern EspClass ESP;
 

cores/esp8266/FunctionalInterrupt.cpp

@@ -1,7 +1,6 @@
 #include <FunctionalInterrupt.h>
 #include <Schedule.h>
 #include "Arduino.h"
-#include <ScheduledFunctions.h>
 
 // Duplicate typedefs from core_esp8266_wiring_digital_c
 typedef void (*voidFuncPtr)(void);
@@ -17,7 +16,6 @@ void ICACHE_RAM_ATTR interruptFunctional(void* arg)
 	if (localArg->functionInfo->reqScheduledFunction)
 	{
 		schedule_function(std::bind(localArg->functionInfo->reqScheduledFunction,InterruptInfo(*(localArg->interruptInfo))));
-//      scheduledInterrupts->scheduleFunctionReg(std::bind(localArg->functionInfo->reqScheduledFunction,InterruptInfo(*(localArg->interruptInfo))), false, true);
 	}
 	if (localArg->functionInfo->reqFunction)
 	{
@@ -54,10 +52,6 @@ void attachInterrupt(uint8_t pin, std::function<void(void)> intRoutine, int mode
 
 void attachScheduledInterrupt(uint8_t pin, std::function<void(InterruptInfo)> scheduledIntRoutine, int mode)
 {
-	if (!scheduledInterrupts)
-	{
-		scheduledInterrupts = new ScheduledFunctions(32);
-	}
 	InterruptInfo* ii = new InterruptInfo;
 
 	FunctionInfo* fi = new FunctionInfo;

cores/esp8266/FunctionalInterrupt.h

@@ -4,7 +4,6 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <functional>
-#include <ScheduledFunctions.h>
 
 extern "C" {
 #include "c_types.h"
@@ -29,7 +28,6 @@ struct ArgStructure {
 	FunctionInfo* functionInfo = nullptr;
 };
 
-static ScheduledFunctions* scheduledInterrupts;
 void attachInterrupt(uint8_t pin, std::function<void(void)> intRoutine, int mode);
 void attachScheduledInterrupt(uint8_t pin, std::function<void(InterruptInfo)> scheduledIntRoutine, int mode);
 

cores/esp8266/PolledTimeout.h

@@ -153,7 +153,7 @@ class timeoutTemplate
     reset(userTimeout);
   }
 
-  ICACHE_RAM_ATTR
+  IRAM_ATTR // fast
   bool expired()
   {
     YieldPolicyT::execute(); //in case of DoNothing: gets optimized away
@@ -162,7 +162,7 @@ class timeoutTemplate
     return expiredOneShot();
   }
 
-  ICACHE_RAM_ATTR
+  IRAM_ATTR // fast
   operator bool()
   {
     return expired(); 
@@ -178,13 +178,15 @@ class timeoutTemplate
     return _timeout != alwaysExpired;
   }
 
+  IRAM_ATTR // called from ISR
   void reset(const timeType newUserTimeout)
   {
     reset();
     _timeout = TimePolicyT::toTimeTypeUnit(newUserTimeout);
     _neverExpires = (newUserTimeout < 0) || (newUserTimeout > timeMax());
   }
 
+  IRAM_ATTR // called from ISR
   void reset()
   {
     _start = TimePolicyT::time();
@@ -208,7 +210,7 @@ class timeoutTemplate
 
 private:
 
-  ICACHE_RAM_ATTR
+  IRAM_ATTR // fast
   bool checkExpired(const timeType internalUnit) const
   {
     // canWait() is not checked here
@@ -218,7 +220,7 @@ class timeoutTemplate
 
 protected:
 
-  ICACHE_RAM_ATTR
+  IRAM_ATTR // fast
   bool expiredRetrigger()
   {
     if (!canWait())
@@ -234,7 +236,7 @@ class timeoutTemplate
     return false;
   }
 
-  ICACHE_RAM_ATTR
+  IRAM_ATTR // fast
   bool expiredOneShot() const
   {
     // returns "always expired" or "has expired"

cores/esp8266/Schedule.cpp

@@ -1,9 +1,16 @@
 #include "Schedule.h"
+#include "PolledTimeout.h"
+#include "interrupts.h"
+
+typedef std::function<bool(void)> mFuncT;
 
 struct scheduled_fn_t
 {
     scheduled_fn_t* mNext;
-    std::function<void(void)> mFunc;
+    mFuncT mFunc;
+    esp8266::polledTimeout::periodicFastUs callNow;
+
+    scheduled_fn_t(): callNow(esp8266::polledTimeout::periodicFastUs::alwaysExpired) { }
 };
 
 static scheduled_fn_t* sFirst = 0;
@@ -14,7 +21,10 @@ static scheduled_fn_t* sLastUnused = 0;
 
 static int sCount = 0;
 
+IRAM_ATTR // called from ISR
 static scheduled_fn_t* get_fn() {
+    InterruptLock lockAllInterruptsInThisScope;
+
     scheduled_fn_t* result = NULL;
     // try to get an item from unused items list
     if (sFirstUnused) {
@@ -35,6 +45,8 @@ static scheduled_fn_t* get_fn() {
 
 static void recycle_fn(scheduled_fn_t* fn)
 {
+    InterruptLock lockAllInterruptsInThisScope;
+
     if (!sLastUnused) {
         sFirstUnused = fn;
     }
@@ -45,8 +57,11 @@ static void recycle_fn(scheduled_fn_t* fn)
     sLastUnused = fn;
 }
 
-bool schedule_function(std::function<void(void)> fn)
+IRAM_ATTR // called from ISR
+bool schedule_function_us(mFuncT fn, uint32_t repeat_us)
 {
+    InterruptLock lockAllInterruptsInThisScope;
+
     scheduled_fn_t* item = get_fn();
     if (!item) {
         return false;
@@ -60,19 +75,45 @@ bool schedule_function(std::function<void(void)> fn)
         sLast->mNext = item;
     }
     sLast = item;
+
+    if (repeat_us)
+        item->callNow.reset(repeat_us);
+
     return true;
 }
 
+IRAM_ATTR // called from ISR
+bool schedule_function(std::function<void(void)> fn)
+{
+    return schedule_function_us([&fn](){ fn(); return false; }, 0);
+}
+
 void run_scheduled_functions()
 {
-	scheduled_fn_t* rFirst = sFirst;
-	sFirst = NULL;
-	sLast  = NULL;
-    while (rFirst) {
-        scheduled_fn_t* item = rFirst;
-        rFirst = item->mNext;
-        item->mFunc();
-        item->mFunc = std::function<void(void)>();
-        recycle_fn(item);
+    scheduled_fn_t* lastRecurring = nullptr;
+    scheduled_fn_t* toCall = sFirst;
+    while (toCall) {
+        scheduled_fn_t* item = toCall;
+        toCall = item->mNext;
+        if (item->callNow)
+        {
+            if (item->mFunc())
+            {
+                lastRecurring = item;
+            }
+            else
+            {
+                {
+                    InterruptLock lockAllInterruptsInThisScope;
+                    if (sFirst == item)
+                        sFirst = item->mNext;
+                    if (sLast == item)
+                        sLast = lastRecurring;
+                }
+
+                item->mFunc = mFuncT();
+                recycle_fn(item);
+            }
+        }
     }
 }

cores/esp8266/Schedule.h

@@ -6,20 +6,25 @@
 #define SCHEDULED_FN_MAX_COUNT 32
 #define SCHEDULED_FN_INITIAL_COUNT 4
 
-// Warning 
-// This API is not considered stable. 
-// Function signatures will change.
+// This API was not considered stable but is now stabilizing.
+// Function signatures may change, queue must stay FIFO.
 // You have been warned.
 
-// Run given function next time `loop` function returns, 
+// Run given function ONCE next time `loop` function returns,
+// or `yield` is called,
 // or `run_scheduled_functions` is called.
 // Use std::bind to pass arguments to a function, or call a class member function.
 // Note: there is no mechanism for cancelling scheduled functions.
 // Keep that in mind when binding functions to objects which may have short lifetime.
 // Returns false if the number of scheduled functions exceeds SCHEDULED_FN_MAX_COUNT.
 bool schedule_function(std::function<void(void)> fn);
 
-// Run all scheduled functions. 
+// Run given function periodically about every <repeat_us> microseconds until it returns false.
+// Note that it may be more than <repeat_us> microseconds between calls if `yield` is not called
+// frequently, and therefore should not be used for timing critical operations.
+bool schedule_function_us(std::function<bool(void)> fn, uint32_t repeat_us);
+
+// Run all scheduled functions.
 // Use this function if your are not using `loop`, or `loop` does not return
 // on a regular basis.
 void run_scheduled_functions();