Build an ESP32 Monitor to Enforce Electrical Panel Clearance Code

The Electrical Panel Clearance Code: NEC 110.26 Explained

If you have ever stacked moving boxes, a workbench, or a water heater in front of a breaker box, you have violated the electrical panel clearance code. Under NFPA 70 (National Electrical Code) Article 110.26, electrical equipment operating at 600 volts or less requires a dedicated, unobstructed working space. For standard residential and light commercial panels, this means a minimum clearance of 36 inches deep (914 mm), 30 inches wide (or the width of the equipment, whichever is greater), and 6.5 feet high.

Why does this matter on the bench and in the field? It is not just about keeping inspectors happy. The 36-inch depth provides an arc-flash safety buffer and physical room for an electrician to pull back on large gauge feeders (like 2/0 AWG aluminum) which have massive bending radii. When homeowners or facility managers encroach on this space, they create a severe safety hazard. To solve this in a smart-facility context, we are going to build an automated clearance monitor using an ESP32 and a precision Time-of-Flight (ToF) sensor that alerts you the moment the 36-inch boundary is breached.

Sensor Selection: Decision Tree for the 36-Inch Zone

Choosing the right sensor to monitor the electrical panel clearance code requires balancing range, beam width, and ambient light rejection. Here is the decision path that leads to our final hardware pick:

The Verdict: Ultrasonic sensors bounce off adjacent door frames and wall moldings, causing false 'code violation' alerts. The TF-Luna is great but requires hardware serial pins, which we prefer to reserve for debugging. The VL53L1X Time-of-Flight sensor wins. It uses a Class 1 laser to measure photon flight time, operates reliably up to 4 meters, allows us to define a Region of Interest (ROI) to ignore the floor, and communicates over standard I2C.

Parts List and Pin Mapping

This build targets the ESP32-WROOM-32 DevKit V1 (30-pin variant). The code utilizes the native I2C bus and an active buzzer module for local alerts.

Bill of Materials (BOM)

• Microcontroller: ESP32-WROOM-32 DevKit V1 (30-pin)
• Sensor: Pololu VL53L1X Time-of-Flight Distance Sensor Carrier (Product #3415)
• Alert: 3.3V/5V Active Buzzer Module (KY-012 or similar)
• Power: 5V 2A USB-C power supply
• Wiring: 22 AWG stranded silicone wire, heat shrink tubing

Pin Mapping Table

Step-by-Step Assembly and Compilable Code

1. Prep the Sensor: Solder the included 90-degree header pins to the Pololu VL53L1X breakout. Ensure the XSHUT pin is left unconnected (pulled high internally) so the sensor stays on.
2. Wire the I2C Bus: Connect SDA to GPIO 21 and SCL to GPIO 22. Pro-tip: The Pololu board includes onboard 10kΩ pull-up resistors. If your I2C bus hangs, verify you aren't adding redundant external pull-ups that are dragging the signal down.
3. Mount the Hardware: Secure the ESP32 and sensor to a 3D-printed bracket or directly to the drywall opposite the panel. Aim the sensor precisely at the center of the panel door.
4. Flash the Code: Install the VL53L1X library by Pololu via the Arduino IDE Library Manager. Select 'DOIT ESP32 DEVKIT V1' as your board, set the flash frequency to 80MHz, and upload the following sketch.

#include <Wire.h>
#include <VL53L1X.h>

// --- Pin Definitions for ESP32-WROOM-32 DevKit V1 ---
#define SDA_PIN 21
#define SCL_PIN 22
#define BUZZER_PIN 13
#define STATUS_LED 2 // Built-in blue LED on most DevKits

// --- NEC 110.26 Clearance Threshold ---
// 36 inches = 914.4 mm. We set threshold to 915mm.
const uint16_t CLEARANCE_THRESHOLD_MM = 915;

// Debounce timing to prevent flickering alerts
unsigned long lastAlertTime = 0;
const unsigned long ALERT_COOLDOWN_MS = 5000;

VL53L1X sensor;

void setup() {
  Serial.begin(115200);
  Wire.begin(SDA_PIN, SCL_PIN);
  Wire.setClock(400000); // Use 400 kHz I2C

  pinMode(BUZZER_PIN, OUTPUT);
  pinMode(STATUS_LED, OUTPUT);
  digitalWrite(BUZZER_PIN, LOW);
  digitalWrite(STATUS_LED, LOW);

  sensor.setTimeout(500);
  if (!sensor.init()) {
    Serial.println("Failed to detect and initialize sensor!");
    // Halt and flash LED to indicate fatal hardware error
    while (1) {
      digitalWrite(STATUS_LED, HIGH); delay(100);
      digitalWrite(STATUS_LED, LOW); delay(100);
    }
  }

  // Configure for long distance mode (up to 4m)
  sensor.setDistanceMode(VL53L1X::Long);
  sensor.setMeasurementTimingBudget(50000); // 50ms budget
  sensor.startContinuous(50); // Read every 50ms
  
  Serial.println("Sensor initialized. Monitoring 36-inch clearance...");
}

void loop() {
  uint16_t distance = sensor.read();

  // Error Handling: Check for I2C Timeout
  if (sensor.timeoutOccurred()) {
    Serial.println("VL53L1X: I2C timeout");
    return;
  }

  // Filter out-of-range readings (sensor returns 0 or 8190 on error)
  if (distance == 0 || distance > 4000) {
    return; 
  }

  Serial.print("Distance (mm): ");
  Serial.println(distance);

  // Evaluate NEC 110.26 Compliance
  if (distance < CLEARANCE_THRESHOLD_MM) {
    unsigned long currentTime = millis();
    if (currentTime - lastAlertTime > ALERT_COOLDOWN_MS) {
      triggerViolationAlert(distance);
      lastAlertTime = currentTime;
    }
    digitalWrite(STATUS_LED, HIGH);
  } else {
    digitalWrite(STATUS_LED, LOW);
    digitalWrite(BUZZER_PIN, LOW); // Ensure buzzer is off when clear
  }
}

void triggerViolationAlert(uint16_t dist) {
  Serial.println("*** CODE VIOLATION: 36-inch clearance breached! ***");
  // Sound active buzzer for 500ms
  digitalWrite(BUZZER_PIN, HIGH);
  delay(500);
  digitalWrite(BUZZER_PIN, LOW);
}

Debugging: Fixing 'Failed to detect and initialize sensor!'

When working with I2C sensors on the ESP32, the most common point of failure is bus initialization. If your serial monitor outputs the exact string Failed to detect and initialize sensor!, the ESP32 cannot handshake with the VL53L1X. Do not assume the sensor is dead; follow this ranked cause list.

Ranked Causes and Fixes

1. Missing or Conflicting Pull-Up Resistors (Most Likely): I2C requires pull-ups to function. The Pololu VL53L1X has 10kΩ pull-ups enabled by default. If you are using a generic clone board without pull-ups, the SDA/SCL lines will float, causing initialization to fail. Fix: Add external 4.7kΩ resistors from SDA to 3.3V and SCL to 3.3V.
2. Logic Level Overvoltage Damage: The VL53L1X is strictly a 3.3V device. If you accidentally wired the VIN pin to the ESP32's 5V (VIN) pin, or if you are using a 5V Arduino Uno instead of the ESP32 without a logic level converter, you have likely fried the sensor's I2C transceiver. Fix: Replace the sensor and verify VCC is exactly 3.3V.
3. XSHUT Pin Held Low: The XSHUT pin is an active-low hardware reset. If it is accidentally shorted to ground, the chip stays in sleep mode. Fix: Ensure XSHUT is either left floating (internal pull-up handles it) or tied directly to 3.3V.

Extending and Simplifying the Build

The base code above provides a standalone, audible alert. Depending on your deployment environment, you will want to modify the output stage.

How to Simplify (The 'Dumb' Indicator)

If you are installing this in a noisy mechanical room where a buzzer will be ignored, strip out the buzzer code and wire a NE-51 Neon Indicator Lamp (rated for 120V AC) via a mechanical relay module. Mount the neon lamp directly above the panel door. When the ESP32 detects a violation, it triggers the relay, illuminating a hardwired red light that facility managers cannot ignore. Ensure the relay module is rated for the lamp's inrush current and housed in a NEMA 1 enclosure.

How to Extend (Smart Facility MQTT Integration)

For commercial buildings, local buzzers are insufficient. To log electrical panel clearance code violations over time, integrate the PubSubClient library. Add your WiFi credentials and publish the distance payload to an MQTT broker (like Mosquitto or AWS IoT Core):

// Add inside the loop() when a violation occurs:
char payload[50];
snprintf(payload, sizeof(payload), "{\"panel_id\":\"Main_South\",\"dist_mm\":%d,\"status\":\"blocked\"}", distance);
client.publish("facility/panel/clearance", payload);

This allows you to pipe the data into Home Assistant or Grafana, generating automated maintenance tickets when a panel remains blocked for more than 15 minutes. By combining strict adherence to NEC 110.26 with embedded IoT monitoring, you transition from reactive code enforcement to proactive facility safety management.