← PREV_LECNEXT_LEC →

Introduction

Core Concept

Why Every New Task Needs a Dummy Stack Frame

The ARM Cortex-M context-switch mechanism is symmetric: PendSV saves register state onto the current task’s stack before switching, and restores it from the next task’s stack after switching. This works perfectly for a task that has already run at least once — its previous state is already there. But a brand-new task has never run, so its private stack is empty and the scheduler would load garbage into the CPU.

The solution is simple: before launching the scheduler, pre-fill each task’s stack with a fake (dummy) context that looks exactly like a real saved state. When PendSV pops that frame during the very first context switch, the processor transitions cleanly to Thread mode and begins executing the task’s entry function.

1

Allocate private stack per task

Each task gets its own 1 KB region in SRAM. The stack grows downward, so it starts at the top of its region.

2

Pre-populate SF1 (hardware frame) with fake values

Push xPSR, PC (task entry), LR (EXC_RETURN), R12, R3–R0. Only PC and xPSR need real values; the rest can be 0.

3

Pre-populate SF2 (software frame) with zeros

Push R4–R11 (8 registers). All zeros is safe — the task will overwrite them immediately.

4

Save resulting PSP into the task’s TCB

Store the final stack pointer value so the scheduler can load it into PSP when the task is first scheduled.

5

Launch the scheduler

Only now is it safe to start SysTick and trigger the first PendSV. Each task’s stack looks like it was previously suspended.

Diagram

Complete Dummy Stack Frame Layout

A fresh task stack occupies exactly 64 bytes — 8 registers in SF2 (32 B) plus 8 registers in SF1 (32 B). The PSP is set to point at the bottom of the complete frame (lowest address).

Reference

Critical Values in the Dummy Frame

Most registers in the fake frame can be initialised to zero without consequence — the task will set them when it runs. However three slots carry processor-defined semantics and must be set correctly:

Code

Implementing init_task_stack()

Below is a complete, annotated implementation. The function walks the stack downward (decrement-before-store) using a uint32_t* pointer, then saves the final PSP value into the task control block.

C

/*
 * init_task_stack.c
 * Pre-populates dummy SF1 + SF2 on each task's private stack
 * so the scheduler can first-launch it as if it was suspended.
 */
#include "scheduler.h"

/* Stack region constants (128 KB SRAM, top = 0x2001FFFF+1) */
#define SRAM_START   0x20000000U
#define SRAM_SIZE    (128U * 1024U)           /* 128 KB            */
#define SRAM_END     (SRAM_START + SRAM_SIZE) /* 0x20020000        */
#define STACK_SIZE   1024U                    /* 1 KB per task     */

/* Base address of each task's stack (grows downward from top) */
#define T1_STACK_START  SRAM_END
#define T2_STACK_START  (T1_STACK_START - STACK_SIZE)
#define T3_STACK_START  (T2_STACK_START - STACK_SIZE)
#define T4_STACK_START  (T3_STACK_START - STACK_SIZE)
#define SCHED_STACK_START (T4_STACK_START - STACK_SIZE)

/* EXC_RETURN: "Thread mode, PSP, no FPU" */
#define EXC_RETURN_THREAD_PSP   0xFFFFFFFDU
/* xPSR: Thumb bit must be set */
#define DUMMY_xPSR              0x01000000U

/* Forward declarations of the four task functions */
void task1_handler(void);
void task2_handler(void);
void task3_handler(void);
void task4_handler(void);

/* Task control block array (defined in scheduler.c) */
extern tcb_t g_tcb[MAX_TASKS];

/*
 * init_stack_for_task()
 * Writes a 16-word (64-byte) dummy frame to the task's private stack
 * and stores the resulting PSP in its TCB.
 *
 *  Stack layout (each cell = 4 bytes, address decrements downward):
 *
 *  High address  +------------------+
 *  (stack_top-1) |     xPSR         |  0x01000000
 *                |     PC           |  &task_handlerX
 *                |     LR           |  0xFFFFFFFD  (EXC_RETURN)
 *                |     R12          |  0
 *                |     R3           |  0
 *                |     R2           |  0
 *                |     R1           |  0
 *                |     R0           |  0           <- SF1 base
 *                |     R11          |  0
 *                |     R10          |  0
 *                |     R9           |  0
 *                |     R8           |  0
 *                |     R7           |  0
 *                |     R6           |  0
 *                |     R5           |  0
 *  Low address   |     R4           |  0           <- PSP points here
 *                +------------------+
 */
static void init_stack_for_task(uint32_t stack_top, void (*entry)(void), tcb_t *tcb)
{
    /* Cast stack_top to a uint32_t pointer.
     * We decrement BEFORE writing (ARM full-descending stack).       */
    uint32_t *sp = (uint32_t *)stack_top;

    /* ─── SF1: hardware frame (pushed last → highest address) ─── */
    *(--sp) = DUMMY_xPSR;                         /* xPSR            */
    *(--sp) = (uint32_t)entry | 0x1U;             /* PC (Thumb LSB)  */
    *(--sp) = EXC_RETURN_THREAD_PSP;              /* LR              */
    *(--sp) = 0x0000000CU;  /* R12 — use 0xC as debug marker        */
    *(--sp) = 0x00000003U;  /* R3                                   */
    *(--sp) = 0x00000002U;  /* R2                                   */
    *(--sp) = 0x00000001U;  /* R1                                   */
    *(--sp) = 0x00000000U;  /* R0                                   */

    /* ─── SF2: software frame (pushed first → lowest address) ─── */
    *(--sp) = 0x0000000BU;  /* R11 — use register number as marker  */
    *(--sp) = 0x0000000AU;  /* R10                                  */
    *(--sp) = 0x00000009U;  /* R9                                   */
    *(--sp) = 0x00000008U;  /* R8                                   */
    *(--sp) = 0x00000007U;  /* R7                                   */
    *(--sp) = 0x00000006U;  /* R6                                   */
    *(--sp) = 0x00000005U;  /* R5                                   */
    *(--sp) = 0x00000004U;  /* R4                                   */

    /* Save the PSP into the TCB */
    tcb->psp_value = (uint32_t)sp;
}

/*
 * init_tasks_stack()
 * Call this once during startup, before init_systick() or sched_launch().
 */
void init_tasks_stack(void)
{
    init_stack_for_task(T1_STACK_START, task1_handler, &g_tcb[0]);
    init_stack_for_task(T2_STACK_START, task2_handler, &g_tcb[1]);
    init_stack_for_task(T3_STACK_START, task3_handler, &g_tcb[2]);
    init_stack_for_task(T4_STACK_START, task4_handler, &g_tcb[3]);
}

C

/*
 * scheduler.h
 * Minimal RTOS scheduler definitions
 */
#ifndef SCHEDULER_H
#define SCHEDULER_H

#include <stdint.h>

#define MAX_TASKS  4

/*
 * Task Control Block (TCB)
 * The only state we need for a simple round-robin scheduler
 * is the saved PSP value per task.
 */
typedef struct {
    uint32_t psp_value;   /* Saved stack pointer (PSP) for this task */
} tcb_t;

/* Defined in scheduler.c */
extern tcb_t g_tcb[MAX_TASKS];
extern uint8_t g_current_task;

/* API */
void init_tasks_stack(void);
void init_systick(uint32_t tick_hz);
void init_scheduler_stack(uint32_t sched_stack_start);
void sched_launch(void);
void save_psp(uint32_t psp);
uint32_t get_psp(void);
void update_next_task(void);

#endif /* SCHEDULER_H */

C

/*
 * main.c
 * Four-task round-robin scheduler startup sequence
 */
#include "scheduler.h"

/* ── Task implementations (LED toggle with busy-wait) ── */
void task1_handler(void)
{
    while (1) {
        toggle_led(LED_GREEN);   /* 1 s period  */
        delay_ms(500);
    }
}

void task2_handler(void)
{
    while (1) {
        toggle_led(LED_ORANGE);  /* 500 ms period */
        delay_ms(250);
    }
}

void task3_handler(void)
{
    while (1) {
        toggle_led(LED_RED);     /* 250 ms period */
        delay_ms(125);
    }
}

void task4_handler(void)
{
    while (1) {
        toggle_led(LED_BLUE);    /* 125 ms period */
        delay_ms(62);
    }
}

/* ── Startup ── */
int main(void)
{
    /* 1. Set up the MSP for the scheduler itself */
    init_scheduler_stack(SCHED_STACK_START);

    /* 2. Initialise hardware */
    led_init_all();

    /* 3. Build fake stack frames for all tasks — MUST be before launch */
    init_tasks_stack();

    /* 4. Configure SysTick for 1 ms tick (assuming 16 MHz clock) */
    init_systick(1000);          /* 1000 ticks/s = 1 ms per tick */

    /* 5. Hand control to the scheduler (never returns) */
    sched_launch();

    /* Should never reach here */
    for (;;);
}

Code

/* PendSV_Handler.s — GNU AS (ARM Cortex-M Thumb2)
 *
 * Called by SysTick_Handler (sets PENDSVSET bit).
 * Performs context switch between tasks using PSP.
 */

    .syntax unified
    .cpu cortex-m4
    .thumb

    .global PendSV_Handler
    .type   PendSV_Handler, %function

PendSV_Handler:
    /* ── SAVE current task context ── */
    MRS     R0, PSP            /* R0 = current task PSP               */
    STMDB   R0!, {R4-R11}      /* Push SF2 (R4-R11) onto task stack   */
    BL      save_psp           /* save_psp(R0) → stores in TCB        */

    /* ── SELECT next task ── */
    BL      update_next_task   /* Advance g_current_task index        */

    /* ── RESTORE next task context ── */
    BL      get_psp            /* R0 = next task's PSP from TCB       */
    LDMIA   R0!, {R4-R11}      /* Pop SF2 (R4-R11) from next stack    */
    MSR     PSP, R0            /* Update PSP to above SF1             */
    MOV     LR, #0xFFFFFFFD    /* EXC_RETURN: Thread/PSP/no FPU       */
    BX      LR                 /* Return; hardware pops SF1 → runs task*/

    .size PendSV_Handler, . - PendSV_Handler

Memory Layout

SRAM Stack Region Map

Five 1 KB stacks are carved from the top of SRAM. The scheduler itself uses the topmost region (it runs in Handler mode with MSP). Tasks T1–T4 occupy the four regions below it.

Practical Demo

Four-Task LED Toggle Demo

A classic first scheduler demo: four tasks each toggle a different LED at different rates. Because the tasks share CPU time via round-robin scheduling (1 ms slice), all four LEDs appear to blink independently — yet only one task runs at a time.

C

/*
 * tasks.c — four LED tasks for STM32F4xx Discovery board
 * LED pins: PD12 Green, PD13 Orange, PD14 Red, PD15 Blue
 */
#include "stm32f4xx.h"
#include "scheduler.h"

#define LED_GREEN   (1u << 12)
#define LED_ORANGE  (1u << 13)
#define LED_RED     (1u << 14)
#define LED_BLUE    (1u << 15)

static void delay_ms(uint32_t ms)
{
    /* Simple busy-wait calibrated for 16 MHz AHB clock.
     * Replace with a proper timer in production.          */
    volatile uint32_t count = ms * 2000U;
    while (count--);
}

static void toggle_led(uint32_t pin)
{
    GPIOD->ODR ^= pin;   /* XOR-toggle the pin */
}

/* ── Task handlers ── */

void task1_handler(void)
{
    for (;;) {
        toggle_led(LED_GREEN);
        delay_ms(500);
    }
}

void task2_handler(void)
{
    for (;;) {
        toggle_led(LED_ORANGE);
        delay_ms(250);
    }
}

void task3_handler(void)
{
    for (;;) {
        toggle_led(LED_RED);
        delay_ms(125);
    }
}

void task4_handler(void)
{
    for (;;) {
        toggle_led(LED_BLUE);
        delay_ms(62);
    }
}

/* ── LED GPIO init ── */
void led_init_all(void)
{
    /* Enable clock for GPIOD */
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN;

    /* PD12–PD15: Output, push-pull, no pull */
    GPIOD->MODER  &= ~(0xFFu << 24);   /* clear bits 24-31 */
    GPIOD->MODER  |=  (0x55u << 24);   /* 01=output for each pin */
    GPIOD->OTYPER &= ~(0xFu  << 12);   /* push-pull */
    GPIOD->OSPEEDR|=  (0xFFu << 24);   /* high speed */
}

C

/*
 * delay.c — SysTick-based accurate delay
 * Requires SysTick to be running at 1 ms interval.
 */
#include "stm32f4xx.h"
#include <stdint.h>

static volatile uint32_t g_tick_count = 0;

/* Called by SysTick_Handler (along with context-switch logic) */
void delay_tick_increment(void)
{
    g_tick_count++;
}

/* Blocking delay — task is still running (busy-wait) */
void delay_ms(uint32_t ms)
{
    uint32_t start = g_tick_count;
    while ((g_tick_count - start) < ms) {
        /* yield CPU voluntarily in a real RTOS — here we busy-wait */
        __NOP();
    }
}

Code

/* ── Semihosting / ITM trace output (optional debug) ── */

[  0 ms] Scheduler started. Current task: T1
[  1 ms] Context switch: T1 → T2
[  2 ms] Context switch: T2 → T3
[  3 ms] Context switch: T3 → T4
[  4 ms] Context switch: T4 → T1
...
[ 62 ms] T4: BLUE LED toggles (62 ms elapsed)
[125 ms] T3: RED LED toggles
[125 ms] T4: BLUE LED toggles
[250 ms] T2: ORANGE LED toggles
[250 ms] T3: RED LED toggles
[250 ms] T4: BLUE LED toggles
[500 ms] T1: GREEN LED toggles
[500 ms] T2: ORANGE LED toggles
[500 ms] T3: RED LED toggles
[500 ms] T4: BLUE LED toggles
[1000ms] T1: GREEN LED toggles  ← back to start of 1 s cycle

/* Board observation:
 * - Green LED blinks at  1 Hz (slowest)
 * - Orange LED blinks at 2 Hz
 * - Red LED blinks at    4 Hz
 * - Blue LED blinks at   8 Hz (fastest)
 * All four LEDs appear independent — cooperative multitasking illusion!
 */

Debugging

Common Mistakes & How to Fix Them

Summary

Key Facts at a Glance

Quiz

Test Your Understanding

FAQ

Frequently Asked Questions