Watchdog task pattern in FreeRTOS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Watchdog Task Notification Behavior

Consider a FreeRTOS system with a watchdog task waiting for notifications from multiple worker tasks. What will be the output of the watchdog task if it uses xTaskNotifyWait with ulBitsToClearOnEntry = 0 and ulBitsToClearOnExit = 0xFFFFFFFF, and two worker tasks notify it with bits 0x01 and 0x02 respectively before the watchdog calls xTaskNotifyWait?

FreeRTOS

/* Watchdog task snippet */
uint32_t ulNotificationValue = 0;
BaseType_t xResult = xTaskNotifyWait(
    0,          // ulBitsToClearOnEntry
    0xFFFFFFFF, // ulBitsToClearOnExit
    &ulNotificationValue,
    0           // xTicksToWait
);
// Print notification value
printf("Notification value: 0x%02X\n", ulNotificationValue);

A Notification value: 0x01

B Notification value: 0x00

C Notification value: 0x02

D Notification value: 0x03

💡 Hint

Remember that xTaskNotifyWait accumulates bits set by multiple notifications if ulBitsToClearOnEntry is zero.

Since ulBitsToClearOnEntry is zero, the notification value is not cleared before waiting. Both notifications set bits 0x01 and 0x02, so the accumulated value is 0x03. After reading, ulBitsToClearOnExit clears all bits.

🧠 Conceptual

intermediate

Purpose of Watchdog Task in FreeRTOS

What is the main purpose of implementing a watchdog task pattern in a FreeRTOS-based embedded system?

A To increase the CPU clock speed dynamically based on workload.

B To handle all hardware interrupts in the system centrally.

C To monitor other tasks and detect if any task has stopped responding or is stuck.

D To allocate memory dynamically to tasks at runtime.

💡 Hint

Think about system reliability and fault detection.

The watchdog task monitors the health of other tasks by expecting periodic signals. If a task fails to signal, the watchdog can take corrective action like resetting the system.

🔧 Debug

advanced

Debugging Watchdog Task Starvation

A watchdog task in FreeRTOS is supposed to run every 100ms to check system health. However, it never runs and the system hangs. Which of the following is the most likely cause?

FreeRTOS

void WatchdogTask(void *pvParameters) {
    for (;;) {
        // Check health
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

// System initialization
xTaskCreate(WatchdogTask, "Watchdog", 128, NULL, 1, NULL);
// Other tasks with priority 2 running continuously without delay

A Other higher priority tasks are starving the watchdog task by never yielding or delaying.

B The watchdog task stack size is too large causing memory overflow.

C The watchdog task priority is higher than other tasks causing deadlock.

D The watchdog task is missing a call to vTaskStartScheduler().

💡 Hint

Consider task priorities and CPU time allocation.

If higher priority tasks never block or yield, the lower priority watchdog task will never get CPU time, causing it to starve and never run.

📝 Syntax

advanced

Correct Use of Task Notifications for Watchdog

Which of the following code snippets correctly sends a notification bit to a watchdog task from a worker task in FreeRTOS?

A xTaskNotify(watchdogHandle, 0x01, eSetBits);

B xTaskNotify(watchdogHandle, 0x01, eNoAction);

C xTaskNotify(watchdogHandle, 1, eSetValueWithOverwrite);

D xTaskNotify(watchdogHandle, 0x01);

💡 Hint

Check the notification action parameter to set bits.

Using eSetBits sets the specified bits in the notification value, which is the correct way to signal a watchdog task bit.

🚀 Application

expert

Designing a Watchdog Task for Multiple Worker Tasks

You need to design a watchdog task that monitors 4 worker tasks. Each worker task must notify the watchdog every 500ms by setting a unique bit (bit 0 to bit 3). The watchdog task runs every 1 second and checks if all bits are set. If any bit is missing, it triggers a system reset.

Which of the following watchdog task code snippets correctly implements this logic?

FreeRTOS

void WatchdogTask(void *pvParameters) {
    uint32_t ulNotificationValue;
    for (;;) {
        if (xTaskNotifyWait(0xFFFFFFFF, 0xFFFFFFFF, &ulNotificationValue, pdMS_TO_TICKS(1000)) == pdTRUE) {
            if ((ulNotificationValue & 0x0F) != 0x0F) {
                // Missing notification from some worker
                SystemReset();
            }
        } else {
            // No notification received
            SystemReset();
        }
    }
}

A The code should use ulBitsToClearOnEntry = 0 to accumulate bits instead of clearing them before wait.

B The code correctly waits for notifications, clears bits on entry and exit, and checks all 4 bits are set.

C The code should not clear bits on exit to preserve notification bits for next cycle.

D The code should use a timeout of 500ms instead of 1000ms in xTaskNotifyWait.

💡 Hint

Think about clearing bits before and after waiting to detect missing notifications each cycle.

Clearing bits on entry ensures only new notifications count each cycle. Clearing on exit resets bits for next cycle. Checking bits 0-3 ensures all workers notified.