Coursera Plus Annual Is 40% Off. Ends Soon!

Class Central is learner-supported. When you buy through links on our site, we may earn an affiliate commission.

Coursera

Embedded Build Systems with GNU Tools and Makefiles

Packt via Coursera

Go to class Write review

Overview

Google, IBM & Meta Certificates – 40% Off a Year
One Coursera Plus subscription covers most Professional Certificates on Coursera. 40% off a full year through Dec 2.
Unlock All Certificates
Move beyond IDE-driven workflows by configuring GNU Arm tools, linker scripts, startup files, CMSIS integration, and Makefiles for bare-metal STM32 firmware builds. Command-line build systems give embedded developers control over how firmware is compiled, linked, inspected, and automated. This course focuses on bare-metal STM32 development without depending on an IDE, helping learners understand the full path from source files to executable firmware. The course starts with development environment setup, GCC for Arm, OpenOCD, documentation, and memory-mapped register work. Learners then explore the GNU toolchain, build process, linker scripts, C startup files, Make, CMSIS integration, advanced Make techniques, and a semihosting-based ADC sensor-data project. Practical exercises reveal how linker scripts, startup code, binutils, and Makefiles work together in real projects. Learners gain confidence diagnosing build issues and automating firmware workflows; by the end of this course, they can build bare-metal embedded firmware from scratch using GNU tools and Make. Embedded developers, firmware engineers, and STM32 learners who want to understand and control the build process outside an IDE. Suitable for those with basic C and microcontroller knowledge who need practical experience with GNU Arm tools, linker scripts, startup files, and Makefiles. Learners work from the command line with a text editor, GNU tools, and Make. The course explains each build artifact before integrating it into a working firmware project. Examples move from registers and linking to CMSIS and sensor-data output. This course is based on Embedded Build Systems with GNU Tools and Makefiles, by Israel Gbati. This course is licensed and distributed by Packt. All rights reserved. Packt is one of the world's most prolific publishers of cutting-edge technical content. For over two decades we've made it our mission to curate and publish the knowledge of only the very best technical experts. We focus on real-world courses that help our customers get the job done, with coverage that extends across a wide range of established and cutting-edge technical topics. If you're an individual or an organisation that embraces learning by doing, Packt is the perfect fit for you.

Syllabus

  • The Development Environment
    • This module provides an in-depth look at setting up and understanding the development environment for embedded systems. Learners will explore firmware development methodologies, essential tools, and practical setup procedures. By the end, they will be able to configure a functional development workspace.
  • Constructing Peripheral Registers from Memory Addresses
    • This module focuses on setting up development environments, understanding hardware documentation, and configuring peripheral registers for embedded systems. Learners will gain hands-on skills in using technical documentation, setting up IDEs, and implementing firmware for microcontrollers.
  • Understanding the Build Process and Exploring the GNU Toolchain
    • This module provides an in-depth look at the build process for embedded systems, focusing on the GNU toolchain and its components. Learners will gain hands-on understanding of compiling, linking, and analyzing object files for ARM Cortex-M projects. The content covers practical workflows and key tools used in firmware development.
  • Developing the Linker Script and Startup File
    • This module provides an in-depth exploration of linker scripts and startup files in embedded systems, covering memory mapping, section placement, symbol definitions, and practical implementation techniques. Learners will gain hands-on experience with building and verifying custom firmware components using structured, firmware-focused workflows.
  • The Make Build System
    • This module introduces learners to the fundamentals of the Make build system, covering how to set up, configure, and automate software builds using makefiles. It focuses on practical skills like defining variables, testing build processes, and troubleshooting common issues in firmware development.
  • Integrating the Cortex-M Software Interface Standard (CMSIS)
    • This module provides an in-depth understanding of the CMSIS standard and its role in embedded systems development. Learners will explore the integration of CMSIS components, including GPIO drivers, and gain hands-on experience with firmware setup and implementation on ARM Cortex-M microcontrollers.
  • More Techniques on Using Make
    • This module covers advanced techniques for using Make in firmware development, including organizing output folders, generating map files, integrating CMSIS, and building with assembly and C++ source files. Learners will gain practical skills in structuring and managing embedded build systems effectively.
  • Sending ADC Sensor Data Using Semihosting
    • This module explores the process of converting analog sensor signals into digital data using ADC and implementing it in embedded systems. It covers configuring ADC modes, developing drivers, and interfacing with display hardware using semihosting. Learners will gain hands-on experience with firmware development and sensor data visualization.

Taught by

Packt - Course Instructors

Reviews

Start your review of Embedded Build Systems with GNU Tools and Makefiles

Go to class

Never Stop Learning.

Get personalized course recommendations, track subjects and courses with reminders, and more.

Sign up for free
Someone learning on their laptop while sitting on the floor.