Robust Software for Embedded Systems
              2 Day 
                Course
              Embedded 
                software engineers employ design patterns to ensure that their 
                software is suitable for industrial and consumer use. Failure 
                detection and recovery is vital and the software must be designed 
                so that it can run continuously without the need for a reboot. 
                 
              These 
                techniques include the use of watchdog hardware to detect a deadlocked 
                system. Error handling mechanisms should be capable of reporting 
                the exact location of a software bug, even after the system has 
                been deployed. Memory management techniques need to ensure that 
                that a memory leak or stack overflow will not lurk like a timebomb 
                in a long-running system. Programmers need to be aware of real-time 
                pitfalls when using interrupts and an RTOS.  
              This course 
                is ideal for engineers who can write software, but are new to 
                embedded systems, especially if those embedded systems have safety 
                concerns or require high reliability.  
              The course 
                is based on ten years of experience writing embedded software 
                for life-critical medical equipment. The course has been developed 
                by Niall Murphy, author of the popular Murphy's Law column in 
                Embedded Systems Programming magazine. The course is available 
                on-site and is also part of our public training schedule. We are 
                always happy to discuss course customisation.  
              Related 
                magazine articles, authored by the course presenter,can be found 
                at Robust Programming Articles. 
              Audience
              This course is ideal for engineers who can 
                write software, but are new to embedded systems. 
              Content
                
              Introduction 
              
                - Definitions for 
                  Safety, Availability, Reliability
 
                - Graceful degradation 
                  
 
                - Industry magic bullets
 
               
              Data 
                Integrity Checks 
              
              Persistent Storage 
              
                
                  - Error Detection
 
                     
                  -  Double Buffering
 
                     
                  - Versioning
 
                 
                 
              Built-in Self-test 
                  
              
                
                  - RAM/ROM/address 
                    line tests
 
                     
                  - Loopback tests
 
                  - Cable and subassembly 
                    tests
 
                     
                 
                 
              Interlocks 
              
                
                  - Hardware limitations 
                    on software actions
 
                     
                  - Software limitations 
                    on user actions
 
                 
                 
              Exception Handling 
                and Asserts 
              
                
                  - Language Support
 
                     
                  -  Assert Macro
 
                     
                  - Debug code issues
 
                 
                 
              Memory Management 
              
                
                  - Static Allocation
 
                     
                  - Stack Measurement
 
                     
                  -  malloc and fragmentation
 
                     
                  - Pools
 
                     
                  - Detecting Leaks 
                    Interrupts
 
                 
                 
              Interrupts 
              
                
                  - Reentrancy
 
                     
                  -  Motivation
 
                     
                  - Parallelism
 
                     
                  - Timed Polling
 
                 
                 
              Real Time Operating 
                System 
              
                
                  - Tasking
 
                     
                  - Decomposition
 
                     
                  - Preemptive Kernels
 
                     
                  - Priority Inversion
 
                     
                  - Queuing
 
                  - Timing Accuracy
 
                 
                 
              Watchdogs 
              
                
                  - Goals
 
                     
                  -  Response to failure
 
                     
                  - Timeout Length
 
                     
                  - Self Test
 
                     
                  - Multi-tasking 
                  
 
                 
                 
              Mathematical Dangers 
                  
              
                
                  - Fixed Point Math
 
                     
                  -  Using spreadsheets 
                    for testing
 
                     
                  - Floating point 
                    equality
 
                 
                 
              Control Loop 
              
                - Monitoring vs. Control
 
                   
                -  Calibration
 
               
              Static Analysis 
                Techniques 
              
                
                  - lint
 
                     
                  - Hazard Analysis
 
                     
                  - Failure Mode Effects 
                    Analysis
 
                     
                  -  Design and code 
                    inspections
 
                 
                 
                
                |