Priority inheritance behavior in FreeRTOS - Mini Project: Build & Apply

Priority Inheritance Behavior in FreeRTOS

📖 Scenario: You are working on a FreeRTOS-based embedded system where two tasks share a resource protected by a mutex. You want to understand how priority inheritance helps avoid priority inversion.

🎯 Goal: Build a simple FreeRTOS program with two tasks and a mutex. Observe how priority inheritance works when a low priority task holds the mutex and a high priority task tries to take it.

📋 What You'll Learn

Create two tasks: LowPriorityTask and HighPriorityTask

Create a mutex called xMutex

Use priority inheritance by taking and giving the mutex

Print messages showing task execution order and mutex status

💡 Why This Matters

🌍 Real World

Priority inheritance is important in embedded systems to avoid priority inversion, which can cause delays in critical tasks.

💼 Career

Understanding FreeRTOS mutexes and priority inheritance is essential for embedded software engineers working on real-time systems.

1

Create two tasks and a mutex

Create a mutex called xMutex using xSemaphoreCreateMutex(). Create two tasks named LowPriorityTask and HighPriorityTask with priorities 1 and 2 respectively. Use xTaskCreate() for both tasks.

FreeRTOS

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

SemaphoreHandle_t xMutex;

void LowPriorityTask(void *pvParameters) {
    // Task code here
}

void HighPriorityTask(void *pvParameters) {
    // Task code here
}

int main(void) {
    // Create the mutex
    // Create LowPriorityTask with priority 1
    // Create HighPriorityTask with priority 2
    // Start the scheduler
    // Your code here
    return 0;
}

Hint

Use xSemaphoreCreateMutex() to create the mutex. Use xTaskCreate() to create tasks with the specified names and priorities.

2

Add task code to take and give the mutex

In LowPriorityTask, take the mutex xMutex using xSemaphoreTake() with portMAX_DELAY, then simulate work by calling vTaskDelay(1000 / portTICK_PERIOD_MS). Then give the mutex back using xSemaphoreGive(). In HighPriorityTask, delay for 100 ticks first, then try to take the mutex with xSemaphoreTake() and portMAX_DELAY, then give it back immediately.

FreeRTOS

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

SemaphoreHandle_t xMutex;

void LowPriorityTask(void *pvParameters) {
    // Take the mutex
    // Simulate work with vTaskDelay
    // Give the mutex
    // Your code here
}

void HighPriorityTask(void *pvParameters) {
    // Delay 100 ticks
    // Take the mutex
    // Give the mutex
    // Your code here
}

int main(void) {
    xMutex = xSemaphoreCreateMutex();
    xTaskCreate(LowPriorityTask, "LowPriorityTask", configMINIMAL_STACK_SIZE, NULL, 1, NULL);
    xTaskCreate(HighPriorityTask, "HighPriorityTask", configMINIMAL_STACK_SIZE, NULL, 2, NULL);
    vTaskStartScheduler();
    return 0;
}

Hint

Use xSemaphoreTake() and xSemaphoreGive() to control the mutex. Use vTaskDelay() to simulate work and delay.

3

Add print statements to show task execution and mutex status

Add printf() statements in LowPriorityTask before taking the mutex, after taking it, and after giving it. Similarly, add printf() in HighPriorityTask before and after taking the mutex. Use messages exactly: "LowPriorityTask waiting for mutex\n", "LowPriorityTask got mutex\n", "LowPriorityTask released mutex\n", "HighPriorityTask waiting for mutex\n", "HighPriorityTask got mutex\n".

FreeRTOS

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

SemaphoreHandle_t xMutex;

void LowPriorityTask(void *pvParameters) {
    // Print waiting message
    xSemaphoreTake(xMutex, portMAX_DELAY);
    // Print got mutex message
    vTaskDelay(1000 / portTICK_PERIOD_MS);
    xSemaphoreGive(xMutex);
    // Print released mutex message
    vTaskDelete(NULL);
}

void HighPriorityTask(void *pvParameters) {
    vTaskDelay(100 / portTICK_PERIOD_MS);
    // Print waiting message
    xSemaphoreTake(xMutex, portMAX_DELAY);
    // Print got mutex message
    xSemaphoreGive(xMutex);
    vTaskDelete(NULL);
}

int main(void) {
    xMutex = xSemaphoreCreateMutex();
    xTaskCreate(LowPriorityTask, "LowPriorityTask", configMINIMAL_STACK_SIZE, NULL, 1, NULL);
    xTaskCreate(HighPriorityTask, "HighPriorityTask", configMINIMAL_STACK_SIZE, NULL, 2, NULL);
    vTaskStartScheduler();
    return 0;
}

Hint

Use printf() to show when each task waits for, gets, and releases the mutex.

4

Run and observe the output

Run the program and observe the printed output. The output should show LowPriorityTask waiting for mutex, then LowPriorityTask got mutex, then HighPriorityTask waiting for mutex, then LowPriorityTask released mutex, and finally HighPriorityTask got mutex. Write a printf() statement after vTaskStartScheduler() in main() to print "Scheduler started\n".

FreeRTOS

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

SemaphoreHandle_t xMutex;

void LowPriorityTask(void *pvParameters) {
    printf("LowPriorityTask waiting for mutex\n");
    xSemaphoreTake(xMutex, portMAX_DELAY);
    printf("LowPriorityTask got mutex\n");
    vTaskDelay(1000 / portTICK_PERIOD_MS);
    xSemaphoreGive(xMutex);
    printf("LowPriorityTask released mutex\n");
    vTaskDelete(NULL);
}

void HighPriorityTask(void *pvParameters) {
    vTaskDelay(100 / portTICK_PERIOD_MS);
    printf("HighPriorityTask waiting for mutex\n");
    xSemaphoreTake(xMutex, portMAX_DELAY);
    printf("HighPriorityTask got mutex\n");
    xSemaphoreGive(xMutex);
    vTaskDelete(NULL);
}

int main(void) {
    xMutex = xSemaphoreCreateMutex();
    xTaskCreate(LowPriorityTask, "LowPriorityTask", configMINIMAL_STACK_SIZE, NULL, 1, NULL);
    xTaskCreate(HighPriorityTask, "HighPriorityTask", configMINIMAL_STACK_SIZE, NULL, 2, NULL);
    // Print Scheduler started message
    // Your code here
    vTaskStartScheduler();
    return 0;
}

Hint

Print "Scheduler started\n" before starting the scheduler to confirm the program started. Observe the order of printed messages to understand priority inheritance.

Practice

1. What is the main purpose of priority inheritance in FreeRTOS?

easy

A. To increase the priority of all tasks equally

B. To prevent low priority tasks from blocking high priority tasks for too long

C. To allow tasks to run in a random order

D. To disable task scheduling temporarily

Solution

1. Step 1: Understand priority inversion problem

   Priority inversion happens when a low priority task holds a resource needed by a high priority task, causing delays.

2. Step 2: Role of priority inheritance

   Priority inheritance temporarily raises the low priority task's priority to the high priority task's level to reduce blocking time.

3. Final Answer:

   To prevent low priority tasks from blocking high priority tasks for too long -> Option B

4. Quick Check:

   Priority inheritance prevents blocking = A [OK]

Hint: Priority inheritance helps high priority tasks run faster [OK]

Common Mistakes:

• Thinking it raises all tasks' priorities
• Confusing it with disabling scheduling
• Believing it randomizes task order

2. Which FreeRTOS synchronization primitive automatically supports priority inheritance?

easy

A. Semaphore (binary)

B. Event group

C. Mutex

D. Queue

Solution

1. Step 1: Identify synchronization primitives

   FreeRTOS offers semaphores, mutexes, queues, and event groups for task synchronization.

2. Step 2: Check which supports priority inheritance

   Mutexes in FreeRTOS implement priority inheritance automatically to avoid priority inversion.

3. Final Answer:

   Mutex -> Option C

4. Quick Check:

   Mutex = priority inheritance support [OK]

Hint: Mutexes handle priority inheritance automatically [OK]

Common Mistakes:

• Choosing binary semaphore which lacks priority inheritance
• Confusing queues or event groups with mutexes
• Assuming all synchronization primitives support priority inheritance

3. Consider three tasks: High, Medium, and Low priority. Low holds a mutex needed by High. Medium is ready to run. What happens when priority inheritance is enabled?

medium

A. Medium task runs before Low and High

B. Low task is blocked until Medium finishes

C. High task runs immediately, ignoring mutex

D. Low task inherits High priority, runs before Medium

Solution

1. Step 1: Analyze priority inversion scenario

   Low priority task holds mutex needed by High priority task, but Medium priority task is ready.

2. Step 2: Effect of priority inheritance

   Low task temporarily inherits High priority, so it runs before Medium to release mutex faster.

3. Final Answer:

   Low task inherits High priority, runs before Medium -> Option D

4. Quick Check:

   Priority inheritance boosts Low task priority = B [OK]

Hint: Low task runs at High priority to unblock High task [OK]

Common Mistakes:

• Assuming Medium runs before Low despite inheritance
• Thinking High runs without mutex
• Believing Low is blocked by Medium

4. You wrote code using a binary semaphore to protect a shared resource, but high priority tasks are blocked too long. What is the likely issue?

medium

A. Binary semaphore does not support priority inheritance

B. Mutex was not created properly

C. High priority tasks are not using the semaphore

D. Task priorities are all equal

Solution

1. Step 1: Identify synchronization primitive used

   Binary semaphore is used to protect shared resource.

2. Step 2: Check priority inheritance support

   Binary semaphores do not support priority inheritance, causing priority inversion issues.

3. Final Answer:

   Binary semaphore does not support priority inheritance -> Option A

4. Quick Check:

   Binary semaphore lacks priority inheritance = A [OK]

Hint: Use mutex, not binary semaphore, for priority inheritance [OK]

Common Mistakes:

• Assuming binary semaphore supports priority inheritance
• Blaming task priorities without checking synchronization
• Ignoring mutex creation correctness

5. In a system with tasks A (priority 3), B (priority 2), and C (priority 1), task C holds a mutex needed by A. Task B is CPU intensive. How does FreeRTOS priority inheritance help avoid priority inversion here?

hard

A. Task C temporarily inherits priority 3, preempting B to release mutex faster

B. Task B inherits priority 3 to run before C and A

C. Task A runs without waiting for mutex

D. Task C is blocked until B finishes

Solution

1. Step 1: Understand task priorities and mutex ownership

   Task C (low priority) holds mutex needed by Task A (high priority), while Task B (medium priority) is CPU intensive.

2. Step 2: Apply priority inheritance behavior

   Task C inherits Task A's high priority (3) temporarily, allowing it to preempt Task B and release the mutex quickly.

3. Final Answer:

   Task C temporarily inherits priority 3, preempting B to release mutex faster -> Option A

4. Quick Check:

   Priority inheritance boosts C to A's priority = C [OK]

Hint: Low priority task inherits high priority to beat medium task [OK]

Common Mistakes:

• Thinking medium priority task inherits high priority
• Assuming high priority task runs without mutex
• Believing low priority task is blocked by medium task