5.3 Cortex-M0 Guide

The example switches the thread-mode stack from the main stack to the process stack, then uses a software exception to check that the exception context uses the main stack and switches back automatically.

Data path: macros declare the stack size and stack values → clear the process stack area → __set_PSP sets the top of the process stack → __set_CONTROL switches to the process stack → __ISB flushes the pipeline → read CONTROL and PSP back to check → after the software exception SVC_Handler reads back the interrupt-context stack

1. Set the stack size and stack values with macros first. Both the process stack area size and the values of the two stacks are macros, so the switch and the check share the same set of constants.

#define SP_PROCESS_SIZE          0x200 /* Process stack size */
#define SP_PROCESS               0x02  /* Process stack */
#define SP_MAIN                  0x00  /* Main stack */

SP_PROCESS_SIZE set to 0x200 makes the process stack area 512 bytes; the two values map directly onto the stack-select bit of the control register.

2. Set the process stack pointer, switch the stack, and read back to check. The process stack pointer is pointed at the top of the stack first, then the control register selects the process stack, after which a synchronization instruction flushes the pipeline and the value is read back to confirm.

    /* Set Process stack value */
    __set_PSP((uint32_t)PSPMemAlloc + SP_PROCESS_SIZE);

    /* Select Process Stack as Thread mode Stack */
    __set_CONTROL(SP_PROCESS);

    /* Execute ISB instruction to flush pipeline as recommended by Arm */
    __ISB();

    /* Get the Thread mode stack used */
    CurrentStack = (__get_CONTROL() & 0x02);

    /* Get process stack pointer value */
    PSPValue = __get_PSP();

The synchronization instruction is required after the switch, otherwise later instructions may still use the old stack value.

3. Use a software exception to check that the interrupt context uses the main stack. After a software exception is triggered, the handler reads back the control register and confirms that the exception context no longer uses the process stack.

void SVC_Handler(void)
{
    IsrStack = (__get_CONTROL() & 0x02);
}

On exception entry the hardware switches to the main stack automatically and restores the previous stack selection on return to thread mode, so this check logic can be carried over directly when porting.

Corresponding source files: src/main.c, src/n32g033_it.c, firmware/CMSIS/core/core_cm0.h

The example works out a 10 ms tick period from the core clock and starts SysTick, then increments a counter and prints on the even condition inside the interrupt.

Data path: macros declare the divisor and the count variable → SystemCoreClockUpdate updates the core clock → SysTick_Config configures and starts the 10 ms tick → the main loop is empty → every 10 ms SysTick_Handler increments the count → the value is printed when even

1. Set the divisor and the count variable first. The divisor fixes the tick period and the count variable reflects how often the interrupt has fired; both are declared at file scope.

#define SYSTICK_10MS           ((uint32_t)100)

uint32_t Tick_num = 0;

SYSTICK_10MS set to 100 divides the core clock into 100 parts, giving a 10 ms tick period; change this macro to change the period.

2. Update the core clock and configure SysTick for 10 ms. The current core clock is recomputed from the registers first, then divided by the divisor to set the reload value and start the tick interrupt.

int main(void)
{
    /* USART Init */
    log_init();
    log_info("Cortex-M0 SysTick \r\n");

    /* Get SystemCoreClock */
    SystemCoreClockUpdate();

    /* Config 10ms SysTick  */
    SysTick_Config(SystemCoreClock/SYSTICK_10MS);

    while (1)
    {
    }
}

The core clock must be updated first, otherwise the reload value is computed from the old clock and the actual tick period differs from the intended one.

3. Increment the count and print on the condition inside the interrupt. Each tick interrupt adds one to the count variable and prints one line when the count is even, which keeps the printing from being too frequent.

void SysTick_Handler(void)
{
    Tick_num++;
    if((Tick_num%2) == 0)
    {
        log_info("Cortex-M0 SysTick IRQ %d\r\n",Tick_num);
    }
}

Printing inside the interrupt takes some time; when the tick period is short, buffer the messages and output them from the main flow instead.

Corresponding source files: src/main.c, src/n32g033_it.c, firmware/CMSIS/core/core_cm0.h