FreeRTOS architecture overview - Step-by-Step Execution

Concept Flow - FreeRTOS architecture overview

Start FreeRTOS Kernel

↓

Initialize Hardware & Resources

↓

Create Tasks & Queues

↓

Start Scheduler

↓

Scheduler Chooses Task

↓

Task Runs

↓

Task Blocks or Yields

↓

Scheduler Chooses Next Task

↓

Idle Task Runs

↓

Repeat Scheduling Cycle

This flow shows how FreeRTOS starts, creates tasks, runs the scheduler, and switches between tasks.

Execution Sample

FreeRTOS

void main(void) {
  xTaskCreate(Task1, "Task1", 1000, NULL, 1, NULL);
  vTaskStartScheduler();
}

void Task1(void *pvParameters) {
  for(;;) { /* Task code */ }
}

This code creates one task and starts the FreeRTOS scheduler to run it.

Execution Table

Step	Action	Scheduler State	Running Task	Notes
1	System starts	Scheduler not running	None	Kernel initialized
2	Create Task1	Scheduler not running	None	Task1 added to ready list
3	Start Scheduler	Scheduler running	Task1	Scheduler picks highest priority task
4	Task1 runs	Scheduler running	Task1	Task1 executes its loop
5	Task1 blocks or yields	Scheduler running	Idle Task	No ready tasks, idle runs
6	Idle Task runs	Scheduler running	Idle Task	CPU idle until next event
7	Task1 ready again	Scheduler running	Task1	Scheduler switches back to Task1
8	Repeat cycle	Scheduler running	Task1 or Idle	Continuous scheduling
9	System shutdown	Scheduler stopped	None	Scheduler stops, system halts

💡 Scheduler runs indefinitely until system shutdown or reset

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	After Step 7	Final
Scheduler State	Not running	Not running	Running	Running	Running	Running
Running Task	None	None	Task1	Idle Task	Task1	Task1 or Idle
Task1 State	Not created	Ready	Running	Blocked/Yielded	Ready	Running or Blocked

Key Moments - 3 Insights

Why does the Idle Task run after Task1 blocks or yields?

When Task1 blocks or yields (see step 5 in execution_table), no other tasks are ready, so the scheduler runs the Idle Task to keep the CPU busy.

What happens if no tasks are created before starting the scheduler?

If no tasks exist, the scheduler runs only the Idle Task indefinitely, as shown in the scheduler state after step 3.

Does the scheduler stop automatically?

No, the scheduler runs indefinitely until the system is shut down or reset, as noted in the exit_note.

Visual Quiz - 3 Questions

Look at the execution_table, what is the running task immediately after starting the scheduler?

A Idle Task

B Task1

C None

D Scheduler

💡 Hint

Check step 3 in the execution_table where the scheduler starts and picks Task1.

At which step does the scheduler run the Idle Task?

A Step 4

B Step 5

C Step 6

D Step 7

💡 Hint

Look at the execution_table rows where the running task is Idle Task.

If Task1 never blocks or yields, which task runs continuously?

A Task1

B Scheduler

C Idle Task

D No task runs

💡 Hint

Refer to variable_tracker showing Task1 state during continuous running.

Concept Snapshot

FreeRTOS starts by initializing hardware and creating tasks.
The scheduler runs and picks the highest priority ready task.
Tasks run until they block, yield, or complete.
When no tasks are ready, the Idle Task runs.
The scheduler runs indefinitely managing task switching.

Full Transcript

FreeRTOS architecture begins with system start and hardware initialization. Tasks are created and added to the ready list. When the scheduler starts, it picks the highest priority ready task to run. Tasks execute their code until they block or yield, at which point the scheduler selects the next ready task. If no tasks are ready, the Idle Task runs to keep the CPU busy. This cycle repeats indefinitely until the system shuts down or resets.

Practice

1. What is the main role of the FreeRTOS scheduler in its architecture?

easy

A. To store data permanently

B. To decide which task runs and when

C. To compile the code

D. To manage hardware interrupts only

Solution

1. Step 1: Understand the scheduler's purpose

   The scheduler controls task execution order and timing in FreeRTOS.

2. Step 2: Compare with other options

   Storing data, compiling code, or only managing interrupts are not scheduler roles.

3. Final Answer:

   To decide which task runs and when -> Option B

4. Quick Check:

   Scheduler controls task timing = To decide which task runs and when [OK]

Hint: Scheduler manages task timing and switching [OK]

Common Mistakes:

• Confusing scheduler with memory storage
• Thinking scheduler compiles code
• Assuming scheduler only handles interrupts

2. Which of the following is the correct way to create a task in FreeRTOS?

easy

A. task_create(TaskFunction, StackSize);

B. CreateTask(TaskFunction, Priority);

C. xTaskCreate(TaskFunction, "TaskName", StackSize, NULL, Priority, &TaskHandle);

D. StartTask(TaskFunction, "TaskName");

Solution

1. Step 1: Recall FreeRTOS task creation syntax

   The correct function is xTaskCreate with parameters: function, name, stack size, parameters, priority, and handle.

2. Step 2: Check options for exact match

   Only xTaskCreate(TaskFunction, "TaskName", StackSize, NULL, Priority, &TaskHandle); matches the correct FreeRTOS API call syntax.

3. Final Answer:

   xTaskCreate(TaskFunction, "TaskName", StackSize, NULL, Priority, &TaskHandle); -> Option C

4. Quick Check:

   Use xTaskCreate with full parameters = xTaskCreate(TaskFunction, "TaskName", StackSize, NULL, Priority, &TaskHandle); [OK]

Hint: Remember xTaskCreate needs 6 parameters [OK]

Common Mistakes:

• Using incorrect function names
• Omitting required parameters
• Confusing task creation with starting tasks

3. Given the following FreeRTOS code snippet, what will be the output on the serial console?

void vTask1(void *pvParameters) {
    for (;;) {
        printf("Task 1 running\n");
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

void vTask2(void *pvParameters) {
    for (;;) {
        printf("Task 2 running\n");
        vTaskDelay(pdMS_TO_TICKS(500));
    }
}

int main() {
    xTaskCreate(vTask1, "Task1", 1000, NULL, 1, NULL);
    xTaskCreate(vTask2, "Task2", 1000, NULL, 1, NULL);
    vTaskStartScheduler();
    return 0;
}

medium

A. Task 1 running every 1 second, Task 2 running every 0.5 seconds

B. Task 1 and Task 2 run simultaneously without delay

C. Only Task 1 runs, Task 2 never runs

D. No output because scheduler is not started

Solution

1. Step 1: Analyze task delays

   Task 1 delays 1000 ms (1 second), Task 2 delays 500 ms (0.5 seconds) between prints.

2. Step 2: Understand scheduler behavior

   Both tasks have same priority and run repeatedly with their delays, so Task 2 prints twice as often.

3. Final Answer:

   Task 1 running every 1 second, Task 2 running every 0.5 seconds -> Option A

4. Quick Check:

   Delays control print frequency = Task 1 running every 1 second, Task 2 running every 0.5 seconds [OK]

Hint: Check vTaskDelay times to predict print frequency [OK]

Common Mistakes:

• Assuming tasks run simultaneously without delay
• Thinking only one task runs
• Ignoring vTaskStartScheduler call

4. Identify the error in this FreeRTOS task creation code snippet:

void vTask(void *pvParameters) {
    for (;;) {
        // Task code
    }
}

int main() {
    xTaskCreate(vTask, "Task", 1000, NULL, 2);
    vTaskStartScheduler();
    return 0;
}

medium

A. Missing task handle parameter in xTaskCreate

B. Task function should not have an infinite loop

C. Priority value 2 is invalid

D. vTaskStartScheduler() should be called before xTaskCreate

Solution

1. Step 1: Check xTaskCreate parameters

   xTaskCreate requires 6 parameters; here only 5 are provided, missing the task handle pointer.

2. Step 2: Verify other parts

   Infinite loop in task is normal, priority 2 is valid, scheduler must start after task creation.

3. Final Answer:

   Missing task handle parameter in xTaskCreate -> Option A

4. Quick Check:

   xTaskCreate needs 6 params = Missing handle param [OK]

Hint: Count xTaskCreate parameters; must be six [OK]

Common Mistakes:

• Omitting task handle parameter
• Misunderstanding infinite loops in tasks
• Incorrect order of scheduler start

5. You want to design a FreeRTOS system where a high-priority task waits for data from a low-priority task without wasting CPU time. Which FreeRTOS feature best supports this design?

hard

A. Running both tasks at the same priority to share CPU equally

B. Using vTaskDelay in the high-priority task to wait

C. Using global variables with busy-wait loops

D. Using a queue to send data and block the high-priority task until data arrives

Solution

1. Step 1: Understand task synchronization needs

   The high-priority task must wait efficiently without wasting CPU cycles.

2. Step 2: Evaluate FreeRTOS features

   Queues allow blocking the high-priority task until data is available, avoiding busy-waiting.

3. Step 3: Rule out other options

   vTaskDelay wastes time, busy-wait loops waste CPU, equal priority doesn't guarantee waiting.

4. Final Answer:

   Using a queue to send data and block the high-priority task until data arrives -> Option D

5. Quick Check:

   Queue blocks task efficiently = Using a queue to send data and block the high-priority task until data arrives [OK]

Hint: Use queues to block and wait without CPU waste [OK]

Common Mistakes:

• Using delays instead of blocking
• Busy-waiting wastes CPU
• Ignoring priority differences