@alteriom/painlessmesh 1.8.0 → 1.8.1

package/examples/queued_alarms/queued_alarms.ino

@@ -0,0 +1,265 @@
+//************************************************************
+// Queued Alarms Example - Message Queueing for Offline Mode
+//
+// Demonstrates priority-based message queueing for critical alarms
+// when Internet connection is unavailable. Perfect for IoT systems
+// that cannot afford to lose critical data.
+//
+// Use Case: Fish farm dissolved oxygen monitoring
+// - CRITICAL alarms (low O2) must never be lost
+// - Queue messages during Internet outages
+// - Automatic delivery when connection restored
+//
+// Hardware: ESP32 or ESP8266
+//************************************************************
+
+#include "painlessMesh.h"
+
+// Mesh configuration
+#define   MESH_PREFIX     "FishFarmMesh"
+#define   MESH_PASSWORD   "somethingSneaky"
+#define   MESH_PORT       5555
+
+// Router credentials for bridge node
+#define   ROUTER_SSID     "YourWiFiSSID"
+#define   ROUTER_PASSWORD "YourWiFiPassword"
+
+// Sensor thresholds (mg/L for dissolved oxygen)
+#define   CRITICAL_O2_THRESHOLD  3.0
+#define   WARNING_O2_THRESHOLD   5.0
+
+// Queue configuration
+#define   MAX_QUEUE_SIZE  500
+#define   QUEUE_PRUNE_AGE (24 * 60 * 60 * 1000)  // 24 hours in ms
+
+Scheduler userScheduler;
+painlessMesh mesh;
+
+bool offlineMode = false;
+uint32_t lastO2Check = 0;
+uint32_t lastQueuePrune = 0;
+
+// Simulated sensor reading (replace with actual sensor code)
+float readDissolvedOxygenSensor() {
+  // In real application, read from actual sensor
+  // For demo, simulate varying O2 levels
+  static float o2Level = 7.0;
+  o2Level += random(-20, 20) / 10.0;  // +/- 2.0 mg/L variation
+  o2Level = constrain(o2Level, 2.0, 10.0);
+  return o2Level;
+}
+
+// Send critical O2 alarm
+void sendCriticalAlarm(float o2Level) {
+  // Create alarm message (in real app, use JSON)
+  String payload = String("{\"type\":\"CRITICAL_ALARM\",\"sensor\":\"O2\",\"value\":") 
+                   + String(o2Level, 2) + ",\"threshold\":" 
+                   + String(CRITICAL_O2_THRESHOLD, 2) + ",\"tankId\":\"TANK_A\",\"nodeId\":" 
+                   + mesh.getNodeId() + ",\"timestamp\":" + mesh.getNodeTime() + "}";
+  
+  if (offlineMode || !mesh.hasInternetConnection()) {
+    // CRITICAL: Queue for guaranteed delivery
+    uint32_t msgId = mesh.queueMessage(
+      payload,
+      "mqtt://cloud.farm.com/alarms/critical",
+      PRIORITY_CRITICAL
+    );
+    
+    if (msgId) {
+      Serial.printf("🚨 CRITICAL O2 ALARM: %.2f mg/L - QUEUED #%u\n", o2Level, msgId);
+    } else {
+      Serial.printf("🚨 CRITICAL O2 ALARM: %.2f mg/L - QUEUE FAILED!\n", o2Level);
+    }
+  } else {
+    // Send immediately via bridge (in real app, use MQTT client)
+    Serial.printf("🚨 CRITICAL O2 ALARM: %.2f mg/L - SENT IMMEDIATELY\n", o2Level);
+    // mqttClient.publish("alarms/critical", payload.c_str());
+  }
+}
+
+// Send warning alarm
+void sendWarningAlarm(float o2Level) {
+  String payload = String("{\"type\":\"WARNING\",\"sensor\":\"O2\",\"value\":") 
+                   + String(o2Level, 2) + ",\"threshold\":" 
+                   + String(WARNING_O2_THRESHOLD, 2) + ",\"nodeId\":" 
+                   + mesh.getNodeId() + "}";
+  
+  if (offlineMode) {
+    uint32_t msgId = mesh.queueMessage(
+      payload,
+      "mqtt://cloud.farm.com/alarms/warning",
+      PRIORITY_HIGH
+    );
+    
+    if (msgId) {
+      Serial.printf("⚠️  WARNING O2: %.2f mg/L - QUEUED #%u\n", o2Level, msgId);
+    } else {
+      Serial.printf("⚠️  WARNING O2: %.2f mg/L - QUEUE FULL\n", o2Level);
+    }
+  } else {
+    Serial.printf("⚠️  WARNING O2: %.2f mg/L - SENT\n", o2Level);
+  }
+}
+
+// Send normal telemetry
+void sendNormalTelemetry(float o2Level) {
+  String payload = String("{\"sensor\":\"O2\",\"value\":") + String(o2Level, 2) 
+                   + ",\"nodeId\":" + mesh.getNodeId() + "}";
+  
+  if (offlineMode) {
+    // Low priority - queue only if space available
+    uint32_t msgId = mesh.queueMessage(
+      payload,
+      "mqtt://cloud.farm.com/telemetry",
+      PRIORITY_LOW
+    );
+    
+    if (msgId) {
+      Serial.printf("📊 Telemetry: %.2f mg/L - queued #%u\n", o2Level, msgId);
+    } else {
+      Serial.printf("📊 Telemetry: %.2f mg/L - dropped (queue full)\n", o2Level);
+    }
+  } else {
+    Serial.printf("📊 Telemetry: %.2f mg/L\n", o2Level);
+  }
+}
+
+// Check O2 sensor and send appropriate message
+void checkO2Sensor() {
+  float o2Level = readDissolvedOxygenSensor();
+  
+  if (o2Level < CRITICAL_O2_THRESHOLD) {
+    sendCriticalAlarm(o2Level);
+  } else if (o2Level < WARNING_O2_THRESHOLD) {
+    sendWarningAlarm(o2Level);
+  } else {
+    sendNormalTelemetry(o2Level);
+  }
+}
+
+// Bridge status callback - Internet connectivity changed
+void bridgeStatusCallback(uint32_t bridgeNodeId, bool hasInternet) {
+  if (!hasInternet) {
+    offlineMode = true;
+    Serial.println("\n⚠️  OFFLINE MODE ACTIVATED");
+    Serial.printf("  Bridge node %u lost Internet\n", bridgeNodeId);
+    Serial.printf("  Queue size: %u messages\n", mesh.getQueuedMessageCount());
+    
+    uint32_t critical = mesh.getQueuedMessageCount(PRIORITY_CRITICAL);
+    if (critical > 0) {
+      Serial.printf("  ⚠️  %u CRITICAL messages queued!\n", critical);
+    }
+  } else {
+    offlineMode = false;
+    Serial.println("\n✅ ONLINE MODE - Internet restored");
+    Serial.printf("  Bridge node %u has Internet\n", bridgeNodeId);
+    
+    // Flush queued messages
+    uint32_t queuedCount = mesh.getQueuedMessageCount();
+    if (queuedCount > 0) {
+      Serial.printf("  Flushing %u queued messages...\n", queuedCount);
+      
+      auto messages = mesh.flushMessageQueue();
+      for (auto& msg : messages) {
+        // In real application, send via MQTT or HTTP
+        Serial.printf("  Sending queued message #%u (priority=%d, attempts=%u)\n",
+                     msg.id, msg.priority, msg.attempts);
+        
+        // Simulate sending (in real app, check if send succeeded)
+        bool sent = true;  // Replace with: mqttClient.publish(...)
+        
+        if (sent) {
+          mesh.removeQueuedMessage(msg.id);
+        } else {
+          // Increment attempt counter
+          mesh.incrementQueuedMessageAttempts(msg.id);
+          
+          // Remove if too many attempts
+          if (msg.attempts >= 3) {
+            Serial.printf("  ❌ Message #%u failed after 3 attempts, removing\n", msg.id);
+            mesh.removeQueuedMessage(msg.id);
+          }
+        }
+      }
+      
+      Serial.printf("  ✅ Queue flushed (%u messages sent)\n", queuedCount);
+    }
+  }
+}
+
+// Queue state callback - Monitor queue health
+void queueStateCallback(QueueState state, uint32_t messageCount) {
+  switch (state) {
+    case QUEUE_EMPTY:
+      Serial.println("ℹ️  Queue empty");
+      break;
+    case QUEUE_NORMAL:
+      Serial.printf("ℹ️  Queue normal (%u messages)\n", messageCount);
+      break;
+    case QUEUE_75_PERCENT:
+      Serial.printf("⚠️  Queue 75%% full (%u messages)\n", messageCount);
+      break;
+    case QUEUE_FULL:
+      Serial.printf("🚨 Queue FULL (%u messages) - dropping LOW priority\n", messageCount);
+      break;
+  }
+}
+
+void setup() {
+  Serial.begin(115200);
+  Serial.println("\n\n=== Fish Farm O2 Monitoring with Message Queue ===\n");
+  
+  // Initialize mesh
+  mesh.setDebugMsgTypes(ERROR | STARTUP | CONNECTION);
+  mesh.init(MESH_PREFIX, MESH_PASSWORD, &userScheduler, MESH_PORT);
+  
+  // For bridge node: set router credentials
+  // Uncomment if this is the bridge node
+  // mesh.stationManual(ROUTER_SSID, ROUTER_PASSWORD);
+  // mesh.setHostname("FishFarmBridge");
+  
+  // Enable message queue
+  mesh.enableMessageQueue(true, MAX_QUEUE_SIZE);
+  Serial.printf("Message queue enabled (capacity: %u)\n", MAX_QUEUE_SIZE);
+  
+  // Set callbacks
+  mesh.onBridgeStatusChanged(&bridgeStatusCallback);
+  mesh.onQueueStateChanged(&queueStateCallback);
+  
+  Serial.println("Setup complete. Monitoring O2 levels...\n");
+  
+  // Initialize random for sensor simulation
+  randomSeed(analogRead(0));
+}
+
+void loop() {
+  mesh.update();
+  
+  // Check O2 sensor every 10 seconds
+  if (millis() - lastO2Check > 10000) {
+    lastO2Check = millis();
+    checkO2Sensor();
+    
+    // Print queue status
+    uint32_t queueSize = mesh.getQueuedMessageCount();
+    if (queueSize > 0) {
+      Serial.printf("  [Queue: %u messages", queueSize);
+      
+      uint32_t critical = mesh.getQueuedMessageCount(PRIORITY_CRITICAL);
+      if (critical > 0) {
+        Serial.printf(" (%u CRITICAL)", critical);
+      }
+      
+      Serial.println("]");
+    }
+  }
+  
+  // Prune old messages every hour
+  if (millis() - lastQueuePrune > 3600000) {
+    lastQueuePrune = millis();
+    uint32_t pruned = mesh.pruneQueue(QUEUE_PRUNE_AGE);
+    if (pruned > 0) {
+      Serial.printf("ℹ️  Pruned %u old messages from queue\n", pruned);
+    }
+  }
+}

package/library.json

@@ -6,7 +6,7 @@
     "type": "git",
     "url": "https://github.com/Alteriom/painlessMesh"
   },
-  "version": "1.8.0",
+  "version": "1.8.1",
   "frameworks": [
     "arduino"
   ],

package/library.properties

@@ -1,5 +1,5 @@
 name=AlteriomPainlessMesh
-version=1.8.0
+version=1.8.1
 author=Coopdis,Scotty Franzyshen,Edwin van Leeuwen,Germán Martín,Maximilian Schwarz,Doanh Doanh,Alteriom
 maintainer=Alteriom
 sentence=A painless way to setup a mesh with ESP8266 and ESP32 devices with Alteriom extensions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alteriom/painlessmesh",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "description": "painlessMesh is a user-friendly library for creating mesh networks with ESP8266 and ESP32 devices. This Alteriom fork includes additional packages for sensor data (SensorPackage), device commands (CommandPackage), and status monitoring (StatusPackage). It handles routing and network management automatically, so you can focus on your application. The library uses JSON-based messaging and syncs time across all nodes, making it ideal for coordinated behaviour like synchronized light displays or sensor networks reporting to a central node.",
   "keywords": [
     "arduino",

package/src/arduino/wifi.hpp

@@ -18,6 +18,13 @@ namespace painlessmesh {
 namespace wifi {
 class Mesh : public painlessmesh::Mesh<Connection> {
  public:
+  // Multi-bridge selection strategy enum (must be declared early)
+  enum BridgeSelectionStrategy {
+    PRIORITY_BASED = 0,  // Use highest priority bridge (default)
+    ROUND_ROBIN = 1,     // Distribute load evenly
+    BEST_SIGNAL = 2      // Use bridge with best RSSI
+  };
+
   /** Initialize the mesh network
    *
    * Add this to your setup() function. This routine does the following things:
@@ -279,6 +286,51 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     Log(STARTUP, "  Port: %d\n", port);
   }
 
+  /**
+   * Initialize mesh as a bridge node with priority (for multi-bridge mode)
+   * 
+   * This overload adds bridge priority configuration for multi-bridge deployments.
+   * Priority determines which bridge is preferred when multiple bridges are available.
+   * 
+   * @param meshSSID The name of your mesh network
+   * @param meshPassword WiFi password for the mesh
+   * @param routerSSID SSID of the router to connect to
+   * @param routerPassword Password for the router
+   * @param baseScheduler Task scheduler for mesh operations
+   * @param port TCP port for mesh communication (default: 5555)
+   * @param priority Bridge priority: 10=highest (primary), 5=medium (secondary), 1=lowest (default: 5)
+   */
+  void initAsBridge(TSTRING meshSSID, TSTRING meshPassword,
+                    TSTRING routerSSID, TSTRING routerPassword,
+                    Scheduler *baseScheduler, uint16_t port, uint8_t priority) {
+    using namespace logger;
+    
+    // Validate and store priority
+    if (priority < 1) priority = 1;
+    if (priority > 10) priority = 10;
+    bridgePriority = priority;
+    
+    // Store role based on priority
+    if (priority >= 8) {
+      bridgeRole = "primary";
+    } else if (priority >= 5) {
+      bridgeRole = "secondary";
+    } else {
+      bridgeRole = "standby";
+    }
+    
+    Log(STARTUP, "=== Bridge Mode Initialization (Priority: %d, Role: %s) ===\n", 
+        priority, bridgeRole.c_str());
+    
+    // Call the base initAsBridge method
+    initAsBridge(meshSSID, meshPassword, routerSSID, routerPassword, baseScheduler, port);
+    
+    // Setup multi-bridge coordination if enabled
+    if (multiBridgeEnabled) {
+      initBridgeCoordination();
+    }
+  }
+
   /**
    * Connect (as a station) to a specified network and ip
    *
@@ -418,6 +470,148 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     bridgeRoleChangedCallback = callback;
   }
 
+  /**
+   * Enable or disable multi-bridge coordination mode
+   * 
+   * When enabled, multiple bridges can operate simultaneously for:
+   * - Load balancing across multiple Internet connections
+   * - Geographic distribution
+   * - Hot standby redundancy without failover delays
+   * 
+   * @param enabled true to enable multi-bridge mode, false for single-bridge (default)
+   */
+  void enableMultiBridge(bool enabled) {
+    multiBridgeEnabled = enabled;
+    if (enabled) {
+      Log(logger::GENERAL, "enableMultiBridge(): Multi-bridge coordination enabled\n");
+    }
+  }
+
+  /**
+   * Set bridge selection strategy for multi-bridge mode
+   * 
+   * @param strategy Selection strategy:
+   *   - PRIORITY_BASED: Always use highest priority bridge (default)
+   *   - ROUND_ROBIN: Distribute load evenly across bridges
+   *   - BEST_SIGNAL: Always use bridge with best RSSI
+   */
+  void setBridgeSelectionStrategy(BridgeSelectionStrategy strategy) {
+    bridgeSelectionStrategy = strategy;
+    Log(logger::GENERAL, "setBridgeSelectionStrategy(): Strategy set to %d\n", (int)strategy);
+  }
+
+  /**
+   * Set maximum number of concurrent bridges in multi-bridge mode
+   * 
+   * @param maxBridges Maximum bridges to track (default: 2, max: 5)
+   */
+  void setMaxBridges(uint8_t maxBridges) {
+    if (maxBridges < 1) maxBridges = 1;
+    if (maxBridges > 5) maxBridges = 5;
+    maxConcurrentBridges = maxBridges;
+    Log(logger::GENERAL, "setMaxBridges(): Max concurrent bridges set to %d\n", maxBridges);
+  }
+
+  /**
+   * Get list of all active bridges (with Internet connection)
+   * 
+   * @return vector of node IDs for active bridges
+   */
+  std::vector<uint32_t> getActiveBridges() {
+    std::vector<uint32_t> activeBridges;
+    auto bridges = this->getBridges();
+    
+    for (const auto& bridge : bridges) {
+      if (bridge.internetConnected && bridge.isHealthy()) {
+        activeBridges.push_back(bridge.nodeId);
+      }
+    }
+    
+    return activeBridges;
+  }
+
+  /**
+   * Get recommended bridge for message transmission
+   * 
+   * Uses the configured bridge selection strategy to pick the best bridge.
+   * Returns 0 if no suitable bridge is available.
+   * 
+   * @return node ID of recommended bridge, or 0 if none available
+   */
+  uint32_t getRecommendedBridge() {
+    auto activeBridges = getActiveBridges();
+    
+    if (activeBridges.empty()) {
+      return 0;
+    }
+    
+    // Single bridge - return it
+    if (activeBridges.size() == 1) {
+      return activeBridges[0];
+    }
+    
+    // Multi-bridge mode: apply selection strategy
+    switch (bridgeSelectionStrategy) {
+      case ROUND_ROBIN: {
+        // Simple round-robin: cycle through bridges
+        lastSelectedBridgeIndex = (lastSelectedBridgeIndex + 1) % activeBridges.size();
+        return activeBridges[lastSelectedBridgeIndex];
+      }
+      
+      case BEST_SIGNAL: {
+        // Find bridge with best RSSI
+        uint32_t bestBridge = 0;
+        int8_t bestRSSI = -127;
+        
+        for (const auto& bridge : this->getBridges()) {
+          if (bridge.internetConnected && bridge.isHealthy() && bridge.routerRSSI > bestRSSI) {
+            bestRSSI = bridge.routerRSSI;
+            bestBridge = bridge.nodeId;
+          }
+        }
+        return bestBridge;
+      }
+      
+      case PRIORITY_BASED:
+      default: {
+        // Use highest priority bridge (stored in bridgePriorities map)
+        uint32_t bestBridge = 0;
+        uint8_t highestPriority = 0;
+        
+        for (uint32_t bridgeId : activeBridges) {
+          uint8_t priority = bridgePriorities[bridgeId];
+          if (priority > highestPriority) {
+            highestPriority = priority;
+            bestBridge = bridgeId;
+          }
+        }
+        
+        // If no priority info, use first active bridge
+        return bestBridge ? bestBridge : activeBridges[0];
+      }
+    }
+  }
+
+  /**
+   * Select a specific bridge for next transmission
+   * 
+   * This overrides the automatic bridge selection for one message.
+   * 
+   * @param bridgeNodeId Node ID of bridge to use
+   */
+  void selectBridge(uint32_t bridgeNodeId) {
+    selectedBridgeOverride = bridgeNodeId;
+  }
+
+  /**
+   * Check if multi-bridge mode is enabled
+   * 
+   * @return true if multi-bridge coordination is enabled
+   */
+  bool isMultiBridgeEnabled() const {
+    return multiBridgeEnabled;
+  }
+
   void stop() {
     // remove all WiFi events
 #ifdef ESP32
@@ -498,6 +692,115 @@ class Mesh : public painlessmesh::Mesh<Connection> {
         this->bridgeStatusIntervalMs);
   }
 
+  /**
+   * Initialize bridge coordination broadcasting
+   * Sets up periodic coordination messages between bridges
+   */
+  void initBridgeCoordination() {
+    using namespace logger;
+    
+    if (!this->isBridge() || !multiBridgeEnabled) {
+      return;
+    }
+    
+    Log(STARTUP, "initBridgeCoordination(): Setting up multi-bridge coordination\n");
+    
+    // Register handler for incoming coordination messages (Type 613)
+    this->callbackList.onPackage(
+        613,  // BRIDGE_COORDINATION type
+        [this](protocol::Variant& variant, std::shared_ptr<Connection>, uint32_t) {
+          JsonDocument doc;
+          TSTRING str;
+          variant.printTo(str);
+          deserializeJson(doc, str);
+          JsonObject obj = doc.as<JsonObject>();
+          
+          if (obj["priority"].is<unsigned int>()) {
+            uint32_t fromNode = obj["from"];
+            uint8_t priority = obj["priority"];
+            TSTRING role = obj["role"].as<TSTRING>();
+            uint8_t load = obj["load"] | 0;
+            
+            // Store bridge priority for selection decisions
+            bridgePriorities[fromNode] = priority;
+            
+            // Update peer bridges list
+            if (obj["peerBridges"].is<JsonArray>()) {
+              JsonArray peers = obj["peerBridges"];
+              for (JsonVariant peer : peers) {
+                uint32_t peerId = peer.as<uint32_t>();
+                if (peerId != this->nodeId && 
+                    std::find(knownBridgePeers.begin(), knownBridgePeers.end(), peerId) == knownBridgePeers.end()) {
+                  knownBridgePeers.push_back(peerId);
+                }
+              }
+            }
+            
+            Log(CONNECTION, "Bridge coordination from %u: priority=%d, role=%s, load=%d%%\n",
+                fromNode, priority, role.c_str(), load);
+          }
+          return false;  // Don't consume the package
+        });
+    
+    // Create periodic task to send coordination messages
+    bridgeCoordinationTask = this->addTask(
+      30000,  // 30 seconds interval
+      TASK_FOREVER,
+      [this]() {
+        this->sendBridgeCoordination();
+      }
+    );
+    
+    Log(STARTUP, "Bridge coordination enabled (priority: %d, role: %s)\n", 
+        bridgePriority, bridgeRole.c_str());
+  }
+
+  /**
+   * Send bridge coordination message to other bridges
+   * Called periodically in multi-bridge mode
+   */
+  void sendBridgeCoordination() {
+    using namespace logger;
+    
+    if (!this->isBridge() || !multiBridgeEnabled) {
+      return;
+    }
+    
+    // Calculate current load (simplified: based on node count)
+    uint8_t currentLoad = 0;
+    auto nodeCount = this->getNodeList(false).size();
+    if (nodeCount > 0) {
+      currentLoad = (nodeCount * 100) / MAX_CONN;
+      if (currentLoad > 100) currentLoad = 100;
+    }
+    
+    // Create coordination message
+    JsonDocument doc;
+    JsonObject obj = doc.to<JsonObject>();
+    
+    obj["type"] = 613;  // BRIDGE_COORDINATION
+    obj["from"] = this->nodeId;
+    obj["routing"] = 2;  // BROADCAST
+    obj["priority"] = bridgePriority;
+    obj["role"] = bridgeRole;
+    obj["load"] = currentLoad;
+    obj["timestamp"] = this->getNodeTime();
+    obj["message_type"] = 613;
+    
+    // Add peer bridges list
+    JsonArray peers = obj["peerBridges"].to<JsonArray>();
+    for (uint32_t peerId : knownBridgePeers) {
+      peers.add(peerId);
+    }
+    
+    String msg;
+    serializeJson(doc, msg);
+    this->sendBroadcast(msg);
+    
+    Log(CONNECTION, "Bridge coordination sent: priority=%d, role=%s, load=%d%%\n",
+        bridgePriority, bridgeRole.c_str(), currentLoad);
+  }
+
   /**
    * Scan for router and return its signal strength
    * 
@@ -578,7 +881,7 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     electionCandidates.push_back(selfCandidate);
     
     // Broadcast candidacy using JSON directly (avoiding dependency on alteriom package)
-    DynamicJsonDocument doc(256);
+    JsonDocument doc;
     JsonObject obj = doc.to<JsonObject>();
     obj["type"] = 611;  // BRIDGE_ELECTION
     obj["from"] = this->nodeId;
@@ -721,7 +1024,7 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     }
     
     // Broadcast takeover announcement
-    DynamicJsonDocument doc(256);
+    JsonDocument doc;
     JsonObject obj = doc.to<JsonObject>();
     obj["type"] = 612;  // BRIDGE_TAKEOVER
     obj["from"] = this->nodeId;
@@ -789,7 +1092,7 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     // Create bridge status package
     // We need to include the package header here since we're in wifi namespace
     // The package will be sent as a JSON string
-    DynamicJsonDocument doc(256);
+    JsonDocument doc;
     JsonObject obj = doc.to<JsonObject>();
     
     obj["type"] = 610;  // BRIDGE_STATUS type
@@ -937,6 +1240,19 @@ class Mesh : public painlessmesh::Mesh<Connection> {
   uint32_t electionDeadline = 0;
   std::vector<BridgeCandidate> electionCandidates;
   std::function<void(bool isBridge, TSTRING reason)> bridgeRoleChangedCallback;
+
+  // Multi-bridge coordination state and configuration
+ protected:
+  bool multiBridgeEnabled = false;
+  BridgeSelectionStrategy bridgeSelectionStrategy = PRIORITY_BASED;
+  uint8_t maxConcurrentBridges = 2;
+  uint8_t bridgePriority = 5;  // Default medium priority
+  TSTRING bridgeRole = "secondary";  // Default role
+  std::shared_ptr<Task> bridgeCoordinationTask;
+  std::map<uint32_t, uint8_t> bridgePriorities;  // nodeId -> priority mapping
+  std::vector<uint32_t> knownBridgePeers;  // List of peer bridge node IDs
+  uint32_t selectedBridgeOverride = 0;  // Manual bridge selection override
+  size_t lastSelectedBridgeIndex = 0;  // For round-robin selection
 };
 }  // namespace wifi
 };  // namespace painlessmesh