Normal Operation
      ↓
B1 Press
      ↓
PC13 EXTI
      ↓
LED OFF
      ↓
Configure Standby
      ↓
SLEEPDEEP = 1
      ↓
__WFI()
      ↓
STANDBY

PA0 WKUP
LOW → HIGH
      ↓
Wakeup Event
      ↓
System Reset
      ↓
main() from beginning
      ↓
SBF Check
      ↓
"System resume from Standby....."

B1
→ PC13
→ EXTI13
→ Standby 진입

PA0
→ WKUP pin

LD1
→ PB0

ON
→ Normal Operation
OFF
→ Entering Standby

Inc/
├── gpio.h
├── gpio_exti.h
├── standby_mode.h
└── uart.h
Src/
├── gpio.c
├── gpio_exti.c
├── standby_mode.c
├── uart.c
└── main.c

GPIO

UART

EXTI

#ifndef STANDBY_MODE_H__
#define STANDBY_MODE_H__
#include <stdint.h>
#include "stm32f4xx.h"
/*

Configure PA0 as the external WKUP input.
*/
void wakeup_pin_init(void);

/*

Configure Standby mode and enter low-power state.
*/
void standby_wakeup_pin_setup(void);

/*

Return the current PA0 input state.


Complete archived function body was not preserved
in the current Notion source.
*/
uint8_t get_wakeup_pin_state(void);

#endif

void wakeup_pin_init(void)
{
/*
* --------------------------------------------------------
* Step 1. Enable GPIOA Clock
* --------------------------------------------------------
*
* PA0 is used as the WKUP input pin.
*/
RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
/*
 * --------------------------------------------------------
 * Step 2. Configure PA0 as Input
 * --------------------------------------------------------
 *
 * MODER<span>[1:0]</span>:
 *
 *     00 = Input
 *
 * Clear both bits.
 */
GPIOA-&gt;MODER &amp;= ~(1U &lt;&lt; 0);
GPIOA-&gt;MODER &amp;= ~(1U &lt;&lt; 1);


/*
 * --------------------------------------------------------
 * Step 3. Disable Internal Pull-up / Pull-down
 * --------------------------------------------------------
 *
 * PUPDR<span>[1:0]</span>:
 *
 *     00 = No Pull
 *
 * External wiring directly determines
 * whether PA0 is LOW or HIGH.
 */
GPIOA-&gt;PUPDR &amp;= ~(1U &lt;&lt; 0);
GPIOA-&gt;PUPDR &amp;= ~(1U &lt;&lt; 1);

}

void standby_wakeup_pin_setup(void)
{
/*
* --------------------------------------------------------
* Step 1. Check Wakeup Pin State
* --------------------------------------------------------
*
* ORIGINAL PRACTICE CODE:
*/
while (get_wakeup_pin_state() == 0U)
{
}
/*
 * IMPORTANT — RE-TEST REQUIRED
 *
 * Existing notes described the code above as:
 *
 *     "wait until PA0 is stably LOW"
 *
 * However the actual C condition means:
 *
 *     while PA0 == 0
 *         keep waiting
 *
 * Therefore this loop exits only when:
 *
 *     PA0 != 0
 *     → HIGH
 *
 * The code and archived explanation do not agree.
 *
 * Because PA0 wake-up was NOT hardware-tested,
 * do not silently change this condition.
 *
 * Verify the intended PA0 sequence during re-test.
 */


/*
 * --------------------------------------------------------
 * Step 2. Temporarily Disable Wakeup Pin
 * --------------------------------------------------------
 *
 * PWR->CSR bit8 controls the wakeup pin.
 *
 * Disable it before clearing the old
 * wakeup condition.
 */
PWR->CSR &= ~(1U << 8);


/*
 * --------------------------------------------------------
 * Step 3. Clear Wakeup Flag
 * --------------------------------------------------------
 *
 * PWR->CR bit2:
 *
 *     CWUF
 *
 * Clears a previously latched wakeup event.
 */
PWR->CR |= (1U << 2);


/*
 * --------------------------------------------------------
 * Step 4. Enable Wakeup Pin Again
 * --------------------------------------------------------
 *
 * PA0 WKUP detection becomes active.
 */
PWR->CSR |= (1U << 8);


/*
 * --------------------------------------------------------
 * Step 5. Select Standby Mode
 * --------------------------------------------------------
 *
 * set_power_mode(PWR_MODE_STANDBY)
 *
 * configures PWR->CR.PDDS.
 *
 * Full helper implementation is not preserved
 * in the archived chapter source.
 */
set_power_mode(PWR_MODE_STANDBY);


/*
 * --------------------------------------------------------
 * Step 6. Enable Deep Sleep at Cortex-M4 Level
 * --------------------------------------------------------
 *
 * SCB SCR bit2:
 *
 *     SLEEPDEEP = 1
 *
 * Tells the Cortex-M core that WFI should
 * enter a deep low-power mode.
 */
SCB->SCR |= (1U << 2);


/*
 * --------------------------------------------------------
 * Step 7. Wait For Interrupt
 * --------------------------------------------------------
 *
 * __WFI()
 *
 * WFI = Wait For Interrupt
 *
 * With:
 *
 *     PDDS = 1
 *     SLEEPDEEP = 1
 *
 * this instruction causes the MCU
 * to enter Standby.
 *
 * After this point normal code execution stops.
 */
__WFI();


/*
 * In Standby mode, successful wake-up causes
 * a reset-like restart.
 *
 * Therefore normal execution is not expected
 * to continue here.
 */

}

while (get_wakeup_pin_state() == 0U)
{
}

PA0 = 0
↓
Stay in while()
PA0 = 1
↓
Exit while()

Wait until PA0 becomes HIGH

PA0이 LOW로 안정될 때까지 대기

PA0 LOW일 때 함수 진행 여부
PA0 HIGH일 때 함수 진행 여부

#include "gpio.h"
#include "gpio_exti.h"
#include "standby_mode.h"
#include "uart.h"
/*

Check whether this boot occurred
after leaving Standby mode.
*/
static void check_reset_source(void);

/*

Called from EXTI interrupt path.
*/
static void exti_callback(void);

int main(void)
{
/*
* --------------------------------------------------------
* Step 1. Initialize UART
* --------------------------------------------------------
*
* Used to report wakeup status.
*/
uart_init();
/*
 * --------------------------------------------------------
 * Step 2. Initialize LD1
 * --------------------------------------------------------
 *
 * PB0 → LD1
 */
led_init();


/*
 * --------------------------------------------------------
 * Step 3. Initialize PA0 Wakeup Input
 * --------------------------------------------------------
 */
wakeup_pin_init();


/*
 * --------------------------------------------------------
 * Step 4. Check Previous Reset Source
 * --------------------------------------------------------
 *
 * Standby wake-up causes main() to restart.
 *
 * Therefore check SBF early during boot.
 */
check_reset_source();


/*
 * --------------------------------------------------------
 * Step 5. Indicate Normal Operation
 * --------------------------------------------------------
 *
 * LED ON:
 *
 *     board is awake
 */
led_on();


/*
 * --------------------------------------------------------
 * Step 6. Configure B1 EXTI
 * --------------------------------------------------------
 *
 * B1:
 *
 *     PC13
 *        ↓
 *     EXTI13
 *        ↓
 *     Standby entry
 */
pc13_exti_init();


while (1)
{
    /*
     * Main loop has no polling task.
     *
     * B1 interrupt triggers Standby entry.
     */
}

}

static void check_reset_source(void)
{
/*
* --------------------------------------------------------
* Step 1. Enable Power Controller Clock
* --------------------------------------------------------
*
* PWR peripheral belongs to APB1.
*/
RCC->APB1ENR |= RCC_APB1ENR_PWREN;
/*
 * --------------------------------------------------------
 * Step 2. Check Standby Flag
 * --------------------------------------------------------
 *
 * SBF:
 *
 *     Standby Flag
 *
 * If set:
 *
 *     this boot followed Standby mode.
 */
if ((PWR->CSR & PWR_CSR_SBF)
    == PWR_CSR_SBF)
{
    /*
     * -----------------------------------------------
     * Clear Standby Flag
     * -----------------------------------------------
     *
     * CSBF:
     *
     *     Clear Standby Flag
     */
    PWR->CR |= PWR_CR_CSBF;


    /*
     * Inform the user that this boot occurred
     * after Standby wake-up.
     *
     * NOTE:
     *
     * This exact message is the EXPECTED output.
     *
     * Actual PA0 wake-up has not yet been verified.
     */
    uart_write_string(
        "System resume from Standby.....\r\n"
    );


    /*
     * ORIGINAL PRACTICE CODE
     *
     * Same PA0 condition appears here.
     *
     * Again:
     *
     *     while state == 0
     *
     * means the function waits while LOW
     * and exits when HIGH.
     *
     * Re-test required.
     */
    while (get_wakeup_pin_state() == 0U)
    {
    }
}


/*
 * --------------------------------------------------------
 * Step 3. Check Wakeup Flag
 * --------------------------------------------------------
 *
 * WUF:
 *
 *     Wakeup Flag
 */
if ((PWR->CSR & PWR_CSR_WUF)
    == PWR_CSR_WUF)
{
    /*
     * Clear WUF for the next low-power cycle.
     */
    PWR->CR |= PWR_CR_CWUF;
}

}

static void exti_callback(void)
{
/*
* --------------------------------------------------------
* Step 1. Turn LED OFF
* --------------------------------------------------------
*
* This is the last visible indication
* before entering Standby.
*
* It must happen BEFORE __WFI().
*/
led_off();
/*
 * --------------------------------------------------------
 * Step 2. Enter Standby
 * --------------------------------------------------------
 */
standby_wakeup_pin_setup();


/*
 * Once __WFI() enters Standby,
 * normal execution stops.
 */

}

standby_wakeup_pin_setup();
led_off();

__WFI();

CPU execution stops

led_off();

led_off();
standby_wakeup_pin_setup();

LED OFF
↓
WFI
↓
Standby

B1
↓
PC13 Rising Edge
↓
EXTI13
↓
EXTI15_10_IRQHandler
↓
exti_callback()
↓
LED OFF
↓
Wakeup Flag Clear
↓
Wakeup Pin Enable
↓
PDDS = 1
↓
SLEEPDEEP = 1
↓
__WFI()
↓
STANDBY

SCB->SCR |= (1U << 2);

WFI
↓
Deep Sleep

PWR->CR.PDDS = 1

Deep Sleep Mode
중에서도
Standby 선택

SLEEPDEEP only
→ Deep Sleep category
PDDS + SLEEPDEEP
→ Standby

__WFI();

Wait For Interrupt

SLEEPDEEP = 1
PDDS      = 1

__WFI()
↓
Standby

uint32_t counter = 1234;

counter = 1234

이 변수 값에서 계속 실행

Reset
↓
Startup
↓
.data initialize
↓
.bss clear
↓
main()

Pause / Resume

Power Down
+
Reboot

Power-on reset?
NRST?
Standby wake?

PWR->CSR & PWR_CSR_SBF

SBF = 1
↓
Previous state was Standby

uart_write_string(
"System resume from Standby.....\r\n"
);

WUF = 1

PWR->CR |= PWR_CR_CWUF;

Check Event
↓
Handle Event
↓
Clear Flag
↓
Prepare Next Event

PA0
→ GND
→ LOW

B1 Press
↓
LED OFF
↓
Standby

LOW
↓
HIGH

GND
↓
3.3 V

Wakeup Event
↓
System Reset
↓
main()
↓
SBF detected
↓
UART:
System resume from Standby.....
↓
LD1 ON

1. PA0 IDR 확인
2. get_wakeup_pin_state() return 확인
3. while 조건 확인
4. WUF clear 확인
5. EWUP enable 확인
6. PDDS 확인
7. SLEEPDEEP 확인
8. WFI
9. PA0 LOW → HIGH
10. SBF 확인

while (get_wakeup_pin_state() == 0U)
{
}

Build
PASS
Download
PASS
B1 EXTI
PASS
LED OFF before Standby
PASS
Standby Entry
PASS

Normal
→ LD1 ON
B1 Press
→ LD1 OFF
Standby
→ UART communication stops

PA0 WKUP
↓
Standby Exit
↓
System Reset
↓
SBF = 1
↓
UART Resume Message

PA0 wake-up test용 jumper wire 없음

Standby Entry
Verified
Wakeup
Pending

text = 1660 bytes
data = 0 bytes
bss  = 2560 bytes

Warnings = 0

RCC->APB1ENR

PWREN = 1

PWR->CSR

PWR->CR

PDDS = 1

SCB->SCR

SLEEPDEEP = 1

PWR->CSR

SBF
WUF

images/ch18_build.png
images/ch18_before_standby.png
images/ch18_standby_led_off.png
images/ch18_power_registers.png

images/ch18_pa0_low.png
images/ch18_pa0_high.png
images/ch18_wakeup_flags.png
images/ch18_resume_uart.png
images/ch18_wakeup.gif

LD1 ON
↓
B1 Press
↓
LD1 OFF
↓
Standby
↓
PA0 LOW → HIGH
↓
Reset
↓
UART:
System resume from Standby.....
↓
LD1 ON

B1
↓
EXTI
↓
LED OFF
↓
PWR.PDDS
+
SCB.SLEEPDEEP
↓
__WFI()
↓
STANDBY

PA0 WKUP
↓
Reset
↓
main()
↓
SBF
↓
Wakeup Detection