Task priority assignment in FreeRTOS - Mini Project: Build & Apply

Task Priority Assignment in FreeRTOS

📖 Scenario: You are working on a simple embedded system using FreeRTOS. You need to create tasks with different priorities to manage how the system handles multiple jobs.

🎯 Goal: Build a FreeRTOS program that creates two tasks with specific priorities and prints messages showing which task is running.

📋 What You'll Learn

Create two tasks named Task1 and Task2

Assign Task1 a priority of 2

Assign Task2 a priority of 1

Each task should print a message indicating it is running

Start the FreeRTOS scheduler

💡 Why This Matters

🌍 Real World

Embedded systems often run multiple tasks like sensor reading, communication, and control. Assigning priorities helps manage which tasks get CPU time first.

💼 Career

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

1

Create two task functions

Write two task functions named Task1 and Task2. Each function should be an infinite loop that prints "Task 1 is running" and "Task 2 is running" respectively, then calls vTaskDelay(1000 / portTICK_PERIOD_MS) to wait for 1 second.

FreeRTOS

// Define Task1 function
void Task1(void *pvParameters) {
    // Your code here
}

// Define Task2 function
void Task2(void *pvParameters) {
    // Your code here
}

Hint

Use while(1) loops inside each task function to keep them running. Use printf to print messages and vTaskDelay to pause.

2

Create task handles and priority variables

Declare two task handles named xTask1Handle and xTask2Handle. Also, create two variables task1Priority and task2Priority and set them to 2 and 1 respectively.

FreeRTOS

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

void Task1(void *pvParameters) {
    while(1) {
        printf("Task 1 is running\n");
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void Task2(void *pvParameters) {
    while(1) {
        printf("Task 2 is running\n");
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

// Declare task handles and priority variables
// Your code here

Hint

Use TaskHandle_t to declare task handles. Use const UBaseType_t for priority variables.

3

Create tasks with assigned priorities

Use xTaskCreate to create Task1 and Task2 with their respective priorities task1Priority and task2Priority. Pass the task handles xTask1Handle and xTask2Handle to store the created tasks.

FreeRTOS

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

void Task1(void *pvParameters) {
    while(1) {
        printf("Task 1 is running\n");
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void Task2(void *pvParameters) {
    while(1) {
        printf("Task 2 is running\n");
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

TaskHandle_t xTask1Handle = NULL;
TaskHandle_t xTask2Handle = NULL;

const UBaseType_t task1Priority = 2;
const UBaseType_t task2Priority = 1;

int main(void) {
    // Create Task1 and Task2 with their priorities
    // Your code here
}

Hint

Use xTaskCreate with parameters: function name, task name string, stack size, parameters (NULL), priority, and task handle address.

4

Start the scheduler and print confirmation

Call vTaskStartScheduler() to start the FreeRTOS scheduler. Then print "Scheduler started" before starting. This will run the tasks with their assigned priorities.

FreeRTOS

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

void Task1(void *pvParameters) {
    while(1) {
        printf("Task 1 is running\n");
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void Task2(void *pvParameters) {
    while(1) {
        printf("Task 2 is running\n");
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

TaskHandle_t xTask1Handle = NULL;
TaskHandle_t xTask2Handle = NULL;

const UBaseType_t task1Priority = 2;
const UBaseType_t task2Priority = 1;

int main(void) {
    xTaskCreate(Task1, "Task1", configMINIMAL_STACK_SIZE, NULL, task1Priority, &xTask1Handle);
    xTaskCreate(Task2, "Task2", configMINIMAL_STACK_SIZE, NULL, task2Priority, &xTask2Handle);
    printf("Scheduler started\n");
    // Start the scheduler
    // Your code here
}

Hint

Call vTaskStartScheduler() after printing the message to begin running the tasks.

Practice

1.

In FreeRTOS, what does a higher task priority number mean?

easy

A. The task runs only when idle

B. The task runs after lower priority tasks

C. The task runs before lower priority tasks

D. The task is deleted automatically

Solution

1. Step 1: Understand task priority meaning

   In FreeRTOS, tasks with higher priority numbers get CPU time before lower priority tasks.

2. Step 2: Relate priority number to execution order

   A higher number means the task is more important and runs first.

3. Final Answer:

   The task runs before lower priority tasks -> Option C

4. Quick Check:

   Higher priority = runs first [OK]

Hint: Higher number means higher priority, runs first [OK]

Common Mistakes:

• Thinking lower number means higher priority
• Confusing priority with task state
• Assuming priority controls memory usage

2.

Which of the following is the correct way to assign a priority of 3 to a task in FreeRTOS using xTaskCreate?

void vTaskFunction(void *pvParameters) { /* Task code */ }

xTaskCreate(vTaskFunction, "Task1", 1000, NULL, ?, NULL);

easy

A. taskPriority = 3

B. "3"

C. priority = 3

D. 3

Solution

1. Step 1: Check xTaskCreate parameters

   The fifth parameter is the task priority and expects an integer value.

2. Step 2: Identify correct priority assignment

   Passing 3 directly as an integer is correct; strings or assignments are invalid here.

3. Final Answer:

   3 -> Option D

4. Quick Check:

   Priority parameter = integer value [OK]

Hint: Priority is an integer, no quotes or assignments [OK]

Common Mistakes:

• Using quotes around priority number
• Writing assignment expressions inside parameters
• Passing variable names without declaration

3.

Given the following FreeRTOS code snippet, which task will run first?

void TaskA(void *pvParameters) { while(1) {} }
void TaskB(void *pvParameters) { while(1) {} }

xTaskCreate(TaskA, "A", 1000, NULL, 2, NULL);
xTaskCreate(TaskB, "B", 1000, NULL, 4, NULL);

medium

A. TaskB

B. TaskA

C. Both run simultaneously

D. Neither runs

Solution

1. Step 1: Identify task priorities

   TaskA has priority 2, TaskB has priority 4.

2. Step 2: Determine which runs first

   TaskB has higher priority, so it runs before TaskA.

3. Final Answer:

   TaskB -> Option A

4. Quick Check:

   Higher priority task runs first [OK]

Hint: Higher priority number runs first [OK]

Common Mistakes:

• Assuming tasks run in creation order
• Thinking equal priority means simultaneous run
• Ignoring priority values

4.

What is wrong with this FreeRTOS task creation code snippet?

void vTask(void *pvParameters) { /* code */ }

xTaskCreate(vTask, "Task", 1000, NULL, 5, NULL);
xTaskCreate(vTask, "Task", 1000, NULL, -1, NULL);

medium

A. Priority cannot be negative

B. Task name must be unique

C. Stack size must be zero

D. Task function must return int

Solution

1. Step 1: Check priority values

   FreeRTOS priorities must be zero or positive integers; negative values are invalid.

2. Step 2: Validate other parameters

   Task name can be reused, stack size 1000 is valid, and task function returns void as required.

3. Final Answer:

   Priority cannot be negative -> Option A

4. Quick Check:

   Priority >= 0 required [OK]

Hint: Priority must be zero or positive [OK]

Common Mistakes:

• Using negative priority values
• Thinking task names must be unique
• Expecting task function to return int

5.

You have three tasks with priorities 1, 3, and 3. How should you assign priorities to ensure the most important task runs first and the least important runs last?

Choose the best priority assignment:

• A: Task1=1, Task2=3, Task3=3
• B: Task1=3, Task2=3, Task3=1
• C: Task1=3, Task2=1, Task3=3
• D: Task1=1, Task2=1, Task3=3

hard

A. Task1=1 (lowest), Task2=3, Task3=3 (highest)

B. Task1=3 (highest), Task2=3, Task3=1 (lowest)

C. Task1=3 (highest), Task2=1, Task3=3 (highest)

D. Task1=1, Task2=1, Task3=3 (highest)

Solution

1. Step 1: Identify importance order

   The most important task should have highest priority (3), least important lowest (1).

2. Step 2: Match priorities to tasks

   Task1=3 (highest), Task2=3, Task3=1 (lowest) assigns highest priority (3) to Task1 and Task2, and lowest (1) to Task3, ensuring important tasks run first.

3. Final Answer:

   Task1=3 (highest), Task2=3, Task3=1 (lowest) -> Option B

4. Quick Check:

   Highest priority = most important task [OK]

Hint: Assign highest number to most important task [OK]

Common Mistakes:

• Assigning same priority to all tasks
• Giving lowest priority to important tasks
• Ignoring task importance order