@alteriom/painlessmesh 1.7.2 → 1.7.4

package/examples/alteriom/.pio/libdeps/esp8266/TaskScheduler/examples/Scheduler_example29_NonArduino/src/main.cpp

@@ -0,0 +1,267 @@
+/*
+   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:
+   - ESP32
+
+   This example is compiled without Arduino.h in TS header. 
+*/
+
+#include <TaskSchedulerDeclarations.h>
+
+#include "main.h"
+#include "led.h"
+
+// Scheduler
+Scheduler ts;
+
+
+// Comment the following 3 functions out to observe errors due to missing Arduino.h
+unsigned long _task_millis() {
+  return xTaskGetTickCount();
+}
+
+unsigned long _task_micros() {
+  return (unsigned long) (esp_timer_get_time());
+}
+
+void _task_yield() {
+  portYIELD();
+}
+
+/*
+   Approach 1: LED is driven by the boolean variable; false = OFF, true = ON
+*/
+void blink1CB();
+Task tBlink1 ( PERIOD1 * TASK_MILLISECOND, DURATION / PERIOD1, &blink1CB, &ts, true );
+
+/*
+   Approach 2: two callback methods: one turns ON, another turns OFF
+*/
+void blink2CB_ON();
+void blink2CB_OFF();
+Task tBlink2 ( PERIOD2 * TASK_MILLISECOND, DURATION / PERIOD2, &blink2CB_ON, &ts, false );
+
+/*
+   Approach 3: Use RunCounter
+*/
+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
+*/
+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
+*/
+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
+*/
+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();
+}
+
+// === 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();
+}

package/examples/alteriom/.pio/libdeps/esp8266/TaskScheduler/examples/Scheduler_example29_NonArduino/test/README

@@ -0,0 +1,11 @@
+
+This directory is intended for PlatformIO Unit Testing and project tests.
+
+Unit Testing is a software testing method by which individual units of
+source code, sets of one or more MCU program modules together with associated
+control data, usage procedures, and operating procedures, are tested to
+determine whether they are fit for use. Unit testing finds problems early
+in the development cycle.
+
+More information about PlatformIO Unit Testing:
+- https://docs.platformio.org/page/plus/unit-testing.html

package/examples/alteriom/.pio/libdeps/esp8266/TaskScheduler/examples/Scheduler_example30_THREAD_SAFE/README.md

@@ -0,0 +1,232 @@
+# Example 30: _TASK_THREAD_SAFE - Multi-threaded TaskScheduler
+
+## Overview
+
+This example demonstrates the use of the `_TASK_THREAD_SAFE` compile option for safe multi-threaded operation with TaskScheduler on FreeRTOS-based platforms (ESP32, ESP8266, STM32, etc.).
+
+## What it Demonstrates
+
+### 1. Thread-Safe Request Queue
+- Implementation of required `_task_enqueue_request()` and `_task_dequeue_request()` functions
+- FreeRTOS queue for handling task control requests from multiple threads
+- Automatic handling of ISR vs. normal task context
+
+### 2. ISR-Safe Operations
+- Button interrupt triggering StatusRequest signals
+- Hardware timer ISR changing task parameters
+- Proper use of `requestAction()` from interrupt context
+
+### 3. Multi-Thread Task Control
+- FreeRTOS worker thread adjusting task parameters
+- Safe task manipulation from non-scheduler threads
+- Queue-based communication between threads
+
+### 4. StatusRequest Integration
+- Task waiting on StatusRequest completion
+- Signaling from ISR context
+- Automatic task activation on event
+
+## Hardware Requirements
+
+- **ESP32** development board (recommended)
+- Built-in LED (LED_BUILTIN)
+- Boot button (GPIO 0 on most boards)
+
+Also compatible with:
+- ESP8266
+- STM32 with FreeRTOS
+- Any Arduino-compatible board with FreeRTOS support
+
+## Expected Behavior
+
+1. **LED Blinking**: LED blinks at varying rates (controlled by worker thread and timer ISR)
+2. **Button Press**: Pressing the boot button triggers a fast blink burst
+3. **Timer Events**: Every 7 seconds, hardware timer toggles blink rate
+4. **Thread Updates**: Worker thread changes blink interval every 3 seconds
+5. **Statistics**: Serial output shows counters and current state every 5 seconds
+
+## Key Components
+
+### Queue Implementation
+
+```cpp
+// Required global queue
+QueueHandle_t tsQueue;
+uint8_t tsQueueData[TS_QUEUE_LEN * sizeof(_task_request_t)];
+StaticQueue_t tsQueueBuffer;
+
+// Required enqueue function
+bool _task_enqueue_request(_task_request_t* req) {
+  if (xPortInIsrContext()) {
+    // ISR context
+    BaseType_t xHigherPriorityTaskWokenByPost = pdFALSE;
+    BaseType_t rc = xQueueSendFromISR(tsQueue, req, &xHigherPriorityTaskWokenByPost);
+    if (xHigherPriorityTaskWokenByPost) portYIELD_FROM_ISR();
+    return (rc == pdTRUE);
+  }
+  else {
+    // Normal task context
+    return (xQueueSend(tsQueue, req, pdMS_TO_TICKS(TS_ENQUEUE_WAIT_MS)) == pdTRUE);
+  }
+}
+
+// Required dequeue function
+bool _task_dequeue_request(_task_request_t* req) {
+  return (xQueueReceive(tsQueue, req, TS_DEQUEUE_WAIT_MS) == pdTRUE);
+}
+```
+
+### Safe Task Control from ISR
+
+```cpp
+void IRAM_ATTR buttonISR() {
+  // Signal StatusRequest from ISR (thread-safe)
+  ts.requestAction(&buttonPressed, TASK_SR_REQUEST_SIGNALCOMPLETE, 0, 0, 0, 0, 0);
+  isrTriggers++;
+}
+
+void IRAM_ATTR timerISR() {
+  // Change task interval from ISR (thread-safe)
+  ts.requestAction(&tBlink, TASK_REQUEST_SETINTERVAL, newInterval, 0, 0, 0, 0);
+}
+```
+
+### Safe Task Control from Worker Thread
+
+```cpp
+void workerThread(void* parameter) {
+  while (true) {
+    vTaskDelay(pdMS_TO_TICKS(3000));
+
+    // Safely adjust blink interval from worker thread
+    uint32_t newInterval = 300 + (counter % 5) * 100;
+    ts.requestAction(&tBlink, TASK_REQUEST_SETINTERVAL, newInterval, 0, 0, 0, 0);
+  }
+}
+```
+
+## Building and Running
+
+### PlatformIO
+
+```bash
+# Navigate to example directory
+cd lib/TaskScheduler/examples/Scheduler_example30_THREAD_SAFE
+
+# Build and upload
+pio run -t upload
+
+# Monitor serial output
+pio device monitor
+```
+
+### Arduino IDE
+
+1. Open `src/main.cpp` as a `.ino` file
+2. Install TaskScheduler library (version 3.8.0 or newer)
+3. Select ESP32 board
+4. Add to Arduino IDE preprocessor defines:
+   ```
+   -D_TASK_THREAD_SAFE
+   -D_TASK_STATUS_REQUEST
+   -D_TASK_TIMEOUT
+   -D_TASK_ISR_SUPPORT
+   ```
+5. Compile and upload
+
+## Serial Output Example
+
+```
+===========================================
+TaskScheduler Example 30: _TASK_THREAD_SAFE
+===========================================
+
+Task request queue created (size: 16)
+Button interrupt attached (press boot button)
+Hardware timer started (triggers every 7 seconds)
+Worker thread created
+
+--- System initialized ---
+Expected behavior:
+1. LED blinks at variable rate
+2. Press button for fast blink burst
+3. Timer ISR changes rate every 7s
+4. Worker thread adjusts rate every 3s
+5. All operations are thread-safe!
+
+[5123] Blink #10 (ISR triggers: 2, Thread updates: 1)
+Button pressed! Starting fast blink sequence...
+
+=== Statistics at 10000 ms ===
+Total blinks: 45
+ISR triggers: 2
+Thread updates: 3
+Current blink interval: 400 ms
+================================
+```
+
+## Configuration
+
+Adjust these constants in `main.cpp`:
+
+```cpp
+#define TS_QUEUE_LEN        16    // Request queue size (increase if overflow occurs)
+#define TS_ENQUEUE_WAIT_MS  10    // Max wait for enqueue (ms)
+#define TS_DEQUEUE_WAIT_MS  0     // No wait for dequeue
+```
+
+## Troubleshooting
+
+### Queue Overflow
+If you see "Failed to enqueue request" messages:
+- Increase `TS_QUEUE_LEN`
+- Increase `TS_ENQUEUE_WAIT_MS`
+- Reduce request frequency
+
+### Watchdog Timeouts
+If the ESP32 reboots with watchdog errors:
+- Ensure `ts.execute()` runs frequently in loop()
+- Check that no task blocks for too long
+- Reduce worker thread priority
+
+### Compilation Errors
+Ensure all compile flags are set in `platformio.ini`:
+- `_TASK_THREAD_SAFE` (required)
+- `_TASK_STATUS_REQUEST` (for button example)
+- `_TASK_ISR_SUPPORT` (for ESP ISR methods)
+
+## Learning Points
+
+### ✅ DO:
+- Always use `requestAction()` from ISRs and worker threads
+- Implement both enqueue and dequeue functions
+- Size the queue based on request frequency
+- Mark ISR functions with `IRAM_ATTR` (ESP32/ESP8266)
+
+### ❌ DON'T:
+- Call task methods directly from ISRs or other threads
+- Skip queue implementation (required for _TASK_THREAD_SAFE)
+- Forget to process requests (automatically done in `execute()`)
+- Block in ISRs waiting for queue space
+
+## Related Examples
+
+- **Example 27**: PlatformIO project structure
+- **Example 28**: Tickless operation with FreeRTOS
+- **Example 04/05**: StatusRequest basics
+
+## Further Reading
+
+- [TaskScheduler Wiki](https://github.com/arkhipenko/TaskScheduler/wiki)
+- TaskScheduler_THREAD_SAFE.md in your project root
+- FreeRTOS queue documentation
+- ESP32 interrupt handling
+
+## License
+
+Same as TaskScheduler library (see library LICENSE file)
+
+## Version
+
+Created for TaskScheduler v3.8.0+
+Updated for TaskScheduler v4.0.0 (October 2024)

package/examples/alteriom/.pio/libdeps/esp8266/TaskScheduler/examples/Scheduler_example30_THREAD_SAFE/platformio.ini

@@ -0,0 +1,44 @@
+; PlatformIO Project Configuration File
+;
+; TaskScheduler Example 30: _TASK_THREAD_SAFE
+;
+; This example demonstrates the use of _TASK_THREAD_SAFE compile option
+; for safe interaction with TaskScheduler from multiple threads and ISRs.
+;
+; Demonstrates:
+; - FreeRTOS queue implementation for request handling
+; - Safe task control from ISR context
+; - Safe task control from worker threads
+; - StatusRequest signaling from interrupts
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+[platformio]
+default_envs = esp32dev
+
+[env:esp32dev]
+platform = espressif32
+board = esp32dev
+framework = arduino
+
+[env]
+lib_deps =
+    arkhipenko/TaskScheduler @ ^4.0.0
+
+build_flags =
+    ; Core thread safety features
+    -D _TASK_THREAD_SAFE         ; Enable thread-safe operations
+    -D _TASK_HEADER_AND_CPP      ; Enable CPP compilation
+
+    ; Supporting features
+    -D _TASK_STATUS_REQUEST      ; Enable StatusRequest support
+    -D _TASK_TIMEOUT             ; Enable timeout support
+    -D _TASK_TIMECRITICAL        ; Enable timing diagnostics
+    -D _TASK_ISR_SUPPORT         ; Enable ISR-safe methods (ESP only)
+
+    ; Debug options
+    -D _DEBUG_
+
+monitor_speed = 115200
+upload_speed = 921600