@alteriom/painlessmesh 1.7.2 → 1.7.4

package/examples/meshCommandNode/.pio/libdeps/esp32/TaskScheduler/examples/Scheduler_example30_THREAD_SAFE/src/main.cpp

@@ -0,0 +1,310 @@
+/*
+ * TaskScheduler Example 30: _TASK_THREAD_SAFE
+ *
+ * This example demonstrates the use of the _TASK_THREAD_SAFE compile option
+ * for safe multi-threaded operation with TaskScheduler.
+ *
+ * Features demonstrated:
+ * 1. FreeRTOS queue implementation for thread-safe request handling
+ * 2. Task control from hardware timer ISR
+ * 3. Task control from FreeRTOS worker thread
+ * 4. StatusRequest signaling from ISR
+ * 5. Safe parameter updates from different contexts
+ *
+ * Hardware: ESP32 (or any platform with FreeRTOS support)
+ *
+ * Expected behavior:
+ * - LED blinks at varying rates
+ * - Button press triggers immediate blink from ISR
+ * - Worker thread adjusts blink rate periodically
+ * - All operations are thread-safe via request queue
+ */
+
+#include <Arduino.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+#include <freertos/queue.h>
+
+// Must define _TASK_THREAD_SAFE before including TaskScheduler
+// (or define it in platformio.ini build_flags)
+#include <TaskSchedulerDeclarations.h>
+
+// ============================================
+// Configuration
+// ============================================
+#ifndef LED_BUILTIN
+#define LED_BUILTIN 2
+#endif
+
+#define LED_PIN             LED_BUILTIN
+#define BUTTON_PIN          0              // Boot button on most ESP32 boards
+
+#define TS_QUEUE_LEN        16             // Task request queue length
+#define TS_ENQUEUE_WAIT_MS  10             // Max wait time for enqueue (ms)
+#define TS_DEQUEUE_WAIT_MS  0              // No wait for dequeue
+
+// ============================================
+// Global Variables
+// ============================================
+
+// Task Scheduler queue (for thread-safe operations)
+QueueHandle_t tsQueue;
+uint8_t tsQueueData[TS_QUEUE_LEN * sizeof(_task_request_t)];
+StaticQueue_t tsQueueBuffer;
+
+// Scheduler
+Scheduler ts;
+
+// Status request for ISR signaling
+StatusRequest buttonPressed;
+
+// Task counters
+volatile uint32_t blinkCount = 0;
+volatile uint32_t isrTriggers = 0;
+volatile uint32_t threadUpdates = 0;
+
+// ============================================
+// Task Queue Implementation (Required for _TASK_THREAD_SAFE)
+// ============================================
+
+/**
+ * Enqueue a task request (called from any thread/ISR)
+ * This function is required when _TASK_THREAD_SAFE is enabled
+ */
+bool _task_enqueue_request(_task_request_t* req) {
+  if (xPortInIsrContext()) {
+    // Called from ISR context
+    BaseType_t xHigherPriorityTaskWokenByPost = pdFALSE;
+    BaseType_t rc = xQueueSendFromISR(tsQueue, req, &xHigherPriorityTaskWokenByPost);
+    if (xHigherPriorityTaskWokenByPost) {
+      portYIELD_FROM_ISR();
+    }
+    return (rc == pdTRUE);
+  }
+  else {
+    // Called from normal task context
+    return (xQueueSend(tsQueue, req, pdMS_TO_TICKS(TS_ENQUEUE_WAIT_MS)) == pdTRUE);
+  }
+}
+
+/**
+ * Dequeue a task request (called by scheduler)
+ * This function is required when _TASK_THREAD_SAFE is enabled
+ */
+bool _task_dequeue_request(_task_request_t* req) {
+  if (xPortInIsrContext()) {
+    // Called from ISR context (shouldn't normally happen)
+    BaseType_t xHigherPriorityTaskWokenByPost = pdFALSE;
+    BaseType_t rc = xQueueReceiveFromISR(tsQueue, req, &xHigherPriorityTaskWokenByPost);
+    if (xHigherPriorityTaskWokenByPost) {
+      portYIELD_FROM_ISR();
+    }
+    return (rc == pdTRUE);
+  }
+  else {
+    // Called from normal task context
+    return (xQueueReceive(tsQueue, req, TS_DEQUEUE_WAIT_MS) == pdTRUE);
+  }
+}
+
+// ============================================
+// Task Callbacks
+// ============================================
+
+/**
+ * LED blink task callback
+ */
+void blinkCallback() {
+  digitalWrite(LED_PIN, !digitalRead(LED_PIN));
+  blinkCount++;
+
+  if (blinkCount % 10 == 0) {
+    Serial.printf("[%lu] Blink #%lu (ISR triggers: %lu, Thread updates: %lu)\n",
+                  millis(), blinkCount, isrTriggers, threadUpdates);
+  }
+}
+
+Task tBlink(500, TASK_FOREVER, &blinkCallback, &ts, true);
+
+/**
+ * Fast blink task (triggered by button press)
+ */
+void fastBlinkCallback() {
+  digitalWrite(LED_PIN, !digitalRead(LED_PIN));
+}
+
+Task tFastBlink(100, 10, &fastBlinkCallback, &ts, false);
+
+/**
+ * Statistics task callback
+ */
+void statsCallback() {
+  Serial.printf("\n=== Statistics at %lu ms ===\n", millis());
+  Serial.printf("Total blinks: %lu\n", blinkCount);
+  Serial.printf("ISR triggers: %lu\n", isrTriggers);
+  Serial.printf("Thread updates: %lu\n", threadUpdates);
+  Serial.printf("Current blink interval: %lu ms\n", tBlink.getInterval());
+
+#ifdef _TASK_TIMECRITICAL
+  if (ts.isOverrun()) {
+    Serial.println("WARNING: Scheduler overrun detected!");
+  }
+#endif
+
+  Serial.println("================================\n");
+}
+
+Task tStats(5000, TASK_FOREVER, &statsCallback, &ts, true);
+
+// ============================================
+// ISR Handlers
+// ============================================
+
+/**
+ * Button ISR - triggers fast blink using thread-safe requestAction
+ */
+void IRAM_ATTR buttonISR() {
+  // Signal the status request from ISR
+  // This is thread-safe via requestAction
+  ts.requestAction(&buttonPressed, TASK_SR_REQUEST_SIGNALCOMPLETE, 0, 0, 0, 0, 0);
+  isrTriggers++;
+}
+
+/**
+ * Timer ISR - adjusts blink rate using thread-safe requestAction
+ */
+void IRAM_ATTR timerISR() {
+  // Change the blink interval from ISR (thread-safe)
+  static uint32_t nextInterval = 1000;
+
+  ts.requestAction(&tBlink, TASK_REQUEST_SETINTERVAL, nextInterval, 0, 0, 0, 0);
+
+  // Alternate between fast and slow
+  nextInterval = (nextInterval == 1000) ? 200 : 1000;
+}
+
+// ============================================
+// Worker Thread
+// ============================================
+
+/**
+ * Background worker thread that adjusts task parameters
+ * Demonstrates safe task manipulation from another FreeRTOS task
+ */
+void workerThread(void* parameter) {
+  uint32_t counter = 0;
+
+  while (true) {
+    vTaskDelay(pdMS_TO_TICKS(3000));  // Run every 3 seconds
+
+    counter++;
+
+    // Safely adjust the blink interval from worker thread
+    uint32_t newInterval = 300 + (counter % 5) * 100;  // 300-700ms range
+
+    // Use requestAction for thread-safe operation
+    bool success = ts.requestAction(&tBlink, TASK_REQUEST_SETINTERVAL, newInterval, 0, 0, 0, 0);
+
+    if (success) {
+      threadUpdates++;
+    } else {
+      Serial.println("ERROR: Failed to enqueue request (queue full?)");
+    }
+  }
+}
+
+// ============================================
+// Status Request Task
+// ============================================
+
+/**
+ * Task that waits for button press signal
+ */
+void buttonWatchCallback() {
+  Serial.println("Button pressed! Starting fast blink sequence...");
+
+  // Restart the fast blink task
+  // Direct call is safe because we're in scheduler context
+  tFastBlink.restart();
+}
+
+Task tButtonWatch(TASK_IMMEDIATE, TASK_FOREVER, &buttonWatchCallback, &ts, false);
+
+// ============================================
+// Setup and Main Loop
+// ============================================
+
+void setup() {
+  Serial.begin(115200);
+  delay(500);
+
+  Serial.println("\n\n===========================================");
+  Serial.println("TaskScheduler Example 30: _TASK_THREAD_SAFE");
+  Serial.println("===========================================\n");
+
+  // Initialize LED
+  pinMode(LED_PIN, OUTPUT);
+  digitalWrite(LED_PIN, LOW);
+
+  // Initialize button with pull-up
+  pinMode(BUTTON_PIN, INPUT_PULLUP);
+
+  // Create the task request queue
+  tsQueue = xQueueCreateStatic(
+    TS_QUEUE_LEN,
+    sizeof(_task_request_t),
+    tsQueueData,
+    &tsQueueBuffer
+  );
+
+  if (tsQueue == NULL) {
+    Serial.println("ERROR: Failed to create task queue!");
+    while (1) delay(1000);
+  }
+
+  Serial.printf("Task request queue created (size: %d)\n", TS_QUEUE_LEN);
+
+  // Set up button watch task to wait for button press signal
+  tButtonWatch.waitFor(&buttonPressed);
+
+  // Attach button interrupt
+  attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), buttonISR, FALLING);
+  Serial.println("Button interrupt attached (press boot button)");
+
+  // Create timer for periodic ISR (every 7 seconds)
+  hw_timer_t* timer = timerBegin(0, 80, true);  // Timer 0, prescaler 80 (1MHz), count up
+  timerAttachInterrupt(timer, &timerISR, true);
+  timerAlarmWrite(timer, 7000000, true);  // 7 seconds in microseconds, auto-reload
+  timerAlarmEnable(timer);
+  Serial.println("Hardware timer started (triggers every 7 seconds)");
+
+  // Create worker thread
+  xTaskCreate(
+    workerThread,
+    "WorkerThread",
+    4096,
+    NULL,
+    1,  // Priority
+    NULL
+  );
+  Serial.println("Worker thread created");
+
+  Serial.println("\n--- System initialized ---");
+  Serial.println("Expected behavior:");
+  Serial.println("1. LED blinks at variable rate");
+  Serial.println("2. Press button for fast blink burst");
+  Serial.println("3. Timer ISR changes rate every 7s");
+  Serial.println("4. Worker thread adjusts rate every 3s");
+  Serial.println("5. All operations are thread-safe!\n");
+
+  delay(1000);
+}
+
+void loop() {
+  // Run the scheduler
+  // It will automatically process queued requests via processRequests()
+  ts.execute();
+
+  // Small delay to prevent watchdog issues
+  delay(1);
+}

package/examples/meshCommandNode/.pio/libdeps/esp32/TaskScheduler/examples/Scheduler_template/Scheduler_template.ino

@@ -0,0 +1,166 @@
+/*
+    Your code description here
+    (c) you, 20XX
+    All rights reserved.
+
+    Functionality: 
+    
+    Version log:
+    
+    20XX-MM-DD:
+        v1.0.0  - Initial release
+        
+*/
+// ==== DEFINES ===================================================================================
+
+// ==== Debug and Test options ==================
+#define _DEBUG_
+//#define _TEST_
+
+//===== Debugging macros ========================
+#ifdef _DEBUG_
+#define SerialD Serial
+#define _PM(a) SerialD.print(millis()); SerialD.print(": "); SerialD.println(a)
+#define _PP(a) SerialD.print(a)
+#define _PL(a) SerialD.println(a)
+#define _PX(a) SerialD.println(a, HEX)
+#else
+#define _PM(a)
+#define _PP(a)
+#define _PL(a)
+#define _PX(a)
+#endif
+
+
+
+
+// ==== INCLUDES ==================================================================================
+
+// ==== Uncomment desired compile options =================================
+// ----------------------------------------
+// The following "defines" control library functionality at compile time,
+// and should be used in the main sketch depending on the functionality required
+// Should be defined BEFORE #include <TaskScheduler.h>  !!!
+// In PlatformIO - better define those as build_flags in platformio.ini file
+//
+// #define _TASK_TIMECRITICAL       // Enable monitoring scheduling overruns
+// #define _TASK_SLEEP_ON_IDLE_RUN  // Enable 1 ms SLEEP_IDLE powerdowns between runs if no callback methods were invoked during the pass
+// #define _TASK_STATUS_REQUEST     // Compile with support for StatusRequest functionality - triggering tasks on status change events in addition to time only
+// #define _TASK_WDT_IDS            // Compile with support for wdt control points and task ids
+// #define _TASK_LTS_POINTER        // Compile with support for local task storage pointer
+// #define _TASK_PRIORITY           // Support for layered scheduling priority
+// #define _TASK_MICRO_RES          // Support for microsecond resolution
+// #define _TASK_STD_FUNCTION       // Support for std::function 
+// #define _TASK_DEBUG              // Make all methods and variables public for debug purposes
+// #define _TASK_INLINE             // Make all methods "inline" - needed to support some multi-tab, multi-file implementations
+// #define _TASK_TIMEOUT            // Support for overall task timeout
+// #define _TASK_OO_CALLBACKS       // Support for callbacks via inheritance
+// #define _TASK_EXPOSE_CHAIN       // Methods to access tasks in the task chain
+// #define _TASK_SCHEDULING_OPTIONS // Support for multiple scheduling options
+// #define _TASK_SELF_DESTRUCT      // Enable tasks to "self-destruct" after disable
+// #define _TASK_TICKLESS           // Enable support for tickless sleep on FreeRTOS
+// #define _TASK_DO_NOT_YIELD       // Disable yield() method in execute() for ESP chips
+// #define _TASK_ISR_SUPPORT        // for esp chips - place control methods in IRAM
+// #define _TASK_NON_ARDUINO        // for non-arduino use
+// #define _TASK_HEADER_AND_CPP     // compile CPP file (non-Arduino IDE platforms)
+// #define _TASK_THREAD_SAFE        // Enable additional checking for thread safety
+
+#include <TaskScheduler.h>
+
+
+
+// ==== GLOBALS ===================================================================================
+// ==== Scheduler ==============================
+Scheduler ts;
+
+void task1Callback();
+void task2Callback();
+
+// ==== Scheduling defines (cheat sheet) =====================
+/*
+  TASK_MILLISECOND  - one millisecond in millisecond/microseconds
+  TASK_SECOND       - one second in millisecond/microseconds
+  TASK_MINUTE       - one minute in millisecond/microseconds
+  TASK_HOUR         - one hour in millisecond/microseconds
+  TASK_IMMEDIATE    - schedule task to runn as soon as possible
+  TASK_FOREVER      - run task indefinitely
+  TASK_ONCE         - run task once
+  TASK_NOTIMEOUT    - set timeout interval to No Timeout
+  
+  TASK_SCHEDULE     - schedule is a priority, with "catch up" (default)
+  TASK_SCHEDULE_NC  - schedule is a priority, without "catch up"
+  TASK_INTERVAL     - interval is a priority, without "catch up"
+  
+  TASK_SR_OK        - status request triggered with an OK code (all good)
+  TASK_SR_ERROR     - status request triggered with an ERROR code
+  TASK_SR_CANCEL    - status request was cancelled
+  TASK_SR_ABORT     - status request was aborted
+  TASK_SR_TIMEOUT   - status request timed out
+*/
+
+// ==== Task definitions ========================
+Task t1 (100 * TASK_MILLISECOND, TASK_FOREVER, &task1Callback, &ts, true);
+Task t2 (TASK_IMMEDIATE, 100 /* times */, &task2Callback, &ts, true);
+
+
+
+// ==== CODE ======================================================================================
+
+/**************************************************************************/
+/*!
+    @brief    Standard Arduino SETUP method - initialize sketch
+    @param    none
+    @returns  none
+*/
+/**************************************************************************/
+void setup() {
+  // put your setup code here, to run once:
+#if defined(_DEBUG_) || defined(_TEST_)
+  Serial.begin(115200);
+  delay(2000);
+  _PL("Scheduler Template: setup()");
+#endif
+}
+
+
+/**************************************************************************/
+/*!
+    @brief    Standard Arduino LOOP method - using with TaskScheduler there 
+              should be nothing here but ts.execute()
+    @param    none
+    @returns  none
+*/
+/**************************************************************************/
+void loop() {
+  ts.execute();
+}
+
+
+/**************************************************************************/
+/*!
+    @brief    Callback method of task1 - explain
+    @param    none
+    @returns  none
+*/
+/**************************************************************************/
+void task1Callback() {
+_PM("task1Callback()");
+//  task code
+}
+
+
+/**************************************************************************/
+/*!
+    @brief    Callback method of task2 - explain
+    @param    none
+    @returns  none
+*/
+/**************************************************************************/
+void task2Callback() {
+_PM("task2Callback()");
+//  task code
+}
+
+
+
+

package/examples/meshCommandNode/.pio/libdeps/esp32/TaskScheduler/keywords.txt

@@ -0,0 +1,161 @@
+#######################################
+# Syntax Coloring Map For TaskManager
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+Scheduler	KEYWORD1
+StatusRequest	KEYWORD1
+Task	KEYWORD1
+TS	KEYWORD1
+TaskScheduler	KEYWORD1
+TsScheduler	KEYWORD1
+TsStatusRequest	KEYWORD1
+TsTask	KEYWORD1
+TsTaskScheduler	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+abort	KEYWORD2
+addTask	KEYWORD2
+adjust	KEYWORD2
+allowSleep	KEYWORD2
+Callback	KEYWORD2
+cancel	KEYWORD2
+isCanceled	KEYWORD2
+isCompleted	KEYWORD2
+cpuLoadReset	KEYWORD2
+currentLts	KEYWORD2
+delay	KEYWORD2
+deleteTask	KEYWORD2
+disable	KEYWORD2
+disableAll	KEYWORD2
+disableOnLastIteration	KEYWORD2
+enable	KEYWORD2
+enableAll	KEYWORD2
+enableDelayed	KEYWORD2
+enableIfNot	KEYWORD2
+execute	KEYWORD2
+forceNextIteration	KEYWORD2
+getActiveTasks	KEYWORD2
+getControlPoint	KEYWORD2
+getCount	KEYWORD2
+getCount	KEYWORD2
+getCpuLoadCycle	KEYWORD2
+getCpuLoadIdle	KEYWORD2
+getCpuLoadTotal	KEYWORD2
+getCurrentTask	KEYWORD2
+getFirstTask	KEYWORD2
+getId	KEYWORD2
+getInternalStatusRequest	KEYWORD2
+getInterval	KEYWORD2
+getInvokedTasks	KEYWORD2
+getIterations	KEYWORD2
+getLastTask	KEYWORD2
+getLtsPointer	KEYWORD2
+getNextTask	KEYWORD2
+getNextRun	KEYWORD2
+getOverrun	KEYWORD2
+getPreviousTask	KEYWORD2
+getRunCounter	KEYWORD2
+getSchedulingOption	KEYWORD2
+getSelfDestruct	KEYWORD2
+getStartDelay	KEYWORD2
+getStatus	KEYWORD2
+getStatusRequest	KEYWORD2
+getTimeout	KEYWORD2
+getTotalTasks	KEYWORD2
+init	KEYWORD2
+isEnabled	KEYWORD2
+isFirstIteration	KEYWORD2
+isLastIteration	KEYWORD2
+isOverrun	KEYWORD2
+OnDisable	KEYWORD2
+OnEnable	KEYWORD2
+pause	KEYWORD2
+isPending	KEYWORD2
+requestAction	KEYWORD2
+resetTimeout	KEYWORD2
+restart	KEYWORD2
+restartDelayed	KEYWORD2
+resume	KEYWORD2
+set	KEYWORD2
+setCallback	KEYWORD2
+setControlPoint	KEYWORD2
+setHighPriorityScheduler	KEYWORD2
+setId	KEYWORD2
+setInterval	KEYWORD2
+setIterations	KEYWORD2
+setLtsPointer	KEYWORD2
+setOnDisable	KEYWORD2
+setOnEnable	KEYWORD2
+setSchedulingOption	KEYWORD2
+setSelfDestruct	KEYWORD2
+setSleepMethod	KEYWORD2
+setTimeout	KEYWORD2
+setWaiting	KEYWORD2
+signal	KEYWORD2
+signalComplete	KEYWORD2
+startNow	KEYWORD2
+isTimedOut	KEYWORD2
+timeUntilNextIteration	KEYWORD2
+untilTimeout	KEYWORD2
+waitFor	KEYWORD2
+waitForDelayed	KEYWORD2
+yield	KEYWORD2
+yieldOnce	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+
+_TASK_DEBUG	LITERAL1
+_TASK_INLINE	LITERAL1
+_TASK_LTS_POINTER	LITERAL1
+_TASK_MICRO_RES	LITERAL1
+_TASK_OO_CALLBACKS	LITERAL1
+_TASK_PRIORITY	LITERAL1
+_TASK_SLEEP_ON_IDLE_RUN	LITERAL1
+_TASK_STATUS_REQUEST	LITERAL1
+_TASK_STD_FUNCTION	LITERAL1
+_TASK_TIMECRITICAL	LITERAL1
+_TASK_TIMEOUT	LITERAL1
+_TASK_WDT_IDS	LITERAL1
+_TASK_EXPOSE_CHAIN	LITERAL1
+_TASK_SCHEDULING_OPTIONS	LITERAL1
+_TASK_THREAD_SAFE	LITERAL1
+_TASK_SELF_DESTRUCT	LITERAL1
+_TASK_TICKLESS  LITERAL1
+_TASK_DO_NOT_YIELD  LITERAL1
+_TASK_ISR_SUPPORT LITERAL1
+_TASK_NON_ARDUINO LITERAL1
+_TASK_HEADER_AND_CPP  LITERAL1
+TASK_FOREVER	LITERAL1
+TASK_HOUR	LITERAL1
+TASK_IMMEDIATE	LITERAL1
+TASK_MILLISECOND	LITERAL1
+TASK_MINUTE	LITERAL1
+TASK_NOTIMEOUT	LITERAL1
+TASK_ONCE	LITERAL1
+TASK_SECOND	LITERAL1
+SleepCallback	LITERAL1
+TaskCallback	LITERAL1
+TaskOnDisable	LITERAL1
+TaskOnEnable	LITERAL1
+TASK_SCHEDULE	LITERAL1
+TASK_SCHEDULE_NC	LITERAL1
+TASK_INTERVAL	LITERAL1
+TASK_SR_OK	LITERAL1
+TASK_SR_ERROR	LITERAL1
+TASK_SR_CANCEL	LITERAL1
+TASK_SR_ABORT	LITERAL1
+TASK_SR_TIMEOUT	LITERAL1
+TASK_INTERVAL_KEEP	LITERAL1
+TASK_INTERVAL_RECALC	LITERAL1
+TASK_INTERVAL_RESET	LITERAL1
+
+#######################################
+

package/examples/meshCommandNode/.pio/libdeps/esp32/TaskScheduler/library.json

@@ -0,0 +1,22 @@
+{
+  "name": "TaskScheduler",
+  "keywords": "multitasking, cooperative, event, task, taskscheduler, scheduling",
+  "description": "Cooperative multitasking for Arduino, ESPx, STM32 and other microcontrollers",
+  "repository":
+  {
+    "type": "git",
+    "url": "https://github.com/arkhipenko/TaskScheduler"
+  },
+  "authors":
+  [
+    {
+      "name": "Anatoli Arkhipenko",
+      "email": "arkhipenko@hotmail.com",
+      "url": "https://github.com/arkhipenko",
+      "maintainer": true
+    }
+  ],
+  "version": "4.0.2",
+  "frameworks": "arduino",
+  "platforms": "*"
+}

package/examples/meshCommandNode/.pio/libdeps/esp32/TaskScheduler/library.properties

@@ -0,0 +1,9 @@
+name=TaskScheduler
+version=4.0.2
+author=Anatoli Arkhipenko <arkhipenko@hotmail.com>
+maintainer=Anatoli Arkhipenko <arkhipenko@hotmail.com>
+sentence=Cooperative multitasking for Arduino, ESPx, STM32 and other microcontrollers.
+paragraph=Supports: periodic task execution (with dynamic execution period in milliseconds or microseconds – frequency of execution), number of iterations (limited or infinite number of iterations), execution of tasks in predefined sequence, dynamic change of task execution parameters (frequency, number of iterations, callback methods), power saving via entering IDLE sleep mode when tasks are not scheduled to run, event-driven task invocation via Status Request object, task IDs and Control Points for error handling and watchdog timer, Local Task Storage pointer (allowing use of same callback code for multiple tasks), layered task prioritization, std::functions (where supported), overall task timeout, static and dynamic callback method binding.
+category=Timing
+url=https://github.com/arkhipenko/TaskScheduler.git
+architectures=*

package/examples/meshCommandNode/.pio/libdeps/esp32/TaskScheduler/src/TScheduler.hpp

@@ -0,0 +1,29 @@
+// Cooperative multitasking library for Arduino
+// Copyright (c) 2015-2019 Anatoli Arkhipenko
+
+/*
+    This is a namespace wrapper to avoid collision with frameworks having their
+    own class named Scheduler (i.e. nordicnrf52)
+    include it instead of <TaskScheduler.h> into your sketch and use Class name wrapper - 'TaskScheduler'
+    i.e. 
+    TaskScheduler ts;
+*/
+
+#pragma once
+#include <Arduino.h>
+
+namespace TS{
+#include "TaskScheduler.h"
+}
+
+using TsScheduler = TS::Scheduler;
+using TsTask = TS::Task;
+#ifdef _TASK_STATUS_REQUEST
+using TsStatusRequest = TS::StatusRequest;
+#endif
+#ifdef _TASK_SLEEP_ON_IDLE_RUN
+using TsSleepCallback = TS::SleepCallback;
+#endif
+using TsTaskCallback = TS::TaskCallback;
+using TsTaskOnDisable = TS::TaskOnDisable;
+using TsTaskOnEnable = TS::TaskOnEnable;