Real Time Operating System

Introduction to RTOS

• A Real-Time Operating System (RTOS) is a specialized operating

system designed to process data and execute tasks within strict time
constraints.
• It ensures that critical tasks are completed within a predetermined time
frame, making it essential for time-sensitive applications like embedded
systems, medical devices, industrial automation.
 Key Difference from General-Purpose OS and
RTOS
General-Purpose OS RTOS
• Maximizes overall task completion • Ensures timely execution of
and system utilization critical tasks
• Time-sharing, fairness-based • Priority-based, deterministic
• Response time is Variable and • Response time is Low and
unpredictable predictable
• Higher latency due to multitasking • Latency is Minimal (milliseconds
• May experience delays due to or microseconds)
background processes • Highly reliable for time-sensitive
• Soft preemption (task switching operations
based on fairness) • Hard preemption (strict execution
order)
 Types of RTOS
• Hard Real-Time OS: Guarantees
that tasks must complete within a
strict deadline.

• Soft Real-Time OS: Deadlines are

important but missing them
occasionally is acceptable.

• Firm Real-Time OS: Missing a

deadline is undesirable but does
not cause system failure.
 What is POSIX
• POSIX (Portable Operating System Interface) is a standardized set of APIs
developed by IEEE for OS compatibility.

• It ensures portability of software across different operating systems.

• POSIX provides common system calls and libraries for file handling, threading, and
process control.

• Used in Linux, Unix, macOS, and some Real-Time Operating Systems (RTOS).

• Example: A POSIX-compliant application written for Linux can run on macOS or

QNX with minimal changes.
 Why POSIX Matters in RTOS?
• Portability: Code written for a POSIX RTOS (e.g., VxWorks, QNX) can be
easily migrated.
• API Consistency: Developers can use familiar functions.
• Standardization: Ensures uniform handling of file I/O, process control, and
inter-process communication (IPC).
• Reduced Development Effort: Allows reuse of existing code across
multiple embedded platforms.
• Trade-off: Some RTOS (e.g., FreeRTOS) are not fully POSIX-compliant
because POSIX APIs may introduce performance overhead.
 Need for RTOS in Embedded Systems
• Predictability: Ensures the system behaves identically under the same
conditions.

• Determinism: Tasks execute within a fixed, known time frame.

• Deadline Guarantees: Essential for safety-critical applications (e.g.,

medical devices, automotive, aerospace).

• Efficient Resource Management: Manages CPU time, memory, and

peripherals effectively.
 Foreground/Background Systems
• Foreground (Interrupt-Driven) – Handles urgent tasks immediately using
Interrupt Service Routines (ISRs).
• Background (Main Loop) – Handles non-urgent tasks, but with limitations
like polling overhead, latency, and lack of prioritization.
• Example: Fire Alarm System
• Foreground: Fire detection sensor sends an alert (interrupt-driven).
• Background: A temperature sensor continuously checks the room
temperature in a loop.
 Why Foreground/Background Systems Fall
Short & RTOS Advantages
Problems with Foreground/Background Systems

• Blocking Issues: Low-priority tasks delay high-priority ones.

• Polling Overhead: Wastes CPU cycles checking for events.

• High Latency: Interrupts must wait for the main loop to complete.

• No Prioritization: All background tasks are treated equally.

How RTOS Solves These Issues

• Preemptive Scheduling: High-priority tasks interrupt lower ones.

• Multitasking: Replaces polling with efficient task switching.

• Priority-Based Execution: Critical tasks (e.g., motor control) preempt non-

critical ones (e.g., logging).

• Examples: ABS braking system, Flight control systems, Pacemakers &

ventilators.
 RTOS Kernel Architecture
• Kernel is the core part of an
operating system (OS). It manages
the system's resources and acts as a
bridge between hardware and
software.
• The "brain" of the RTOS: Manages
hardware resources and ensures real-
time behavior.
 Core components of Kernel

• Task Scheduler: Prioritizes and switches tasks.

• ISR (Interrupt Service Routines): Handles hardware interrupts.

• IPC (Inter-Process Communication): Enables task coordination.

• Memory Management: Allocates/controls memory.

 Task Scheduler & Scheduling Policies
• In an RTOS (Real-Time Operating System), multiple tasks or processes
run either simultaneously or in quick succession.

• Scheduling Policies

• Preemptive: High-priority tasks interrupt lower ones.

• Priority-Based: Static (fixed) vs. Dynamic (adjustable).

• Round-Robin: Equal time slices for same-priority tasks.

 ISR in RTOS
• In RTOS (Real-Time Operating System), ISRs play a crucial role in
handling time-critical events and then notifying tasks to take over further
processing.

• Two-Level Interrupt Handling:

• Primary ISR: Quick response (e.g. save sensor data).

• Deferred Processing: Offloads complex work to a task.

• Example: RTOS in Action: Anti-Lock Braking System (ABS)

 Bare-Metal Systems
• Bare-metal programming means writing code that runs directly on the
hardware, without any operating system or real-time operating system
(RTOS) managing tasks, memory, or scheduling.

• ISR runs to completion; no task switching.

• Risk of long ISRs blocking critical tasks.

 ISR in RTOS vs. Bare-Metal Systems
ISR in RTOS
ISR in Bare-Metal
• Runs under a Real-Time Operating • Runs directly on hardware (no OS)
System
• Programmer manually manages
• RTOS manages interrupt and task interrupt priorities
priorities • ISR reads sensor and processes data
• ISR detects sensor input, signals task to itself
process data • No task scheduling; ISRs run in
• High-priority tasks interrupt ISRs (if isolation.
allowed).
 Multitasking & Context Switching
• Multitasking : The ability of a system to run multiple tasks (or threads) seemingly
at the same time.

• In embedded systems with RTOS, multitasking allows multiple functions.

• Example: Reading sensors, controlling motors, communicating via Bluetooth to

run in a coordinated way without interfering with each other.

• Context Switching: Saving the current task’s state and restoring another task’s
state so the CPU can continue from where it left off.

• It allows the processor to switch from one task to another seamlessly as if each task
has the CPU all to itself.
• Inter-Process Communication (IPC)
mechanisms are essential for
enabling processes to communicate
and synchronize their actions when
running concurrently in an
operating system.
 IPC Mechanisms
• Semaphores

• A semaphore is a signaling mechanism used to manage access to shared

resources or coordinate task execution.
• Message Queues / Mailboxes

• A message queue allows asynchronous

communication between tasks. One task
sends a message, another receives it.
They don’t need to run at the same time.

• Messages are stored in a queue until the

receiver picks them up.

• Mailboxes are a simpler version. They

typically store one message at a time.
• Pipes & Events
• Pipes: Pipes are unidirectional communication channels used to send a stream of bytes
from one task to another.
• When timing is critical and you want to stream data.
• Pipes ensure that data flows efficiently between tasks without needing them to run at
the same time.
• Events: Events (or event flags) are used to signal occurrences in the system such as a
hardware interrupt, task completion, or specific system condition.
• A task can wait for one or more event flags to be set before proceeding.
• RTOS maintains event flags, a bitfield where each bit represents a different event.
• Timers
• Timers in RTOS provide precise timing and delay functions for tasks, events,
or timeouts.
• Timers ensure timing accuracy, especially important in hard real-time
systems (like medical or automotive).
• Memory Management
• Memory management is the method by which an RTOS allocates, uses, and
frees up memory for different components like:Tasks, Queues, Semaphores,
Buffers
• Static memory allocation and Dynamic memory allocation
 RTOS services in contrast with traditional OS
RTOS Traditional OS
• P r i o r i t y - b a s e d , d e t e r m i n i s t i c , m a y u s e • Fairness-based (e.g., round-robin, time-
preemptive scheduling sharing), less predictable

• Hard/Soft real-time deadlines are respected • No guaranteed response time

• Very fast and predictable

• May involve delay due to background
processes
• Often static or controlled dynamic allocation
• Fully dynamic (malloc, garbage collection)
• Lightweight, minimal memory usage
• Heavy, needs large memory & storage
• Optimized for low-power embedded systems
• Higher power usage due to background
• FreeRTOS, VxWorks, QNX, RTEMS, Zephyr services
• Windows, Ubuntu, Android, macOS
 Importatnt Questions
• 4 marks questions
1. Define a Real-Time Operating System (RTOS) and explain its key
characteristics.
2. Differentiate between General-Purpose OS and RTOS with examples.
3. Explain the significance of POSIX in the context of RTOS.
4. What are the types of Real-Time Operating Systems? Explain each with
an example.
5. Describe the concept of determinism in RTOS and its importance in
embedded systems.
6. What is the role of a kernel in RTOS?
7. List and explain any three core components of an RTOS kernel.
8. Explain the foreground/background system architecture with a real-world
example.
9. Discuss the limitations of foreground/background systems in embedded
applications.
10. Describe preemptive scheduling and its advantage in RTOS.
11. What are ISRs in RTOS? Explain the concept of two-level interrupt
handling.
12. Compare ISR handling in RTOS and bare-metal systems.
13. Define multitasking and context switching in RTOS with suitable
examples.
14. Explain any two Inter-Process Communication (IPC) mechanisms used in
RTOS.
15. Compare RTOS with traditional OS in terms of memory management and
scheduling.
• 8 marks questions
1. Compare and contrast Hard, Soft, and Firm Real-Time Operating Systems

2. Analyze the difference between Foreground/Background Systems and RTOS-based

systems. Illustrate with an example how RTOS addresses the shortcomings of traditional
interrupt-driven systems.

3. Explain the architecture of the RTOS kernel. Describe the role of the Task Scheduler,
ISR, IPC, and Memory Management with real-time examples where each component is
critical.

4. Discuss POSIX compliance in the context of RTOS. What are its benefits and trade-offs?
Give examples of how POSIX-compliant RTOS systems promote portability and
reduced development time.
5. Explain various scheduling policies used in RTOS like preemptive,
priority-based (static and dynamic), and round-robin. Illustrate how these
scheduling techniques can be applied in a multitasking embedded
application.
6. Compare ISR (Interrupt Service Routine) handling in RTOS and Bare-
Metal Systems. Explain with examples the advantages of two-level
interrupt handling in RTOS.
7. Describe in detail the role of multitasking and context switching in RTOS.
How do these features enable better performance in embedded
applications such as drones or smart home systems?
8. Explain different Inter-Process Communication (IPC) mechanisms
(semaphores, message queues, pipes, events). Compare them in terms of
synchronization, communication, and real-time application suitability.
9. Discuss the importance of Timers and Memory Management in RTOS.
How do static and dynamic memory allocations affect system performance
in real-time systems?
10. RTOS vs. Traditional OS: Analyze and compare their characteristics in
terms of task scheduling, memory usage, power efficiency, and real-time
performance. Provide examples of where each is more appropriate