Standard Training Courses
Realtime Programming for the QNX Neutrino RTOS
You must have a good working knowledge of C and a general knowledge of operating systems. Familiarity with embedded systems or realtime concepts is an asset.
This course is designed for anyone who develops QNX® Neutrino® RTOS realtime applications. By the end of the course, you will have written several example programs and learned to apply QNX Neutrino RTOS concepts to real-world applications.
- Familiarize the developer with the features, services, and architecture of the QNX Neutrino RTOS.
- Focus on real-world problems and the techniques for solving them.
- Provide hands-on exercises so the developer can learn to apply the concepts introduced throughout the course.
The course consists of the following sections:
- QNX Neutrino Architecture
We'll start with an overview of the QNX Neutrino RTOS, highlighting key features, services, and architecture. This overview serves as a "roadmap" to the rest of the course, allowing you to get a feel for the services that the QNX Neutrino RTOS provides.
- IDE Basics
Provides the background that anyone working with the IDE in the QNX Momentics development suite must have. Starting with the central concepts of the IDE, you'll become adept at navigating in the IDE and configuring it to suit your personal needs. We then talk about projects, workspaces, and the host-target model, introducing the various ways to interface with your target. We end with a handful of the preferences that can make your life easier.
- Compiling and debugging
This section provides a quick introduction to editing, compiling, running, and debugging your application from the QNX Momentics IDE, giving the minimum needed to do the programming exercises in the programming sections.
- Processes, Threads and Synchronization
Unlike many common legacy RTOSs, QNX Neutrino executes programs in separate, memory protected, processes. This section touches on how a system design problem can be broken down into separate processes, and how processes are started and terminated. In addition, in this section we'll discuss what a thread is, how to start and stop a thread, and how to synchronize resource access via QNX Neutrino RTOS and POSIX function calls. Several hands-on lab exercises form a significant component of this section.
- Interprocess communication
Explores the various methods that the QNX Neutrino RTOS provides for allowing two or more processes to exchange information and control. We focus on the QNX message passing that is fundamental to how QNX Neutrino works, but also examine pulses, shared memory and QNX asynchronous messages.
- Comparing QNX IPC Methods
A quick look at the relative advantages and disadvantages of the various IPC methods supported by QNX with a few to choosing which method(s) to use in your system.
- Introduction to Hardware Programming
An introduction to hardware access methods including IO-mapped and memory-mapped IO, allocating DMA-safe memory, and interrupt handling.
- Timers, clocks, and timeouts
In a realtime system, you need to keep track of real time and schedule periodic events. This section looks at the QNX Neutrino RTOS functions that deal with real time, timers, and kernel timeouts. A hands-on exercise will illustrate how to generate and handle periodic events.
- Multicore Processing
Discusses how to configure your application for Multicore, how scheduling works, where ISRs run, and processor affinity. Also examines how to perform synchronization among threads and between threads and ISRs.
- Building a QNX Neutrino Boot/OS Image
In this section we'll look at how to bind together core OS components, such as the Neutrino microkernel, network components, filesystem components, drivers, etc, to produce a bootable OS image. As well, we'll go through the many ways that a QNX Neutrino OS image can be stored on embedded systems.
- Introduction to resource managers
Any process can be a resource manager, and drivers almost always are. This section looks at the capabilities of resource managers, include pathname-space resolution, IPC message formats, and general structure. Through a set of exercises we'll look at the initialization of a simple resource manager and the handling of read() and write() operations.