Mímir, Keeper of the Well of Wisdom

Mastering Microcontroller and Embedded Driver Development

https://www.udemy.com/course/mastering-microcontroller-with-
peripheral-driver-development/

Year : 2026
Language : English
Level : All Levels
Category : IT & Software
Subcategory : Hardware
Duration : 28h 28m
Lectures : 278
Rating : 4.6/5 (12,748 reviews)
Students : 78,192

INSTRUCTOR(S)

HEADLINE
(MCU1) Learn bare metal driver development using Embedded C:
Writing drivers for STM32 GPIO,I2C,SPI,USART from scratch

WHAT YOU'LL LEARN
* Understand Right ways of Handling and programming MCU
Peripherals
* Develop Peripheral drivers for your Microcontroller
* Understand complete Driver Development steps right from
scratch for GPIO,SPI,I2C and USART.
* Learn Writing peripheral driver headers, prototyping APIs

implementation
* Explore MCU data sheets, Reference manuals, start-up Codes

get things done
* Learn Right ways of handling/configuring Interrupts for
various peripherals
* Learn about Peripheral IRQs/Vector table/NVIC interfaces and
many
* Learn about Configuration/status/Control registers of
various
Peripherals
* Demystifying behind the scene working details of
SPI,I2C,GPIOs,USART etc.
* Explore hidden secretes of MCU bus interfaces, clock
sources,
MCU clock configurations, etc.
* Understand right ways of enabling/configuring peripheral
clocks/serial clocks/baud rates of various serial protocols
* Learn about MCUs AHB, APB bus protocols
* Learn about different MCU clocks like HCLK, PCLK, PLL,etc
* Learn to capture/decode/analyze traces of serial protocols

Logic analyzer
* Learn about Quick ways of debugging peripheral issues with
case studies

REQUIREMENTS
* Basic knowledge of C programming
* If you are completely new to MCU and C programming language
then you are advised to finish our "Embedded C" course for
absolute beginners first

WHO IS THIS COURSE FOR
* Professionals interested in exploring Embedded systems
* Hobbyists and students who want to start their career in
Embedded world
* If you think about 'embedded' then think about taking this
course. you will not be disappointe
* This Course may not be suitable for those people who are
looking for quick prototyping using boards such as Arduino

DESCRIPTION
>> Your Search for an in-depth microcontroller programming
course ends here !!<<< Course code: MCU1 Learn bare-metal
driver
development using Embedded C : Writing drivers for STM32
GPIO,I2C, SPI,USART from scratch English Subtitles/CCs are
enabled for this course. Update 6: videos are updated with the
latest STM32CUBEIDE Update 5: All drivers are developed in a
live session with step-by-step coding and added stm32-Arduino
communication exercises using SPI and I2C. Update 4: Dedicated
support team is assigned to address student's Q/A Update 3:
English Closed captions are fixed Update 2 : Added Bus matrix

memory map /vector table /interrupt design discussion with
code
examples. Update 1: Eclipse IDE setup for ARM Cortex M based
MCUs added The course is designed for beginners to advanced
audiences. Brief Description: This course Demystifies the
internal working of the Microcontroller and its Peripherals.
Coding for the Peripherals STEP-BY-STEP and Developing
software
drivers entirely from scratch by extracting maximum
information
from Datasheets, Reference manuals, specs, etc Protocol
Decoding
Using logic analyzers, Debugging, Testing along with Hints and
Tips. Long Description: Learning Embedded System Programming

be a challenge. Since it's a relatively complex field, there's
no actual gold standard yet for how things are practiced, or
taught, which can frustrate people who are just trying to
learn
new things and couldn't connect the dots. This is the
motivation
behind creating this course to help engineers and students
learn
different aspects of embedded systems by providing high-
quality
advanced lectures at a relatively low price. Master Behind the
Scene working; created this course because I believe your time
is precious, and you shouldn't have to hunt around to get a
practical foundation In Embedded System Programming. In this
course, you will learn to write your peripheral driver for
most
commonly used peripherals such as GPIOs, I2C, SPI, USART,
etc.,
and the exciting thing is that you will learn everything from
scratch. No 3rd party libraries! No blind coding! Write your
driver APIs by dealing with the peripheral registers of the
MCU!
Code and Implement APIs from scratch, diving into the
datasheet
and reference manual of the MCU. I will thoroughly explain how
to extract the maximum information from datasheets, Technical
Reference manuals to configure and handle peripherals. These
techniques you can go and apply to any MCUs you have at your
hand. In this course, I will walk you through step-by-step
procedures on configuring various Peripherals like GPIOs, SPI,
USART, I2C by taking you into the reference manual and
datasheet. We will develop a fully working driver code,
interrupt handlers, sample application everything from scratch
to understand the big picture. In each lecture, I assure you
that you will learn something new to use in your work or
projects. You'll find yourself handling these peripherals with
much more clarity. You will be able to speculate and debug the
problem quickly. I'll show you tricks and tips to debug the
most
common issues using debugging tools such as logic analyzers.
This is not the Arduino style of programming: I believe
Arduino
is for quick prototyping of projects/products but not for
mastering the working of micro-controllers and their
peripherals. Unlike Arduino programming, where you develop a
quick solution and prototyping of products using third-party
libraries, this course is entirely different. In this course,

3rd party libraries are used. Everything we will code by
referring to the technical reference manual of the MCU and
will
create our own library. The Power of this approach is that you
can quickly speculate problems and debug like a pro when
things
go wrong in your project due to bugs. If one thing me and my
students are good at is "debugging,." To achieve good
debugging
skills, it's essential to code by understanding how things
work
behind the scene but not by blindly using some third-party
libraries, and that's the biggest TAKE away from this course.
The course is designed and explained so that it is generic
across any microcontroller. The code we develop can be used as
templates to quickly build a peripheral driver for your MCUs

chip peripherals. Software/Hardware used: In this course, the
code is developed so that it can be ported to any MCU you have
at your hand. If you need any help porting these codes to
different MCUs, you can always reach out to me! The course is
strictly not bound to any 1 type of MCU. So, if you already
have
any Development board that runs with an ARM-Cortex M3/M4
processor, I recommend you continue using it. But if you don't
have any development boards, then check out the below
Development boards. 1. STM32F407xx based Discovery board (
This
is the board used in this course) MCU Vendor:
STMicroelectronics
IDE: STM32CUBEIDE (Free) My promise: I am confident that this
course will save you many hours of
studying/experimenting/googling time to learn about MCU
programming. I will personally answer your questions about
this
material, either privately or in a group discussion. If you

not satisfied, for any reason, you can get a full refund from
Udemy within 30 days. No questions asked. But I am confident

won't need to. I stand behind this course 100% and am
committed
to helping you. Learning order of FastBit Embedded Brain
Academy
Courses, If you are a beginner in the field of embedded
systems,
then you can take our courses in the below-mentioned order.
This
is just a recommendation from the instructor for beginners. 1)
Microcontroller Embedded C Programming: absolute
beginners(Embedded C) 2) Embedded Systems Programming on ARM
Cortex-M3/M4 Processor(ARM Cortex M4 Processor specific) 3)
Mastering Microcontroller with Embedded Driver
Development(MCU1)
4) Mastering Microcontroller: TIMERS, PWM, CAN, RTC,LOW
POWER(MCU2) 5) Mastering Microcontroller: STM32-LTDC, LCD-TFT,
LVGL(MCU3) 6) Embedded System Design using UML State
Machines(State machine) 7) Mastering RTOS: Hands-on FreeRTOS

STM32Fx with Debugging(RTOS) 8) ARM Cortex M Microcontroller

Programming Demystified(DMA) 9) STM32Fx Microcontroller Custom
Bootloader Development(Bootloader) 10) Embedded Linux Step by
Step using Beaglebone Black(Linux) 11) Linux device driver
programming using Beaglebone Black(LDD1)

COURSE CONTENT

Chapter 1: Notes and Information
1. About the instructor
2. Important Note
3. What is this course all about ??
4. Source Code and Slides
5. Rating and Review

Chapter 2: Development board used in our courses
6. About MCU Development board

Chapter 3: Hardware/Software Requirements
7. Hardware/Software Requirements

Chapter 4: IDE installation
8. Downloading STM32CUBEIDE
9. Installation-Windows
10. Installation-Ubuntu
11. Embedded Target
12. Documents required

Chapter 5: Creating a project using STM32CUBEIDE
13. Creating Hello-World project
14. SWV working principle
15. Testing Hello-World through SWV
16. OpenOCD and Semihosting to use printf

Chapter 6: Embedded Code Debugging Tips and tricks
17. Debugging options
18. Single stepping
19. Disassembly and Register windows
20. Breakpoints
21. Expression and variable windows
22. Memory browser windows
23. Call stack and fault analyzers
24. Data watch-points
25. SFR windows
26. Other basic features of IDE

Chapter 7: Understanding MCU Memory Map
27. Understanding Memory Map of the MCU: Part 1
28. Understanding Memory Map of the MCU: Part 2
29. Understanding Memory Map of the MCU: Part 3

Chapter 8: MCU Bus Interfaces
30. MCU Bus Interfaces Explanation Part 1:
I-Code/D-Code/S-Bus
31. MCU Bus Interfaces Explanation Part 2: AHB/APB1/APB2
32. MCU Bus Interfaces Explanation Part 3: Q/A session
33. Understanding MCU Bus Matrix

Chapter 9: Understanding MCU Clocks and Details
34. Understanding MCU Clocking System:Part1

Chapter 10: Understanding MCU Clock tree
35. Understanding MCU clock sources and HSE
36. HSI and RCC registers
37. Peripheral clock configuration
38. Exercise : HSI measurements
39. About USB logic analyzer
40. Code implementation
41. Exercise : HSE measurements

Chapter 11: Understanding MCU Vector table
42. Understanding MCU Vector Table

Chapter 12: Understanding MCU interrupt Design , NVIC,
Interrupt handling
43. Understanding MCU interrupt Design , NVIC, Interrupt
handling: Part 1
44. Understanding MCU interrupt Design , NVIC, Interrupt
handling: Part 2
45. Understanding MCU interrupt Design , NVIC, Interrupt
handling: Part 3

Chapter 13: Importance of "Volatile" Keyword
46. Importance of "Volatile" Keyword: Part-1
47. Importance of "Volatile" Keyword-Part 2

Chapter 14: GPIO Must know concepts
48. GPIO pin and GPIO port
49. GPIO behind the scene
50. GPIO input mode with high impedance state
51. GPIO input mode with pull-up/down state
52. GPIO output mode with open drain state
53. GPIO output mode with push pull state
54. Optimizing I/O power consumption

Chapter 15: GPIO Programming structure and Registers
55. GPIO programming structure
56. Exploring GPIO PORT and pins of STM32F4xx Discovery
board
57. GPIO Mode register(used to set mode for a pin)
58. Input configuration of a Microcontroller's GPIO Pin
59. Output Configuration of a GPIO Pin in Push pull mode
60. Output Configuration of a GPIO Pin in open drain mode
61. Input stage of a GPIO pin during output configuration
62. Alternate functionality Configuration of a GPIO pin
63. GPIO out put type register explanation

Chapter 16: GPIO Registers : SPEED, PULL UP/DOWN, IDR and ODR
64. GPIO output speed register and its applicability
65. GPIO Pull up and Pull down register
66. GPIO input data register
67. GPIO output data register and summary of various modes
discussed

Chapter 17: GPIO Alternate functionality register and example
of usage
68. Alternate functionality settings of a GPIO pin with
example : Part 1
69. Alternate functionality settings of a GPIO pin with
example : Part 1
70. Request for Review

Chapter 18: GPIO peripheral clock control
71. Enabling and disabling GPIO peripheral clock

Chapter 19: GPIO driver development overview and Project
creation
72. GPIO driver development overview
73. MCU Specific header file and its contents
74. New project creation and creating MCU specific
headerfile
75. Include path settings
76. Important note on IDE usage

Chapter 20: Updating MCU specific header file with bus domain
and peripheral details
77. Writing base address C macros for MCU's embedded
memories : Part 1
78. Writing base address C macros for MCU's embedded
memories : Part 2
79. Defining base addresses of different bus domains
80. Defining base addresses of AHB1 Peripherals
81. Defining base addresses of APB1 and APB2 Peripherals
82. Defining base addresses conclusion

Chapter 21: Structuring peripheral registers
83. Address of peripheral registers
84. Structuring peripheral registers
85. Peripheral definition macros

Chapter 22: Writing Clock enable and disable macros
86. Writing peripheral clock enable and disable C Macros
87. Project include settings and build

Chapter 23: GPIO driver API requirements and handle structure
88. Creating GPIO driver header and source file
89. Defining GPIO handle and configuration structure
90. Driver API requirements and adding API prototypes
91. Driver API input parameters and return types
92. Driver empty API implementation and documentation

Chapter 24: GPIO driver API Implementation : Clock control
93. Implementation of GPIO peripheral clock control API

Chapter 25: GPIO driver API Implementation : GPIO init and de-
init
94. Writing user configurable macros
95. Implementation of GPIO init API
96. Implementation of GPIO init API contd.
97. Configuring Alternate function registers
98. GPIO de-init API implementation

Chapter 26: GPIO driver API Implementation : GPIO data read
and write
99. Implementation of GPIO input port read and input pin
read APIs
100. Implementation of GPIO output port write and output pin
write APIs
101. Implementation of GPIO pin toggle API

Chapter 27: Exercise
102. Exercise : LED toggling with PUSH PULL configuration
103. Exercise : LED toggling with OPEN DRAIN configuration
104. Exercise : Handling on board LED and Button
105. Exercise : Connecting external button and circuit
explanation
106. Exercise : Testing button interface
107. Exercise : Button interrupt introduction

Chapter 28: GPIO pin Interrupt configuration
108. GPIO pin Interrupt configuration coding : Part 1
109. GPIO pin Interrupt configuration coding : Part 2
110. GPIO pin Interrupt configuration coding : Part 3
111. GPIO pin Interrupt configuration coding : Part 4
112. GPIO pin Interrupt configuration coding : Part 5
113. GPIO pin Interrupt configuration coding : Part 6
114. GPIO pin Interrupt configuration coding : Part 7

Chapter 29: Exercise : GPIO interrupts
115. Exercise : External button interrupt implementation
116. Exercise : Debugging the application : Part 1
117. Exercise : Debugging the application : Part 2

Chapter 30: MCU I/O Pin specifications
118. STM32 Pin specifications
119. Pin current characteristics
120. Logic levels

Chapter 31: SPI introduction and bus details
121. Introduction to SPI Bus
122. SPI comparison with other protocols
123. Importance of SPI slave select pin
124. SPI Minimum bus configuration
125. SPI behind the scene data communication principle

Chapter 32: SPI bus configuration and functional block diagram
126. SPI bus configuration discussion : full duplex, half
duplex and simplex
127. SPI functional block diagram explanation

Chapter 33: STM32 NSS pin settings and management
128. NSS settings in STM32 master and slave modes
129. STM32 SPI hardware and software slave managements

Chapter 34: SPI CPOL and CPHA discussion
130. SPI CPOL and CPHA discussion
131. SPI CPOL and CPHA waveform example

Chapter 35: SPI serial clock discussion
132. SPI peripherals of your Microcontroller
133. SPI Serial clock frequency

Chapter 36: SPI Driver : API requirements and configuration
structure
134. SPI API requirements and configuration items
135. updating MCU specific header file with SPI related
details
136. SPI adding API prototypes to driver header file

Chapter 37: SPI Driver API Implementation : Clock control
137. Implementation of SPI peripheral clock control API

Chapter 38: SPI Driver API Implementation : SPI init
138. SPI user configuration options writing and register bit
definition macros
139. Implementation of SPI init API : Part 1
140. Implementation of SPI init API : Part 2

Chapter 39: SPI Driver API Implementation : Send Data
141. Implementation of SPI send data API : Part 1
142. Implementation of SPI send data API : Part 2
143. Implementation of SPI send data API : Part 3
144. Implementation of SPI send data API : Part 4

Chapter 40: Exercise : SPI Send Data
145. Exercise to test SPI Send Data API
146. Finding out microcontroller pins to communicate over
SPI2
147. Exercise : Code implementation : Part 1
148. Exercise : Code implementation : Part 2
149. Exercise : Code implementation : Part 3
150. Exercise : Testing

Chapter 41: Exercise : STM32 master and Arduino Slave
communication
151. Exercise : Communicating with Arduino slave
152. Exercise : Coding Part 1
153. Exercise : Coding Part 2
154. Exercise : Coding Part 3
155. Exercise : Testing

Chapter 42: SPI Driver API : Receive data
156. Implementation of SPI data receive API : Part 1
157. Implementation of SPI data receive API : Part 2

Chapter 43: Exercise : SPI receive data
158. Exercise : SPI command and response based
communication
159. Exercise : Coding Part 1
160. Exercise : Coding Part 2
161. Exercise : Coding Part 3

Chapter 44: SPI interrupts
162. SPI peripheral interrupting the processor

Chapter 45: SPI interrupt mode APIs
163. SPI interrupt mode API implementation and changes to
handle structure
164. SPI send data with interrupt API implementation
165. SPI receive data with interrupt implementation

Chapter 46: SPI Driver API : IRQ handling
166. SPI : Handling of interrupts
167. SPI IRQ handler implementation : Part 1
168. SPI IRQ handler implementation : Part 2
169. SPI IRQ handler implementation : Part 3
170. Exercise

Chapter 47: Common problems in SPI
171. Common problems in SPI and Debugging Tips

Chapter 48: I2C introduction and I2C signals
172. I2C introduction and differences with SPI
173. I2C SDA and SCL signals

Chapter 49: I2C modes
174. I2C standard and fast mode

Chapter 50: Understanding I2C Protocol
175. I2C Protocol explanation
176. I2C START and STOP conditions
177. I2C ACK and NACK
178. I2C Data validity

Chapter 51: I2C master and slave communication
179. Example of master writing to slave
180. Understanding repeated START condition

Chapter 52: STM32 I2C functional block diagram
181. I2C functional block diagram

Chapter 53: I2C driver API requirements and config structures
182. I2C driver API requirements
183. I2C handle and configuration structure
184. I2C user configurable macros
185. I2C API prototypes
186. Steps for I2C init implementation

Chapter 54: I2C serial clock discussion(SCLK)
187. I2C serial clock settings with explanation
188. Clock Stretching

Chapter 55: I2C Driver API : I2C Init
189. Implementation of I2C init API : Part 1
190. Implementation of I2C init API : Part 2
191. Implementation of I2C init API : Part 3

Chapter 56: I2C Driver API : I2C Master send data
192. I2C transfer sequence diagram for master sending data
193. Implementation of I2C master sending data API : Part 1
194. Implementation of I2C master sending data API : Part 2
195. Implementation of I2C master sending data API : Part 3
196. Implementation of I2C master sending data API : Part 4
197. Implementation of I2C master sending data API : Part 5

Chapter 57: I2C pull up resistance , rise time and bus
capacitance
198. I2C pull up resistance , rise time and bus capacitance
discussion
199. I2C rise time calculation

Chapter 58: Exercise
200. Exercise : Introduction
201. Exercise : Coding Part 1
202. Exercise : Coding Part 2
203. Exercise : Testing

Chapter 59: I2C Driver API : I2C Master receive data
204. I2C transfer sequence diagram for master receiving data
205. Assignment : I2C master receive data API implementation
206. Implementation of I2C master receive data API : Part 1
207. Implementation of I2C master receive data API : Part 2

Chapter 60: Exercise
208. Exercise : Reading data from the I2C slave
209. Exercise : Coding Part 1
210. Exercise : Coding Part 2
211. Exercise : Coding Part 3
212. Exercise : Testing repeated start

Chapter 61: I2C Interrupts and IRQ numbers
213. I2C IRQ and interrupt discussion
214. I2C errors and importance of BUSY flag
215. I2C handle structure modification
216. I2C adding interrupt related macros and interrupt APIs

Chapter 62: I2C interrupt based APIs
217. Assignment : I2C interrupt APIs implementation
218. Implementation of I2C interrupt based APIs

Chapter 63: I2C IRQ handler implementation
219. I2C IRQ handler implementation Part 1
220. I2C IRQ handler implementation Part 2
221. I2C IRQ handler implementation Part 3
222. I2C IRQ handler implementation Part 4
223. I2C IRQ handler implementation Part 5
224. I2C IRQ handler implementation Part 6
225. I2C IRQ handler implementation Part 7
226. I2C IRQ handler implementation Part 8
227. I2C error IRQ handler implementation

Chapter 64: Exercise
228. Exercise : Testing I2C interrupt APIs part 1
229. Exercise : Testing I2C interrupt APIs part 2

Chapter 65: I2C slave programming
230. I2C slave programming discussion
231. I2C transfer sequence diagram for slave transmitter
232. I2C slave support in driver

Chapter 66: Exercise
233. Exercise : I2C slave programming
234. Exercise : Coding Part 1
235. Exercise : Testing
236. Exercise : Modifying I2C transactions

Chapter 67: Common problems in I2C
237. Common Problems in I2C and Debugging Tips

Chapter 68: UART Essentials
238. Intro UART vs USART
239. Understanding UART pins
240. UART frame formats
241. Baud Rate
242. Synchronization bits
243. UART Parity

Chapter 69: UART functional block and Peripheral Clock
244. Exploring UART functional block
245. UART peripheral clock

Chapter 70: UART Communication
246. UART Transmitter
247. Uart Receiver

Chapter 71: USART driver development
248. USART driver development confiugrable items
249. USART driver APIs prototypes
250. Configuration options and USART registers
251. USART Driver API : USART Init
252. USART Driver API : Tx and Rx assignment
253. USART Driver API : Send data

Chapter 72: USART oversampling and baudrate
254. USART oversampling
255. USART Baud rate calculation Part-2
256. USART Baud rate calculation Part-2
257. USART baudrate coding

Chapter 73: Exercise
258. Exercise : USART send data to arduino
259. communicating with PC over UART

Chapter 74: USART interrupts
260. USART interrupt discussion
261. Exercise
262. USART IRQ handler implementation : Assignment

Chapter 75: Exercise : RTC on LCD
263. Real time clock on LCD
264. DS1307 RTC registers
265. RTC code implementation
266. RTC coding for set time and date
267. RTC coding for get time and date
268. BCD and Binary manipulation functions
269. Writing RTC application
270. RTC and Systick
271. LCD connections
272. Significance of LCD pins
273. LCD initialization
274. LCD initialization flowchart
275. Sending command and data to LCD
276. Creating LCD command code
277. Testing

Chapter 76: BONUS LECTURE
278. BONUS LECTURE

DATES
Published : 2016-07-21
Last Updated : 2026-01-02

If you fear the truth, don?t come to my well.