@alteriom/painlessmesh 1.7.3 → 1.7.4

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

@@ -0,0 +1,339 @@
+/**
+      This test illustrates the use if yield methods and internal StatusRequest objects
+      THIS TEST HAS BEEN TESTED ON NODEMCU V.2 (ESP8266)
+
+      The WiFi initialization and NTP update is executed in parallel to blinking the onboard LED
+      and an external LED connected to D2 (GPIO04)
+      Try running with and without correct WiFi parameters to observe the difference in behaviour
+*/
+
+#define _TASK_SLEEP_ON_IDLE_RUN
+#define _TASK_STATUS_REQUEST
+#include <TaskScheduler.h>
+
+#include <ESP8266WiFi.h>
+#include <WiFiUdp.h>
+
+Scheduler ts;
+
+// Callback methods prototypes
+void connectInit();
+void ledCallback();
+bool ledOnEnable();
+void ledOnDisable();
+void ledOn();
+void ledOff();
+void ntpUpdateInit();
+
+// Tasks
+
+Task  tConnect    (TASK_SECOND, TASK_FOREVER, &connectInit, &ts, true);
+Task  tLED        (TASK_IMMEDIATE, TASK_FOREVER, &ledCallback, &ts, false, &ledOnEnable, &ledOnDisable);
+
+// Tasks running on events
+Task  tNtpUpdate  (&ntpUpdateInit, &ts);
+
+// Replace with WiFi parameters of your Access Point/Router:
+const char *ssid  =  "wifi_network";
+const char *pwd   =  "wifi_password";
+
+long  ledDelayOn, ledDelayOff;
+
+#define LEDPIN            D0      // Onboard LED pin - linked to WiFi
+#define LEDPIN2           D2      // External LED
+#define CONNECT_TIMEOUT   30      // Seconds
+#define CONNECT_OK        0       // Status of successful connection to WiFi
+#define CONNECT_FAILED    (-99)   // Status of failed connection to WiFi
+
+// NTP Related Definitions
+#define NTP_PACKET_SIZE  48       // NTP time stamp is in the first 48 bytes of the message
+
+IPAddress     timeServerIP;       // time.nist.gov NTP server address
+const char*   ntpServerName = "time.nist.gov";
+byte          packetBuffer[ NTP_PACKET_SIZE]; //buffer to hold incoming and outgoing packets
+unsigned long epoch;
+
+WiFiUDP udp;                      // A UDP instance to let us send and receive packets over UDP
+
+#define LOCAL_NTP_PORT  2390      // Local UDP port for NTP update
+
+
+
+void setup() {
+  Serial.begin(74880);
+  Serial.println(F("TaskScheduler test #14 - Yield and internal StatusRequests"));
+  Serial.println(F("=========================================================="));
+  Serial.println();
+
+  pinMode (LEDPIN, OUTPUT);
+  pinMode (LEDPIN2, OUTPUT);
+
+  tNtpUpdate.waitFor( tConnect.getInternalStatusRequest() );  // NTP Task will start only after connection is made
+}
+
+void loop() {
+  ts.execute();                   // Only Scheduler should be executed in the loop
+}
+
+/**
+   Initiate connection to the WiFi network
+*/
+void connectInit() {
+  Serial.print(millis());
+  Serial.println(F(": connectInit."));
+  Serial.println(F("WiFi parameters: "));
+  Serial.print(F("SSID: ")); Serial.println(ssid);
+  Serial.print(F("PWD : ")); Serial.println(pwd);
+
+  WiFi.mode(WIFI_STA);
+  WiFi.hostname("esp8266");
+  WiFi.begin(ssid, pwd);
+  yield();
+
+  ledDelayOn = TASK_SECOND / 2;
+  ledDelayOff = TASK_SECOND / 4;
+  tLED.enable();
+
+  tConnect.yield(&connectCheck);            // This will pass control back to Scheduler and then continue with connection checking
+}
+
+/**
+   Periodically check if connected to WiFi
+   Re-request connection every 5 seconds
+   Stop trying after a timeout
+*/
+void connectCheck() {
+  Serial.print(millis());
+  Serial.println(F(": connectCheck."));
+
+  if (WiFi.status() == WL_CONNECTED) {                // Connection established
+    Serial.print(millis());
+    Serial.print(F(": Connected to AP. Local ip: "));
+    Serial.println(WiFi.localIP());
+    tConnect.disable();
+  }
+  else {
+
+    if (tConnect.getRunCounter() % 5 == 0) {          // re-request connection every 5 seconds
+
+      Serial.print(millis());
+      Serial.println(F(": Re-requesting connection to AP..."));
+
+      WiFi.disconnect(true);
+      yield();                                        // This is an esp8266 standard yield to allow linux wifi stack run
+      WiFi.hostname("esp8266");
+      WiFi.mode(WIFI_STA);
+      WiFi.begin(ssid, pwd);
+      yield();                                        // This is an esp8266 standard yield to allow linux wifi stack run
+    }
+
+    if (tConnect.getRunCounter() == CONNECT_TIMEOUT) {  // Connection Timeout
+      tConnect.getInternalStatusRequest()->signal(CONNECT_FAILED);  // Signal unsuccessful completion
+      tConnect.disable();
+
+      Serial.print(millis());
+      Serial.println(F(": connectOnDisable."));
+      Serial.print(millis());
+      Serial.println(F(": Unable to connect to WiFi."));
+
+      ledDelayOn = TASK_SECOND / 16;                  // Blink LEDs quickly due to error
+      ledDelayOff = TASK_SECOND / 16;
+      tLED.enable();
+    }
+  }
+}
+
+/**
+   Initiate NTP update if connection was established
+*/
+void ntpUpdateInit() {
+  Serial.print(millis());
+  Serial.println(F(": ntpUpdateInit."));
+
+  if ( tConnect.getInternalStatusRequest()->getStatus() != CONNECT_OK ) {  // Check status of the Connect Task
+    Serial.print(millis());
+    Serial.println(F(": cannot update NTP - not connected."));
+    return;
+  }
+
+  udp.begin(LOCAL_NTP_PORT);
+  if ( WiFi.hostByName(ntpServerName, timeServerIP) ) { //get a random server from the pool
+
+    Serial.print(millis());
+    Serial.print(F(": timeServerIP = "));
+    Serial.println(timeServerIP);
+
+    sendNTPpacket(timeServerIP); // send an NTP packet to a time server
+  }
+  else {
+    Serial.print(millis());
+    Serial.println(F(": NTP server address lookup failed."));
+    tLED.disable();
+    udp.stop();
+    tNtpUpdate.disable();
+    return;
+  }
+
+  ledDelayOn = TASK_SECOND / 8;
+  ledDelayOff = TASK_SECOND / 8;
+  tLED.enable();
+
+  tNtpUpdate.set( TASK_SECOND, CONNECT_TIMEOUT, &ntpCheck );
+  tNtpUpdate.enableDelayed();
+}
+
+/**
+ * Check if NTP packet was received
+ * Re-request every 5 seconds
+ * Stop trying after a timeout
+ */
+void ntpCheck() {
+  Serial.print(millis());
+  Serial.println(F(": ntpCheck."));
+
+  if ( tNtpUpdate.getRunCounter() % 5 == 0) {
+
+    Serial.print(millis());
+    Serial.println(F(": Re-requesting NTP update..."));
+
+    udp.stop();
+    yield();
+    udp.begin(LOCAL_NTP_PORT);
+    sendNTPpacket(timeServerIP);
+    return;
+  }
+
+  if ( doNtpUpdateCheck()) {
+    Serial.print(millis());
+    Serial.println(F(": NTP Update successful"));
+
+    Serial.print(millis());
+    Serial.print(F(": Unix time = "));
+    Serial.println(epoch);
+
+    tLED.disable();
+    tNtpUpdate.disable();
+    udp.stop();
+  }
+  else {
+    if ( tNtpUpdate.isLastIteration() ) {
+      Serial.print(millis());
+      Serial.println(F(": NTP Update failed"));
+      tLED.disable();
+      udp.stop();
+    }
+  }
+}
+
+/**
+ * Send NTP packet to NTP server
+ */
+void sendNTPpacket(IPAddress & address)
+{
+  Serial.print(millis());
+  Serial.println(F(": sendNTPpacket."));
+
+  // set all bytes in the buffer to 0
+  memset(packetBuffer, 0, NTP_PACKET_SIZE);
+  // Initialize values needed to form NTP request
+  // (see URL above for details on the packets)
+  packetBuffer[0] = 0b11100011;   // LI, Version, Mode
+  packetBuffer[1] = 0;     // Stratum, or type of clock
+  packetBuffer[2] = 6;     // Polling Interval
+  packetBuffer[3] = 0xEC;  // Peer Clock Precision
+  // 8 bytes of zero for Root Delay & Root Dispersion
+  packetBuffer[12]  = 49;
+  packetBuffer[13]  = 0x4E;
+  packetBuffer[14]  = 49;
+  packetBuffer[15]  = 52;
+
+  // all NTP fields have been given values, now
+  // you can send a packet requesting a timestamp:
+  udp.beginPacket(address, 123); //NTP requests are to port 123
+  udp.write(packetBuffer, NTP_PACKET_SIZE);
+  udp.endPacket();
+  yield();
+}
+
+/**
+ * Check if a packet was recieved.
+ * Process NTP information if yes
+ */
+bool doNtpUpdateCheck() {
+
+  Serial.print(millis());
+  Serial.println(F(": doNtpUpdateCheck."));
+
+  yield();
+  int cb = udp.parsePacket();
+  if (cb) {
+    // We've received a packet, read the data from it
+    udp.read(packetBuffer, NTP_PACKET_SIZE); // read the packet into the buffer
+
+    //the timestamp starts at byte 40 of the received packet and is four bytes,
+    // or two words, long. First, esxtract the two words:
+
+    unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
+    unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);
+    // combine the four bytes (two words) into a long integer
+    // this is NTP time (seconds since Jan 1 1900):
+    unsigned long secsSince1900 = highWord << 16 | lowWord;
+
+    // now convert NTP time into everyday time:
+    // Unix time starts on Jan 1 1970. In seconds, that's 2208988800:
+    const unsigned long seventyYears = 2208988800UL;
+    // subtract seventy years:
+    epoch = secsSince1900 - seventyYears;
+    return (epoch != 0);
+  }
+  return false;
+}
+
+/**
+ * Flip the LED state based on the current state
+ */
+bool ledState;
+void ledCallback() {
+  if ( ledState ) ledOff();
+  else ledOn();
+}
+
+/**
+ * Make sure the LED starts lit
+ */
+bool ledOnEnable() {
+  ledOn();
+  return true;
+}
+
+/**
+ * Make sure LED ends dimmed
+ */
+void ledOnDisable() {
+  ledOff();
+}
+
+/**
+ * Turn LEDs on. 
+ * Set appropriate delay.
+ * PLEASE NOTE: NodeMCU onbaord LED is active-low
+ */
+void ledOn() {
+  ledState = true;
+  digitalWrite(LEDPIN, LOW);
+  digitalWrite(LEDPIN2, HIGH);
+  tLED.delay( ledDelayOn );
+}
+
+/**
+ * Turn LEDs off. 
+ * Set appropriate delay.
+ * PLEASE NOTE: NodeMCU onbaord LED is active-low
+ */
+void ledOff() {
+  ledState = false;
+  digitalWrite(LEDPIN, HIGH);
+  digitalWrite(LEDPIN2, LOW);
+  tLED.delay( ledDelayOff );
+}
+

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

@@ -0,0 +1,53 @@
+/** 
+ * TaskScheduler Test sketch - Showing how to use std::function
+ * to get acces to variables from within the task callback function 
+ * 
+ * Support for std::function is only available for ESP8266 architecture
+ */
+#define _TASK_SLEEP_ON_IDLE_RUN
+#define _TASK_STD_FUNCTION   // Compile with support for std::function 
+#include <TaskScheduler.h>
+
+Scheduler ts;
+int counter = 0;
+
+class Calculator {
+public:
+    int cumSum = 0; // cumulative sum
+    Calculator(int b) {
+        // Pass the this pointer, so that we get access to this->cumSum
+        // Also pass a copy of b
+        calculateTask.set(TASK_SECOND, TASK_FOREVER, [this, b]() {
+            counter++;
+            Serial.printf("%u. %u: cumSum = %u + %u\t", counter, millis(), cumSum, b);
+            cumSum += b;
+            Serial.printf("Resulting cumulative sum: %u\n", cumSum);
+        });
+        ts.addTask(calculateTask);
+        calculateTask.enable();
+    }
+
+    Task calculateTask;
+};
+
+Calculator calc1(2);
+Calculator calc2(4);
+Calculator calc3(8);
+
+// Disable tasks after 10 seconds
+Task tWrapper(10*TASK_SECOND, TASK_ONCE, []() {
+    ts.disableAll();
+}, &ts); 
+
+/**
+ * Standard Arduino setup and loop methods
+ */
+void setup() {
+  Serial.begin(74880);
+  Serial.println("std::function test");
+  tWrapper.enableDelayed();
+}
+
+void loop() {
+  ts.execute();
+}

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

@@ -0,0 +1,18 @@
+//This file is intentionally left blank.
+//
+//Arduino IDE plays some dirty tricks on the main sketch .ino file:
+//it rearranges #includes, blindly creates forward definitions,
+//includes every file in the project that does not have .c or .cpp
+//file extension.
+//
+//Usually it all turns well if you have only one source file and you are either
+//inexperienced or really expert C++ Arduino programmer.
+//For the folks with the middle ground skills level, when you want
+//to split your code into several .cpp files, it is best to leave
+//this main sketch empty.
+//
+//It doesn't matter where you define the void loop() and void setup().
+//Just make sure there is exactly one definition of each.
+//
+//And if you want to use standard Arduino functions
+//like digitalWrite or the Serial object - just add #include<Arduino.h>.

package/examples/meshCommandNode/.pio/libdeps/esp32/TaskScheduler/examples/Scheduler_example16_Multitab/file1.cpp

@@ -0,0 +1,31 @@
+#include <Arduino.h>
+#include "header.hpp"
+
+
+//Declare the functions we want to use before we are ready to define them
+void t1Callback();
+
+
+// Tasks
+Task t1(2000, 10, &t1Callback, &runner, true);  //adding task to the chain on creation
+Task t3(5000, TASK_FOREVER, &t3Callback);
+
+
+void t1Callback() {
+    Serial.print("t1: ");
+    Serial.println(millis());
+
+    if (t1.isFirstIteration()) {
+      runner.addTask(t3);
+      t3.enable();
+      Serial.println("t1: enabled t3 and added to the chain");
+    }
+
+    if (t1.isLastIteration()) {
+      t3.disable();
+      runner.deleteTask(t3);
+      t2.setInterval(500);
+      Serial.println("t1: disable t3 and delete it from the chain. t2 interval set to 500");
+    }
+}
+

package/examples/meshCommandNode/.pio/libdeps/esp32/TaskScheduler/examples/Scheduler_example16_Multitab/file2.cpp

@@ -0,0 +1,55 @@
+// Test the same as example#2:
+// Initially only tasks 1 and 2 are enabled
+// Task1 runs every 2 seconds 10 times and then stops
+// Task2 runs every 3 seconds indefinitely
+// Task1 enables Task3 at its first run
+// Task3 run every 5 seconds
+// loop() runs every 1 second (a default scheduler delay, if no shorter tasks' interval is detected)
+// Task1 disables Task3 on its last iteration and changed Task2 to run every 1/2 seconds
+// Because Task2 interval is shorter than Scheduler default tick, loop() executes ecery 1/2 seconds now
+// At the end Task2 is the only task running every 1/2 seconds
+
+
+//Header that declares all shared objects between .cpp files
+#include "header.hpp"
+
+#include <Arduino.h> //for Serial and delay
+
+Scheduler runner; //Let the scheduler live here, in the main file, ok?
+
+
+//Pretend, that the t2 task is a special task,
+//that needs to live in file2 object file.
+void t2Callback() {
+    Serial.print("t2: ");
+    Serial.println(millis());
+}
+Task t2(3000, TASK_FOREVER, &t2Callback, &runner, true);
+
+//Lets define t3Callback here. We are going to use it in file1
+//for Task 1.
+void t3Callback() {
+    Serial.print("t3: ");
+    Serial.println(millis());
+}
+
+
+
+
+
+
+void setup () {
+  Serial.begin(115200);
+  delay(5000);
+  Serial.println("Scheduler TEST (multi-tab)");
+
+  runner.startNow();  // set point-in-time for scheduling start
+}
+
+
+void loop () {
+  runner.execute();
+
+//  Serial.println("Loop ticks at: ");
+//  Serial.println(millis());
+}

package/examples/meshCommandNode/.pio/libdeps/esp32/TaskScheduler/examples/Scheduler_example16_Multitab/header.hpp

@@ -0,0 +1,15 @@
+//This is the place to declare every single function
+//and global variable that is going to be reused between cpp files.
+
+
+//We are going to use the TaskScheduler, but only the declarations part.
+//Remember to put customization macros before the #include:
+#define _TASK_SLEEP_ON_IDLE_RUN
+#include <TaskSchedulerDeclarations.h>
+
+//Let the runner object be a global, single instance shared between object files.
+extern Scheduler runner;
+extern Task t2; //the t2 is defined in file2, but we need to access it from file1.
+
+//This function needs to be shared (between file2 and file1).
+void t3Callback();

package/examples/meshCommandNode/.pio/libdeps/esp32/TaskScheduler/examples/Scheduler_example16_Multitab/ts.cpp

@@ -0,0 +1,20 @@
+//This is the only .cpp file that gets the #include<TaskScheduler.h>.
+//Without it, the linker would not find necessary TaskScheduler's compiled code.
+//
+//Remember to put customization macros here as well.
+//
+//And don't import any common headers (here: header.hpp)
+//
+//Really. This file needs to be short. All stuff is in TaskScheduler.h.
+
+//  #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 
+//  #define _TASK_DEBUG             // Make all methods and variables public for debug purposes
+
+#include <TaskScheduler.h>

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

@@ -0,0 +1,90 @@
+/*
+    This eaxmple illustrates the use of overall Task timeout functionality:
+
+    Task 1 - runs every 1 seconds and times out in 10 seconds
+    Task 2 - runs every 5 seconds and resets the timeout every run, so runs continuosly even though the timeout is set to 10 seconds
+*/
+
+
+// #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 
+// #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
+
+#include <TaskScheduler.h>
+
+Scheduler ts;
+
+void task1Callback();
+void task1OnDisable();
+void task2Callback();
+void task2OnDisable();
+
+Task t1(1 * TASK_SECOND, TASK_FOREVER, &task1Callback, &ts, false, NULL, &task1OnDisable);
+Task t2(5 * TASK_SECOND, TASK_FOREVER, &task2Callback, &ts, false, NULL, &task2OnDisable);
+
+void setup() {
+  // put your setup code here, to run once:
+  Serial.begin(115200);
+
+  Serial.println("TaskScheduler Timeout example");
+  Serial.println("=============================");
+
+  t1.setTimeout(10 * TASK_SECOND);
+  t2.setTimeout(10 * TASK_SECOND);
+
+  ts.enableAll();
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+  ts.execute();
+}
+
+
+void task1Callback() {
+  Serial.print("Task 1:\t");
+  Serial.print(millis());
+  Serial.print(": t/out=");
+  Serial.print(t1.getTimeout());
+  Serial.print("\tms until t/out=");
+  Serial.println( t1.untilTimeout());
+
+}
+void task1OnDisable() {
+  if (t1.timedOut()) {
+    Serial.println("Task 1 has timed out. Restarting");
+    t1.setInterval(1 * TASK_SECOND);
+    t1.setIterations(15);
+    t1.setTimeout(TASK_NOTIMEOUT);
+    t1.enable(); 
+  }
+  else {
+    Serial.println("Task 1 has been disabled");
+  }
+}
+
+void task2Callback() {
+  Serial.print("Task 2:\t");
+  Serial.print(millis());
+  Serial.print(": t/out=");
+  Serial.print(t2.getTimeout());
+  Serial.print("\tms until t/out=");
+  Serial.println( t2.untilTimeout());
+  t2.resetTimeout();
+}
+void task2OnDisable() {
+  if (t2.timedOut()) {
+    Serial.println("Task 2 has timed out");
+  }
+  else {
+    Serial.println("Task 2 has been disabled");
+  }
+}