Real-time vs general-purpose OS in FreeRTOS - Hands-On Comparison

Real-time vs General-purpose OS Task Scheduling

📖 Scenario: You are working on a small embedded device that controls a home automation system. It needs to handle urgent tasks like turning off the heater immediately when the temperature is too high, and also less urgent tasks like updating the display every few seconds.This project will help you understand how a real-time operating system (RTOS) like FreeRTOS schedules tasks differently from a general-purpose OS.

🎯 Goal: You will create two tasks in FreeRTOS: one high-priority task that simulates an urgent sensor check, and one low-priority task that simulates a display update. You will see how the RTOS runs the urgent task immediately when needed, unlike a general-purpose OS that might delay it.

📋 What You'll Learn

Create two FreeRTOS tasks with different priorities

Use vTaskDelay to simulate task timing

Print messages to show which task is running

Observe task switching behavior

💡 Why This Matters

🌍 Real World

Embedded systems like home automation, robotics, and automotive use real-time OS to handle urgent tasks reliably.

💼 Career

Understanding RTOS task scheduling is essential for embedded software engineers and developers working on time-critical applications.

1

Create two FreeRTOS tasks

Write code to create two tasks named UrgentTask and DisplayTask using xTaskCreate. Use the function prototypes void UrgentTask(void *pvParameters) and void DisplayTask(void *pvParameters). Do not start the scheduler yet.

FreeRTOS

// Create two tasks UrgentTask and DisplayTask using xTaskCreate
// Your code here

Hint

Use xTaskCreate to create tasks with their function names and priorities.

2

Add task delays and print messages

Inside UrgentTask, add a printf statement to print "Urgent task running" before vTaskDelay(pdMS_TO_TICKS(1000)). Inside DisplayTask, add a printf statement to print "Display task running" before vTaskDelay(pdMS_TO_TICKS(2000)).

FreeRTOS

#include "FreeRTOS.h"
#include "task.h"
#include 

void UrgentTask(void *pvParameters) {
    for (;;) {
        // Print urgent task message
        // Your code here
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

void DisplayTask(void *pvParameters) {
    for (;;) {
        // Print display task message
        // Your code here
        vTaskDelay(pdMS_TO_TICKS(2000));
    }
}

int main(void) {
    xTaskCreate(UrgentTask, "UrgentTask", 1000, NULL, 2, NULL);
    xTaskCreate(DisplayTask, "DisplayTask", 1000, NULL, 1, NULL);
    // Scheduler not started yet
    return 0;
}

Hint

Use printf before the delay in each task to show which task runs.

3

Start the FreeRTOS scheduler

In the main function, after creating the tasks, add the call to vTaskStartScheduler() to start the RTOS scheduler.

FreeRTOS

#include "FreeRTOS.h"
#include "task.h"
#include 

void UrgentTask(void *pvParameters) {
    for (;;) {
        printf("Urgent task running\n");
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

void DisplayTask(void *pvParameters) {
    for (;;) {
        printf("Display task running\n");
        vTaskDelay(pdMS_TO_TICKS(2000));
    }
}

int main(void) {
    xTaskCreate(UrgentTask, "UrgentTask", 1000, NULL, 2, NULL);
    xTaskCreate(DisplayTask, "DisplayTask", 1000, NULL, 1, NULL);
    // Start the scheduler below
    // Your code here
    return 0;
}

Hint

Call vTaskStartScheduler() to begin running the tasks.

4

Observe and print the task switching output

Run the program and observe the printed output. Write a printf statement after vTaskStartScheduler() in main to print "Scheduler ended". Note that this line should never run if the scheduler works correctly. The expected output should show alternating messages from UrgentTask and DisplayTask.

FreeRTOS

#include "FreeRTOS.h"
#include "task.h"
#include 

void UrgentTask(void *pvParameters) {
    for (;;) {
        printf("Urgent task running\n");
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

void DisplayTask(void *pvParameters) {
    for (;;) {
        printf("Display task running\n");
        vTaskDelay(pdMS_TO_TICKS(2000));
    }
}

int main(void) {
    xTaskCreate(UrgentTask, "UrgentTask", 1000, NULL, 2, NULL);
    xTaskCreate(DisplayTask, "DisplayTask", 1000, NULL, 1, NULL);
    vTaskStartScheduler();
    // Print Scheduler ended below
    // Your code here
    return 0;
}

Hint

The scheduler runs tasks repeatedly. You should see both messages printed repeatedly. The line "Scheduler ended" should not appear unless the scheduler stops.

Practice

1. Which of the following best describes a real-time operating system (RTOS) like FreeRTOS?

easy

A. It responds quickly and predictably to events.

B. It is designed mainly for running desktop applications.

C. It delays tasks unpredictably to save power.

D. It only runs one task at a time without multitasking.

Solution

1. Step 1: Understand RTOS purpose

   RTOS is designed to respond quickly and predictably to events, ensuring timing is guaranteed.

2. Step 2: Compare options

   Options B, C, and D describe general-purpose OS or incorrect behavior.

3. Final Answer:

   It responds quickly and predictably to events. -> Option A

4. Quick Check:

   RTOS = predictable quick response [OK]

Hint: RTOS means fast and predictable response to events [OK]

Common Mistakes:

• Confusing RTOS with general-purpose OS
• Thinking RTOS delays tasks unpredictably
• Assuming RTOS runs only one task

2. Which syntax correctly creates a FreeRTOS task in C?

easy

A. createTask(TaskFunction, "Task1", 1000, NULL, 1, NULL);

B. xTaskCreate(TaskFunction, "Task1", 1000, NULL, 1, NULL);

C. xTaskStart(TaskFunction, "Task1", 1000, NULL, 1, NULL);

D. TaskCreate(xTask, "Task1", 1000, NULL, 1, NULL);

Solution

1. Step 1: Recall FreeRTOS task creation function

   The correct function to create a task is xTaskCreate with parameters: function, name, stack size, parameters, priority, and handle.

2. Step 2: Check each option

   Only xTaskCreate(TaskFunction, "Task1", 1000, NULL, 1, NULL); uses the correct function name and parameter order. Others use wrong function names.

3. Final Answer:

   xTaskCreate(TaskFunction, "Task1", 1000, NULL, 1, NULL); -> Option B

4. Quick Check:

   FreeRTOS task creation = xTaskCreate [OK]

Hint: FreeRTOS task creation always uses xTaskCreate() [OK]

Common Mistakes:

• Using incorrect function names like createTask or xTaskStart
• Mixing up parameter order
• Omitting required parameters

3. Given this FreeRTOS code snippet, what will be the output sequence printed?

void Task1(void *pvParameters) {
  for (int i = 0; i < 3; i++) {
    printf("Task1: %d\n", i);
    vTaskDelay(10);
  }
  vTaskDelete(NULL);
}

void Task2(void *pvParameters) {
  for (int i = 0; i < 3; i++) {
    printf("Task2: %d\n", i);
    vTaskDelay(10);
  }
  vTaskDelete(NULL);
}

medium

A. Task1: 0
Task1: 1
Task1: 2
Task2: 0
Task2: 1
Task2: 2

B. Task2: 0
Task2: 1
Task2: 2
Task1: 0
Task1: 1
Task1: 2

C. Task1: 0
Task2: 1
Task1: 2
Task2: 0
Task1: 1
Task2: 2

D. Task1: 0
Task2: 0
Task1: 1
Task2: 1
Task1: 2
Task2: 2

Solution

1. Step 1: Understand vTaskDelay effect

   vTaskDelay causes the current task to pause, allowing other tasks of equal priority to run.

2. Step 2: Trace task execution order

   Task1 prints 0, delays; Task2 runs, prints 0, delays; then Task1 prints 1, and so on, alternating output.

3. Final Answer:

   Task1: 0 Task2: 0 Task1: 1 Task2: 1 Task1: 2 Task2: 2 -> Option D

4. Quick Check:

   vTaskDelay causes task switching, so output alternates [OK]

Hint: vTaskDelay switches tasks, output alternates between tasks [OK]

Common Mistakes:

• Assuming one task runs fully before the other
• Ignoring vTaskDelay effect
• Mixing output order

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

void Task(void *pvParameters) {
  while(1) {
    // Task code
  }
}

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

medium

A. The task function must call vTaskDelete(NULL) to end.

B. Stack size 1000 is too large and causes error.

C. vTaskStartScheduler() is missing and should be added.

D. The task function should not have an infinite loop.

Solution

1. Step 1: Analyze main function

   A task is created with xTaskCreate, but the scheduler is never started.

2. Step 2: Recall FreeRTOS startup

   vTaskStartScheduler() must be called after creating initial tasks to begin scheduling and multitasking.

3. Final Answer:

   vTaskStartScheduler() is missing and should be added. -> Option C

4. Quick Check:

   FreeRTOS requires vTaskStartScheduler() call [OK]

Hint: vTaskStartScheduler() starts the RTOS scheduler [OK]

Common Mistakes:

• Thinking infinite loop is wrong in RTOS tasks
• Missing vTaskStartScheduler call
• Assuming stack size causes error

5. You are designing a system that must control a robotic arm with precise timing to avoid damage. Which OS choice is best and why?

hard

A. Use a real-time OS like FreeRTOS because it guarantees predictable timing.

B. Use a real-time OS because it delays tasks unpredictably to save power.

C. Use a general-purpose OS because it has better user interfaces.

D. Use a general-purpose OS because it handles many tasks simultaneously.

Solution

1. Step 1: Identify system requirements

   Precise timing is critical to avoid damage, so predictable response is needed.

2. Step 2: Match OS type to requirement

   Real-time OS guarantees predictable timing; general-purpose OS may delay unpredictably.

3. Final Answer:

   Use a real-time OS like FreeRTOS because it guarantees predictable timing. -> Option A

4. Quick Check:

   Precise timing needs RTOS, not general OS [OK]

Hint: Precise timing needs RTOS, not general OS [OK]

Common Mistakes:

• Choosing general-purpose OS for timing-critical tasks
• Confusing power saving with timing guarantees
• Ignoring predictability requirement