D. Kalinsky Associates
Home  |  Training Courses  |  Online Learning  |  Resources  |  About Us  |  Contact  |  Site Map  
Foundation Course:

"Architectural Design of Real-Time Software"

*  A Foundation Course for Embedded and Real-Time Embedded Software Developers and Designers

*  How to Plan and Structure Embedded Application Software using a Real-Time Operating System

*  3- Day Intensive Class        (lectures, discussions, design examples, exercises)
COURSE OVERVIEW

This course examines the activities of high-level design of real-time and embedded systems software that's to be
developed using a real-time operating system (RTOS).

The class begins with a quick examination of some fundamental issues in real-time multitasking embedded
application software design and development, and briefly reviews several modern techniques for real-time and
embedded software requirements specification.  It then quickly focuses on how to structure a software system that
must execute within strict deadline and resource limits.  Emphasis is placed on multitasking and timing behaviors,
rather than object orientation.

The class continues with a detailed examination of a broad spectrum of intertask communication and synchronization
options including mutexes of several varieties. 'Liveness' issues such as deadly embrace, lockout, memory starvation
and CPU starvation are discussed in detail.   Students learn how to correctly configure queue lengths, and examine
design dangers such as excessive interrupt latency and interrupt overflow.  The next  major subject area of the class
is the evaluation of timing performance and quality of a real-time or embedded software design.  A large variety of
application examples reinforce the concepts that are learned.  Design patterns for real-time software are presented in
depth, as are a variety of "design skunks" (design schemes that are to be avoided).

This course is not a general course about software design theory, but rather it is highly focused on the design of
deeply-embedded, time-constrained, resource-constrained multitasking software that will run under the control of a
modern RTOS.


WHO SHOULD ATTEND ?

This course is intended for practicing real-time and embedded systems software system architects, project
managers and technical consultants who have responsibility for designing, structuring and implementing the
software for real-time and embedded computer systems using an RTOS.  This course focuses on design for
single-CPU systems.

Course participants are expected to have thorough familiarity with at least one RTOS.  [This knowledge can be gained
by attending one of the prerequisite introductory courses "
Introduction to Embedded Systems and Software" or
"
Introduction to Real-Time Operating Systems".]


COURSE OBJECTIVES

The primary goal of this course is to give the participant the skills necessary to do high-level design of software for
single-CPU real-time and embedded computer systems using a real-time operating system.  This is a very practical,
results-oriented course that will provide knowledge and skills that can be applied immediately.

For engineers more focused on multi-core multiprocessing software design, our course "
MultiCore Software
Architectural Design
" may be of more immediate interest.


COURSE CONTENTS

Day 1 - Morning:   Definitions / Real-Time Requirements

Embedded / Real-Time Systems: Definitions and Issues
Requirements Analysis: Context Diagram and Usage Scenarios
Quick Overview of Entity-Relationship Diagrams, State Transition Diagrams and StateCharts
What You Get in an RTOS, and What You Don't Get

Day 1 - Afternoon:   Identifying Tasks and Objects

High-Level Software Architecture: Concurrency
The Gomaa Guidelines for Decomposition into Tasks
Exercise: Heart Rhythm Monitor - Design Partitioning
Object Orientation for Embedded/Real-Time Software?

Day 2 - Morning:   16 Methods for Intertask Communication

The Correctness Killers: Deadlock, Lockout, Starvation
Software Architecture: Intertask Data Communication
Software Architecture: Intertask Synchronization

Day 2 - Afternoon:   Fine-Tuning of Intertask Communication

Mutexes: Priority Inheritance and Priority Ceiling
Modeling of Message Queues
Exercise: Queuing Calculations for Medical Device

Day 3 - Morning:   A Plethora of Design Examples

"Standard Circuits" for Real-Time and Multitasking Software Design
Design Patterns for Embedded Software
Optional: Design Patterns for Secure Software
Optional: Extended Example: Aircraft Fly-by-Wire

Day 3 - Afternoon:   Evaluating the Quality of a Multitasking Software Design

Evaluating Real-Time and Multitasking Software Designs
Some "
Design Skunks" in Real-Time Software
Performance Analysis: Individual Scenarios
Performance Analysis: Task Scheduling Theory and Calculations
Exercise: Medical System Performance Calculations

Final Examination.


INSTRUCTOR:  Dr. David Kalinsky
Check it out! Get the "flavor" of this course by perusing
a couple of the course's reading assignments:
"
Mutexes Battle Priority Inversions", or
"
Queueing Theory for Embedded Systems Designers"
Price of an On-Site Course
Schedule an On-Site Course
© Copyright 2013, D. Kalinsky Associates, All Rights Reserved.
This page Updated November 22, 2012
New