ESP32 Brownout Guide: 5 Powerful Ways to Prevent Resets and Protect Your Projects

Learn ESP32 brownout troubleshooting, protection, and interrupts. Fix brownout resets, use capacitors, and ensure stable ESP32 performance for projects.

If you’ve been working with the ESP32, you might have seen the dreaded message: “ESP32 brownout detector was triggered.” Maybe your board reset unexpectedly, or some of your peripherals started acting strange. Don’t worry—today, we’re going to unpack everything about ESP32 brownout: what it is, why it happens, and how to fix it. By the end of this guide, you’ll understand ESP32 brownout protection like a pro.

What is a Brownout?

Before diving into the ESP32 specifics, let’s talk about brownouts in general.

A brownout is a temporary drop in voltage in an electrical system. Unlike a blackout, where power completely goes out, a brownout just dips below the normal voltage level.

What Does a Brownout Mean?

When voltage drops below the device’s minimum operating voltage, it can cause:

• Unexpected resets
• Unstable operation
• Corrupted data

Essentially, your ESP32 or other electronics may not have enough juice to function properly. This is particularly important for sensitive microcontrollers like the ESP32, which rely on a stable 3.3V supply.

What Happens During a Brownout?

During a brownout, the ESP32 might:

• Restart unexpectedly
• Fail to read sensors correctly
• Cause Wi-Fi or Bluetooth to fail
• Trigger error messages like “ESP32 BOD brownout detector was triggered”

This is the ESP32 protecting itself. Microcontrollers include a brownout detector that monitors the voltage level and resets the chip if the voltage drops too low.

ESP32 Brownout Detector Explained

The ESP32 has a built-in brownout detector. This chip feature watches your board’s voltage and makes sure it doesn’t dip below a safe operating level.

If the voltage drops too low, the detector triggers and the ESP32 will reset or shut down to prevent damage.

You might see messages like:

• “ESP32 brownout detector was triggered”
• “ESP32 e BOD brownout detector was triggered”

Both mean the same thing: the board detected low voltage.

ESP32 Brownout Interrupt

Some ESP32 variants allow you to configure brownout interrupts. This means that instead of an immediate reset, your program can detect the brownout condition and take action.

You might use a brownout interrupt to:

• Save sensor readings
• Safely shut down peripherals
• Log the event for debugging

Using brownout interrupts requires understanding the ESP32’s BOD (Brownout Detector) registers and configurations.

Why Does the ESP32 Brownout Happen?

There are several common causes:

1. Low Power Supply
   Your 3.3V supply might be unable to handle spikes in current.
2. High Current Draw
   Peripherals like motors, relays, or LEDs can pull more current than the board can supply.
3. Capacitor Issues
   A weak or missing capacitor on the ESP32’s power line can make voltage dips worse.

This is where ESP32 brownout capacitor comes in. Adding a capacitor can stabilize the voltage and prevent brownouts.

ESP32 Brownout Capacitor: How It Helps

Adding a capacitor near the ESP32’s power pins acts like a tiny energy reservoir. When your ESP32 suddenly needs more current, the capacitor supplies it, preventing the voltage from dipping too low.

A common recommendation is:

• 100µF electrolytic capacitor across 3.3V and GND
• Optional 0.1µF ceramic capacitor for high-frequency stability

This simple tweak often solves most brownout problems.

ESP32 Brownout Reset

When the brownout detector is triggered, the ESP32 performs a brownout reset. Essentially, the microcontroller restarts itself to avoid running under unsafe voltage.

If you see repeated resets, it’s a sign your board isn’t getting stable voltage.

ESP32 Brownout Disable: Is It Safe?

Some developers try to disable the brownout detector using:

WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); // Disable BOD

Or via configuration in ESP-IDF or Arduino.

While this can stop resets, it’s not recommended. Disabling brownout protection exposes your ESP32 to:

• Corrupted flash memory writes
• Peripheral malfunction
• Permanent damage in extreme cases

A better approach is to fix the underlying voltage problem.

Troubleshooting and Protection

We learned what a brownout is, why the ESP32 triggers its brownout detector, and how capacitors can help stabilize voltage. Now, let’s dive deeper into practical solutions, troubleshooting tips, and brownout protection techniques to keep your ESP32 running smoothly.

ESP32 BOD Brownout Detector Was Triggered: Troubleshooting

If you see the message “ESP32 BOD brownout detector was triggered” or “ESP32 e BOD brownout detector was triggered”, it means the voltage dipped below safe levels. Here’s how to troubleshoot:

1. Check Your Power Supply

The first thing to do is make sure your ESP32 is getting enough voltage.

• Recommended: 5V via USB or a 3.3V regulated supply.
• Low-quality USB cables or power adapters often cause voltage drops. Swap them and test again.

2. Reduce Current Draw

Peripherals like sensors, motors, or Wi-Fi spikes can draw more current than your supply can handle.

• Disconnect peripherals one by one to identify the culprit.
• For high-current devices, consider a separate power supply.

3. Add a Brownout Capacitor

As we mentioned in Part 1, adding a capacitor can stabilize voltage:

• 100µF electrolytic across 3.3V and GND
• 0.1µF ceramic capacitor near the ESP32 for high-frequency noise

4. Inspect Board Wiring

Loose connections, long wires, or breadboards can cause voltage dips.

• Keep wires short and secure.
• Avoid running ESP32 power lines near motors or relays, which generate noise.

5. Monitor Voltage in Real-Time

Use a multimeter or oscilloscope to watch the 3.3V line.

• Voltage dipping below ~3.0V usually triggers the brownout detector.
• This helps you pinpoint whether the brownout is hardware-related.

ESP32 Brownout Protection Techniques

Preventing brownouts is better than reacting to them. Here’s how to protect your ESP32:

1. Use a Stable Power Supply

Always provide a regulated 3.3V or 5V supply with enough current capacity.

• ESP32 typically consumes 160-260mA during Wi-Fi transmission.
• Peak current can reach 500mA during spikes.

2. Add Capacitors for Stability

We already discussed capacitors. Let’s break it down for best results:

• Bulk capacitor (100µF–470µF): Handles sudden current spikes.
• Decoupling capacitor (0.1µF): Filters high-frequency noise.

3. Minimize Peripheral Load

• Avoid powering heavy peripherals directly from the ESP32.
• Use external power sources for motors, LEDs, and relays.

4. Enable Brownout Interrupt (Optional)

Some advanced ESP32 setups allow ESP32 brownout interrupt, letting your code detect voltage drops before a reset occurs.

// Pseudocode example
attachBrownoutInterrupt([]() {
    Serial.println("Brownout detected! Saving state...");
    saveSensorData();
});

This is helpful in critical applications where losing data is not an option.

ESP32 Brownout Reset: How to Handle It

A brownout reset is the ESP32’s safety mechanism. If resets happen frequently:

1. Check your power supply and USB cable.
2. Add capacitors for stability.
3. Reduce peripheral load.
4. Consider brownout interrupts if your project needs graceful handling.

Avoid ESP32 brownout disable, as turning off protection can corrupt flash memory and cause unpredictable behavior.

ESP32 Brownout Detector Was Triggered Disable: Why You Should Avoid It

Some tutorials suggest disabling the brownout detector:

WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); // Not recommended

While this may stop resets temporarily, it’s risky:

• Flash writes may fail
• Sensors or peripherals could malfunction
• Permanent board damage if voltage drops too low

Instead, focus on hardware fixes: capacitors, stable supply, and current management.

Common Causes of ESP32 Brownouts

Let’s summarize the main causes so you can quickly identify the problem:

ESP32 Brownout Capacitor Guide

Adding the right capacitor can make a huge difference in preventing brownouts.

• Electrolytic Capacitor (100µF–470µF): Handles sudden voltage drops
• Ceramic Capacitor (0.1µF): Filters high-frequency noise

Place capacitors as close to the ESP32 3.3V and GND pins as possible. This simple addition can solve most brownout issues permanently.

For a more detailed guide on managing ESP32 power and improving stability, check out this ESP32 DAC tutorial—it also covers tips on capacitor placement and voltage optimization.

Code Solutions and Advanced Protection

So far, we’ve learned what a brownout is, why it happens, and how to troubleshoot it. Now, let’s get hands-on. We’ll explore how to handle ESP32 brownouts in code, use brownout interrupts, and implement advanced protection for your projects.

Detecting Brownouts in ESP32 Code

The ESP32 has a built-in Brownout Detector (BOD). You can monitor voltage drops and take action programmatically.

Here’s a simple approach using Arduino IDE:

#include 

void setup() {
  Serial.begin(115200);
  esp_brownout_init(); // Initialize brownout monitoring (ESP-IDF)
}

void loop() {
  if (esp_brownout_occurred()) {
    Serial.println("Brownout detected!");
    // Take corrective actions here
    saveSensorData(); // Example: save important data
  }
  delay(1000);
}

Note: In Arduino, ESP32 brownout detection is usually automatic, but advanced users can integrate interrupts via ESP-IDF for more precise handling.

Using ESP32 Brownout Interrupts

A brownout interrupt allows your code to react before the board resets. This is useful if you need to save data or safely shut down peripherals.

Example in ESP-IDF:

#include "esp_system.h"
#include "driver/rtc_io.h"
#include "esp_sleep.h"

void IRAM_ATTR brownout_isr() {
    Serial.println("Brownout interrupt triggered! Saving data...");
    // Your safe shutdown code here
}

void setup() {
  Serial.begin(115200);

  // Configure brownout interrupt
  esp_brownout_enable_interrupt(true);
  attachInterrupt(BOD_INT_PIN, brownout_isr, FALLING);
}

void loop() {
  // Normal ESP32 operation
}

Explanation:

• esp_brownout_enable_interrupt(true): Enables brownout interrupt.
• attachInterrupt(): Calls your function when a brownout is detected.
• Use IRAM_ATTR for interrupt routines to ensure execution during low-voltage conditions.

Pro Tip: Interrupt routines should be short and efficient. Avoid heavy computation.

ESP32 Brownout Protection in IoT Projects

If your ESP32 is part of an IoT system, brownouts can cause sensor data loss, Wi-Fi disconnects, or cloud communication errors. Here’s how to protect your project:

1. Stable Power Source

Use a regulated 5V or 3.3V supply with sufficient current. ESP32 peaks at 500mA during Wi-Fi bursts.

2. Capacitors for Voltage Stability

• 100µF–470µF electrolytic capacitor across 3.3V and GND
• 0.1µF ceramic capacitor near power pins

3. Reduce Peripheral Load

High-current devices like motors, relays, and LEDs should be powered separately.

4. Brownout Interrupts

Use interrupts to save sensor readings or gracefully disconnect from Wi-Fi before a reset.

5. ESP32 BOD Brownout Detector Was Triggered: Logging

Always log brownout events. This helps you debug and optimize your power design.

if (esp_brownout_occurred()) {
    Serial.println("Brownout detected! Logging event...");
    logToSDCard();
}

ESP32 Brownout Disable: When Not to Do It

It’s tempting to just disable the brownout detector using:

WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); // Disable BOD

But this is risky. You may avoid resets temporarily, but voltage drops can corrupt flash memory or damage peripherals.

The recommended approach is fix the voltage and power design, not disable protection.

ESP32 E BOD Brownout Detector Was Triggered: How to Handle Repeated Resets

Sometimes your ESP32 repeatedly triggers brownout resets. Here’s a checklist:

1. Check USB or power supply
2. Add capacitors (100µF–470µF electrolytic + 0.1µF ceramic)
3. Reduce peripheral load
4. Use shorter wires on breadboards
5. Monitor voltage with multimeter or oscilloscope
6. Enable brownout interrupts to handle critical data safely

By following these steps, most brownout issues can be solved permanently.

ESP32 Brownout Reset: Summary

To recap:

• Brownout resets protect the ESP32 from low voltage damage.
• Repeated brownouts indicate insufficient power or high current draw.
• Interrupts and capacitors can help your ESP32 survive voltage dips without data loss.
• Disabling brownout detection is unsafe—avoid it.

With proper ESP32 brownout protection, you can make your projects more reliable, especially in IoT, robotics, and sensor applications.

Real-World Applications and Battery-Powered Boards

By now, you understand what a brownout is, why the ESP32 triggers its brownout detector, and how to use capacitors and interrupts to handle brownouts in code. In this part, we’ll focus on real-world scenarios, especially for battery-powered ESP32 projects, and advanced tips to prevent and debug brownouts.

Real-World Scenarios Where ESP32 Brownouts Happen

Brownouts aren’t just theoretical—they show up in practical projects. Here are some examples:

1. Wi-Fi-Heavy IoT Projects

ESP32 spikes its current during Wi-Fi transmission. If your power supply can’t keep up, you might see:

• ESP32 brownout detector was triggered
• Unexpected resets during data upload

Solution: Use a capacitor near the 3.3V pin and a regulated power supply capable of at least 500mA.

2. Battery-Powered ESP32

Battery-powered boards are especially prone to brownouts. When the battery voltage drops below ~3.0V, your ESP32 can reset unexpectedly.

Tips:

• Use a low-dropout (LDO) voltage regulator to keep 3.3V stable.
• Add 100µF–470µF electrolytic capacitor for sudden current spikes.
• Monitor battery voltage and implement a brownout interrupt to save data before reset.

Example:

if (esp_brownout_occurred()) {
    Serial.println("Brownout detected on battery-powered ESP32!");
    saveDataToEEPROM(); // Save critical sensor readings
}

3. Motor or LED Projects

High-current devices like motors, relays, or bright LEDs can cause voltage dips:

• Your ESP32 may reset during motor startup
• LED bursts can pull enough current to trigger brownouts

Fix: Power these devices separately or add a large capacitor (470µF+) across the ESP32 power pins.

4. Sensors with High Power Peaks

Some sensors, like gas or environmental sensors, draw current spikes when sampling. This can trigger brownout resets.

• Use brownout interrupts to log sensor readings
• Add capacitors to stabilize voltage during peak sampling

Advanced Troubleshooting for Persistent ESP32 Brownouts

Even after capacitors and stable power, some projects still see brownouts. Here’s an advanced checklist:

Step 1: Measure Real-Time Voltage

Use a multimeter or oscilloscope to watch the 3.3V supply. Look for dips below 3.0V.

Step 2: Inspect Wiring

Long wires, thin breadboard connections, or shared grounds with motors can cause voltage dips.

Step 3: Optimize Wi-Fi Usage

Wi-Fi spikes often cause resets. Consider:

• Using deep sleep when idle
• Avoiding heavy data bursts

Step 4: Verify Capacitor Placement

Ensure capacitors are as close as possible to the ESP32 3.3V and GND pins.

Step 5: Implement Brownout Interrupts

Use interrupts to safely handle voltage drops:

void IRAM_ATTR brownoutHandler() {
    Serial.println("Brownout interrupt triggered!");
    saveCriticalData();
}

Step 6: Avoid Disabling BOD

Never disable the brownout detector. It protects your ESP32 from unstable voltage that could corrupt flash memory.

ESP32 Brownout Protection for Battery Projects

Battery-powered ESP32 boards need extra care:

1. Use LDO regulators to maintain stable 3.3V.
2. Add bulk and decoupling capacitors.
3. Monitor battery voltage and warn the user if voltage drops.
4. Use brownout interrupts to save sensor data or safely disconnect peripherals.

Example: Environmental sensor project powered by Li-ion battery

• 3.7V battery → LDO → ESP32
• 220µF capacitor near 3.3V pin
• Brownout interrupt to save temperature/humidity readings to EEPROM

This setup prevents brownout resets and ensures reliable data logging.

ESP32 BOD Brownout Detector Was Triggered: Logging

Logging brownout events helps you optimize hardware and software:

• Save timestamp of resets to EEPROM
• Monitor battery voltage trends
• Identify peripherals causing spikes

Example code snippet:

if (esp_brownout_occurred()) {
    Serial.println("Brownout detected! Logging event...");
    logToSDCard(); // Save logs for debugging
}

Real-World Project, Final Tips, and FAQs

By now, you know what brownouts are, why the ESP32 triggers its brownout detector, how to handle them in code, and how to protect battery-powered or high-current projects. Let’s put it all together in a real-world example, finalize best practices, and answer common questions.

Real-World Example: ESP32 Weather Station with Brownout Protection

Imagine building a battery-powered weather station with temperature, humidity, and gas sensors. You want reliable readings even when battery voltage drops.

Step 1: Hardware Setup

• ESP32 board (any variant)
• DHT11/DHT22 sensor for temperature/humidity
• MQ-135 for air quality
• 3.7V Li-ion battery with LDO regulator to 3.3V
• Capacitors: 220µF electrolytic + 0.1µF ceramic near ESP32 power pins
• Optional: SD card for logging

Step 2: Power Management

• Use LDO regulator to maintain stable 3.3V
• Add bulk and decoupling capacitors
• Ensure wiring is short and secure

Step 3: Software Setup

Use brownout interrupts to save sensor readings before a reset:

#include 
#include "esp_system.h"

void IRAM_ATTR brownoutHandler() {
    Serial.println("Brownout detected! Saving sensor data...");
    saveSensorData(); // Save data to EEPROM or SD card
}

void setup() {
    Serial.begin(115200);

    // Enable brownout interrupt
    esp_brownout_enable_interrupt(true);
    attachInterrupt(BOD_INT_PIN, brownoutHandler, FALLING);

    // Sensor initialization
    initSensors();
}

void loop() {
    readSensors();
    sendDataToCloud();
    delay(2000);
}

Step 4: Logging and Alerts

• Log brownout events to SD card or internal memory
• Optionally, trigger an LED or buzzer to alert when voltage drops

With this setup, your weather station can survive battery dips and Wi-Fi spikes without losing data.

Final Checklist for Preventing ESP32 Brownouts

Here’s a concise checklist for stable ESP32 operation:

1. Use a regulated power supply capable of handling peak current (≥500mA).
2. Add capacitors: 100µF–470µF electrolytic + 0.1µF ceramic.
3. Separate high-current peripherals (motors, relays, LEDs).
4. Use short, secure wiring on breadboards or PCBs.
5. Monitor voltage with a multimeter or oscilloscope.
6. Enable brownout interrupts to save critical data.
7. Avoid disabling brownout detection—it protects flash and peripherals.
8. Log brownout events for debugging and optimization.

Frequently Asked Questions (FAQs)

Q1: What is a brownout in ESP32?

A brownout is a temporary drop in voltage below the ESP32’s safe operating level, causing resets or unstable behavior.

Q2: What happens during a brownout?

During a brownout, the ESP32 may reset unexpectedly, fail to read sensors, or disconnect from Wi-Fi.

Q3: Why does “ESP32 brownout detector was triggered” appear?

It appears when the ESP32 detects a voltage drop below its threshold. This is a safety feature to protect the microcontroller.

Q4: Can I disable the ESP32 brownout detector?

Yes, but it’s not recommended. Disabling it may corrupt flash memory or damage peripherals.

Q5: How do I prevent ESP32 brownouts?

Use a stable power supply, add capacitors, reduce peripheral load, and implement brownout interrupts if necessary.

Q6: What is an ESP32 brownout capacitor?

It’s a capacitor placed near the ESP32’s 3.3V and GND pins to stabilize voltage during current spikes.

Q7: How do brownout interrupts work on ESP32?

A brownout interrupt triggers your code when voltage dips below the threshold, allowing you to save data before a reset.

Q8: What causes repeated ESP32 brownout resets?

Low-quality power supply, heavy peripherals, poor wiring, or insufficient capacitors are common causes.

Q9: How do I log brownout events?

Use EEPROM, SD cards, or Serial logs to record when a brownout occurs for debugging.

Q10: Is ESP32 BOD brownout detector different from regular brownout detector?

BOD (Brownout Detector) is just the official term ESP32 uses for its brownout detection feature.

Q11: Can battery-powered ESP32 avoid brownouts?

Yes, with LDO regulators, capacitors, short wiring, and monitoring voltage.

Q12: What is ESP32 e BOD brownout detector was triggered?

It’s the extended BOD message indicating the ESP32 detected a brownout through its internal circuitry.

Summary

Congratulations! By following this guide, you now know:

• What ESP32 brownouts are and why they happen
• How to detect and troubleshoot brownouts
• How to use brownout capacitors and interrupts
• How to protect battery-powered and high-current projects
• Real-world project examples and FAQs for beginners

Following these techniques will ensure your ESP32 projects run reliably, even under unstable power conditions.

Raj Kumar

Mr. Raj Kumar is a highly experienced Technical Content Engineer with 7 years of dedicated expertise in the intricate field of embedded systems. At Embedded Prep, Raj is at the forefront of creating and curating high-quality technical content designed to educate and empower aspiring and seasoned professionals in the embedded domain.

Throughout his career, Raj has honed a unique skill set that bridges the gap between deep technical understanding and effective communication. His work encompasses a wide range of educational materials, including in-depth tutorials, practical guides, course modules, and insightful articles focused on embedded hardware and software solutions. He possesses a strong grasp of embedded architectures, microcontrollers, real-time operating systems (RTOS), firmware development, and various communication protocols relevant to the embedded industry.

Raj is adept at collaborating closely with subject matter experts, engineers, and instructional designers to ensure the accuracy, completeness, and pedagogical effectiveness of the content. His meticulous attention to detail and commitment to clarity are instrumental in transforming complex embedded concepts into easily digestible and engaging learning experiences. At Embedded Prep, he plays a crucial role in building a robust knowledge base that helps learners master the complexities of embedded technologies.

embeddedprep.com/