# v1.9.2 - WiFi Resilience

## Problem in v1.9.1

**Symptoms:**
- After WiFi outage (router restart, temporary network issues), device enters AP mode
- WiFi credentials are cleared, requiring manual reconfiguration
- User must reconnect to "TJ56654-Setup" AP and re-enter WiFi password
- This happens every time WiFi goes down temporarily

**Root Cause:**

Aggressive credential clearing after connection failures:
```cpp
void processWiFiConnection() {
  // After 5 failed attempts...
  if (wifiRetry.currentRetry >= wifiRetry.maxRetries) {
    // Clear credentials!
    memset(config.ssid, 0, sizeof(config.ssid));
    memset(config.password, 0, sizeof(config.password));
    saveConfig();

    // Start AP mode for reconfiguration
    WiFiManager wm;
    wm.startConfigPortal("TJ56654-Setup", "12345678");
  }
}
```

**Impact:**
- Poor user experience during network outages
- Unnecessary manual intervention required
- Device unusable until reconfigured

## Solution: Resilient WiFi

### Key Changes

| Feature | Before (v1.9.1) | After (v1.9.2) |
|---------|-----------------|----------------|
| Credential clearing | After 5 failed attempts | Never |
| Retry strategy | Give up after 5 tries | Infinite retries |
| Retry interval | Fixed 5 seconds | Exponential backoff (5s-5min) |
| Fallback AP | After clearing credentials | After ~5 min (keeps credentials) |
| Clock during outage | Shows connection counter | Shows last synced time |
| User notification | Numeric counter | "No WiFi" message |

### Implementation

#### 1. WiFi Retry Configuration

```cpp
// Infinite retries with exponential backoff
struct WiFiRetryConfig {
  uint8_t currentRetry = 0;
  unsigned long nextRetryTime = 0;
  static const unsigned long MAX_BACKOFF_MS = 300000;  // Max 5 minutes

  unsigned long getBackoffDelay() {
    // 5s, 10s, 20s, 40s, 80s, 160s, 300s (max)
    unsigned long delay = 5000UL * (1UL << currentRetry);
    return (delay > MAX_BACKOFF_MS) ? MAX_BACKOFF_MS : delay;
  }

  void recordAttempt() {
    currentRetry++;
    nextRetryTime = millis() + getBackoffDelay();
  }

  void reset() {
    currentRetry = 0;
    nextRetryTime = 0;
  }
};
```

#### 2. No Credential Clearing

```cpp
void processWiFiConnection() {
  if (WiFi.status() == WL_CONNECTED) {
    if (wifiConnState != WIFI_CONN_CONNECTED) {
      Serial.println("WiFi connected!");
      wifiConnState = WIFI_CONN_CONNECTED;
      wifiRetry.reset();

      // Disable fallback AP if it was enabled
      if (WiFi.getMode() == WIFI_AP_STA) {
        Serial.println("Disabling fallback AP");
        WiFi.mode(WIFI_STA);
      }
    }
    return;
  }

  // Connection failed - but DON'T clear credentials!
  if (millis() >= wifiRetry.nextRetryTime) {
    Serial.printf("WiFi retry %d, next in %lu sec\n",
                  wifiRetry.currentRetry,
                  wifiRetry.getBackoffDelay() / 1000);

    wifiRetry.recordAttempt();

    // Try to connect with SDK or EEPROM credentials
    if (strlen(config.password) > 0) {
      WiFi.begin(config.ssid, config.password);
    } else {
      WiFi.begin();  // Use SDK-stored credentials
    }

    // Enable fallback AP after 5+ attempts (~2.5 min)
    if (wifiRetry.currentRetry >= 5 && WiFi.getMode() != WIFI_AP_STA) {
      Serial.println("Enabling fallback AP (dual mode)");
      WiFi.mode(WIFI_AP_STA);
      WiFi.softAP("TJ56654-Setup", "12345678");
    }
  }
}
```

#### 3. "No WiFi" Display

```cpp
void ICACHE_FLASH_ATTR showNoWiFi(unsigned long nextRetrySeconds) {
  display.clearDisplay();
  display.setTextSize(2);
  display.setTextColor(SSD1306_WHITE);

  // Center "No WiFi" text
  display.setCursor(20, 8);
  display.println("No WiFi");

  // Show retry countdown
  display.setTextSize(1);
  display.setCursor(10, 52);
  if (nextRetrySeconds < 60) {
    display.printf("Retry in %lu sec", nextRetrySeconds);
  } else {
    display.printf("Retry in %lu min", nextRetrySeconds / 60);
  }

  display.display();
}
```

#### 4. Clock Continues During Outage

```cpp
void updateDisplay() {
  if (WiFi.status() != WL_CONNECTED) {
    // Show "No WiFi" status
    unsigned long nextRetry = (wifiRetry.nextRetryTime > millis())
                             ? (wifiRetry.nextRetryTime - millis()) / 1000
                             : 0;
    showNoWiFi(nextRetry);
    return;
  }

  // Normal display modes when WiFi is connected
  // ...
}
```

#### 5. WiFi Disconnect Indicator

When WiFi is disconnected but time is still valid, show "!" in date line:
```cpp
void showTimeMode() {
  // ... time display ...

  // Date line with WiFi status indicator
  display.setCursor(0, 0);
  if (WiFi.status() != WL_CONNECTED) {
    display.print("! ");  // WiFi disconnected indicator
  }
  display.print(dateString);
}
```

#### 6. SDK Credentials Support

WiFiManager stores credentials in ESP SDK flash, not EEPROM. This caused issues after OTA updates:

```cpp
void setupWiFi() {
  // Try SDK-stored credentials first (from WiFiManager)
  if (strlen(config.password) > 0) {
    // EEPROM has credentials - use them
    WiFi.begin(config.ssid, config.password);
  } else {
    // EEPROM empty - try SDK credentials
    WiFi.begin();  // Uses last saved WiFi from SDK
  }
}
```

## Retry Backoff Schedule

| Attempt | Delay | Cumulative Time |
|---------|-------|-----------------|
| 1 | 5 sec | 5 sec |
| 2 | 10 sec | 15 sec |
| 3 | 20 sec | 35 sec |
| 4 | 40 sec | 1 min 15 sec |
| 5 | 80 sec | 2 min 35 sec |
| 6 | 160 sec | 5 min 15 sec |
| 7+ | 300 sec (5 min) | +5 min each |

**Fallback AP enabled after attempt 5** (~2.5 min of failures)

## Network Activity Summary

| Service | Interval | Endpoint | Protocol | Daily Requests |
|---------|----------|----------|----------|----------------|
| NTP | 1 hour | pool.ntp.org:123 | UDP | 24 |
| Weather | 30 min | api.open-meteo.com | HTTP | 48 |
| mDNS | continuous | 224.0.0.251 | UDP multicast | N/A |

**Total**: ~50-75 requests/day (minimal network load)

## Dual STA+AP Mode

When fallback AP is enabled, device operates in dual mode:
- **STA (Station)**: Continues trying to connect to configured WiFi
- **AP (Access Point)**: Allows user to reconfigure if needed

```cpp
// Enable dual mode
WiFi.mode(WIFI_AP_STA);
WiFi.softAP("TJ56654-Setup", "12345678");

// Continue WiFi connection attempts in STA mode
WiFi.begin(config.ssid, config.password);
```

When WiFi reconnects:
```cpp
if (WiFi.status() == WL_CONNECTED && WiFi.getMode() == WIFI_AP_STA) {
  // Disable AP, return to STA-only mode
  WiFi.mode(WIFI_STA);
  Serial.println("WiFi reconnected, disabled fallback AP");
}
```

## Test Scenarios

### Scenario 1: Router Restart (5 minutes)

**Before (v1.9.1):**
1. WiFi disconnects
2. 5 retry attempts (25 seconds)
3. Credentials cleared
4. Device enters AP mode
5. User must reconfigure WiFi

**After (v1.9.2):**
1. WiFi disconnects
2. Retry with backoff (5s, 10s, 20s, 40s, 80s)
3. After ~2.5 min: Fallback AP enabled (dual mode)
4. Device continues retrying
5. Router comes back
6. Device reconnects automatically
7. Fallback AP disabled
8. No user intervention needed

### Scenario 2: Extended Outage (30+ minutes)

**v1.9.2 Behavior:**
1. Retries every 5 minutes after initial backoff
2. Fallback AP available for reconfiguration if needed
3. Clock shows last synced time
4. "No WiFi" indicator on display
5. Reconnects automatically when WiFi returns

### Scenario 3: OTA Update

**Problem**: WiFiManager stores credentials in SDK flash, but our EEPROM may be empty after update.

**Solution**: Try SDK credentials first:
```cpp
if (strlen(config.password) > 0) {
  WiFi.begin(config.ssid, config.password);
} else {
  WiFi.begin();  // SDK credentials
}
```

## Memory Impact

| Resource | v1.9.1 | v1.9.2 | Change |
|----------|--------|--------|--------|
| RAM | 37,644 | 37,800 | +156 bytes |
| IRAM | 61,987 | 61,987 | 0 bytes |
| Flash | 408,844 | 409,100 | +256 bytes |

Minimal memory increase (+0.4%) for significant UX improvement.

## Conclusion

**v1.9.2 provides true WiFi resilience:**
- Never clears credentials
- Infinite retries with smart backoff
- Fallback AP for emergency reconfiguration
- Clock continues during outages
- Clear user feedback on display

**Results:**
- No more manual reconfiguration after WiFi outages
- Device recovers automatically when network returns
- User can still reconfigure via fallback AP if needed
- Minimal network overhead (~50 requests/day)

**Status**: Production ready