ESP32 Relay Wiring Guide: Safe 120V/240V Switching & Boot Pin Pitfalls

The Core Challenge: ESP32 GPIO Limits vs. Relay Coil Demands

You cannot drive a standard 5V mechanical relay coil directly from an ESP32 GPIO pin. The ESP32 outputs 3.3V logic and can safely source only ~40mA per pin (absolute maximum), while a standard SRD-05VDC-SL-C relay coil requires 5V and draws 70-90mA. Attempting to wire a raw relay directly to a GPIO pin will result in a weak magnetic field, contact chatter, and eventually a fried ESP32 silicon trace.

The correct approach is using a relay module equipped with an optocoupler (like the PC817) and a transistor driver circuit. However, even with a module, the ESP32 introduces a unique embedded hurdle: strapping pins. During boot, the ESP32 reads specific GPIO pins to determine its boot mode. If a relay module pulls one of these pins high or low at the exact moment of power-on, the ESP32 will enter a boot loop or fail to flash.

For a complete breakdown of ESP32 pin behaviors during the boot sequence, refer to the official Espressif ESP32 Hardware Design Guidelines.

Parts List & Pin Mapping Matrix

This guide targets the ESP32 DevKit V1 (30-pin variant) paired with a standard 4-channel 5V relay module. Do not use the 38-pin variant without adjusting for the shifted GND and 3V3 pins.

Required Components

• Microcontroller: ESP32 DevKit V1 (30-pin, ESP32-WROOM-32 module)
• Relay Module: 4-Channel 5V Relay Module with Optocoupler (SRD-05VDC-SL-C relays, 10A @ 120VAC / 10A @ 240VAC)
• Power Supply: 5V 2A (minimum) USB wall adapter (Do not use a standard laptop USB port; it cannot handle relay coil inrush)
• Wiring: 22 AWG stranded hook-up wire for low voltage; 14 AWG THHN for mains voltage connections
• Flyback Protection: Built into the module via 1N4148 diodes (verify they are populated on your specific board)

Pin Mapping Table

Step-by-Step Wiring & Isolation Protocol

Before touching any mains wiring, we must address the low-voltage control side. Most cheap relay modules feature a jumper labeled JD-VCC. Understanding this jumper is the difference between a safe, isolated build and one that feeds 120V AC noise straight into your ESP32's 3.3V logic rail.

Phase 1: Low Voltage Control Wiring

1. Verify the JD-VCC Jumper: For basic projects, leave the JD-VCC jumper in place. This powers both the relay coils and the optocoupler LEDs from the ESP32's VIN pin. Pro-Tip: For true galvanic isolation in noisy industrial environments, remove the jumper, supply 5V directly to the JD-VCC and GND pins on the relay side, and only connect the ESP32 GND to the module's input GND.
2. Connect Power: Wire the ESP32 VIN to the module VCC, and ESP32 GND to module GND.
3. Connect Logic: Wire GPIO 25, 26, 27, and 14 to IN1, IN2, IN3, and IN4 respectively.
4. Verify Flyback Diodes: Look at the relay module PCB. Ensure there is a small glass diode (usually 1N4148) wired in reverse parallel across each relay coil. If your module lacks these, you must solder them in. Without them, the collapsing magnetic field of the coil will generate a high-voltage spike that can reset or destroy the ESP32. See All About Circuits' guide on flyback diodes for the physics behind this.

Phase 2: Mains Voltage Termination (Safety Critical)

1. Identify Terminals: Each relay has three mains terminals: NC (Normally Closed), COM (Common), and NO (Normally Open).
2. Wire the Load: For a standard light or pump that should turn ON when the ESP32 triggers the relay, wire your AC Hot (Line) into the COM terminal, and wire the load's Hot input into the NO terminal.
3. Neutral and Ground: The relay module does not switch the Neutral wire. Wire the AC Neutral directly to the load using a wire nut or Wago connector. Bond the equipment grounding conductor (bare copper or green) directly to the load's chassis ground.
4. Strain Relief: Ensure all 14 AWG THHN wires are seated fully in the blue terminal blocks and that no stray copper strands are bridging adjacent terminals.

Complete Arduino IDE Control Code

This code targets the ESP32 DevKit V1. It includes safe boot states (ensuring relays default to OFF before the setup routine completes), a simple serial command interface, and integration with the ESP32 Task Watchdog Timer (WDT) to recover from firmware lockups caused by electrical noise.

#include <Arduino.h>
#include <esp_task_wdt.h>

// Pin Definitions (Avoiding strapping pins 0, 2, 12, 15)
#define RELAY_1 25
#define RELAY_2 26
#define RELAY_3 27
#define RELAY_4 14

// Relay Logic: Most 5V modules are Active LOW
// HIGH = Relay OFF (Optocoupler LED off)
// LOW = Relay ON (Optocoupler LED on)
#define RELAY_ON  LOW
#define RELAY_OFF HIGH

const int relayPins[] = {RELAY_1, RELAY_2, RELAY_3, RELAY_4};
const int numRelays = 4;

void setup() {
  Serial.begin(115200);
  delay(500); // Allow serial monitor to connect
  
  Serial.println("[BOOT] Initializing ESP32 Relay Controller...");

  // 1. Initialize Watchdog Timer (3 second timeout)
  esp_task_wdt_init(3, true);
  esp_task_wdt_add(NULL);

  // 2. Configure Pins and set SAFE STATE immediately
  // This prevents relays from chattering or turning on during boot
  for (int i = 0; i < numRelays; i++) {
    pinMode(relayPins[i], OUTPUT);
    digitalWrite(relayPins[i], RELAY_OFF);
  }
  
  Serial.println("[READY] All relays OFF. Awaiting serial commands (1-4 to toggle, 0 for all off).");
}

void loop() {
  // Reset Watchdog Timer to prevent reboot
  esp_task_wdt_reset();

  if (Serial.available() > 0) {
    char cmd = Serial.read();
    
    // Error Handling: Ignore newline/carriage return characters
    if (cmd == '\n' || cmd == '\r') return;

    int relayIndex = cmd - '0'; // Convert char to int

    if (relayIndex == 0) {
      // Emergency Stop: Turn all relays off
      for (int i = 0; i < numRelays; i++) {
        digitalWrite(relayPins[i], RELAY_OFF);
      }
      Serial.println("[CMD] All relays turned OFF.");
    } 
    else if (relayIndex >= 1 && relayIndex <= numRelays) {
      // Toggle specific relay
      int pin = relayPins[relayIndex - 1];
      int currentState = digitalRead(pin);
      int newState = (currentState == RELAY_ON) ? RELAY_OFF : RELAY_ON;
      
      digitalWrite(pin, newState);
      Serial.printf("[CMD] Relay %d toggled to %s.\n", relayIndex, (newState == RELAY_ON) ? "ON" : "OFF");
    } 
    else {
      Serial.printf("[ERROR] Invalid command '%c'. Use 1-4 to toggle, 0 for all off.\n", cmd);
    }
  }
  
  delay(50); // Small debounce/delay to yield to background WiFi/BT tasks
}

Debugging: "Brownout detector was triggered" & Boot Failures

The most common point of failure in ESP32 relay builds is the dreaded brownout reset. When the relay coil engages, it draws a sudden inrush of current. If your power delivery cannot handle it, the ESP32's internal voltage monitor trips a hardware reset to protect the flash memory.

The Exact Error String

If you open the Arduino IDE Serial Monitor at 115200 baud and see this exact block repeating, you have a power delivery failure:

Brownout detector was triggered

abort() was called at PC 0x400d78db on core 1
Backtrace: 0x4008...
ets_main.c 371

First Three Things to Check When It Fails

1. Check your USB Cable and Power Brick: Standard laptop USB ports supply only 500mA. A 4-channel relay module with all coils energized draws ~360mA, plus the ESP32's WiFi radio spikes to ~240mA during transmission. This totals ~600mA, causing severe voltage drop across cheap, thin USB cables. Fix: Use a dedicated 5V 2A (or higher) wall adapter and a high-quality, short USB cable.
2. Verify You Aren't Powering Coils from 3V3: A fatal beginner mistake is wiring the relay module's VCC to the ESP32's 3V3 pin instead of the VIN (5V) pin. The 3V3 regulator on the DevKit V1 can only supply ~500mA total and will instantly overheat and shut down when a 5V relay coil attempts to draw current through it. Fix: Move VCC to the VIN/5V pin.
3. Inspect for Missing Flyback Diodes: If the module lacks reverse-biased diodes across the coils, the inductive kickback (Back-EMF) when the relay turns off generates a 50V+ spike that couples into the ESP32's ground plane, triggering a brownout or silicon latch-up. Fix: Solder 1N4148 diodes across the coil pins (cathode to positive, anode to negative).

Extending and Simplifying the Build

Once you have the basic mechanical relay setup running, you will likely want to adapt it for specific real-world environments. Here is how to scale the design up or down.

Simplify: Switch to Solid State Relays (SSRs)

Mechanical relays (like the SRD-05VDC) are loud, suffer from contact arcing, and have a finite lifespan of ~100,000 cycles. If you are switching resistive loads (like heaters or incandescent lights) or need silent operation, replace the mechanical module with an Omron G3MB-202P Solid State Relay module.

• Pros: Zero-crossing switching (eliminates inrush current spikes), completely silent, no moving parts, optically isolated by default.
• Cons: Generates heat (requires a heatsink for loads >2A), cannot switch DC loads (triacs only latch off when AC current crosses zero), and has a small leakage current when "off".
• Wiring Note: SSR modules usually require 5V logic but draw only ~15mA per channel, meaning you can safely drive them closer to the ESP32's GPIO limits, though a driver transistor is still recommended for longevity.

Extend: Add MQTT for Home Assistant Integration

To move from a serial-controlled bench project to a deployed smart home node, integrate the PubSubClient library. By connecting the ESP32 to your local WiFi and an MQTT broker (like Mosquitto), you can map Home Assistant switch entities directly to the GPIO pins. When extending to MQTT, ensure you add a WiFi reconnect routine and utilize the ESP32's deep sleep or modem sleep features to prevent the WROOM module from overheating inside an enclosed plastic junction box.