@alteriom/painlessmesh 1.7.2 → 1.7.4

package/examples/alteriom/.pio/libdeps/esp32/TaskScheduler/examples/Scheduler_example23_IDLE_Callback/Scheduler_example23_IDLE_Callback.ino

@@ -0,0 +1,157 @@
+/*
+   An example of using scheduler's custom sleep callback method
+
+   An empty loop is executed for 10 seconds with a 10 ms. interval
+   The first time it is excuted with an empty sleep callback, and
+   the second time with a 1 ms delay in the custom callback
+
+  RESULTS:
+
+  Arduino Nano:
+=================================
+  Testing empty sleep callback...
+  cEmptyCallback=1001
+  cEmptyTotal=423866
+  Testing 1 ms delayed sleep callback...
+  cDelayCallback=1001
+  cDelayTotal=10669
+
+
+  ESP8266 at 80MHz
+=================================
+  Testing empty sleep callback...
+  cEmptyCallback=1001
+  cEmptyTotal=278101
+  Testing 1 ms delayed sleep callback...
+  cDelayCallback=1001
+  cDelayTotal=10493
+
+
+  ESP8266 at 160MHz
+=================================
+  Testing empty sleep callback...
+  cEmptyCallback=1001
+  cEmptyTotal=546041
+  Testing 1 ms delayed sleep callback...
+  cDelayCallback=1001
+  cDelayTotal=10746
+
+
+  Maple Mini STM32 board at 70MHz -O3 code optimization
+==================================
+  Testing empty sleep callback...
+  cEmptyCallback=1001
+  cEmptyTotal=2689973
+  Testing 1 ms delayed sleep callback...
+  cDelayCallback=1001
+  cDelayTotal=10958
+
+
+  esp32 at 240MHz
+==================================
+  Testing empty sleep callback...
+  cEmptyCallback=1001
+  cEmptyTotal=492851
+  Testing 1 ms delayed sleep callback...
+  cDelayCallback=1001
+  cDelayTotal=11002
+
+
+*/
+
+#define _TASK_SLEEP_ON_IDLE_RUN
+#include <TaskScheduler.h>
+
+Scheduler ts;
+
+// Callback methods prototypes
+void Count();
+bool tEmptyOn();
+void tEmptyOff();
+bool tDelayOn();
+void tDelayOff();
+
+// Sleep methods prototypes
+void sEmpty(unsigned long aT);
+void sDelay(unsigned long aT);
+
+// Tasks
+Task tCount ( 10, TASK_FOREVER, &Count, &ts, false );
+Task tEmpty ( 10000, TASK_ONCE, NULL, &ts, false, &tEmptyOn, &tEmptyOff );
+Task tDelay ( 10000, TASK_ONCE, NULL, &ts, false, &tDelayOn, &tDelayOff );
+
+
+volatile unsigned long cEmptyCallback, cEmptyTotal, cDelayCallback, cDelayTotal;
+volatile unsigned long *cCB, *cTL;
+
+void setup() {
+  Serial.begin(115200);
+  delay(5000);
+  Serial.println("Start counting...");
+  ts.setSleepMethod( &sEmpty );
+  tEmpty.restartDelayed();
+}
+
+
+void sEmpty(unsigned long aT) {
+}
+
+void sDelay(unsigned long aT) {
+  delay(1);
+}
+
+bool tEmptyOn() {
+  Serial.println("Testing empty sleep callback...");
+  cCB = &cEmptyCallback;
+  cTL = &cEmptyTotal;
+
+  *cCB = 0;
+  *cTL = 0;
+
+  tCount.restart();
+
+  return true;
+}
+
+void tEmptyOff() {
+  tCount.disable();
+
+  Serial.print("cEmptyCallback="); Serial.println(*cCB);
+  Serial.print("cEmptyTotal="); Serial.println(*cTL);
+
+  ts.setSleepMethod( &sDelay );
+  tDelay.restartDelayed();
+}
+
+
+bool tDelayOn() {
+  Serial.println("Testing 1 ms delayed sleep callback...");
+  cCB = &cDelayCallback;
+  cTL = &cDelayTotal;
+
+  *cCB = 0;
+  *cTL = 0;
+
+  tCount.restart();
+
+  return true;
+}
+
+void tDelayOff() {
+  tCount.disable();
+
+  Serial.print("cDelayCallback="); Serial.println(*cCB);
+  Serial.print("cDelayTotal="); Serial.println(*cTL);
+}
+
+void Count() {
+  (*cCB)++;
+}
+
+
+
+void loop() {
+  // put your main code here, to run repeatedly:
+  ts.execute();
+  (*cTL)++;
+}

package/examples/alteriom/.pio/libdeps/esp32/TaskScheduler/examples/Scheduler_example24_CPU_LOAD/Scheduler_example24_CPU_LOAD.ino

@@ -0,0 +1,87 @@
+
+/**
+   This sketch collects scheduling overhead and CPU Idle Sleep information.
+   A task is invoked every 10 milliseconds for 10 seconds.
+   CPU statistics are collected
+
+   Compile and run once with _TASK_SLEEP_ON_IDLE_RUN enabled, then with _TASK_SLEEP_ON_IDLE_RUN disabled.
+   Compare the results.
+*/
+
+#define _TASK_ESP8266_DLY_THRESHOLD 50L
+#define _TASK_ESP32_DLY_THRESHOLD 40L
+
+#define _TASK_SLEEP_ON_IDLE_RUN
+#define _TASK_TIMECRITICAL
+#include <TaskScheduler.h>
+
+Scheduler ts;
+
+// Callback methods prototypes
+void Count();
+bool tOn(); void tOff();
+
+// Tasks
+Task c(10, TASK_FOREVER, &Count, &ts);
+Task t(10000, TASK_ONCE, NULL, &ts, true, &tOn, &tOff);
+
+
+volatile unsigned long c1, c2;
+bool tOn() {
+  c1 = 0;
+  c2 = 0;
+  c.enable();
+
+  return true;
+}
+
+void tOff() {
+  c.disable();
+  unsigned long cpuTot = ts.getCpuLoadTotal();
+  unsigned long cpuCyc = ts.getCpuLoadCycle();
+  unsigned long cpuIdl = ts.getCpuLoadIdle();
+
+  Serial.print("Loop counts c1="); Serial.println(c1);
+  Serial.print("Task counts c2="); Serial.println(c2);
+  Serial.print("Total CPU time="); Serial.print(cpuTot); Serial.println(" micros");
+  Serial.print("Scheduling Overhead CPU time="); Serial.print(cpuCyc); Serial.println(" micros");
+  Serial.print("Idle Sleep CPU time="); Serial.print(cpuIdl); Serial.println(" micros");
+  Serial.print("Productive work CPU time="); Serial.print(cpuTot - cpuIdl - cpuCyc); Serial.println(" micros");
+  Serial.println();
+
+  float idle = (float)cpuIdl / (float)cpuTot * 100;
+  Serial.print("CPU Idle Sleep "); Serial.print(idle); Serial.println(" % of time.");
+
+  float prod = (float)(cpuIdl + cpuCyc) / (float)cpuTot * 100;
+  Serial.print("Productive work (not idle, not scheduling)"); Serial.print(100.00 - prod); Serial.println(" % of time.");
+
+}
+
+void setup() {
+  // put your setup code here, to run once:
+  Serial.begin(115200);
+  delay(1000);
+  Serial.println("CPU Time Measurement");
+  Serial.println("Start");
+
+  ts.startNow();
+  t.delay();
+  ts.cpuLoadReset();
+}
+
+void Count() {
+  c2++;  // number of task callback invocations
+
+  // Try different delay intervals to see CPU statistics change
+  //  delay(1);
+  //  delay(5);
+  //  delay(10);
+  //  delay(20);
+}
+
+
+void loop() {
+  // put your main code here, to run repeatedly:
+  ts.execute();
+  c1++;  // number of loop() cycles
+}

package/examples/alteriom/.pio/libdeps/esp32/TaskScheduler/examples/Scheduler_example25_SCHEDULER_CHAIN/Scheduler_example25_SCHEDULER_CHAIN.ino

@@ -0,0 +1,127 @@
+/*
+    TaskScheduler Example #25
+
+    Create 10 random Tasks. Prints the entire chain.
+    Then executes chain once printing the remaining chain from currently active task
+    Deletes all tasks afterwards
+*/
+
+// #define _TASK_TIMECRITICAL      // Enable monitoring scheduling overruns
+#define _TASK_SLEEP_ON_IDLE_RUN // Enable 1 ms SLEEP_IDLE powerdowns between tasks 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 (ESP8266 and ESP32 ONLY)
+// #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 dynamic callback method binding
+// #define _TASK_DEFINE_MILLIS     // Force forward declaration of millis() and micros() "C" style
+#define _TASK_EXPOSE_CHAIN      // Methods to access tasks in the task chain
+
+#include <TaskScheduler.h>
+#include <QueueArray.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
+
+
+// Scheduler
+Scheduler ts;
+
+void taskCallback();
+void cleanUp();
+
+Task tManager(6000, TASK_ONCE, &cleanUp, &ts, false);
+/*
+  Scheduling defines:
+  TASK_MILLISECOND
+  TASK_SECOND
+  TASK_MINUTE
+  TASK_HOUR
+  TASK_IMMEDIATE
+  TASK_FOREVER
+  TASK_ONCE
+  TASK_NOTIMEOUT
+*/
+
+int noOfTasks = 10;
+QueueArray <Task*> toDelete;
+
+void setup() {
+  // put your setup code here, to run once:
+#if defined(_DEBUG_) || defined(_TEST_)
+  Serial.begin(115200);
+  delay(2000);
+  _PL("Scheduler Example: Expose Scheduler Task Chain"); _PL();
+#endif
+
+  _PL("Generating a random chain of tasks");
+  for (int i = 0; i < noOfTasks; i++) {
+    long p = random(100, 5001); // from 100 ms to 5 seconds
+    long j = random(1, 11); // from 1 to 10 iterations)
+    Task *t = new Task(p, j, &taskCallback, &ts, false);
+    _PP(F("Generated a new task:\t")); _PP(t->getId()); _PP(F("\tInt, Iter = \t"));
+    _PP(p); Serial.print(", "); _PL(j);
+    if ( random(1, 100) > 50 ) {
+      t->enable();
+    }
+    else {
+      t->enableDelayed();
+    }
+    toDelete.push(t);
+  }
+  _PL();
+  _PL("Printing the entire chain");
+  Task* f = ts.getFirstTask();
+  Task* l = ts.getLastTask();
+  while (f) {
+    _PP("Task #"); _PL(f->getId());
+    f = f->getNextTask();
+  }
+  _PL();
+  tManager.enableDelayed();
+}
+
+
+void loop() {
+  ts.execute();
+}
+
+
+void taskCallback() {
+  _PP(millis());
+  _PP(": taskCallback() of task #");
+  Task* t = ts.getCurrentTask();
+  t->disable();
+  _PL(t->getId());
+  Task* l = ts.getLastTask();
+  while (t) {
+    _PP("#"); _PP(t->getId());
+    if (t->getNextTask() != NULL) _PP("->");
+    t = t->getNextTask();
+  }
+  _PL(); _PL();
+}
+
+void cleanUp() {
+    _PL("Deleting tasks:");
+  do {
+    Task* t = toDelete.pop();
+    _PP("Deleting task #"); _PL(t->getId());
+    delete t;
+  } while (!toDelete.isEmpty());
+
+  for (;;) ;
+}

package/examples/alteriom/.pio/libdeps/esp32/TaskScheduler/examples/Scheduler_example26_SCHEDULING_OPTIONS/Scheduler_example26_SCHEDULING_OPTIONS.ino

@@ -0,0 +1,181 @@
+/*
+    Example of scheduling options:
+
+    t1 - is a default option with priority given to schedule, i.e., scheduler tries
+         maintain original schedule and performs task "catch up" to ensure the number
+         of iterations that were supposed to happen do happen.
+
+    t2 - is an option with priority given to schedule, but without "catch up"
+         the scheduler will try to maintain original schedule, but next task invocation
+         is always scheduled to happen in the future 
+
+    t3 - is a option with priority given to interval. Task are scheduled always in the
+         future from the point of their current invocation start using task's interval.
+
+
+*/
+// ==== 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 =================================
+// #define _TASK_TIMECRITICAL         // Enable monitoring scheduling overruns
+// #define _TASK_SLEEP_ON_IDLE_RUN    // Enable 1 ms SLEEP_IDLE powerdowns between tasks 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 (ESP8266 and ESP32 ONLY)
+// #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 dynamic callback method binding
+// #define _TASK_DEFINE_MILLIS        // Force forward declaration of millis() and micros() "C" style
+// #define _TASK_EXPOSE_CHAIN         // Methods to access tasks in the task chain
+#define _TASK_SCHEDULING_OPTIONS    // Support for multiple scheduling options
+#include <TaskScheduler.h>
+
+
+
+// ==== GLOBALS ===================================================================================
+// ==== Scheduler ==============================
+Scheduler ts;
+
+void t1CB();
+void t2CB();
+void t3CB();
+
+// ==== Scheduling defines (cheat sheet) =====================
+/*
+  TASK_MILLISECOND
+  TASK_SECOND
+  TASK_MINUTE
+  TASK_HOUR
+  TASK_IMMEDIATE
+  TASK_FOREVER
+  TASK_ONCE
+  TASK_NOTIMEOUT
+
+  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 definitions ========================
+Task t1_schedule    (100 * TASK_MILLISECOND, 10, &t1CB, &ts);
+Task t2_schedule_nc (100 * TASK_MILLISECOND, 10, &t2CB, &ts);
+Task t3_interval    (100 * TASK_MILLISECOND, 10, &t3CB, &ts);
+
+
+
+// ==== 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(1000);
+  _PL("Scheduling Options: setup()");
+#endif
+
+  t2_schedule_nc.setSchedulingOption(TASK_SCHEDULE_NC);
+  t3_interval.setSchedulingOption(TASK_INTERVAL);
+
+
+  _PM("t1 start time");
+  t1_schedule.enable();
+  delay(10);
+  
+  _PM("t2 start time");
+  t2_schedule_nc.enable();
+  delay(10);
+
+  _PM("t3 start time");
+  t3_interval.enable();
+
+  delay(333);
+  _PM("333 ms delay ended");
+}
+
+
+/**************************************************************************/
+/*!
+    @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 t1CB() {
+  _PM("t1CB()");
+  //  task code
+  delay(10);
+}
+
+
+/**************************************************************************/
+/*!
+    @brief    Callback method of task2 - explain
+    @param    none
+    @returns  none
+*/
+/**************************************************************************/
+void t2CB() {
+  _PM("t2CB()");
+  //  task code
+  delay(10);
+}
+
+/**************************************************************************/
+/*!
+    @brief    Callback method of task3 - explain
+    @param    none
+    @returns  none
+*/
+/**************************************************************************/
+void t3CB() {
+  _PM("t3CB()");
+  //  task code
+  delay(10);
+}

package/examples/alteriom/.pio/libdeps/esp32/TaskScheduler/examples/Scheduler_example27_PlatformIO/include/README

@@ -0,0 +1,39 @@
+
+This directory is intended for project header files.
+
+A header file is a file containing C declarations and macro definitions
+to be shared between several project source files. You request the use of a
+header file in your project source file (C, C++, etc) located in `src` folder
+by including it, with the C preprocessing directive `#include'.
+
+```src/main.c
+
+#include "header.h"
+
+int main (void)
+{
+ ...
+}
+```
+
+Including a header file produces the same results as copying the header file
+into each source file that needs it. Such copying would be time-consuming
+and error-prone. With a header file, the related declarations appear
+in only one place. If they need to be changed, they can be changed in one
+place, and programs that include the header file will automatically use the
+new version when next recompiled. The header file eliminates the labor of
+finding and changing all the copies as well as the risk that a failure to
+find one copy will result in inconsistencies within a program.
+
+In C, the usual convention is to give header files names that end with `.h'.
+It is most portable to use only letters, digits, dashes, and underscores in
+header file names, and at most one dot.
+
+Read more about using header files in official GCC documentation:
+
+* Include Syntax
+* Include Operation
+* Once-Only Headers
+* Computed Includes
+
+https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html

package/examples/alteriom/.pio/libdeps/esp32/TaskScheduler/examples/Scheduler_example27_PlatformIO/include/led.h

@@ -0,0 +1,12 @@
+#ifndef _TS29_LED_H
+#define _TS29_LED_H
+
+// LED_BUILTIN  13
+#if defined( ARDUINO_ARCH_ESP32 )
+#define LED_BUILTIN  23 // esp32 dev2 kit does not have LED
+#endif
+
+void LEDOff();
+void LEDOn();
+
+#endif //   _TS27_LED_H

package/examples/alteriom/.pio/libdeps/esp32/TaskScheduler/examples/Scheduler_example27_PlatformIO/include/main.h

@@ -0,0 +1,25 @@
+#ifndef _TS29_MAIN_H
+#define _TS29_MAIN_H
+
+#ifdef _DEBUG_
+#define _PP(a) Serial.print(a);
+#define _PL(a) Serial.println(a);
+#else
+#define _PP(a)
+#define _PL(a)
+#endif
+
+#define PERIOD1 500
+#define DURATION 10000
+
+#define PERIOD2 400
+
+#define PERIOD3 300
+
+#define PERIOD4 200
+
+#define PERIOD5 600
+
+#define PERIOD6 300
+
+#endif

package/examples/alteriom/.pio/libdeps/esp32/TaskScheduler/examples/Scheduler_example27_PlatformIO/lib/README

@@ -0,0 +1,46 @@
+
+This directory is intended for project specific (private) libraries.
+PlatformIO will compile them to static libraries and link into executable file.
+
+The source code of each library should be placed in a an own separate directory
+("lib/your_library_name/[here are source files]").
+
+For example, see a structure of the following two libraries `Foo` and `Bar`:
+
+|--lib
+|  |
+|  |--Bar
+|  |  |--docs
+|  |  |--examples
+|  |  |--src
+|  |     |- Bar.c
+|  |     |- Bar.h
+|  |  |- library.json (optional, custom build options, etc) https://docs.platformio.org/page/librarymanager/config.html
+|  |
+|  |--Foo
+|  |  |- Foo.c
+|  |  |- Foo.h
+|  |
+|  |- README --> THIS FILE
+|
+|- platformio.ini
+|--src
+   |- main.c
+
+and a contents of `src/main.c`:
+```
+#include <Foo.h>
+#include <Bar.h>
+
+int main (void)
+{
+  ...
+}
+
+```
+
+PlatformIO Library Dependency Finder will find automatically dependent
+libraries scanning project source files.
+
+More information about PlatformIO Library Dependency Finder
+- https://docs.platformio.org/page/librarymanager/ldf.html