5.16 PWR Guide

The example routes the PVD output to the NVIC through EXTI Line16, and the main loop only waits for the interrupt.

Data path: PWR_PVDLevelConfig writes PLS in PWR_CTRL -> PWR_PvdEnable sets PVDEN -> VDD crossing the threshold changes PVDO -> EXTI Line16 triggers PVD_IRQHandler -> PWR_GetFlagStatus reads PWR_PVDO_FLAG -> serial print

1. Configure EXTI Line16 to receive the PVD output. The PVD detection event is internally connected to interrupt line 16; the example first clears the pending bit of that line and then configures it for 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_LINE16);
    EXTI_InitStruct(&EXTI_InitStructure);
    EXTI_InitStructure.EXTI_Line    = EXTI_LINE16;
    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 porting, check the EXTI line that the PVD is wired to, the trigger edges, and the interrupt handler bound to that line.

2. Enable the PVD interrupt channel. Both the preemption and sub-priority of PVD_IRQn are 0, with a priority group of one preemption bit.

    NVIC_InitType NVIC_InitStructure;

    /* Configure one bit for preemption priority */
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
    /* Enable the PVD Interrupt */
    NVIC_InitStructure.NVIC_IRQChannel                   = PVD_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority        = 0;
    NVIC_InitStructure.NVIC_IRQChannelCmd                = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

When changing the priority, update the preemption and sub-priority here and check the order relative to other interrupts.

3. Set the threshold and turn on the PVD. PWR_PVDLevelConfig first writes the threshold into the PLS field of PWR_CTRL, then PWR_PvdEnable sets PVDEN; after that the main loop is empty.

    /* 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);

    while (1)
    {
    }

When porting, change the PWR_PVD_LEVEL_* macro to the required alarm voltage, from 2.0 V to 4.8 V in 200 mV steps.

4. Read the flag and print in the interrupt. The handler first clears the pending bit of EXTI Line16 and then tests PVDO with PWR_GetFlagStatus to print the supply direction.

    if (EXTI_GetStatusFlag(EXTI_LINE16) != RESET)
    {
        /* Clear the EXTI line 16 pending bit */
        EXTI_ClrITPendBit(EXTI_LINE16);

        /* Check PVD output */
        if (PWR_GetFlagStatus(PWR_PVDO_FLAG) != RESET)
        {
            /* VDD is below PVD threshold */
            printf("PVD IRQ: VDD below threshold!\r\n");
        }
        else
        {
            /* VDD is above PVD threshold */
            printf("PVD IRQ: VDD above threshold.\r\n");
        }
    }

When changing the decision direction or the output text, keep the order of clearing the pending bit before reading the flag so that a later interrupt is not missed.

Corresponding source files: src/main.c, src/n32g41x_it.c

The example configures the WKUP key EXTI0 interrupt first, then the main loop delays and enters SLEEP, from which the key wakes it to continue.

Data path: KeyInputExtiInit configures PA0 as an input wired to EXTI0 -> PWR_EnterSLEEPMode(PWR_SLEEP_NOW, PWR_SLEEPENTRY_WFI) clears SLEEPDEEP and executes WFI -> a key press triggers EXTI0_IRQHandler to clear the pending bit -> the CPU continues and prints the exit message

1. Define the WKUP key and EXTI line with macros. inc/main.h groups the key port, pin source, EXTI line, interrupt vector and interrupt handler name, and all later configuration goes through these macros.

/* WKUP EXTI wakeup configuration (PA0 -> EXTI0) */
#define KEY_EXTI_PORT_SOURCE    GPIOA_PORT_SOURCE
#define KEY_EXTI_PIN_SOURCE     GPIO_PIN_SOURCE0

#define KEY_EXTI_LINE           EXTI_LINE0

#define KEY_EXTI_IRQn           EXTI0_IRQn
#define KEY_EXTI_IRQHandler     EXTI0_IRQHandler

When another key is used, change the port, pin source and EXTI line in this group and keep the interrupt handler name consistent with the vector.

2. Configure the key pin as an input wired to EXTI0. KeyInputExtiInit enables the clock of the key port, configures the pin as an input, then selects the port source and pin source with GPIO_ConfigEXTILine, and finally configures the EXTI line for rising edge triggering and enables it.

    /* Enable the GPIO Clock */
    BUTTON_WKUP_CLK_ENABLE;

    /*Configure the GPIO pin as input floating*/
    GPIO_InitStruct(&GPIO_InitStructure);
    GPIO_InitStructure.Pin        = Pin;
    GPIO_InitStructure.GPIO_Mode  = GPIO_MODE_INPUT;
    GPIO_InitPeripheral(GPIOx, &GPIO_InitStructure);

    /*Configure key EXTI Line to key input  Pin*/
    GPIO_ConfigEXTILine(KEY_EXTI_PORT_SOURCE, KEY_EXTI_PIN_SOURCE);

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

When porting, change BUTTON_WKUP_PORT, BUTTON_WKUP_PIN and the port source and pin source of GPIO_ConfigEXTILine to match the actual key.

3. Delay, enter SLEEP and print the entry and exit messages. Each loop iteration delays 1 s, prints the entry message and calls PWR_EnterSLEEPMode to enter SLEEP, and prints the exit message after wake-up.

    while (1)
    {
       /* Insert a long delay */
       SysTick_Delay_Ms(1000);
       log_info("Entry SLEEP mode\n");
       /* Request to enter SLEEP mode*/
       PWR_EnterSLEEPMode(PWR_SLEEP_NOW, PWR_SLEEPENTRY_WFI);
       log_info("Exit SLEEP mode\n");
    }

The first argument PWR_SLEEP_NOW means sleep-now; changing the delay argument adjusts the interval between two sleeps.

4. Clear the EXTI pending bit in the handler. On the key interrupt the handler tests the status flag of that line and clears the pending bit, so the CPU leaves SLEEP and returns to the main loop.

void KEY_EXTI_IRQHandler(void)
{
    if (EXTI_GetStatusFlag(KEY_EXTI_LINE) != RESET)
    {
        EXTI_ClrStatusFlag(KEY_EXTI_LINE);
    }
}

When porting, check the mapping between the handler name and EXTI0_IRQHandler in the startup file, and that the flag cleared matches the EXTI line.

Corresponding source files: src/main.c, src/n32g41x_it.c, inc/main.h

The example configures the WKUP key interrupt first, the main loop enters STOP, and after wake-up it rebuilds the system clock and continues.

Data path: KeyInputExtiInit wires PA0 to EXTI0 -> PWR_EnterSTOPMode(PWR_STOPENTRY_WFI) sets SLEEPDEEP and executes WFI -> the key wakes the MCU -> SetSysClockToPLL re-enables HSI and the PLL -> print the exit message

1. Wire the WKUP key to EXTI0 on the rising edge. KeyInputExtiInit selects the port source and pin source with GPIO_ConfigEXTILine, then configures EXTI0 as an interrupt on the rising edge and enables it.

    /*Configure key EXTI Line to key input  Pin*/
    GPIO_ConfigEXTILine(KEY_EXTI_PORT_SOURCE, KEY_EXTI_PIN_SOURCE);

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

When porting, change the port source and pin source macros to the actual wake-up pin, and check that this EXTI line has wake-up capability in STOP mode.

2. Enter STOP and rebuild the clock after wake-up. The loop delays 1 s, prints the entry message and calls PWR_EnterSTOPMode; after the key wakes the MCU it calls SetSysClockToPLL to restore the clock, then delays 10 ms and re-initializes the log.

    while (1)
    {
       /* Insert a long delay */
       SysTick_Delay_Ms(1000);
       log_info("Entry STOP mode\n"); 
       /* Request to enter STOP mode*/
       PWR_EnterSTOPMode(PWR_STOPENTRY_WFI);
       /* Configures system clock after wake-up from STOP: enable HSI, PLL and select
          PLL as system clock source */
       SetSysClockToPLL(RCC_PLL_SRC_HSI,80000000);
       SysTick_Delay_Ms(10);
       log_init();
       log_info("\nExit STOP mode\n");
    }

The serial port is unusable between the STOP wake-up and the clock rebuild, so the exit message follows SetSysClockToPLL and the new log_init call.

3. The clock rebuild selects PLL parameters for the target frequency. SetSysClockToPLL picks the multiplier, output divider and FLASH latency for the 80 MHz target, sets the bus dividers and then switches the PLL to the system clock.

        case 80000000:
            /* 4MHz * 40 = 160MHz(FVCO) / 2(PLLOD) /1 = 80MHz(Fpll) */
            latency   = FLASH_LATENCY_2;   /* 72MHz < SYSCLK <= 80MHz */
            pllmul    = 40;
            plloutdiv = RCC_PLL_OD_DIV_2;
            pllsysdiv = DISABLE;
            break;
        default:
            return ERROR;
    }

    /* HCLK = SYSCLK */
    RCC_ConfigHclk(RCC_SYSCLK_DIV1);

    /* PCLK2 = HCLK */
    RCC_ConfigPclk2(RCC_HCLK_DIV1);

    /* PCLK1 = HCLK/2 */
    RCC_ConfigPclk1(RCC_HCLK_DIV2);

When porting, change pllmul, plloutdiv and pllsysdiv for the actual crystal and target frequency, and adjust FLASH_LATENCY and the bus dividers accordingly.

Corresponding source files: src/main.c