What is an RTOS in FreeRTOS - Visual Explanation

Concept Flow - What is an RTOS

Start: System powered on

↓

RTOS Kernel starts

↓

Create Tasks

↓

Scheduler runs

↓

Tasks run based on priority

↓

Tasks wait, run, or sleep

↓

RTOS manages timing and resources

↓

System runs smoothly with multitasking

↓

System shutdown or reset

This flow shows how an RTOS starts, creates tasks, schedules them by priority, manages timing, and keeps the system running smoothly.

Execution Sample

FreeRTOS

void main() {
  vTaskCreate(Task1, "Task1", 1000, NULL, 1, NULL);
  vTaskCreate(Task2, "Task2", 1000, NULL, 2, NULL);
  vTaskStartScheduler();
}

This code creates two tasks with different priorities and starts the RTOS scheduler to run them.

Execution Table

Step	Action	Details	Result
1	System powers on	Hardware and RTOS kernel initialize	RTOS kernel ready
2	Create Task1	Priority 1, stack size 1000	Task1 added to ready list
3	Create Task2	Priority 2, stack size 1000	Task2 added to ready list
4	Start Scheduler	RTOS scheduler begins running	Scheduler picks highest priority task
5	Run Task2	Priority 2 is higher than 1	Task2 runs first
6	Task2 blocks or yields	Task2 waits for event or time	Scheduler switches to Task1
7	Run Task1	Priority 1 task runs	Task1 executes
8	Tasks switch based on events	RTOS manages timing and resources	Multitasking continues
9	System runs continuously	RTOS handles task switching	Smooth multitasking
10	System shutdown or reset	RTOS stops	System powers off or restarts

💡 System stops when powered off or reset

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	Final
Task1 State	Not created	Ready	Ready	Ready	Ready	Running	Waiting or Running
Task2 State	Not created	Not created	Ready	Ready	Running	Blocked or Yielded	Waiting or Running
Scheduler State	Idle	Idle	Idle	Running	Running	Running	Running

Key Moments - 3 Insights

Why does Task2 run before Task1 even though Task1 was created first?

Because Task2 has a higher priority (2) than Task1 (1), the scheduler runs the highest priority task first as shown in execution_table step 5.

What happens when a running task blocks or yields?

The scheduler switches to another ready task, as seen in step 6 where Task2 blocks and Task1 starts running.

Does the RTOS run tasks one after another or at the same time?

The RTOS runs tasks one at a time very quickly by switching between them, creating the effect of multitasking, explained in steps 7 and 8.

Visual Quiz - 3 Questions

Look at the execution_table, which task runs first after the scheduler starts?

A Task1

B Task2

C Both at the same time

D No task runs

💡 Hint

Check step 5 in the execution_table where the scheduler picks the highest priority task.

At which step does Task2 stop running and Task1 start?

A Step 6

B Step 5

C Step 4

D Step 7

💡 Hint

Look at step 6 where Task2 blocks or yields and the scheduler switches to Task1.

If Task1 had higher priority than Task2, how would the execution_table change at step 5?

A Task2 would still run first

B Both tasks run simultaneously

C Task1 would run first

D Scheduler would not run any task

💡 Hint

Priority determines which task runs first as shown in step 5.

Concept Snapshot

RTOS (Real-Time Operating System) manages multiple tasks by priority.
It creates tasks, then runs the highest priority task first.
Tasks can run, wait, or sleep; RTOS switches tasks quickly.
Scheduler controls which task runs to keep system responsive.
Used in systems needing timely, predictable task management.

Full Transcript

An RTOS is a special operating system that helps a device run many tasks smoothly by managing their order and timing. When the system starts, the RTOS kernel initializes and creates tasks with assigned priorities. The scheduler then runs the highest priority task first. If that task waits or blocks, the scheduler switches to the next ready task. This switching happens very fast, making it seem like tasks run at the same time. The RTOS keeps the system responsive and predictable, which is important for real-time applications. The example code shows creating two tasks with different priorities and starting the scheduler. The execution table traces how tasks run step-by-step, showing Task2 runs first because it has higher priority. When Task2 blocks, Task1 runs. This cycle continues until the system shuts down or resets.

Practice

1. What does RTOS stand for in embedded systems?

easy

A. Random Task Operating System

B. Real-Time Operating System

C. Rapid Transfer Operating Software

D. Reliable Time Output System

Solution

1. Step 1: Understand the acronym RTOS

   RTOS is a common term in embedded systems referring to a type of operating system.

2. Step 2: Match the correct full form

   RTOS stands for Real-Time Operating System, which manages tasks with timing constraints.

3. Final Answer:

   Real-Time Operating System -> Option B

4. Quick Check:

   RTOS = Real-Time Operating System [OK]

Hint: Remember RTOS means system for real-time tasks [OK]

Common Mistakes:

• Confusing RTOS with general operating systems
• Thinking RTOS stands for random or rapid terms
• Mixing up the order of words in the acronym

2. Which of the following is the correct way to create a task in FreeRTOS?

easy

A. xTaskCreate(TaskFunction, "TaskName", StackSize, NULL, Priority, NULL);

B. createTask(TaskFunction, "TaskName", StackSize, Priority);

C. TaskCreate(TaskFunction, StackSize, Priority);

D. xCreateTask(TaskFunction, "TaskName", Priority);

Solution

1. Step 1: Recall FreeRTOS task creation syntax

   FreeRTOS uses the function xTaskCreate with specific parameters including function, name, stack size, parameters, priority, and task handle.

2. Step 2: Identify the correct function call

   xTaskCreate(TaskFunction, "TaskName", StackSize, NULL, Priority, NULL); matches the correct syntax with all required parameters and correct function name.

3. Final Answer:

   xTaskCreate(TaskFunction, "TaskName", StackSize, NULL, Priority, NULL); -> Option A

4. Quick Check:

   FreeRTOS task creation uses xTaskCreate [OK]

Hint: Look for xTaskCreate with all parameters included [OK]

Common Mistakes:

• Using incorrect function names like createTask
• Omitting required parameters
• Wrong order of parameters

3. Consider this FreeRTOS code snippet:

void Task1(void *pvParameters) {
  for(;;) {
    vTaskDelay(1000 / portTICK_PERIOD_MS);
    printf("Task1 running\n");
  }
}

int main() {
  xTaskCreate(Task1, "Task1", 1000, NULL, 1, NULL);
  vTaskStartScheduler();
  return 0;
}

What will be the output when this program runs?

medium

A. Compilation error due to missing parameters

B. Task1 running printed once then program ends

C. Task1 running printed every 1 second repeatedly

D. No output because scheduler is not started

Solution

1. Step 1: Analyze the task loop and delay

   The task runs an infinite loop with vTaskDelay of 1000 milliseconds, so it prints "Task1 running" every second.

2. Step 2: Check scheduler start and task creation

   The task is created and scheduler started, so the task runs indefinitely printing the message repeatedly.

3. Final Answer:

   Task1 running printed every 1 second repeatedly -> Option C

4. Quick Check:

   Infinite loop with delay prints repeatedly [OK]

Hint: Infinite loop with delay prints repeatedly [OK]

Common Mistakes:

• Thinking the program ends after one print
• Assuming scheduler is not started
• Confusing delay units or missing infinite loop

4. Identify the error in this FreeRTOS task creation code:

void Task2(void *pvParameters) {
  // Task code
}

int main() {
  xTaskCreate(Task2, "Task2", 500, NULL, 2);
  vTaskStartScheduler();
  return 0;
}

medium

A. Missing last parameter (task handle) in xTaskCreate call

B. Task function should not have parameters

C. Stack size is too small

D. Scheduler should be started before creating tasks

Solution

1. Step 1: Review xTaskCreate function parameters

   xTaskCreate requires six parameters: function, name, stack size, parameters, priority, and task handle pointer.

2. Step 2: Check the code for missing parameters

   The code provides only five parameters, missing the last one (task handle), causing a compile error.

3. Final Answer:

   Missing last parameter (task handle) in xTaskCreate call -> Option A

4. Quick Check:

   xTaskCreate needs 6 parameters [OK]

Hint: Count parameters in xTaskCreate; must be six [OK]

Common Mistakes:

• Omitting the task handle parameter
• Thinking task functions cannot have parameters
• Starting scheduler before task creation

5. You want to run two tasks in FreeRTOS: one blinking an LED every 500ms and another reading a sensor every 1000ms. Which feature of an RTOS helps you achieve this reliably?

hard

A. Static memory allocation only

B. Single-threaded execution without interrupts

C. Manual delay loops in main program

D. Task scheduling with priorities and time slicing

Solution

1. Step 1: Understand multitasking needs

   Running two tasks with different timing requires the system to switch between tasks efficiently and predictably.

2. Step 2: Identify RTOS feature for multitasking

   RTOS uses task scheduling with priorities and time slicing to manage multiple tasks reliably.

3. Final Answer:

   Task scheduling with priorities and time slicing -> Option D

4. Quick Check:

   RTOS scheduling enables reliable multitasking [OK]

Hint: RTOS scheduling manages multiple timed tasks [OK]

Common Mistakes:

• Thinking single-threaded code can handle multitasking well
• Using manual delays instead of scheduler
• Confusing memory allocation with task management