@alteriom/painlessmesh 1.8.15 → 1.9.1

package/src/arduino/wifi.hpp

@@ -8,6 +8,7 @@
 #include "painlessMeshSTA.h"
 
 #include "painlessmesh/callback.hpp"
+#include "painlessmesh/gateway.hpp"
 #include "painlessmesh/mesh.hpp"
 #include "painlessmesh/router.hpp"
 #include "painlessmesh/tcp.hpp"
@@ -168,8 +169,18 @@ class Mesh : public painlessmesh::Mesh<Connection> {
         return;
       }
       
-      // Skip check during startup period (60 seconds) to allow initial bridge discovery
-      if (millis() < 60000) {
+      // Skip check during startup period to allow initial bridge discovery
+      if (millis() < electionStartupDelayMs) {
+        return;
+      }
+      
+      // IMPORTANT: Don't trigger election if we're disconnected from the mesh
+      // When isolated, we can't receive bridge status broadcasts, so lack of
+      // healthy bridge could simply mean WE are disconnected, not that the bridge
+      // is unavailable. Wait until mesh connectivity is restored before considering
+      // an election.
+      if (!this->hasActiveMeshConnections()) {
+        Log(CONNECTION, "Bridge monitor: Skipping - no active mesh connections\n");
         return;
       }
       
@@ -185,14 +196,80 @@ class Mesh : public painlessmesh::Mesh<Connection> {
       // If no healthy bridge exists, trigger an election
       if (!hasHealthyBridge) {
         Log(CONNECTION, "Bridge monitor: No healthy bridge detected, triggering election\n");
-        // Small delay to randomize election start across nodes
-        uint32_t randomDelay = random(1000, 3000);
+        // Random delay to prevent simultaneous elections when multiple nodes start together
+        uint32_t randomDelay = random(electionRandomDelayMinMs, electionRandomDelayMaxMs);
+        Log(CONNECTION, "Bridge monitor: Scheduling election in %u ms\n", randomDelay);
         this->addTask(randomDelay, TASK_ONCE, [this]() {
           this->startBridgeElection();
         });
       }
     });
 
+    // Add separate periodic task for isolated bridge retry
+    // This handles the case where a node:
+    // - Has router credentials configured
+    // - Is isolated (no mesh connections)
+    // - Should attempt to become a bridge directly
+    // This is different from the election mechanism which requires mesh connectivity
+    this->addTask(isolatedBridgeRetryIntervalMs, TASK_FOREVER, [this]() {
+      // Only retry if failover is enabled and we have credentials
+      if (!bridgeFailoverEnabled || !routerCredentialsConfigured) {
+        return;
+      }
+      
+      // Don't retry if we're already a bridge
+      if (this->isBridge()) {
+        return;
+      }
+      
+      // Skip during startup period
+      if (millis() < electionStartupDelayMs) {
+        return;
+      }
+      
+      // Only retry when isolated (no mesh connections found)
+      if (this->hasActiveMeshConnections()) {
+        // Reset retry counter when mesh is active
+        _isolatedBridgeRetryAttempts = 0;
+        return;
+      }
+      
+      // Limit retry attempts with reset after timeout
+      if (_isolatedBridgeRetryAttempts >= MAX_ISOLATED_BRIDGE_RETRY_ATTEMPTS) {
+        // Check if enough time has passed to reset the counter
+        if (millis() > _isolatedBridgeRetryResetTime) {
+          Log(CONNECTION, "Isolated bridge retry: Reset timeout reached, resetting attempt counter\n");
+          _isolatedBridgeRetryAttempts = 0;
+        } else {
+          Log(CONNECTION, "Isolated bridge retry: Max attempts (%d) reached, reset in %u seconds\n",
+              MAX_ISOLATED_BRIDGE_RETRY_ATTEMPTS, (_isolatedBridgeRetryResetTime - millis()) / 1000);
+          return;
+        }
+      }
+      
+      // Check if mesh network exists on any channel before trying to become bridge
+      // If mesh exists but we can't connect, don't try to become bridge
+      uint16_t emptyScans = stationScan.getConsecutiveEmptyScans();
+      if (emptyScans < ISOLATED_BRIDGE_RETRY_SCAN_THRESHOLD) {
+        Log(CONNECTION, "Isolated bridge retry: Only %d empty scans, waiting for more scans\n",
+            emptyScans);
+        return;
+      }
+      
+      Log(CONNECTION, "Isolated bridge retry: Node isolated with %d empty scans, attempting bridge promotion\n",
+          emptyScans);
+      
+      // Attempt to become bridge directly (bypassing election since we're isolated)
+      // Only increment retry counter if we actually attempted promotion
+      if (this->attemptIsolatedBridgePromotion()) {
+        _isolatedBridgeRetryAttempts++;
+        // Set reset time when reaching max attempts
+        if (_isolatedBridgeRetryAttempts >= MAX_ISOLATED_BRIDGE_RETRY_ATTEMPTS) {
+          _isolatedBridgeRetryResetTime = millis() + isolatedBridgeRetryResetIntervalMs;
+        }
+      }
+    });
+
     tcpServerInit();
     eventHandleInit();
 
@@ -384,6 +461,150 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     return success;
   }
 
+  /**
+   * Initialize mesh as a shared gateway node
+   * 
+   * This method initializes all mesh nodes in AP+STA mode with router
+   * connectivity. Unlike initAsBridge() which creates a single bridge node,
+   * initAsSharedGateway() allows all nodes to connect to the router while
+   * maintaining mesh communication.
+   * 
+   * Key features:
+   * - All nodes operate in AP+STA mode
+   * - All nodes connect to the same router
+   * - Mesh and router operate on the same channel for reliability
+   * - Automatic router reconnection on disconnect
+   * - Channel synchronization between mesh and router
+   * 
+   * @param meshPrefix The name prefix for the mesh network
+   * @param meshPassword WiFi password for the mesh network
+   * @param routerSSID SSID of the router to connect to
+   * @param routerPassword Password for the router
+   * @param userScheduler Task scheduler for mesh operations
+   * @param port TCP port for mesh communication (default: 5555)
+   * @param config SharedGatewayConfig with advanced settings (optional)
+   * @return true if initialization succeeded, false otherwise
+   */
+  bool initAsSharedGateway(TSTRING meshPrefix, TSTRING meshPassword,
+                           TSTRING routerSSID, TSTRING routerPassword,
+                           Scheduler *userScheduler, uint16_t port = 5555,
+                           gateway::SharedGatewayConfig config = gateway::SharedGatewayConfig()) {
+    using namespace logger;
+    
+    Log(STARTUP, "=== Shared Gateway Mode Initialization ===\n");
+    
+    // Validate configuration if enabled
+    if (config.enabled) {
+      auto result = config.validate();
+      if (!result.valid) {
+        Log(ERROR, "initAsSharedGateway(): Config validation failed: %s\n",
+            result.errorMessage.c_str());
+        return false;
+      }
+    }
+    
+    // Store shared gateway configuration
+    _sharedGatewayConfig = config;
+    _sharedGatewayConfig.routerSSID = routerSSID;
+    _sharedGatewayConfig.routerPassword = routerPassword;
+    _sharedGatewayConfig.enabled = true;
+    _sharedGatewayMode = true;
+    
+    Log(STARTUP, "Step 1: Scanning for router %s to detect channel...\n", routerSSID.c_str());
+    
+    // Step 1: Scan for router to detect its channel
+    // We need to ensure mesh and router operate on the same channel
+    if (WiFi.status() != WL_DISCONNECTED) WiFi.disconnect();
+    
+#if ESP_ARDUINO_VERSION_MAJOR >= 3
+    WiFi.setAutoReconnect(false);
+    Log(STARTUP, "initAsSharedGateway(): AutoReconnect disabled\n");
+#else
+    WiFi.setAutoConnect(false);
+    Log(STARTUP, "initAsSharedGateway(): AutoConnect disabled\n");
+#endif
+    WiFi.persistent(false);
+    WiFi.mode(WIFI_STA);
+    
+    // Connect to router to detect channel
+    WiFi.begin(routerSSID.c_str(), routerPassword.c_str());
+    
+    // Wait for connection with timeout (using constant for configurability)
+    int timeout = ROUTER_CONNECTION_TIMEOUT_SECONDS;
+    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-14 for 2.4GHz, region-dependent)
+      if (detectedChannel < MIN_WIFI_CHANNEL || detectedChannel > MAX_WIFI_CHANNEL) {
+        Log(ERROR, "\n✗ Invalid channel detected: %d, falling back to 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 during channel detection\n");
+      Log(ERROR, "Continuing with default channel 1, will retry router connection later\n");
+    }
+    
+    // Disconnect from router, we'll reconnect after mesh init
+    WiFi.disconnect();
+    delay(100);
+    
+    Log(STARTUP, "Step 2: Initializing mesh on channel %d...\n", detectedChannel);
+    
+    // Step 2: Initialize mesh on detected channel with AP+STA mode
+    // Set scheduler before init
+    this->setScheduler(userScheduler);
+    init(meshPrefix, meshPassword, port, WIFI_AP_STA, detectedChannel, 0, MAX_CONN);
+    
+    Log(STARTUP, "Step 3: Establishing router connection in shared gateway mode...\n");
+    
+    // Step 3: Establish router connection using stationManual
+    // Port 0 means we don't expect TCP mesh connection to the router
+    stationManual(routerSSID, routerPassword, 0);
+    
+    // Step 4: Setup router connection monitoring and reconnection logic
+    initSharedGatewayMonitoring();
+    
+    // Store router credentials for reconnection
+    setRouterCredentials(routerSSID, routerPassword);
+    
+    Log(STARTUP, "=== Shared Gateway Mode Active ===\n");
+    Log(STARTUP, "  Mesh Prefix: %s\n", meshPrefix.c_str());
+    Log(STARTUP, "  Mesh Channel: %d (synced with router)\n", detectedChannel);
+    Log(STARTUP, "  Router: %s\n", routerSSID.c_str());
+    Log(STARTUP, "  Port: %d\n", port);
+    Log(STARTUP, "  Mode: AP+STA (all nodes can connect to router)\n");
+    
+    return true;
+  }
+
+  /**
+   * Check if shared gateway mode is enabled
+   * 
+   * @return true if node is operating in shared gateway mode
+   */
+  bool isSharedGatewayMode() const {
+    return _sharedGatewayMode;
+  }
+
+  /**
+   * Get the shared gateway configuration
+   * 
+   * @return const reference to the SharedGatewayConfig
+   */
+  const gateway::SharedGatewayConfig& getSharedGatewayConfig() const {
+    return _sharedGatewayConfig;
+  }
+
   /**
    * Connect (as a station) to a specified network and ip
    *
@@ -555,6 +776,37 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     minimumBridgeRSSI = minRSSI;
   }
 
+  /**
+   * Set the startup delay before first bridge election check
+   * 
+   * Allows time for mesh network formation before starting bridge elections.
+   * Longer delays reduce the risk of split-brain scenarios when multiple nodes
+   * start simultaneously, ensuring nodes discover each other before elections.
+   * 
+   * @param delayMs Startup delay in milliseconds (default: 60000 = 60 seconds, min: 10000)
+   */
+  void setElectionStartupDelay(uint32_t delayMs) {
+    if (delayMs < 10000) delayMs = 10000;  // Minimum 10 seconds
+    electionStartupDelayMs = delayMs;
+  }
+
+  /**
+   * Set the random delay range for bridge elections
+   * 
+   * When multiple nodes detect missing bridge simultaneously, randomized delays
+   * prevent all nodes from starting elections at the same instant. Longer delays
+   * provide more time for mesh discovery and reduce split-brain risk.
+   * 
+   * @param minMs Minimum random delay in milliseconds (default: 1000 = 1 second)
+   * @param maxMs Maximum random delay in milliseconds (default: 3000 = 3 seconds)
+   */
+  void setElectionRandomDelay(uint32_t minMs, uint32_t maxMs) {
+    if (minMs < 100) minMs = 100;  // Minimum 100ms
+    if (maxMs < minMs) maxMs = minMs + 1000;  // Ensure max > min
+    electionRandomDelayMinMs = minMs;
+    electionRandomDelayMaxMs = maxMs;
+  }
+
   /**
    * Set callback for when this node's bridge role changes
    * 
@@ -1342,6 +1594,95 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     });
   }
 
+  /**
+   * Attempt to promote an isolated node to bridge
+   * 
+   * This method handles the case where a node is isolated (no mesh connections)
+   * but has router credentials. Unlike the election-based promotion, this
+   * directly attempts to connect to the router without requiring mesh connectivity.
+   * 
+   * This is useful for:
+   * - Nodes that failed initial bridge setup and need to retry
+   * - Nodes that are the first to start and no mesh exists yet
+   * - Recovery scenarios where mesh network is unavailable
+   *
+   * @return true if promotion was attempted (regardless of success), false if skipped
+   */
+  bool attemptIsolatedBridgePromotion() {
+    using namespace logger;
+    
+    Log(CONNECTION, "=== Isolated Bridge Promotion Attempt ===\n");
+    Log(CONNECTION, "Attempt %d of %d\n", _isolatedBridgeRetryAttempts + 1, MAX_ISOLATED_BRIDGE_RETRY_ATTEMPTS);
+    
+    // First, scan for router to check if it's visible
+    int8_t routerRSSI = scanRouterSignalStrength(routerSSID);
+    
+    if (routerRSSI == 0) {
+      Log(CONNECTION, "attemptIsolatedBridgePromotion(): Router %s not visible\n", routerSSID.c_str());
+      return false;  // Don't count as an attempt - router not visible
+    }
+    
+    // Check minimum RSSI threshold for isolated promotion
+    if (routerRSSI < minimumBridgeRSSI) {
+      Log(CONNECTION, "attemptIsolatedBridgePromotion(): Router RSSI %d dBm below threshold %d dBm\n",
+          routerRSSI, minimumBridgeRSSI);
+      return false;  // Don't count as an attempt - signal too weak
+    }
+    
+    Log(CONNECTION, "attemptIsolatedBridgePromotion(): Router visible with RSSI %d dBm\n", routerRSSI);
+    Log(CONNECTION, "Attempting direct bridge promotion (bypassing election)\n");
+    
+    // Save current mesh configuration
+    uint8_t savedChannel = _meshChannel;
+    
+    // Stop current mesh operations
+    this->stop();
+    delay(1000);
+    
+    // Attempt to initialize as bridge
+    bool bridgeInitSuccess = this->initAsBridge(_meshSSID, _meshPassword, routerSSID, routerPassword,
+                                                 mScheduler, _meshPort);
+    
+    if (!bridgeInitSuccess) {
+      Log(ERROR, "✗ Isolated bridge promotion failed - router unreachable\n");
+      Log(ERROR, "Reverting to regular node on channel %d\n", savedChannel);
+      
+      // Re-initialize as regular node on the original channel
+      this->init(_meshSSID, _meshPassword, mScheduler, _meshPort, WIFI_AP_STA,
+                 savedChannel, _meshHidden, MAX_CONN);
+      
+      // Re-configure router credentials for future retry attempts
+      this->setRouterCredentials(routerSSID, routerPassword);
+      this->enableBridgeFailover(true);
+      
+      // Notify via callback
+      if (bridgeRoleChangedCallback) {
+        bridgeRoleChangedCallback(false, "Isolated bridge promotion failed - router unreachable");
+      }
+      
+      return true;  // Count as an attempt - we tried but failed
+    }
+    
+    // Success! Reset retry counter
+    _isolatedBridgeRetryAttempts = 0;
+    lastRoleChangeTime = millis();
+    
+    Log(STARTUP, "✓ Isolated bridge promotion complete on channel %d\n", _meshChannel);
+    
+    // Notify via callback
+    if (bridgeRoleChangedCallback) {
+      bridgeRoleChangedCallback(true, "Isolated node promoted to bridge");
+    }
+    
+    // Send bridge status announcement to attract other nodes
+    this->addTask(3000, TASK_ONCE, [this]() {
+      Log(STARTUP, "Sending bridge status announcement on channel %d\n", _meshChannel);
+      this->sendBridgeStatus();
+    });
+    
+    return true;  // Count as an attempt - we succeeded
+  }
+
   /**
    * Handle received bridge election package
    * Called by package handler when election message arrives
@@ -1564,12 +1905,23 @@ class Mesh : public painlessmesh::Mesh<Connection> {
   TSTRING routerPassword = "";
   uint32_t electionTimeoutMs = 5000;  // Default 5 seconds
   int8_t minimumBridgeRSSI = -80;  // Default -80 dBm minimum for isolated elections
+  uint32_t electionStartupDelayMs = 60000;  // Default 60 seconds before first election check
+  uint32_t electionRandomDelayMinMs = 1000;  // Default min 1 second random delay
+  uint32_t electionRandomDelayMaxMs = 3000;  // Default max 3 seconds random delay
   uint32_t lastRoleChangeTime = 0;
   ElectionState electionState = ELECTION_IDLE;
   uint32_t electionDeadline = 0;
   std::vector<BridgeCandidate> electionCandidates;
   std::function<void(bool isBridge, TSTRING reason)> bridgeRoleChangedCallback;
 
+  // Isolated bridge retry state and configuration
+  uint8_t _isolatedBridgeRetryAttempts = 0;
+  uint32_t _isolatedBridgeRetryResetTime = 0;  // Time when retry counter can be reset
+  static const uint8_t MAX_ISOLATED_BRIDGE_RETRY_ATTEMPTS = 5;  // Max retry attempts before waiting
+  static const uint32_t isolatedBridgeRetryIntervalMs = 60000;  // Retry every 60 seconds
+  static const uint32_t isolatedBridgeRetryResetIntervalMs = 300000;  // Reset counter after 5 minutes
+  static const uint16_t ISOLATED_BRIDGE_RETRY_SCAN_THRESHOLD = 6;  // Require 6 empty scans before retrying
+
   // Multi-bridge coordination state and configuration
  protected:
   bool multiBridgeEnabled = false;
@@ -1582,6 +1934,154 @@ class Mesh : public painlessmesh::Mesh<Connection> {
   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
+
+  // Shared gateway mode state and configuration
+  bool _sharedGatewayMode = false;
+  gateway::SharedGatewayConfig _sharedGatewayConfig;
+  std::shared_ptr<Task> _sharedGatewayMonitorTask;
+  uint32_t _lastRouterReconnectAttempt = 0;
+  uint8_t _routerReconnectAttempts = 0;
+  static const uint8_t MAX_ROUTER_RECONNECT_ATTEMPTS = 10;
+  static const uint32_t ROUTER_RECONNECT_BASE_INTERVAL = 5000;  // 5 seconds base interval
+  static const uint32_t ROUTER_RECONNECT_MAX_INTERVAL = 300000; // 5 minutes max interval
+  static const int ROUTER_CONNECTION_TIMEOUT_SECONDS = 30;      // Router connection timeout
+  static const uint8_t MIN_WIFI_CHANNEL = 1;
+  static const uint8_t MAX_WIFI_CHANNEL = 14;  // Support channels 1-14 for regions that allow it
+
+  /**
+   * Initialize shared gateway monitoring
+   * 
+   * Sets up periodic monitoring of router connection and automatic
+   * reconnection logic for shared gateway mode.
+   */
+  void initSharedGatewayMonitoring() {
+    using namespace logger;
+    
+    if (!_sharedGatewayMode) {
+      return;
+    }
+    
+    Log(STARTUP, "initSharedGatewayMonitoring(): Setting up router connection monitoring\n");
+    
+    // Add callback for router disconnection in shared gateway mode
+    this->droppedConnectionCallbacks.push_back(
+        [this](uint32_t nodeId, bool station) {
+          if (station && _sharedGatewayMode) {
+            Log(CONNECTION, "Router disconnected in shared gateway mode, scheduling reconnection\n");
+            scheduleRouterReconnect();
+          }
+        });
+    
+    // Create periodic monitoring task
+    _sharedGatewayMonitorTask = this->addTask(
+        _sharedGatewayConfig.internetCheckInterval,
+        TASK_FOREVER,
+        [this]() {
+          monitorRouterConnection();
+        });
+    
+    Log(STARTUP, "Router connection monitoring enabled (interval: %u ms)\n",
+        _sharedGatewayConfig.internetCheckInterval);
+  }
+
+  /**
+   * Monitor router connection in shared gateway mode
+   * 
+   * Checks router connectivity and triggers reconnection if needed.
+   */
+  void monitorRouterConnection() {
+    using namespace logger;
+    
+    if (!_sharedGatewayMode) {
+      return;
+    }
+    
+    bool isConnected = (WiFi.status() == WL_CONNECTED) && 
+                       (WiFi.localIP() != IPAddress(0, 0, 0, 0));
+    
+    if (!isConnected) {
+      Log(CONNECTION, "monitorRouterConnection(): Router connection lost, triggering reconnect\n");
+      scheduleRouterReconnect();
+    } else {
+      // Connection is healthy, reset reconnect attempts
+      _routerReconnectAttempts = 0;
+      
+      // Log periodic status
+      Log(GENERAL, "monitorRouterConnection(): Router connected (RSSI: %d dBm, IP: %s)\n",
+          WiFi.RSSI(), WiFi.localIP().toString().c_str());
+    }
+  }
+
+  /**
+   * Schedule router reconnection with exponential backoff
+   */
+  void scheduleRouterReconnect() {
+    using namespace logger;
+    
+    if (!_sharedGatewayMode) {
+      return;
+    }
+    
+    // Don't schedule if already connected
+    if (WiFi.status() == WL_CONNECTED) {
+      return;
+    }
+    
+    // Limit reconnection attempts
+    if (_routerReconnectAttempts >= MAX_ROUTER_RECONNECT_ATTEMPTS) {
+      Log(ERROR, "scheduleRouterReconnect(): Max reconnection attempts reached (%d)\n",
+          MAX_ROUTER_RECONNECT_ATTEMPTS);
+      Log(ERROR, "Router reconnection suspended. Manual intervention may be required.\n");
+      return;
+    }
+    
+    // Calculate delay with exponential backoff, preventing overflow
+    // Limit shift amount to prevent overflow (5000 * 2^6 = 320000 is safe)
+    uint8_t shiftAmount = (_routerReconnectAttempts > 6) ? 6 : _routerReconnectAttempts;
+    uint32_t delay = ROUTER_RECONNECT_BASE_INTERVAL * (1UL << shiftAmount);
+    if (delay > ROUTER_RECONNECT_MAX_INTERVAL) delay = ROUTER_RECONNECT_MAX_INTERVAL;
+    
+    // Don't reconnect too frequently
+    uint32_t now = millis();
+    if (now - _lastRouterReconnectAttempt < delay) {
+      return;
+    }
+    
+    _routerReconnectAttempts++;
+    _lastRouterReconnectAttempt = now;
+    
+    Log(CONNECTION, "scheduleRouterReconnect(): Attempting reconnection (attempt %d/%d, delay %u ms)\n",
+        _routerReconnectAttempts, MAX_ROUTER_RECONNECT_ATTEMPTS, delay);
+    
+    // Schedule reconnection
+    this->addTask(delay, TASK_ONCE, [this]() {
+      attemptRouterReconnect();
+    });
+  }
+
+  /**
+   * Attempt to reconnect to the router
+   */
+  void attemptRouterReconnect() {
+    using namespace logger;
+    
+    if (!_sharedGatewayMode) {
+      return;
+    }
+    
+    // Check if already connected
+    if (WiFi.status() == WL_CONNECTED) {
+      Log(CONNECTION, "attemptRouterReconnect(): Already connected to router\n");
+      _routerReconnectAttempts = 0;
+      return;
+    }
+    
+    Log(CONNECTION, "attemptRouterReconnect(): Reconnecting to router %s...\n",
+        _sharedGatewayConfig.routerSSID.c_str());
+    
+    // Use stationManual to reconnect (port 0 means no TCP mesh connection to router)
+    stationManual(_sharedGatewayConfig.routerSSID, _sharedGatewayConfig.routerPassword, 0);
+  }
 };
 }  // namespace wifi
 };  // namespace painlessmesh