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

"Embedded Software Fundamentals" Masterclass

*  Comprehensive Training on Embedded Fundamentals for new Embedded Software Developers

*  4- or 5- Day Intensive Class       (with student work exercises)
MASTERCLASS OVERVIEW

This Masterclass introduces the concepts shared by most embedded systems and their software.  It also introduces
the techniques used in the development of embedded multitasking application software, including real-time operating
systems, and debugging techniques specific to real-time and embedded software.

The Masterclass begins with the fundamental elements of embedded systems hardware and software, including their
design and development.  Fundamental processor and operating system concepts relevant to multitasking systems
are introduced, with focus on the basic services provided by off-the-shelf real-time operating system ("RTOS") kernels.

The Masterclass then introduces the students to multitasking application software design.  Design approaches are
shown for soft- and hard- real time systems.  In addition, development and debugging tools are studied.  The special
facilities of the "C" programming language for embedded software development are surveyed, as well as more
disciplined approaches to "C" language programming for use in critical systems.

The Masterclass concludes with an extensive 2-day session on the "Top 50" bugs in embedded software, and tools
and techniques that are used to deal with them.


WHO SHOULD ATTEND ?

This Masterclass is intended for practicing software developers who are transitioning into embedded systems
software development.   Masterclass participants are expected to be knowledgeable in the C programming language
for general applications.

This is technical training for engineers working in industry with less than a year of experience in the specifics of
embedded systems development.  [For those with more experience, we recommend the advanced course
"
Architectural Design of Real-Time Software"  .]


MASTERCLASS OBJECTIVES

The primary goal of this Masterclass is to give the participant the concepts and skills necessary to develop software
for embedded computer systems, including the use of a real-time operating system and debugging tools and
techniques.  This is very practical, results-oriented training that will provide knowledge and skills that can be applied
immediately.


MASTERCLASS STRUCTURE

This Masterclass is an amalgam of sections of the following 3 courses:
For on-site ("in-house") presentation, the selection of sections of these 3 courses taken for inclusion into the
Masterclass can be tailored to the specific needs of your company.


MASTERCLASS CONTENTS

Embedded Systems Basics

Embedded Computer Systems Overview
Embedded Systems I/O
Embedded / Real-Time Systems: Definitions and Issues
Introduction to Embedded Software Development: The Host-Target Dichotomy
Survey of Task Schedulers

RTOS Kernel Basics

Introduction to Real-Time Operating Systems
Task States and Task Scheduling
Exercise: Multitasking
Introduction to Intertask Communication and Synchronization
Message Passing from Task to Task
Exercise: Messages and Message Queues
Semaphores and Shared Data
Exercise: Binary Semaphores
Liveness Issues: Deadlock, Lockout, Starvation

Additional RTOS Services

Mutexes
Exercise: Priority Inversion
RTOS Timers
RTOS Events
Dynamic Memory Allocation
Memory Protection
Interrupt Handling in an RTOS Environment

Designing and Developing Embedded Applications

Partitioning of Software into Tasks
Schedulability Issues: Hard vs. Soft Real-Time
Rate Monotonic Scheduling
Embedded Device Driver Development
Testing: Black Box Approaches
Testing: White Box Approaches
Exercise: White Box Test Planning (as per DO-178B avionic software standard)
"C"-Language in Embedded Systems
Overview of MultiCore MultiProcessing

Debugging Embedded Applications

What is a Bug ?
The Debugging "Cookbook"
9 Golden Guidelines for Debugging
A Taxonomy of Real-Time / Embedded Bugs
Exercise: Bugs when Porting to New Hardware

David's "Top 5"  Real-Time Bugs

Stack Overflows
Race Conditions
Deadlocks
Timing Problems
Re-entrancy Conditions

Real-Time Debugging Tools and their Limitations

Where Traditional Debugging Techniques are Insufficient
The Correctness Killers: Violations of Liveness
Deadlock: 4 Ingredients, and 8 'Fixes'
Task Lockouts and Starvations
The 3 Classes of Real-Time Software Debuggers
Cutting Edge Debuggers: Time-Reversal, SensorPoints
Logic Analyzers
Post-Mortem Debugging
Exercise: Bug in a Real-Time Controller

Mindsets for Debugging Real-Time Software
Cause and Effect: The Scientific Method
Assertions and Invariants
Memory Allocation/De-allocation Bugs
Proactive Debugging Techniques

Bugs in Multi-tasking and ISRs: The Mis-use of RTOS's

Task Decomposition and Communication Defects
Multi-tasking Debugging Techniques
Interrupt Service Routine Design Defects
RTOS Usage Defects
Exercise: Bug in Interrupt Handling

Programming Bugs in Real-Time Software

C-Language Ambiguities and Coding Disciplines
C-Language Code Analysis and Tools
Static vs. Dynamic Code Analysis
Exercise: C-Language Shenanigans
The JPL "Power of 10" Coding Rules
Metrics Predict Bugs
Exercise: Cyclomatic Complexity

Final Examination.


INSTRUCTOR:  Dr. David Kalinsky
Price of an On-Site Course
Check it out! Get the "flavor" of this course by trying one of the
course's classroom lectures in on-line format:
Sample Lecture
Schedule an On-Site Course
© Copyright 2010, D. Kalinsky Associates, All Rights Reserved.
This page Updated February 18, 2010
New
New