Real-time vs general-purpose OS in FreeRTOS - Visual Side-by-Side Comparison

Concept Flow - Real-time vs general-purpose OS

Start

↓

Choose OS Type

↓

General-purpose OS

↓

Handles many tasks

↓

May delay tasks

↓

End

This flow shows the choice between general-purpose and real-time OS, highlighting their task handling and timing guarantees.

Execution Sample

FreeRTOS

void taskA(void *params) {
  while(1) {
    // Do work
    vTaskDelay(100 / portTICK_PERIOD_MS);
  }
}

void taskB(void *params) {
  TickType_t lastWakeTime = 0;
  while(1) {
    // Do time-critical work
    vTaskDelayUntil(&lastWakeTime, 50 / portTICK_PERIOD_MS);
  }
}

Two FreeRTOS tasks: taskA uses general delay, taskB uses precise periodic delay for real-time behavior.

Execution Table

Step	Task	Action	Timing Behavior	Result
1	taskA	Start loop	Delays 100ms after work	Runs work, then delays
2	taskB	Start loop	Delays precisely every 50ms	Runs work exactly on schedule
3	taskA	After delay	May be delayed by other tasks	Runs next work cycle
4	taskB	After delayUntil	Wakes exactly at next 50ms interval	Runs next work cycle on time
5	taskA	Repeat	Timing less strict	Possible jitter in execution
6	taskB	Repeat	Strict timing maintained	Consistent periodic execution
7	Exit	N/A	Infinite loops, no exit	Tasks run indefinitely

💡 Tasks run infinite loops; no natural exit, showing continuous scheduling differences.

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
taskA_delay	100ms	100ms	100ms	100ms	100ms
taskB_lastWakeTime	0ms	50ms	100ms	150ms	continues increasing

Key Moments - 3 Insights

Why does taskB use vTaskDelayUntil instead of vTaskDelay?

vTaskDelayUntil keeps the task running at precise intervals (see execution_table rows 2 and 4), ensuring real-time timing, unlike vTaskDelay which can accumulate delays.

Can taskA guarantee exact timing like taskB?

No, taskA uses vTaskDelay which waits a fixed time after finishing work, so delays from other tasks can cause timing jitter (see execution_table rows 1 and 3).

Why do both tasks run infinite loops?

In FreeRTOS, tasks often run forever to keep doing their jobs repeatedly (see exit_note). This shows continuous scheduling differences between general-purpose and real-time tasks.

Visual Quiz - 3 Questions

Look at the execution_table, what is the delay time taskA uses after each work cycle?

A 100ms

B 50ms

C 150ms

D No delay

💡 Hint

Check the 'Timing Behavior' column for taskA in rows 1 and 3.

At which step does taskB wake exactly on schedule using vTaskDelayUntil?

A Step 1

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Action' and 'Timing Behavior' columns for taskB in the execution_table.

If taskA used vTaskDelayUntil like taskB, what would change in variable_tracker?

A taskA_delay would become variable

B taskA_delay would track precise wake times like taskB_lastWakeTime

C taskB_lastWakeTime would reset to 0

D No change in variables

💡 Hint

Compare how taskB_lastWakeTime changes in variable_tracker and think about taskA's timing.

Concept Snapshot

Real-time OS guarantees tasks run at precise times using functions like vTaskDelayUntil.
General-purpose OS tasks use simpler delays like vTaskDelay, which may cause timing jitter.
Real-time tasks are critical for time-sensitive work.
FreeRTOS supports both styles with different delay functions.
Use vTaskDelayUntil for strict periodic timing.
Use vTaskDelay for simpler, less strict delays.

Full Transcript

This visual execution compares real-time and general-purpose OS behavior using FreeRTOS tasks. TaskA uses vTaskDelay, which waits a fixed time after work but can be delayed by other tasks, causing timing jitter. TaskB uses vTaskDelayUntil, which wakes the task at precise intervals, ensuring real-time timing. Both tasks run infinite loops to simulate continuous operation. Variable tracking shows taskA_delay stays constant at 100ms, while taskB_lastWakeTime increases precisely every 50ms. Key moments clarify why vTaskDelayUntil is needed for real-time guarantees and why general-purpose delays can cause timing issues. The quiz tests understanding of timing differences and variable changes. The snapshot summarizes key differences and usage in FreeRTOS.