Why priority design matters in FreeRTOS - Visual Breakdown

Concept Flow - Why priority design matters

Start Tasks

↓

Task with Highest Priority Runs

↓

Lower Priority Tasks Wait

↓

If Higher Priority Task Blocks or Delays

↓

Next Highest Priority Task Runs

↓

Repeat Until All Tasks Complete or Blocked

Tasks run based on priority: highest priority ready task runs first, lower priority tasks wait. Proper priority design avoids blocking important tasks.

Execution Sample

FreeRTOS

Task1 (Priority 3) runs
Task2 (Priority 2) runs
Task3 (Priority 1) runs
Higher priority tasks preempt lower ones

Shows how tasks with different priorities run, with higher priority tasks running before lower ones.

Execution Table

Step	Running Task	Task Priorities	Action	Result
1	Task1	Task1=3, Task2=2, Task3=1	Task1 starts running	Task1 runs
2	Task1	Task1=3, Task2=2, Task3=1	Task1 continues	Task1 runs
3	Task2	Task1=3 (blocked), Task2=2, Task3=1	Task1 blocks, Task2 runs	Task2 runs
4	Task2	Task1=3 (blocked), Task2=2, Task3=1	Task2 continues	Task2 runs
5	Task3	Task1=3 (blocked), Task2=2 (blocked), Task3=1	Task2 blocks, Task3 runs	Task3 runs
6	Idle	All tasks blocked	All tasks blocked, idle runs	Idle runs
7	Task1	Task1=3 ready	Task1 ready again, preempts idle	Task1 runs

💡 Execution stops when all tasks are blocked or completed.

Variable Tracker

Variable	Start	After Step 3	After Step 5	After Step 7
Task1 State	Ready	Blocked	Blocked	Ready
Task2 State	Ready	Running	Blocked	Blocked
Task3 State	Ready	Ready	Running	Blocked
CPU Running Task	Task1	Task2	Task3	Task1

Key Moments - 3 Insights

Why does Task2 run only after Task1 blocks?

Because Task1 has higher priority (3) and runs first; Task2 (priority 2) runs only when Task1 is blocked, as shown in execution_table step 3.

What happens if a higher priority task becomes ready while a lower priority task is running?

The higher priority task preempts the lower priority one immediately, as seen in step 7 where Task1 preempts idle.

Why is priority design important in FreeRTOS?

To ensure critical tasks run promptly and lower priority tasks do not block them, preventing delays or missed deadlines.

Visual Quiz - 3 Questions

Look at the execution_table, which task runs at step 5?

A Task1

B Task3

C Task2

D Idle

💡 Hint

Check the 'Running Task' column at step 5 in execution_table.

At which step does Task1 become blocked?

A Step 3

B Step 1

C Step 5

D Step 7

💡 Hint

Look at Task1 State in variable_tracker after step 3.

If Task1 never blocks, what happens to Task2 and Task3?

A They run normally after Task1

B They run simultaneously with Task1

C They never get CPU time

D They run before Task1

💡 Hint

Recall that higher priority tasks preempt lower ones; see concept_flow and execution_table.

Concept Snapshot

FreeRTOS runs tasks by priority.
Highest priority ready task runs first.
Lower priority tasks wait if higher priority is ready.
Proper priority design avoids blocking critical tasks.
Preemption ensures responsiveness.
Blocking or delays let lower priority tasks run.

Full Transcript

In FreeRTOS, tasks have priorities. The system always runs the highest priority task that is ready. Lower priority tasks wait until higher priority tasks block or delay. This ensures important tasks get CPU time first. If a higher priority task becomes ready while a lower priority task runs, it preempts the lower one immediately. Proper priority design is important to avoid blocking critical tasks and to keep the system responsive. The execution table shows tasks running step-by-step based on their priority and state changes. Variable tracking shows how task states and CPU running task change over time.

Practice

1.

Why is task priority important in FreeRTOS?

easy

A. It determines which task runs first when multiple are ready.

B. It changes the task's memory size automatically.

C. It controls the task's stack overflow protection.

D. It sets the task's execution time limit.

Solution

1. Step 1: Understand task scheduling in FreeRTOS

   FreeRTOS uses task priorities to decide which task runs when multiple tasks are ready.

2. Step 2: Identify the role of priority

   The highest priority ready task gets CPU time first, ensuring important tasks run promptly.

3. Final Answer:

   It determines which task runs first when multiple are ready. -> Option A

4. Quick Check:

   Priority controls task execution order = A [OK]

Hint: Priority decides task run order, highest runs first [OK]

Common Mistakes:

• Confusing priority with memory size
• Thinking priority limits execution time
• Assuming priority controls stack protection

2.

Which of the following is the correct way to set a task priority in FreeRTOS?

vTaskPrioritySet(

easy

A. vTaskPrioritySet(TaskHandle_t xTask);

B. vTaskPrioritySet(TaskHandle_t xTask, UBaseType_t uxNewPriority);

C. vTaskPrioritySet(UBaseType_t uxNewPriority, TaskHandle_t xTask);

D. vTaskPrioritySet(UBaseType_t uxNewPriority);

Solution

1. Step 1: Recall FreeRTOS API for setting priority

   The function vTaskPrioritySet requires the task handle and the new priority as parameters.

2. Step 2: Check parameter order

   The correct order is first the task handle, then the new priority value.

3. Final Answer:

   vTaskPrioritySet(TaskHandle_t xTask, UBaseType_t uxNewPriority); -> Option B

4. Quick Check:

   Correct parameter order = C [OK]

Hint: Task handle first, then priority in vTaskPrioritySet [OK]

Common Mistakes:

• Swapping parameter order
• Missing one parameter
• Using wrong parameter types

3.

Given two tasks, TaskA with priority 3 and TaskB with priority 2, both ready to run, which task will FreeRTOS run first?

medium

A. TaskB

B. Depends on task creation order

C. Both run simultaneously

D. TaskA

Solution

1. Step 1: Compare task priorities

   TaskA has priority 3, TaskB has priority 2. Higher number means higher priority.

2. Step 2: Determine which task runs first

   FreeRTOS runs the highest priority ready task first, so TaskA runs before TaskB.

3. Final Answer:

   TaskA -> Option D

4. Quick Check:

   Higher priority runs first = B [OK]

Hint: Higher priority number runs first in FreeRTOS [OK]

Common Mistakes:

• Thinking lower number means higher priority
• Assuming tasks run simultaneously
• Believing creation order affects scheduling

4.

What is wrong with this code snippet?

vTaskPrioritySet(3, TaskHandle);

medium

A. Parameters are in wrong order.

B. Priority value 3 is invalid.

C. TaskHandle should be a number.

D. Function name is incorrect.

Solution

1. Step 1: Check function parameter order

   The correct order is (TaskHandle_t xTask, UBaseType_t uxNewPriority), but here it is reversed.

2. Step 2: Validate parameter types

   TaskHandle should be first, priority second. The code swaps them causing error.

3. Final Answer:

   Parameters are in wrong order. -> Option A

4. Quick Check:

   Correct parameter order matters = A [OK]

Hint: Task handle first, priority second in vTaskPrioritySet [OK]

Common Mistakes:

• Swapping parameters
• Using wrong data types
• Misnaming the function

5.

You have three tasks: Task1 (priority 2), Task2 (priority 2), and Task3 (priority 3). Task1 and Task2 share a resource and must not run simultaneously. How should you design priorities to keep the system responsive and safe?

hard

A. Use no priorities and rely on task delays.

B. Set all tasks to same priority to avoid conflicts.

C. Set Task3 highest priority, Task1 and Task2 equal lower priorities, use mutex for resource.

D. Set Task1 highest priority, Task2 medium, Task3 lowest.

Solution

1. Step 1: Assign highest priority to critical task

   Task3 has highest priority (3) to keep system responsive.

2. Step 2: Use equal lower priorities and mutex for shared resource

   Task1 and Task2 have same priority (2) and use a mutex to prevent simultaneous access.

3. Step 3: Avoid equal priorities without synchronization

   Equal priorities without mutex risk resource conflicts; delays reduce responsiveness.

4. Final Answer:

   Set Task3 highest priority, Task1 and Task2 equal lower priorities, use mutex for resource. -> Option C

5. Quick Check:

   Priority + mutex ensures safety and responsiveness = D [OK]

Hint: Use highest priority for critical task, mutex for shared resource [OK]

Common Mistakes:

• Ignoring resource protection
• Setting all tasks same priority without sync
• Using delays instead of priorities