Employing Heartbeat Monitoring Between Tasks

In this lesson, you will learn how to implement a cross-task heartbeat system to ensure that independent software modules remain alive and responsive during operation.

The Concept of Inter-Task Heartbeats

While a hardware watchdog timer (from lesson 16) monitors the system as a whole, it cannot distinguish between a healthy system and one where a single, non-critical task has deadlocked. Heartbeat monitoring bridges this gap. By requiring tasks to periodically "check in" with a supervisor or each other, you create a software-based health observation layer.

If a task enters an infinite loop or stalls on a resource, it fails to send its heartbeat. The monitoring task, seeing the missed signal, can then trigger an error-handling routine or initiate a graceful degradation strategy (lesson 25) before the system-wide watchdog forces a full reset.

Implementation Pattern

The simplest approach is a shared global structure or a message queue where each task updates a timestamp or a "living" counter.

typedef struct {
    uint32_t last_heartbeat;
    bool is_healthy;
} TaskStatus_t;

// Shared array, protected by mutex or atomic access
TaskStatus_t task_registry[NUM_TASKS];

// Inside a task loop
void Task_A(void) {
    while(1) {
        // ... perform task logic ...
        
        // Update heartbeat
        task_registry[ID_TASK_A].last_heartbeat = GetSystemTicks();
        task_registry[ID_TASK_A].is_healthy = true;
    }
}

// Inside a Monitor Task
void MonitorTask(void) {
    if ((GetSystemTicks() - task_registry[ID_TASK_A].last_heartbeat) > TIMEOUT_THRESHOLD) {
        // Trigger recovery logic for Task A
        HandleTaskFailure(ID_TASK_A);
    }
}

Design Considerations

For this to be effective, your heartbeat monitoring must be deterministic. Avoid blocking calls when checking the registry; use non-blocking status flags. Furthermore, ensure that the monitoring task itself is the most reliable piece of software in your architecture. If the monitor fails, the system loses its ability to perform software-based diagnostics.

By layering this monitoring on top of your existing defensive coding practices (like MISRA C standards and runtime assertions), you add a proactive layer of observability that catches software-level "soft" failures long before they impact the physical environment.

Key Takeaway: Heartbeat monitoring enables localized failure detection within an RTOS, allowing for targeted recovery actions that preserve system uptime.