Need Help? Contact us at:

support@embeddedexpert.io

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

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
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.

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.

NOT UNDERSTANDING THE CODE

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.

CODE NOT WORKING - WASTED TIME

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

CANNOT BUILD ANYTHING NEW -LACK OF CONFIDENCE, IMPOSTER

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