Customized Courses - Training Modules in Alphabetical Order
If you opt for on-site training, you can choose from our existing courses or design a custom program by selecting the modules you need. To have an instructor help you select from the following modules, or to request new modules, contact email@example.com.
Advanced Topics for Resource Managers (3.5 hours)
Prerequisites: Threads and Synchronization, Introduction to Resource Managers
Explores the various ways to return from handlers, manage access and modification times, leave clients blocked, use multi-threaded resource managers, implement combine messages, perform unblock handling, receive pulses, and make select() and ionotify() work. Resource manager concepts are reinforced through a variety of hands-on exercises.
Application Profiling (1 hour)
Learn how to use the application profiler in the QNX Momentics development suite to profile a single process. Using the profiler, you can pinpoint which parts of your code are consuming the most CPU, at both the function level and the source-line level. You can then use that information to make your code more efficient. Both live and postmortem profiling are covered.
Building a Boot Image (1 hour)
A detailed look at building boot images, which contain the binaries that run just after the reset vector. Boot images typically include components such as startup code, the process manager, the kernel, drivers, and a startup script. We also explore various ways to load a boot image onto your target.
Code Coverage (1.5 hours)
Determining the effectiveness of a test suite takes work. In this section we'll see the IDE tools determining how much of your code has actually been executed, broken down to the source line, by your testing.
Comparing QNX IPC Methods (0.5 hours)
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.
Compiling and Debugging (1.75 hours)
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.
Note: This module is a light replacement for the Editing and Compiling and Running and Debugging modules. If you take one of those modules, it isn't necessary to take this one.
Debugging Memory Problems (2 hours)
Memory problems, such as memory corruption, can often be subtle and uncaught by testing. In this section, we explore the powerful Momentics IDE tools for finding memory corruption, leaks, and excessive memory consumption.
Editing and Compiling (1.5 hours)
This section will focus on the code editor in the Momentics IDE, including the many powerful, time-saving features. In addition, we look at how to build code and how the IDE identifies problems with the build.
Embedding with the QNX Momentics IDE (3 hours)
Prerequisites: Overview of QNX Embedded Systems
Details how to use the IDE in the QNX Momentics development suite to create a bootable image file that includes the components needed at boot time. Also explains how to create an embedded file system image that contains the components needed once your system has booted up. Often the IPL, images, and other components need to be converted to some intermediate form prior to putting on the target. We'll discuss how to perform that conversion. We'll also explore features that let you perform serial and TFTP downloads to a target.
File System Resource Managers (3.25 hours)
Prerequisites: Writing a Resource Manager
A discussion on how to write file system resource managers, which are processes that represent data in the form of files or file systems. You will learn to write a resource manager that presents a tar file as a file system.
High Availability (2.5 hours)
We start with how QNX architecture lends itself to high availability, then look at how to design applications that take advantage of that architecture. Next, we explore the high availability toolkit in detail, starting with how to use the high availability manager for doing process restart and multistage restart. We then cover the client recovery library, also included in the toolkit, which helps clients to restore broken connections.
IDE Basics (2 hours)
Focussing on Eclipse fundamentals, this section 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 navigatin in the IDE and configuring it to suit your personal needs and likes. We then talk about projects, workspaces and the host-target model, introducing various ways to interface to your target. We end with a handful of preferences that can make your life easier.
Interprocess Communication (7 hours)
Prerequisites: Threads and Synchronization
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 Persistent Publish/Subscribe Service.
Interrupts (2.75 hours)
Prerequisites: Interprocess Communication (recommended)
Explores how the QNX Neutrino RTOS makes it relatively easy to write and debug interrupt handlers. We present several approaches to interrupt handlers.
Introduction to Hardware Programming (1.5 hours)
An introduction to hardware access methods including IO-mapped and memory-mapped IO, allocating DMA-safe memory, and interrupt handling.
Introduction to I/O (0.25 hours)
An overview of port I/O, memory mapped I/O, DMA memory configuration, and how to use the PCI API.
Introduction to Resource Managers (3 hours)
Prerequisites: Interprocess Communication
Any process can be a resource manager, and drivers usually are. This section looks at the capabilities of resource managers, including 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.
I/O (1.0 hours)
Covers in detail the I/O aspects of a driver, including how to do port I/O and memory-mapped I/O, how to perform DMA memory configuration, and how to use the PCI API. Note: If you take this module, you don't have to take the "Introduction to I/O" module.
I/O Exercises (duration depends on which exercises are chosen, see below)
Prerequisites: I/O, Introduction to Resource Managers
A collection of challenging exercises that are a must for anyone learning to write device drivers. The exercises used depend on the hardware available. You can choose from:
Screen driver exercise (2.5 hours)
You'll write an I/O manager that does read()s from, write()s to, and devctl()s for changing the configuration of VGA text mode memory.
Keyboard driver exercise (1.5 hours)
You will write a simple driver that handles x86 keyboard input.
Managing C/C++ Projects (2 hours)
The basic container for code in the IDE is a project. We cover the three types of projects for C/C++ code: a project where the entire contents and build structure are up to you, a project with a predefined structure that supports multiple platforms, and library projects. We cover both header file and project dependencies and discuss how to get code from elsewhere and place it into your projects.
More on Threads and Synchronization (1.5 hours)
Prerequisites: Threads and Synchronization
Covers additional issues for anyone who wants to know a lot about threads, including reader/writer locks, once control, and thread local storage.
Other Debugging Topics (5 hours)
Prerequisites: IDE Basics, QNX Neutrino RTOS Architecture, Running and Debugging
This module broadens the definition of debugging by exploring capabilities that are beyond the reach of conventional tools. It starts with using the QNX Momentics IDE to debug multithreaded processes and multiple processes, then explores how to debug IPC issues, debug callbacks, do postmortem debugging, attach to a running process, and debug shared libraries.
Overview of QNX Embedded Systems (0.5 hours)
Before doing actual embedding, you must understand the components that you want to embed and how they relate to each other. You also need this information when designing your embedded system. To explain all this, we cover many of the possible ways of booting, what components are involved, and how they all fit together.
Performance Analysis (6 hours)
Prerequisites: System Profiling, and QNX Neutrino RTOS Architecture
Demonstrates how the application profiler and the system profiler can help you diagnose why an application is behaving slowly. We'll look at two or three systems that are not behaving as expected, and use the IDE's Performance Analysis tools to determine why things are going wrong.
POSIX Interprocess Communication in QNX (2 hours)
QNX also supplies a rich set of POSIX IPC methods. This section looks at signals, shared memory, pipes, POSIX message queues, and TCP/IP.
QNX Momentics Development Suite: IDE Basics (2 hours)
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, along with pointers to various sources of documentation.
QNX Neutrino RTOS Architecture (3 hours)
Gives an overview of the QNX Neutrino RTOS architecture, covering what the microkernel and the process manager do. We talk about standards, protected address spaces, process/thread model, timing, and scheduling. We also introduce various types of IPC, synchronization, what a resource manager is and where shared objects fit in.
QNX Neutrino RTOS Programming Basics (2.5 hours)
A review of basic programming topics for the QNX Neutrino RTOS, such as threads, mutexes, message passing, pulses, and timing. This module provides a refresher course to students familiar with QNX programming and offers a good background for other course material.
Note: You don't have to select this module if you're taking other modules that cover the same topics in more detail.
Running and Debugging (2.5 hours)
Running programs on an embedded system, in a cross development environment, is naturally more involved than in a non cross development environment. This section introduces how this is accomplished using the QNX Momentics IDE. As well, we will have a look at how typical debugging actions, such as single-stepping, setting and using breakpoints and viewing program variables, are accomplished.
Serial I/O (0.5 hours)
Covers how to configure serial ports, from both code and the command line, and then goes through the details of doing serial I/O.
Multicore Processing (0.5 hours)
Prerequisites: QNX Neutrino RTOS Programming Basics or equivalent
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.
System Profiling (3 hours)
With system profiling, you can examine your system as a whole to see what's going on. Detail is available down to the kernel level. We start by covering what is happening on the kernel side and how to do the necessary setup. Next, we look at how to log the activity through the QNX Momentics IDE, from the command line, or under program control. Then, we look at how to use the IDE's system profiling perspective to analyze the resulting data. We finish off with how to insert your own data into logs.
Timers, Clocks, and Timeouts (3.25 hours)
Prerequisites: Interprocess Communication (recommended)
An explanation of how to meet deterministic timing requirements. We discuss timing architecture and how to handle periodic timing, one-shot timing, time-stamping, benchmarking, and timeouts.
Threads and Synchronization (3.5 hours)
An overview of thread services in the QNX Neutrino RTOS, which allow multiple flows of execution through a given program. We discuss what a thread is, thread priorities, scheduling algorithms, how to start and stop a thread, and how to synchronize resource access via the QNX Neutrino RTOS and POSIX function calls. Hands-on exercises show you how to apply some of these key concepts.
Writing a Resource Manager (5.5 hours)
A look at the capabilities of resource managers, including pathname-space resolution, IPC message formats, and general structure. We provide several exercises, from a very simple resource manager that implements /dev/null to more complex examples that support multiple devices.