Verifying Electrical Panel Height Code with an ESP32 ToF Sensor Build

When roughing in a new 200A residential service or upgrading a commercial subpanel, verifying the electrical panel height code is a critical step before the inspector arrives. While the National Electrical Code (NEC) does not mandate a universal minimum height for the panel enclosure itself, it strictly regulates the maximum height of the breaker handles and the required headroom. Combine this with ADA reach-range requirements for commercial spaces, and a simple tape measure often falls short of the precision and logging capabilities modern contractors need.

In this guide, we will build a bench-calibrated, IoT-enabled measurement tool using an ESP32 and a VL53L1X Time-of-Flight (ToF) laser sensor. This device instantly calculates the center-grip height of a breaker handle, flags code violations on an onboard OLED, and logs the data via MQTT. We will cover the exact code requirements, the hardware pinout, and the complete compilable firmware.

Decoding the Electrical Panel Height Code

Before wiring the sensor, we must define the exact thresholds our firmware will check against. The concept of a single "electrical panel height code" is a misnomer; compliance is actually a matrix of NEC switch-height rules, working space headroom, and accessibility standards. Below is the data-dense reference table your ESP32 logic will use to flag violations.

Source references: NFPA 70 (NEC) and ADA Standards for Accessible Design.

Hardware Spec Sheet and Parts List

To achieve millimeter accuracy over a 2-meter range, ultrasonic sensors (like the HC-SR04) are insufficient due to beam divergence and temperature drift. We need a VCSEL (Vertical-Cavity Surface-Emitting Laser) ToF sensor. The VL53L1X uses a SPAD (Single-Photon Avalanche Diode) array to measure the time it takes for infrared photons to bounce back, providing exact millimeter readings regardless of ambient light or target color.

Difficulty Rating: Intermediate (Requires I2C bus management, 3.3V logic level awareness, and basic C++ pointer logic).
Build Time: 45 minutes for hardware, 20 minutes for firmware flashing and calibration.

Pin Mapping and I2C Bus Wiring

The ESP32 DevKit v1 has multiple hardware I2C buses, but the default Arduino `Wire` library maps to specific pins. We will share the I2C bus between the VL53L1X sensor and the SSD1306 OLED. Because the VL53L1X breakout from Pololu includes onboard 3.3V regulation and I2C pull-up resistors, we can safely power it from the ESP32's 5V (VIN) pin, while keeping the logic lines at 3.3V.

Compilable ESP32 Firmware for Height Verification

The following C++ code is written for the Arduino IDE targeting the ESP32 DevKit v1 (30-pin). It initializes the I2C bus, configures the VL53L1X for long-distance mode (up to 4 meters), and continuously polls the distance. If the measured height exceeds the NEC 404.8(A) limit of 2000mm, the OLED displays a red warning box (simulated via text inversion) and flags the measurement as a code violation.

Required Libraries (install via Arduino Library Manager): Pololu_VL53L1X, Adafruit_SSD1306, Adafruit_GFX.

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

// --- Pin Definitions ---
#define SDA_PIN 21
#define SCL_PIN 22
#define XSHUT_PIN 5

// --- Display Definitions ---
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
#define SCREEN_ADDRESS 0x3C

// --- Code Thresholds (in mm) ---
#define NEC_MAX_BREAKER_HEIGHT 2000 // 6'7" per NEC 404.8(A)
#define ADA_MAX_REACH_HEIGHT 1220   // 48" per ADA 308.2

VL53L1X sensor;
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

bool adaMode = false; // Toggle via button in a production build

void setup() {
  Serial.begin(115200);
  
  // Initialize I2C with explicit pins
  Wire.begin(SDA_PIN, SCL_PIN);
  Wire.setClock(400000); // 400kHz I2C Fast Mode

  // Initialize OLED
  if(!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;); // Halt execution
  }
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);
  display.setTextSize(1);
  display.setCursor(0,0);
  display.println("Booting ToF Sensor...");
  display.display();

  // Initialize VL53L1X
  pinMode(XSHUT_PIN, OUTPUT);
  digitalWrite(XSHUT_PIN, LOW); // Hold in reset
  delay(100);
  digitalWrite(XSHUT_PIN, HIGH); // Release reset
  delay(100);

  if (!sensor.init()) {
    Serial.println("Failed to detect and initialize VL53L1X sensor!");
    display.clearDisplay();
    display.setCursor(0,0);
    display.println("ERROR: ToF Sensor");
    display.println("Not found on I2C");
    display.display();
    while (1) { delay(1000); } // Halt
  }

  // Configure sensor for long distance mode
  sensor.setDistanceMode(VL53L1X::Long);
  sensor.setMeasurementTimingBudget(50000); // 50ms budget
  sensor.startContinuous(50); // Read every 50ms
  
  Serial.println("Sensor initialized. Ready to measure panel height.");
}

void loop() {
  // Read distance in millimeters
  uint16_t distance_mm = sensor.read();
  
  if (sensor.timeoutOccurred()) {
    Serial.print("TIMEOUT: ");
    Serial.println(sensor.read());
  }

  // Determine Compliance
  int threshold = adaMode ? ADA_MAX_REACH_HEIGHT : NEC_MAX_BREAKER_HEIGHT;
  bool isCompliant = (distance_mm <= threshold) && (distance_mm > 10); // >10mm to filter noise

  // Update OLED
  display.clearDisplay();
  
  // Header
  display.setCursor(0, 0);
  display.println(adaMode ? "ADA Mode" : "NEC 404.8(A) Mode");
  display.drawLine(0, 10, 128, 10, SSD1306_WHITE);
  
  // Measurement
  display.setTextSize(2);
  display.setCursor(10, 20);
  display.print(distance_mm);
  display.setTextSize(1);
  display.print(" mm");
  
  // Status
  display.setCursor(0, 50);
  if (isCompliant) {
    display.println("STATUS: PASS (Compliant)");
  } else {
    display.invertDisplay(true); // Flash inversion for visual alarm
    display.println("FAIL: EXCEEDS CODE MAX");
    delay(200);
    display.invertDisplay(false);
  }
  
  display.display();
  
  // Serial logging for MQTT integration later
  Serial.print("Distance: ");
  Serial.print(distance_mm);
  Serial.print("mm | Limit: ");
  Serial.print(threshold);
  Serial.print("mm | Status: ");
  Serial.println(isCompliant ? "PASS" : "FAIL");
  
  delay(100);
}

Debugging: I2C Timeouts and Initialization Errors

When working with high-precision I2C sensors on the ESP32, bus contention and initialization sequencing are the most common failure points. If your serial monitor outputs the exact error string: "Failed to detect and initialize VL53L1X sensor!", or if the sensor continuously throws a TIMEOUT during the loop, follow these ranked troubleshooting steps.

1. Check the XSHUT Pin Sequencing: The VL53L1X requires a clean hardware reset to enter I2C boot mode properly. If the GPIO 5 pin is left floating or driven HIGH before the 3.3V rail stabilizes, the sensor's internal state machine will lock up. Ensure the digitalWrite(XSHUT_PIN, LOW) delay is at least 100ms. If you are using a generic clone breakout board instead of the Pololu variant, the XSHUT pin might be labeled GPIO1 or left unbroken-out; tie it directly to 3.3V via a 10k pull-up resistor if not using ESP32 control.
2. Verify I2C Pull-Up Resistors and Bus Capacitance: The ESP32's internal pull-ups are weak (typically 45kΩ). The Pololu VL53L1X breakout includes 2.2kΩ pull-ups on SDA and SCL. If you added the SSD1306 OLED to the same bus, and your OLED module also has 4.7kΩ pull-ups, the combined parallel resistance might be pulling the bus too low, causing I2C ACK failures. Use a multimeter to measure resistance between SDA and 3.3V; it should read between 1.5kΩ and 4.7kΩ. If it's lower, physically remove the pull-up resistor from the OLED board.
3. Address I2C Bus Speed and Wire Length: The firmware sets the I2C clock to 400kHz (Wire.setClock(400000)). If your sensor is mounted on a tripod and connected to the ESP32 via wires longer than 30cm (12 inches), parasitic capacitance will degrade the square wave edges, resulting in a TIMEOUT error during the sensor.read() polling loop. Drop the bus speed to 100kHz (Wire.setClock(100000)) or move the ESP32 closer to the sensor using a shield configuration.

Extending and Simplifying the Build

Depending on your jobsite needs, you may want to strip this project down to its bare essentials or scale it up for fleet-wide compliance tracking.

How to Simplify the Build

If you do not need an OLED screen and want to reduce the BOM cost and power draw, eliminate the SSD1306 entirely. Replace the display logic with a simple bi-color LED or the ESP32's onboard WS2812 RGB LED (if using a DevKit v1 variant that includes one).
Logic: Blink Green twice for NEC Pass, Blink Red continuously for NEC Fail. This turns the device into a simple "go/no-go" gauge that an apprentice can use while mounting the panel bracket, providing instant visual feedback without requiring them to read a screen in a dimly lit basement.

How to Extend the Build

For commercial electrical contractors managing multi-unit apartment builds or hospital renovations, manual logging is a liability risk. You can extend this firmware by integrating the PubSubClient library to publish the measurement data via MQTT over the ESP32's WiFi radio.
Implementation: Add a QR code scanner module (like the GM65 or ESP32-CAM) to scan the panel's asset tag. The ESP32 then publishes a JSON payload to a Home Assistant or AWS IoT Core broker:

{
  "asset_id": "PANEL-204-A",
  "measured_height_mm": 1985,
  "code_limit_mm": 2000,
  "status": "PASS",
  "timestamp": 1715623400
}

This creates an immutable, time-stamped digital ledger proving that every panel was verified against the electrical panel height code prior to drywall installation, protecting your firm from costly rework if an inspector later claims the handles were mounted too high.