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

cores/esp8266/Arduino.h

@@ -165,6 +165,15 @@ void ets_intr_unlock();
 #define interrupts() xt_rsil(0)
 #define noInterrupts() xt_rsil(15)
 
+#define lockEnterVar(varSave, level) __asm__ __volatile__("rsil %0," __STRINGIFY(level) : "=a" (varSave))
+#define lockLeaveVar(varSave)        __asm__ __volatile__("wsr %0,ps; isync" :: "a" (varSave) : "memory")
+
+#define lockDeclM()  uint32_t intrState
+#define lockEnterM() lockEnterVar(intrState, 15)
+#define lockLeaveM() lockLeaveVar(intrState)
+
+#define lockEnter() lockDeclM(); lockEnterM()
+#define lockLeave() lockLeaveM()
 
 #define clockCyclesPerMicrosecond() ( F_CPU / 1000000L )
 #define clockCyclesToMicroseconds(a) ( (a) / clockCyclesPerMicrosecond() )

cores/esp8266/FunctionalInterrupt.cpp

@@ -3,6 +3,8 @@
 #include "Arduino.h"
 #include <ScheduledFunctions.h>
 
+static ScheduledFunctions* scheduledInterrupts;
+
 // Duplicate typedefs from core_esp8266_wiring_digital_c
 typedef void (*voidFuncPtr)(void);
 typedef void (*voidFuncPtrArg)(void*);

cores/esp8266/FunctionalInterrupt.h

@@ -29,7 +29,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,28 +1,29 @@
 #include "Schedule.h"
+#include "PolledTimeout.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;
-static scheduled_fn_t* sLast = 0;
-
 static scheduled_fn_t* sFirstUnused = 0;
-static scheduled_fn_t* sLastUnused = 0;
 
 static int sCount = 0;
 
+IRAM_ATTR // called from ISR
 static scheduled_fn_t* get_fn() {
     scheduled_fn_t* result = NULL;
     // try to get an item from unused items list
     if (sFirstUnused) {
         result = sFirstUnused;
         sFirstUnused = result->mNext;
-        if (sFirstUnused == NULL) {
-            sLastUnused = NULL;
-        }
     }
     // if no unused items, and count not too high, allocate a new one
     else if (sCount != SCHEDULED_FN_MAX_COUNT) {
@@ -35,44 +36,53 @@ static scheduled_fn_t* get_fn() {
 
 static void recycle_fn(scheduled_fn_t* fn)
 {
-    if (!sLastUnused) {
-        sFirstUnused = fn;
-    }
-    else {
-        sLastUnused->mNext = fn;
-    }
-    fn->mNext = NULL;
-    sLastUnused = fn;
+    fn->mNext = sFirstUnused;
+    sFirstUnused = fn;
 }
 
-bool schedule_function(std::function<void(void)> fn)
+IRAM_ATTR // called from ISR
+bool schedule_function_us(mFuncT fn, uint32_t repeat_us)
 {
+    lockEnter();
+
     scheduled_fn_t* item = get_fn();
     if (!item) {
+        lockLeave();
         return false;
     }
     item->mFunc = fn;
-    item->mNext = NULL;
-    if (!sFirst) {
-        sFirst = item;
-    }
-    else {
-        sLast->mNext = item;
-    }
-    sLast = item;
+    item->mNext = sFirst;
+    sFirst = item;
+
+    lockLeave();
+
+    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* toCall = sFirst;
+    while (toCall) {
+        scheduled_fn_t* item = toCall;
+        toCall = item->mNext;
+        if (item->callNow && !item->mFunc())
+        {
+            lockEnter();
+            if (sFirst == item)
+                sFirst = item->mNext;
+            lockLeave();
+
+            item->mFunc = mFuncT();
+            recycle_fn(item);
+        }
     }
 }

cores/esp8266/Schedule.h

@@ -6,20 +6,24 @@
 #define SCHEDULED_FN_MAX_COUNT 32
 #define SCHEDULED_FN_INITIAL_COUNT 4
 
-// Warning 
-// This API is not considered stable. 
+// Warning
+// This API is not considered stable.
 // Function signatures will change.
 // 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 every at least <repeat_us> microseconds until it returns false
+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();

cores/esp8266/core_esp8266_main.cpp

@@ -91,13 +91,15 @@ extern "C" void esp_yield() {
 }
 
 extern "C" void esp_schedule() {
+    // always on CONT stack here
+    run_scheduled_functions();
     ets_post(LOOP_TASK_PRIORITY, 0, 0);
 }
 
 extern "C" void __yield() {
     if (cont_can_yield(g_pcont)) {
         esp_schedule();
-        esp_yield();
+        cont_yield(g_pcont); //esp_yield();
     }
     else {
         panic();
@@ -122,7 +124,6 @@ static void loop_wrapper() {
         setup_done = true;
     }
     loop();
-    run_scheduled_functions();
     esp_schedule();
 }
 

tests/host/common/Arduino.h

@@ -143,26 +143,20 @@ extern "C" {
 #define __STRINGIFY(a) #a
 #endif
 
-    // these low level routines provide a replacement for SREG interrupt save that AVR uses
-    // but are esp8266 specific. A normal use pattern is like
-    //
-    //{
-    //    uint32_t savedPS = xt_rsil(1); // this routine will allow level 2 and above
-    //    // do work here
-    //    xt_wsr_ps(savedPS); // restore the state
-    //}
-    //
-    // level (0-15), interrupts of the given level and above will be active
-    // level 15 will disable ALL interrupts,
-    // level 0 will enable ALL interrupts,
-    //
-#define xt_rsil(level) (__extension__({uint32_t state; __asm__ __volatile__("rsil %0," __STRINGIFY(level) : "=a" (state)); state;}))
-#define xt_wsr_ps(state)  __asm__ __volatile__("wsr %0,ps; isync" :: "a" (state) : "memory")
-
+#define xt_rsil(level) (level)
+#define xt_wsr_ps(state) do { (void)(state); } while (0)
+
 #define interrupts() xt_rsil(0)
 #define noInterrupts() xt_rsil(15)
-
-
+
+#define lockEnterVar(varSave, level) do { (void)(varSave); (void)(level); } while (0)
+#define lockLeaveVar(varSave)        do { (void)0; } while (0)
+#define lockDeclM()                  do { (void)0; } while (0)
+#define lockEnterM()                 do { (void)0; } while (0)
+#define lockLeaveM()                 do { (void)0; } while (0)
+#define lockEnter()                  do { (void)0; } while (0)
+#define lockLeave()                  do { (void)0; } while (0)
+
 #define clockCyclesPerMicrosecond() ( F_CPU / 1000000L )
 #define clockCyclesToMicroseconds(a) ( (a) / clockCyclesPerMicrosecond() )
 #define microsecondsToClockCycles(a) ( (a) * clockCyclesPerMicrosecond() )

tests/host/common/c_types.h

@@ -102,6 +102,9 @@ typedef enum {
 #define ICACHE_RODATA_ATTR
 #endif /* ICACHE_FLASH */
 
+// counterpart https://github.com/espressif/arduino-esp32/blob/master/cores/esp32/esp8266-compat.h
+#define IRAM_ATTR ICACHE_RAM_ATTR
+
 #define STORE_ATTR __attribute__((aligned(4)))
 
 #ifndef __cplusplus

tools/sdk/include/c_types.h

@@ -93,6 +93,9 @@ typedef enum {
 #define ICACHE_RAM_ATTR
 #endif /* ICACHE_FLASH */
 
+// counterpart https://github.com/espressif/arduino-esp32/blob/master/cores/esp32/esp8266-compat.h
+#define IRAM_ATTR ICACHE_RAM_ATTR
+
 #define STORE_ATTR __attribute__((aligned(4)))
 
 #ifndef __cplusplus