Priority-based scheduling in FreeRTOS - Mini Project: Build & Apply

Priority-based scheduling

📖 Scenario: You are working on a small embedded system that uses FreeRTOS. You want to create tasks with different priorities to see how FreeRTOS schedules them.

🎯 Goal: Create three tasks with different priorities and observe how FreeRTOS runs the highest priority task first.

📋 What You'll Learn

Create three tasks named Task1, Task2, and Task3.

Assign priorities 1, 2, and 3 to Task1, Task2, and Task3 respectively.

Each task should print its name once when it runs.

Start the FreeRTOS scheduler to run the tasks.

💡 Why This Matters

🌍 Real World

Embedded systems often need to run multiple tasks with different importance levels. Priority-based scheduling helps ensure critical tasks run first.

💼 Career

Understanding FreeRTOS task priorities is essential for embedded software developers working on real-time applications like IoT devices, automotive systems, and industrial controllers.

1

Create three tasks with empty functions

Create three task functions called Task1, Task2, and Task3. Each function should have the correct FreeRTOS task signature and an infinite loop with no code inside.

FreeRTOS

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

void Task2(void *pvParameters) {
    for(;;) {
        // Your code here
    }
}

void Task3(void *pvParameters) {
    for(;;) {
        // Your code here
    }
}

Hint

Each task function must have the signature void TaskName(void *pvParameters) and an infinite loop for(;;).

2

Create task handles and add tasks with priorities

Create three task handles called xTask1Handle, xTask2Handle, and xTask3Handle. Use xTaskCreate to create Task1 with priority 1, Task2 with priority 2, and Task3 with priority 3. Use stack size 100 for all tasks and pass NULL as parameters.

FreeRTOS

void Task1(void *pvParameters) {
    for(;;) {
    }
}

void Task2(void *pvParameters) {
    for(;;) {
    }
}

void Task3(void *pvParameters) {
    for(;;) {
    }
}

TaskHandle_t xTask1Handle, xTask2Handle, xTask3Handle;

// Create tasks with priorities
// Your code here

Hint

Use xTaskCreate with the correct parameters: function, name, stack size, parameters, priority, and handle.

3

Add print statements inside each task

Inside the infinite loop of each task function, add a printf statement that prints the task name: "Running Task1\n" in Task1, "Running Task2\n" in Task2, and "Running Task3\n" in Task3. Add a vTaskDelay(1000 / portTICK_PERIOD_MS); after the print to delay 1 second.

FreeRTOS

void Task1(void *pvParameters) {
    for(;;) {
        // Add printf and delay here
    }
}

void Task2(void *pvParameters) {
    for(;;) {
        // Add printf and delay here
    }
}

void Task3(void *pvParameters) {
    for(;;) {
        // Add printf and delay here
    }
}

TaskHandle_t xTask1Handle, xTask2Handle, xTask3Handle;

xTaskCreate(Task1, "Task1", 100, NULL, 1, &xTask1Handle);
xTaskCreate(Task2, "Task2", 100, NULL, 2, &xTask2Handle);
xTaskCreate(Task3, "Task3", 100, NULL, 3, &xTask3Handle);

Hint

Use printf to print the task name and vTaskDelay to pause the task for 1 second.

4

Start the FreeRTOS scheduler

Add the call vTaskStartScheduler(); after creating the tasks to start the FreeRTOS scheduler.

FreeRTOS

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

void Task1(void *pvParameters) {
    for(;;) {
        printf("Running Task1\n");
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void Task2(void *pvParameters) {
    for(;;) {
        printf("Running Task2\n");
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void Task3(void *pvParameters) {
    for(;;) {
        printf("Running Task3\n");
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

TaskHandle_t xTask1Handle, xTask2Handle, xTask3Handle;

xTaskCreate(Task1, "Task1", 100, NULL, 1, &xTask1Handle);
xTaskCreate(Task2, "Task2", 100, NULL, 2, &xTask2Handle);
xTaskCreate(Task3, "Task3", 100, NULL, 3, &xTask3Handle);

// Start the scheduler
// Your code here

Hint

Call vTaskStartScheduler(); to start running the tasks.

Practice

1.

What does priority-based scheduling in FreeRTOS ensure?

easy

A. Tasks run randomly without any priority

B. Tasks run in the order they were created

C. The highest priority task runs first

D. All tasks run equally regardless of priority

Solution

1. Step 1: Understand priority-based scheduling

   Priority-based scheduling means tasks with higher priority get CPU time before lower priority tasks.

2. Step 2: Apply this to FreeRTOS task execution

   FreeRTOS runs the highest priority task that is ready to run first, preempting lower priority tasks.

3. Final Answer:

   The highest priority task runs first -> Option C

4. Quick Check:

   Priority-based scheduling = highest priority runs first [OK]

Hint: Highest priority task always runs first in FreeRTOS [OK]

Common Mistakes:

• Thinking tasks run in creation order
• Assuming equal CPU time for all tasks
• Believing tasks run randomly

2.

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

xTaskCreate(TaskFunction, "TaskName", 1000, NULL, ___, &TaskHandle);

easy

A. task name

B. stack size

C. task handle

D. priority

Solution

1. Step 1: Identify parameters of xTaskCreate

   The fifth parameter in xTaskCreate is the task priority.

2. Step 2: Match parameter to correct argument

   Passing 'priority' sets the task's priority level correctly.

3. Final Answer:

   priority -> Option D

4. Quick Check:

   Fifth parameter in xTaskCreate = priority [OK]

Hint: Priority is the fifth argument in xTaskCreate [OK]

Common Mistakes:

• Confusing stack size with priority
• Using task handle as priority
• Passing task name instead of priority

3.

Given the following FreeRTOS tasks with priorities, which task will run first?

Task A priority = 2
Task B priority = 3
Task C priority = 1

medium

A. Task A

B. Task B

C. Task C

D. All run simultaneously

Solution

1. Step 1: Compare task priorities

   Task B has priority 3, which is higher than Task A (2) and Task C (1).

2. Step 2: Determine which task runs first

   FreeRTOS runs the highest priority task first, so Task B runs before others.

3. Final Answer:

   Task B -> Option B

4. Quick Check:

   Highest priority (3) = Task B [OK]

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

Common Mistakes:

• Choosing task with lowest priority
• Assuming tasks run simultaneously
• Ignoring priority values

4.

Identify the error in this FreeRTOS task creation code snippet:

BaseType_t result = xTaskCreate(TaskFunc, "Task1", 500, NULL, 0, NULL);
if(result != pdPASS) {
    // Handle error
}

What is wrong with the priority value?

medium

A. Priority 0 means lowest priority but is valid

B. Priority 0 is invalid and causes error

C. Priority must be greater than 5

D. Priority should be a negative number

Solution

1. Step 1: Understand priority 0 in FreeRTOS

   Priority 0 is the lowest priority and is valid in FreeRTOS.

2. Step 2: Check if priority 0 causes error

   Priority 0 does not cause an error; task creation can succeed with it.

3. Final Answer:

   Priority 0 means lowest priority but is valid -> Option A

4. Quick Check:

   Priority 0 is valid lowest priority [OK]

Hint: Priority 0 is valid and lowest priority in FreeRTOS [OK]

Common Mistakes:

• Thinking priority 0 is invalid
• Assuming priority must be > 5
• Using negative priority values

5.

You have three tasks with priorities 2, 4, and 3. Task with priority 4 is blocked waiting for an event. Which task will FreeRTOS schedule next?

hard

A. Task with priority 3

B. Task with priority 2

C. Task with priority 4

D. No task runs until priority 4 task is ready

Solution

1. Step 1: Understand task states and scheduling

   FreeRTOS schedules the highest priority task that is ready (not blocked).

2. Step 2: Identify ready tasks

   Task with priority 4 is blocked, so it cannot run now. Tasks with priority 3 and 2 are ready.

3. Step 3: Choose highest priority ready task

   Between priority 3 and 2, priority 3 is higher, so it runs next.

4. Final Answer:

   Task with priority 3 -> Option A

5. Quick Check:

   Highest ready priority = 3 [OK]

Hint: Blocked tasks don't run; next highest ready priority runs [OK]

Common Mistakes:

• Trying to run blocked task
• Ignoring task states
• Assuming no task runs if highest priority blocked