@alteriom/painlessmesh 1.7.9 → 1.8.1

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:
@@ -81,6 +88,72 @@ class Mesh : public painlessmesh::Mesh<Connection> {
 
     this->init(nodeId);
 
+    // Add bridge election package handler (Type 611)
+    this->callbackList.onPackage(
+        611,  // BRIDGE_ELECTION 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["routerRSSI"].is<int>()) {
+            uint32_t fromNode = obj["from"];
+            int8_t routerRSSI = obj["routerRSSI"];
+            uint32_t uptime = obj["uptime"] | 0;
+            uint32_t freeMemory = obj["freeMemory"] | 0;
+            
+            this->handleBridgeElection(fromNode, routerRSSI, uptime, freeMemory);
+            
+            Log(CONNECTION, "Bridge election candidate from %u: RSSI %d dBm\n",
+                fromNode, routerRSSI);
+          }
+          return false;  // Don't consume the package
+        });
+
+    // Add bridge takeover package handler (Type 612)
+    this->callbackList.onPackage(
+        612,  // BRIDGE_TAKEOVER 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["previousBridge"].is<unsigned int>()) {
+            uint32_t newBridge = obj["from"];
+            uint32_t previousBridge = obj["previousBridge"];
+            TSTRING reason = obj["reason"].as<TSTRING>();
+            
+            Log(CONNECTION, "Bridge takeover: Node %u replaced %u (%s)\n",
+                newBridge, previousBridge, reason.c_str());
+                
+            // Notify callback if this node was not the winner
+            if (newBridge != this->nodeId && bridgeRoleChangedCallback) {
+              bridgeRoleChangedCallback(false, "Another node won election");
+            }
+          }
+          return false;  // Don't consume the package
+        });
+
+    // Add callback to detect bridge failures and trigger elections
+    this->onBridgeStatusChanged([this](uint32_t bridgeNodeId, bool hasInternet) {
+      if (!hasInternet && bridgeFailoverEnabled && routerCredentialsConfigured) {
+        Log(CONNECTION, "Bridge %u lost Internet, considering election...\n", bridgeNodeId);
+        
+        // Check if we still have any healthy bridges
+        if (!this->hasInternetConnection()) {
+          Log(CONNECTION, "No healthy bridges, starting election\n");
+          // Small delay to let all nodes detect the failure
+          this->addTask(2000, TASK_ONCE, [this]() {
+            this->startBridgeElection();
+          });
+        }
+      }
+    });
+
     tcpServerInit();
     eventHandleInit();
 
@@ -119,6 +192,145 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     init(ssid, password, port, connectMode, channel, hidden, maxconn);
   }
 
+  /**
+   * Initialize mesh as a bridge node with automatic channel detection
+   * 
+   * This method connects to a router first, detects its channel, then
+   * initializes the mesh on the same channel. This ensures the bridge
+   * can maintain both router and mesh connections on the same channel.
+   * 
+   * The bridge node will automatically:
+   * - Connect to the specified router in STA mode
+   * - Detect the router's WiFi channel
+   * - Initialize the mesh AP on the detected channel
+   * - Set itself as root node
+   * - Maintain the router connection
+   * 
+   * @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)
+   */
+  void initAsBridge(TSTRING meshSSID, TSTRING meshPassword,
+                    TSTRING routerSSID, TSTRING routerPassword,
+                    Scheduler *baseScheduler, uint16_t port = 5555) {
+    using namespace logger;
+    
+    Log(STARTUP, "=== Bridge Mode Initialization ===\n");
+    Log(STARTUP, "Step 1: Connecting to router %s...\n", routerSSID.c_str());
+    
+    // Step 1: Connect to router first to detect its channel
+    // Shut Wifi down and start with a blank slate
+    if (WiFi.status() != WL_DISCONNECTED) WiFi.disconnect();
+    
+    Log(STARTUP, "initAsBridge(): %d\n",
+#if ESP_ARDUINO_VERSION_MAJOR >= 3
+        WiFi.setAutoReconnect(false));
+#else
+        WiFi.setAutoConnect(false));
+#endif
+    WiFi.persistent(false);
+    WiFi.mode(WIFI_STA);
+    
+    // Connect to router and wait for connection
+    WiFi.begin(routerSSID.c_str(), routerPassword.c_str());
+    
+    // Wait for connection (with timeout)
+    int timeout = 30;  // 30 seconds timeout
+    while (WiFi.status() != WL_CONNECTED && timeout > 0) {
+      delay(1000);
+      timeout--;
+      Log(STARTUP, ".");
+    }
+    
+    uint8_t detectedChannel = 1;  // Default fallback
+    
+    if (WiFi.status() == WL_CONNECTED) {
+      detectedChannel = WiFi.channel();
+      // Validate channel is in valid range (1-13 for 2.4GHz)
+      if (detectedChannel < 1 || detectedChannel > 13) {
+        Log(ERROR, "\n✗ Invalid channel detected: %d, using default channel 1\n", detectedChannel);
+        detectedChannel = 1;
+      } else {
+        Log(STARTUP, "\n✓ Router connected on channel %d\n", detectedChannel);
+        Log(STARTUP, "✓ Router IP: %s\n", WiFi.localIP().toString().c_str());
+      }
+    } else {
+      Log(ERROR, "\n✗ Failed to connect to router, using default channel 1\n");
+    }
+    
+    Log(STARTUP, "Step 2: Initializing mesh on channel %d...\n", detectedChannel);
+    
+    // Step 2: Initialize mesh on detected channel
+    init(meshSSID, meshPassword, baseScheduler, port, WIFI_AP_STA, 
+         detectedChannel, 0, MAX_CONN);
+    
+    Log(STARTUP, "Step 3: Establishing bridge connection...\n");
+    
+    // Step 3: Re-establish router connection using stationManual
+    stationManual(routerSSID, routerPassword, 0);
+    
+    // Step 4: Configure as root/bridge node
+    this->setRoot(true);
+    this->setContainsRoot(true);
+    
+    // Step 5: Setup bridge status broadcasting
+    initBridgeStatusBroadcast();
+    
+    Log(STARTUP, "=== Bridge Mode Active ===\n");
+    Log(STARTUP, "  Mesh SSID: %s\n", meshSSID.c_str());
+    Log(STARTUP, "  Mesh Channel: %d (matches router)\n", detectedChannel);
+    Log(STARTUP, "  Router: %s\n", routerSSID.c_str());
+    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
    *
@@ -212,6 +424,194 @@ class Mesh : public painlessmesh::Mesh<Connection> {
   IPAddress getStationIP() { return WiFi.localIP(); }
   IPAddress getAPIP() { return _apIp; }
 
+  /**
+   * Enable or disable automatic bridge failover
+   * 
+   * When enabled, nodes will participate in bridge elections if the primary
+   * bridge goes offline and they have router credentials configured.
+   * 
+   * @param enabled true to enable automatic failover (default), false to disable
+   */
+  void enableBridgeFailover(bool enabled) {
+    bridgeFailoverEnabled = enabled;
+  }
+
+  /**
+   * Set router credentials for bridge election participation
+   * 
+   * Nodes must have router credentials configured to participate in bridge
+   * elections. When a bridge fails, only nodes with credentials can become
+   * the new bridge.
+   * 
+   * @param ssid Router SSID
+   * @param password Router password
+   */
+  void setRouterCredentials(TSTRING ssid, TSTRING password) {
+    routerSSID = ssid;
+    routerPassword = password;
+    routerCredentialsConfigured = true;
+  }
+
+  /**
+   * Set the election timeout (how long to collect candidates)
+   * 
+   * @param timeoutMs Timeout in milliseconds (default: 5000 = 5 seconds)
+   */
+  void setElectionTimeout(uint32_t timeoutMs) {
+    electionTimeoutMs = timeoutMs;
+  }
+
+  /**
+   * Set callback for when this node's bridge role changes
+   * 
+   * @param callback Function to call when role changes
+   */
+  void onBridgeRoleChanged(std::function<void(bool isBridge, TSTRING reason)> callback) {
+    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
@@ -265,6 +665,455 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     WiFi.softAP(_meshSSID.c_str(), _meshPassword.c_str(), _meshChannel,
                 _meshHidden, _meshMaxConn);
   }
+
+  /**
+   * Initialize bridge status broadcasting
+   * Sets up a periodic task to broadcast bridge status to the mesh
+   */
+  void initBridgeStatusBroadcast() {
+    using namespace logger;
+    
+    if (!this->isBridge() || !this->bridgeStatusBroadcastEnabled) {
+      return;
+    }
+    
+    Log(STARTUP, "initBridgeStatusBroadcast(): Setting up bridge status broadcast\n");
+    
+    // Create periodic task to broadcast bridge status
+    bridgeStatusTask = this->addTask(
+      this->bridgeStatusIntervalMs,
+      TASK_FOREVER,
+      [this]() {
+        this->sendBridgeStatus();
+      }
+    );
+    
+    Log(STARTUP, "Bridge status broadcast enabled (interval: %d ms)\n", 
+        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
+   * 
+   * @param routerSSID SSID of router to scan for
+   * @return RSSI in dBm (negative number, -127 to 0), or 0 if not found
+   */
+  int8_t scanRouterSignalStrength(TSTRING routerSSID) {
+    using namespace logger;
+    Log(CONNECTION, "scanRouterSignalStrength(): Scanning for %s...\n", routerSSID.c_str());
+    
+    int n = WiFi.scanNetworks(false, false);
+    Log(CONNECTION, "scanRouterSignalStrength(): Found %d networks\n", n);
+    
+    for (int i = 0; i < n; i++) {
+      if (WiFi.SSID(i) == routerSSID) {
+        int8_t rssi = WiFi.RSSI(i);
+        Log(CONNECTION, "scanRouterSignalStrength(): Found %s with RSSI %d dBm\n", 
+            routerSSID.c_str(), rssi);
+        return rssi;
+      }
+    }
+    
+    Log(CONNECTION, "scanRouterSignalStrength(): Router %s not found\n", routerSSID.c_str());
+    return 0;  // Router not found
+  }
+
+  /**
+   * Start bridge election process
+   * Called when primary bridge failure is detected
+   */
+  void startBridgeElection() {
+    using namespace logger;
+    
+    if (!bridgeFailoverEnabled) {
+      Log(CONNECTION, "startBridgeElection(): Failover disabled\n");
+      return;
+    }
+    
+    if (!routerCredentialsConfigured) {
+      Log(CONNECTION, "startBridgeElection(): No router credentials, cannot participate\n");
+      return;
+    }
+    
+    if (electionState != ELECTION_IDLE) {
+      Log(CONNECTION, "startBridgeElection(): Election already in progress\n");
+      return;
+    }
+    
+    // Prevent rapid role changes
+    if (millis() - lastRoleChangeTime < 60000) {
+      Log(CONNECTION, "startBridgeElection(): Too soon after last role change\n");
+      return;
+    }
+    
+    Log(CONNECTION, "=== Bridge Election Started ===\n");
+    electionState = ELECTION_SCANNING;
+    
+    // Scan for router to get RSSI
+    int8_t routerRSSI = scanRouterSignalStrength(routerSSID);
+    
+    if (routerRSSI == 0) {
+      Log(CONNECTION, "startBridgeElection(): Router not visible, cannot participate\n");
+      electionState = ELECTION_IDLE;
+      return;
+    }
+    
+    Log(CONNECTION, "startBridgeElection(): My router RSSI: %d dBm\n", routerRSSI);
+    
+    // Clear previous candidates
+    electionCandidates.clear();
+    
+    // Add self as candidate
+    BridgeCandidate selfCandidate;
+    selfCandidate.nodeId = this->nodeId;
+    selfCandidate.routerRSSI = routerRSSI;
+    selfCandidate.uptime = millis();
+    selfCandidate.freeMemory = ESP.getFreeHeap();
+    electionCandidates.push_back(selfCandidate);
+    
+    // Broadcast candidacy using JSON directly (avoiding dependency on alteriom package)
+    JsonDocument doc;
+    JsonObject obj = doc.to<JsonObject>();
+    obj["type"] = 611;  // BRIDGE_ELECTION
+    obj["from"] = this->nodeId;
+    obj["routing"] = 2;  // BROADCAST
+    obj["routerRSSI"] = routerRSSI;
+    obj["uptime"] = millis();
+    obj["freeMemory"] = ESP.getFreeHeap();
+    obj["timestamp"] = this->getNodeTime();
+    obj["routerSSID"] = routerSSID;
+    obj["message_type"] = 611;
+    
+    String msg;
+    serializeJson(doc, msg);
+    this->sendBroadcast(msg);
+    
+    Log(CONNECTION, "startBridgeElection(): Candidacy broadcast sent\n");
+    
+    // Set election timeout
+    electionDeadline = millis() + electionTimeoutMs;
+    electionState = ELECTION_COLLECTING;
+    
+    // Schedule election evaluation
+    this->addTask(electionTimeoutMs + 100, TASK_ONCE, [this]() {
+      this->evaluateElection();
+    });
+  }
+
+  /**
+   * Evaluate election and determine winner
+   * Called after election timeout expires
+   */
+  void evaluateElection() {
+    using namespace logger;
+    
+    if (electionState != ELECTION_COLLECTING) {
+      Log(CONNECTION, "evaluateElection(): Not in collecting state\n");
+      return;
+    }
+    
+    Log(CONNECTION, "=== Evaluating Election ===\n");
+    Log(CONNECTION, "evaluateElection(): %d candidates\n", electionCandidates.size());
+    
+    // Find best candidate
+    BridgeCandidate* winner = nullptr;
+    int8_t bestRSSI = -127;  // Worst possible RSSI
+    
+    for (auto& candidate : electionCandidates) {
+      Log(CONNECTION, "evaluateElection(): Candidate %u: RSSI=%d, uptime=%u, mem=%u\n",
+          candidate.nodeId, candidate.routerRSSI, candidate.uptime, candidate.freeMemory);
+      
+      if (candidate.routerRSSI > bestRSSI) {
+        bestRSSI = candidate.routerRSSI;
+        winner = &candidate;
+      } else if (candidate.routerRSSI == bestRSSI && winner != nullptr) {
+        // Tiebreaker 1: Higher uptime
+        if (candidate.uptime > winner->uptime) {
+          winner = &candidate;
+        } else if (candidate.uptime == winner->uptime) {
+          // Tiebreaker 2: More free memory
+          if (candidate.freeMemory > winner->freeMemory) {
+            winner = &candidate;
+          } else if (candidate.freeMemory == winner->freeMemory) {
+            // Tiebreaker 3: Lower node ID (deterministic)
+            if (candidate.nodeId < winner->nodeId) {
+              winner = &candidate;
+            }
+          }
+        }
+      }
+    }
+    
+    if (winner == nullptr) {
+      Log(ERROR, "evaluateElection(): No winner found!\n");
+      electionState = ELECTION_IDLE;
+      return;
+    }
+    
+    Log(CONNECTION, "=== Election Winner: Node %u ===\n", winner->nodeId);
+    Log(CONNECTION, "  Router RSSI: %d dBm\n", winner->routerRSSI);
+    Log(CONNECTION, "  Uptime: %u ms\n", winner->uptime);
+    Log(CONNECTION, "  Free Memory: %u bytes\n", winner->freeMemory);
+    
+    // Record election in diagnostics history
+    if (this->diagnosticsEnabled) {
+      ElectionRecord record;
+      record.timestamp = millis();
+      record.winnerNodeId = winner->nodeId;
+      record.winnerRSSI = winner->routerRSSI;
+      record.candidateCount = electionCandidates.size();
+      record.reason = "Bridge failure detected";
+      
+      this->electionHistory.push_back(record);
+      
+      // Keep history limited to MAX_ELECTION_HISTORY
+      if (this->electionHistory.size() > this->MAX_ELECTION_HISTORY) {
+        this->electionHistory.erase(this->electionHistory.begin());
+      }
+      
+      Log(CONNECTION, "evaluateElection(): Election recorded in history\n");
+    }
+    
+    if (winner->nodeId == this->nodeId) {
+      Log(CONNECTION, "🎯 I WON! Promoting to bridge...\n");
+      promoteToBridge();
+    } else {
+      Log(CONNECTION, "Winner is node %u, remaining as regular node\n", winner->nodeId);
+    }
+    
+    electionState = ELECTION_IDLE;
+    electionCandidates.clear();
+  }
+
+  /**
+   * Promote this node to bridge role
+   * Called when node wins election
+   */
+  void promoteToBridge() {
+    using namespace logger;
+    
+    Log(STARTUP, "=== Becoming Bridge Node ===\n");
+    
+    // Store previous bridge (if any)
+    auto primaryBridge = this->getPrimaryBridge();
+    uint32_t previousBridgeId = primaryBridge ? primaryBridge->nodeId : 0;
+    
+    // Reconfigure as bridge
+    this->stop();
+    delay(1000);
+    
+    this->initAsBridge(_meshSSID, _meshPassword, routerSSID, routerPassword,
+                       mScheduler, _meshPort);
+    
+    lastRoleChangeTime = millis();
+    
+    Log(STARTUP, "✓ Bridge promotion complete\n");
+    
+    // Notify via callback
+    if (bridgeRoleChangedCallback) {
+      bridgeRoleChangedCallback(true, "Election winner - best router signal");
+    }
+    
+    // Broadcast takeover announcement
+    JsonDocument doc;
+    JsonObject obj = doc.to<JsonObject>();
+    obj["type"] = 612;  // BRIDGE_TAKEOVER
+    obj["from"] = this->nodeId;
+    obj["routing"] = 2;  // BROADCAST
+    obj["previousBridge"] = previousBridgeId;
+    obj["reason"] = "Election winner - best router signal";
+    obj["routerRSSI"] = WiFi.RSSI();
+    obj["timestamp"] = this->getNodeTime();
+    obj["message_type"] = 612;
+    
+    String msg;
+    serializeJson(doc, msg);
+    
+    // Small delay to ensure mesh is ready
+    delay(2000);
+    this->sendBroadcast(msg);
+    
+    Log(STARTUP, "✓ Takeover announcement sent\n");
+  }
+
+  /**
+   * Handle received bridge election package
+   * Called by package handler when election message arrives
+   */
+  void handleBridgeElection(uint32_t fromNode, int8_t routerRSSI, uint32_t uptime, 
+                            uint32_t freeMemory) {
+    using namespace logger;
+    
+    if (electionState != ELECTION_COLLECTING) {
+      Log(CONNECTION, "handleBridgeElection(): Not collecting candidates, ignoring\n");
+      return;
+    }
+    
+    // Check if candidate already exists
+    for (auto& candidate : electionCandidates) {
+      if (candidate.nodeId == fromNode) {
+        Log(CONNECTION, "handleBridgeElection(): Duplicate candidate from %u, ignoring\n", fromNode);
+        return;
+      }
+    }
+    
+    BridgeCandidate candidate;
+    candidate.nodeId = fromNode;
+    candidate.routerRSSI = routerRSSI;
+    candidate.uptime = uptime;
+    candidate.freeMemory = freeMemory;
+    
+    electionCandidates.push_back(candidate);
+    
+    Log(CONNECTION, "handleBridgeElection(): Added candidate %u (RSSI: %d dBm)\n",
+        fromNode, routerRSSI);
+  }
+
+  /**
+   * Send bridge status broadcast
+   * Called periodically by bridge nodes to report connectivity status
+   */
+  void sendBridgeStatus() {
+    using namespace logger;
+    
+    if (!this->bridgeStatusBroadcastEnabled) {
+      return;
+    }
+    
+    // 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
+    JsonDocument doc;
+    JsonObject obj = doc.to<JsonObject>();
+    
+    obj["type"] = 610;  // BRIDGE_STATUS type
+    obj["from"] = this->nodeId;
+    obj["routing"] = 2;  // BROADCAST routing
+    obj["timestamp"] = this->getNodeTime();
+    obj["internetConnected"] = (WiFi.status() == WL_CONNECTED);
+    obj["routerRSSI"] = WiFi.RSSI();
+    obj["routerChannel"] = WiFi.channel();
+    obj["uptime"] = millis();
+    obj["gatewayIP"] = WiFi.gatewayIP().toString();
+    obj["message_type"] = 610;
+    
+    String msg;
+    serializeJson(doc, msg);
+    
+    Log(GENERAL, "sendBridgeStatus(): Broadcasting status (Internet: %s)\n",
+        (WiFi.status() == WL_CONNECTED) ? "Connected" : "Disconnected");
+    
+    this->sendBroadcast(msg);
+  }
   void eventHandleInit() {
     using namespace logger;
 #ifdef ESP32
@@ -365,6 +1214,45 @@ class Mesh : public painlessmesh::Mesh<Connection> {
   WiFiEventHandler eventSTAGotIPHandler;
 #endif  // ESP8266
   AsyncServer *_tcpListener;
+  std::shared_ptr<Task> bridgeStatusTask;
+
+  // Bridge failover state and configuration
+  enum ElectionState {
+    ELECTION_IDLE,
+    ELECTION_SCANNING,
+    ELECTION_COLLECTING
+  };
+
+  struct BridgeCandidate {
+    uint32_t nodeId;
+    int8_t routerRSSI;
+    uint32_t uptime;
+    uint32_t freeMemory;
+  };
+
+  bool bridgeFailoverEnabled = true;
+  bool routerCredentialsConfigured = false;
+  TSTRING routerSSID = "";
+  TSTRING routerPassword = "";
+  uint32_t electionTimeoutMs = 5000;  // Default 5 seconds
+  uint32_t lastRoleChangeTime = 0;
+  ElectionState electionState = ELECTION_IDLE;
+  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