Chapter 284: Power Consumption Optimization Techniques

Chapter Objectives

By the end of this chapter, you will be able to:

• Understand the different power-saving modes available on the ESP32: Modem Sleep, Light Sleep, and Deep Sleep.
• Configure and use Dynamic Frequency Scaling (DFS) to automatically adjust CPU speed.
• Implement Deep Sleep with various wake-up sources, such as timers and external interrupts.
• Use RTC memory to preserve application state across Deep Sleep cycles.
• Measure and analyze power consumption in different operating modes.
• Apply hardware and software best practices to minimize energy usage in your projects.
• Recognize the low-power strengths and differences across ESP32 variants.

Introduction

For many embedded applications, particularly in the IoT space, power is the most valuable resource. Devices like remote sensors, wearables, and asset trackers must operate on a small battery for months or even years. In these scenarios, optimizing for low power consumption is not just a feature—it’s the primary design driver. An application that drains its battery in a day is a failure, no matter how fast or feature-rich it is.

This chapter delves into the art of making your ESP32 applications sip power instead of guzzling it. We will explore the hardware features and software frameworks provided by Espressif for managing power. From dynamically changing the CPU frequency to putting the chip into a deep slumber where it consumes mere microamps, you will learn the techniques required to dramatically extend the battery life of your devices.

Theory

1. Understanding Power Consumption States

An ESP32’s power consumption is directly related to which parts of the chip are active. To manage this, the ESP32 supports several power modes, which can be thought of like states of human consciousness.

• Active Mode: This is the “fully awake” state. The CPU and all configured peripherals are running at full speed. This mode consumes the most power, typically in the range of 50-240mA, depending on CPU frequency and radio usage.
• Modem Sleep Mode: This is a “daydreaming” state. The CPU and peripherals are running, but the Wi-Fi and Bluetooth radios are powered down between required transmissions (e.g., between DTIM beacon intervals in a Wi-Fi network). This is an automatic mode enabled by default when using the Wi-Fi driver and provides a good balance of connectivity and power saving without any application intervention. Consumption can drop to ~3-20mA.
• Light Sleep Mode: This is a “light nap.” The main CPU is paused (xt_clock_gate), and most peripherals are clock-gated. The system’s state is preserved in RAM. The chip can be woken up very quickly from various sources (like a GPIO pin change or a timer). This mode is useful when you need to stop CPU execution for short periods but want to resume instantly without a full reboot. Power consumption is typically under 1mA (~800µA).
• Deep Sleep Mode: This is the “hibernation” state. The main CPU, most RAM, and all digital peripherals are powered off. Only the Real-Time Clock (RTC) controller, some RTC peripherals, and the ULP co-processor remain powered on. Waking up from Deep Sleep triggers a full reboot, but it offers the lowest power consumption, often just a few microamps (µA). This is the most critical mode for long-term battery-powered operation.

2. Dynamic Frequency Scaling (DFS)

In Active Mode, the CPU doesn’t always need to run at its maximum speed. DFS is a feature that automatically adjusts the CPU frequency based on the system’s needs. When the CPU is busy, it runs at a higher frequency. When it’s idle (e.g., waiting for an I/O event), it scales down to a lower frequency. This is analogous to a person walking slowly when relaxed and sprinting when in a hurry. By reducing the clock speed, DFS can significantly reduce active power consumption with minimal impact on performance.

DFS is configured in menuconfig and works by changing the CPU clock source between the high-speed main PLL and a lower-speed clock like the XTAL.

3. Deep Sleep and Wake-up Sources

Since waking from Deep Sleep causes a reboot, the ESP32 needs a way to know why it woke up and what to do next. This is accomplished using designated wake-up sources.

• Timer: The most common source. You instruct the RTC timer to wake the chip after a specific duration (e.g., “wake up in 30 seconds to take a new sensor reading”).
• External (GPIO): You can configure one or more RTC-capable GPIO pins to trigger a wake-up on a specific logic level (high or low). This is perfect for reacting to external events, like a button press or a sensor threshold being crossed.
  • ext0: Wake-up using a single specific GPIO pin.
  • ext1: Wake-up using one of several RTC GPIO pins. The chip can identify which pin caused the wake-up.
• Touch Pad: Wakes the chip when a specific capacitive touch pad is touched.
• ULP Co-processor: The Ultra-Low-Power (ULP) co-processor can run its own simple program while the main CPU is in Deep Sleep. It can perform basic tasks like monitoring a sensor and can wake up the main CPU only when a specific condition is met. This is the most advanced form of power saving.
• UART / GPIO (Light Sleep only): Can wake the chip from Light Sleep on UART input or multiple GPIO changes.

4. Preserving State with RTC Memory

Because Deep Sleep powers off the main RAM, all variable states are lost. To solve this, the ESP32 provides a small amount of RTC Memory (also called RTC FAST/SLOW memory). This memory region retains its contents during Deep Sleep.

By using the RTC_DATA_ATTR attribute on a global variable, you instruct the linker to place that variable in RTC memory.

RTC_DATA_ATTR int boot_count = 0;

void app_main(void) {
    boot_count++;
    printf("Boot count: %d\n", boot_count);
    // Go to sleep...
}

In this example, boot_count will correctly increment each time the device wakes from deep sleep, allowing you to maintain state across sleep cycles.

Practical Examples

Example 1: Deep Sleep with Timer Wake-up

This example demonstrates the fundamental deep sleep cycle. The device will wake up, print a message with a boot count, and go back to sleep for 10 seconds.

Code

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_sleep.h"
#include "esp_log.h"

static const char *TAG = "DEEP_SLEEP";

// RTC_DATA_ATTR places this variable in RTC memory.
// It will retain its value across deep sleep cycles.
RTC_DATA_ATTR int boot_count = 0;

void app_main(void) {
    // Increment and print the boot count.
    boot_count++;
    ESP_LOGI(TAG, "Boot count: %d", boot_count);

    // Check the wake-up reason.
    esp_sleep_wakeup_cause_t cause = esp_sleep_get_wakeup_cause();
    ESP_LOGI(TAG, "Wakeup caused by: %d", cause);

    // Configure the timer to wake us up in 10 seconds.
    const int deep_sleep_sec = 10;
    ESP_LOGI(TAG, "Entering deep sleep for %d seconds", deep_sleep_sec);
    esp_deep_sleep(1000000LL * deep_sleep_sec); // Time in microseconds
}

Build and Run

1. Create a new project.
2. Copy the code into your main file.
3. Flash and monitor: idf.py flash monitor.

Observe

You will see the boot message, followed by the “Entering deep sleep” message. Then, the device will go silent. Ten seconds later, it will reboot, and the boot_count will have incremented. This cycle will repeat indefinitely. If you have a power monitor (like a Joulescope or Power Profiler Kit), you would see the current drop from tens of milliamps to just a few microamps during the sleep period.

Example 2: Dynamic Frequency Scaling (DFS)

This example shows how to enable DFS and observe its effect (conceptually).

Setup and Code

1. Enable DFS in menuconfig:
   • idf.py menuconfig
   • Component config —> Power management —> Check Enable Power Management.
   • CPU frequency should be set to a high value (e.g., 240MHz for ESP32).
   • Enable Enable dynamic frequency scaling (DFS).
   • Save and exit.
2. Application Code:

#include <stdio.h>
#include "freertos/FreeRTOS.hh"
#include "freertos/task.h"
#include "esp_log.h"
#include "esp_pm.h"

static const char *TAG = "DFS_TEST";

void app_main(void) {
#if CONFIG_PM_ENABLE
    ESP_LOGI(TAG, "Power management is enabled.");

    // Configure DFS to use max and min frequencies.
    // On ESP32, this might be 240MHz and 80MHz.
    // This configuration is often done by default when DFS is enabled.
    esp_pm_config_t pm_config = {
        .max_freq_mhz = 240, // Check your chip's max frequency
        .min_freq_mhz = 80,  // Check available frequencies
        .light_sleep_enable = false // Let's focus on DFS for this example
    };
    esp_pm_configure(&pm_config);
    ESP_LOGI(TAG, "DFS configured.");
#endif

    while (1) {
        ESP_LOGI(TAG, "Main task is busy for a moment...");
        // Simulate CPU-intensive work
        for (volatile int i = 0; i < 2000000; i++) {}

        ESP_LOGI(TAG, "Main task is now idle...");
        // When this task blocks, the CPU is idle, and DFS
        // should reduce the frequency.
        vTaskDelay(pdMS_TO_TICKS(5000));
    }
}

Observe

Without a power profiler, the effect of DFS is invisible. However, what’s happening is that during the busy-loop, the CPU will be running at its max_freq_mhz. As soon as the task calls vTaskDelay, the FreeRTOS IDLE task runs, and the power management framework automatically scales the CPU frequency down to min_freq_mhz, saving significant power.

Variant Notes

Power management is an area with significant differences between variants.

• Wake-up Sources: Most wake-up sources (timer, ext0, ext1, touch) are available across the family. However, the exact number of RTC-capable GPIOs differs. Always consult the datasheet for your specific variant.

Common Mistakes & Troubleshooting Tips

Exercises

1. External Wake-up: Modify the Deep Sleep example to use a GPIO pin as a wake-up source instead of a timer. Connect a push button to an RTC-capable GPIO pin. The device should sleep indefinitely until the button is pressed.
2. Power Measurement: If you have access to a multimeter that can measure microamps or a power profiler, set up the Deep Sleep example and measure the actual current consumption of your development board in both Active and Deep Sleep modes. Note the difference.
3. Light Sleep vs. Deep Sleep: Write an application that wakes up every 5 seconds. Implement this first using Light Sleep (esp_light_sleep_start()) and then using Deep Sleep. If you have a power profiler, compare the average power consumption of both approaches.
4. Wi-Fi Power Saving: Take a simple Wi-Fi station example that connects to your network. Use esp_wifi_set_ps(WIFI_PS_MIN_MODEM) to enable Wi-Fi power saving. Measure the power consumption before and after enabling this mode. You should see a significant drop in the average current as the radio sleeps between beacons.

Summary

• Power is paramount for battery-operated devices.
• ESP32 offers several power states: Active, Modem Sleep, Light Sleep, and Deep Sleep.
• Deep Sleep offers the lowest power consumption (µA range) but requires a reboot on wake-up. It is the key to multi-year battery life.
• Use RTC Memory (RTC_DATA_ATTR) to preserve state across Deep Sleep cycles.
• Dynamic Frequency Scaling (DFS) reduces power consumption during Active mode by adjusting CPU speed.
• Accurate power measurement requires bypassing the development board’s USB circuitry.
• Newer variants like the ESP32-C6 and H2 offer significantly lower deep sleep currents than older models.

Further Reading

• ESP-IDF Documentation: Power Management:
  • Power Management Guide
• ESP-IDF Documentation: Deep Sleep Wake-up Sources:
  • Sleep Modes
• Espressif Application Note: ULP Co-processor Programming:
  • ULP Coprocessor Programming (Example within the ESP32-Sense-Kit Guide)