@alteriom/painlessmesh 1.7.4 → 1.7.6

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

@@ -1,181 +0,0 @@
-/** This test emulates querying 3 sensors once every 10 seconds, each could respond with a different delay
- *    (ultrasonic sensors for instance) and printing a min value of the three when all three have reported their values.
- *    The overall timeout of 1 second is setup as well.
- *    An error message needs to be printed if a timeout occurred instead of a value.
- */
-
-
-#define _TASK_SLEEP_ON_IDLE_RUN
-#define _TASK_STATUS_REQUEST
-#include <TaskScheduler.h>
-
-#ifdef ARDUINO_ARCH_STM32F1
-#define A0	3
-#endif
-
-StatusRequest measure;
-
-Scheduler ts; 
-
-// Callback methods prototypes
-void CycleCallback();
-void MeasureCallback(); 
-bool MeasureEnable();
-void MeasureDisable();
-void CalcCallback();
-void S1Callback(); bool S1Enable();
-void S2Callback(); bool S2Enable();
-void S3Callback(); bool S3Enable();
-
-// Tasks
-Task tCycle(10000, TASK_FOREVER, &CycleCallback, &ts, true);
-Task tMeasure(1000, TASK_ONCE, &MeasureCallback, &ts, false, &MeasureEnable, &MeasureDisable);
-Task tCalculate(&CalcCallback, &ts);
-Task tSensor1(0, TASK_ONCE, &S1Callback, &ts, false, &S1Enable);
-Task tSensor2(0, TASK_ONCE, &S2Callback, &ts, false, &S2Enable);
-Task tSensor3(0, TASK_ONCE, &S3Callback, &ts, false, &S3Enable);
-
-
-long distance, d1, d2, d3;
-
-void CycleCallback() {
-  Serial.println("CycleCallback: Initiating measurement cycle every 10 seconds");
-
-  tMeasure.restartDelayed();
-}
-
-
-
-bool MeasureEnable() {
-  Serial.println("MeasureEnable: Activating sensors");  
-
-  distance = 0;
-  measure.setWaiting(3); // Set the StatusRequest to wait for 3 signals. 
-  tCalculate.waitFor(&measure);
-
-  tSensor1.restartDelayed();
-  tSensor2.restartDelayed();
-  tSensor3.restartDelayed();
-
-  return true;
-}
-
-void MeasureCallback() {
-  Serial.println("MeasureCallback: Invoked by calculate task or one second later");  
-
-  if (measure.pending()) {
-    tCalculate.disable();
-    measure.signalComplete(-1);  // signal error
-    Serial.println("MeasureCallback: Timeout!");
-  }
-  else {
-    Serial.print("MeasureCallback: Min distance=");Serial.println(distance);
-  }
-}
-
-void MeasureDisable() {
-  Serial.println("MeasureDisable: Cleaning up");  
-  
-  tSensor1.disable();
-  tSensor2.disable();
-  tSensor3.disable();
-}
-
-
-void CalcCallback() {
-  Serial.println("CalcCallback: calculating");  
-  distance = -1;
-  if ( measure.getStatus() >= 0) {  // only calculate if statusrequest ended successfully
-    distance = d1 < d2 ? d1 : d2;
-    distance = d3 < distance ? d3 : distance;
-    tMeasure.forceNextIteration();
-  }
-}
-
-
-/** Simulation code for sensor 1
- *  ----------------------------
- */
-bool S1Enable() {
-  Serial.print("S1Enable: Triggering sensor1. Delay=");  
-
-  tSensor1.setInterval( random(1200) );  // Simulating sensor delay, which could go over 1 second and cause timeout
-  d1 = 0;
-  
-  Serial.println( tSensor1.getInterval() );
-  return true;
-}
-
-void S1Callback() {
-  Serial.print("S1Callback: Emulating measurement. d1=");  
-  d1 = random(501); // pick a value from 0 to 500 "centimeters" simulating a measurement 
-  measure.signal();
-  
-  Serial.println(d1); 
-}
-
-
-/** Simulation code for sensor 2
- *  ----------------------------
- */
-bool S2Enable() {
-  Serial.print("S2Enable: Triggering sensor2. Delay=");  
-
-  tSensor2.setInterval( random(1200) );  // Simulating sensor delay, which could go over 1 second and cause timeout
-  d2 = 0;
-
-  Serial.println( tSensor2.getInterval() );
-  return true;
-}
-
-void S2Callback() {
-  Serial.print("S2Callback: Emulating measurement. d2=");  
-  d2 = random(501); // pick a value from 0 to 500 "centimeters" simulating a measurement
-  measure.signal();
-
-  Serial.println(d2);  
-}
-
-
-/** Simulation code for sensor 3
- *  ----------------------------
- */
-bool S3Enable() {
-  Serial.print("S3Enable: Triggering sensor3. Delay=");  
-
-  tSensor3.setInterval( random(1200) );  // Simulating sensor delay, which could go over 1 second and cause timeout
-  d3 = 0;
-
-  Serial.println( tSensor3.getInterval() );
-  return true;
-}
-
-void S3Callback() {
-  Serial.print("S3Callback: Emulating measurement. d3=");  
-  d3 = random(501); // pick a value from 0 to 500 "centimeters" simulating a measurement
-  measure.signal();
-  
-  Serial.println(d3); 
-}
-
-
-/** Main Arduino code
- *  Not much is left here - everything is taken care of by the framework
- */
-void setup() {
-
-  Serial.begin(115200);
-  Serial.println("TaskScheduler StatusRequest Sensor Emulation Test. Complex Test.");  
-  
-#ifdef ARDUINO_ARCH_STM32F1
-  pinMode(A0, INPUT_ANALOG);
-#endif
-  
-  randomSeed(analogRead(A0)+millis());
-}
-
-void loop() {
-  
-  ts.execute();
-
-}

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

@@ -1,117 +0,0 @@
-
-/**
- * This is a test to prove that processor really goes into IDLE sleep.
- * For this setup:
- * 
- *
- 
-Task c(10, -1, &Count, &ts);
-Task t(10000, 1, NULL, &ts, true, &tOn, &tOff);
-
-The result are:
-
-1): With #define _TASK_SLEEP_ON_IDLE_RUN enabled
-On Arduino Uno:
-  Start
-  c1=10771 - v2.5.0 (v1.9.0: same)
-  c2=1001
-
-On Teensy 3.5 (120MHz ARM):
-  Start
-  c1=21065
-  c2=1001
-
-On esp8266 (80 MHz)
-  Start
-  c1=10492
-  c2=1001
-  
-On STM32F103RCBT6 (Maple Mini @72 MHz)
-  Start
-  c1=21004
-  c2=1001
-
-and
-
-2): With #define _TASK_SLEEP_ON_IDLE_RUN disabled (commented out)
-Arduino Uno:
-  Start
-  c1=722426 - v3.0.2
-  c1=635735 - v2.5.0  
-  c1=551947 - v1.9.0
-  c2=1001
-
-On Teensy 3.5 (120MHz ARM):
-  Start
-  c1=2690322
-  c2=1001
-
-On esp8266 (80 MHz)
-  Start
-  c1=351085 (689833 at 160Mhz)
-  c2=1001
-  
-On STM32F103RCBT6 (Maple Mini @72 MHz)
-  Start
-  c1=4665019
-  c2=1001
-  
-C1 in scenario 2) is much higher than in scenario 1) because processor is put to sleep for 1), but not for 2)
-
- */
-
-
-/**
- * Compile and run once with _TASK_SLEEP_ON_IDLE_RUN enabled, then with _TASK_SLEEP_ON_IDLE_RUN disabled.
- * Compare the results.
- */
- 
-//#define _TASK_SLEEP_ON_IDLE_RUN
-#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();
-  Serial.print("c1=");Serial.println(c1);
-  Serial.print("c2=");Serial.println(c2);
-}
-
-void setup() {
-  // put your setup code here, to run once:
-  Serial.begin(115200);
-  delay(1000);
-  Serial.println("Start");
-
-  ts.startNow();
-  t.delay();
-}
-
-void Count() {
-  c2++;
-}
-
-
-void loop() {
-  // put your main code here, to run repeatedly:
-  ts.execute();
-  c1++;
-}

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

@@ -1,133 +0,0 @@
-/** 
- *  TaskScheduler Test sketch - use of task IDs and watchdog timer to identify hung tasks
- *  THIS SKETCH RUNS ON AVR BOARDS ONLY
- *  Test case: 
- *    Watchdog timer is set to 2 seconds (interrupt + reset)
- *    A hearbeat task (resetting the watchdog timer) is scheduled with 500 ms interval
- *    A number of tasks are running every 1 second and "rolling the dice" 0..19.  If 5, task is made to enter infinite loop
- *    Device should reset in 2 seconds after a task enters infinite loop
- *    A task id and a control point number are saved to EEPROM prior to device reset, and are displayed after reboot.
- *    In real life, device might chose to NOT activate certain tasks which failed previously (failed sensors for instance)
- */
-
-#define _TASK_SLEEP_ON_IDLE_RUN
-#define _TASK_WDT_IDS
-#include <TaskScheduler.h>
-
-#include <EEPROM.h>
-#include <avr/wdt.h>
-
-Scheduler ts;
-
-// Callback methods prototypes
-void TaskCB(); 
-void HB(); bool HBOn(); void HBOff();
-
-// Three tasks emulating accidental infinite loop
-Task tTask1(TASK_SECOND, TASK_FOREVER, &TaskCB, &ts, true);
-Task tTask2(TASK_SECOND, TASK_FOREVER, &TaskCB, &ts, true);
-Task tTask3(TASK_SECOND, TASK_FOREVER, &TaskCB, &ts, true);
-
-// Heartbeat task - resetting the watchdog timer periodically
-// Initiates WDT on enable, and deactivates it on disable
-Task tHB(500, TASK_FOREVER, &HB, &ts, false, &HBOn, &HBOff);
-
-/**
- * Emulating task callback function
- *   Prints task id and randomly "hangs" in two places.
- *   Control points are stored on the task prior to section which might hang,
- *   making this information available to the WDT interrupt handler
- */
-void TaskCB() {
-  Task& T = ts.currentTask();
-  
-  Serial.print("Task #:"); 
-  Serial.print(T.getId()); 
-  Serial.print(" current iteration = "); 
-  Serial.println(T.getRunCounter());
-
-// Hang if random number between 0 and 19 is 5 (5% probability)
-  T.setControlPoint(10);
-  if (random(20) == 5) for(;;);
-  
-// Hang if random number between 0 and 99 is more that 95 (5% probability)
-  T.setControlPoint(95);
-  if (random(100) > 94) for(;;);
-}
-
-/**
- * This On Enable method sets up the WDT
- * for interrupt and reset after 2 seconds
- */
-bool HBOn() {
-  
-  //disable interrupts
-  cli();
-  //reset watchdog
-  wdt_reset();
-  //set up WDT interrupt
-  WDTCSR = (1<<WDCE)|(1<<WDE);
-  //Start watchdog timer with aDelay prescaller
-  WDTCSR = (1<<WDIE)|(1<<WDE)|(WDTO_2S & 0x2F);
-//  WDTCSR = (1<<WDIE)|(WDTO_2S & 0x2F);  // interrupt only without reset
-  //Enable global interrupts
-  sei();
-}
-
-/**
- * This On Disable method disables WDT
- */
-void HBOff() {
-  wdt_disable();
-}
-
-/**
- * This is a periodic reset of WDT
- */
-void HB() {
-  wdt_reset();
-
-}
-
-/**
- * Watchdog timeout ISR
- * 
- */
-ISR(WDT_vect)
-{
-  Task& T = ts.currentTask();
-
-  digitalWrite(13, HIGH);
-  EEPROM.write(0, (byte)T.getId());
-  EEPROM.write(1, (byte)T.getControlPoint());
-  digitalWrite(13, LOW);
-}
-
-/**
- * Standard arduino setup routine
- */
-void setup() {
-  
-  Serial.begin(115200);
-
-  randomSeed(analogRead(0)+analogRead(5));
-  
-  pinMode(13, OUTPUT);
-  digitalWrite(13, LOW); 
-  
- 
-  Serial.println("WDT heartbeat test");
-  Serial.print("Last task before reset="); Serial.println(EEPROM.read(0));
-  Serial.print("Last control point before reset="); Serial.println(EEPROM.read(1));
-  
-  delay(2000);
-
-  tHB.enableDelayed();
-}
-
-/**
- * Not much is left for the loop()
- */
-void loop() {
-  ts.execute();
-}

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

@@ -1,147 +0,0 @@
-/** 
- *  TaskScheduler Test sketch - use of task's Local Task Storage pointer
- *  Test case: 
- *    Overall test runs for 5 seconds
- *    A number of calculator tasks run every one second, and update their respective variables using Local Task Storage pointer
- *    All calculator tasks use the same callback code, which obtains reference to appropriate variables via LTS pointer
- *    Calculaotr tasks perform simple calculation (as an example):
- *      adding task id number to itself
- *      multiplying task id number by 10
- *      
- *  Upon completion of the overall test, all results are printed out.
- *  Test could be repeated with various number of calculator tasks. 
- *  All that needs to change is data definitions - code is completely agnostic of number of tasks
- */
- 
-#define _TASK_SLEEP_ON_IDLE_RUN  // Compile with support for entering IDLE SLEEP state for 1 ms if not tasks are scheduled to run
-#define _TASK_WDT_IDS           // Compile with support for Task IDs and Watchdog timer
-#define _TASK_LTS_POINTER       // Compile with support for Local Task Storage pointer
-#include <TaskScheduler.h>
-
-// Overall number of calculator tasks:
-#define NO_TASKS  3
-
-Scheduler ts;
-
-// Callback methods prototypes
-void Calculate(); bool CalcOn();
-bool WrapperOn(); void WrapperOff(); 
-
-// Tasks
-// Calculator tasks.
-// Note that all three tasks use the same callback methods
-// They will be updating specific variables based on the
-// Locat Task Storage pointers 
-Task t1(TASK_SECOND, TASK_FOREVER, &Calculate, &ts, false, &CalcOn); 
-Task t2(TASK_SECOND, TASK_FOREVER, &Calculate, &ts, false, &CalcOn); 
-Task t3(TASK_SECOND, TASK_FOREVER, &Calculate, &ts, false, &CalcOn);
-// add more calc tasks here if necessary
-
-Task tWrapper(5*TASK_SECOND, TASK_ONCE, NULL, &ts, false, &WrapperOn, &WrapperOff); 
-
-// The below structure is an object referenced by LTS pointer
-typedef struct {
-  unsigned int id;
-  long         sum;
-  long         product;
-} task_var;
-
-// These are actual structures which hold tasks specific values
-task_var v1;
-task_var v2; 
-task_var v3; 
-
-// Arrays below allow indexed access to specific tasks and tasks variables
-Task     *tasks[] = { &t1, &t2, &t3 };
-task_var *vars[]  = { &v1, &v2, &v3 };
-
-
-/**
- * This method is called when a wrapper task is enabled
- * The purpose is to supply LTS pointers to all the tasks
- */
-bool WrapperOn() {
-
-  for (int i=0; i < NO_TASKS; i++) {
-    Task& T = *tasks[i];
-    T.setLtsPointer( vars[i] );
-    T.enableDelayed();
-  }
-  
-  return true;  // Signal that Task could be enabled
-}
-
-/**
- * This method is called when Wrapper task is disabled (after first and only iteration is executed)
- * For each of the calculor tasks the results are printed out. 
- */
-void WrapperOff() {
-  Serial.println("Finished processing");
-  
-  ts.disableAll();
-  
-  for (int i=0; i < NO_TASKS; i++) {
-    Serial.print("ID: "); Serial.println(vars[i]->id);
-    Serial.print("Sum: "); Serial.println(vars[i]->sum);
-    Serial.print("Product: "); Serial.println(vars[i]->product);
-    Serial.println();
-  }
-}
-
-
-/**
- * This method is executed when each calculator task is enabled
- * The purpose is to initiate all local variables
- */
-bool CalcOn() {
-  Task& T = ts.currentTask();
-  task_var& var = *((task_var*) T.getLtsPointer());
-  
-// Initialize local variables
-  var.id = T.getId();
-  var.sum = 0;
-  var.product = var.id;  
-  
-  return true;
-}
-
-
-/**
- * This method performs simple calculations on task's local variables
- */
-void Calculate() {
-  Task& T = ts.currentTask();
-// Another way to get to LTS pointer:  
-  task_var& var = *((task_var*) ts.currentLts());
-
-
-  Serial.print("Calculating for task: ");
-  Serial.print(T.getId());
-  Serial.print("; Task id per LTS is: ");
-  Serial.println( var.id );
-  
-  var.sum += T.getId();
-  var.product = var.product * 10;
-  
-}
-
-
-/**
- * Standard Arduino setup and loop methods
- */
-void setup() {
-  Serial.begin(115200);
-
-  randomSeed(analogRead(0)+analogRead(5));
-  
-  pinMode(13, OUTPUT);
-  digitalWrite(13, LOW); 
- 
-  Serial.println("Local Task Storage pointer test");
-
-  tWrapper.enableDelayed();
-}
-
-void loop() {
-  ts.execute();
-}

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

@@ -1,57 +0,0 @@
-/** 
- *  TaskScheduler Test
- *  Illustration of use of Time Critical Information
- *
- *  Task1 runs every 1 second indefinitely
- *  On each run it reports how delayed the invokation of the callback method was,
- *  and what was the scheduling overun.
- *  Each run task 1 is dealyed randomly for up to 2 seconds, thus simulating scheduling overrun
- */
- 
- #define _TASK_TIMECRITICAL
- #define _TASK_SLEEP_ON_IDLE_RUN
-#include <TaskScheduler.h>
-
-// Callback methods prototypes
-void t1Callback();
-
-
-//Tasks
-Task t1(1000, -1, &t1Callback);
-
-Scheduler runner;
-
-
-void t1Callback() {
-    Serial.print(millis());
-    Serial.print(": overrun = ");
-    Serial.print(t1.getOverrun());
-    Serial.print(", start delayed by ");
-    Serial.println(t1.getStartDelay());
-    
-    int i = random(2000); 
-    Serial.print("Delaying for "); Serial.println(i);
-    delay(i);
-}
-
-void setup () {
-  Serial.begin(115200);
-  Serial.println("Scheduler TimeCritical TEST");
-  
-  runner.init();
-  Serial.println("Initialized scheduler");
-  
-  runner.addTask(t1);
-  Serial.println("added t1. Waiting for 5 seconds.");
-  
-  delay(5000);
-  
-  t1.enable();
-
-  Serial.println("Enabled t1");
-}
-
-
-void loop () {
-  runner.execute();
-}