Introduction to Real-Time Operating System (RTOS)

Micrium, an American company known for embedded software stacks, offers real-time operating systems with clean code, thorough documentation, and top-notch support; it provides a try-before-you-buy evaluation by downloadable source code.

Explore uCOS-II, a preemptive real-time operating system certified for safety-critical aerospace and medical applications, detailing tasks, semaphores, mailboxes, event flags, timers, and configurable objects.

Install and configure RTOS development environment for lab work, set up drivers and simulation directories, use the complete OS source and the reference config, then compile to verify zero errors.

Initialize the RTOS by configuring the startup sequence and internal data structures. Create at least one application task and start the OS scheduler to hand control to highest priority task.

Explore the task model in real-time operating systems, including single-process flow, task priorities from highest (0) to lowest (255), event waiting, and how sleep tasks affect scheduling.

A task is an independent C function with timing characteristics like execution time and finishing before its period, plus maximum blocking time, managed by ready state, scheduling, context, and storage.

Explain the RTOS task template: a void function with a void pointer, initialize with a parameter struct, then loop forever or until termination, optionally sleeping periodically after waiting for events.

Learn how tasks transition through states in a real-time operating system: from creation to ready, running, waiting for events, and back to ready as events occur.

Explore task creation in real-time operating systems, including creating tasks via create and create extended, passing function pointers and arguments, and managing stack, priority, and optional task metadata.

Define and manage RTOS task stacks, choose incrementing or decrementing models, and apply stack checking with a 1.5x safety margin to prevent overflow.

Revisit task creation in this RTOS lecture, explaining task control blocks and metadata stored in RAM, stack initialization, and how tasks enter the running state.

Learn how real-time operating systems delete tasks, release DCB resources, and handle deletion requests with priority to ensure proper resource cleanup before task removal.

Explore the rtos task services, including runtime priority changes, task name setters and getters, suspend and resume flows, and stack and dcb insights for efficient task management.

Explore partitioning a multitasking RTOS application into tasks to balance scheduling overhead and memory usage, apply divide and conquer and cohesion criteria, and aim for seven tasks maximum.

Explore how to assign priorities in a multitasking RTOS by classifying tasks into four categories by criticality and efficiency, guided by the Gomar criterion and worst-case execution time checks.

Explore real-time operating systems by examining how a preemptive kernel and interrupt service routines drive task scheduling, using priority-based decisions to select the ready task that runs next.

Understand time delay services that suspend a task for milliseconds, seconds, or minutes, and how timer interrupts, system time, and jitter affect real-time behavior.

Learn how shared resources like global data and peripherals cause race conditions when multiple RTOS contexts access them, producing mixed outputs during time slicing, and the need for coordination.

Learn how race conditions arise from non-atomic shared resource access and implement exclusive access with locks, choosing interrupt- or preemption-based synchronization in RTOS.

Disable interrupts to protect a critical section, but the interrupt state may differ before and after. Save the state in a variable and restore it on exit to avoid crashes.

Learn how semaphores protect shared resources in real-time systems using post and wait operations, with counting and binary semaphores, initialization values, and timeouts.

Explore semaphore-based problems in RTOS, including starvation, deadlock, and priority inversion, and analyze how high-, medium-, and low-priority tasks contend for semaphores and potential solutions.

Explore how mutexes and semaphores address priority inversion and starvation in real-time systems, comparing priority inheritance and priority ceiling protections, and explain how tasks regain control after resource release.

Explore the other semaphore and mutex services in real-time operating systems, including zero-timeout checks, non-blocking calls from interrupt contexts, canceling pending tasks, and the option and the broadcast option.

discover how real-time operating systems use semaphores and signals to synchronize tasks, respond to interrupt service routines, and coordinate foreground and background processes with flags.

Use semaphores in real-time operating systems to synchronize tasks and signal events from interrupts, enabling producer–consumer patterns with ring buffers and waiting tasks.

Learn how to use event flags and flag groups for inter-task synchronization, waiting for specific or any combinations of events, posting events, handling timeouts, and querying flag status.

Real-time operating system concepts synchronize tasks across multiple events with an API that waits for an array of events like messages or mailbox. Timeouts and aborts prevent deadlocks.

Explore inter-task communication in real-time systems by sending messages between tasks using generic objects that take a message pointer, with mailboxes and message services enabling synchronization and mutual exclusion.

Explore how a real-time operating system uses a circular buffer as a message queue, with void pointers for generic data, and post and receive operations that block when empty.

Demonstrate how a real-time operating system uses a message queue for inter-task communication by buffering packets from interrupts and deferring processing to the bottom half.

Use a message queue as a counting semaphore to manage a pool of buffers, initializing with dummy messages to track free buffers in a producer-consumer pattern and optimize kernel size.

Explore mailboxes as a core RTOS primitive for inter-task communication, where a mailbox stores messages via pointers, initializes empty, and blocks readers until a message is posted.

Explore other message queue and mailbox services in a real-time operating system (rtos), covering creation, deletion, flush api, and post operation options like broadcast and front option to optimize scheduling.

Manage fixed-size memory using partitions with blocks of varying sizes to prevent fragmentation. Create, allocate, and return blocks within partitions, and assign ASCII names via the memory management API.

Use software timers on a single hardware timer with a timer manager to run multiple timers, supporting one-shot and periodic modes, callbacks, and a creation API.