vTaskDelay() for periodic tasks in FreeRTOS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Understanding vTaskDelay() behavior

What will be the output timing behavior of the following FreeRTOS task code snippet?

void vTaskFunction(void *pvParameters) {
    for (;;) {
        // Task code here
        vTaskDelay(pdMS_TO_TICKS(1000));
        // Print or toggle an LED
    }
}

Assuming the tick rate is 1ms, how often does the task unblock?

FreeRTOS

void vTaskFunction(void *pvParameters) {
    for (;;) {
        vTaskDelay(pdMS_TO_TICKS(1000));
        // action
    }
}

A The task unblocks every 1000 milliseconds (1 second) after the delay.

B The task unblocks immediately without any delay.

C The task unblocks every 1 millisecond.

D The task never unblocks because vTaskDelay blocks indefinitely.

💡 Hint

Remember that vTaskDelay() delays the task for the specified tick count.

The function vTaskDelay(pdMS_TO_TICKS(1000)) causes the task to enter the Blocked state for 1000 ticks. Since the tick rate is 1ms, this equals 1000 milliseconds or 1 second. After this delay, the task unblocks and runs again.

❓ Predict Output

intermediate

Effect of vTaskDelay on task periodicity

Consider a FreeRTOS task that performs some work taking 200ms and then calls vTaskDelay(pdMS_TO_TICKS(1000)). How often will the task run?

FreeRTOS

void vTaskFunction(void *pvParameters) {
    for (;;) {
        // Work taking 200ms
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

A The task runs every 1200 milliseconds (200ms work + 1000ms delay).

B The task runs every 1000 milliseconds exactly.

C The task runs every 200 milliseconds.

D The task runs continuously without delay.

💡 Hint

Think about how vTaskDelay() affects the task after the work is done.

The task does 200ms of work, then calls vTaskDelay() for 1000ms. So the total cycle time is 200ms + 1000ms = 1200ms.

🔧 Debug

advanced

Why does the task drift in timing?

A developer writes this FreeRTOS task to run every 1000ms:

void vTaskFunction(void *pvParameters) {
    for (;;) {
        vTaskDelay(pdMS_TO_TICKS(1000));
        // Do work
    }
}

But the task execution drifts over time, running later and later. Why?

A Because vTaskDelay blocks the task forever.

B Because the tick rate is too fast causing timing errors.

C Because vTaskDelay delays from the time it is called, so work time adds to the period causing drift.

D Because the task priority is too low to run on time.

💡 Hint

Consider when the delay starts counting relative to the work done.

vTaskDelay() delays the task for a fixed time starting from when it is called. Since the work is done before the delay, the total period is work time + delay time. This causes the task to drift later each cycle.

🚀 Application

advanced

Implementing a fixed periodic task with vTaskDelayUntil

Which code snippet correctly implements a task that runs exactly every 1000ms without drift?

A

TickType_t xLastWakeTime = xTaskGetTickCount();
for (;;) {
    vTaskDelay(pdMS_TO_TICKS(1000));
    // work
}

B

TickType_t xLastWakeTime = xTaskGetTickCount();
for (;;) {
    vTaskDelayUntil(&xLastWakeTime, pdMS_TO_TICKS(1000));
    // work
}

C

for (;;) {
    vTaskDelayUntil(NULL, pdMS_TO_TICKS(1000));
    // work
}

D

for (;;) {
    vTaskDelay(1000);
    // work
}

💡 Hint

Use the function designed for fixed periodic delays.

vTaskDelayUntil() uses a reference time to ensure the task runs at fixed intervals, preventing drift. Option B correctly initializes xLastWakeTime and uses vTaskDelayUntil().

🧠 Conceptual

expert

Why is vTaskDelay not ideal for precise periodic tasks?

Why might vTaskDelay() be unsuitable for tasks that require precise periodic execution?

A Because it disables interrupts during the delay period.

B Because it blocks the task indefinitely without timeout.

C Because it requires the task to have the highest priority to work.

D Because it delays relative to when it is called, causing cumulative timing errors if task execution time varies.

💡 Hint

Think about how the delay start time relates to task execution time.

vTaskDelay() delays the task for a fixed time starting from the call moment. If the task execution time varies, the delay accumulates causing drift. For precise periodic timing, vTaskDelayUntil() is preferred.

Practice

1. What is the primary purpose of vTaskDelay() in FreeRTOS?

easy

A. To pause a task for a specific number of ticks

B. To create a new task

C. To delete a task

D. To send data between tasks

Solution

1. Step 1: Understand the function role

   vTaskDelay() is designed to pause or block a task for a set number of tick counts, allowing other tasks to run.

2. Step 2: Compare with other options

   Creating or deleting tasks and sending data are done by other FreeRTOS functions, not vTaskDelay().

3. Final Answer:

   To pause a task for a specific number of ticks -> Option A

4. Quick Check:

   vTaskDelay() pauses task = A [OK]

Hint: vTaskDelay() always pauses task execution for ticks [OK]

Common Mistakes:

• Confusing vTaskDelay() with task creation functions
• Thinking vTaskDelay() sends data
• Assuming vTaskDelay() deletes tasks

2. Which of the following is the correct way to delay a task for 100 milliseconds using vTaskDelay()?

easy

A. vTaskDelay(100);

B. vTaskDelayMs(100);

C. vTaskDelay(pdMS_TO_TICKS(100));

D. vTaskDelayTicks(100);

Solution

1. Step 1: Understand tick conversion

   FreeRTOS uses ticks, not milliseconds directly. To convert milliseconds to ticks, use pdMS_TO_TICKS().

2. Step 2: Check syntax correctness

   Only vTaskDelay(pdMS_TO_TICKS(100)); correctly converts 100 ms to ticks and delays the task.

3. Final Answer:

   vTaskDelay(pdMS_TO_TICKS(100)); -> Option C

4. Quick Check:

   Use pdMS_TO_TICKS() inside vTaskDelay() [OK]

Hint: Always convert ms to ticks with pdMS_TO_TICKS() [OK]

Common Mistakes:

• Passing milliseconds directly without conversion
• Using non-existent functions like vTaskDelayMs()
• Confusing ticks and milliseconds

3. Given the following code snippet, what will be the approximate delay between each print statement?

void TaskFunction(void *pvParameters) {
    while(1) {
        printf("Tick\n");
        vTaskDelay(pdMS_TO_TICKS(500));
    }
}

medium

A. Approximately 1 second

B. Approximately 500 milliseconds

C. No delay, prints continuously

D. Approximately 50 milliseconds

Solution

1. Step 1: Analyze vTaskDelay parameter

   The delay is set to pdMS_TO_TICKS(500), which converts 500 milliseconds to ticks.

2. Step 2: Understand loop timing

   Each loop iteration prints "Tick" then delays for about 500 ms, so prints occur roughly every 500 ms.

3. Final Answer:

   Approximately 500 milliseconds -> Option B

4. Quick Check:

   vTaskDelay(pdMS_TO_TICKS(500)) = 500 ms delay [OK]

Hint: vTaskDelay(pdMS_TO_TICKS(x)) delays about x milliseconds [OK]

Common Mistakes:

• Ignoring pdMS_TO_TICKS conversion
• Assuming no delay in loop
• Confusing milliseconds with ticks

4. Identify the error in this code snippet intended to delay a task for 200 milliseconds:

void Task(void *params) {
    while(1) {
        doWork();
        vTaskDelay(200);
    }
}

medium

A. vTaskDelay cannot be used inside a while loop

B. doWork() must be called after vTaskDelay()

C. The task function must return a value

D. vTaskDelay should use pdMS_TO_TICKS(200) to convert milliseconds

Solution

1. Step 1: Check vTaskDelay argument

   The argument 200 is treated as ticks, not milliseconds. To delay 200 ms, convert using pdMS_TO_TICKS(200).

2. Step 2: Verify other code parts

   Calling doWork() before delay is valid. The task function returns void, which is correct.

3. Final Answer:

   vTaskDelay should use pdMS_TO_TICKS(200) to convert milliseconds -> Option D

4. Quick Check:

   Convert ms to ticks with pdMS_TO_TICKS() [OK]

Hint: Always convert ms to ticks before passing to vTaskDelay() [OK]

Common Mistakes:

• Passing milliseconds directly to vTaskDelay()
• Thinking vTaskDelay can't be in loops
• Expecting task functions to return values

5. You want a task to run exactly every 1 second, but your system tick rate is 1000 Hz (1 tick = 1 ms). Which is the best way to implement this periodic delay using vTaskDelay()?

hard

A. Use vTaskDelayUntil() instead of vTaskDelay() for precise periodic timing

B. Call vTaskDelay(pdMS_TO_TICKS(1000)); inside the task loop

C. Call vTaskDelay(pdMS_TO_TICKS(1000)); and then call vTaskDelay(0);

D. Call vTaskDelay(1000); inside the task loop

Solution

1. Step 1: Understand vTaskDelay limitations

   vTaskDelay() delays relative to current time, so small variations accumulate causing drift in periodic tasks.

2. Step 2: Identify precise periodic method

   vTaskDelayUntil() uses an absolute wake time, preventing drift and ensuring exact periodic execution.

3. Final Answer:

   Use vTaskDelayUntil() instead of vTaskDelay() for precise periodic timing -> Option A

4. Quick Check:

   vTaskDelayUntil() prevents drift in periodic tasks [OK]

Hint: Use vTaskDelayUntil() for exact periodic task timing [OK]

Common Mistakes:

• Using vTaskDelay() causes timing drift
• Assuming tick count matches ms without conversion
• Adding extra delays unnecessarily