A beginner's guide to the concepts of RTOS

Discover how an operating system coordinates simple computing tasks, switches between instruction sets for a thermometer's sensing and display, shares memory resources, and enables multitasking.

Learn how context switching uses registers, stack memory, and the program counter to save and restore task state at scheduling points in RTOS.

Explore common RTOS scheduling policies, including preemptive scheduling, round-robin, earliest deadline first, and first come, first served, and understand how priorities trigger preemption and context switches.

Block a task from executing to protect a shared resource between the temperature sensing task (D1) and the display task in shared memory, preventing unsafe read/write and potential catastrophe.

Learn how a mutex enforces mutual exclusion to protect shared memory, letting one task access the resource while another waits in a blocked state until the mutex is released.

Understand how preemptive scheduling leads to priority inversion when a low-priority task blocks a high-priority one via a mutex, and how priority inheritance resolves it.

Explore kernel variables beyond task and mutex, including DASK mutex semaphores, event timelines, and message cues, and understand how these variables fit in rtos concepts.

Create RTOS tasks via task creation APIs, setting name, priority, stack, and entry, with input pointers; explore nonvolatile memory use and synchronization via mutexes or semaphores.

The scheduler takes system control after starting the basic task, running high-priority tasks first (temperature sensing before the LCD display) and may switch if the high-priority task isn’t ready.

Explore task control blocks in rtos, how kernel creates a task control block for each task with priority and stack state, and how the scheduler uses ready and pending states.

Explore mutex concepts in rtos, including ownership, mutual exclusion, and how tasks access resources safely. Learn mutex creation, timeout handling, and priority inheritance during contention.

Explores recursive mutex behavior and how a task may deadlock by re-acquiring a mutex it already holds, noting that a mutex frees after equivalent releases.

Explore how semaphores regulate access to shared ports using a three-resource example with threads, and learn binary semaphores, timeouts, and event flag groups for resource tracking.

Compare mutexes and semaphores in rtos: mutexes provide ownership and optional priority inheritance, making them heavier; semaphores are lighter but lack ownership and priority inheritance.

Explore semaphore APIs in RTOS, setting initial counts for resources, waiting with timeouts or indefinitely, signaling semaphores, and deleting them to manage producer-consumer scenarios.

Learn how one-shot and periodic timers in RTOS trigger a specified API after a timeout, and how to stop or reschedule callbacks.

Explore how event flag groups let tasks wait for single or multiple events, using flags to indicate status and use combined or and logic, with a digital thermometer example.

Atlas provides event flag group APIs to create, set, clear, and wait for events with a timeout, returning status and freeing resources on deletion.