Need Help? Contact us at:

 Embedded Systems Design Patterns   From Ground Up™

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

 16+ hours | Complete Source Code Included

         Your free gift is on its way to your inbox, but before you go 
check out this very special offer, just for you!

                     Some Lesson Previews (2 of 65)

                                    Coding : Testing the Observer Pattern with Actual Sensors
                                  Coding : Writing the Interface file of the Fertilizer Mixer Client

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

This is an intermediate level course that will take your embedded systems development skills to the next level.
The focus of this course is the very important topic of design patterns.

Some of you may have heard of design patterns in professional software development.
Design patterns are reusable solutions to commonly occurring problems in software development. 

Design patterns allow us to reuse solutions that have been proven to be effective in other similar circumstances.

The question is, how do we apply design patterns to embedded firmware development? 

The goal of this course is to provide a set of 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.

Table of Content

  •  Setting Up Keil uVision 5
  • ​Download Keil uVision 5
  • ​Installing Keil uVision 5
  • ​Installing Packs
  • ​Changing the Compiler
  • ​Getting Started - Th First Class ADT
  • ​ Coding : Collecting Relevant Addresses from Datasheet
  • ​Coding : Creating Registers from Addresses
  • ​Coding : Implementing the Device Interface file
  • Coding  : Implementing Device Client APIs (PART I)
  • ​Coding : Implementing Device Client APIs (PART II)
  • Coding : Implementing Device Client APIs (PART III)
  • ​Coding : Implementing Device Client APIs (PART IV)
  • ​Introduction to Design Patterns
  • ​What is a Design Pattern ?
  • UnderStanding UML Notations
  • ​Coding : Understanding Bit Masking
  • ​Coding : Understanding Bit Fields
  • ​The STATE Design Pattern
  • ​Coding : Conditional Implementation of State Machines-Writing the Interface file
  • ​Coding : Implementing the first Time Source
  • ​Coding : Implementing the second Time Source
  • ​Coding : Implementing the Watch Functions
  • ​Coding : Testing our Implementation
  • ​Coding : Table-based State Machine Implementation
  • ​Coding : The STATE Pattern Implementation
  • ​The STRATEGY Design Pattern
  • ​Coding : The STRATEGY Design Pattern Implementation (PART I)
  • ​Coding : The STRATEGY Design Pattern Implementation (PART II)
  • ​Developing Peripheral Drivers for Sensor Data Collection
  • ​Coding : Developing a Driver for Collecting Digital Input Data
  • ​Coding : Developing a Driver for Collecting Analog Input Data
  • ​Coding : Developing a Driver for Reading the Internal Temperature of the MCU
  • ​The Hardware Proxy Design Pattern
  • ​Introduction to the Hardware Proxy Pattern
  • ​Coding : Writing the Hardware Proxy Interface files
  • ​Coding : Implementing the Hardware Proxy Functions
  • ​Coding: Writing the data Encoding and Decoding functions
  • ​Coding : Implementing more Hardware Proxy functions
  • ​Coding : Testing the Hardware Proxy solution
  • ​The Hardware Adapter Design Pattern
  • ​Introduction to the Hardware Adapter Pattern
  • ​Writing the Hardware Adapter Interface files
  • ​Coding: Implementing the Hardware Proxy functions
  • ​Coding : Implementing the Trans-impedence Amplifier(TIA) Adapter functions.
  • Coding : Implementing the Light-to-frequency (LTF) Adapter functions
  • ​Coding: Testing the Adapter with a Client
  • ​The Client-Server Design Pattern
  • ​Introduction to the Client-Server Pattern
  • ​Coding : Writing the server interface file
  • ​Coding : Writing the HistogramDisplay client interface file
  • ​Coding: Writing the ECG Module interface file
  • ​Coding : Writing the ECG Module functions
  • ​Coding : Writing the HistogramDisplay client functions
  • ​Coding : Writing the interface file of the SystemManager
  • ​Coding : Implementing the SystemManager functions
  • ​Coding : Testing the System with a Single Client
  • ​Coding : Writing the Interface file for the ArrythmiaDetector Client
  • ​Coding : Implementing the ArrythmiaDetector Client functions
  • ​Coding : Implementing the QRSDetector Client
  • ​Coding : Integrating multiple clients into to the System
  • ​Observer Design Pattern (Publisher-Subscriber Pattern )
  • ​Introduction to the Observer Pattern
  • ​Coding : Writing the Interface file for the Server
  • ​Coding : Implementing the Server functions
  • ​Coding : Writing the Interface file of the Fertilizer Mixer Client
  • ​Coding : Implementing the Fertilizer Mixer Client functions
  • ​Coding : Implementing the Display Client
  • ​Coding : Testing the Observer Pattern
  • ​Coding : Testing the Observer Pattern with Actual Sensors
 30 Day Money Back Guarantee
  • ​Embedded Systems Design Patterns From Ground Up ($59.99 Value)
Total Value: $59.99
But today, you're getting all of this...
For Only $49.99

Sometimes I could get my firmware to work but I couldn’t understand a large portion of the code.

I didn’t know what some of the registers were doing. "Why do we write this hexadecimal number into that particular register ?" I would often ask.

Other times I could understand every line of code in the firmware but couldn’t get the firmware to work.

Because I wasn’t good enough, I couldn’t build exactly what I wanted if there were no already made drivers and libraries out there that I could use. Worst of all I couldn’t even get another microcontroller to work apart from the microcontroller used in class.
Long story short, I overcame all of this....
I devised a plan to master the fundamentals...
Quickly read the sections of interest in the datasheet...
Created my own firmware development checklist...
Created my own study guide...

I started creating courses to help other people like yourself master embedded systems development in the most efficient way possible, no waste of time, no frustrations. There is no need for you to go through the same roadblocks and frustrations I went through  some years ago.

About Me

My name is Israel, some of you may have taken some of my embedded systems courses from other online platforms. This is my private channel. 

I have been writing embedded firmware for years, I have built embedded devices like consumer products and robotic arms like the one you see over here. I built this very one when I was a mechanical engineering undergraduate student some years ago.
Till date I have 
trained over 60,000 students in embedded
 firmware development online
...including third year undergraduate university students in-person.

If you taken any of courses before you will know I start from the absolute basics, I do not assume that the student has any prior knowledge of the topic the course. You will also know that by the end of the courses you understand the functions of every register used in developing the particular firmware or driver.

This method is the same for all of my published embedded systems course. 

Here are some of the reviews
My  courses have been reviewed by 1000+ students
  • ​Embedded Systems Design Patterns From Ground Up ($59.99 Value)
Total Value: $59.99
But today, you're getting all of this...
For Only $49.99