Task states (Ready, Running, Blocked, Suspended) in FreeRTOS

Introduction

Tasks in FreeRTOS can be in different states to manage how they run. This helps the system decide which task to run and when.

When you want to know if a task is ready to run or waiting for something.

When debugging why a task is not running as expected.

When designing your program to handle tasks that wait for events or resources.

When you want to pause a task temporarily without deleting it.

When managing multiple tasks to keep the system responsive.

Syntax

FreeRTOS

Task states in FreeRTOS are:
- Ready
- Running
- Blocked
- Suspended

Ready: Task is ready to run but waiting for CPU time.

Running: Task is currently using the CPU.

Examples

This means the task can run anytime but is not running now.

FreeRTOS

Ready: Task is waiting in the queue to run when CPU is free.

Only one task runs at a time on a single-core CPU.

FreeRTOS

Running: Task is actively executing its code.

For example, waiting for a message or timer.

FreeRTOS

Blocked: Task is waiting for an event or time delay to finish.

Used to pause a task without deleting it.

FreeRTOS

Suspended: Task is stopped and will not run until resumed.

Sample Program

This program creates a task that prints a message and then waits for 1 second. The task moves between Running (printing) and Blocked (waiting) states.

FreeRTOS

#include "FreeRTOS.h"
#include "task.h"
#include <stdio.h>

void vTaskFunction(void *pvParameters) {
    for (;;) {
        printf("Task is running\n");
        vTaskDelay(pdMS_TO_TICKS(1000)); // Blocked state for 1 second
    }
}

int main(void) {
    TaskHandle_t xHandle = NULL;
    xTaskCreate(vTaskFunction, "Task1", configMINIMAL_STACK_SIZE, NULL, 1, &xHandle);
    vTaskStartScheduler();
    // The scheduler will now run the task
    return 0;
}

Important Notes

A task in Ready state waits for CPU time but does not run until scheduled.

Blocked tasks do not use CPU until their wait condition is met.

Suspended tasks stay inactive until you explicitly resume them.

Summary

Tasks have states to control when they run.

Ready means waiting to run, Running means using CPU.

Blocked means waiting for something, Suspended means paused.

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