@alteriom/painlessmesh 1.7.2 → 1.7.4

package/examples/meshCommandNode/.pio/libdeps/esp32/TaskScheduler/README.md

@@ -0,0 +1,157 @@
+# Task Scheduler
+### Cooperative multitasking for Arduino, ESPx, STM32 and other microcontrollers
+#### Version 4.0.2: 2025-10-09 [Latest updates](https://github.com/arkhipenko/TaskScheduler/wiki/Latest-Updates)
+
+[![arduino-library-badge](https://www.ardu-badge.com/badge/TaskScheduler.svg?)](https://www.ardu-badge.com/TaskScheduler)
+
+#### Get expedited support or integration consultation for TaskScheduler [from xs:code](https://xscode.com/arkhipenko/TaskScheduler)
+
+[![github](https://github.com/arkhipenko/resources/blob/master/taskscheduler-banner.png)](https://github.com/arkhipenko/TaskScheduler)
+---
+
+### OVERVIEW:
+A lightweight implementation of cooperative multitasking (task scheduling). An easier alternative to preemptive programming and frameworks like FreeRTOS. 
+
+**Why cooperative?**
+
+You mostly do not need to worry about pitfalls of concurrent processing (races, deadlocks, livelocks, resource sharing, etc.).  The fact of cooperative processing takes care of such issues by design. 
+
+_“Everybody who learns concurrency and thinks they understand it, ends up finding mysterious races they thought weren’t possible, and discovers that they didn’t actually understand it yet after all.”_ **Herb Sutter, chair of the ISO C++ standards committee, Microsoft.**
+
+**Main features:**
+1. Periodic task execution, with dynamic execution period in `milliseconds` (default) or `microseconds` (if explicitly enabled) – frequency of execution
+2. Number of iterations (limited or infinite number of iterations)
+3. Execution of tasks in predefined sequence
+4. Dynamic change of task execution parameters (frequency, number of iterations, callback methods)
+5. Power saving via entering **IDLE** sleep mode when tasks are not scheduled to run
+6. Support for event-driven task invocation via Status Request object
+7. Support for task IDs and Control Points for error handling and watchdog timer
+8. Support for Local Task Storage pointer (allowing use of same callback code for multiple tasks)
+9. Support for layered task prioritization
+10. Support for `std::functions` (tested on `ESPx` and `STM32` only)
+11. Overall task timeout
+12. Static and dynamic callback method binding
+13. CPU load / idle statistics for time critical applications
+14. Scheduling options with priority for original schedule (with and without catchup) and interval
+15. Ability to pause/resume and enable/disable scheduling
+16. Thread-safe scheduling while running under preemptive scheduler (i. e., FreeRTOS)
+17. Optional self-destruction of dynamically created tasks upon disable
+18. Support for "tickless" execution under FreeRTOS (continous sleep until next scheduled task invocation)
+19. Support for both Arduino IDE stype (headers only) and PlatformIO style (Header + CPP files)
+20. Support for non-Arduino platforms
+
+Scheduling overhead: between `15` and `18` microseconds per scheduling pass (Arduino UNO rev 3 @ `16MHz` clock, single scheduler w/o prioritization)
+
+**TaskScheduler** was tested on the following platforms:
+* Arduino Uno R3, Nano, Micro
+* ATtiny85
+* ESP8266, ESP32
+* Teensy (tested on Teensy 3.5)
+* nRF52832, nRF52 Adafruit Core (tested on nRF52840 with v3.6.2 workround)
+* STM32 (tested on Mini USB STM32F103RCBT6 ARM Cortex-M3 leaflabs Leaf maple mini module F)
+* MSP430 and MSP432 boards
+* Raspberry Pi (requires external `_TASK_NON_ARDUINO` and `_task_millis()` implementation)
+* Any Linux (requires external `_TASK_NON_ARDUINO` and `_task_millis()` implementation - that's how Unit tests are done)
+
+
+​**Don't just take my word for it - try it for yourself on [Wokwi](https://wokwi.com/playground/task-scheduler)**
+
+
+---
+![TaskScheduler process diagram](https://github.com/arkhipenko/TaskScheduler/raw/master/extras/TaskScheduler_html.png)
+---
+### Changelog 
+
+Changelog is located [here.](https://github.com/arkhipenko/TaskScheduler/wiki/Changelog)
+
+
+#### For detailed functionality overview 
+
+Please refer to TaskScheduler documentation on [GitHub Pages](https://arkhipenko.github.io/ts) or in the [Wiki page](https://github.com/arkhipenko/TaskScheduler/wiki).
+
+### Contributing
+
+#### Code 
+
+As of version 4.0.0 TaskScheduler has a comprehensive set of compilation and unit tests. Please submit a PR with your changes and make sure that your code passes all the tests. 
+
+#### More unit tests
+
+There is no such thing as enough testing. If you come up with another test scenario - please contribute!
+
+### User Feedback:
+
+"I've used https://github.com/arkhipenko/TaskScheduler with great success. Running LED patterns, monitoring button presses, reading data from an accelerometer, auto advancing to the next pattern, reading data from Serial. All at the same time." - [here](https://www.reddit.com/r/FastLED/comments/b3rfzf/wanna_try_some_code_that_is_powerfuldangerous/)
+
+"There are libraries that do this automatically on Arduino too, allowing you to schedule [cooperative] multitasking and sleep the uC between tasks. E.g. https://github.com/arkhipenko/TaskScheduler is really good, I've used it before. You basically queue up a list of task callbacks and a schedule in your `setup()` and then do a call to `tasks.execute()` in `loop()`, which pops off the next task that is due in a queue or sleeps otherwise. It's simple, but much more straightforward than manually using `if millis() - last > delta1... else sleep()` and not as rigid as using the timer ISRs (which really serve a different purpose)." - [here](https://news.ycombinator.com/item?id=14848906)
+
+"I took the controller with me on a business trip and spend the night getting the basic code framework out. It is going to run on top of Arkhipenko’s TaskScheduler. (https://github.com/arkhipenko/TaskScheduler) This should help me isolate any issues between the different control systems while managing the different task’s timing requirements." - [here](https://hackaday.io/project/167479/logs)
+
+"it's really cool and useful, for whenver you want your MCU to do more than 1 task" - [here](https://gitter.im/FastLED/public?at=5947e23dd83c50560c22d5b6)
+
+"I encourage you to use it in the Arduino environment, it allows you to save a lot of time (and code lines) wherever you need to schedule, i.e. run many tasks that should to perform at different frequencies and when we want to have the greatest control over the performance of these tasks and we want good diagnostic of errors." - [here](https://www.elektroda.pl/rtvforum/topic3599980.html)
+
+"arkhipenko/TaskScheduler is still my choice for now, especially when I get my pull request in, so we can have that idle 1 ms sleep feature for free." - [here](http://stm32duinoforum.com/forum/viewtopic_f_18_t_4299.html)
+
+"The difference with milis is basically that you don’t have to be using logics to manage the executions, but the module itself does it. This will allow us to make code more readable and easier to maintain. In addition, we must take into account the extra functions it provides, such as saving energy when not in use, or changing settings dynamically." - [here](https://www.electrosoftcloud.com/en/arduino-taskscheduler-no-more-millis-or-delay/)
+
+
+
+### Check out what TaskScheduler can do:
+
+#### A picture is worth 1024 words:
+
+* Video tutorial of TaskScheduler
+  https://youtu.be/eoJUlH_rWOE?si=eatgXMDMzwLPXrVP
+  
+#### Around the world:
+
+* Ninja Timer: Giant 7-Segment Display at Adafruit.com
+  https://learn.adafruit.com/ninja-timer-giant-7-segment-display/timer-code
+* Playing with NeoPixel to create a nice #smartBulb IoT
+  https://www.zerozone.it/linux-e-open-source/giocare-con-i-neopixel-per-realizzare-un-simpatico-smartbulb-iot/16760
+* Adding a timer to XK X6 Transmitter
+  https://www.elvinplay.com/adding-a-timer-to-xk-x6-transmitter-en/
+* Arduino Bluetooth remote control + ultrasonic anti-collision car
+  https://xie.infoq.cn/article/0f27dbbebcc2b99b35132b262
+* WEMOS D1 Mini로 Ad-hoc WIFI network
+  https://m.blog.naver.com/sonyi/221330334326
+* [3 Devo](http://3devo.eu/) - Quality 3D printing filament, now made accessible and affordable
+(http://3devo.eu/license-information/)
+
+
+* [Houston midi](https://github.com/chaffneue/houston) clock project - TaskScheduler with microseconds resolution
+  
+    >by chaffneue:
+    >>My first arduino project. It's a multi-master midi controller with a shared clock and
+	 auto count in behaviour.
+	
+	 youtube: https://www.youtube.com/watch?v=QRof550TtXo
+
+
+* [Hackabot Nano](http://hackarobot.com/) by Funnyvale -  Compact Plug and Play Arduino compatible robotic kit
+     https://www.kickstarter.com/projects/hackarobot/hackabot-nano-compact-plug-and-play-arduino-robot
+* Discrete Time Systems Wiki - 
+     https://sistemas-en-tiempo-discreto.fandom.com/es/wiki/Tiempo_Real
+
+#### My projects:
+
+* Interactive "Do Not Disturb" sign in a shape of Minecraft Sword (ESP32)
+    (https://www.instructables.com/id/Interactive-Minecraft-Do-Not-Enter-SwordSign-ESP32/)
+* Interactive Predator Costume with Real-Time Head Tracking Plasma Cannon (Teensy, Arduino Nano)
+    (https://www.instructables.com/id/Interactive-Predator-Costume-With-Head-Tracking-Pl/)
+* IoT APIS v2 - Autonomous IoT-enabled Automated Plant Irrigation System (ESP8266)
+    (http://www.instructables.com/id/IoT-APIS-V2-Autonomous-IoT-enabled-Automated-Plant/)
+* APIS - Automated Plant Irrigation System (Arduino Uno)
+    (http://www.instructables.com/id/APIS-Automated-Plant-Irrigation-System/)
+
+* Party Lights LEDs music visualization (Leaf Maple Mini)
+    (https://www.instructables.com/id/Portable-Party-Lights/)
+* Arduino Nano based Hexbug Scarab Robotic Spider (Arduino Nano)
+    (http://www.instructables.com/id/Arduino-Nano-based-Hexbug-Scarab-Robotic-Spider/)
+* Wave your hand to control OWI Robotic Arm... no strings attached (Arduino Uno and Nano)
+    (http://www.instructables.com/id/Wave-your-hand-to-control-OWI-Robotic-Arm-no-strin/)
+
+
+* Interactive Halloween Pumpkin (Arduino Uno)
+    (http://www.instructables.com/id/Interactive-Halloween-Pumpkin/)

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

@@ -0,0 +1,303 @@
+/*
+   Every example set must have a LED blink example
+   For this one the idea is to have as many ways to blink the LED
+   as I can think of. So, here we go.
+
+   Tested on:
+   - Arduino Nano
+   - ESP8266
+   - ESP32
+   - STM32 Maple Mini
+*/
+
+// ----------------------------------------
+// The following "defines" control library functionality at compile time,
+// and should be used in the main sketch depending on the functionality required
+//
+// #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_THREAD_SAFE        // Enable additional checking for thread safety
+// #define _TASK_SELF_DESTRUCT      // Enable tasks to "self-destruct" after disable
+#include <TaskScheduler.h>
+
+// Debug and Test options
+#define _DEBUG_
+//#define _TEST_
+
+#ifdef _DEBUG_
+#define _PP(a) Serial.print(a);
+#define _PL(a) Serial.println(a);
+#else
+#define _PP(a)
+#define _PL(a)
+#endif
+
+// LED_BUILTIN  13
+#if defined( ARDUINO_ARCH_ESP32 )
+#define LED_BUILTIN  23 // esp32 dev2 kit does not have LED
+#endif
+
+// Scheduler
+Scheduler ts;
+
+/*
+   Approach 1: LED is driven by the boolean variable; false = OFF, true = ON
+*/
+#define PERIOD1 500
+#define DURATION 10000
+void blink1CB();
+Task tBlink1 ( PERIOD1 * TASK_MILLISECOND, DURATION / PERIOD1, &blink1CB, &ts, true );
+
+/*
+   Approac 2: two callback methods: one turns ON, another turns OFF
+*/
+#define PERIOD2 400
+void blink2CB_ON();
+void blink2CB_OFF();
+Task tBlink2 ( PERIOD2 * TASK_MILLISECOND, DURATION / PERIOD2, &blink2CB_ON, &ts, false );
+
+/*
+   Approach 3: Use RunCounter
+*/
+#define PERIOD3 300
+void blink3CB();
+Task tBlink3 (PERIOD3 * TASK_MILLISECOND, DURATION / PERIOD3, &blink3CB, &ts, false);
+
+/*
+   Approach 4: Use status request objects to pass control from one task to the other
+*/
+#define PERIOD4 200
+bool blink41OE();
+void blink41();
+void blink42();
+void blink42OD();
+Task tBlink4On  ( PERIOD4 * TASK_MILLISECOND, TASK_ONCE, blink41, &ts, false, &blink41OE );
+Task tBlink4Off ( PERIOD4 * TASK_MILLISECOND, TASK_ONCE, blink42, &ts, false, NULL, &blink42OD );
+
+
+/*
+   Approach 5: Two interleaving tasks
+*/
+#define PERIOD5 600
+bool blink51OE();
+void blink51();
+void blink52();
+void blink52OD();
+Task tBlink5On  ( 600 * TASK_MILLISECOND, DURATION / PERIOD5, &blink51, &ts, false, &blink51OE );
+Task tBlink5Off ( 600 * TASK_MILLISECOND, DURATION / PERIOD5, &blink52, &ts, false, NULL, &blink52OD );
+
+
+/*
+   Approach 6: RunCounter-based with random intervals
+*/
+#define PERIOD6 300
+void blink6CB();
+bool blink6OE();
+void blink6OD();
+Task tBlink6 ( PERIOD6 * TASK_MILLISECOND, DURATION / PERIOD6, &blink6CB, &ts, false, &blink6OE, &blink6OD );
+
+void setup() {
+  // put your setup code here, to run once:
+#if defined(_DEBUG_) || defined(_TEST_)
+  Serial.begin(115200);
+  delay(TASK_SECOND);
+  _PL("TaskScheduler Blink example");
+  _PL("Blinking for 10 seconds using various techniques\n");
+  delay(2 * TASK_SECOND);
+#endif
+  pinMode(LED_BUILTIN, OUTPUT);
+}
+
+void loop() {
+  ts.execute();
+}
+
+inline void LEDOn() {
+  digitalWrite( LED_BUILTIN, HIGH );
+}
+
+inline void LEDOff() {
+  digitalWrite( LED_BUILTIN, LOW );
+}
+
+// === 1 =======================================
+bool LED_state = false;
+void blink1CB() {
+  if ( tBlink1.isFirstIteration() ) {
+    _PP(millis());
+    _PL(": Blink1 - simple flag driven");
+    LED_state = false;
+  }
+
+  if ( LED_state ) {
+    LEDOff();
+    LED_state = false;
+  }
+  else {
+    LEDOn();
+    LED_state = true;
+  }
+
+  if ( tBlink1.isLastIteration() ) {
+    tBlink2.restartDelayed( 2 * TASK_SECOND );
+    LEDOff();
+  }
+}
+
+
+// === 2 ======================================
+void blink2CB_ON() {
+  if ( tBlink2.isFirstIteration() ) {
+    _PP(millis());
+    _PL(": Blink2 - 2 callback methods");
+  }
+
+  LEDOn();
+  tBlink2.setCallback( &blink2CB_OFF );
+
+  if ( tBlink2.isLastIteration() ) {
+    tBlink3.restartDelayed( 2 * TASK_SECOND );
+    LEDOff();
+  }
+}
+
+
+void blink2CB_OFF() {
+
+  LEDOff();
+  tBlink2.setCallback( &blink2CB_ON );
+
+  if ( tBlink2.isLastIteration() ) {
+    tBlink3.restartDelayed( 2 * TASK_SECOND );
+    LEDOff();
+  }
+}
+
+
+// === 3 =====================================
+void blink3CB() {
+  if ( tBlink3.isFirstIteration() ) {
+    _PP(millis());
+    _PL(": Blink3 - Run Counter driven");
+  }
+
+  if ( tBlink3.getRunCounter() & 1 ) {
+    LEDOn();
+  }
+  else {
+    LEDOff();
+  }
+
+  if ( tBlink3.isLastIteration() ) {
+    tBlink4On.setOnEnable( &blink41OE );
+    tBlink4On.restartDelayed( 2 * TASK_SECOND );
+    LEDOff();
+  }
+}
+
+
+// === 4 =============================================
+int counter = 0;
+bool blink41OE() {
+  _PP(millis());
+  _PL(": Blink4 - Internal status request based");
+  counter = 0;
+  tBlink4On.setOnEnable( NULL );
+  return true;
+}
+
+void blink41() {
+  //  _PP(millis());
+  //  _PL(": blink41");
+  LEDOn();
+  StatusRequest* r = tBlink4On.getInternalStatusRequest();
+  tBlink4Off.waitForDelayed( r );
+  counter++;
+}
+
+void blink42() {
+  //  _PP(millis());
+  //  _PL(": blink42");
+  LEDOff();
+  StatusRequest* r = tBlink4Off.getInternalStatusRequest();
+  tBlink4On.waitForDelayed( r );
+  counter++;
+}
+
+
+void blink42OD() {
+  if ( counter >= DURATION / PERIOD4 ) {
+    tBlink4On.disable();
+    tBlink4Off.disable();
+
+    tBlink5On.setOnEnable( &blink51OE );
+    tBlink5On.restartDelayed( 2 * TASK_SECOND );
+    tBlink5Off.restartDelayed( 2 * TASK_SECOND + PERIOD5 / 2 );
+    LEDOff();
+  }
+}
+
+
+// === 5 ==========================================
+bool blink51OE() {
+  _PP(millis());
+  _PL(": Blink5 - Two interleaving tasks");
+  tBlink5On.setOnEnable( NULL );
+  return true;
+}
+void blink51() {
+  //  _PP(millis());
+  //  _PL(": blink51");
+  LEDOn();
+}
+void blink52() {
+  //  _PP(millis());
+  //  _PL(": blink52");
+  LEDOff();
+}
+void blink52OD() {
+  tBlink6.restartDelayed( 2 * TASK_SECOND );
+  LEDOff();
+}
+
+
+// === 6 ============================================
+long interval6 = 0;
+bool blink6OE() {
+  _PP(millis());
+  _PP(": Blink6 - RunCounter + Random ON interval = ");
+  interval6 = random( 100, 901 );
+  tBlink6.setInterval( interval6 );
+  _PL( interval6 );
+  tBlink6.delay( 2 * TASK_SECOND );
+
+  return true;
+}
+
+void blink6CB() {
+  if ( tBlink6.getRunCounter() & 1 ) {
+    LEDOn();
+    tBlink6.setInterval( interval6 );
+  }
+  else {
+    LEDOff();
+    tBlink6.setInterval( TASK_SECOND - interval6 );
+  }
+}
+
+void blink6OD() {
+  tBlink1.restartDelayed( 2 * TASK_SECOND );
+  LEDOff();
+}