Timer callback execution context in FreeRTOS - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a timer callback function with the correct parameter type.

FreeRTOS

void TimerCallback([1] xTimer) {
    // Timer callback code here
}

Drag options to blanks, or click blank then click option'

ATaskHandle_t

Bint

Cvoid*

DTimerHandle_t

Attempts:

3 left

💡 Hint

Common Mistakes

Using int or void* as the parameter type instead of TimerHandle_t.

The timer callback function in FreeRTOS receives a parameter of type TimerHandle_t, which is a handle to the timer that expired.

2fill in blank

medium

Complete the code to start a FreeRTOS timer inside its callback function.

FreeRTOS

BaseType_t xHigherPriorityTaskWoken = pdFALSE;

void TimerCallback(TimerHandle_t xTimer) {
    xTimerStartFromISR(xTimer, [1]);
}

Drag options to blanks, or click blank then click option'

ApdTRUE

BportMAX_DELAY

C0

DpdFALSE

Attempts:

3 left

💡 Hint

Common Mistakes

Using non-zero block time values in ISR context causing errors.

When calling xTimerStartFromISR, the block time parameter should be zero because blocking is not allowed in an ISR context.

3fill in blank

hard

Fix the error in the timer callback function to correctly notify a task from ISR context.

FreeRTOS

void TimerCallback(TimerHandle_t xTimer) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    vTaskNotifyGiveFromISR(xTaskToNotify, [1], &xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

Drag options to blanks, or click blank then click option'

AxHigherPriorityTaskWoken

BNULL

C0

DpdTRUE

Attempts:

3 left

💡 Hint

Common Mistakes

Passing pdTRUE or NULL instead of the address of xHigherPriorityTaskWoken.

The third parameter of vTaskNotifyGiveFromISR is a pointer to BaseType_t variable that indicates if a context switch is required. Passing xHigherPriorityTaskWoken by reference is correct.

4fill in blank

hard

Fill both blanks to correctly create and start a one-shot FreeRTOS timer.

FreeRTOS

TimerHandle_t xTimer = xTimerCreate("OneShotTimer", pdMS_TO_TICKS(1000), [1], NULL, TimerCallback);

if (xTimer != NULL) {
    xTimerStart(xTimer, [2]);
}

Drag options to blanks, or click blank then click option'

ApdFALSE

BpdTRUE

C0

DportMAX_DELAY

Attempts:

3 left

💡 Hint

Common Mistakes

Using pdTRUE for one-shot timer reload parameter.

Using zero block time when starting timer causing start failure.

The third parameter of xTimerCreate is uxAutoReload. For a one-shot timer, it should be pdFALSE. The block time for xTimerStart can be portMAX_DELAY to wait indefinitely for the command to be sent.

5fill in blank

hard

Fill all three blanks to implement a timer callback that stops the timer and sends a notification to a task.

FreeRTOS

void TimerCallback(TimerHandle_t xTimer) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    xTimerStop(xTimer, [1]);
    vTaskNotifyGiveFromISR([2], &xHigherPriorityTaskWoken);
    [3](xHigherPriorityTaskWoken);
}

Drag options to blanks, or click blank then click option'

A0

BxTaskToNotify

CportYIELD_FROM_ISR

DpdTRUE

Attempts:

3 left

💡 Hint

Common Mistakes

Using non-zero block time in timer stop causing blocking.

Passing wrong task handle to notification function.

Not calling portYIELD_FROM_ISR to request context switch.

In the timer callback, xTimerStop is called with zero block time because blocking is not allowed. The task to notify is xTaskToNotify. Finally, portYIELD_FROM_ISR is called with xHigherPriorityTaskWoken to request a context switch if needed.

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