Health monitoring and heartbeat in FreeRTOS - Step-by-Step Execution

Concept Flow - Health monitoring and heartbeat

Start System

↓

Task sends heartbeat

↓

Monitor receives heartbeat

↓

Check heartbeat timing

↓

Continue

The system starts, tasks send heartbeat signals regularly, the monitor checks if heartbeats arrive on time, continuing if OK or raising alert if missed.

Execution Sample

FreeRTOS

void TaskHeartbeat() {
  while(1) {
    SendHeartbeat();
    vTaskDelay(pdMS_TO_TICKS(1000));
  }
}

void MonitorHeartbeat() {
  if (HeartbeatMissed()) Alert();
}

A task sends a heartbeat every second; the monitor checks if any heartbeat is missed and triggers an alert.

Execution Table

Step	Action	Heartbeat Sent?	Heartbeat Received?	Monitor Check	Result
1	Task sends heartbeat	Yes	No	No check yet	Waiting for heartbeat
2	Monitor receives heartbeat	Yes	Yes	Check timing	Heartbeat OK
3	Task delays 1 second	No	Yes	No new heartbeat	Waiting
4	Monitor checks heartbeat timeout	No	Yes	Timeout not reached	Heartbeat OK
5	Task sends heartbeat	Yes	Yes	Check timing	Heartbeat OK
6	Task delay longer than expected	No	Yes	No new heartbeat	Waiting
7	Monitor checks heartbeat timeout	No	No	Timeout exceeded	Alert raised
8	System handles alert	No	No	Alert active	System recovery or reset

💡 Monitor stops normal operation after heartbeat timeout exceeded and alert is raised

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 5	After Step 7	Final
Heartbeat Sent	No	Yes	No	Yes	No	No
Heartbeat Received	No	Yes	Yes	Yes	No	No
Monitor Alert	No	No	No	No	Yes	Yes

Key Moments - 3 Insights

Why does the monitor raise an alert even though a heartbeat was received earlier?

Because the monitor checks if the heartbeat arrives within a timeout window. If the heartbeat is missed for too long (see Step 7), it raises an alert even if previous heartbeats were received (Step 2).

What happens if the task delays longer than expected between heartbeats?

The monitor will detect no new heartbeat within the timeout period (Step 6 and 7) and raise an alert, indicating a possible task failure.

Does the monitor check heartbeat immediately after each send?

No, the monitor checks periodically and compares the last received heartbeat time against the timeout, as shown in Steps 4 and 7.

Visual Quiz - 3 Questions

Look at the execution table, at which step does the monitor first raise an alert?

A Step 5

B Step 7

C Step 3

D Step 2

💡 Hint

Check the 'Result' column for when 'Alert raised' appears.

According to the variable tracker, what is the state of 'Heartbeat Received' after Step 7?

A Yes

B Unknown

C No

D Pending

💡 Hint

Look at the 'Heartbeat Received' row under 'After Step 7' column.

If the task sends heartbeat every 500ms instead of 1000ms, how would the monitor's alert timing change?

A Alert timing would be delayed

B Alert would never occur

C Alert would occur sooner

D No change in alert timing

💡 Hint

Faster heartbeats mean the monitor resets timeout more often, so alert happens later if missed.

Concept Snapshot

Health monitoring uses periodic heartbeat signals from tasks.
Monitor checks if heartbeats arrive within a timeout.
If missed, monitor raises an alert.
Heartbeat interval and timeout must be balanced.
This helps detect task or system failures early.

Full Transcript

In FreeRTOS health monitoring, tasks send heartbeat signals regularly to indicate they are alive. A monitor task listens for these heartbeats and checks if they arrive on time. If a heartbeat is missed beyond a set timeout, the monitor raises an alert to signal a problem. This process helps detect failures early. The execution table shows steps where heartbeats are sent, received, and checked. Variables track heartbeat status and alerts. Key moments clarify why alerts happen after missed heartbeats and how timing affects monitoring. The quiz tests understanding of alert timing and variable states. Overall, this system ensures tasks are running properly by watching their heartbeat signals.

Practice

1. What is the main purpose of a heartbeat task in FreeRTOS?

easy

A. To permanently block other tasks from running

B. To repeatedly indicate the system is running and healthy

C. To increase CPU usage by running continuously without delay

D. To handle user input events exclusively

Solution

1. Step 1: Understand heartbeat task role

   A heartbeat task runs repeatedly to show the system is alive and working properly.

2. Step 2: Eliminate incorrect options

   Blocking other tasks or handling user input are not typical heartbeat functions.

3. Final Answer:

   To repeatedly indicate the system is running and healthy -> Option B

4. Quick Check:

   Heartbeat = system health indicator [OK]

Hint: Heartbeat tasks show system health by running repeatedly [OK]

Common Mistakes:

• Thinking heartbeat blocks other tasks
• Assuming heartbeat handles user input
• Believing heartbeat increases CPU load unnecessarily

2. Which FreeRTOS function is best to use inside a heartbeat task to wait without blocking other tasks?

easy

A. vTaskResume()

B. vTaskSuspend()

C. vTaskDelete()

D. vTaskDelay()

Solution

1. Step 1: Identify delay function for non-blocking wait

   vTaskDelay() suspends the task for a time, allowing others to run.

2. Step 2: Understand other functions

   vTaskSuspend() pauses a task indefinitely, vTaskDelete() removes it, and vTaskResume() restarts a suspended task.

3. Final Answer:

   vTaskDelay() -> Option D

4. Quick Check:

   Use vTaskDelay() for timed waits [OK]

Hint: Use vTaskDelay() to wait without blocking [OK]

Common Mistakes:

• Using vTaskSuspend() which blocks indefinitely
• Confusing vTaskDelete() with delay
• Trying vTaskResume() to wait

3. Given this heartbeat task snippet, what will be the output if the task runs correctly?

void vHeartbeatTask(void *pvParameters) {
  for (;;) {
    printf("Heartbeat\n");
    vTaskDelay(pdMS_TO_TICKS(1000));
  }
}

medium

A. Prints "Heartbeat" once and stops

B. Prints "Heartbeat" continuously without delay

C. Prints "Heartbeat" every second repeatedly

D. Does not print anything due to syntax error

Solution

1. Step 1: Analyze the infinite loop

   The for(;;) loop runs forever, printing "Heartbeat" each cycle.

2. Step 2: Check the delay function

   vTaskDelay(pdMS_TO_TICKS(1000)) pauses the task for 1000 ms (1 second) between prints.

3. Final Answer:

   Prints "Heartbeat" every second repeatedly -> Option C

4. Quick Check:

   Infinite loop + vTaskDelay(1s) = repeated print every second [OK]

Hint: Infinite loop with vTaskDelay prints repeatedly [OK]

Common Mistakes:

• Thinking it prints only once
• Ignoring the delay causing continuous print
• Assuming syntax error without checking code

4. Identify the error in this heartbeat task code snippet:

void vHeartbeatTask(void *pvParameters) {
  while(1) {
    printf("Heartbeat\n");
    vTaskDelay(1000);
  }
}

medium

A. vTaskDelay() argument should be in ticks, not milliseconds

B. printf() cannot be used inside tasks

C. while(1) should be for(;;)

D. Missing task notification call

Solution

1. Step 1: Check vTaskDelay argument type

   vTaskDelay() expects delay in ticks, not milliseconds directly.

2. Step 2: Correct usage

   Use pdMS_TO_TICKS(1000) to convert 1000 ms to ticks for vTaskDelay.

3. Final Answer:

   vTaskDelay() argument should be in ticks, not milliseconds -> Option A

4. Quick Check:

   vTaskDelay(ms) wrong, use pdMS_TO_TICKS(ms) [OK]

Hint: Always convert ms to ticks with pdMS_TO_TICKS() [OK]

Common Mistakes:

• Passing milliseconds directly to vTaskDelay()
• Thinking printf() is disallowed in tasks
• Believing while(1) is invalid syntax

5. You want to implement a heartbeat task that signals system health by toggling an LED every 500 ms and also logs a message every 5 seconds. Which approach is best?

hard

A. Create two separate tasks: one toggling LED every 500 ms, another logging every 5 seconds

B. Use one task with vTaskDelay(500) to toggle LED and count loops to log every 5 seconds

C. Use a single task with vTaskDelay(5000) to do both toggle and log at once

D. Toggle LED and log message without any delay to maximize responsiveness

Solution

1. Step 1: Understand timing requirements

   LED toggles every 500 ms, logging every 5 seconds require different intervals.

2. Step 2: Evaluate task design options

   Two separate tasks allow independent timing without complex counting or blocking.

3. Step 3: Consider drawbacks of other options

   Single task with 500 ms delay and counting adds complexity; 5000 ms delay misses LED timing; no delay wastes CPU.

4. Final Answer:

   Create two separate tasks: one toggling LED every 500 ms, another logging every 5 seconds -> Option A

5. Quick Check:

   Separate tasks for different intervals = clean design [OK]

Hint: Use separate tasks for different heartbeat intervals [OK]

Common Mistakes:

• Trying to handle all timing in one task
• Using long delays missing faster toggles
• No delays causing CPU overload