Task function signature in FreeRTOS - Step-by-Step Execution

Concept Flow - Task function signature

Start Task Function

↓

Function receives void* parameter

↓

Function runs infinite loop

↓

Task does work inside loop

↓

Optionally uses vTaskDelay or other FreeRTOS APIs

↓

Loop repeats forever

↓

Task never returns

A FreeRTOS task function starts with a void pointer parameter and runs an infinite loop doing its work without returning.

Execution Sample

FreeRTOS

void TaskFunction(void *pvParameters) {
    for(;;) {
        // Task code here
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

This task function runs forever, delaying 1 second each loop iteration.

Execution Table

Step	Action	Parameter (pvParameters)	Loop Condition	Task Behavior
1	Task starts	Pointer to parameters	Enter infinite loop	Begin task work
2	Inside loop iteration 1	Pointer unchanged	Loop continues	Execute task code, call vTaskDelay(1000 / portTICK_PERIOD_MS)
3	Inside loop iteration 2	Pointer unchanged	Loop continues	Execute task code, call vTaskDelay(1000 / portTICK_PERIOD_MS)
4	Inside loop iteration 3	Pointer unchanged	Loop continues	Execute task code, call vTaskDelay(1000 / portTICK_PERIOD_MS)
...	Loop repeats forever	Pointer unchanged	Loop continues	Task keeps running, never returns

💡 Task function never exits; it runs an infinite loop to keep the task alive.

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
pvParameters	Pointer to input data	Same pointer	Same pointer	Same pointer	Same pointer

Key Moments - 3 Insights

Why does the task function use an infinite loop?

Because FreeRTOS tasks must keep running to stay alive; the infinite loop ensures the task does not return and get deleted (see execution_table rows 2-5).

What is the purpose of the void* parameter?

It allows passing any data to the task when created; the pointer stays the same throughout the task execution (see variable_tracker).

Can the task function return to end the task?

No, returning would delete the task; tasks should run forever or call vTaskDelete explicitly if they want to end.

Visual Quiz - 3 Questions

Look at the execution_table, what happens to pvParameters after the first loop iteration?

A It stays the same pointer

B It becomes NULL

C It changes to a new pointer

D It is freed automatically

💡 Hint

Check the 'Parameter (pvParameters)' column in execution_table rows 2 and 3.

At which step does the task function exit the infinite loop?

A Step 1

B Step 3

C It never exits

D After the third iteration

💡 Hint

See the 'Loop Condition' column in execution_table; the loop continues forever.

If the infinite loop was removed, what would happen to the task?

A The task would run forever anyway

B The task would run once and then delete itself

C The task would never start

D The task would crash the system

💡 Hint

Refer to key_moments about why the infinite loop is needed to keep the task alive.

Concept Snapshot

FreeRTOS task functions have this signature:
void TaskFunction(void *pvParameters)
{
    for(;;) {
        // task code
        vTaskDelay(...);
    }
}
They receive a void pointer parameter and run an infinite loop to stay alive.

Full Transcript

A FreeRTOS task function must have the signature void TaskFunction(void *pvParameters). It receives a pointer to any data passed when the task is created. The function runs an infinite loop to keep the task alive and perform its work repeatedly. Inside the loop, it can call FreeRTOS APIs like vTaskDelay to wait or yield. The task function never returns; returning would delete the task. The parameter pointer remains unchanged during execution. This pattern ensures the task runs continuously until explicitly deleted.

Practice

1.

What is the correct signature for a FreeRTOS task function?

easy

A. int TaskName(int param)

B. void TaskName(void *pvParameters)

C. void TaskName()

D. void TaskName(int *param)

Solution

1. Step 1: Recall FreeRTOS task function signature

   FreeRTOS tasks must have the signature with return type void and a single void pointer parameter.

2. Step 2: Match the signature with options

   Only void TaskName(void *pvParameters) matches void TaskName(void *pvParameters) exactly.

3. Final Answer:

   void TaskName(void *pvParameters) -> Option B

4. Quick Check:

   Task signature = void TaskName(void *pvParameters) [OK]

Hint: Task functions always return void and take void* parameter [OK]

Common Mistakes:

• Using int return type instead of void
• Omitting the void* parameter
• Using incorrect parameter types

2.

Which of the following is a syntactically correct FreeRTOS task function declaration?

void MyTask(_____)

easy

A. void *pvParameters

B. int param

C. char *name

D. void

Solution

1. Step 1: Understand parameter type for FreeRTOS tasks

   Task functions must accept a single parameter of type void *.

2. Step 2: Check each option

   Only void *pvParameters uses void *pvParameters, which is correct syntax.

3. Final Answer:

   void *pvParameters -> Option A

4. Quick Check:

   Parameter type = void *pvParameters [OK]

Hint: Task parameter must be void pointer (void*) [OK]

Common Mistakes:

• Using int or char pointer instead of void pointer
• Using void without pointer
• Missing parameter entirely

3.

What will happen if you run this FreeRTOS task function?

void ExampleTask(void *pvParameters) {
    for(;;) {
        // Task code here
    }
}

medium

A. The task will return a value causing runtime error.

B. The task will run once and then exit.

C. The task will cause a compile error.

D. The task will run repeatedly in an infinite loop.

Solution

1. Step 1: Analyze the task function loop

   The task contains a for(;;) infinite loop, so it runs repeatedly.

2. Step 2: Understand FreeRTOS task behavior

   Tasks should not return; they run inside infinite loops to keep running.

3. Final Answer:

   The task will run repeatedly in an infinite loop. -> Option D

4. Quick Check:

   Infinite loop in task = runs repeatedly [OK]

Hint: FreeRTOS tasks run inside infinite loops [OK]

Common Mistakes:

• Thinking task runs once and exits
• Expecting return value from task
• Confusing infinite loop with error

4.

Identify the error in this FreeRTOS task function:

void FaultyTask(void *pvParameters) {
    int count = 0;
    while(count < 5) {
        count++;
    }
    return;
}

medium

A. The function should not return; it must loop forever.

B. The parameter type is incorrect.

C. The variable count should be a pointer.

D. The while loop condition is invalid syntax.

Solution

1. Step 1: Check task function return behavior

   FreeRTOS tasks must not return; they should run inside infinite loops.

2. Step 2: Analyze the code flow

   This task loops 5 times then returns, which is incorrect for FreeRTOS tasks.

3. Final Answer:

   The function should not return; it must loop forever. -> Option A

4. Quick Check:

   Tasks must not return, use infinite loop [OK]

Hint: Tasks must never return; use infinite loops [OK]

Common Mistakes:

• Allowing task to return
• Changing parameter type incorrectly
• Misunderstanding loop conditions

5.

You want to pass an integer value to a FreeRTOS task. Which is the correct way to define and use the task function?

void NumberTask(_____)
{
    int received = *(int *)pvParameters;
    for(;;) {
        // Use received value
    }
}

hard

A. void pvParameters

B. int pvParameters

C. void *pvParameters

D. int *pvParameters

Solution

1. Step 1: Recall task function parameter type

   Task functions must accept a void * parameter to allow any data type.

2. Step 2: Understand data passing

   The integer is passed via pointer cast from void *, so parameter must be void *pvParameters.

3. Final Answer:

   void *pvParameters -> Option C

4. Quick Check:

   Use void* parameter to pass any data type [OK]

Hint: Always use void* parameter to pass data to tasks [OK]

Common Mistakes:

• Using int instead of void* parameter
• Using void without pointer
• Not casting void* to correct type inside task