We may earn an affiliate commission when you visit our partners.
Course image
Israel Gbati and BHM Engineering Academy

Are you tired of Copying and Pasting code you don't understand?

With a programming based approach, this course is designed to give you a solid foundation in bare-metal firmware development for  ARM-based microcontrollers . The goal of this course is to teach you how to navigate the microcontroller reference manual and datasheet to extract the right  information to professionally  build peripheral drivers and firmware. To achieve this goal, no libraries are used in this course, purely bare-metal embedded-c and register manipulations.

Read more

Are you tired of Copying and Pasting code you don't understand?

With a programming based approach, this course is designed to give you a solid foundation in bare-metal firmware development for  ARM-based microcontrollers . The goal of this course is to teach you how to navigate the microcontroller reference manual and datasheet to extract the right  information to professionally  build peripheral drivers and firmware. To achieve this goal, no libraries are used in this course, purely bare-metal embedded-c and register manipulations.

Still keeping it simple, this course comes in different ARM Cortex-M development boards  so that students can put the techniques to practice using an ARM Cortex-M development board of their choice. This version of the course uses the STMicroelectronics  STM32F7-NUCLEO which has an ARM Cortex-M7 microcontroller.

So with that understood, let me tell you…

                                                                                     Exactly What You’re Getting

This is dramatically different from any course you have ever taken because it’s more of a professional hands-on “field guide” to stm32 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

See, this course will change your professional life forever. Here is what one student had to say about the 1st version (STM32F4) of the course :

  "I would suggest this course for all the beginners. The concepts have been covered in the right sequence.And also the best part of this lecture series is getting to know how to explore the reference manual and datasheets."

Here is what another student had to say :

    "Extremly helpful to get to understand the uC programming deeper. For me it is much easier from now to develop code because I undertstand the base behind, so I'm more confident and more experienced to develop and debug the code. Really, this course is very useful to link the hardware knowledge with the coding skills. This fills the gap between them. Thanks for it. :)"

A third student :

"I am a professional semiconductor chipset application engineer with 30 years in global embedded product design in system applications. I can say this teacher is very straight forward by sharing his many years knowledge to the students with his true heart. Yes. I love his teaching pace and style. "

                                                     The First Version (STM32F4)  is being Taken by 5000+ Students with 1000+ Reviews

If at least one of the following applies to you then keep reading if not then simply skip this course:

" Escape From "

  1. Copying/Pasting code you don’t understand

  2. Using third party libraries and header files like HAL, LL and StdPeriph

  3. Experiencing bugs you don’t understand

  4. Being afraid of technical documentations like the reference manual and datasheet of the chip

  5. Imposter syndrome

" Arrive At "

  1. Building every single line of code from scratch by writing to the microcontroller’s memory space directly.

  2. Using No third party libraries or header files

  3. Understanding and writing every single line of code yourself- no Copy/Paste

  4. Using the debugger effectively to analyze and resolve any bugs

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

  • 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 Peripheral address

    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

But it gets better because you’re also getting…

                                                         Deep Lessons on Developing Peripheral Drivers

You will learn how to develop bare-metal drivers for the following peripherals :

  • Analog-to-Digital Converter (ADC)

  • Serial Peripheral Interface (SPI)

  • Inter-Integrated Circuit (I2C)

  • Nested Vector Interrupt Controller (NVIC)

  • General Purpose Timers (TIM)

  • System Tick Timer (SysTick)

  • General Purpose Input/Output (GPIO)

                                                           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.

Enroll now

What's inside

Learning objectives

  • Write firmware using only bare-metal embedded-c
  • Understand the cortex-m architecture
  • Write bare-metal adc drivers for the stm32f7 microcontroller
  • Write bare-metal timer drivers for the stm32f7 microcontroller
  • Write bare-metal uart drivers for the stm32f7 microcontroller
  • Write bare-metal interrupt drivers for the stm32f7 microcontroller
  • Write bare-metal gpio drivers for the stm32f7 microcontroller
  • Write bare-metal spi drivers for the stm32f7 microcontroller
  • Write bare-metal i2c drivers for the stm32f7 microcontroller
  • 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
  • Define addresses for the different peripherals
  • Analyze the chip documentation
  • Create registers from the addresses
  • Show more
  • Show less

Syllabus

Getting Started - Constructing Peripheral Registers from Memory Addresses
Downloading our Integrated Development Environment (IDE)
Installing our Integrated Development Environment (IDE)
Read more

Traffic lights

Read about what's good
what should give you pause
and possible dealbreakers
Focuses on bare-metal programming, which is essential for embedded systems engineers who need fine-grained control over hardware resources
Covers a range of peripheral drivers, including ADC, SPI, I2C, and UART, which are commonly used in embedded systems development
Emphasizes understanding chip documentation and register manipulation, which are crucial skills for working with microcontrollers at a low level
Requires students to acquire an STM32F7-NUCLEO development board, which may present a barrier to entry for some learners
Teaches CMSIS, a standard developed by ARM, which is widely used in professional firmware development and promotes code portability
Avoids third-party libraries, which forces learners to build drivers from scratch and may be challenging for beginners without prior experience

Save this course

Create your own learning path. Save this course to your list so you can find it easily later.
Save

Reviews summary

Deep dive into stm32f7 bare-metal

According to learners, this course offers a deep dive into bare-metal programming for the STM32F7, specifically focusing on understanding and manipulating peripheral registers directly rather than relying on standard libraries like HAL. Many appreciate the practical, hands-on approach and the emphasis on reading and using manufacturer documentation. The instructor is widely praised for clear, detailed explanations. However, students consistently note that the course is challenging and requires a solid foundation in C and potentially prior embedded experience, making it less suitable for absolute beginners. While it provides a strong understanding, some feel the pace can be fast or that certain topics could benefit from more detailed code explanations or examples.
Material is difficult but rewarding.
"It's challenging, but the hands-on examples make it click."
"Requires patience and dedication. It's a true bare-metal approach."
"If you stick with it, you learn a ton about STM32F7."
Thorough explanation of registers.
"The register explanations are thorough..."
"...explaining every register bit by bit."
"Showing you how to locate every single register used and the meaning of every hexadecimal value written into the register."
Emphasizes coding from scratch.
"The labs are very practical and build confidence. Best bare-metal course I've found."
"I finally understand the base behind, so I'm more confident and more experienced to develop and debug the code."
"The hands-on examples make it click. Highly recommend for anyone serious about embedded."
Instructor is knowledgeable and clear.
"The instructor is very knowledgeable and presents the material very clearly."
"Instructor is excellent, explaining every register bit by bit."
"Fantastic instructor and material. I've been trying to learn bare-metal for ages, and this course finally made it possible."
"His teaching pace and style is great."
Focuses on registers, not libraries.
"The course delivers on its promise of showing you how to program these devices without relying on any external libraries."
"Excellent deep dive into bare metal programming and how to use documentation."
"I really enjoyed learning how to do bare metal programming without using HAL or any libraries."
"Finally understand *why* we do things this way instead of just using HAL."
Not for absolute beginners.
"It's okay, but definitely not for beginners. You need a solid C background and some prior embedded knowledge."
"Found it too difficult. The instructor assumes too much prior knowledge."
"This course is not for total beginners in C or embedded systems."
"You need to have some programming experience in C."

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in ARM Cortex-M7 STM32F7 Bare-Metal Programming From Ground Up™ with these activities:
Review Embedded C Concepts
Reinforce your understanding of C programming concepts, especially those relevant to embedded systems, to prepare for the bare-metal coding in this course.
Browse courses on Embedded C
Show steps
  • Review pointers and memory management in C.
  • Practice bitwise operations and data structures.
  • Study compiler directives and header files.
Read 'Embedded Systems Architecture' by Daniele Lacamera
Gain a deeper understanding of embedded systems architecture to complement the practical coding aspects of the course.
Show steps
  • Read the chapters on memory management and peripheral interfaces.
  • Take notes on key concepts and architectures.
Implement Basic Peripheral Drivers
Practice writing basic drivers for peripherals like GPIO and UART to solidify your understanding of register manipulation and memory mapping.
Show steps
  • Write a simple GPIO driver to toggle an LED.
  • Implement a basic UART driver to send characters.
  • Test your drivers using a debugger.
Four other activities
Expand to see all activities and additional details
Show all seven activities
Follow STM32F7 Tutorials
Explore online tutorials and example projects for the STM32F7 to gain practical experience and learn different approaches to solving common embedded programming challenges.
Show steps
  • Search for tutorials on specific peripherals (e.g., ADC, SPI).
  • Follow the tutorials and adapt the code to your own projects.
  • Document your learning and any modifications you make.
Develop a Simple Data Logger
Apply your knowledge to build a data logger that reads sensor data using ADC, stores it in memory, and transmits it via UART.
Show steps
  • Configure the ADC to read sensor data.
  • Implement a circular buffer to store the data.
  • Write a UART driver to transmit the data to a computer.
  • Test and debug the data logger.
Contribute to an STM32 Open Source Project
Contribute to an existing open-source project related to STM32 microcontrollers to gain experience working in a collaborative environment and learn from experienced developers.
Show steps
  • Find an open-source project on GitHub or GitLab.
  • Identify a bug or feature to work on.
  • Submit a pull request with your changes.
  • Respond to feedback from the project maintainers.
Read 'Making Embedded Systems' by Elecia White
Learn about best practices in embedded systems development to improve the quality and maintainability of your code.
Show steps
  • Read the chapters on debugging and testing.
  • Apply the principles to your own projects.

Career center

Learners who complete ARM Cortex-M7 STM32F7 Bare-Metal Programming From Ground Up™ will develop knowledge and skills that may be useful to these careers:
Embedded Systems Engineer
An Embedded Systems Engineer designs, develops, and tests embedded systems, which are computer systems with a dedicated function within a larger device. This role requires a deep understanding of hardware and software interaction, which is precisely what this course provides by teaching students to write bare-metal firmware and manipulate hardware registers directly. This course will be particularly beneficial to those wishing to understand how microcontrollers function at their core, enabling them to create optimized and efficient systems. This emphasis on coding directly, without relying on third-party libraries, means that an Embedded Systems Engineer will be able to precisely control the behavior of the microcontroller and debug issues effectively. The practical lessons in developing drivers for peripherals like ADC, UART, and SPI will be directly applicable to this role.
Firmware Engineer
A Firmware Engineer develops the low-level software that controls hardware devices. This course is directly relevant to this career path because it focuses on bare-metal firmware development for ARM-based microcontrollers. It emphasizes working directly with memory addresses and device registers rather than using libraries, which is a core aspect of the work a Firmware Engineer does. This course helps build a foundation in understanding how to read datasheets and reference manuals to extract the necessary information to create peripheral drivers and firmware. By learning to develop drivers for peripherals such as GPIO, ADC, and UART, future Firmware Engineers will gain the skills necessary to confidently develop firmware for various embedded devices. The course’s approach of not using third-party libraries and getting to the root of low-level programming will be very useful.
Hardware Engineer
A Hardware Engineer designs, develops, and tests physical components of computer systems and devices and would benefit greatly from this course. While they typically focus on the physical aspects of hardware, an understanding of how to program and interface with it at a low-level helps build essential knowledge. This course provides the necessary skills in low-level interactions, by teaching how to create peripheral drivers and manipulate microcontroller registers. Specifically, the course's focus on bare-metal programming will enable Hardware Engineers to better understand the software side of the hardware they are designing. This deeper understanding will make them better collaborators on the design team.
Robotics Engineer
A Robotics Engineer designs, builds, and tests robots and automated systems. This course may be useful to those wishing to work as Robotics Engineers as it teaches core concepts of embedded systems and microcontroller programming. The course's teachings in developing drivers for various peripherals, such as timers and analog-to-digital converters (ADCs), are particularly important for interacting with sensors and actuators in robotics. By learning how to program at the register level, without relying on third-party libraries, a Robotics Engineer can have precise control over the behavior of the microcontrollers that control the robot's components, and debug problems effectively. The emphasis on understanding the microcontroller's architecture will be very helpful.
Mechatronics Engineer
Mechatronics Engineers work with systems that combine mechanical, electrical, and computer engineering. This course may be useful for this career, as it teaches practical skills in embedded systems and microcontroller programming. The course’s focus on developing peripheral drivers without relying on third-party libraries aligns well with the need to interface and control various sensors, actuators, and other electronic components within a mechatronic system, such as is taught by this course's GPIO, ADC, and Timer modules. A Mechatronics Engineer who has completed this course can better integrate the hardware and software components of their designs. The bare-metal approach will help them understand how to control microcontrollers at their core.
Automation Engineer
An Automation Engineer designs and implements automated control systems for various industrial processes and would benefit from learning more about embedded systems programming. This course provides a targeted introduction to bare-metal firmware development, which is directly relevant to the type of work they do. The course's emphasis on direct register manipulation and creating peripheral drivers, like GPIO, timers, and ADCs, is key to interfacing with the hardware components used in automation. An Automation Engineer who takes this course will have a better understanding of how to program embedded devices, and fine-tune the control algorithms. The focus on debugging will also allow them to troubleshoot issues in real time.
Control Systems Engineer
A Control Systems Engineer designs and implements control systems. This course may provide useful skills in embedded systems and low-level programming. By learning to write firmware directly to device registers without using libraries, a Control Systems Engineer can have greater understanding over how their systems operate. The course's focus on developing drivers for peripherals such as ADC and timers is suitable to interfacing with the sensors and actuators used in control systems. This emphasis on system-level thinking is helpful in creating robust control systems.
Test Engineer
A Test Engineer creates and conducts tests on products to ensure they meet the required specifications. This course is beneficial to this career field because it provides a deep understanding of how embedded systems operate at a low level. The skills learned from this course in manipulating the microcontroller's registers, and writing peripheral drivers, would help a Test Engineer design more effective tests for embedded products. This includes testing a product's interaction with its hardware. Experience with debugging firmware, also part of the course, makes them better at finding and resolving issues, which is essential in test engineering. A Test Engineer will benefit from the experience gained with practical exercises in this course.
Application Engineer
An Application Engineer provides technical support and guidance for customers using a company's products. This course may help an Application Engineer who is working with embedded systems because it provides a solid understanding of how microcontrollers work at a low level and how to write firmware from scratch. The course’s approach of not using third-party libraries will give an Application Engineer a deeper understanding of the issues customers might face in the field. The practical skills in debugging firmware can assist them in troubleshooting customer issues.
Research and Development Engineer
A Research and Development Engineer tests new products and technologies, often involving embedded systems. This course may be useful to a Research and Development Engineer as it teaches low-level programming. The course's emphasis on bare-metal development, and creating drivers without third-party libraries, can provide an important deeper understanding of how embedded hardware functions. This is particularly helpful for those working on cutting-edge technologies. Furthermore, the debugging techniques taught in this course will be helpful, by allowing for quick resolution of issues in experimental systems. The direct approach to hardware taught in this course is very helpful in testing new embedded systems.
Systems Integrator
A Systems Integrator combines different components and subsystems into a single, functioning system. This course may be helpful for this career field by teaching how to develop peripheral drivers and manipulate hardware registers directly, which are key for integrating embedded devices into complex systems. This course’s focus on understanding how to interact with microcontrollers at a low level helps a Systems Integrator better interface with and troubleshoot issues within these systems. Additionally, the skills taught in debugging and creating drivers for peripherals such as I2C and SPI are highly relevant for connecting different hardware components in a larger system. By learning to work without relying on third party libraries, a Systems Integrator will also have a better understanding of the underlying hardware.
Product Development Engineer
A Product Development Engineer is involved in the design, development, and testing of a product, often involving the use of embedded systems. This course may be useful for a Product Development Engineer because it provides a strong foundation in the low-level programming of microcontrollers. The course's focus on bare-metal firmware development and creating peripheral drivers without relying on libraries will help them understand how the hardware and software components of their products interact. Practical skills in debugging firmware make them better collaborators with the team members on the technical end, leading to more robust and efficient products. The emphasis on understanding and analyzing documentation related to chipsets and hardware is helpful.
Quality Assurance Engineer
A Quality Assurance Engineer is responsible for ensuring product quality. Those who work on products involving embedded systems may find this course helpful, as it teaches low-level interaction with hardware, as well as register manipulation. The course’s focus on understanding datasheets and writing bare-metal code can help a Quality Assurance Engineer develop more robust tests. The debugging experience built by this course will be very helpful in determining the precise flaws in any hardware product. The hands-on nature of the course and its focus on specific hardware makes this applicable to the field.
Technical Support Engineer
A Technical Support Engineer provides assistance to customers experiencing technical issues. This course may be useful for a Technical Support Engineer, particularly if they support embedded systems. The course’s approach in bare-metal firmware development provides a deep understanding of how microcontrollers operate. The ability to understand documentation and manipulate registers directly helps them diagnose problems more effectively. The skills in debugging firmware, also taught in this course, are particularly relevant for troubleshooting issues. The course will give them a better understanding of the software components of the hardware products that they support.
Lecturer
A Lecturer is an educator who teaches at a college or university level. This course may be helpful to a Lecturer who teaches courses related to embedded systems, microcontrollers, or computer engineering, as it provides in-depth knowledge of bare-metal programming. The practical, hands-on approach of the course's modules, as well as the focus on understanding microcontroller architectures, and creating drivers for peripherals, will help them develop their own course material and teach their students with more confidence. The deep dives in the course can be helpful for any Lecturer specializing in the field.

Reading list

We've selected two books that we think will supplement your learning. Use these to develop background knowledge, enrich your coursework, and gain a deeper understanding of the topics covered in ARM Cortex-M7 STM32F7 Bare-Metal Programming From Ground Up™.
Provides a practical guide to embedded systems development, covering topics such as debugging, testing, and real-time operating systems. It offers valuable insights into the software engineering aspects of embedded systems. This book is useful as additional reading and provides a broader perspective on the challenges and best practices in the field. It is commonly used as a textbook in academic institutions and by industry professionals.
Provides a comprehensive overview of embedded systems architecture, covering topics such as memory organization, interrupt handling, and peripheral interfaces. It serves as a valuable reference for understanding the underlying principles of bare-metal programming. While not strictly required, it offers additional depth and context to the course material. It is particularly helpful for those new to embedded systems or those seeking a more thorough understanding of the hardware-software interface.

Share

Help others find this course page by sharing it with your friends and followers:

Similar courses

Similar courses are unavailable at this time. Please try again later.
Our mission

OpenCourser helps millions of learners each year. People visit us to learn workspace skills, ace their exams, and nurture their curiosity.

Our extensive catalog contains over 50,000 courses and twice as many books. Browse by search, by topic, or even by career interests. We'll match you to the right resources quickly.

Find this site helpful? Tell a friend about us.

Affiliate disclosure

We're supported by our community of learners. When you purchase or subscribe to courses and programs or purchase books, we may earn a commission from our partners.

Your purchases help us maintain our catalog and keep our servers humming without ads.

Thank you for supporting OpenCourser.

© 2016 - 2025 OpenCourser