@alteriom/painlessmesh 1.6.1

package/examples/alteriom/alteriom_sensor_node.ino

@@ -0,0 +1,184 @@
+//************************************************************
+// Alteriom Sensor Node Example
+//
+// This example demonstrates how to create an Alteriom-specific
+// sensor node using custom packages with painlessMesh
+//************************************************************
+
+#include "alteriom_sensor_package.hpp"
+#include "painlessMesh.h"
+
+#define MESH_PREFIX "AlteriomMesh"
+#define MESH_PASSWORD "somethingSneaky"
+#define MESH_PORT 5555
+
+Scheduler userScheduler;  // to control your personal task
+painlessMesh mesh;
+
+// Alteriom package handlers
+using namespace alteriom;
+
+// User stub
+void sendSensorData();
+void handleIncomingPackage(uint32_t from, String& msg);
+void handleCommandPackage(CommandPackage& cmd);
+void handleStatusRequest();
+
+Task taskSendSensorData(30000, TASK_FOREVER, &sendSensorData);
+Task taskSendStatus(60000, TASK_FOREVER, &handleStatusRequest);
+
+void setup() {
+  Serial.begin(115200);
+
+  // Initialize mesh
+  mesh.setDebugMsgTypes(ERROR | MESH_STATUS | CONNECTION | SYNC |
+                        COMMUNICATION | GENERAL | MSG_TYPES | REMOTE);
+  mesh.init(MESH_PREFIX, MESH_PASSWORD, &userScheduler, MESH_PORT);
+  mesh.onReceive(&handleIncomingPackage);
+  mesh.onNewConnection(&newConnectionCallback);
+  mesh.onChangedConnections(&changedConnectionCallback);
+  mesh.onNodeTimeAdjusted(&nodeTimeAdjustedCallback);
+
+  // Add tasks
+  userScheduler.addTask(taskSendSensorData);
+  taskSendSensorData.enable();
+
+  userScheduler.addTask(taskSendStatus);
+  taskSendStatus.enable();
+
+  // Initialize sensors (placeholder)
+  Serial.println("Alteriom Sensor Node initialized");
+}
+
+void loop() { mesh.update(); }
+
+void sendSensorData() {
+  // Create sensor package
+  SensorPackage sensorData;
+  sensorData.from = mesh.getNodeId();
+  sensorData.sensorId = mesh.getNodeId();  // Use node ID as sensor ID
+  sensorData.timestamp = mesh.getNodeTime();
+
+  // Read sensor values (placeholder - replace with actual sensor readings)
+  sensorData.temperature =
+      23.5 + random(-50, 50) / 10.0;  // Simulate temperature
+  sensorData.humidity = 45.0 + random(-100, 100) / 10.0;   // Simulate humidity
+  sensorData.pressure = 1013.25 + random(-50, 50) / 10.0;  // Simulate pressure
+  sensorData.batteryLevel = 85 + random(-20, 15);          // Simulate battery
+
+  // Serialize and send
+  DynamicJsonDocument doc(sensorData.jsonObjectSize());
+  JsonObject obj = doc.to<JsonObject>();
+  sensorData.addTo(std::move(obj));
+
+  String msg;
+  serializeJson(doc, msg);
+  mesh.sendBroadcast(msg);
+
+  Serial.printf("Sent sensor data: T=%.1f, H=%.1f, P=%.1f, Bat=%d%%\n",
+                sensorData.temperature, sensorData.humidity,
+                sensorData.pressure, sensorData.batteryLevel);
+}
+
+void handleStatusRequest() {
+  StatusPackage status;
+  status.from = mesh.getNodeId();
+  status.deviceStatus = 0x01;  // Device operational
+  status.uptime = millis() / 1000;
+  status.freeMemory = ESP.getFreeHeap() / 1024;  // KB
+  status.wifiStrength = 75;                      // Placeholder
+  status.firmwareVersion = "1.0.0-alteriom";
+
+  // Serialize and send
+  DynamicJsonDocument doc(status.jsonObjectSize());
+  JsonObject obj = doc.to<JsonObject>();
+  status.addTo(std::move(obj));
+
+  String msg;
+  serializeJson(doc, msg);
+  mesh.sendBroadcast(msg);
+
+  Serial.printf("Sent status: uptime=%ds, mem=%dKB\n", status.uptime,
+                status.freeMemory);
+}
+
+void handleIncomingPackage(uint32_t from, String& msg) {
+  Serial.printf("Received from %u: %s\n", from, msg.c_str());
+
+  // Parse the JSON message
+  DynamicJsonDocument doc(1024);
+  deserializeJson(doc, msg);
+  JsonObject obj = doc.as<JsonObject>();
+
+  // Check message type
+  uint8_t msgType = obj["type"];
+
+  switch (msgType) {
+    case 200:  // SensorPackage
+    {
+      SensorPackage receivedSensor(obj);
+      Serial.printf("Sensor data from %u: T=%.1f, H=%.1f\n",
+                    receivedSensor.from, receivedSensor.temperature,
+                    receivedSensor.humidity);
+      // Process sensor data (store, forward, analyze, etc.)
+    } break;
+
+    case 201:  // CommandPackage
+    {
+      CommandPackage receivedCmd(obj);
+      if (receivedCmd.dest == mesh.getNodeId()) {
+        handleCommandPackage(receivedCmd);
+      }
+    } break;
+
+    case 202:  // StatusPackage
+    {
+      StatusPackage receivedStatus(obj);
+      Serial.printf("Status from %u: uptime=%ds, mem=%dKB, fw=%s\n",
+                    receivedStatus.from, receivedStatus.uptime,
+                    receivedStatus.freeMemory,
+                    receivedStatus.firmwareVersion.c_str());
+    } break;
+
+    default:
+      Serial.printf("Unknown message type: %d\n", msgType);
+      break;
+  }
+}
+
+void handleCommandPackage(CommandPackage& cmd) {
+  Serial.printf("Received command %d for device %u\n", cmd.command,
+                cmd.targetDevice);
+
+  // Process different command types
+  switch (cmd.command) {
+    case 1:  // Reset command
+      Serial.println("Reset command received");
+      // Implement reset logic
+      break;
+
+    case 2:  // Configuration update
+      Serial.printf("Config update: %s\n", cmd.parameters.c_str());
+      // Parse and apply configuration
+      break;
+
+    case 3:  // Data request
+      Serial.println("Data request received");
+      sendSensorData();  // Send current sensor data
+      break;
+
+    default:
+      Serial.printf("Unknown command: %d\n", cmd.command);
+      break;
+  }
+}
+
+void newConnectionCallback(uint32_t nodeId) {
+  Serial.printf("New Connection, nodeId = %u\n", nodeId);
+}
+
+void changedConnectionCallback() { Serial.printf("Changed connections\n"); }
+
+void nodeTimeAdjustedCallback(int32_t offset) {
+  Serial.printf("Adjusted time %u. Offset = %d\n", mesh.getNodeTime(), offset);
+}

package/examples/alteriom/alteriom_sensor_package.hpp

@@ -0,0 +1,128 @@
+#ifndef ALTERIOM_SENSOR_PACKAGE_HPP
+#define ALTERIOM_SENSOR_PACKAGE_HPP
+
+#include "painlessmesh/plugin.hpp"
+
+namespace alteriom {
+
+/**
+ * @brief Sensor data package for broadcasting environmental measurements
+ *
+ * This package is designed for Alteriom's IoT sensor network requirements,
+ * allowing nodes to share environmental data across the mesh.
+ */
+class SensorPackage : public painlessmesh::plugin::BroadcastPackage {
+ public:
+  double temperature = 0.0;  // Temperature in Celsius
+  double humidity = 0.0;     // Relative humidity percentage
+  double pressure = 0.0;     // Atmospheric pressure in hPa
+  uint32_t sensorId = 0;     // Unique sensor identifier
+  uint32_t timestamp = 0;    // Unix timestamp of measurement
+  uint8_t batteryLevel = 0;  // Battery level percentage
+
+  SensorPackage()
+      : BroadcastPackage(200) {}  // Type ID 200 for Alteriom sensors
+
+  SensorPackage(JsonObject jsonObj) : BroadcastPackage(jsonObj) {
+    temperature = jsonObj["temp"];
+    humidity = jsonObj["hum"];
+    pressure = jsonObj["press"];
+    sensorId = jsonObj["sid"];
+    timestamp = jsonObj["ts"];
+    batteryLevel = jsonObj["bat"];
+  }
+
+  JsonObject addTo(JsonObject&& jsonObj) const {
+    jsonObj = BroadcastPackage::addTo(std::move(jsonObj));
+    jsonObj["temp"] = temperature;
+    jsonObj["hum"] = humidity;
+    jsonObj["press"] = pressure;
+    jsonObj["sid"] = sensorId;
+    jsonObj["ts"] = timestamp;
+    jsonObj["bat"] = batteryLevel;
+    return jsonObj;
+  }
+
+#if ARDUINOJSON_VERSION_MAJOR < 7
+  size_t jsonObjectSize() const { return JSON_OBJECT_SIZE(noJsonFields + 6); }
+#endif
+};
+
+/**
+ * @brief Command package for controlling Alteriom devices
+ *
+ * Single-destination package for sending specific commands to individual nodes.
+ */
+class CommandPackage : public painlessmesh::plugin::SinglePackage {
+ public:
+  uint8_t command = 0;        // Command type
+  uint32_t targetDevice = 0;  // Target device ID
+  TSTRING parameters = "";    // Command parameters as JSON string
+  uint32_t commandId = 0;     // Unique command identifier for tracking
+
+  CommandPackage() : SinglePackage(201) {}  // Type ID 201 for Alteriom commands
+
+  CommandPackage(JsonObject jsonObj) : SinglePackage(jsonObj) {
+    command = jsonObj["cmd"];
+    targetDevice = jsonObj["target"];
+    parameters = jsonObj["params"].as<TSTRING>();
+    commandId = jsonObj["cid"];
+  }
+
+  JsonObject addTo(JsonObject&& jsonObj) const {
+    jsonObj = SinglePackage::addTo(std::move(jsonObj));
+    jsonObj["cmd"] = command;
+    jsonObj["target"] = targetDevice;
+    jsonObj["params"] = parameters;
+    jsonObj["cid"] = commandId;
+    return jsonObj;
+  }
+
+#if ARDUINOJSON_VERSION_MAJOR < 7
+  size_t jsonObjectSize() const {
+    return JSON_OBJECT_SIZE(noJsonFields + 4) + parameters.length();
+  }
+#endif
+};
+
+/**
+ * @brief Status report package for device health monitoring
+ */
+class StatusPackage : public painlessmesh::plugin::BroadcastPackage {
+ public:
+  uint8_t deviceStatus = 0;      // Device status flags
+  uint32_t uptime = 0;           // Device uptime in seconds
+  uint16_t freeMemory = 0;       // Free memory in KB
+  uint8_t wifiStrength = 0;      // WiFi signal strength
+  TSTRING firmwareVersion = "";  // Current firmware version
+
+  StatusPackage() : BroadcastPackage(202) {}  // Type ID 202 for Alteriom status
+
+  StatusPackage(JsonObject jsonObj) : BroadcastPackage(jsonObj) {
+    deviceStatus = jsonObj["status"];
+    uptime = jsonObj["uptime"];
+    freeMemory = jsonObj["mem"];
+    wifiStrength = jsonObj["wifi"];
+    firmwareVersion = jsonObj["fw"].as<TSTRING>();
+  }
+
+  JsonObject addTo(JsonObject&& jsonObj) const {
+    jsonObj = BroadcastPackage::addTo(std::move(jsonObj));
+    jsonObj["status"] = deviceStatus;
+    jsonObj["uptime"] = uptime;
+    jsonObj["mem"] = freeMemory;
+    jsonObj["wifi"] = wifiStrength;
+    jsonObj["fw"] = firmwareVersion;
+    return jsonObj;
+  }
+
+#if ARDUINOJSON_VERSION_MAJOR < 7
+  size_t jsonObjectSize() const {
+    return JSON_OBJECT_SIZE(noJsonFields + 5) + firmwareVersion.length();
+  }
+#endif
+};
+
+}  // namespace alteriom
+
+#endif  // ALTERIOM_SENSOR_PACKAGE_HPP

package/examples/alteriom/improved_sensor_node.ino

@@ -0,0 +1,246 @@
+/**
+ * Improved Sensor Node Example with Validation and Metrics
+ *
+ * This example demonstrates the new security and performance improvements
+ * in painlessMesh including input validation, rate limiting, and performance
+ * metrics.
+ */
+
+#include "alteriom_sensor_package.hpp"
+#include "painlessMesh.h"
+
+// Note: The improvement modules (validation, metrics, memory) are automatically
+// included through painlessMesh.h when the corresponding features are enabled
+
+#define MESH_PREFIX "AlteriomImprovedMesh"
+#define MESH_PASSWORD "securePassword123"
+#define MESH_PORT 5555
+
+#define SENSOR_TASK_INTERVAL 30000   // Send sensor data every 30 seconds
+#define METRICS_TASK_INTERVAL 60000  // Report metrics every minute
+#define VALIDATION_ENABLED true      // Enable message validation
+
+Scheduler userScheduler;
+painlessMesh mesh;
+
+// New improvement features
+painlessmesh::validation::MessageValidator validator;
+painlessmesh::validation::RateLimiter rateLimiter(5, 1000);  // 5 msgs/sec max
+painlessmesh::metrics::MetricsCollector metrics;
+painlessmesh::memory::ObjectPool<alteriom::SensorPackage> sensorPool(5);
+
+// Task declarations
+Task sensorTask(SENSOR_TASK_INTERVAL, TASK_FOREVER, &sendSensorData);
+Task metricsTask(METRICS_TASK_INTERVAL, TASK_FOREVER, &reportMetrics);
+
+void setup() {
+  Serial.begin(115200);
+
+  // Configure validation with custom settings
+  painlessmesh::validation::ValidationConfig config;
+  config.max_message_size = 4096;      // Smaller max size for sensors
+  config.max_string_length = 256;      // Reasonable string limits
+  config.strict_type_checking = true;  // Enable strict validation
+  validator.set_config(config);
+
+  mesh.setDebugMsgTypes(ERROR | STARTUP | CONNECTION);
+  mesh.init(MESH_PREFIX, MESH_PASSWORD, &userScheduler, MESH_PORT);
+  mesh.onReceive(&receivedCallback);
+  mesh.onNewConnection(&newConnectionCallback);
+  mesh.onChangedConnections(&changedConnectionCallback);
+  mesh.onNodeTimeAdjusted(&nodeTimeAdjustedCallback);
+
+  userScheduler.addTask(sensorTask);
+  userScheduler.addTask(metricsTask);
+  sensorTask.enable();
+  metricsTask.enable();
+
+  Serial.println("Enhanced Sensor Node Started");
+  Serial.println(
+      "Features: Validation, Rate Limiting, Metrics, Memory Optimization");
+}
+
+void loop() {
+  mesh.update();
+  metrics.update();  // Update performance metrics
+}
+
+void sendSensorData() {
+  // Use object pool for memory efficiency
+  auto sensorPackage = sensorPool.acquire();
+
+  // Simulate sensor readings
+  sensorPackage->temperature = 20.0 + random(-5, 15);   // 15-35°C
+  sensorPackage->humidity = 40.0 + random(0, 40);       // 40-80%
+  sensorPackage->pressure = 1013.25 + random(-50, 50);  // Near sea level
+  sensorPackage->batteryLevel = 85 + random(-10, 15);   // Battery simulation
+  sensorPackage->sensorId = mesh.getNodeId();
+  sensorPackage->timestamp = mesh.getNodeTime();
+
+  // Convert to message variant
+  painlessmesh::protocol::Variant variant(sensorPackage.get());
+  String message;
+  variant.printTo(message);
+
+  // Validate message before sending (optional security check)
+  if (VALIDATION_ENABLED) {
+    JsonDocument doc;
+    deserializeJson(doc, message);
+    JsonObject obj = doc.as<JsonObject>();
+
+    auto result = validator.validate_message(obj, message.length());
+    if (result != painlessmesh::validation::ValidationResult::VALID) {
+      Serial.printf("Message validation failed: %s\n",
+                    validator.get_error_message(result));
+      sensorPool.release(std::move(sensorPackage));  // Return to pool
+      return;
+    }
+  }
+
+  // Send the message
+  bool sent = mesh.sendBroadcast(message);
+  if (sent) {
+    metrics.message_stats().record_sent_message(message.length());
+    Serial.printf(
+        "Sensor data sent: T=%.1f°C, H=%.1f%%, P=%.1f hPa, Batt=%d%%\n",
+        sensorPackage->temperature, sensorPackage->humidity,
+        sensorPackage->pressure, sensorPackage->batteryLevel);
+  } else {
+    metrics.message_stats().record_dropped_message();
+    Serial.println("Failed to send sensor data - network congestion");
+  }
+
+  // Return object to pool for reuse
+  sensorPool.release(std::move(sensorPackage));
+}
+
+void reportMetrics() {
+  String metricsJson = metrics.generate_status_json();
+  Serial.println("=== Performance Metrics ===");
+  Serial.println(metricsJson);
+
+  // Check for performance issues
+  if (metrics.has_performance_issues()) {
+    Serial.println("WARNING: Performance issues detected!");
+
+    if (metrics.memory_stats().is_memory_critical()) {
+      Serial.println("- Critical memory shortage");
+    }
+
+    if (metrics.message_stats().packet_loss_rate() > 0.1) {
+      Serial.printf("- High packet loss: %.1f%%\n",
+                    metrics.message_stats().packet_loss_rate() * 100);
+    }
+
+    if (metrics.topology_stats().connection_stability() < 0.8) {
+      Serial.printf("- Poor connection stability: %.1f%%\n",
+                    metrics.topology_stats().connection_stability() * 100);
+    }
+  }
+
+  Serial.println("===========================");
+}
+
+void receivedCallback(uint32_t from, String& msg) {
+  // Record metrics
+  metrics.message_stats().record_received_message(msg.length());
+
+  // Rate limiting check
+  if (!rateLimiter.allow_message(from)) {
+    Serial.printf("Rate limit exceeded for node %u, dropping message\n", from);
+    metrics.message_stats().record_dropped_message();
+    return;
+  }
+
+  // Validate incoming message
+  if (VALIDATION_ENABLED) {
+    JsonDocument doc;
+    DeserializationError error = deserializeJson(doc, msg);
+
+    if (error) {
+      Serial.printf("JSON parsing failed from %u: %s\n", from, error.c_str());
+      metrics.message_stats().record_parse_error();
+      return;
+    }
+
+    JsonObject obj = doc.as<JsonObject>();
+    auto result = validator.validate_message(obj, msg.length());
+
+    if (result != painlessmesh::validation::ValidationResult::VALID) {
+      Serial.printf("Message validation failed from %u: %s\n", from,
+                    validator.get_error_message(result));
+      metrics.message_stats().record_validation_error();
+      return;
+    }
+  }
+
+  // Process the validated message
+  JsonDocument doc;
+  deserializeJson(doc, msg);
+  JsonObject obj = doc.as<JsonObject>();
+  uint8_t msgType = obj["type"];
+
+  switch (msgType) {
+    case 200:  // SensorPackage
+      handleSensorData(alteriom::SensorPackage(obj), from);
+      break;
+    case 201:  // CommandPackage
+      handleCommand(alteriom::CommandPackage(obj), from);
+      break;
+    case 202:  // StatusPackage
+      handleStatus(alteriom::StatusPackage(obj), from);
+      break;
+    default:
+      Serial.printf("Unknown message type %d from %u\n", msgType, from);
+  }
+}
+
+void handleSensorData(alteriom::SensorPackage sensorData, uint32_t from) {
+  Serial.printf("Sensor data from %u: T=%.1f°C, H=%.1f%%, P=%.1f hPa\n", from,
+                sensorData.temperature, sensorData.humidity,
+                sensorData.pressure);
+}
+
+void handleCommand(alteriom::CommandPackage command, uint32_t from) {
+  Serial.printf("Command from %u: cmd=%d, target=%u\n", from, command.command,
+                command.targetDevice);
+
+  // Example: Handle LED control command
+  if (command.command == 1 && command.targetDevice == mesh.getNodeId()) {
+    digitalWrite(LED_BUILTIN,
+                 command.parameters.indexOf("ON") >= 0 ? HIGH : LOW);
+    Serial.println("LED command executed");
+  }
+}
+
+void handleStatus(alteriom::StatusPackage status, uint32_t from) {
+  Serial.printf("Status from %u: status=%d, uptime=%u, mem=%u\n", from,
+                status.deviceStatus, status.uptime, status.freeMemory);
+}
+
+void newConnectionCallback(uint32_t nodeId) {
+  Serial.printf("New connection: %u\n", nodeId);
+
+  // Update topology metrics
+  auto nodeList = mesh.getNodeList();
+  metrics.topology_stats().record_topology_change(
+      nodeList.size() + 1,  // +1 for this node
+      mesh.connectionCount(),
+      0  // Max hops calculation not implemented in this example
+  );
+}
+
+void changedConnectionCallback() {
+  Serial.printf("Changed connections\n");
+
+  // Update topology metrics
+  auto nodeList = mesh.getNodeList();
+  metrics.topology_stats().record_topology_change(
+      nodeList.size() + 1, mesh.connectionCount(),
+      0  // Max hops calculation not implemented in this example
+  );
+}
+
+void nodeTimeAdjustedCallback(int32_t offset) {
+  Serial.printf("Adjusted time %u. Offset = %d\n", mesh.getNodeTime(), offset);
+}

package/examples/alteriom/platformio.ini

@@ -0,0 +1,25 @@
+[platformio]
+src_dir = .
+
+[env]
+lib_deps =
+    bblanchon/ArduinoJson
+    arkhipenko/TaskScheduler
+
+[env:esp8266]
+platform = espressif8266
+board = nodemcuv2
+framework = arduino
+lib_extra_dirs = ../../  ; Load the local copy of painlessmesh. For your own example add painlessmesh to the lib_deps
+lib_deps =
+    ${env.lib_deps}  ; Inherit common dependencies
+    esp32async/ESPAsyncTCP  ; Only for ESP8266
+
+[env:esp32]
+platform = espressif32
+board = esp32dev
+framework = arduino
+lib_extra_dirs = ../../  ; Load the local copy of painlessmesh. For your own example add painlessmesh to the lib_deps
+lib_deps =
+    ${env.lib_deps}  ; Inherit common dependencies
+    esp32async/AsyncTCP

package/examples/basic/basic.ino

@@ -0,0 +1,66 @@
+//************************************************************
+// this is a simple example that uses the painlessMesh library
+//
+// 1. sends a silly message to every node on the mesh at a random time between 1 and 5 seconds
+// 2. prints anything it receives to Serial.print
+//
+//
+//************************************************************
+#include "painlessMesh.h"
+
+#define   MESH_PREFIX     "whateverYouLike"
+#define   MESH_PASSWORD   "somethingSneaky"
+#define   MESH_PORT       5555
+
+Scheduler userScheduler; // to control your personal task
+painlessMesh  mesh;
+
+// User stub
+void sendMessage() ; // Prototype so PlatformIO doesn't complain
+
+Task taskSendMessage( TASK_SECOND * 1 , TASK_FOREVER, &sendMessage );
+
+void sendMessage() {
+  String msg = "Hello from node ";
+  msg += mesh.getNodeId();
+  mesh.sendBroadcast( msg );
+  taskSendMessage.setInterval( random( TASK_SECOND * 1, TASK_SECOND * 5 ));
+}
+
+// Needed for painless library
+void receivedCallback( uint32_t from, String &msg ) {
+  Serial.printf("startHere: Received from %u msg=%s\n", from, msg.c_str());
+}
+
+void newConnectionCallback(uint32_t nodeId) {
+    Serial.printf("--> startHere: New Connection, nodeId = %u\n", nodeId);
+}
+
+void changedConnectionCallback() {
+  Serial.printf("Changed connections\n");
+}
+
+void nodeTimeAdjustedCallback(int32_t offset) {
+    Serial.printf("Adjusted time %u. Offset = %d\n", mesh.getNodeTime(),offset);
+}
+
+void setup() {
+  Serial.begin(115200);
+
+//mesh.setDebugMsgTypes( ERROR | MESH_STATUS | CONNECTION | SYNC | COMMUNICATION | GENERAL | MSG_TYPES | REMOTE ); // all types on
+  mesh.setDebugMsgTypes( ERROR | STARTUP );  // set before init() so that you can see startup messages
+
+  mesh.init( MESH_PREFIX, MESH_PASSWORD, &userScheduler, MESH_PORT );
+  mesh.onReceive(&receivedCallback);
+  mesh.onNewConnection(&newConnectionCallback);
+  mesh.onChangedConnections(&changedConnectionCallback);
+  mesh.onNodeTimeAdjusted(&nodeTimeAdjustedCallback);
+
+  userScheduler.addTask( taskSendMessage );
+  taskSendMessage.enable();
+}
+
+void loop() {
+  // it will run the user scheduler as well
+  mesh.update();
+}

package/examples/basic/platformio.ini

@@ -0,0 +1,25 @@
+[platformio]
+src_dir = .
+
+[env]
+lib_deps =
+    bblanchon/ArduinoJson
+    arkhipenko/TaskScheduler
+
+[env:esp8266]
+platform = espressif8266
+board = nodemcuv2
+framework = arduino
+lib_extra_dirs = ../../
+lib_deps =
+    ${env.lib_deps}  ; Inherit common dependencies
+    esp32async/ESPAsyncTCP  ; Only for ESP8266
+
+[env:esp32]
+platform = espressif32
+board = esp32dev
+framework = arduino
+lib_extra_dirs = ../../
+lib_deps =
+    ${env.lib_deps}  ; Inherit common dependencies
+    esp32async/AsyncTCP