Course Highlights:
A 5 day course introducing, at a basic level, all fundamental skills required to develop real-time embedded software in a commercial environment.

Delegates will learn:

• The characteristics of real-time systems
• Steps in developing software
• Programming issues - which languages?
• Why design and diagramming is so important
• Design basics - object oriented vs structured techniques
• Development tools
• Real-Time Operating Systems and what they do for us
• Documentation, coding and testing
• Safety and mission critical systems
• Performance engineering basics

Course Objectives:

• To provide basic level information on all topics of software development e.g. programming, design, testing, documentation etc.
• To teach all these aspects in the context of real-time embedded software development.
• To give you the grounding required to start working in the development of real-time embedded software

Who Should Attend:
This course is particularly suited to the following candidates who require a principle foundation in the fundamentals of embedded software development.

• electronic engineers now moving into the field of software development
• graduates without experience of developing real-time embedded systems
• engineers transferring to real-time embedded software development from other disciplines

Pre-Requisite:

A basic level of programming experience.

Course Outline:

What is a real-time system?
- Characteristics of real-time systems
- Problems of real-time embedded development

Writing dependable software
- Why embedded software must be robust
- How errors are introduced

A process for software development
- Different software lifecycles
- Waterfall
- V model
- Iterative and incremental
- The importance of requirements capture
- Fitting a process into your organisation

Design basics
- Design fundamentals
- The building blocks of design
- Structured vs. OO techniques
- The importance of design reviews
- Design patterns - what and why?

Operating Systems for Real-Time Applications
- Basic features of real-time operating systems.
- Scheduling - concepts and implementation issues.
- Control of shared resources - mutual exclusion, semaphores and monitors.
- Task communication and synchronisation features.
- Memory management in embedded systems.
- Outline structures and features of modern operating systems.
- An introduction to Posix.

Design Notations
- Structured notation
- UML - the standard OO notation
- Extensions to notations for real-time - What and why
- Fitting diagrams into your design process

Programming Languages
- What languages are suitable for embedded development?
- A comparison of their strengths and weaknesses
- Is Java suitable for embedded development?
- Code development and packaging
- Moving from design into code
- The importance of coding standards

Testing
- Unit test
- Module test
- Systems test
- Acceptance testing
- Static and Dynamic analysis of code
- Dynamic analysis of code
- Code walkthroughs
- White box and Black box testing
- Code and design metrics

Development Tools
- Compilers & Debuggers
- Debugging on the host
- Debugging on the target
- Emulators & Probes
- Case tools
- Requirements tools
- Configuration management tools

Mission Critical and Safety Critical Systems
- System specification aspects.
- Application software aspects
- Real-world interfacing
- Operating systems aspects
- Numerical issues
- Processor problems
- Hardware-based fault-tolerance
- System specification aspects

Documentation
- Why?
- What documents come from the design process
- User documentation
- Source code aspects
- Quality control
- A process for managing change
- Configuration management
- Library management

Software Re-use
- Can it be achieved?
- How can it be managed?
- Designing for re-use
- Testing re-used code

Continuous improvement
- Measuring the development process
- Quality standards
- ISO9001
- Tick IT
- The Capability Maturity Model CMM