Interrupts for Low-Power Operation

1. The Inefficiency of Polling

Let's consider a basic task: toggle an LED when a button is pressed. The most straightforward approach is polling, where you continuously check the button's state inside a while(1) loop.

// Simplified polling example
while (1)
{
    if (HAL_GPIO_ReadPin(BUTTON_PORT, BUTTON_PIN) == GPIO_PIN_RESET)
    {
        HAL_GPIO_TogglePin(LED_PORT, LED_PIN);
        HAL_Delay(200); // Simple debounce
    }
}

While functional, this code is incredibly inefficient from a power perspective. The CPU is running at full speed, executing millions of instructions per second, just to repeatedly check a pin. The vast majority of this activity is wasted, as the button's state changes infrequently.

This diagram perfectly illustrates the difference between polling and an interrupt-driven approach.

Our goal is to transform our code from the top model (polling) to the bottom model (interrupt-driven), allowing the CPU to enter a low-power state instead of being wastefully "Busy".

2. From Polling to Interrupts: The "Wait For Interrupt" (WFI) Strategy

Instead of polling, we will configure the system to enter a low-power mode and rely on an external interrupt (EXTI) from the button pin to wake it up. The core of this strategy revolves around the "Wait For Interrupt" (WFI) instruction.

When the CPU executes WFI, it halts and enters a low-power state until an interrupt occurs. The STM32 HAL provides a convenient function for this: HAL_PWR_EnterSLEEPMode().

However, there's a critical detail. By default, the SysTick timer generates an interrupt every 1ms to service the HAL time base (HAL_GetTick()). If we simply enter Sleep mode, the SysTick interrupt will wake the CPU up almost immediately, defeating the purpose.

The solution is to temporarily disable the SysTick interrupt before sleeping and re-enable it upon waking.

The following document provides an excellent, in-depth explanation of these concepts.

Practical Implementation

Let's see this in action. The process involves configuring a GPIO as an external interrupt, then using the WFI strategy in our main loop.

To summarize the logic for an interrupt-driven sleep cycle:

1. Setup: Configure a GPIO pin (e.g., your button pin) to trigger an external interrupt (EXTI) on a rising or falling edge. Enable the corresponding interrupt in the NVIC.
2. Main Loop while(1):
   • Print a message like "Entering Sleep Mode..." to your UART terminal.
   • Call HAL_SuspendTick() to prevent the SysTick from waking the CPU.
   • Call HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON, PWR_SLEEPENTRY_WFI). The code execution will pause here until an interrupt occurs.
   • (CPU is now asleep)
   • ... (Button is pressed, EXTI fires, CPU wakes up) ...
   • Execution resumes here, immediately after the sleep function.
   • Call HAL_ResumeTick() to restore the HAL time base.
   • Print a "Woke up!" message to the UART.
3. Interrupt Callback HAL_GPIO_EXTI_Callback():
   • This function is automatically called when the EXTI interrupt for your button pin occurs.
   • Inside this function, you can perform the immediate action, such as toggling an LED.
   • Important: The primary role of the ISR in this design is simply to wake the processor. The main loop handles what to do after waking up.

This design is vastly more power-efficient. The CPU is completely idle, consuming minimal power, until the user provides input.

3. A More Elegant Approach: "Sleep-on-Exit"

For applications that are almost entirely event-driven, there's an even more efficient feature built into the ARM Cortex-M core called Sleep-on-Exit.

When this feature is enabled, the MCU automatically re-enters sleep mode as soon as it finishes executing an Interrupt Service Routine (ISR). It doesn't even return to the while(1) loop. The CPU is only active for the brief period it takes to service the interrupt.

This is perfect for a device that should do nothing but react to external events.

Now, let's watch a practical demonstration of this powerful feature.

The Sleep-on-Exit logic simplifies your main function significantly:

1. Setup: During initialization, after setting up your peripherals and interrupts, call HAL_PWR_EnableSleepOnExit().
2. Main Loop while(1): This loop can now be completely empty! The first time an interrupt occurs, the CPU will execute the ISR and then automatically go to sleep. It will remain asleep, waking only to service subsequent interrupts.

Conclusion

Today you have bridged the gap from theory to practice in power management. You have learned how to transform an inefficient polling-based design into a power-saving, interrupt-driven one by leveraging the MCU's Sleep mode.

Key Takeaways:

• Polling is inefficient: It keeps the CPU busy and consumes significant power for no productive reason.
• Interrupts enable sleep: By configuring peripherals to trigger interrupts, you can let the CPU enter a low-power mode while waiting for an event.
• WFI (Wait For Interrupt) is the core instruction for this strategy, implemented in the HAL via HAL_PWR_EnterSLEEPMode().
• The SysTick timer must be suspended (HAL_SuspendTick()) before entering Sleep mode to prevent it from waking the MCU immediately.
• Sleep-on-Exit (HAL_PWR_EnableSleepOnExit()) is a powerful feature for purely event-driven systems, allowing the MCU to automatically return to sleep after servicing an interrupt.

Preview of the Next Lesson:

You've now successfully implemented Sleep mode. In the next lesson, we will go deeper. You will place the MCU into the more powerful Stop mode and wake it using an EXTI. More importantly, you will finally connect your multimeter to the circuit and measure the current consumption in Run, Sleep, and Stop modes to see the real-world impact of your power optimization efforts.