5.14 NVIC Guide

The example fixes the priority grouping first, then configures the interrupt priorities of the key and of GTIM3, and finally verifies the masking effect from the main loop with the global interrupt switch.

Data path: main → NVIC_PriorityGroupConfig writes SCB->AIRCR → NVIC_Init writes NVIC->IP and NVIC->ISER → EXTI4_IRQHandler toggles Key_Status → the main loop calls __disable_irq and __enable_irq → serial printing stops and resumes

1. Fix the priority grouping first. NVIC_PriorityGroupConfig writes the PRIGROUP field of SCB->AIRCR; this example uses NVIC_PriorityGroup_2, that is 2 bits for the pre-emption priority and 2 bits for the subpriority. NVIC_Init then packs the two priority levels into 8 bits according to that grouping, so a changed grouping needs the values of every interrupt reviewed again.

    /* Configure two bits for preemption priority */
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);

2. Give the key interrupt the lower pre-emption priority. KeyInputExtiInit fills in the NVIC_InitType fields and calls NVIC_Init to set EXTI4_IRQn to pre-emption 1 and subpriority 0 and to enable the channel.

    /* Set key input interrupt priority */
    NVIC_InitStructure.NVIC_IRQChannel                   = KEY_INPUT_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = NVIC_PRE_PRIORITY_1;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority        = NVIC_SUB_PRIORITY_0;
    NVIC_InitStructure.NVIC_IRQChannelCmd                = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

When the key pin or the interrupt line changes, NVIC_IRQChannel must stay consistent with KEY_INPUT_IRQn in inc/main.h.

3. Give GTIM3 the higher pre-emption priority. TIM_Config sets GTIM3_IRQn to pre-emption 0 and subpriority 0, so its pre-emption priority is higher than that of the key interrupt.

    /* Set GTIM3 interrupt priority */
    NVIC_InitStructure.NVIC_IRQChannel                   = GTIM3_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = NVIC_PRE_PRIORITY_0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority        = NVIC_SUB_PRIORITY_0;
    NVIC_InitStructure.NVIC_IRQChannelCmd                = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

To change which of the two interrupts pre-empts the other, edit the NVIC_PRE_PRIORITY_* value in both places rather than only one of them.

4. Verify masking from the main loop with the global interrupt switch. Once Key_Status has been set by EXTI4_IRQHandler, the main loop calls __disable_irq, waits for the key to be pressed and released again, and then calls __enable_irq; during that window the GTIM3 interrupt no longer prints.

    while (1)
    {
        while (Key_Status == DISABLE) {}

        log_info("Disable irq \r\n");
        __disable_irq();

        while(GPIO_ReadInputDataBit(KEY_INPUT_PORT, KEY_INPUT_PIN) == RESET) {}
        while(GPIO_ReadInputDataBit(KEY_INPUT_PORT, KEY_INPUT_PIN) == SET) {}

        log_info("enable irq \r\n");
        __enable_irq();
    }

__disable_irq and __enable_irq only touch PRIMASK, so an interrupt that became pending during the masked window is still serviced after the interrupt is re-enabled; leaving the mask requires the key to be pressed and then released.

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

The example puts the priority grouping inside the key initialization, uses the CMSIS priority interfaces to set the SysTick pre-emption priority, and passes the pre-emption result between the interrupts and the main loop through a state variable.

Data path: KeyInputExtiInit → NVIC_PriorityGroupConfig and NVIC_Init set the key priority → NVIC_SetPriority writes the SysTick priority with NVIC_EncodePriority and NVIC_GetPriorityGrouping → EXTI4_IRQHandler writes SCB->ICSR to pend SysTick → SysTick_Handler samples with NVIC_GetActive and sets Key_Status → the main loop calls NVIC_SetPriority again according to the state

1. Set the SysTick priority through the CMSIS interfaces. After initializing the key interrupt, main reads the current grouping with NVIC_GetPriorityGrouping, encodes the pre-emption priority and the subpriority with NVIC_EncodePriority and hands the result to NVIC_SetPriority; the pre-emption priority variable starts at 0.

    KeyInputExtiInit(KEY_INPUT_PORT, KEY_INPUT_PIN);
    /* Configure the SysTick Handler Priority: Preemption priority(0) and subpriority */
    NVIC_SetPriority(SysTick_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), PreemptionPriorityValue, 0));

NVIC_GetPriorityGrouping and NVIC_EncodePriority keep the encoding consistent with the actual grouping; the grouping should not be rewritten by another initialization before NVIC_SetPriority is used to change a priority.

2. Raise the SysTick pre-emption priority at run time according to the state. The main loop re-reads Key_Status on every pass: at 1 it changes the SysTick pre-emption priority to PreemptionPriorityValue + 2, at 2 it prints the end of the test, and otherwise it prints Key_Status = 0.

    while (1)
    {
        if (Key_Status == 1)
        {
            log_info("Key_Status = 1 \r\n");
            /* Configure the SysTick Handler Priority: Preemption priority(2) and subpriority */
            NVIC_SetPriority(SysTick_IRQn,
                             NVIC_EncodePriority(NVIC_GetPriorityGrouping(), PreemptionPriorityValue + 2, 0));
        }
        else if (Key_Status == 2)
        {
            log_info("NVIC IRQ Priority Test End \r\n");
        }
        else
        {
            log_info("Key_Status = 0 \r\n");
        }

        /* Insert delay Time */
        Delay(0x8FFFFF);
    }

A smaller pre-emption priority number means a higher priority, so the + 2 lowers the SysTick pre-emption priority; the subpriority is always passed as 0 because the key interrupt subpriority is 0 as well.

3. Pend the SysTick exception from the key interrupt. After confirming that EXTI4 is pending, EXTI4_IRQHandler writes the PENDSTSET bit of SCB->ICSR so that the SysTick exception is pended before the key interrupt returns, and then clears the EXTI pending bit.

    if (EXTI_GetStatusFlag(KEY_INPUT_EXTI_LINE) != RESET)
    {
        /* Generate SysTick exception */
        SCB->ICSR |= 0x04000000;

        /* Clears the SEL Button EXTI line pending bits */
        EXTI_ClrStatusFlag(KEY_INPUT_EXTI_LINE);
    }

Writing the PENDSTSET bit of SCB->ICSR only makes the SysTick exception pending; whether it pre-empts immediately depends on the pre-emption priority of SysTick relative to the interrupt being serviced.

4. Judge the pre-emption relationship inside the SysTick interrupt. SysTick_Handler uses NVIC_GetActive to read whether the key interrupt is still active: still active means the key interrupt was pre-empted by SysTick, so it sets Key_Status to 1, and otherwise to 2, for the main loop to read.

    /* If the EXTI4 IRQ Handler was preempted by SysTick Handler */
    if (NVIC_GetActive(KEY_INPUT_IRQn) != 0)
    {
        Key_Status = 1;
    }
    else
    {
        Key_Status = 2;
    }

NVIC_GetActive reads the active state of an interrupt rather than its pending state; polling it from the main loop would be disturbed by the changing pre-emption relationship, so the example only uses the sample taken inside the interrupt.

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

The example uses the key interrupt as the trigger condition, calls the vector table relocation interface from the main loop, and then stays in an empty loop without returning.

Data path: main → KeyInputExtiInit configures the key EXTI and its priority → EXTI4_IRQHandler sets Key_Status to ENABLE → the main loop calls NVIC_SetVectorTable to write SCB->VTOR → the program enters the empty loop

1. Read the offset macros first. inc/main.h gives the FLASH and the SRAM vector table offsets as two macros; the example uses only the SRAM offset, whose value is 0x00010000.

#define VECT_TAB_FLASH_OFFSET ((uint32_t)0x00000000)
#define VECT_TAB_SRAM_OFFSET  ((uint32_t)0x00010000)

2. Give the key interrupt priority in the initialization. KeyInputExtiInit configures the grouping first and then sets EXTI4_IRQn to pre-emption 0 and subpriority 0.

    /* Configure two bits for preemption priority */
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);

    /* Set key input interrupt priority */
    NVIC_InitStructure.NVIC_IRQChannel                   = KEY_INPUT_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = NVIC_PRE_PRIORITY_0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority        = NVIC_SUB_PRIORITY_0;
    NVIC_InitStructure.NVIC_IRQChannelCmd                = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

3. The interrupt service function has two branches selected by a macro. EXTI4_IRQHandler uses conditional compilation to give different behaviour depending on whether VECT_TAB_SRAM is defined: when it is defined only the SRAM branch notice is printed, and when it is not defined Key_Status is set to ENABLE; the project target macros are N32G412 and N32G415, VECT_TAB_SRAM is not defined, so the #else branch runs.

#ifdef VECT_TAB_SRAM
        log_info("EXTI4 IRQHandler is executed(SRAM) \r\n");
#else
        /* Key_Status */
        Key_Status = ENABLE;
        log_info("EXTI4 IRQHandler is executed(FLASH) \r\n");
#endif

4. The main loop performs the relocation and then stops. Once Key_Status has become ENABLE, main calls NVIC_SetVectorTable to change the vector table base to NVIC_VectTab_RAM plus the offset, and then enters an empty loop that never returns.

        if (Key_Status == ENABLE)
        {
            log_info("Sets the vector table location and Offset \r\n");

            /* Vector Table Relocation in Internal SRAM. */
            NVIC_SetVectorTable(NVIC_VectTab_RAM, VECT_TAB_SRAM_OFFSET);

            while (1)
                ;
        }

After the relocation the interrupt vectors come from the table in SRAM; the offset argument of NVIC_SetVectorTable should be a multiple of 0x200 as its comment requires, so a changed offset value needs to respect that alignment.

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