Task states (Ready, Running, Blocked, Suspended) in FreeRTOS - Mini Project: Build & Apply

Understanding Task States in FreeRTOS

📖 Scenario: You are working on a simple embedded system using FreeRTOS. You want to understand how tasks move between different states: Ready, Running, Blocked, and Suspended.This project will help you create tasks and observe their states using FreeRTOS API calls.

🎯 Goal: Create three FreeRTOS tasks with different behaviors to demonstrate the task states: Ready, Running, Blocked, and Suspended. You will set up the tasks, configure a delay to block one task, suspend another, and print the states to the console.

📋 What You'll Learn

Create three tasks named Task1, Task2, and Task3.

Use a configuration variable delay_time to control blocking duration.

Implement task functions that demonstrate Ready, Running, Blocked, and Suspended states.

Print the state of each task using eTaskGetState().

💡 Why This Matters

🌍 Real World

Embedded systems often use FreeRTOS to manage multiple tasks. Understanding task states helps in debugging and optimizing system behavior.

💼 Career

Embedded software engineers and firmware developers need to manage task states to ensure responsive and efficient real-time applications.

1

Create three FreeRTOS tasks

Create three tasks named Task1, Task2, and Task3 using xTaskCreate(). Each task should run a simple function that loops infinitely. Use vTaskDelay(1) inside each task to allow context switching.

FreeRTOS

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

void Task1(void *pvParameters) {
    while(1) {
        vTaskDelay(1);
    }
}

void Task2(void *pvParameters) {
    while(1) {
        vTaskDelay(1);
    }
}

void Task3(void *pvParameters) {
    while(1) {
        vTaskDelay(1);
    }
}

int main(void) {
    // Create Task1
    // Create Task2
    // Create Task3
    return 0;
}

Hint

Use xTaskCreate() to create each task with a stack size of 1000 and priority 1. Then start the scheduler with vTaskStartScheduler().

2

Add a delay configuration variable

Add a variable named delay_time of type TickType_t and set it to pdMS_TO_TICKS(1000) to represent a 1000 ms delay.

FreeRTOS

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

TickType_t delay_time = 0;

void Task1(void *pvParameters) {
    while(1) {
        vTaskDelay(1);
    }
}

void Task2(void *pvParameters) {
    while(1) {
        vTaskDelay(1);
    }
}

void Task3(void *pvParameters) {
    while(1) {
        vTaskDelay(1);
    }
}

int main(void) {
    xTaskCreate(Task1, "Task1", 1000, NULL, 1, NULL);
    xTaskCreate(Task2, "Task2", 1000, NULL, 1, NULL);
    xTaskCreate(Task3, "Task3", 1000, NULL, 1, NULL);
    vTaskStartScheduler();
    return 0;
}

Hint

Use TickType_t delay_time = pdMS_TO_TICKS(1000); to set a 1-second delay.

3

Make Task2 block and Task3 suspend

Modify Task2 to call vTaskDelay(delay_time) inside its loop to enter the Blocked state. Modify Task3 to suspend itself once using vTaskSuspend(NULL) to enter the Suspended state.

FreeRTOS

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

TickType_t delay_time = pdMS_TO_TICKS(1000);

void Task1(void *pvParameters) {
    while(1) {
        vTaskDelay(1);
    }
}

void Task2(void *pvParameters) {
    // Modify Task2 to block
    // Your code here
}

void Task3(void *pvParameters) {
    // Modify Task3 to suspend itself
    // Your code here
}

int main(void) {
    xTaskCreate(Task1, "Task1", 1000, NULL, 1, NULL);
    xTaskCreate(Task2, "Task2", 1000, NULL, 1, NULL);
    xTaskCreate(Task3, "Task3", 1000, NULL, 1, NULL);
    vTaskStartScheduler();
    return 0;
}

Hint

Use vTaskDelay(delay_time); in Task2's loop and call vTaskSuspend(NULL); once at the start of Task3.

4

Print the state of each task

In main(), after creating the tasks, declare three TaskHandle_t variables named handle1, handle2, and handle3. Pass their addresses to xTaskCreate() to get the task handles. Then print the state of each task using eTaskGetState() and printf(). Use the format: "Task1 state: %d\n", "Task2 state: %d\n", and "Task3 state: %d\n".

FreeRTOS

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

TickType_t delay_time = pdMS_TO_TICKS(1000);

void Task1(void *pvParameters) {
    while(1) {
        vTaskDelay(1);
    }
}

void Task2(void *pvParameters) {
    while(1) {
        vTaskDelay(delay_time);
    }
}

void Task3(void *pvParameters) {
    vTaskSuspend(NULL);
    while(1) {
        vTaskDelay(1);
    }
}

int main(void) {
    TaskHandle_t handle1, handle2, handle3;
    // Create tasks with handles
    // Print states of each task
    // Start scheduler
    return 0;
}

Hint

Use TaskHandle_t variables to get task handles from xTaskCreate(). Then print each task's state using eTaskGetState() and printf(). The states are integers representing Ready (2), Blocked (3), and Suspended (4).

Practice

1.

Which FreeRTOS task state means the task is waiting to be assigned CPU time but is ready to run?

easy

A. Suspended

B. Running

C. Blocked

D. Ready

Solution

1. Step 1: Understand the meaning of Ready state

   The Ready state means the task is prepared and waiting for CPU time but is not currently running.

2. Step 2: Compare with other states

   Running means the task is currently executing. Blocked means waiting for an event. Suspended means paused by user.

3. Final Answer:

   Ready -> Option D

4. Quick Check:

   Ready = waiting to run [OK]

Hint: Ready means waiting but able to run soon [OK]

Common Mistakes:

• Confusing Ready with Running
• Thinking Blocked means ready
• Mixing Suspended with Blocked

2.

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

void suspendTask(TaskHandle_t task) {
    // What function to call?
}

easy

A. vTaskBlock(task);

B. vTaskSuspend(task);

C. vTaskReady(task);

D. vTaskRun(task);

Solution

1. Step 1: Recall FreeRTOS API for suspending tasks

   The function to suspend a task is vTaskSuspend(), which pauses the task until resumed.

2. Step 2: Verify other options

   vTaskBlock() and vTaskReady() do not exist as API calls. vTaskRun() is not a FreeRTOS function.

3. Final Answer:

   vTaskSuspend(task); -> Option B

4. Quick Check:

   Suspend task = vTaskSuspend() [OK]

Hint: Suspend tasks with vTaskSuspend() function [OK]

Common Mistakes:

• Using non-existent functions
• Confusing suspend with block
• Trying to run tasks manually

3.

Consider this FreeRTOS code snippet:

void vTaskFunction(void *pvParameters) {
    for (;;) {
        if (xSemaphoreTake(xSemaphore, 0) == pdTRUE) {
            // Critical section
        } else {
            vTaskDelay(pdMS_TO_TICKS(100));
        }
    }
}

What is the state of the task when vTaskDelay() is called?

medium

A. Running

B. Ready

C. Blocked

D. Suspended

Solution

1. Step 1: Understand vTaskDelay effect

   Calling vTaskDelay causes the task to enter Blocked state, waiting for the delay time to expire.

2. Step 2: Confirm task state during delay

   While delayed, the task is not Ready or Running; it is Blocked until the timer expires.

3. Final Answer:

   Blocked -> Option C

4. Quick Check:

   vTaskDelay = Blocked state [OK]

Hint: vTaskDelay puts task in Blocked state [OK]

Common Mistakes:

• Thinking delay means Ready
• Confusing Blocked with Suspended
• Assuming task runs during delay

4.

Identify the error in this FreeRTOS task management code:

vTaskSuspend(NULL);
vTaskResume(NULL);
vTaskResume(xTaskHandle);

What is wrong with this code?

medium

A. vTaskResume(NULL) is invalid and causes error

B. Cannot suspend current task with NULL parameter

C. vTaskResume requires task handle, NULL is allowed

D. No errors, code is correct

Solution

1. Step 1: Check vTaskSuspend(NULL) usage

   Passing NULL to vTaskSuspend suspends the current task, which is valid.

2. Step 2: Check vTaskResume(NULL) usage

   Passing NULL to vTaskResume is invalid and causes an error because NULL is not a valid task handle to resume.

3. Final Answer:

   vTaskResume(NULL) is invalid and causes error -> Option A

4. Quick Check:

   vTaskResume(NULL) causes error [OK]

Hint: vTaskResume(NULL) is invalid, must use valid handle [OK]

Common Mistakes:

• Assuming NULL resumes current task
• Confusing suspend and resume parameters
• Ignoring NULL parameter rules

5.

You want to create a task that waits for a button press event without using CPU time unnecessarily. Which task state should the task enter while waiting?

hard

A. Blocked

B. Ready

C. Running

D. Suspended

Solution

1. Step 1: Understand waiting without CPU use

   To avoid wasting CPU, the task should not be Running or Ready while waiting.

2. Step 2: Choose appropriate waiting state

   Blocked state is used when a task waits for an event like a button press, so it sleeps until event occurs.

3. Step 3: Differentiate from Suspended

   Suspended means paused by user, not event-driven waiting.

4. Final Answer:

   Blocked -> Option A

5. Quick Check:

   Wait for event = Blocked state [OK]

Hint: Wait for event = Blocked to save CPU [OK]

Common Mistakes:

• Using Suspended instead of Blocked
• Keeping task Ready and wasting CPU
• Confusing Running with waiting