@alteriom/painlessmesh 1.6.1 → 1.7.2

package/examples/meshCommandNode/alteriom_sensor_package.hpp

@@ -0,0 +1,235 @@
+#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
+
+  // Command response fields (for MQTT bridge)
+  uint32_t responseToCommand = 0; // CommandId this is responding to
+  TSTRING responseMessage = "";   // Success/error message
+
+  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>();
+    responseToCommand = jsonObj["respTo"] | 0;
+    responseMessage = jsonObj["respMsg"].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;
+    if (responseToCommand > 0) {
+      jsonObj["respTo"] = responseToCommand;
+      jsonObj["respMsg"] = responseMessage;
+    }
+    return jsonObj;
+  }
+
+#if ARDUINOJSON_VERSION_MAJOR < 7
+  size_t jsonObjectSize() const {
+    return JSON_OBJECT_SIZE(noJsonFields + 7) + firmwareVersion.length() +
+           responseMessage.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/meshCommandNode/meshCommandNode.ino

@@ -0,0 +1,263 @@
+#include "painlessMesh.h"
+#include "alteriom_sensor_package.hpp"
+
+// Define LED_BUILTIN for ESP32 boards that don't have it predefined
+#ifndef LED_BUILTIN
+#define LED_BUILTIN 2
+#endif
+
+#define MESH_PREFIX     "AlteriomMesh"
+#define MESH_PASSWORD   "somethingSneaky"
+#define MESH_PORT       5555
+
+using namespace alteriom;
+
+Scheduler userScheduler;
+painlessMesh mesh;
+
+// Command handlers
+void handleCommand(const CommandPackage& cmd);
+void sendStatusResponse(uint32_t commandId, String message, uint8_t status = 0);
+void sendConfiguration();
+void sendStatus();
+
+// Command definitions (matching mqtt_command_bridge.hpp)
+enum Commands {
+  RESET = 1,
+  SLEEP = 2,
+  WAKE = 3,
+  LED_CONTROL = 10,
+  RELAY_SWITCH = 11,
+  PWM_SET = 12,
+  GET_CONFIG = 100,
+  SET_CONFIG = 101,
+  GET_STATUS = 200,
+  GET_METRICS = 201
+};
+
+void setup() {
+  Serial.begin(115200);
+  
+  pinMode(LED_BUILTIN, OUTPUT);
+  
+  mesh.setDebugMsgTypes(ERROR | STARTUP | CONNECTION);
+  mesh.init(MESH_PREFIX, MESH_PASSWORD, &userScheduler, MESH_PORT);
+  
+  mesh.onReceive([](uint32_t from, String& msg) {
+    Serial.printf("Received from %u\n", from);
+    
+    // Parse message
+    JsonDocument doc;
+    DeserializationError error = deserializeJson(doc, msg);
+    
+    if (error) {
+      Serial.printf("JSON parse error: %s\n", error.c_str());
+      return;
+    }
+    
+    uint8_t msgType = doc["type"];
+    
+    if (msgType == 201) {
+      // CommandPackage
+      JsonObject obj = doc.as<JsonObject>();
+      CommandPackage cmd(obj);
+      
+      // Check if command is for this node
+      if (cmd.targetDevice == 0 || cmd.targetDevice == mesh.getNodeId()) {
+        handleCommand(cmd);
+      }
+    }
+  });
+  
+  mesh.onNewConnection([](uint32_t nodeId) {
+    Serial.printf("New connection: %u\n", nodeId);
+  });
+  
+  mesh.onChangedConnections([]() {
+    Serial.printf("Connections changed - nodes: %d\n", mesh.getNodeList().size());
+  });
+  
+  Serial.printf("Mesh node initialized: %u\n", mesh.getNodeId());
+  Serial.println("Ready to receive commands");
+}
+
+void loop() {
+  mesh.update();
+}
+
+/**
+ * @brief Handle incoming command
+ */
+void handleCommand(const CommandPackage& cmd) {
+  Serial.printf("Command received: cmd=%d, id=%u\n", cmd.command, cmd.commandId);
+  
+  switch(cmd.command) {
+    case RESET:
+      sendStatusResponse(cmd.commandId, "Rebooting...");
+      delay(1000);
+      ESP.restart();
+      break;
+      
+    case SLEEP: {
+      JsonDocument params;
+      deserializeJson(params, cmd.parameters);
+      uint32_t duration = params["duration_ms"];
+      
+      sendStatusResponse(cmd.commandId, "Entering sleep for " + String(duration) + "ms");
+      delay(100);
+      
+      ESP.deepSleep(duration * 1000);
+      break;
+    }
+    
+    case LED_CONTROL: {
+      JsonDocument params;
+      deserializeJson(params, cmd.parameters);
+      
+      bool state = params["state"];
+      uint8_t brightness = params["brightness"] | 255;
+      
+      digitalWrite(LED_BUILTIN, state ? LOW : HIGH);
+      
+      String msg = "LED " + String(state ? "ON" : "OFF");
+      if (brightness < 255) {
+        msg += " (brightness: " + String(brightness) + ")";
+      }
+      
+      sendStatusResponse(cmd.commandId, msg);
+      Serial.println(msg);
+      break;
+    }
+    
+    case RELAY_SWITCH: {
+      JsonDocument params;
+      deserializeJson(params, cmd.parameters);
+      
+      uint8_t channel = params["channel"];
+      bool state = params["state"];
+      
+      // Control relay (GPIO configuration needed)
+      String msg = "Relay " + String(channel) + " " + String(state ? "ON" : "OFF");
+      sendStatusResponse(cmd.commandId, msg);
+      Serial.println(msg);
+      break;
+    }
+    
+    case PWM_SET: {
+      JsonDocument params;
+      deserializeJson(params, cmd.parameters);
+      
+      uint8_t pin = params["pin"];
+      uint16_t duty = params["duty"];
+      
+      // Set PWM (example - adjust for your hardware)
+      String msg = "PWM pin " + String(pin) + " set to " + String(duty);
+      sendStatusResponse(cmd.commandId, msg);
+      Serial.println(msg);
+      break;
+    }
+    
+    case GET_CONFIG:
+      sendConfiguration();
+      break;
+      
+    case GET_STATUS:
+      sendStatus();
+      break;
+      
+    case GET_METRICS: {
+      // Send enhanced status
+      EnhancedStatusPackage metrics;
+      metrics.from = mesh.getNodeId();
+      metrics.deviceStatus = 0;
+      metrics.uptime = millis() / 1000;
+      metrics.freeMemory = ESP.getFreeHeap() / 1024;
+      metrics.wifiStrength = WiFi.RSSI();
+      metrics.firmwareVersion = "1.0.0";
+      
+      auto nodeList = mesh.getNodeList();
+      metrics.nodeCount = nodeList.size();
+      metrics.connectionCount = nodeList.size();
+      
+      auto variant = painlessmesh::protocol::Variant(&metrics);
+      String msg;
+      variant.printTo(msg);
+      
+      mesh.sendBroadcast(msg);
+      Serial.println("Metrics sent");
+      break;
+    }
+    
+    case SET_CONFIG: {
+      JsonDocument params;
+      deserializeJson(params, cmd.parameters);
+      
+      JsonObject config = params.as<JsonObject>();
+      
+      if (config["deviceName"].is<String>()) {
+        String name = config["deviceName"];
+        Serial.printf("Config: deviceName=%s\n", name.c_str());
+      }
+      
+      if (config["sampleRate"].is<uint32_t>()) {
+        uint32_t rate = config["sampleRate"];
+        Serial.printf("Config: sampleRate=%u\n", rate);
+      }
+      
+      sendStatusResponse(cmd.commandId, "Configuration updated");
+      break;
+    }
+    
+    default:
+      sendStatusResponse(cmd.commandId, "Unknown command: " + String(cmd.command), 2);
+      Serial.printf("Unknown command: %d\n", cmd.command);
+  }
+}
+
+/**
+ * @brief Send status response
+ */
+void sendStatusResponse(uint32_t commandId, String message, uint8_t status) {
+  StatusPackage response;
+  response.from = mesh.getNodeId();
+  response.deviceStatus = status;
+  response.uptime = millis() / 1000;
+  response.freeMemory = ESP.getFreeHeap() / 1024;
+  response.wifiStrength = WiFi.RSSI();
+  response.firmwareVersion = "1.0.0";
+  response.responseToCommand = commandId;
+  response.responseMessage = message;
+  
+  auto variant = painlessmesh::protocol::Variant(&response);
+  String msg;
+  variant.printTo(msg);
+  
+  mesh.sendBroadcast(msg);
+  Serial.printf("Response sent: %s\n", message.c_str());
+}
+
+/**
+ * @brief Send configuration
+ */
+void sendConfiguration() {
+  JsonDocument config;
+  config["deviceName"] = "Sensor-" + String(mesh.getNodeId());
+  config["firmwareVersion"] = "1.0.0";
+  config["role"] = "sensor";
+  config["sampleRate"] = 60000;
+  config["ledEnabled"] = true;
+  
+  String configStr;
+  serializeJson(config, configStr);
+  
+  sendStatusResponse(0, configStr);
+  Serial.println("Configuration sent");
+}
+
+/**
+ * @brief Send basic status
+ */
+void sendStatus() {
+  sendStatusResponse(0, "OK");
+  Serial.println("Status sent");
+}

package/examples/meshCommandNode/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}
+    me-no-dev/ESPAsyncTCP
+
+[env:esp32]
+platform = espressif32
+board = esp32dev
+framework = arduino
+lib_extra_dirs = ../../
+lib_deps =
+    ${env.lib_deps}
+    mathieucarbou/AsyncTCP