How to Implement an Arduino restore_wifi Routine for ESP32 Dropped Connections

The Core Problem: Why ESP32 WiFi Drops and Fails to Reconnect

If you have deployed an ESP32-based IoT node in the field, you have likely encountered the silent killer of telemetry: the unhandled WiFi drop. Unlike a desktop PC, a microcontroller does not have an OS-level network manager to automatically renegotiate DHCP leases or switch to a 5GHz fallback. When the connection drops, the Arduino WiFi.h library often leaves the LWIP (Lightweight IP) TCP/IP stack in a hung state.

You will typically see this manifest in your serial monitor with one of the following exact error strings:

• [E][wifi_sta.cpp:412] sta_event_handler(): Disconnect reason: 201 (NO_AP_FOUND - The router rebooted or changed channels).
• [E][wifi_sta.cpp:412] sta_event_handler(): Disconnect reason: 8 (ASSOC_LEAVE - The router forcibly deauthenticated the ESP32, often due to DHCP lease expiry).
• [E][WiFiGeneric.cpp:145] wifiLowLevelInit(): Failed to initialize WiFi (Memory corruption or brownout during the reconnect attempt).

To solve this, we do not rely on the built-in reconnect methods. Instead, we write a custom restore_wifi routine that forces a full stack teardown and rebuild. According to the Espressif WiFi Driver Documentation, explicitly stopping and restarting the WiFi driver is the only guaranteed way to clear stale LWIP states after a severe disconnect event.

Parts List and Pin Mapping for the Test Rig

This implementation targets the most common board variant in the wild: the ESP32-WROOM-32 DevKit V1 (30-pin). Do not use the older 38-pin ESP32-WROVER boards for this specific pin mapping, as the internal flash routing differs.

Pin Mapping Table

The Decision Tree: Choosing Your Reconnect Strategy

Not all IoT nodes have the same power or latency constraints. Use this decision path to select the correct reconnect architecture for your build.

The Complete restore_wifi Implementation (ESP32 Core v3.x)

The following code is fully compilable in the Arduino IDE (ensure you have the esp32 board package v3.0.x or newer installed via the Espressif Arduino Core GitHub board manager URL). It uses the modern ARDUINO_EVENT_ macros, which replaced the deprecated SYSTEM_EVENT_ macros in recent IDF v5.1 ports.

#include <WiFi.h>

// --- PIN DEFINITIONS ---
#define PIN_STATUS_LED 25

// --- NETWORK CREDENTIALS ---
const char* WIFI_SSID = "YourNetworkSSID";
const char* WIFI_PASS = "YourNetworkPassword";

// --- RECONNECT STATE VARIABLES ---
unsigned long lastReconnectAttempt = 0;
const unsigned long reconnectInterval = 5000; // 5-second backoff
bool wifiDisconnected = false;

// --- WIFI EVENT HANDLER ---
void WiFiEvent(WiFiEvent_t event) {
  switch(event) {
    case ARDUINO_EVENT_WIFI_STA_CONNECTED:
      Serial.println("[WiFi] Connected to AP.");
      digitalWrite(PIN_STATUS_LED, HIGH);
      wifiDisconnected = false;
      break;
      
    case ARDUINO_EVENT_WIFI_STA_DISCONNECTED:
      Serial.println("[WiFi] Disconnected from AP.");
      digitalWrite(PIN_STATUS_LED, LOW);
      wifiDisconnected = true;
      break;
      
    case ARDUINO_EVENT_WIFI_STA_GOT_IP:
      Serial.print("[WiFi] IP Address: ");
      Serial.println(WiFi.localIP());
      break;
  }
}

// --- THE RESTORE ROUTINE ---
void restore_wifi() {
  // Only attempt reconnect if disconnected AND backoff timer has elapsed
  if (wifiDisconnected && (millis() - lastReconnectAttempt > reconnectInterval)) {
    lastReconnectAttempt = millis();
    Serial.println("[restore_wifi] Tearing down LWIP stack and restarting radio...");
    
    // CRITICAL: wifiOff() or disconnect(true) clears the DHCP state machine
    WiFi.disconnect(true, true); 
    delay(100); // Allow RF capacitor discharge and state flush
    
    // Restart the WiFi driver
    WiFi.begin(WIFI_SSID, WIFI_PASS);
  }
}

void setup() {
  Serial.begin(115200);
  delay(500); // Allow serial monitor to attach
  
  pinMode(PIN_STATUS_LED, OUTPUT);
  digitalWrite(PIN_STATUS_LED, LOW);
  
  // Register event listener BEFORE calling WiFi.begin()
  WiFi.onEvent(WiFiEvent);
  
  // Disable power saving to prevent micro-drops on weak routers
  WiFi.setSleep(false); 
  
  Serial.println("[Setup] Initiating first WiFi connection...");
  WiFi.begin(WIFI_SSID, WIFI_PASS);
}

void loop() {
  // Call the restore routine on every loop pass (non-blocking)
  restore_wifi();
  
  // --- YOUR APPLICATION LOGIC HERE ---
  // Example: Read sensor, publish MQTT, etc.
  // Ensure all logic here is non-blocking (no delay() calls)
}

Why WiFi.disconnect(true, true) is Mandatory

Passing true, true to the disconnect method tells the ESP32 to not only disconnect from the Access Point but also to erase the stored WiFi credentials and flush the internal LWIP DHCP client state. If you omit this, and your router reboots and assigns a different subnet (e.g., changing from 192.168.1.x to 192.168.0.x), the ESP32 will associate with the radio but fail to route TCP packets, resulting in a "ghost connection" where WiFi.status() reports WL_CONNECTED but ping fails.

Troubleshooting: First Three Things to Check When It Fails

If your serial monitor shows the restore_wifi routine firing repeatedly without achieving a GOT_IP event, halt your debugging and check these three physical and logical layers in order:

1. Measure the 3.3V Rail Under Load (Hardware): Connect your multimeter or oscilloscope to the 3V3 pin and GND. Trigger the ESP32 to connect. If the voltage dips below 3.15V during the TX burst, the onboard AMS1117-3.3 regulator is browning out. Fix: Solder a 470µF electrolytic capacitor and a 100nF ceramic capacitor in parallel directly across the 5V and GND pins on the DevKit to handle transient current spikes.
2. Verify the WiFi Event Macros (Software): If you copied code from a tutorial written before 2024, it likely uses SYSTEM_EVENT_STA_DISCONNECTED. In ESP32 Core v3.x, these macros were renamed to ARDUINO_EVENT_WIFI_STA_DISCONNECTED. Using the old macros will result in the event handler never firing, meaning wifiDisconnected remains false and the restore routine never triggers.
3. Check Router "Airtime Fairness" and Band Steering (Network): Modern mesh routers (like Eero or TP-Link Deco) aggressively deauthenticate 2.4GHz devices that do not support 802.11ax (WiFi 6) to free up airtime. The ESP32-WROOM-32 is an 802.11 b/g/n device. Fix: Log into your router admin panel and disable "Airtime Fairness" or create a dedicated 2.4GHz IoT SSID with Band Steering disabled.

Extending and Simplifying the Build

Once the baseline restore_wifi routine is stable, you should adapt it to your specific project architecture.

How to Extend: Add Task Watchdog and MQTT Sync

For mission-critical nodes, a WiFi drop often means your MQTT client is also dead. Extend the ARDUINO_EVENT_WIFI_STA_GOT_IP case in the event handler to trigger your MQTT reconnect function. Furthermore, wrap your main loop in an ESP32 Task Watchdog (esp_task_wdt). If the LWIP stack locks up the CPU in an infinite wait state, the watchdog will trigger a hardware reset, which is the ultimate failsafe for field-deployed hardware.

How to Simplify: The Polling Fallback

If you are building a simple data logger where a 10-second delay in reconnecting is acceptable, and you want to save RAM by avoiding the event listener queue, strip out the WiFi.onEvent() entirely. Replace the restore_wifi() logic with a simple polling check:

if (WiFi.status() != WL_CONNECTED && millis() - lastCheck > 10000) {
  WiFi.disconnect(true, true);
  WiFi.begin(SSID, PASS);
  lastCheck = millis();
}

This removes the interrupt-driven event overhead, simplifying the codebase at the cost of slightly slower disconnect detection. Choose the event-driven method for real-time actuators; choose polling for slow environmental sensors.