Timer callback execution context in FreeRTOS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Timer callback context and variable access

Consider this FreeRTOS timer callback function. What will be the output when the timer expires?

FreeRTOS

static int count = 0;

void vTimerCallback(TimerHandle_t xTimer) {
    count++;
    printf("Count is %d\n", count);
}

// Timer created and started elsewhere with 1 second period

A Runtime error due to invalid context

B Count is incremented but not printed

C Count is 1

D Count is 0

💡 Hint

Remember that timer callbacks run in the timer service task context, so accessing static variables is safe.

The timer callback runs in the timer service task context, so it can safely access and modify static variables. Each time the timer expires, count increments and prints the updated value.

❓ Predict Output

intermediate

Using FreeRTOS API in timer callback

What will happen if you call vTaskDelay(1000) inside a FreeRTOS timer callback function?

FreeRTOS

void vTimerCallback(TimerHandle_t xTimer) {
    vTaskDelay(1000);
    printf("Delayed inside timer callback\n");
}

A The system hangs or deadlocks

B The task delays for 1000 ticks and then prints

C Compilation error due to invalid API usage

D The delay is ignored and print happens immediately

💡 Hint

Consider the context in which timer callbacks run and what vTaskDelay requires.

Timer callbacks run in the timer service task context, which must not block or delay. Calling vTaskDelay inside a timer callback causes the timer service task to block, leading to system hang or deadlock.

🔧 Debug

advanced

Debugging unexpected behavior in timer callback

A timer callback modifies a global variable, but the main task never sees the updated value. What is the most likely cause?

FreeRTOS

volatile int shared_var = 0;

void vTimerCallback(TimerHandle_t xTimer) {
    shared_var = 1;
}

void main_task(void *params) {
    while(shared_var == 0) {
        // wait
    }
    printf("Shared var updated\n");
}

A Timer callback runs in interrupt context and cannot modify variables

B Missing memory barrier or synchronization causing stale cache reads

C shared_var should not be volatile

D Timer callback is never called due to wrong timer period

💡 Hint

Think about how variables shared between tasks and callbacks should be handled.

Even though shared_var is volatile, without proper synchronization or memory barriers, the main task may read a cached stale value and never see the update made by the timer callback.

📝 Syntax

advanced

Correct timer callback function signature

Which of the following is the correct function signature for a FreeRTOS timer callback?

A int vTimerCallback(TimerHandle_t xTimer)

B void vTimerCallback(void *pvTimer)

C void vTimerCallback()

D void vTimerCallback(TimerHandle_t xTimer)

💡 Hint

Check the FreeRTOS API documentation for timer callback signatures.

The correct signature is void vTimerCallback(TimerHandle_t xTimer). The callback receives the timer handle as a parameter and returns void.

🚀 Application

expert

Safe operations inside timer callback

Which operation is safe to perform inside a FreeRTOS timer callback function?

A Calling <code>xSemaphoreGive()</code> to release a semaphore

B Calling <code>vTaskDelay()</code> to block the timer task

C Calling <code>xQueueSendFromISR()</code> to send data to a queue

D Calling <code>printf()</code> to output debug information

💡 Hint

Consider which FreeRTOS API functions are safe in the timer service task context.

Timer callbacks run in the timer service task context, not an ISR. Therefore, calling xSemaphoreGive() is safe. xQueueSendFromISR() is meant for ISR context and should not be called here. vTaskDelay() blocks the timer task and is unsafe. printf() may cause reentrancy issues and is generally unsafe.

Practice

1. In FreeRTOS, where does a timer callback function execute when a timer expires?

easy

A. Inside the main application task context

B. Inside an interrupt service routine (ISR)

C. Inside the timer service task context

D. Inside a hardware timer peripheral

Solution

1. Step 1: Understand timer callback execution

   Timer callbacks in FreeRTOS run when the timer expires, but not in the main task or ISR context.

2. Step 2: Identify the correct context

   The timer callback runs inside the timer service task context, which is a dedicated task for handling timers.

3. Final Answer:

   Inside the timer service task context -> Option C

4. Quick Check:

   Timer callback context = timer service task [OK]

Hint: Timer callbacks run in timer service task, not main or ISR [OK]

Common Mistakes:

• Thinking timer callbacks run in ISR context
• Assuming callbacks run in main application task
• Confusing hardware timer peripheral with callback context

2. Which of the following is the correct way to define a FreeRTOS timer callback function?

easy

A. void TimerCallback(TimerHandle_t xTimer)

B. void TimerCallback(void)

C. int TimerCallback(int timerId)

D. void TimerCallback(void *param)

Solution

1. Step 1: Recall FreeRTOS timer callback signature

   The callback function must accept a TimerHandle_t parameter representing the timer.

2. Step 2: Match the correct function signature

   Only the signature with void TimerCallback(TimerHandle_t xTimer) matches FreeRTOS requirements.

3. Final Answer:

   void TimerCallback(TimerHandle_t xTimer) -> Option A

4. Quick Check:

   Callback signature = void func(TimerHandle_t) [OK]

Hint: Timer callbacks take TimerHandle_t parameter only [OK]

Common Mistakes:

• Using no parameters in callback
• Using void* or int instead of TimerHandle_t
• Returning int instead of void

3. Given the following code snippet, what will be printed when the timer expires?

void vTimerCallback(TimerHandle_t xTimer) {
    printf("Timer expired\n");
}

int main() {
    TimerHandle_t xTimer = xTimerCreate("Timer", pdMS_TO_TICKS(1000), pdFALSE, NULL, vTimerCallback);
    xTimerStart(xTimer, 0);
    vTaskDelay(pdMS_TO_TICKS(1500));
    return 0;
}

medium

A. Timer expired

B. No output

C. Compilation error

D. Runtime error

Solution

1. Step 1: Analyze timer creation and start

   The timer is created with 1 second period, one-shot, and started, but vTaskStartScheduler() is missing.

2. Step 2: Check scheduler requirement

   FreeRTOS timers require the scheduler (and timer service task) to be running via vTaskStartScheduler(); without it, the callback never executes, producing no output.

3. Final Answer:

   No output -> Option B

4. Quick Check:

   Missing vTaskStartScheduler() = no callback execution [OK]

Hint: FreeRTOS timers require vTaskStartScheduler() [OK]

Common Mistakes:

• Assuming scheduler starts automatically
• Thinking timer expires without scheduler running
• Believing vTaskDelay alone allows callback execution

4. Identify the problem in this timer callback code snippet:

void vTimerCallback(TimerHandle_t xTimer) {
    vTaskDelay(pdMS_TO_TICKS(100));
    printf("Timer callback done\n");
}

medium

A. Using vTaskDelay inside timer callback blocks timer service task

B. Missing return statement in callback

C. Incorrect parameter type in callback

D. printf cannot be used in timer callbacks

Solution

1. Step 1: Understand timer callback context

   Timer callbacks run inside the timer service task, which handles all timers sequentially.

2. Step 2: Analyze use of vTaskDelay in callback

   Calling vTaskDelay blocks the timer service task, delaying other timers and causing timing issues.

3. Final Answer:

   Using vTaskDelay inside timer callback blocks timer service task -> Option A

4. Quick Check:

   Blocking calls in timer callback delay all timers [OK]

Hint: Never block or delay inside timer callbacks [OK]

Common Mistakes:

• Thinking callbacks can safely block or delay
• Assuming missing return causes error
• Believing printf is disallowed in callbacks

5. You want to toggle an LED every 500ms using a FreeRTOS timer. Which approach correctly uses the timer callback without blocking the timer service task?

void vTimerCallback(TimerHandle_t xTimer) {
    // Option 1
    // vTaskDelay(pdMS_TO_TICKS(100));
    // toggleLED();

    // Option 2
    toggleLED();
}

int main() {
    TimerHandle_t xTimer = xTimerCreate("LEDTimer", pdMS_TO_TICKS(500), pdTRUE, NULL, vTimerCallback);
    xTimerStart(xTimer, 0);
    vTaskStartScheduler();
    return 0;
}

hard

A. Use Option 1 with vTaskDelay inside callback

B. Call toggleLED from main task instead of timer

C. Use a blocking delay in main before starting timer

D. Use Option 2 with direct toggleLED call in callback

Solution

1. Step 1: Review timer callback best practices

   Timer callbacks should be short and non-blocking to avoid delaying other timers.

2. Step 2: Evaluate options for toggling LED

   Option 1 uses vTaskDelay inside callback, which blocks timer service task. Option 2 calls toggleLED directly without delay, which is correct.

3. Final Answer:

   Use Option 2 with direct toggleLED call in callback -> Option D

4. Quick Check:

   Non-blocking callback = direct toggleLED call [OK]

Hint: Keep timer callbacks short and non-blocking [OK]

Common Mistakes:

• Adding delays inside timer callbacks
• Trying to toggle LED outside timer context
• Blocking main task instead of using timer