Bare-metal vs RTOS execution model in Embedded C - Hands-On Comparison

Bare-metal vs RTOS Execution Model

📖 Scenario: You are working on a simple embedded system that controls two LEDs. One LED should blink slowly, and the other should blink quickly. You want to understand the difference between running this on a bare-metal system (without an operating system) and using a Real-Time Operating System (RTOS) to manage tasks.

🎯 Goal: Build two versions of the LED blinking program: one using a bare-metal approach with a simple loop and delays, and another using an RTOS with two separate tasks. This will help you see how the execution models differ.

📋 What You'll Learn

Create variables to represent LED states

Implement a delay function

Write a bare-metal loop to blink LEDs

Write RTOS tasks to blink LEDs concurrently

Print LED states to simulate blinking

💡 Why This Matters

🌍 Real World

Embedded systems often control hardware like LEDs, motors, or sensors. Understanding bare-metal and RTOS models helps design efficient and responsive devices.

💼 Career

Embedded software engineers must know how to write code for microcontrollers both with and without operating systems to meet project requirements.

1

Setup LED state variables

Create two integer variables called led_slow and led_fast and initialize both to 0 to represent LEDs being off.

Embedded C

# Create two integer variables led_slow and led_fast and set both to 0
# Your code here

Hint

Use int to declare variables and set them to 0.

2

Add delay function

Write a function called delay that takes an integer count and uses a simple empty loop to create a delay.

Embedded C

int led_slow = 0;
int led_fast = 0;

// Write a delay function that loops count times
void delay(int count) {
    // Your code here
}

Hint

Use a for loop inside the delay function to waste time.

3

Write bare-metal LED blinking loop

Write a main function that uses an infinite while loop to toggle led_slow every 1000000 counts and led_fast every 500000 counts using the delay function. Toggle means change 0 to 1 or 1 to 0.

Embedded C

int led_slow = 0;
int led_fast = 0;

void delay(int count) {
    for (int i = 0; i < count; i++) {
        // empty loop for delay
    }
}

// Write main function with infinite loop to toggle LEDs with delays
int main() {
    // Your code here
}

Hint

Use while (1) for an infinite loop and toggle LEDs using led = !led;.

4

Simulate RTOS tasks for LED blinking

Write two functions called task_slow and task_fast that toggle led_slow and led_fast respectively with delays of 1000000 and 500000 counts. Then write a main function that calls these two tasks alternately in an infinite loop and prints the LED states after each toggle using printf.

Embedded C

int led_slow = 0;
int led_fast = 0;

void delay(int count) {
    for (int i = 0; i < count; i++) {
        // empty loop for delay
    }
}

// Write task_slow to toggle led_slow with delay
void task_slow() {
    // Your code here
}

// Write task_fast to toggle led_fast with delay
void task_fast() {
    // Your code here
}

// Write main to call task_slow and task_fast alternately and print LED states
int main() {
    // Your code here
}

Hint

Each task toggles its LED, delays, then prints the state. The main loop calls both tasks repeatedly.

Practice

1. Which statement best describes the bare-metal execution model in embedded C?

easy

A. Multiple tasks run concurrently with a scheduler.

B. It requires an operating system to manage tasks.

C. Code runs directly on hardware with a single main loop.

D. It uses virtual machines to isolate processes.

Solution

1. Step 1: Understand bare-metal execution

   Bare-metal means the program runs directly on the hardware without an operating system.

2. Step 2: Identify the execution style

   Bare-metal typically uses a single main loop to control the program flow.

3. Final Answer:

   Code runs directly on hardware with a single main loop. -> Option C

4. Quick Check:

   Bare-metal = single main loop [OK]

Hint: Bare-metal means one main loop, no OS multitasking [OK]

Common Mistakes:

• Confusing bare-metal with RTOS multitasking
• Thinking bare-metal requires an OS
• Assuming bare-metal uses task scheduling

2. Which of the following is the correct way to start a task in an RTOS environment in embedded C?

easy

A. void startTask() { while(1) { /* task code */ } }

B. xTaskCreate(taskFunction, "Task", 1000, NULL, 1, NULL);

C. main() { runTask(); }

D. createThread(taskFunction);

Solution

1. Step 1: Recognize RTOS task creation syntax

   In embedded C with RTOS like FreeRTOS, tasks are created using xTaskCreate().

2. Step 2: Match the correct function call

   xTaskCreate(taskFunction, "Task", 1000, NULL, 1, NULL); uses xTaskCreate() with proper parameters to start a task.

3. Final Answer:

   xTaskCreate(taskFunction, "Task", 1000, NULL, 1, NULL); -> Option B

4. Quick Check:

   RTOS task start = xTaskCreate() [OK]

Hint: RTOS tasks start with xTaskCreate() function [OK]

Common Mistakes:

• Using infinite loops without RTOS task creation
• Calling non-existent functions like createThread()
• Starting tasks directly in main() without scheduler

3. Given the following code snippet in a bare-metal system:

int main() {
  while(1) {
    toggleLED();
  }
  return 0;
}

What will happen when this runs?

medium

A. The LED toggles continuously without stopping.

B. The program creates multiple tasks to toggle the LED.

C. The LED toggles once and the program ends.

D. The program will cause a runtime error.

Solution

1. Step 1: Analyze the infinite loop

   The while(1) loop runs forever, repeatedly calling toggleLED().

2. Step 2: Understand bare-metal behavior

   Since there is no OS, the program stays in this loop, toggling the LED continuously.

3. Final Answer:

   The LED toggles continuously without stopping. -> Option A

4. Quick Check:

   Infinite loop toggles LED forever [OK]

Hint: Infinite loop means continuous action in bare-metal [OK]

Common Mistakes:

• Thinking tasks are created automatically
• Assuming program ends after one toggle
• Expecting runtime errors without cause

4. In an RTOS program, the following code snippet causes the LED to toggle only once:

void taskLED(void *params) {
  toggleLED();
}

int main() {
  xTaskCreate(taskLED, "LED", 1000, NULL, 1, NULL);
  vTaskStartScheduler();
  while(1) {}
}

What is the main problem?

medium

A. The task function lacks an infinite loop to keep running.

B. The scheduler is not started properly.

C. The task priority is too low to run.

D. The LED toggle function is incorrect.

Solution

1. Step 1: Check the task function structure

   The task function runs toggleLED() once and then returns, ending the task immediately.

2. Step 2: Understand RTOS task lifetime

   RTOS tasks must have an infinite loop to keep running and performing actions repeatedly.

3. Final Answer:

   The task function lacks an infinite loop to keep running. -> Option A

4. Quick Check:

   RTOS tasks need infinite loops [OK]

Hint: RTOS tasks must loop forever to keep running [OK]

Common Mistakes:

• Forgetting infinite loop in task function
• Assuming scheduler auto-repeats tasks
• Blaming LED function without checking task code

5. You have a project that needs to read sensor data, control motors, and communicate over UART simultaneously. Which execution model is best and why?

hard

A. Bare-metal, because it is simpler and uses one main loop.

B. Bare-metal, because multitasking is not possible in RTOS.

C. RTOS, but only if the hardware supports virtual machines.

D. RTOS, because it can run multiple tasks concurrently with scheduling.

Solution

1. Step 1: Analyze project requirements

   The project needs to handle sensor reading, motor control, and UART communication at the same time.

2. Step 2: Match execution model to multitasking needs

   RTOS supports multiple tasks running concurrently with a scheduler, ideal for complex multitasking.

3. Final Answer:

   RTOS, because it can run multiple tasks concurrently with scheduling. -> Option D

4. Quick Check:

   Multitasking needs = RTOS [OK]

Hint: Use RTOS for multitasking, bare-metal for simple loops [OK]

Common Mistakes:

• Choosing bare-metal for complex multitasking
• Thinking RTOS can't multitask
• Confusing virtual machines with RTOS requirements