Need Help? Contact us at:

Embedded Build Systems with GNU Tools and Makefiles

| Extreme Embedded Development |

10+ 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!

No  Integrated Developed Environment (IDE)  used :  just the command line, a text editor and makefiles.
Have you ever wondered what it is like to develop embedded firmware without using any IDE- just a simple text editor and the command line ?

Have you heard of build systems like Make, if so have you ever wondered how these tools can be applied to embedded firmware development to automate the build process? 

If you have no idea of what build systems like Make are, do you want to learn about them from scratch and apply them to your embedded firmware development ?

Preview #1
Lesson  : Writing the StartUp file(Pt.3)
In this lesson we complete the implementation of our startup.c file by writing the Reset_Handler()
Preview #2
Lesson :  Exploring the GNU Bin Tools- Analyzing Object files
In this lesson we shall see how to analyze an object file using the objdump tool the comes with our GNU Toolchain.
If any of this applies to you then keep reading this overview of our new course :

       Extreme Embedded Bare-Metal Development

The goal of this course is to teach you how to set up an embedded toolchain, set up a build system, and then navigate the reference manual and datasheet of the tools as well the target microcontroller to develop firmware for the target microcontroller without using any IDE (Integrated Development Environment), libraries or third party header files.

Exactly What You're Getting

This is dramatically different from any course you have ever taken because like many of my courses, this is more of a professional hands-on “field guide” to stm32 extreme bare metal firmware development. The reason why is because there’s no fluff or filler. It immediately gets down to the actual subject, showing you exactly what to do, how to do it, and why.

Plus, it’s easy.

And you’ll immediately “get” the entire mythology I personally use to build firmware for consumer devices in my professional life.

It's About MORE Than Just Getting the Code to Work
If at least one of the following applies to you then keep reading if not then simply skip this course:

" Escape From "

  • Using Integrated Development                                          Environments (IDE)
  • ​Copying/Pasting code you don’t understand
  • Using third party libraries and header files                like HAL, LL and StdPeiph
  • Experiencing bugs you don’t understand
  • ​Being afraid of technical documentations                  like the reference manual and datasheet of               the chip
  • ​Imposter syndrome

" Arrive At "

  • Using no IDEs- applying build systems like                 Make
  • Write your own Linker Script
  • ​Write your C Startup file​
  • ​Build every single line of code from scratch               by writing to the microcontroller’s memory               space directly.
  • Use No third party libraries or header files
  • Understand and write every single line of                   code yourself- no Copy/Paste
  • ​Use the debugger effectively to analyze                       and  resolve any bugs
  • ​Develop proficiency in your embedded                         development skills and confidently take                       the next steps
So like I said, there’s more than just getting each piece of code to work. 

Here’s an overview of what you’re getting...
Understanding the Build Process:
In order to be able to truly develop firmware from scratch we need to understand what goes on
at each and every stage as the .c and .h source files are being converted to .elf executables. We will analyze the Preprocessing Stage -> the Compiling Stage -> the Assembling Stage ->the Linking Stage  all the way to the Locator Stage.
Writing the Linker Script:
To be able to properly merge the various source files and place different sections of the source files into different memory regions of our target microcontroller we need to write our own linker script to tell the linker the different regions and sizes of memory available on our target microcontroller and also in which regions of memory we want to store specific sections of the source code.
Writing the C Startup file
The Reset_Handler is the first function to be executed when microcontroller comes out of reset. We will have to define this function in our C Startup file. We will also have to define the vector table in this same file.
Automating the Build Process with Make
A Build System is a piece of program that takes source code as input and produces a deployable software as output. Make is one of the popular Build Systems out there. We shall learn how to automate our build process with Make.
Analyzing the chip documentations:
Before developing the firmware for any chip you have to learn how to read the documentation provided by the chip manufacturer.
Defining address for the different peripheral:
All components on the microcontroller have an address range.To write to a component or read from a component you need to locate its address range in the documentation and properly define the addresses in your code.
Creating registers from the address:
The addresses in the address range of a component represent the registers of that component. To access these registers you have effectively typecast the addresses.
Understanding CMSIS:
Cortex-Microcontroller Interface Standard (CMSIS)CMSIS is a standard developed by Arm for all Cortex-Microcontrollers. This is the standard used in professional firmware development.
By the end of this course...

You Will Be Able To :

  • Build complete firmware without using an Integrated Development Environment (IDE)
  • ​Write your own Linker Script
  • Write your own C Startup file
  • ​Effectively apply GNU Bin Tools
  • ​Effectively apply Build Systems like Make to your Embedded Development
  • ​Effectively write your own Makefiles to automate the Build Process in your Embedded Projects
  • ​Build every single line of code from scratch by writing to the microcontroller’s memory space directly.
  • ​Use No third party libraries or header files
  • ​Develop proficiency in your embedded development skills and confidently take the next steps
  • ​Define addresses for the different peripherals
  • ​Analyze the chip documentation
  • ​Create registers from the addresses

Table of Contents

  • Development Environment
  • ​Ways of Firmware Development
  • ​Tools of the Trade
  • ​Overview of the Development Environment
  • ​Installing GCC for Arm
  • ​Setting Up OpenOCD
  • ​Constructing Peripheral Registers from Memory Addresses
  • ​Getting the best out of this course
  • ​Downloading our Integrated Development Environment (IDE) for Control Experiment
  • ​Installing an Integrated Development Environment (IDE) for Control Experiment
  • Getting the right Documentation for Bare-Metal Development
  • ​Programming : Locating the Ports and Pins of Components on the Nucleo board
  • ​Defining Addresses of Modules using information from the Documentation
  • ​Programming : Creating required Registers using Information from Documentation
  • ​Programming : Configuring Pins using the Registers we Created
  • ​Programming : Creating Registers from Structure Members
  • ​Understanding the Build Process and Exploring the GNU Toolchain
  • ​​Understanding the Build Process
  • ​Overview of Some GNU Bin Tools
  • ​Programming : Observing the Build Process from IDE Perspective
  • ​Compiling and Linking Existing Source files using the GNU Arm Toolchain
  • ​Programming : Exploring the GNU Bin Tools - The Compiler
  • ​Programming : Exploring the GNU Bin Tools - Adding Options for Arm Cortex
  • ​Programming : Exploring the GNU Bin Tools - Stopping After Compilation
  • ​Programming : Exploring the GNU Bin Tools - Analyzing Object files
  • ​Developing the Linker Script and Startup File
  • ​Understanding the Memory Model and Linker Script
  • ​Getting familiar with some Linker Commands
  • ​Analyzing the Linker Script Generated by CubeIDE
  • ​Understanding Linker Constants
  • ​Programming : Writing the Linker Script (Pt.1)- Memory Definition
  • ​Programming : Writing the StartUp file (Pt.1)- Creating the ISR Vector Section
  • ​Programming : Writing the StartUp file (Pt.2)- Populating the Vector Table
  • ​Programming : Verifying the Creation of the Custom Section
  • ​Understanding the load Memory of different Sections
  • ​Programming : Writing the Linker Script (Pt.2)- Merging Sections
  • ​Understanding Linker Symbols
  • ​The Location Counter
  • ​Example of a simple Linker Script
  • ​Programming : Writing the Linker Script (Pt.3)- Creating Symbols
  • ​Programming : Writing the Linker Script (Pt.4)- Testing the Linker Script
  • ​Programming : Writing the Linker Script (Pt.5)- Aligning Memory Sections
  • ​Programming : Writing the StartUp file (Pt.3)- Writing the Reset_Handler
  • ​Programming :Testing the Linker Script on the Target
  • ​Programming : Flashing the Target using GDB Client
  • The "Make" Build System
  • ​Introduction to Build Systems and Makefiles
  • ​Setting Up Make
  • ​Programming : Automating the Build Process using Make
  • ​Programming : Using Variables in Makefiles
  • ​Programming : Testing the Makefile
  • ​Integrating the Cortex-M Software Interface Standard (CMSIS)
  • ​Introduction to CMSIS and It's Components
  • ​Understanding the CMSIS Standard
  • ​Overview of ARM Cortex-M General Purpose Input/Output Module
  • ​More Techniques on Using Make
  • ​Programing : Integrating CMSIS into our Firmware
  • ​Programing : Creating Output Folders with Make
  • ​Programming : Generating Map files into Output Folders
  • ​Programming : Using Folder Variables and Input Folders
  • ​Programming : Building with Assembly Source files
  • ​Programming : Building with C++ Source files
  • ​Sending ADC Sensor Data using Semihosting
  • ​Introduction to Analog to Digital Conversion
  • ​Understanding ADC Independents Modes
  • ​Programming : Developing the ADC Single Conversion Driver
  • ​Programming : Developing the ADC Continuous Conversion Driver
  • ​Programming : Displaying Sensor Data with Semihosting (Pt.1)
  • ​Programming : Displaying Sensor Data with Semihosting (Pt.2)

Specially Designed For People Who Hate 

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. 
Although the course explains every single line of code .... you will also get

Access to the EmbeddedExpertIO Forum

where you can ask questions and discuss embedded systems topics.

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.
Our courses have been reviewed by 1000+ students
Here are some of the reviews

 30 Day Money Back Guarantee

Now it's time for you also to benefit from the...

Modern Embedded-C 
From Ground Up

Here's a recap of


When You Purchase This AMAZING Offer!

  • 1. Extreme Embedded Bare-Metal Development  ($69.99 Value)
  • Duration: 10+ hours
  • Resources: Lifetime access to videos + Complete source code
Total Value: $69.99
But today, you're getting all of this...
For Only $29.78