vTaskDelayUntil() for precise timing in FreeRTOS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this FreeRTOS task timing code?

Consider a FreeRTOS task using vTaskDelayUntil() to run every 100 ticks. What will be the output timestamps printed by the task?

FreeRTOS

TickType_t xLastWakeTime;

void vTaskFunction(void *pvParameters) {
    xLastWakeTime = xTaskGetTickCount();
    for (int i = 0; i < 3; i++) {
        vTaskDelayUntil(&xLastWakeTime, 100);
        printf("Tick: %lu\n", xTaskGetTickCount());
    }
}

A Tick: 101\nTick: 201\nTick: 301

B Tick: 100\nTick: 200\nTick: 300

C Tick: 100\nTick: 201\nTick: 302

D Tick: 0\nTick: 100\nTick: 200

💡 Hint

Remember that vTaskDelayUntil() delays the task until the next fixed tick count based on xLastWakeTime.

The vTaskDelayUntil() function delays the task to maintain a fixed periodic rate. Starting from xLastWakeTime, it adds the delay period (100 ticks) each time. So the ticks printed are 100, 200, and 300.

🧠 Conceptual

intermediate

Why use vTaskDelayUntil() instead of vTaskDelay() for periodic tasks?

Which reason best explains why vTaskDelayUntil() is preferred over vTaskDelay() for tasks that must run at precise intervals?

A vTaskDelayUntil() maintains a fixed periodic rate by accounting for task execution time, while vTaskDelay() delays relative to the current time causing drift.

B vTaskDelayUntil() uses less CPU than vTaskDelay() because it disables interrupts during delay.

C vTaskDelayUntil() allows tasks to run faster than the specified delay, while vTaskDelay() enforces a strict minimum delay.

D vTaskDelayUntil() automatically adjusts task priority during delay, vTaskDelay() does not.

💡 Hint

Think about how each function calculates the delay period relative to time.

vTaskDelayUntil() uses a reference time to keep the task running at fixed intervals, compensating for the time the task itself takes to run. vTaskDelay() delays relative to the current time, so small delays in execution accumulate causing drift.

🔧 Debug

advanced

Identify the bug causing timing drift in this FreeRTOS task

This task is intended to run every 50 ticks using vTaskDelayUntil(). However, the timing drifts and the task runs slower than expected. What is the bug?

FreeRTOS

TickType_t xLastWakeTime;

void vTaskFunction(void *pvParameters) {
    for (;;) {
        xLastWakeTime = xTaskGetTickCount();
        vTaskDelayUntil(&xLastWakeTime, 50);
        printf("Tick: %lu\n", xTaskGetTickCount());
    }
}

A xLastWakeTime is reset inside the loop each iteration, so the delay is always relative to the current tick count causing drift.

B xLastWakeTime is not declared as volatile, so the compiler optimizes it incorrectly.

C The task does not call vTaskDelay() before vTaskDelayUntil(), causing starvation.

D vTaskDelayUntil() is called with the wrong delay value; it should be 100 instead of 50.

💡 Hint

Check where xLastWakeTime is initialized and updated.

The variable xLastWakeTime must be initialized once before the loop and then passed to vTaskDelayUntil() each iteration. Resetting it inside the loop causes the delay to be relative to the current time every time, losing the fixed periodic timing.

📝 Syntax

advanced

Which option correctly uses vTaskDelayUntil() for a 200 tick periodic task?

Choose the code snippet that correctly implements a FreeRTOS task running every 200 ticks using vTaskDelayUntil().

A

TickType_t xLastWakeTime = 0;
for (;;) {
    vTaskDelayUntil(&xLastWakeTime, 200);
    // Task code
}

B

TickType_t xLastWakeTime;
xLastWakeTime = xTaskGetTickCount();
for (;;) {
    vTaskDelayUntil(xLastWakeTime, 200);
    // Task code
}

C

TickType_t xLastWakeTime = xTaskGetTickCount();
for (;;) {
    vTaskDelayUntil(&xLastWakeTime, 200);
    // Task code
}

D

TickType_t xLastWakeTime;
for (;;) {
    xLastWakeTime = xTaskGetTickCount();
    vTaskDelayUntil(&xLastWakeTime, 200);
    // Task code
}

💡 Hint

Remember the correct way to initialize and update xLastWakeTime for vTaskDelayUntil().

Option C initializes xLastWakeTime once before the loop and passes its address to vTaskDelayUntil() each iteration, which is correct. Option C passes the value, not the pointer. Option C initializes to zero which may cause incorrect timing. Option C resets xLastWakeTime inside the loop causing drift.

🚀 Application

expert

Calculate the number of task executions in 1000 ticks using vTaskDelayUntil()

A FreeRTOS task uses vTaskDelayUntil() with a delay of 120 ticks to run periodically. How many times will the task execute within 1000 ticks?

A 7

B 8

C 10

D 9

💡 Hint

Divide the total ticks by the delay period and consider the first execution timing.

The task runs first after 120 ticks, then every 120 ticks. The number of executions in 1000 ticks is floor(1000 / 120) = 8, but since the first execution happens at 120 ticks, total executions are 8 + 1 = 9.