Why priority design matters in FreeRTOS - See It in Action

Why Priority Design Matters in FreeRTOS

📖 Scenario: Imagine you are building a simple embedded system using FreeRTOS. This system has multiple tasks like reading sensors, controlling motors, and sending data over communication. Each task has a different importance level. To make sure the most important tasks run first, you need to assign priorities correctly.

🎯 Goal: You will create three FreeRTOS tasks with different priorities and observe how priority affects which task runs first. This will help you understand why designing task priorities carefully is important in real-time systems.

📋 What You'll Learn

Create three FreeRTOS tasks named SensorTask, MotorTask, and CommTask

Assign priorities: SensorTask highest, MotorTask medium, CommTask lowest

Each task should print its name when running

Observe the order of task execution based on priority

💡 Why This Matters

🌍 Real World

In embedded systems like robots or IoT devices, tasks have different importance. Priority design ensures critical tasks run on time.

💼 Career

Understanding task priorities is essential for embedded software engineers working with real-time operating systems like FreeRTOS.

1

Create three FreeRTOS tasks

Write code to create three FreeRTOS tasks named SensorTask, MotorTask, and CommTask. Each task should run a simple function that prints its name once and then deletes itself.

FreeRTOS

// Create three tasks: SensorTask, MotorTask, CommTask
// Each task prints its name and deletes itself
// Your code here

Hint

Use xTaskCreate to create each task. Each task function should print its name and then call vTaskDelete(NULL) to end.

2

Assign different priorities to tasks

Change the task creation code to assign priorities: SensorTask priority 3, MotorTask priority 2, and CommTask priority 1.

FreeRTOS

#include "FreeRTOS.h"
#include "task.h"
#include 

void SensorTask(void *pvParameters) {
    printf("SensorTask is running\n");
    vTaskDelete(NULL);
}

void MotorTask(void *pvParameters) {
    printf("MotorTask is running\n");
    vTaskDelete(NULL);
}

void CommTask(void *pvParameters) {
    printf("CommTask is running\n");
    vTaskDelete(NULL);
}

int main(void) {
    // Change priorities here
    xTaskCreate(SensorTask, "SensorTask", 1000, NULL, 3, NULL);
    xTaskCreate(MotorTask, "MotorTask", 1000, NULL, 2, NULL);
    xTaskCreate(CommTask, "CommTask", 1000, NULL, 1, NULL);
    vTaskStartScheduler();
    return 0;
}
// Your code here

Hint

Set the priority argument in xTaskCreate to 3 for SensorTask, 2 for MotorTask, and 1 for CommTask.

3

Observe task execution order

Add code to each task to print its name repeatedly in a loop with a small delay. This will help you see which task runs first based on priority.

FreeRTOS

#include "FreeRTOS.h"
#include "task.h"
#include 

void SensorTask(void *pvParameters) {
    while(1) {
        printf("SensorTask is running\n");
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

void MotorTask(void *pvParameters) {
    while(1) {
        printf("MotorTask is running\n");
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

void CommTask(void *pvParameters) {
    while(1) {
        printf("CommTask is running\n");
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

int main(void) {
    xTaskCreate(SensorTask, "SensorTask", 1000, NULL, 3, NULL);
    xTaskCreate(MotorTask, "MotorTask", 1000, NULL, 2, NULL);
    xTaskCreate(CommTask, "CommTask", 1000, NULL, 1, NULL);
    vTaskStartScheduler();
    return 0;
}
// Your code here

Hint

Use an infinite loop while(1) in each task. Inside the loop, print the task name and call vTaskDelay(pdMS_TO_TICKS(1000)) to pause for 1 second.

4

Print the observed task execution order

Run the program and observe the printed output. Write a print statement outside the tasks that explains which task runs first based on priority.

FreeRTOS

#include "FreeRTOS.h"
#include "task.h"
#include 

void SensorTask(void *pvParameters) {
    while(1) {
        printf("SensorTask is running\n");
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

void MotorTask(void *pvParameters) {
    while(1) {
        printf("MotorTask is running\n");
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

void CommTask(void *pvParameters) {
    while(1) {
        printf("CommTask is running\n");
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

int main(void) {
    xTaskCreate(SensorTask, "SensorTask", 1000, NULL, 3, NULL);
    xTaskCreate(MotorTask, "MotorTask", 1000, NULL, 2, NULL);
    xTaskCreate(CommTask, "CommTask", 1000, NULL, 1, NULL);
    vTaskStartScheduler();
    // Print explanation below
    printf("SensorTask runs first because it has the highest priority.\n");
    // Your code here
}

Hint

After starting the scheduler, add a printf statement explaining that SensorTask runs first due to its highest priority.

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