5.14 PWR Guide

The example first enables the PWR clock, then configures the external interrupt and interrupt channel for the voltage crossing, sets the threshold and turns on monitoring, and enters the interrupt service on crossing.

Data path: RCC_EnableAPBPeriphClk enables the PWR clock -> EXTI_Configuration clears the line 7 flag and sets the trigger edges -> NVIC_Configuration enables PVD_IRQn -> PWR_PVDLevelConfig writes the threshold level -> PWR_PvdEnable sets PVDEN -> voltage crossing -> PVD_IRQHandler clears the flag

1. First enable the PWR APB clock. PVD belongs to the power-management unit, so the PWR clock must be enabled before configuration.

    /* Enable PWR and BKP clock */
    RCC_EnableAPBPeriphClk(RCC_APB_PERIPH_PWR, ENABLE);

In another project, if the PWR clock is not enabled the writes to the PWR registers do not take effect.

2. Configure the external interrupt line for the voltage crossing. The PVD output is connected internally to EXTI line 7, so clear the pending bit then set rising and falling edge triggering.

    EXTI_InitType EXTI_InitStructure;

    /* Configure EXTI Line16(PVD Output) to generate an interrupt on rising and
       falling edges */
    EXTI_ClrITPendBit(EXTI_LINE7);
    EXTI_InitStructure.EXTI_Line    = EXTI_LINE7;
    EXTI_InitStructure.EXTI_Mode    = EXTI_Mode_Interrupt;
    EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising_Falling;
    EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    EXTI_InitPeripheral(&EXTI_InitStructure);

When moving to another chip or changing the trigger, only adjust EXTI_Line and EXTI_Trigger; the other fields stay unchanged.

3. Enable the interrupt channel, set the threshold and turn on monitoring. After NVIC enables the PVD interrupt, write the threshold level and set the PVDEN bit.

    NVIC_InitType NVIC_InitStructure;

    /* Enable the PVD Interrupt */
    NVIC_InitStructure.NVIC_IRQChannel                   = PVD_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPriority           = 0;
    NVIC_InitStructure.NVIC_IRQChannelCmd                = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    /* Configure the PVD Level to 2.4V ,from 2V ~ 4.8V,one step mean add 200mv*/
    PWR_PVDLevelConfig(PWR_PVD_LEVEL_2V4);

    /* Enable the PVD Output */
    PWR_PvdEnable(ENABLE);

The threshold levels map one to one to the PLS encoding in the user manual, so for another voltage just change the macro.

4. Clear the pending bit in the interrupt service function. After confirming line 7 is set, print a hint and clear the flag so the interrupt is not entered repeatedly.

void PVD_IRQHandler(void)
{
    if (EXTI_GetITStatus(EXTI_LINE7) != RESET)
    {
        log_info("\r\n Enter PVD interrupt \r\n");
        /* Clear the Key Button EXTI line pending bit */
        EXTI_ClrITPendBit(EXTI_LINE7);
        
    }
}

The handler name must match the vector name in the startup file; when porting to event mode this handler is not needed.

Corresponding source files: src/main.c, src/n32g033_it.c, firmware/n32g033_std_periph_driver/inc/n32g033_pwr.h

The example connects the key pin to an external interrupt as the wake-up source, enters STOP after a delay in the main loop, and reconfigures the clock after wake-up to keep running.

Data path: RCC_EnableAPBPeriphClk enables the PWR clock -> log_init initializes logging -> KeyInputExtiInit configures the PA0 external interrupt -> the loop runs SysTick_Delay_Ms -> PWR_EnterSTOPMode enters STOP -> the key wakes it and SetSysClockToHSI reconfigures the clock -> log_init

1. Enable the PWR clock and initialize logging and the wake-up source. Before entering low power, enable the PWR clock, then initialize the serial logging and the key interrupt.

    /* Enable PWR Clock */
    RCC_EnableAPBPeriphClk(RCC_APB_PERIPH_PWR, ENABLE);
    /* Initialize LEDs on n32g033-EVAL board */
    log_init();
    log_info("\n PWR_STOP INIT ");
    /* Initialize Key button Interrupt to wakeUp stop */
    KeyInputExtiInit(KEY_INPUT_PORT, KEY_INPUT_PIN);

KEY_INPUT_PORT and KEY_INPUT_PIN are defined in inc/main.h as GPIOA and pin 0; change these two macros to use another pin.

2. Enter STOP after a delay in the main loop and reconfigure the clock on wake-up. Each iteration delays first, prints, then enters STOP; on wake-up it immediately switches the system clock back to HSI and reinitializes logging.

    while (1)
    {
        /* Insert a long delay */
        SysTick_Delay_Ms(2000);

        log_info("\n STOP ENTRY ");
        PWR_EnterSTOPMode(PWR_STOPENTRY_WFI);
        SetSysClockToHSI(RCC_SYSCLK_PRES_DIV1);
        log_init();
        log_info("\n STOP EXIT ");
    }

The clock must be reconfigured after wake-up, otherwise the serial baud rate will not match the core frequency and the output will be garbled.

3. Connect the key pin to the external interrupt line and set the priority. Configure the key pin as floating input, trigger external interrupt line 0 on the rising edge with EXTI0_6_IRQn priority 0x01.

    /*Configure key EXTI Line to key input  Pin*/
    GPIO_ConfigEXTILine(GPIOA_PORT_SOURCE, GPIO_PIN_SOURCE0);

    /*Configure key EXTI line*/
    EXTI_InitStructure.EXTI_Line = EXTI_LINE0;
    EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
    EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
    EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    EXTI_InitPeripheral(&EXTI_InitStructure);

    /*Set key input interrupt priority*/
    NVIC_InitStructure.NVIC_IRQChannel                   = EXTI0_6_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPriority           = 0x01;
    NVIC_InitStructure.NVIC_IRQChannelCmd                = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

The combination of external interrupt source and pin number must follow the EXTI mapping in the user manual; the interrupt channel name is fixed in the startup file.

4. Clear the pending bit in the interrupt service function after wake-up. After confirming line 0 is set, clear the flag so the next key press can still wake it up.

void EXTI0_6_IRQHandler(void)
{
    if (EXTI_GetITStatus(EXTI_LINE0) != RESET)
    {
        /* Clear the Key Button EXTI line pending bit */
        EXTI_ClrITPendBit(EXTI_LINE0);
    }
}

When switching to event wake-up, the interrupt channel need not be enabled and this handler is not needed.

Corresponding source files: src/main.c, src/n32g033_it.c, firmware/n32g033_std_periph_driver/inc/n32g033_pwr.h