Start Date: 12/10/2023

Price 8,232 ILS


Course Overview

Many software engineers work with C and C++ (EC++) programming languages for real time and embedded development. This course aims to give them a fuller appreciation of the more advanced aspects of the languages in the real time and embedded environments.
Programming real time embedded systems make many special demands on the software engineer.  These include understanding compile, link and run-time issues, which are included in the course. It also covers real time programming issues that are specific to the C and C++ languages.
Most of the course is relevant to both C and C++ software engineers, though some special points relevant to C++ and object oriented are also presented.
The course is specifically aimed at issues relevant to real-time embedded software engineers.

Who should attend?

The course is designed for software engineers who want to improve their use of the C and / or C++ programming languages in a real time, embedded environment.


A good grasp of the fundamentals of C and/or C++. A good grasp of real time and embedded is an advantage.

Course Outline:

1. Introduction

2. Embedded C
• Real time C
• Embedded C
• Writing code in Kernel Space

3. Elements of C/C++
• Type Specifiers and Qualifiers
• Type coercion and conversion
• Struct layout
• Uses of union
• Bitfields
• Enum v #define
• Typedef
• Unscrambling declarations (cdecl)
• Floating-point and fixed-point number systems
• IEEE Standard 754
• Importance of good structure
• Quality and style

4. Effective Pointers
• Arrays and pointers; compatibility and incompatibility
• The principle of dynamic memory allocation
• Void pointers
• Implementing basic data structures: pointers, arrays, queues, stacks, lists
• Function pointers: basics, callbacks, state machine
• Optimizations with pointers
• Variable sized structures

5. Memory Management Architecture
• Caching
• Hardware memory management
• Sections of a program
• Mapping of program in memory
• Dynamic memory allocation

6. Intertask Communication
• Intertask Synchronization: Race Conditions and Critical Sections
• Shared Memory
• Locks
• Mutexes
• Semaphores
• Deadlocks
• Signals
• Message Queues

7. The Toolchain
• Pre-processor compiler directives and cross compilers
• Macros v functions
• The Linker and memory sections
• Using the toolchain to your advantage
• What happens before main
• What is happening at runtime
• Estimation of stack requirements

8. Optimizations
• Tips for optimizing embedded C/C++ code

9. Writing Safer C
• MISRA-C and CWE™
• Compiler warnings
• Hard learned pitfalls
• Coding style and banned API
• Preparing for debug

10. Hardware Programming Model
• Interrupts – handlers and dispatchers
• Hardware and Software interrupts
• Contexts

11. Timing
• The challenge in measuring time
• Hardware and Software timers
• Watchdog timer
• Real time debug vs. time

12. Object oriented C
• Implementing OOP with C (OOC)
• Mixing C and C++

13. Inheritance and OO Design
• Inheritance models
• The use of virtual functions

14. Embedded C++
• C vs. C++
• Benefits of embedded C++ (EC++)
• Restrictions for EC++

15. C++ Resource Management
• Managing contained members
• The Rule of the Big Three
• Garbage collection
• Smart pointers
• Resource managing classes

16. Templates and Generic Programming
• Understand the two meanings of typename
• Know how to access names in templatized base classes
• Parameter-independent code
• Traits
• Template metaprogramming

17. The Standard Template Library
• STL Components
• Containers
• Iterators
• Algorithms
• Using emplace
• Manipulating Algorithms
• Container Elements
• Extending the STL

18. Input/Output Using Stream Classes
• Common Background of I/O Streams
• Fundamental Stream Classes and Objects
• Standard Stream Operators << and >>
• Standard Input/Output Functions
• Manipulators
• Formatting
• Internationalization
• File Access
• Connecting Input and Output Streams
• Stream Classes for Strings
• Input/Output Operators for User-Defined Types
• The Stream Buffer Classes
• Performance Issues

19. Summary