Embedded Systems Design Patterns From Ground Up™

Client-Server Design Pattern,Observer Pattern,Hardware Proxy Design Pattern etc

   Watch Promo

Hello, welcome to the "Embedded Systems Design Patterns " course.

This course teaches you how to apply design patterns to embedded firmware development. Design patterns are reusable solutions to commonly occurring problems in software development. Design patterns allow us to think about solutions in a more abstract way and therefore identify and underscore the important properties of the solution. Also, design patterns allow us to reuse solutions that have been proven to be effective in other similar circumstances.

The goal of this course is to provide a set tools for firmware developers to deal with commonly recurring firmware design issues. The course focuses on practical solutions by taking real-world problems and solving them using various design pattern solutions, examples such as data access in an ECG system using the Client-Server Design Pattern, IO device development using the Strategy Design Pattern, hardware portability using Hardware Proxy Design Pattern, Sensor Data Subscription and Notification Observer Design Pattern etc.

Here’s an overview of what you’re getting in this intermediate level course...

Getting started with embedded design patterns using the First-Class Abstract Data Type (ADT)

The first-class ADT allows us to hide the internals of a data structure so that clients using the data structure will not have access to the internals. You can think of it as a library where you don’t have the source but have access to only the exposed functions. We shall see how the First-Class ADT improves encapsulation and eliminates tight coupling.

In this section we learn how to implement the First-Class ADT from scratch. We shall:

  • Collect relevant addresses from the datasheet and create registers from them
  • Implement the device interface file
  • Implement the client APIs
  • Test out the First-Class ADT implementation.


Introduction to Design Patterns

Over here we shall provide a theoretical understanding of design patterns and provide some practical prerequisite that we shall need for the rest of the course.

Specifically, we shall :

  • Understand the basic structure of a design pattern, the name, the solution, the consequence etc.
  • Understand UML notations for interclass relationships
  • Understand bit masking and bit fields.

Hands-On Development with the STATE Pattern

The State pattern allows an object to change its behaviour when its internal state changes.Over here we shall demonstrate how to solve the same problem using three methods:

  • The conditional state machine .
  • Table-based state machine
  • State pattern implementation


By using this comparative approach, we will be able to clearly see the advantages of the State pattern.

Hands-On Development with the STRATEGY Pattern

The Strategy pattern allows us to extend and customise existing software code. This design pattern allows us to create objects which represent various strategies and a special object known as a context object. The behaviour of the context object changes based on its strategy object.

We shall see how to implement this in code.

Hands-On Development with the Hardware Proxy Pattern
The hardware proxy pattern uses a class to encapsulate all access to a hardware device, regardless of its physical interface.


Applying this design pattern reduces compatibility issues between hardware and clients when any changes to the hardware are introduced.

We shall analyse the UML diagram of this pattern and then implement this pattern in code.

Hands-On Development with the Hardware Adapter Pattern

The hardware adapter pattern is useful when the application requires one interface, but the actual hardware provides another. This pattern allows us to create an element that converts between the two interfaces.


In this section we shall employ a case study of developing an adapter for a trans-impedance amplifier (TIA) circuit and a light-to-frequency converter (LTF) circuit both of which provide the same information but different interfaces. We shall implement the hardware proxy design pattern in code to solve this issue.

Hands-On Development with the Client-Server Pattern
The client-server patten allows us to design a system with a single producer of data and multiple consumers. Over here we are going to demonstrate the effectiveness of the client-server pattern by implementing an ECG system with multiple modules, all of whom require access to the same data.
Hands-On Development with the Observer Pattern
The observer pattern is an improvement over the client-server pattern, over here a client simply needs to subscribe to a data source, as soon as there is new data in the data source, the client will be notified automatically, without the client reading the data source.


We shall see how to do all of this in code.


As always, this is….


Specially Designed For People Who Hate Copy/Paste

Listen. If you don’t like “Copy/Paste” you’re not alone. I can’t stand it either. I’d literally rather have a piece of code that I wrote from scratch that doesn’t work than someone else’s working code I copied and pasted.

And that’s why I’ve spent months designing and recording this course in which I show you how to locate every single register used and the meaning of every hexadecimal value written into the register.

Also, it comes with a money back guarantee, so you have nothing to lose.

Why don't you give it a try and see how it goes. You can always request a refund within 30 days of purchase.




Frequently Asked Questions


When does the course start and finish?
The course starts now and never ends! It is a completely self-paced online course - you decide when you start and when you finish.
How long do I have access to the course?
How does lifetime access sound? After enrolling, you have unlimited access to this course for as long as you like - across any and all devices you own.
What if I am unhappy with the course?
We would never want you to be unhappy! If you are unsatisfied with your purchase, contact us in the first 30 days and we will give you a full refund.
Do I get a certificate?
Yes, after a successful completion of the course.

Course Curriculum


  Setting Up
Available in days
days after you enroll
  Getting Started - Th First Class ADT
Available in days
days after you enroll
  Introduction to Design Patterns
Available in days
days after you enroll
  The STATE Design Pattern
Available in days
days after you enroll
  Developing Peripheral Drivers for Sensor Data Collection
Available in days
days after you enroll
  The Hardware Proxy Design Pattern
Available in days
days after you enroll
  The Hardware Adapter Design Pattern
Available in days
days after you enroll
  The Client-Server Design Pattern
Available in days
days after you enroll
  Observer Design Pattern (Publisher-Subscriber Pattern )
Available in days
days after you enroll
  Closing
Available in days
days after you enroll

Your Instructor


EmbeddedExpertIO™
EmbeddedExpertIO™

EmbeddedExpertIO represents a vibrant collective dedicated to the mastery of sophisticated embedded systems software development for professionals.

EmbeddedExpertIO stands as a premier source of tailored embedded systems development courses, catering to individuals and enterprises seeking to hone or acquire embedded firmware programming expertise. Our extensive course selections encompass beginner to advanced levels, addressing diverse facets of embedded systems development, such as WiFi, STM32, IoT systems design, memory safeguarding, and beyond.

Our core objective is to equip individuals and organizations with the indispensable skills to thrive in the swiftly evolving embedded systems sector. We achieve this by providing immersive, hands-on education under the guidance of seasoned industry specialists. Our ambition is to emerge as the favored learning platform for embedded systems development professionals across the globe.