@alteriom/painlessmesh 1.6.1 → 1.7.2

package/examples/alteriomPhase1/alteriom_sensor_package.hpp

@@ -0,0 +1,224 @@
+#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
+};
+
+/**
+ * @brief Enhanced status package with comprehensive health metrics (Phase 1)
+ *
+ * This is an extended version of StatusPackage that includes additional
+ * mesh statistics, performance metrics, and alerting capabilities.
+ * Type ID 203 is used to distinguish from the basic StatusPackage (202).
+ */
+class EnhancedStatusPackage : public painlessmesh::plugin::BroadcastPackage {
+ public:
+  // Device Health (from original StatusPackage)
+  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
+  TSTRING firmwareMD5 = "";      // Firmware hash for OTA verification
+
+  // Mesh Statistics
+  uint16_t nodeCount = 0;         // Number of known nodes in mesh
+  uint8_t connectionCount = 0;    // Number of direct connections
+  uint32_t messagesReceived = 0;  // Total messages received
+  uint32_t messagesSent = 0;      // Total messages sent
+  uint32_t messagesDropped = 0;   // Total messages dropped/failed
+
+  // Performance Metrics
+  uint16_t avgLatency = 0;     // Average message latency in ms
+  uint8_t packetLossRate = 0;  // Packet loss rate percentage (0-100)
+  uint16_t throughput = 0;     // Network throughput in bytes/sec
+
+  // Warnings/Alerts
+  uint8_t alertFlags = 0;  // Bit flags for various alert conditions
+  TSTRING lastError = "";  // Last error message for diagnostics
+
+  EnhancedStatusPackage()
+      : BroadcastPackage(203) {}  // Type ID 203 for enhanced status
+
+  EnhancedStatusPackage(JsonObject jsonObj) : BroadcastPackage(jsonObj) {
+    deviceStatus = jsonObj["status"];
+    uptime = jsonObj["uptime"];
+    freeMemory = jsonObj["mem"];
+    wifiStrength = jsonObj["wifi"];
+    firmwareVersion = jsonObj["fw"].as<TSTRING>();
+    firmwareMD5 = jsonObj["fwMD5"].as<TSTRING>();
+
+    nodeCount = jsonObj["nodes"];
+    connectionCount = jsonObj["conns"];
+    messagesReceived = jsonObj["msgRx"];
+    messagesSent = jsonObj["msgTx"];
+    messagesDropped = jsonObj["msgDrop"];
+
+    avgLatency = jsonObj["latency"];
+    packetLossRate = jsonObj["loss"];
+    throughput = jsonObj["throughput"];
+
+    alertFlags = jsonObj["alerts"];
+    lastError = jsonObj["lastErr"].as<TSTRING>();
+  }
+
+  JsonObject addTo(JsonObject&& jsonObj) const {
+    jsonObj = BroadcastPackage::addTo(std::move(jsonObj));
+
+    // Device Health
+    jsonObj["status"] = deviceStatus;
+    jsonObj["uptime"] = uptime;
+    jsonObj["mem"] = freeMemory;
+    jsonObj["wifi"] = wifiStrength;
+    jsonObj["fw"] = firmwareVersion;
+    jsonObj["fwMD5"] = firmwareMD5;
+
+    // Mesh Statistics
+    jsonObj["nodes"] = nodeCount;
+    jsonObj["conns"] = connectionCount;
+    jsonObj["msgRx"] = messagesReceived;
+    jsonObj["msgTx"] = messagesSent;
+    jsonObj["msgDrop"] = messagesDropped;
+
+    // Performance Metrics
+    jsonObj["latency"] = avgLatency;
+    jsonObj["loss"] = packetLossRate;
+    jsonObj["throughput"] = throughput;
+
+    // Alerts
+    jsonObj["alerts"] = alertFlags;
+    jsonObj["lastErr"] = lastError;
+
+    return jsonObj;
+  }
+
+#if ARDUINOJSON_VERSION_MAJOR < 7
+  size_t jsonObjectSize() const {
+    return JSON_OBJECT_SIZE(noJsonFields + 18) + firmwareVersion.length() +
+           firmwareMD5.length() + lastError.length();
+  }
+#endif
+};
+
+}  // namespace alteriom
+
+#endif  // ALTERIOM_SENSOR_PACKAGE_HPP

package/examples/alteriomPhase1/phase1_features.ino

@@ -0,0 +1,242 @@
+/**
+ * Phase 1 OTA Features Example - Compressed OTA & Enhanced Status
+ *
+ * This example demonstrates the Phase 1 enhancements to painlessMesh:
+ * - Option 1E: Compressed OTA Transfer for 40-60% bandwidth reduction
+ * - Option 2A: Enhanced StatusPackage with comprehensive metrics
+ *
+ * Features:
+ * - Compressed firmware updates reduce network bandwidth
+ * - Enhanced status reporting with mesh statistics and performance metrics
+ * - Backward compatible with existing nodes
+ */
+
+#include "alteriom_sensor_package.hpp"
+#include "painlessMesh.h"
+
+#define MESH_PREFIX "AlteriomPhase1Mesh"
+#define MESH_PASSWORD "phase1Features"
+#define MESH_PORT 5555
+
+#define STATUS_INTERVAL 30000  // Send enhanced status every 30 seconds
+
+Scheduler userScheduler;
+painlessMesh mesh;
+
+// Task declarations
+Task statusTask(STATUS_INTERVAL, TASK_FOREVER, &sendEnhancedStatus);
+
+// Metrics tracking
+unsigned long lastRebootTime = 0;
+uint32_t totalMessagesReceived = 0;
+uint32_t totalMessagesSent = 0;
+
+void setup() {
+  Serial.begin(115200);
+  
+  lastRebootTime = millis();
+  
+  mesh.setDebugMsgTypes(ERROR | STARTUP | CONNECTION);
+  mesh.init(MESH_PREFIX, MESH_PASSWORD, &userScheduler, MESH_PORT);
+  
+  mesh.onReceive(&receivedCallback);
+  mesh.onNewConnection(&newConnectionCallback);
+  mesh.onChangedConnections(&changedConnectionCallback);
+  
+  // Add the enhanced status reporting task
+  userScheduler.addTask(statusTask);
+  statusTask.enable();
+  
+  Serial.println("Phase 1 Features Example Started");
+  Serial.println("- Compressed OTA enabled");
+  Serial.println("- Enhanced Status reporting active");
+}
+
+void loop() {
+  mesh.update();
+}
+
+/**
+ * Send Enhanced Status Package with comprehensive metrics
+ */
+void sendEnhancedStatus() {
+  alteriom::EnhancedStatusPackage status;
+  
+  // Device Health
+  status.deviceStatus = 0x01;  // 0x01 = Online and healthy
+  status.uptime = (millis() - lastRebootTime) / 1000;  // Uptime in seconds
+  
+#ifdef ESP32
+  status.freeMemory = ESP.getFreeHeap() / 1024;  // Free heap in KB
+  status.firmwareVersion = "1.0.0-phase1";
+  status.wifiStrength = constrain(map(WiFi.RSSI(), -100, -50, 0, 100), 0, 100);
+#elif defined(ESP8266)
+  status.freeMemory = ESP.getFreeHeap() / 1024;
+  status.firmwareVersion = "1.0.0-phase1";
+  status.wifiStrength = constrain(map(WiFi.RSSI(), -100, -50, 0, 100), 0, 100);
+#else
+  status.freeMemory = 128;  // Default for testing
+  status.firmwareVersion = "1.0.0-test";
+  status.wifiStrength = 75;
+#endif
+  
+  // For demonstration, use a placeholder MD5
+  status.firmwareMD5 = "abc123def456";
+  
+  // Mesh Statistics
+  auto nodeList = mesh.getNodeList();
+  status.nodeCount = nodeList.size();
+  status.connectionCount = nodeList.size();  // Use node count as connection count
+  status.messagesReceived = totalMessagesReceived;
+  status.messagesSent = totalMessagesSent;
+  status.messagesDropped = 0;  // Would need tracking in real implementation
+  
+  // Performance Metrics
+  // In a real implementation, these would be calculated from actual metrics
+  status.avgLatency = 50;      // Average message latency in ms
+  status.packetLossRate = 1;   // 1% packet loss
+  status.throughput = 512;     // Bytes per second
+  
+  // Alerts - check for various conditions
+  status.alertFlags = 0;
+  if (status.freeMemory < 32) {
+    status.alertFlags |= 0x01;  // Low memory alert
+  }
+  if (status.wifiStrength < 30) {
+    status.alertFlags |= 0x02;  // Weak signal alert
+  }
+  if (status.connectionCount == 0 && status.nodeCount == 0) {
+    status.alertFlags |= 0x04;  // Isolated node alert
+  }
+  
+  status.lastError = (status.alertFlags == 0) ? "" : "See alert flags";
+  
+  // Convert to JSON and send
+  String msg;
+  DynamicJsonDocument doc(status.jsonObjectSize());
+  JsonObject obj = doc.to<JsonObject>();
+  status.addTo(std::move(obj));
+  serializeJson(doc, msg);
+  
+  mesh.sendBroadcast(msg);
+  totalMessagesSent++;
+  
+  Serial.printf("Enhanced Status sent - Nodes: %d, Mem: %dKB, Uptime: %ds\n",
+                status.nodeCount, status.freeMemory, status.uptime);
+}
+
+/**
+ * Callback when messages are received
+ */
+void receivedCallback(uint32_t from, String& msg) {
+  totalMessagesReceived++;
+  
+  // Parse the message to identify the type
+  DynamicJsonDocument doc(2048);
+  DeserializationError error = deserializeJson(doc, msg);
+  
+  if (error) {
+    Serial.printf("JSON parse error from %u: %s\n", from, error.c_str());
+    return;
+  }
+  
+  JsonObject obj = doc.as<JsonObject>();
+  int msgType = obj["type"];
+  
+  switch (msgType) {
+    case 203: {  // Enhanced Status Package
+      alteriom::EnhancedStatusPackage status(obj);
+      
+      Serial.printf("Enhanced Status from %u: v%s, Nodes: %d, Mem: %dKB, Msgs: %d/%d\n",
+                    from, 
+                    status.firmwareVersion.c_str(),
+                    status.nodeCount,
+                    status.freeMemory,
+                    status.messagesReceived,
+                    status.messagesSent);
+      
+      if (status.alertFlags != 0) {
+        Serial.printf("  ALERTS (0x%02X): %s\n", status.alertFlags, status.lastError.c_str());
+      }
+      break;
+    }
+    
+    case 202: {  // Basic Status Package (backward compatible)
+      alteriom::StatusPackage status(obj);
+      Serial.printf("Basic Status from %u: v%s, Mem: %dKB\n",
+                    from, status.firmwareVersion.c_str(), status.freeMemory);
+      break;
+    }
+    
+    default:
+      Serial.printf("Message type %d from %u (not a status package)\n", msgType, from);
+      break;
+  }
+}
+
+void newConnectionCallback(uint32_t nodeId) {
+  Serial.printf("New Connection: %u\n", nodeId);
+  Serial.printf("Total nodes in mesh: %d\n", mesh.getNodeList().size());
+}
+
+void changedConnectionCallback() {
+  Serial.printf("Connections changed. Nodes: %d\n", mesh.getNodeList().size());
+}
+
+/**
+ * Example: How to use Compressed OTA (sender side)
+ * 
+ * This function shows how to enable compressed OTA transfers.
+ * In a real implementation, this would be called from an OTA sender node.
+ */
+void setupCompressedOTA() {
+  #ifdef PAINLESSMESH_ENABLE_OTA
+  
+  // Example firmware info
+  String firmwareMD5 = "abc123def456789";  // MD5 of firmware
+  size_t numParts = 100;                   // Number of firmware chunks
+  
+  // Offer OTA update with compression enabled
+  // Parameters: role, hardware, md5, numParts, forced, broadcasted, compressed
+  auto otaTask = mesh.offerOTA(
+    "sensor",      // Role this firmware is for
+    "ESP32",       // Hardware type
+    firmwareMD5,   // MD5 hash of firmware
+    numParts,      // Number of data chunks
+    false,         // Not forced (only update if different)
+    false,         // Not using broadcast mode (yet - Phase 2)
+    true           // COMPRESSED! 40-60% bandwidth savings
+  );
+  
+  Serial.println("Compressed OTA announced!");
+  Serial.println("Expected bandwidth savings: 40-60%");
+  Serial.println("Nodes will receive and decompress firmware automatically");
+  
+  #else
+  Serial.println("OTA not enabled. Define PAINLESSMESH_ENABLE_OTA");
+  #endif
+}
+
+/**
+ * Benefits of Phase 1 Features:
+ * 
+ * 1. Compressed OTA (Option 1E):
+ *    - 40-60% reduction in network bandwidth
+ *    - Faster firmware distribution across mesh
+ *    - Lower energy consumption
+ *    - Backward compatible with uncompressed OTA
+ *    - Works with all future OTA options (broadcast, progressive, etc.)
+ * 
+ * 2. Enhanced Status Package (Option 2A):
+ *    - Comprehensive device health monitoring
+ *    - Mesh network statistics (nodes, connections, messages)
+ *    - Performance metrics (latency, packet loss, throughput)
+ *    - Alert system for proactive issue detection
+ *    - Standardized format across all Alteriom nodes
+ *    - Easy integration with monitoring dashboards
+ * 
+ * Next Steps (Phase 2):
+ *    - Broadcast OTA for even faster updates in large meshes
+ *    - MQTT bridge for cloud monitoring integration
+ *    - Professional monitoring tools (Grafana, InfluxDB)
+ */

package/examples/alteriomPhase1/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