Fundamentals of Real-Time Operating Systems (RT201) On-Line Course

Register Now

You will have 180 days to access the on-line course.

Speaker: Mike McCullough, President RTETC, LLC.

Course – Fundamentals of Real-Time Operating Systems (RT201)

Lecturer – Mike McCullough is President and CEO of RTETC, LLC. Mike has a BS in Computer Engineering and an MS in Systems Engineering from Boston University. He has held a variety of software engineering positions at LynuxWorks, Embedded Planet, Wind River Systems and Lockheed Sanders. RTETC, LLC provides Real-Time embedded training and consulting to many embedded systems companies. RTETC focuses on Real-Time operating systems (RTOS), Linux and Android solutions for the embedded systems market.

Course Summary – This course introduces the basics of Real-Time Operating Systems (RTOSes) using VxWorks and Linux as examples. The course focuses on the primary principles of RTOSes including determinism, real-time scheduling, interrupt latency and fast context switching as well as time and space partitioning in hard real-time environments. The first part of the course focuses on acquiring an understanding of microkernel and memory architectures for Real-Time including scheduling, signals, system calls, synchronization, inter-process communications and interrupt handling. The latter part of the course covers considerations for timing, memory management, device drivers, booting, debugging and deployment of Real-Time embedded systems.

Who Should Attend – The course is designed for real-time engineers who are using or intending to use a Real-Time Operating System. It is also targeted at experienced developers requiring a refresher course on RTOSes. This course will clearly demonstrate both the strengths and weaknesses of the Real-Time Operating Systems in Embedded Systems.

Course Objectives

• To provide a basic understanding of Real-Time Requirements
• To understand the complexities of RTOS scheduling and synchronization
• To learn how to configure, boot, test and deploy real-time embedded systems
• To give students the confidence to apply these concepts to their next RTOS project

Hardware and Software Requirements – The student should have a working Linux desktop environment either directly installed or in a virtualization environment or have access to a development environment for a Real-Time Operating System such as VxWorks. An Embedded Linux target hardware platform is useful but not absolutely required for this course.

Embedded Development Basics
Embedded Systems Characteristics
Embedded Real-Time Systems
Real-Time Enough
Embedded Linux and Real-Time
Real-Time Operating System Basics
Microkernel Architecture
Microkernel Scheduling
Rate Monotonic Analysis and Fixed Priority Scheduling
Latency and Latency Measurements
Fast Context Switching
Real-Time Memory Architectures
Time and Space Partitioning and ARINC
Multiprocessor Basics
Amdahl’s Law
RTOS Kernel Overview
Real-Time Scheduling and Task Management
Signals and System Calls
Inter-Processor Communications (IPC)
Interrupt Handling
Error Handling
Timing and Timers
Real-Time Memory Management
Real-Time Scheduling
OS Scheduling Types
Pre-emptive Multitasking
Typical Scheduling Issues
VxWorks Scheduling
Linux Scheduling
Linux Threads
Tasks and Task-Specific Data (TSD)
VxWorks Real-Time Processes (RTPs)
Measuring Task and Thread Performance
Signals in Embedded RTOSes
System Calls in Embedded RTOSes
Via Global Data
Via Semaphores, Files and Signals
Mutexes in VxWorks and Linux
Linux Futexes
Software Watchdog Timers
Inter-Process Communications (IPC)
More Semaphores
Message Queues
Shared Memory
Pipes and FIFOs
Remote Procedure Calls

Interrupt and Exception Handling
Basic Interrupt Process
VxWorks intLib and excLib
Routines You Can Call From Interrupt Context

Interrupt Service Routines (ISRs)
VxWorks and Linux ISRs

Bottom Halves in Linux

Deferring Work
Tasklets and Work Queues in Linux
Helper Tasks and Threads
Error Handling
Error Handling Approaches
errno and perror
strerror and strerror_r
Resets, OOPS, Panics and Segmentation Faults
Error Logging Approaches
How Linux Tells Time
Kernel, POSIX and Interval Timers
High-Resolution Timers (HRTs)
Watchdog Timers
Sleep Waiting and Spinlocks
Using Timers
Embedded Recommendations for Timing
Memory Management and Paging
The VxWorks Memory Model
The First-Fit Memory Algorithm
VxWorks memLib and memPartLib
Linux, Memory and Demand Paging
Mapping Device Memory
The Slab Allocators
Memory Barriers
The OOM Killer
Reserving and Locking Memory
Memory in Embedded Systems
Device Drivers
File Descriptors in VxWorks
The VxWorks IO Subsystem
VxWorks ioLib and iosLib
The 5 Basic Device Driver Types
File Descriptors in Linux
The UNIX Device Driver Model
Major and Minor Numbers
The New Device Driver Model
VxWorks Boot Example
VxWorks Configuration Files
VxWorks Application Startup
The Root Filesystem in Linux
Bootloaders and U-Boot
Embedded Linux Boot Methods
Building and Booting from SD Cards
Real-Time Debugging
Process-Level Debug
GDB, GDB Server and the GDB Server Debugger
The VxWorks Debug Agent (WDB)
A Remote Debug Example
Printing and Logging

System-Level Debug
System-Level Debug Tools
The /proc Filesystem in Linux
Advanced Logging Methods
Kernel Debugging
Crash and Core Dumps
Visualization Tools
System Architecture Design Approaches
Deploying VxWorks Systems
VxWorks Systems Customization and Configuration
VxWorks Field Upgrades
Deploying Embedded Linux
Linux Systems Customization and Configuration
Choosing and Building the Root Filesystem
Module Decisions
Final IT Work
Linux Field Upgrades
RTOS Trends
Development Trends
Monitoring Trends
Testing Trends
Some Final Recommendations

Registration is on-going. You will have 180-days to access the course.

Course fee: $330.00

Refund Policy:  No refunds for online courses once the course is accessed by the attendee.