Home › Services › Training › 5-day …

5-day course: Prog. Tech. for Reliable Embedded Systems (C)

Cars, aircraft, medical equipment through to fridges, TVs, MP3 players and even (wet) razors are all good examples of modern systems which contain embedded processors. Overall, it is usually estimated that for every desktop computer chip sold, 100 processors are sold for embedded systems.

As this field grows, there are many job opportunities available for individuals who understand how to develop software for reliable embedded systems.

Using a practical mixture of informal seminars and “hands on” training sessions, this 5-day introductory course has been designed to give you the key skills required to make rapid progress in this exciting field.

This course can be used as the first module on the MSc in Reliable Embedded Systems.

Where and when will this course be delivered next?

This course will be delivered as follows:

We have a maximum class size of 25 people on this course. Early booking is recommended.

Places can be reserved by e-mail (places will be confirmed on receipt of payment).

We can also deliver this course on your site at any time: please contact us for details.

Course brochure

Three course brochures are available:

Want to program in Ada?

Please note that this course is taught using the C programming language.

A similar course based on the Ada programming language will be available shortly.

Trainer biodata

Cover of Embedded C

This module will be delivered by Professor Michael J. Pont from the University of Leicester, UK.

Michael Pont holds a BSc (Electrical and Electronic Engineering) from the University of Glasgow and a PhD (Computer Science) from the University of Southampton. Michael is Professor of Embedded Systems and Head of the Embedded Systems Laboratory at the University of Leicester: he is also CEO of TTE Systems Ltd.

This year, Michael was the recipient of the “Best Presenter” award at the Embedded Masterclass.

Michael is author / co-author of more than 100 technical publications and author of three books (“Patterns for Time-Triggered Embedded Systems”, “Embedded C” and “Software Engineering with C++ and CASE Tools”).

Everyone who attends this module will receive a signed copy of Prof. Pont’s best-selling book “Embedded C”.

Price

In Malaysia, course fees are as follows:

  • RM 3500 per place.
  • For block bookings of 5 places (from a single organisation) the total fee is RM 13500.

In the UK, course fees are as follows:

  • £500 + VAT per place.
  • For block bookings of 5 places (from a single organisation) the total fee is £2100.

Please note that these are introductory rates: organisations / individuals can attend only a single training module at these rates: after taking a module at the introductory rate, the normal short-course fee is RM 10,500 (Malaysia), £1,500 + VAT (UK). Please contact us if you require further information about these restrictions.

In all cases, the fees will be refunded in full if you subsequently register for the MSc in Reliable Embedded Systems.

To ensure that the training is of the highest quality and that you gain maximum benefit from discussions with the trainers, the total class size is strictly limited to a total of 20 people.

The course fee includes:

The following refreshments are also provided (all included in the course fee):

  • Coffee / tea / water (available throughout the day)
  • Morning and afternoon snacks (including breakfast in Malaysia)
  • A full buffet or sandwich lunch

In short - everything is included: all you need to do is turn up, with your laptop computer and learn about embedded systems.

In Malaysia, the training takes places in the Executive Learning Centre at PSDC.

In the UK, the training takes place at the University of Leicester.

Please contact us for further details.

Pre-requisites

This is an introductory course. No previous experience with embedded systems is required.

Some previous programming experience in a high-level language (such as C, C++ or Java) is assumed at the start of the course. If you have not had this experience, suggestions for background reading can be provided.

Course objectives

After attending this course, participants should:

  • Understand what an embedded system is;
  • Have a good knowledge of the three key hardware platforms used to create modern embedded systems: microcontrollers, field-programmable gate arrays and “embedded PCs”;
  • Be able to write high-quality software for reliable embedded systems;
  • Understand how to test and debug existing embedded systems;
  • Understand the key concepts of “real-time” systems and the importance of timing behaviour when creating reliable embedded systems.
  • Be ready to join the MSc in Reliable Embedded Systems if they wish to do so.

Course contents

Day 1: An introduction to “Embedded C”

On Day 1, the world of embedded systems is introduced using a series of short seminars interleaved with practical sessions which are designed to reinforce the key concepts. C is the standard programming language for embedded systems: working with a processor simulator and an 8-bit target, you will learn how to create your first programs in “Embedded C”. Starting by flashing an LED, you will soon move on to learn how to create reliable code for working with switches and taking control of the real world. We’ll end the session by discussing the use of the MISRA C programming guidelines and the ways in which the use of this “safe subset” of the C language can assist in the creation of reliable systems (there’s a lot to take in: you’ll be provided with your own printed copy of these guidelines to review at your leisure).

Day 2: Real-time “Embedded C”

On Day 2, we move on to look at the need for simple operating systems, and the concepts of “real time” constraints. We consider and discuss concepts such as worst-case execution time, task jitter and time-out mechanisms. By the end of the day, you’ll have created and tested a complete set of code for your first realistic embedded systems.

Day 3: Exploring modern hardware platforms

In the first two days of this course, we focus on software development and you’ll work with a simple processor simulator to test your code. On Day 3, we move into the 21st century: you’ll by start creating code for a modern (32-bit) microcontroller with an ARM® processor core. After you’ve got your first system running, you’ll learn about debugging (including the use of JTAG) and timing analysis.

Modern embedded systems use a wide range of platforms. To round off Day 3, we’ll look at two further targets.

  • In recent years, the Intel® Atom processor has become the basis of many “embedded PCs”. We’ll consider some of the challenges involved in creating reliable systems based on this type of platform. As you’ll learn, your embedded PC will run happily without a “conventional” operating system (we won’t be using Windows® or Linux: instead we’ll be programming “at the bare metal” for maximum predictability and performance).
  • We’ll then go on to look at “Field programmable gate arrays” (FPGAs). FPGAs are already a popular implementation platform for developers of embedded systems (and some people believe that they will be the platform of choice for the majority of new systems within the next few years). We’ll introduce you to some of the challenges and opportunities offered by this exciting new platform. As you’ll see, FPGAs provide enormous flexibility, allowing you to create a custom processor target for every project.

Day 4: Working with multiple tasks

In Day 4, we begin to look at some more advanced topics, including issues associated with task design (including task pre-emption). We’ll start by considering the popular rate-monotonic (RM) and earliest deadline first (EDF) task scheduling algorithms for single-processor systems. We’ll go on to discuss some key design challenges for systems which involve task pre-emption and shared resources, including ways of avoiding “priority inversion”.

Day 5: Working with distributed systems

On Day 5, we’ll begin to consider some of the challenges involved in creating distributed embedded systems: that is, systems involving multiple processors connected in some form of network using (for example) a bus or star topology. We’ll consider key design issues, including ways in which we can synchronise the timing of tasks that are running on different nodes. Our focus will be on systems which employ the popular Controller Area Network (CAN) protocol.

Learning goals

  • To learn how to write reliable programs in “embedded C”;
  • To learn how to create reliable, power-efficient and cost-effective embedded systems using microcontrollers;
  • To learn how to use x86 processors (“embedded PCs) for prototyping and for low-volume production of very powerful embedded systems;
  • To learn how to create very flexible embedded systems using field-programmable gate arrays (FPGAs).

Methodology

This course is taught through a carefully-planned combination of seminars and practical (laboratory) classes. Problems will be set during seminars and in laboratory sessions. Case studies will be used extensively in the laboratory sessions.

Who should attend

The course is intended for anyone who is interested in working in the field of embedded systems. No previous experience of embedded systems is required, but some previous programming experience will be useful. The course will be particularly well suited for people with a technical background (e.g. mechanical engineering or “desktop” computer programming) who wish to retrain to take advantage of the huge employment opportunities in the field of embedded systems.

Links to the MSc programme in Reliable Embedded Systems

This course provides an ideal foundation for people who are interested in joining the University of Leicester’s MSc programme in Reliable Embedded Systems.