MCU Sleep and Stop Modes with EXTI Wake-up

1. Review: Implementing Sleep Mode with EXTI Wake-up

Let's begin with a quick practical review of Sleep mode. As you learned, in Sleep mode, only the CPU core is stopped, while peripherals and their clocks remain active. This allows for very fast wake-up times.

The process to enter Sleep mode and wake via an external interrupt (like a button press) follows these steps:

1. Configure a GPIO pin as an input with an external interrupt (e.g., GPIO_MODE_IT_FALLING).
2. Enable the EXTI line's interrupt in the NVIC.
3. In your main loop, suspend the SysTick timer to prevent it from waking the CPU every millisecond.
4. Call the HAL function to enter Sleep mode.
5. Upon wake-up (triggered by the EXTI), execution resumes. Re-enable the SysTick timer.
6. The HAL_GPIO_EXTI_Callback() function is where you can handle the interrupt-specific logic.

/* main.c */

// Inside your while(1) loop
printf("Entering Sleep Mode...\r\n");
HAL_Delay(10); // Ensure printf buffer is flushed

// 1. Suspend SysTick
HAL_SuspendTick();

// 2. Enter Sleep Mode (execution pauses here)
HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON, PWR_SLEEPENTRY_WFI);

// ---- MCU WAKES UP HERE ----

// 3. Resume SysTick
HAL_ResumeTick();
printf("Woke up from Sleep Mode!\r\n");

// ... your post-wakeup logic ...

For a detailed video walkthrough of setting this up, please watch the following tutorial.

2. Deeper Savings: Introducing Stop Mode

While Sleep mode is useful, Stop mode offers a much more significant reduction in power consumption. In Stop mode, the MCU powers down not only the CPU but also the main high-speed clock sources (HSI, HSE, and the PLL). However, the contents of the SRAM and all peripheral registers are preserved.

This deeper sleep comes with a crucial consequence: because the system clock source is turned off, it must be re-initialized upon wake-up.

The following article provides an excellent comparison and explains the technical details for both Sleep and Stop modes.

3. Implementing Stop Mode with EXTI Wake-up

The procedure for entering Stop mode is very similar to Sleep mode, but with two key differences: a different HAL function and the mandatory clock reconfiguration after waking up.

The steps are:

1. Configure the GPIO and EXTI, just as before.
2. Suspend the SysTick timer (HAL_SuspendTick()).
3. Call HAL_PWR_EnterSTOPMode(). Note the different parameters compared to the sleep function.
4. The MCU enters Stop mode. Execution pauses.
5. When the EXTI fires, the MCU wakes up. The code execution resumes at the instruction immediately following HAL_PWR_EnterSTOPMode().
6. Crucially, you must immediately call SystemClock_Config() to restore your HSI/HSE and PLL configuration.
7. After the clock is stable, you can resume the SysTick (HAL_ResumeTick()).

/* main.c */

// Inside your while(1) loop
printf("Entering STOP Mode...\r\n");
HAL_Delay(10); 

// 1. Suspend SysTick
HAL_SuspendTick();

// 2. Enter STOP Mode (execution pauses here)
HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);

// ---- MCU WAKES UP HERE ----

// 3. CRITICAL: Reconfigure the System Clock
SystemClock_Config(); // This function was generated by CubeMX

// 4. Resume SysTick
HAL_ResumeTick();
printf("Woke up from STOP Mode!\r\n");

// ... your post-wakeup logic ...

The following video demonstrates this exact process. While it uses an STM32F4, the HAL functions and the core concepts—especially the need to reconfigure the clock—are identical, which is a testament to the portability of the STM32 HAL.

4. Hands-on Exercise: Implementing Stop Mode Wake-up

Now it's your turn to apply what you've learned.

Your Task:
Create a new STM32CubeIDE project for your Blue Pill board.

1. Configure PC13 as a GPIO_Output for the onboard LED.
2. Configure a user button on pin PA8 as a GPIO_Input with a pull-up resistor and set its mode to GPIO_MODE_IT_FALLING.
3. Enable the corresponding EXTI interrupt in the NVIC (EXTI line[9:5] interrupt).
4. Configure USART1 for communication (e.g., at 115200 baud) so you can use printf.
5. In main.c, write an application that:
   • Prints a "System Initialized" message.
   • Enters an infinite while(1) loop.
   • Inside the loop, it prints "Entering STOP Mode in 3 seconds...".
   • Blinks the LED on PC13 three times with a 200ms delay between toggles.
   • Follows the sequence described in Section 3 to enter Stop mode.
   • Upon waking (from the button press on PA8), it should reconfigure the clock, resume the tick, print "Woke up from STOP mode!", and toggle the LED once to confirm.
   • The loop should then repeat, re-entering Stop mode.

You can find a complete project example that uses this exact logic in the following resource. It is a fantastic reference if you get stuck, as it provides the full main.c and explains each part.

A Note on Debugging: When the MCU enters Stop mode, the core and its debug circuitry are powered down. This will cause your ST-Link debugger to disconnect. You will not be able to use breakpoints or step through code that executes after entering a deep sleep state. This is normal. Rely on printf statements via UART and LED indicators to verify that your code is working as expected.

Conclusion

Congratulations! You have now implemented the two most common low-power modes on an STM32 microcontroller and can wake the system using an external interrupt. This is a fundamental skill for building battery-powered and power-efficient devices.

Key Takeaways:

• Sleep Mode: Simple to use, fast wake-up. Stops only the CPU. Peripherals remain active.
• Stop Mode: Offers significant power savings by stopping high-speed clocks. Requires a system clock reconfiguration (SystemClock_Config()) upon wake-up.
• The general sequence for both is: Suspend Tick -> Enter Low-Power Mode -> (Wake-up) -> Reconfigure Clock (for Stop only) -> Resume Tick.
• Debugging deep sleep modes requires indirect methods like UART logging, as the debug interface is often disabled.

Preview of the Next Lesson:

You've learned to save power when the device is idle. But what about when it's active? In our next lesson, we will explore techniques to disable unused peripheral clocks in the RCC to minimize power consumption even when the CPU is running. This practice, known as clock gating, is another essential tool in your power optimization toolkit.