What is an RTOS and Why Use FreeRTOS?

An RTOS is an operating system designed to respond to events within known time frames, which is fundamental when programming embedded systems that cannot be left “thinking” indefinitely.

We are starting a new course on the website, and this is one of the ones I was most eager to bring. We are going to talk about FreeRTOS and real-time operating systems.

If you come from the Arduino world, you are most likely used to programming within setup() and loop(). It is the standard, simple way and works perfectly for blinking an LED or reading a sensor.

However, as our projects grow, we start encountering problems. We want to read a sensor every 100ms, control a stepper motor, handle WiFi requests, and update a display, all “at the same time”.

At that point, classic sequential programming starts to fall short, and an RTOS becomes a very useful tool.

The “Super Loop” Paradigm

Before understanding the solution, let’s analyze the problem. The classic architecture of simple firmware is the Infinite Loop or “Super Loop”.

void setup() {
    // Initialization
}

void loop() {
    readSensors();
    processData();
    updateDisplay();
    moveMotors();
}

This is sequential programming. The processor executes the first instruction, then the second, and so on.

The Blocking Problem

The problem arises when one of these functions takes a long time. For example, imagine we use the infamous delay() function:

void loop() {
    digitalWrite(LED, HIGH);
    delay(1000); // <--- The processor stays HERE blocked
    digitalWrite(LED, LOW);
    delay(1000);
    
    readButton(); // <--- If you press the button during the delay, the system does NOT notice
}

While the processor is counting milliseconds in the delay(), it cannot do anything else. If data arrives via the serial port, if the user presses a button, or if there is an emergency, the microcontroller is “deaf.”

Multitasking and the Scheduler

The beauty of an RTOS lies in its ability to simulate multitasking.

Even if we have a single processor core, the RTOS allows us to divide our code into small, independent units called Tasks.

The component in charge of managing this is the Scheduler. The Scheduler stops one task, saves its state, loads the state of the next task, and executes it.

This happens so fast (hundreds or thousands of times per second) that it gives us the illusion that everything is running simultaneously.

Preemptive Multitasking

FreeRTOS typically uses a preemptive multitasking model. This means the Scheduler can interrupt (preempt) the currently running task at any time to give way to another higher priority task.

Imagine this scenario:

1. We have a task DisplayTask drawing graphics (low priority).
2. An interrupt from a critical sensor arrives and unblocks SensorTask via an ISR-safe API.
3. The Scheduler immediately pauses the DisplayTask.
4. It executes the SensorTask (high priority).
5. When finished, it resumes DisplayTask exactly where it left off.

This is something that is extremely difficult to achieve cleanly with a “Super Loop.”

Differences: Super Loop vs RTOS

To visualize it better, let’s look at a direct comparison: