Task states (Ready, Running, Blocked, Suspended) in FreeRTOS - Step-by-Step Execution

Concept Flow - Task states (Ready, Running, Blocked, Suspended)

Task Created

↓

Ready State

↓

Scheduler Picks Task

↓

Running State

↓

Blocked

↓

Ready

Tasks move between states: Ready means waiting to run, Running means executing, Blocked means waiting for event/time, Suspended means paused by user. Scheduler controls transitions.

Execution Sample

FreeRTOS

void vTaskFunction(void *pvParameters) {
  for(;;) {
    // Running
    vTaskDelay(1000); // Blocked
  }
}

A task runs, then calls vTaskDelay to block itself for 1000 ticks, then becomes ready again after delay.

Execution Table

Step	Task State	Action	Reason/Trigger	Next State
1	Ready	Scheduler selects task	Highest priority ready task	Running
2	Running	Task executes code	Normal execution	Running
3	Running	Calls vTaskDelay(1000)	Task requests delay	Blocked
4	Blocked	Delay timer counts down	Waiting for 1000 ticks	Blocked
5	Blocked	Delay expires	Timer reaches zero	Ready
6	Ready	Scheduler selects task again	Task is highest priority ready	Running
7	Running	Task resumes execution	After delay	Running

💡 Task cycles between Running, Blocked (delay), Ready states repeatedly as scheduler runs.

Variable Tracker

Variable	Start	After Step 3	After Step 5	After Step 7
Task State	Ready	Blocked	Ready	Running
Delay Timer	0	1000	0	0

Key Moments - 3 Insights

Why does the task move from Running to Blocked after calling vTaskDelay?

Because vTaskDelay makes the task wait for a set time, so it cannot run until the delay expires (see execution_table step 3).

What is the difference between Ready and Running states?

Ready means the task can run but is waiting for the CPU; Running means the task is currently executing (see steps 1 and 2).

How does a Suspended state differ from Blocked?

Suspended is paused by user action and won't run until resumed; Blocked waits for events or time and resumes automatically (not shown in sample but important).

Visual Quiz - 3 Questions

Look at the execution_table, what is the task state immediately after calling vTaskDelay?

A Blocked

B Ready

C Running

D Suspended

💡 Hint

Check execution_table row 3 where vTaskDelay is called and state changes.

At which step does the task become Ready again after being Blocked?

A Step 4

B Step 6

C Step 5

D Step 7

💡 Hint

Look for when the delay expires and task moves from Blocked to Ready in execution_table.

If the task never called vTaskDelay, which states would it cycle through?

A Running and Blocked only

B Ready and Running only

C Blocked and Suspended only

D Suspended and Ready only

💡 Hint

Refer to variable_tracker and execution_table showing delay causes Blocked state.

Concept Snapshot

Task states in FreeRTOS:
- Ready: waiting to run
- Running: currently executing
- Blocked: waiting for event/time
- Suspended: paused by user
Scheduler moves tasks between these states based on events and priorities.

Full Transcript

In FreeRTOS, tasks move through states: Ready means the task is waiting to run; Running means it is executing on the CPU. When a task calls vTaskDelay, it moves to Blocked state, waiting for the delay to expire. After the delay, it returns to Ready, waiting for the scheduler to run it again. Suspended state is when the task is paused by user action and won't run until resumed. The scheduler controls these transitions based on priorities and events.

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