#24 scheduling using lambda functions is now supported on 32 bit boards. Specifically all ESP, SAMD and mbed hardware.

Author: dave

README.md

@@ -38,6 +38,16 @@ In the setup method, add an function callback that gets fired once in the future
 	}, TIME_SECONDS);
 ```
 
+From 1.2 onwards: On ESP8266, ESP32, all mbed boards, and most 32 bit Arduino boards you can also capture values. An example of this usage follows:
+
+```
+    int capturedValue = 42;
+    taskManager.scheduleFixedRate(2, [capturedValue]() {
+        log("Execution with captured value = ", capturedValue);
+    }, TIME_SECONDS);
+
+```
+
 You can also create a class that extends from `Executable` and schedule that instead. For example:
 
 ```

examples/mbedRtos/mbedExample.cpp

@@ -151,6 +151,11 @@ void setupTasks() {
     // here we create an event that will be triggered on another thread and then notify task manager when it is
     // triggered. We will allocate using new and let task manager delete it when done.
     taskManager.registerEvent(&diceEvent);
+
+    int capturedValue = 42;
+    taskManager.scheduleFixedRate(2, [capturedValue]() {
+        log("Execution with captured value = ", capturedValue);
+    }, TIME_SECONDS);
 }
 
 bool exitThreads = false;

examples/taskManagement/taskManagement.ino

@@ -10,7 +10,7 @@ shows all the uses of the scheduler, for a simpler example, see the timedBlink e
 To test the interrupt support, wire a switch to pin 2 with pull up/down. Each change of state
 will cause an interrupt.
 
-Written by Dave Cherry of thecoderscorner.com in 2017
+Written by Dave Cherry of TheCodersCorner.com in 2017
 */
 
 #include <Arduino.h>
@@ -22,8 +22,6 @@ Written by Dave Cherry of thecoderscorner.com in 2017
 // a task, so it's safe to call anything you wish during it's execution.
 const int interruptPin = 2;
 
-int taskId = -1;
-
 // When we are not using IoAbstraction with task manager, then if we want to use interrupts, this class
 // provides the absolute bare minimum interrupt abstraction. Normally, we'd use IoAbstraction's device
 // abstraction capabilities instead.
@@ -40,13 +38,13 @@ void log(const char* logLine) {
 }
 
 /**
- * This is called by taskManager when the interrupt is raised. TaskManager marshalls the
+ * This is called by taskManager when the interrupt is raised. TaskManager marshals the
  * interrupt into a task, so it is safe to call Serial etc here. Be aware that interrupts
  * handled by taskManager are not completely real time, so only use when some slight delay
  * can be accepted. 
  * 
  * - Safe usage: change in rotary encoder, button pressed.
- * - Unsafe usage: over temprature shutdown, safety circuit.
+ * - Unsafe usage: over temperature shutdown, safety circuit.
  */
 void onInterrupt(pintype_t pin) {
 	log("Interrupt triggered");
@@ -114,7 +112,7 @@ void setup() {
     pinMode(interruptPin, INPUT);
 
     //
-    // Now we register some taks, note that on AVR by default there are 6 slots, all others have 10 slots.
+    // Now we register some tasks, note that on AVR by default there are 6 slots, all others have 10 slots.
     // this can be changed in TaskManager.h to your preferred setting.
     //
 
@@ -123,7 +121,7 @@ void setup() {
 
     // Now we schedule oneSecondPulse() to be called every second.
     // keep hold of the ID as we will later cancel it from running.
-    taskId = taskManager.scheduleFixedRate(1, oneSecondPulse, TIME_SECONDS);
+    taskid_t taskId = taskManager.scheduleFixedRate(1, oneSecondPulse, TIME_SECONDS);
 
     //
     // now we do a yield operation, which is similar to delayMicroseconds but allows other
@@ -133,13 +131,16 @@ void setup() {
     taskManager.yieldForMicros(32000);
     log("Waited 32 milli second with yield in setup");
 
-    // now schedule a task to run once in 30 seconds
-    taskManager.scheduleOnce(30000, [] {
+#ifdef TM_ALLOW_CAPTURED_LAMBDA
+    // now schedule a task to run once in 30 seconds, we capture the taskId using a locally captured value. Notice that
+    // this only works on 32 bit boards such as ESP*, ARM, mbed etc.
+    taskManager.scheduleOnce(30000, [taskId]() {
         log("30 seconds up, stopping 1 second job");
 
         // now cancel the one second job we scheduled earlier
         taskManager.cancelTask(taskId);
     });
+#endif
 
     // and another to run repeatedly at 5 second intervals, shows the task slot status
     taskManager.scheduleFixedRate(5, [] {

src/TaskPlatformDeps.h

@@ -11,6 +11,8 @@ class TimerTask;
 
 #if defined(__MBED__) || defined(ARDUINO_ARDUINO_NANO33BLE)
 
+#define TM_ALLOW_CAPTURED_LAMBDA
+
 // check if this is Arduino mbed or regular mbed.
 #if defined(ARDUINO_ARDUINO_NANO33BLE)
 # define IOA_USE_ARDUINO
@@ -79,6 +81,7 @@ namespace tm_internal {
 #include "Arduino.h"
 typedef uint8_t pintype_t;
 # define IOA_USE_ARDUINO
+# define TM_ALLOW_CAPTURED_LAMBDA
 
 
 #if defined(ESP8266)
@@ -256,6 +259,12 @@ inline void atomicWritePtr(TimerTaskAtomicPtr* pPtr, TimerTask* newValue) {
 }
 #endif // All platform checks
 
+// for all mbed and ESP boards we already enable lambda captures, SAMD is a known extra case that works.
+// we can only enable on larger boards with enough memory to take the extra size of the structures.
+#if !defined(TM_DONT_USE_LAMBDA) && defined(ARDUINO_ARCH_SAMD)
+# define TM_ALLOW_CAPTURED_LAMBDA
+#endif
+
 //
 // Scheduling size. On all boards by default task manager uses 32 bit schedule data to make it more general purpose.
 // Note that even on 8 bit boards, all the math still needs to be 32 bit to deal with times, so there is very little

src/TaskTypes.cpp

@@ -25,11 +25,13 @@ class RunningState {
     }
 };
 
-TimerTask::TimerTask() {
+TimerTask::TimerTask() : callback() {
     // set everything to not in use.
     timingInformation = TIME_MILLIS;
     myTimingSchedule = 0;
-    callback = nullptr;
+    scheduledAt = 0;
+    next = nullptr;
+    taskRef = nullptr;
     executeMode = EXECTYPE_FUNCTION;
     tm_internal::atomicWritePtr(&next, nullptr);
     tm_internal::atomicWriteBool(&taskInUse, false);
@@ -94,8 +96,6 @@ unsigned long TimerTask::microsFromNow() {
 }
 
 void TimerTask::execute() {
-    if (callback == nullptr) return;
-
     RunningState runningState(this);
 
     auto execType = (ExecutionType) (executeMode & EXECTYPE_MASK);
@@ -122,7 +122,10 @@ void TimerTask::clear() {
     if((executeMode & EXECTYPE_DELETE_ON_DONE) != 0 && taskRef != nullptr) {
         delete taskRef;
     }
-    callback = nullptr;
+    taskRef = nullptr;
+#ifdef TM_ALLOW_CAPTURED_LAMBDA
+    callback = std::function<void()>();
+#endif
 
     // clear timing info
     scheduledAt = 0;

src/TaskTypes.h

@@ -116,7 +116,12 @@ class BaseEvent : public Executable {
 /**
  * Definition of a function to be called back when a scheduled event is required. Takes no parameters, returns nothing.
  */
+#ifdef TM_ALLOW_CAPTURED_LAMBDA
+#include <functional>
+typedef std::function<void()> TimerFn;
+#else
 typedef void (*TimerFn)();
+#endif
 
 /**
  * The time units that can be used with the schedule calls.
@@ -161,12 +166,22 @@ enum ExecutionType : uint8_t {
  */
 class TimerTask {
 private:
+#ifdef TM_ALLOW_CAPTURED_LAMBDA
+    /** the thing that needs to be executed when the time is reached or event is triggered */
+    volatile union {
+        Executable *taskRef;
+        BaseEvent *eventRef;
+    };
+    TimerFn callback;
+#else
     /** the thing that needs to be executed when the time is reached or event is triggered */
     volatile union {
         TimerFn callback;
         Executable *taskRef;
         BaseEvent *eventRef;
     };
+#endif
+
     /** TimerTask is essentially stored in a linked list by time in TaskManager, this represents the next item */
     tm_internal::TimerTaskAtomicPtr next;