
Install Keil uVision 5 from ARM's official site by visiting the downloads page, submitting the form, and completing the download and installation.
Install Keil uVision 5 by following the installation wizard, accepting the license, choosing the install location, and entering your name; the package installer adds startup files for different silicon manufacturers.
Install parks for cortex microcontrollers using the park installer, handle up-to-date and deprecated versions, and prepare to test the installation on sdm 32, klxx series, and tm4c boards.
Open Keil uVision 5, create a new project, select a Cortex-M microcontroller, and configure startup files, packs, target options, and debugging for code download.
Develop an led class in object-oriented c by defining color and state types, creating a constructor, and implementing set state and get state, with translation to c++ in future lessons.
Create an LED class in object-oriented C, mapping red, blue, green, and yellow LEDs to port B. Enable port clocks and configure the GPIO mode register for output.
Transform a legacy C embedded LED project into a C++ LED class by converting structs to classes, adding a constructor, and using new and delete for memory management.
Implement constructors and member functions for a power elite class in C, initializing parent class, color, and state; provide functions to set current, get current and voltage, and compute power.
Test and assemble a power LCD class by creating two instances, calling the constructor with color, state, and electrical parameters, and computing power.
Explore implementing inheritance in C++ by converting a C example to a derived power LCD from the elite base class. Focus on constructor initialization and public inheritance; test with debugging.
Build a gpio driver from scratch by defining base addresses, offsets, and a gpio register struct. Enable RCC clocks and illustrate object-oriented reuse by porting from C to C++.
Create a typedef struct to represent all RCC registers, including clock control, PLL configuration, clock interrupts, resets, enables, and low power enables, padding for correct offsets.
Extend the gpio driver to include ports b, c, d, e, and h by using base addresses, offsets, and enable bits, then test blinking an lcd on port b.
Refactor by moving the drive logic into a new header file for a stm32f4 gpio driver. Include it from the main file, build, and download to the board.
Build a gpio library on top of the driver by defining header files and symbolic pin names. Implement initialization, and read/write prototypes with pin modes to enable configuration and control.
Define symbolic pin values and initialize gpio pins, then implement read and write functions that use gpio input data registers, mode and pull-up/down settings, and the bit set/reset register.
Test the GPO library by enabling clocks, configuring PA5 as a push-pull output, and initializing ports; run a loop to toggle the pin and deploy to the board.
Add a medical LCD class to the firmware to explore polymorphism in C, expanding LCD modules with infrared wavelengths and a constructor, getters, and setters, then test on hardware.
Explore polymorphism in C by implementing virtual functions for power LCD and medical LCD, sharing a common interface to compute efficiency and run diagnostics.
Extend the gpio library to support alternate function mode for pins, including push-pull and open-drain configurations, by updating mode, output type, and speed registers in C.
Develop a C++ gpio library for embedded systems by turning a C driver into a class, implementing read and write pins with port enums, then test with a main.
Implement a uart driver using object oriented principles, map registers into a 32-bit structure with status, data, baud rate, control registers 1-3, guard time, and prescaler on the APB1 bus.
Develop a UART driver from scratch in C by enabling clocks, configuring GPIO alternate functions, setting baud rate to 9600, and sending data via status and data registers.
Develop a uart library in C for embedded systems, creating header and C files to support tx, rx, or both, with baud rates like 115200 and 9600, and configurable options.
Develop and test a UART library in C by implementing read and write functions that wait for data arrival and TX buffer readiness, exposing prototypes in the lib uart header.
Test the UART library by initializing the UART for transmission at 115200 baud, sending a character, then building and flashing to the board, and verifying the output in Terra Term.
In this lesson, you test the SysTick driver by configuring GPIO, enabling the clock, and setting a 1-second SysTick delay, verifying the flag.
Develop a SysTick library on top of the driver, adding two delay functions—one for seconds and one for milliseconds—and test it in the main program with a 500 ms delay.
Transform the systick library from C to C++ by building a dedicated C++ class, wiring header and source files, and implementing constructor, delay, and basic interrupt scaffolding for embedded timing.
Are you tired of Copying and Pasting code you don't understand?
This course is for anyone seeking to improve their embedded firmware development skills. This course focuses on how to apply object-oriented principles to embedded firmware development.
By the end of this course you will be able to write Objected-Oriented Embedded-C Applications as well as Objected-Oriented Embedded-C++ Applications.
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 :
"So far this class has been awesome. I'm a C programmer that's been using Python a lot lately so this class helps to make my C code look a little more object oriented and class based. Also, he goes through how to transform some C code into C++ code which is pretty great"
Here is what another student had to say :
"Absolutely it was a good match for me because I am new to the OOP in Embedded system and I have now gained good Understanding of C++ and OOP for Microcontrollers. Very detailed and nicely designed course I will regularly check for the new update. I think it is the best course about OOP on Embedded system."
If at least one of the following applies to you then keep reading if not then simply skip this course:
" Escape From "
Copying/Pasting code you don’t understand
Using third party libraries and header files like HAL, LL and StdPeriph
Experiencing bugs you don’t understand
Being afraid of technical documentations like the reference manual and datasheet of the chip
Imposter syndrome
" Arrive At "
Building every single line of code from scratch by writing to the microcontroller’s memory space directly.
Using No third party libraries or header files
Understanding and writing every single line of code yourself- no Copy/Paste
Using the debugger effectively to analyze and resolve any bugs
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 Object-Oriented Concepts
Like:
Polymorphism
Inheritance
Encapsulation
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 loose.