STM32 Driver Development: Build Drivers & Control Dino Game

Build GPIO, USART and Timer drivers from scratch, then use your STM32 board to control the Chrome Dino Game.

  • 0.0 (0 Reviews)
  • 0 Students
  • 166 Lessons
  • Embedded Coding

Course Overview

I started out as a beginner (or “snoop”), unsure where to start. Today, I confidently apply embedded knowledge in professional projects and take part in expert-level technical discussions. That’s why I know exactly which parts are confusing for beginners — and I’ve made it my mission to explain them simply and clearly.

Are you ready to stop relying on libraries and start writing your own embedded drivers from scratch?

This hands-on course is designed to teach you how to build essential embedded drivers — for GPIO, USART/UART, Timers — with no HAL, no abstraction, and no shortcuts. Whether you're a beginner or a self-taught enthusiast, this course will help you gain full control of the microcontroller by programming directly at the register level.

Instead of endless theory, we use a project-based learning approach. Throughout the course, you'll apply each driver you build to control a fun, interactive Dino game — a perfect way to instantly see the result of your code in action and stay motivated as you progress.

You don’t need any prior experience with low-level embedded programming. We’ll start from the very beginning: installing the necessary tools, setting up your environment, and writing your first embedded driver step-by-step.

To help you learn effectively, this course uses animations, graphs, and diagrams to break down complex ideas — instead of overwhelming you with text-heavy slides. I also use a live coding style throughout the course, so it’ll feel like you and I are sharing the same screen, learning side by side. You'll see exactly how I think, troubleshoot, and write real embedded code in action.

This course is carefully designed to be completed in around 8.5 hours, so you can finish it in one to two weeks — or even faster if you're a quick learner. You’ll walk away with practical skills, real project experience, and the confidence to build embedded systems without relying on pre-written libraries.

If you’re ready to take full control of embedded systems and actually see your code come to life, this course is for you.

Let’s build drivers — and make the Dino run!

See more

FAQ

FAQ area empty

Course curriculum

19 chương 166 bài học 8 giờ 40 phút 7 bài học thử miễn phí
Chương 1 Course overview & Motivation
Chương 2 Run the game
Chương 3 Development environment setup
  • What is this section about? Học thử 0:33
  • STM32F407 DISC board introduction - What do we have on this board? 3:41
  • Required document Học thử 4:27
  • Required software 1:38
  • Install Keil uVision 5 1:46
  • Install VSCode 1:26
  • Install STLink driver 1:32
  • Install Git 1:07
  • Download Hercules 1:01
  • Pack installation 2:59
  • Git init 0:58
  • Hello world 6:49
  • First commit 4:26
  • Volatile keyword 5:57
  • Volatile commit and code compare between commits 2:15
Chương 4 Inside the MCU: Architecture, Bus system, Memory map and Clock
  • What is this section about? 1:02
  • MCU block diagram 4:55
  • Data bus connection example 0:50
  • Simplified MCU block diagram 2:16
  • Bus matrix 3:56
  • MCU clock system 4:55
  • Memory map 5:06
  • Section Quiz
Chương 5 GPIO deep dive: Input & Output
  • What do we have in GPIO sections? 1:00
  • What is GPIO? 2:27
  • Output buffer 1:00
  • Input buffer 0:53
  • Input floating 1:48
  • Input pull-up/pull-down 3:15
  • Output push-pull and Output open drain 2:55
  • Output speed 2:16
  • Section Quiz
Chương 6 GPIO in practice: MCU-level configuration
  • GPIO in STM32F407 0:55
  • Input configuration in the MCU 2:24
  • Output configuration in the MCU 1:10
  • Alternate function configuration in the MCU 1:14
  • Analog configuration in the MCU 0:59
  • Section Quiz
Chương 7 Mastering GPIO registers
  • Best way to approach this section 0:32
  • GPIO registers 3:24
  • GPIO pin mode register 7:30
  • GPIO output type register 1:00
  • GPIO pull-up/pull-down register 0:51
  • GPIO output speed register 0:47
  • GPIO input data register 1:00
  • GPIO output data register 0:37
  • GPIO bit set/reset register 0:51
  • GPIO port lock configuration register 1:52
  • GPIO alternate function registers 5:54
  • Section Quiz
Chương 8 Hands-On: Writing your first GPIO driver
  • How to learn this section effectively? 0:27
  • How to access GPIO registers by using Struct 2:50
  • Define GPIO register definition struct 4:54
  • GPIO base address definition 4:23
  • GPIO pin configuration struct 3:03
  • Pin configuration macros 5:58
  • Function prototypes 3:58
  • GPIO_Init() 4:37
  • GPIO_Init() (continued) 6:36
  • GPIO_WritePin() 1:28
  • GPIO_WritePin() testing - Blink an LED 4:46
  • Enable GPIO clock 2:27
  • Define GPIO clock enable/disable macros and test application 6:51
  • Reset and run configuration 0:58
  • Commit code 3:41
  • Control external LEDs 0:44
  • GPIO_ReadPin() 7:23
  • GPIO_ReadPin() testing - Read user button state 0:50
  • Read external button's state 1:13
  • GPIO_TogglePin() 4:58
  • GPIO_TogglePin() testing- Press button to toggle an LED state 3:26
  • Commit code and challenge 1:05
  • GPIO challenge accepted! 2:23
  • GPIO_WritePinBit() and testing 5:51
  • GPIO_LockConf() 4:28
  • GPIO_LockConf() testing - Lock GPIO configuration registers 3:34
  • Comment your code! 3:22
Chương 9 Understanding interrupts: Concepts & Use cases
  • What do we have in interrupt sections? 0:41
  • Basic concept of interrupts 2:29
  • Vector table 5:20
  • How the program handles an interrupt 1:07
  • Section Quiz
Chương 10 GPIO interrupt in the MCU
  • GPIO interrupt with EXTI and NVIC 5:00
  • Inside the EXTI 4:00
  • GPIO interrupt setup 1:11
  • Section Quiz
Chương 11 Hands-On: Coding GPIO interrupt
  • SYSCFG register definition struct 5:49
  • EXTI register definition struct 3:15
  • GPIO_IT_Init() - Configuration steps 6:06
  • GPIO_IT_Init() - Specify GPIO port to be mapped 5:31
  • GPIO_IT_Init() - EXTI configuration 4:45
  • GPIO_IT_Init() - Define NVIC register definition struct 5:36
  • GPIO_IT_Init() - NVIC_SetPriority() 6:38
  • GPIO_IT_Init() - NVIC_EnableIRQ() 1:47
  • GPIO_IT_Init()- Define IRQ number macros 4:41
  • GPIO interrupt - Button press detection 6:11
  • GPIO interrupt - It's debug time! 8:48
  • Create the Dino "Jump" signal 0:36
Chương 12 USART explained: Frame structure & Communication modes
  • What do we have in the USART sections? 1:05
  • What is USART? 1:47
  • USART pins 2:09
  • USART Synchronous mode 1:58
  • USART Asynchronous mode 2:05
  • Hardware flow control mode 3:12
  • Mid Quiz
  • Frame format 2:20
  • Start bit/Stop bit 2:46
  • Parity bit 5:25
  • Parity check limitation 2:49
  • Baud rate 3:01
  • Oversampling 4:45
  • Baud rate calculation 3:45
  • Baud rate calculation Example 1 2:27
  • Baud rate calculation Example 2 1:28
  • Baud rate calculation Overflow handling 1:25
  • Baud rate calculation in code 3:54
  • Section Quiz
Chương 13 Hands-On: Writing your USART driver
  • USART registers overview 4:25
  • Define USART register definition struct 5:19
  • Define USART configuration struct 6:20
  • Define USART configuration struct (continued) 4:32
  • USART_Init() - Configuration steps 2:23
  • USART_Init() - Implementation 8:18
  • Get APB1 clock frequency 9:52
  • Get APB2 clock frequency 1:30
  • USART_Transmit() 7:56
  • USART_Receive() 6:53
  • Configure a USART peripheral 6:13
  • Control an LED by commands from Hercules 6:53
Chương 14 Hands-On: USART interrupts: Efficient serial communication
  • Button press transmit and receive interrupt 7:24
  • Button press transmit and receive interrupt (continued) 2:45
  • Button press transmit and receive interrupt - testing 1:58
  • Send the Dino "Jump" signal to the Dino game 1:39
Chương 15 Timer fundamentals: Counting and update event generation
  • What do we have in Timer sections? 1:18
  • Basic timer introduction 6:40
  • Types of timers in STM32F407 and their characteristics 5:22
  • Timer period calculation 1:41
  • Section Quiz
Chương 16 Hands-On: Building basic timer driver
  • Define timer register definition struct 1:26
  • Define timer base addresses and clock control 2:23
  • Define timer base configuration struct 5:49
  • TIM_Base_Init() 4:17
  • Timer_Base_Start() and Timer_Base_Stop() 0:58
  • Non-blocking delay generation with timer 3:52
  • Blinky LED with timer delay generation 2:16
Chương 17 Hands-On: Timer interrupts
  • Timer update event interrupt 6:52
  • Update event interrupt testing with button debouncing 1:16
Chương 18 Output compare & PWM: Concepts & Use cases
  • Ouput compare 3:42
  • PWM - Pulse Width Modulation 1:37
  • PWM generation using output compare unit 4:18
  • Control LED brightness with PWM 1:09
  • Section Quiz
Chương 19 Hands-On: PWM driver development & Application
  • Update timer register definition struct 2:30
  • Understanding the output compare configuration struct 2:30
  • Define output compare configuration struct 2:58
  • TIM_OC_Init() 7:53
  • Initialize output compare to generate PWM 3:57
  • Control LED brightness by command - Implementation 1:48
  • Control LED brightness by command - Testing 2:09
  • Control LED brightness based on Dino’s Jumps 1:07

Requirment

  • Basic knowledge of C programming language

Outcomes

  • Master bare-metal driver development for essential peripherals like GPIO, USART/UART, Timer (Output Compare and PWM)— no HAL, no magic, just full control

  • Learn to decode technical reference manuals and extract register-level details — a skill transferable across any microcontroller family, not just STM32

  • Think like an embedded engineer: debug, build, and solve real problems

  • Control a real Dino Game using your own embedded drivers

  • Understand microcontroller architecture: buses, block diagrams, and how the CPU talks to peripherals

  • Implement interrupt-driven programming for GPIOs, USART, and Timers

  • Unlock creative thinking by exploring how embedded systems can power games — not just LEDs and sensors

  • Gain confidence in debugging techniques using breakpoints, register watch view to troubleshoot

  • Get a developer mindset: instead of relying on libraries, you'll build your own tools — understanding what’s happening at the lowest level

  • Organize your code clearly with proper structure, comment and separation

Instructor

...
Embedded Coding

0.0

  • ... 0 Student
  • ... 1 Course
  • ... 0 review

View Details

Reviews

Rate this course :

Remove all