Managing Callback Context and Execution Constraints

Apply best practices for writing efficient timer callback functions, ensuring they remain non-blocking to prevent system-wide jitter and missed deadlines.

In this lesson, you will learn how to design software timer callbacks that maintain system responsiveness by adhering to strict execution constraints.

The Timer Callback Constraint

When you utilize RTOS software timers, the associated callback function typically executes within the context of a high-priority "Timer Service Task." Because this task is often shared across all software timers in your system, any delay in one callback propagates to every other scheduled event. If a callback blocks—for instance, by waiting for a mutex or performing a long-running calculation—you introduce jitter and risk missing critical timing deadlines for unrelated tasks.

Efficient Callback Design

To ensure system-wide stability, follow the "short and fast" rule: your callback should never block. Instead of performing heavy logic, use the callback strictly as a signaling mechanism. If you need to process data or wait for a resource, pass that responsibility to a lower-priority worker task via a queue or a task notification.

Consider this inefficient pattern versus a robust implementation:

// INEFFICIENT: Callback blocks the Timer Service Task
void TimerCallback(TimerHandle_t xTimer) {
    // Blocking for a resource causes system-wide jitter
    xSemaphoreTake(xResourceMutex, portMAX_DELAY); 
    ProcessData();
    xSemaphoreGive(xResourceMutex);
}

// ROBUST: Callback delegates work
void TimerCallback(TimerHandle_t xTimer) {
    // Non-blocking notification to a worker task
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    vTaskNotifyGiveFromISR(xWorkerTaskHandle, &xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

By offloading the work to a task, the Timer Service Task returns to a blocked state almost instantly, leaving it free to trigger subsequent timers with microsecond precision. Avoid printf calls, heavy mathematical loops, or any operation that could invoke the scheduler while inside the callback. Treat the timer callback like an Interrupt Service Routine (ISR): keep it brief, keep it non-blocking, and delegate the heavy lifting to the task scheduler.

Key Takeaway: Never block inside a timer callback; instead, use lightweight signaling primitives to offload intensive operations to a dedicated task to prevent system-wide timing jitter.