Complete ESP32 Wi-Fi Programming Guide: Mastering Arduino Wi-Fi Library Functions

// Professional initialization with error handling
bool connectToWiFi(const char* ssid, const char* password, int maxRetries = 20) {
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  
  Serial.print("Connecting to ");
  Serial.print(ssid);
  
  int retryCount = 0;
  while (WiFi.status() != WL_CONNECTED && retryCount < maxRetries) {
    delay(500);
    Serial.print(".");
    retryCount++;
    
    // Reset Wi-Fi hardware if stuck (based on field testing)
    if (retryCount % 10 == 0) {
      Serial.println("\nResetting Wi-Fi adapter...");
      WiFi.disconnect();
      delay(100);
      WiFi.begin(ssid, password);
    }
  }
  
  if (WiFi.status() == WL_CONNECTED) {
    Serial.println("\nConnected successfully!");
    Serial.print("IP address: ");
    Serial.println(WiFi.localIP());
    return true;
  } else {
    Serial.println("\nConnection failed!");
    return false;
  }
}

// Robust AP setup with configurable parameters
bool setupAccessPoint(const char* apSSID, const char* apPassword = NULL, 
                      int channel = 1, int maxConnections = 4) {
  
  // Validate parameters (critical for network stability)
  if (strlen(apSSID) == 0 || strlen(apSSID) > 31) {
    Serial.println("Error: SSID must be 1-31 characters");
    return false;
  }
  
  if (apPassword != NULL && strlen(apPassword) < 8) {
    Serial.println("Warning: AP password should be at least 8 characters for security");
  }
  
  WiFi.mode(WIFI_AP);
  
  // Configure with additional stability parameters
  WiFi.softAP(apSSID, apPassword, channel, 0, maxConnections);
  
  // Verify AP started successfully
  delay(100); // Allow AP initialization
  
  if (WiFi.softAPgetStationNum() >= 0) { // Check if AP is running
    Serial.print("Access Point '");
    Serial.print(apSSID);
    Serial.println("' started successfully");
    Serial.print("AP IP address: ");
    Serial.println(WiFi.softAPIP());
    return true;
  } else {
    Serial.println("Failed to start Access Point");
    return false;
  }
}

#include <vector>
#include <algorithm>

struct NetworkInfo {
  String ssid;
  int32_t rssi;
  uint8_t encryption;
  int32_t channel;
  bool isHidden;
};

// Comparator for sorting networks by signal strength
bool compareRSSI(const NetworkInfo &a, const NetworkInfo &b) {
  return a.rssi > b.rssi; // Higher RSSI (less negative) is better
}

std::vector<NetworkInfo> scanNetworksDetailed(bool showHidden = false) {
  std::vector<NetworkInfo> networks;
  
  // Set appropriate mode for scanning
  WiFi.mode(WIFI_STA);
  WiFi.disconnect();
  delay(100);
  
  Serial.println("Starting advanced Wi-Fi scan...");
  
  // Scan with comprehensive parameters
  int networkCount = WiFi.scanNetworks(/*async=*/false, /*showHidden=*/showHidden);
  
  if (networkCount == 0) {
    Serial.println("No networks found. Check antenna or positioning.");
    return networks;
  }
  
  Serial.print("Found ");
  Serial.print(networkCount);
  Serial.println(" networks:");
  
  // Collect detailed information
  for (int i = 0; i < networkCount; i++) {
    NetworkInfo net;
    net.ssid = WiFi.SSID(i);
    net.rssi = WiFi.RSSI(i);
    net.encryption = WiFi.encryptionType(i);
    
    // Note: Channel information requires additional implementation
    // as standard Arduino WiFi library doesn't expose it directly
    
    // Determine if network is hidden (SSID empty but network detected)
    net.isHidden = (net.ssid.length() == 0);
    
    networks.push_back(net);
    
    // Print analysis
    Serial.print(i + 1);
    Serial.print(": ");
    
    if (net.isHidden) {
      Serial.print("[Hidden Network]");
    } else {
      Serial.print(net.ssid);
    }
    
    Serial.print(" (");
    Serial.print(net.rssi);
    Serial.print(" dBm) ");
    
    // Signal quality interpretation (based on extensive testing)
    if (net.rssi >= -50) Serial.print("Excellent");
    else if (net.rssi >= -60) Serial.print("Good");
    else if (net.rssi >= -70) Serial.print("Fair");
    else if (net.rssi >= -80) Serial.print("Weak");
    else Serial.print("Poor");
    
    Serial.print(" | Security: ");
    switch (net.encryption) {
      case WIFI_AUTH_OPEN: Serial.print("Open"); break;
      case WIFI_AUTH_WEP: Serial.print("WEP"); break;
      case WIFI_AUTH_WPA_PSK: Serial.print("WPA-PSK"); break;
      case WIFI_AUTH_WPA2_PSK: Serial.print("WPA2-PSK"); break;
      case WIFI_AUTH_WPA_WPA2_PSK: Serial.print("WPA/WPA2"); break;
      case WIFI_AUTH_WPA2_ENTERPRISE: Serial.print("WPA2-Enterprise"); break;
      case WIFI_AUTH_WPA3_PSK: Serial.print("WPA3-PSK"); break;
      case WIFI_AUTH_WPA2_WPA3_PSK: Serial.print("WPA2/WPA3"); break;
      default: Serial.print("Unknown");
    }
    
    Serial.println();
  }
  
  // Sort by signal strength
  std::sort(networks.begin(), networks.end(), compareRSSI);
  
  Serial.println("\nNetworks sorted by signal strength (best first):");
  for (size_t i = 0; i < networks.size() && i < 5; i++) {
    Serial.print(i + 1);
    Serial.print(". ");
    Serial.print(networks[i].ssid);
    Serial.print(" (");
    Serial.print(networks[i].rssi);
    Serial.println(" dBm)");
  }
  
  // Clean up scan result to free memory
  WiFi.scanDelete();
  
  return networks;
}

class WiFiConnectionManager {
private:
  String ssid;
  String password;
  unsigned long lastConnectionAttempt;
  unsigned long connectionTimeout;
  int maxRetries;
  int currentRetry;
  bool persistentMode;
  
  // Connection statistics
  unsigned long totalUptime;
  unsigned long totalDowntime;
  int connectionCount;
  int dropoutCount;
  
public:
  WiFiConnectionManager(const String &ssid, const String &password, 
                       unsigned long timeout = 30000, int maxRetries = 5)
    : ssid(ssid), password(password), connectionTimeout(timeout), 
      maxRetries(maxRetries), currentRetry(0), persistentMode(true),
      totalUptime(0), totalDowntime(0), connectionCount(0), dropoutCount(0) {
    lastConnectionAttempt = 0;
  }
  
  // Main connection management loop - call regularly in loop()
  ConnectionStatus manageConnection() {
    wl_status_t status = WiFi.status();
    unsigned long now = millis();
    
    switch (status) {
      case WL_CONNECTED:
        if (currentRetry > 0) {
          Serial.println("Connection restored!");
          recordUptime();
          currentRetry = 0;
          connectionCount++;
        }
        return CONNECTED;
        
      case WL_IDLE_STATUS:
      case WL_DISCONNECTED:
      case WL_CONNECTION_LOST:
      case WL_CONNECT_FAILED:
        // Check if we should attempt reconnection
        if (persistentMode && (now - lastConnectionAttempt > connectionTimeout || 
            lastConnectionAttempt == 0)) {
          
          if (currentRetry == 0) {
            dropoutCount++;
            Serial.println("Wi-Fi disconnected. Attempting to reconnect...");
            recordDowntime();
          }
          
          if (currentRetry < maxRetries) {
            attemptReconnection();
            lastConnectionAttempt = now;
            currentRetry++;
          } else {
            Serial.println("Max retries exceeded. Performing deep reset...");
            deepReset();
            currentRetry = 0;
          }
        }
        return DISCONNECTED;
        
      default:
        return ERROR;
    }
  }
  
  void attemptReconnection() {
    Serial.print("Reconnection attempt ");
    Serial.print(currentRetry + 1);
    Serial.print("/");
    Serial.println(maxRetries);
    
    // Different strategies based on retry count
    if (currentRetry < 2) {
      // Simple reconnect first
      WiFi.reconnect();
    } else if (currentRetry < 4) {
      // Disconnect and fresh connect
      WiFi.disconnect();
      delay(100);
      WiFi.begin(ssid.c_str(), password.c_str());
    } else {
      // Reset Wi-Fi hardware
      WiFi.disconnect();
      delay(1000);
      WiFi.mode(WIFI_OFF);
      delay(1000);
      WiFi.mode(WIFI_STA);
      WiFi.begin(ssid.c_str(), password.c_str());
    }
  }
  
  void deepReset() {
    Serial.println("Performing ESP32 Wi-Fi deep reset...");
    WiFi.disconnect(true);  // Disconnect with cleanup
    delay(2000);
    WiFi.mode(WIFI_OFF);
    delay(2000);
    
    // Restart Wi-Fi interface
    WiFi.mode(WIFI_STA);
    delay(1000);
    WiFi.begin(ssid.c_str(), password.c_str());
    
    currentRetry = 0;
    lastConnectionAttempt = millis();
  }
  
  void printStatistics() {
    Serial.println("\n=== Wi-Fi Connection Statistics ===");
    Serial.print("Total connections: ");
    Serial.println(connectionCount);
    Serial.print("Total dropouts: ");
    Serial.println(dropoutCount);
    Serial.print("Uptime: ");
    Serial.print(totalUptime / 1000);
    Serial.println(" seconds");
    Serial.print("Downtime: ");
    Serial.print(totalDowntime / 1000);
    Serial.println(" seconds");
    
    if (connectionCount > 0) {
      float reliability = 100.0 * (1.0 - (float)dropoutCount / connectionCount);
      Serial.print("Reliability: ");
      Serial.print(reliability, 1);
      Serial.println("%");
    }
  }
  
  // ... Additional methods for recording uptime/downtime
};

// Comprehensive static IP configuration with validation
struct NetworkConfig {
  IPAddress localIP;
  IPAddress gateway;
  IPAddress subnet;
  IPAddress primaryDNS;
  IPAddress secondaryDNS;
};

bool configureStaticIP(const NetworkConfig &config, bool verbose = true) {
  // Validate IP addresses
  if (!isValidIP(config.localIP) || !isValidIP(config.gateway) || 
      !isValidIP(config.subnet)) {
    if (verbose) Serial.println("Error: Invalid IP configuration");
    return false;
  }
  
  // Check if IP is within subnet
  if (!isInSubnet(config.localIP, config.gateway, config.subnet)) {
    if (verbose) {
      Serial.println("Error: Local IP not within specified subnet");
      Serial.print("Local IP: ");
      Serial.println(config.localIP);
      Serial.print("Gateway: ");
      Serial.println(config.gateway);
      Serial.print("Subnet: ");
      Serial.println(config.subnet);
    }
    return false;
  }
  
  // Apply configuration
  if (verbose) {
    Serial.println("Configuring static IP...");
    Serial.print("Local IP: ");
    Serial.println(config.localIP);
    Serial.print("Gateway: ");
    Serial.println(config.gateway);
    Serial.print("Subnet: ");
    Serial.println(config.subnet);
  }
  
  // DNS servers are optional
  if (config.primaryDNS != INADDR_NONE) {
    if (!WiFi.config(config.localIP, config.gateway, config.subnet, 
                     config.primaryDNS, config.secondaryDNS)) {
      if (verbose) Serial.println("STA Failed to configure");
      return false;
    }
  } else {
    if (!WiFi.config(config.localIP, config.gateway, config.subnet)) {
      if (verbose) Serial.println("STA Failed to configure");
      return false;
    }
  }
  
  if (verbose) Serial.println("Static IP configured successfully");
  return true;
}

// Helper function to validate subnet membership
bool isInSubnet(IPAddress ip, IPAddress gateway, IPAddress subnet) {
  for (int i = 0; i < 4; i++) {
    if ((ip[i] & subnet[i]) != (gateway[i] & subnet[i])) {
      return false;
    }
  }
  return true;
}

// Example configuration for different environments
NetworkConfig homeNetwork = {
  IPAddress(192, 168, 1, 150),  // Local IP
  IPAddress(192, 168, 1, 1),    // Gateway
  IPAddress(255, 255, 255, 0),  // Subnet
  IPAddress(8, 8, 8, 8),        // Primary DNS
  IPAddress(8, 8, 4, 4)         // Secondary DNS
};

NetworkConfig enterpriseNetwork = {
  IPAddress(10, 0, 5, 42),      // Local IP
  IPAddress(10, 0, 0, 1),       // Gateway
  IPAddress(255, 255, 0, 0),    // Subnet
  IPAddress(10, 0, 0, 10),      // Internal DNS
  IPAddress(1, 1, 1, 1)         // Backup DNS
};

class SignalAnalyzer {
private:
  std::vector<int32_t> rssiReadings;
  unsigned long lastReadingTime;
  unsigned long readingInterval;
  int32_t rssiThreshold;
  int32_t hysteresis;
  bool lowSignalWarning;
  
public:
  SignalAnalyzer(unsigned long interval = 5000, int32_t threshold = -75, 
                 int32_t hysteresis = 5)
    : readingInterval(interval), rssiThreshold(threshold), 
      hysteresis(hysteresis), lowSignalWarning(false) {
    lastReadingTime = 0;
    rssiReadings.reserve(100); // Store last 100 readings
  }
  
  void update() {
    unsigned long now = millis();
    
    if (now - lastReadingTime >= readingInterval) {
      if (WiFi.status() == WL_CONNECTED) {
        int32_t currentRSSI = WiFi.RSSI();
        rssiReadings.push_back(currentRSSI);
        
        // Keep only last 100 readings
        if (rssiReadings.size() > 100) {
          rssiReadings.erase(rssiReadings.begin());
        }
        
        // Check signal quality with hysteresis
        if (!lowSignalWarning && currentRSSI < rssiThreshold) {
          lowSignalWarning = true;
          Serial.print("Warning: Low signal strength: ");
          Serial.print(currentRSSI);
          Serial.println(" dBm");
          Serial.println("Consider moving device closer to router");
        } else if (lowSignalWarning && currentRSSI > (rssiThreshold + hysteresis)) {
          lowSignalWarning = false;
          Serial.println("Signal strength improved");
        }
        
        lastReadingTime = now;
      }
    }
  }
  
  void printAnalysis() {
    if (rssiReadings.empty()) {
      Serial.println("No signal data available");
      return;
    }
    
    // Calculate statistics
    int32_t sum = 0;
    int32_t minRSSI = 0;
    int32_t maxRSSI = -100;
    
    for (int32_t rssi : rssiReadings) {
      sum += rssi;
      if (rssi > maxRSSI) maxRSSI = rssi;
      if (rssi < minRSSI) minRSSI = rssi;
    }
    
    float averageRSSI = (float)sum / rssiReadings.size();
    
    Serial.println("\n=== Signal Strength Analysis ===");
    Serial.print("Current RSSI: ");
    Serial.print(WiFi.RSSI());
    Serial.println(" dBm");
    Serial.print("Average RSSI: ");
    Serial.print(averageRSSI, 1);
    Serial.println(" dBm");
    Serial.print("Minimum RSSI: ");
    Serial.print(minRSSI);
    Serial.println(" dBm");
    Serial.print("Maximum RSSI: ");
    Serial.print(maxRSSI);
    Serial.println(" dBm");
    Serial.print("Samples: ");
    Serial.println(rssiReadings.size());
    
    // Interpretation guide
    Serial.println("\nSignal Quality Guide:");
    Serial.println("-30 dBm: Excellent (Close to AP)");
    Serial.println("-50 dBm: Very Good");
    Serial.println("-60 dBm: Good");
    Serial.println("-70 dBm: Fair (Minimum for reliable streaming)");
    Serial.println("-80 dBm: Poor (Basic connectivity, may drop)");
    Serial.println("-90 dBm: Very Poor (Unstable)");
  }
  
  // Get signal quality as percentage (for dashboard display)
  int getSignalQualityPercent() {
    int32_t rssi = WiFi.RSSI();
    
    // Convert RSSI to percentage (empirical formula)
    if (rssi >= -30) return 100;
    else if (rssi <= -90) return 0;
    else {
      // Linear mapping between -30 and -90 dBm
      return map(rssi, -90, -30, 0, 100);
    }
  }
};

#include "driver/rtc_cntl.h"

class WiFiPowerManager {
private:
  bool powerSaveEnabled;
  int currentPowerMode;
  
public:
  enum PowerMode {
    MAX_PERFORMANCE = 0,  // Full power, maximum throughput
    BALANCED = 1,         // Balanced power/performance
    POWER_SAVE = 2,       // Reduced power, moderate performance
    MINIMUM_POWER = 3     // Minimum power, basic connectivity
  };
  
  WiFiPowerManager() : powerSaveEnabled(false), currentPowerMode(MAX_PERFORMANCE) {}
  
  bool setPowerMode(PowerMode mode) {
    switch (mode) {
      case MAX_PERFORMANCE:
        // Disable power saving for maximum performance
        WiFi.setSleep(false);
        currentPowerMode = mode;
        Serial.println("Power mode: Maximum Performance");
        return true;
        
      case BALANCED:
        // Light sleep between packets
        WiFi.setSleep(WIFI_PS_MIN_MODEM);
        currentPowerMode = mode;
        Serial.println("Power mode: Balanced");
        return true;
        
      case POWER_SAVE:
        // Moderate power saving
        WiFi.setSleep(WIFI_PS_MAX_MODEM);
        currentPowerMode = mode;
        Serial.println("Power mode: Power Save");
        return true;
        
      case MINIMUM_POWER:
        // Aggressive power saving (may increase latency)
        WiFi.setSleep(WIFI_PS_MAX_MODEM);
        
        // Additional Wi-Fi radio optimizations
        esp_wifi_set_max_tx_power(40); // Reduce TX power (40 = 4dBm)
        
        currentPowerMode = mode;
        Serial.println("Power mode: Minimum Power");
        return true;
        
      default:
        Serial.println("Invalid power mode");
        return false;
    }
  }
  
  // Dynamic power adjustment based on conditions
  void adaptivePowerManagement() {
    static unsigned long lastCheck = 0;
    unsigned long now = millis();
    
    // Check every 30 seconds
    if (now - lastCheck > 30000) {
      int32_t rssi = WiFi.RSSI();
      
      // Adjust power based on signal strength
      if (rssi > -60) {
        // Strong signal, can reduce power
        if (currentPowerMode != MINIMUM_POWER) {
          setPowerMode(MINIMUM_POWER);
        }
      } else if (rssi > -75) {
        // Moderate signal, balanced mode
        if (currentPowerMode != BALANCED) {
          setPowerMode(BALANCED);
        }
      } else {
        // Weak signal, need maximum performance
        if (currentPowerMode != MAX_PERFORMANCE) {
          setPowerMode(MAX_PERFORMANCE);
        }
      }
      
      lastCheck = now;
    }
  }
  
  // Get estimated battery life based on current configuration
  float estimateBatteryLife(float batteryCapacityMah, float averageCurrentMa) {
    if (averageCurrentMa <= 0) {
      // Provide typical current draws based on mode
      switch (currentPowerMode) {
        case MAX_PERFORMANCE: averageCurrentMa = 120.0; break;
        case BALANCED: averageCurrentMa = 80.0; break;
        case POWER_SAVE: averageCurrentMa = 50.0; break;
        case MINIMUM_POWER: averageCurrentMa = 30.0; break;
      }
    }
    
    if (batteryCapacityMah <= 0 || averageCurrentMa <= 0) {
      return 0.0;
    }
    
    return batteryCapacityMah / averageCurrentMa; // Hours
  }
};

class WiFiDiagnostic {
public:
  static void runFullDiagnostic() {
    Serial.println("\n=== ESP32 Wi-Fi Diagnostic ===");
    Serial.println("Starting comprehensive diagnostic...\n");
    
    // 1. Check Wi-Fi hardware
    Serial.println("1. Hardware Check:");
    checkWiFiHardware();
    
    // 2. Check current status
    Serial.println("\n2. Connection Status:");
    checkConnectionStatus();
    
    // 3. Scan networks
    Serial.println("\n3. Network Scan:");
    scanAndAnalyzeNetworks();
    
    // 4. Check configuration
    Serial.println("\n4. Configuration Check:");
    checkConfiguration();
    
    // 5. Performance test
    Serial.println("\n5. Performance Test:");
    testPerformance();
    
    Serial.println("\n=== Diagnostic Complete ===");
    Serial.println("Recommendations:");
    provideRecommendations();
  }
  
  static void checkWiFiHardware() {
    Serial.print("Wi-Fi MAC Address: ");
    Serial.println(WiFi.macAddress());
    
    Serial.print("Chip ID: ");
    Serial.println(ESP.getEfuseMac(), HEX);
    
    // Check if Wi-Fi is initialized
    if (WiFi.getMode() == WIFI_MODE_NULL) {
      Serial.println("WARNING: Wi-Fi not initialized!");
    } else {
      Serial.println("Wi-Fi initialized properly");
    }
  }
  
  static void checkConnectionStatus() {
    wl_status_t status = WiFi.status();
    
    Serial.print("Status: ");
    Serial.println(statusToString(status));
    
    if (status == WL_CONNECTED) {
      Serial.print("IP Address: ");
      Serial.println(WiFi.localIP());
      
      Serial.print("Subnet Mask: ");
      Serial.println(WiFi.subnetMask());
      
      Serial.print("Gateway: ");
      Serial.println(WiFi.gatewayIP());
      
      Serial.print("RSSI: ");
      Serial.print(WiFi.RSSI());
      Serial.println(" dBm");
      
      Serial.print("Channel: ");
      // Note: Channel information requires esp_wifi_get_channel() from ESP-IDF
    }
  }
  
  static String statusToString(wl_status_t status) {
    switch (status) {
      case WL_IDLE_STATUS: return "Idle";
      case WL_NO_SSID_AVAIL: return "No SSID Available";
      case WL_SCAN_COMPLETED: return "Scan Completed";
      case WL_CONNECTED: return "Connected";
      case WL_CONNECT_FAILED: return "Connect Failed";
      case WL_CONNECTION_LOST: return "Connection Lost";
      case WL_DISCONNECTED: return "Disconnected";
      default: return "Unknown";
    }
  }
  
  static void scanAndAnalyzeNetworks() {
    int n = WiFi.scanNetworks();
    
    if (n == 0) {
      Serial.println("No networks found. Possible issues:");
      Serial.println("  - Wi-Fi antenna disconnected");
      Serial.println("  - Severe interference");
      Serial.println("  - Hardware failure");
      return;
    }
    
    Serial.print("Found ");
    Serial.print(n);
    Serial.println(" networks:");
    
    for (int i = 0; i < n; i++) {
      Serial.print("  ");
      Serial.print(i + 1);
      Serial.print(". ");
      Serial.print(WiFi.SSID(i));
      Serial.print(" (");
      Serial.print(WiFi.RSSI(i));
      Serial.print(" dBm, Ch:");
      // Channel info would go here
      Serial.print(") ");
      
      // Security type
      switch (WiFi.encryptionType(i)) {
        case WIFI_AUTH_OPEN: Serial.println("[Open]"); break;
        case WIFI_AUTH_WPA_PSK: Serial.println("[WPA]"); break;
        case WIFI_AUTH_WPA2_PSK: Serial.println("[WPA2]"); break;
        case WIFI_AUTH_WPA_WPA2_PSK: Serial.println("[WPA/WPA2]"); break;
        default: Serial.println("[Other]");
      }
    }
  }
  
  static void checkConfiguration() {
    // Check common configuration issues
    Serial.print("Wi-Fi Mode: ");
    switch (WiFi.getMode()) {
      case WIFI_MODE_NULL: Serial.println("NULL"); break;
      case WIFI_MODE_STA: Serial.println("Station"); break;
      case WIFI_MODE_AP: Serial.println("Access Point"); break;
      case WIFI_MODE_APSTA: Serial.println("Station + AP"); break;
    }
    
    // Check if we're trying to connect while in AP mode
    if (WiFi.getMode() == WIFI_MODE_AP) {
      Serial.println("NOTE: In AP mode only. Cannot connect to other networks.");
    }
  }
  
  static void testPerformance() {
    if (WiFi.status() != WL_CONNECTED) {
      Serial.println("Not connected. Skipping performance test.");
      return;
    }
    
    // Simple ping test to gateway
    IPAddress gateway = WiFi.gatewayIP();
    Serial.print("Pinging gateway ");
    Serial.print(gateway);
    Serial.println("...");
    
    // Note: Actual ping implementation requires additional libraries
    // or custom ICMP implementation
  }
  
  static void provideRecommendations() {
    wl_status_t status = WiFi.status();
    
    switch (status) {
      case WL_NO_SSID_AVAIL:
        Serial.println("  - Verify SSID name is correct");
        Serial.println("  - Move device closer to router");
        Serial.println("  - Check if network is hidden (requires scan parameter)");
        break;
        
      case WL_CONNECT_FAILED:
        Serial.println("  - Verify password is correct");
        Serial.println("  - Check router security settings");
        Serial.println("  - Try rebooting router");
        break;
        
      case WL_CONNECTION_LOST:
        Serial.println("  - Check signal strength (aim for > -70 dBm)");
        Serial.println("  - Reduce interference from other devices");
        Serial.println("  - Consider adding Wi-Fi repeater");
        break;
        
      case WL_IDLE_STATUS:
        Serial.println("  - Call WiFi.begin() to start connection");
        break;
        
      case WL_DISCONNECTED:
        Serial.println("  - Check WiFi.begin() was called");
        Serial.println("  - Verify network credentials");
        break;
        
      case WL_CONNECTED:
        int32_t rssi = WiFi.RSSI();
        if (rssi < -75) {
          Serial.println("  - Signal is weak. Consider repositioning device");
          Serial.print("  - Current RSSI: ");
          Serial.print(rssi);
          Serial.println(" dBm");
        } else {
          Serial.println("  - Connection appears stable");
        }
        break;
    }
    
    // General recommendations
    Serial.println("\nGeneral troubleshooting steps:");
    Serial.println("  1. Power cycle ESP32");
    Serial.println("  2. Reboot router");
    Serial.println("  3. Update ESP32 Arduino core");
    Serial.println("  4. Check for firmware updates");
    Serial.println("  5. Test with simple example sketch");
  }
};

#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>

class WeatherStation {
private:
  // Configuration
  const char* ssid;
  const char* password;
  const char* apiKey;
  const char* city;
  
  // Managers
  WiFiConnectionManager* wifiManager;
  SignalAnalyzer* signalAnalyzer;
  WiFiPowerManager* powerManager;
  
  // Data
  float temperature;
  float humidity;
  float pressure;
  unsigned long lastUpdate;
  unsigned long updateInterval;
  
public:
  WeatherStation(const char* ssid, const char* password, 
                 const char* apiKey, const char* city)
    : ssid(ssid), password(password), apiKey(apiKey), city(city),
      temperature(0), humidity(0), pressure(0), 
      lastUpdate(0), updateInterval(300000) { // 5 minutes
    
    wifiManager = new WiFiConnectionManager(ssid, password);
    signalAnalyzer = new SignalAnalyzer(10000, -75, 5); // Check every 10s
    powerManager = new WiFiPowerManager();
  }
  
  void begin() {
    Serial.begin(115200);
    delay(1000);
    
    Serial.println("Weather Station Initializing...");
    
    // Start with maximum performance for initial connection
    powerManager->setPowerMode(WiFiPowerManager::MAX_PERFORMANCE);
    
    // Connect to Wi-Fi
    if (wifiManager->connect()) {
      Serial.println("Connected to Wi-Fi");
      
      // Switch to balanced mode for normal operation
      powerManager->setPowerMode(WiFiPowerManager::BALANCED);
      
      // Initial data fetch
      fetchWeatherData();
    } else {
      Serial.println("Failed to connect to Wi-Fi");
      // Could implement fallback to AP mode for configuration
    }
  }
  
  void loop() {
    unsigned long now = millis();
    
    // Manage connection
    wifiManager->manageConnection();
    
    // Monitor signal
    signalAnalyzer->update();
    
    // Adaptive power management
    powerManager->adaptivePowerManagement();
    
    // Update weather data periodically
    if (now - lastUpdate >= updateInterval) {
      if (WiFi.status() == WL_CONNECTED) {
        fetchWeatherData();
        lastUpdate = now;
      } else {
        Serial.println("Skipping update - not connected");
      }
    }
    
    // Display status periodically
    static unsigned long lastStatus = 0;
    if (now - lastStatus >= 60000) { // Every minute
      displayStatus();
      lastStatus = now;
    }
    
    delay(100); // Small delay to prevent watchdog issues
  }
  
  void fetchWeatherData() {
    Serial.println("Fetching weather data...");
    
    // Switch to higher power mode for data transfer
    powerManager->setPowerMode(WiFiPowerManager::MAX_PERFORMANCE);
    
    HTTPClient http;
    String url = "http://api.openweathermap.org/data/2.5/weather?q=";
    url += city;
    url += "&appid=";
    url += apiKey;
    url += "&units=metric";
    
    http.begin(url);
    int httpCode = http.GET();
    
    if (httpCode == HTTP_CODE_OK) {
      String payload = http.getString();
      
      // Parse JSON response
      DynamicJsonDocument doc(1024);
      deserializeJson(doc, payload);
      
      temperature = doc["main"]["temp"];
      humidity = doc["main"]["humidity"];
      pressure = doc["main"]["pressure"] / 100.0; // Convert to hPa
      
      Serial.print("Temperature: ");
      Serial.print(temperature);
      Serial.println(" °C");
      Serial.print("Humidity: ");
      Serial.print(humidity);
      Serial.println(" %");
      Serial.print("Pressure: ");
      Serial.print(pressure);
      Serial.println(" hPa");
    } else {
      Serial.print("HTTP Error: ");
      Serial.println(httpCode);
    }
    
    http.end();
    
    // Return to balanced mode
    powerManager->setPowerMode(WiFiPowerManager::BALANCED);
  }
  
  void displayStatus() {
    Serial.println("\n--- Weather Station Status ---");
    Serial.print("Wi-Fi: ");
    Serial.println(WiFi.status() == WL_CONNECTED ? "Connected" : "Disconnected");
    
    if (WiFi.status() == WL_CONNECTED) {
      Serial.print("Signal: ");
      Serial.print(signalAnalyzer->getSignalQualityPercent());
      Serial.println("%");
      
      Serial.print("IP: ");
      Serial.println(WiFi.localIP());
      
      Serial.print("Temperature: ");
      Serial.print(temperature);
      Serial.println(" °C");
      
      Serial.print("Last update: ");
      Serial.print((millis() - lastUpdate) / 1000);
      Serial.println(" seconds ago");
    }
    
    Serial.println("---------------------------");
  }
  
  // Get estimated battery life (assuming 18650 battery)
  float getBatteryLifeEstimate() {
    return powerManager->estimateBatteryLife(2600.0, 0); // 2600mAh battery
  }
};

// Usage example
// WeatherStation station("MyWiFi", "password123", "your_api_key", "London");
// station.begin();
// In loop(): station.loop();