@alteriom/painlessmesh 1.7.8 → 1.8.0

package/src/arduino/wifi.hpp

@@ -63,6 +63,7 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     _meshSSID = ssid;
     _meshPassword = password;
     _meshChannel = channel;
+    Log(STARTUP, "init(): Mesh channel set to %d\n", _meshChannel);
     _meshHidden = hidden;
     _meshMaxConn = maxconn;
     _meshPort = port;
@@ -80,6 +81,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();
 
@@ -118,6 +185,100 @@ 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);
+  }
+
   /**
    * Connect (as a station) to a specified network and ip
    *
@@ -128,13 +289,21 @@ class Mesh : public painlessmesh::Mesh<Connection> {
    */
   void stationManual(TSTRING ssid, TSTRING password, uint16_t port = 0,
                      IPAddress remote_ip = IPAddress(0, 0, 0, 0)) {
+    using namespace logger;
     // Set station config
     stationScan.manualIP = remote_ip;
 
+    Log(STARTUP, "stationManual(): Connecting to %s\n", ssid.c_str());
+
     // Start scan
     stationScan.init(this, ssid, password, port, _meshChannel,
                      static_cast<bool>(_meshHidden));
     stationScan.manual = true;
+
+    // Directly initiate connection - ESP will auto-detect router's channel
+    WiFi.begin(ssid.c_str(), password.c_str());
+
+    Log(STARTUP, "stationManual(): Connection initiated\n");
   }
 
   void initStation() {
@@ -203,6 +372,52 @@ 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;
+  }
+
   void stop() {
     // remove all WiFi events
 #ifdef ESP32
@@ -256,6 +471,346 @@ 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);
+  }
+
+  /**
+   * 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)
+    DynamicJsonDocument doc(256);
+    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
+    DynamicJsonDocument doc(256);
+    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
+    DynamicJsonDocument doc(256);
+    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
@@ -356,6 +911,32 @@ 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;
 };
 }  // namespace wifi
 };  // namespace painlessmesh