Mastering Microcontroller and Embedded Driver Development

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

File Size :

16.35 GB

Total length :

28h 33m

FastBit Embedded Brain Academy

Language

2/2023

Ratings

 4.6/5

Ultimate C Masterclass for 2023

PYSPARK Developer Course Spark with Python

AZ500 Microsoft Azure Security Technologies with SIMS

Microsoft AZ500 Certification Azure Security Technologies

Your Onboarding Journey to Xero

Mastering Microcontroller and Embedded Driver Development

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 and implementation
Explore MCU data sheets, Reference manuals, start-up Codes to 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 on 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

Description

>> Your Search for an in-depth microcontroller programming course ends here !!<<Overview

Section 1: Notes and Information

Lecture 1 About the instructor

Lecture 2 Important Note

Lecture 3 What is this course all about ??

Lecture 4 Source Code and Slides

Lecture 5 Rating and Review

Section 2: Development board used in our courses

Lecture 6 About MCU Development board

Section 3: Hardware/Software Requirements

Lecture 7 Hardware/Software Requirements

Section 4: IDE installation

Lecture 8 Downloading STM32CUBEIDE

Lecture 9 Installation-Windows

Lecture 10 Installation-Ubuntu

Lecture 11 Embedded Target

Lecture 12 Documents required

Section 5: Creating a project using STM32CUBEIDE

Lecture 13 Creating Hello-World project

Lecture 14 SWV working principle

Lecture 15 Testing Hello-World through SWV

Lecture 16 OpenOCD and Semihosting to use printf

Section 6: Embedded Code Debugging Tips and tricks

Lecture 17 Debugging options

Lecture 18 Single stepping

Lecture 19 Disassembly and Register windows

Lecture 20 Breakpoints

Lecture 21 Expression and variable windows

Lecture 22 Memory browser windows

Lecture 23 Call stack and fault analyzers

Lecture 24 Data watch-points

Lecture 25 SFR windows

Lecture 26 Other basic features of IDE

Section 7: Understanding MCU Memory Map

Lecture 27 Understanding Memory Map of the MCU: Part 1

Lecture 28 Understanding Memory Map of the MCU: Part 2

Lecture 29 Understanding Memory Map of the MCU: Part 3

Section 8: MCU Bus Interfaces

Lecture 30 MCU Bus Interfaces Explanation Part 1: I-Code/D-Code/S-Bus

Lecture 31 MCU Bus Interfaces Explanation Part 2: AHB/APB1/APB2

Lecture 32 MCU Bus Interfaces Explanation Part 3: Q/A session

Lecture 33 Understanding MCU Bus Matrix

Section 9: Understanding MCU Clocks and Details

Lecture 34 Understanding MCU Clocking System:Part1

Section 10: Understanding MCU Clock tree

Lecture 35 Understanding MCU clock sources and HSE

Lecture 36 HSI and RCC registers

Lecture 37 Peripheral clock configuration

Lecture 38 Exercise : HSI measurements

Lecture 39 About USB logic analyzer

Lecture 40 Code implementation

Lecture 41 Exercise : HSE measurements

Section 11: Understanding MCU Vector table

Lecture 42 Understanding MCU Vector Table

Section 12: Understanding MCU interrupt Design , NVIC, Interrupt handling

Lecture 43 Understanding MCU interrupt Design , NVIC, Interrupt handling: Part 1

Lecture 44 Understanding MCU interrupt Design , NVIC, Interrupt handling: Part 2

Lecture 45 Understanding MCU interrupt Design , NVIC, Interrupt handling: Part 3

Section 13: Importance of “Volatile” Keyword

Lecture 46 Importance of “Volatile” Keyword: Part-1

Lecture 47 Importance of “Volatile” Keyword-Part 2

Section 14: GPIO Must know concepts

Lecture 48 GPIO pin and GPIO port

Lecture 49 GPIO behind the scene

Lecture 50 GPIO input mode with high impedance state

Lecture 51 GPIO input mode with pull-up/down state

Lecture 52 GPIO output mode with open drain state

Lecture 53 GPIO output mode with push pull state

Lecture 54 Optimizing I/O power consumption

Section 15: GPIO Programming structure and Registers

Lecture 55 GPIO programming structure

Lecture 56 Exploring GPIO PORT and pins of STM32F4xx Discovery board

Lecture 57 GPIO Mode register(used to set mode for a pin)

Lecture 58 Input configuration of a Microcontroller’s GPIO Pin

Lecture 59 Output Configuration of a GPIO Pin in Push pull mode

Lecture 60 Output Configuration of a GPIO Pin in open drain mode

Lecture 61 Input stage of a GPIO pin during output configuration

Lecture 62 Alternate functionality Configuration of a GPIO pin

Lecture 63 GPIO out put type register explanation

Section 16: GPIO Registers : SPEED, PULL UP/DOWN, IDR and ODR

Lecture 64 GPIO output speed register and its applicability

Lecture 65 GPIO Pull up and Pull down register

Lecture 66 GPIO input data register

Lecture 67 GPIO output data register and summary of various modes discussed

Section 17: GPIO Alternate functionality register and example of usage

Lecture 68 Alternate functionality settings of a GPIO pin with example : Part 1

Lecture 69 Alternate functionality settings of a GPIO pin with example : Part 1

Lecture 70 Request for Review

Section 18: GPIO peripheral clock control

Lecture 71 Enabling and disabling GPIO peripheral clock

Section 19: GPIO driver development overview and Project creation

Lecture 72 GPIO driver development overview

Lecture 73 MCU Specific header file and its contents

Lecture 74 New project creation and creating MCU specific headerfile

Lecture 75 Include path settings

Lecture 76 Important note on IDE usage

Section 20: Updating MCU specific header file with bus domain and peripheral details

Lecture 77 Writing base address C macros for MCU’s embedded memories : Part 1

Lecture 78 Writing base address C macros for MCU’s embedded memories : Part 2

Lecture 79 Defining base addresses of different bus domains

Lecture 80 Defining base addresses of AHB1 Peripherals

Lecture 81 Defining base addresses of APB1 and APB2 Peripherals

Lecture 82 Defining base addresses conclusion

Section 21: Structuring peripheral registers

Lecture 83 Address of peripheral registers

Lecture 84 Structuring peripheral registers

Lecture 85 Peripheral definition macros

Section 22: Writing Clock enable and disable macros

Lecture 86 Writing peripheral clock enable and disable C Macros

Lecture 87 Project include settings and build

Section 23: GPIO driver API requirements and handle structure

Lecture 88 Creating GPIO driver header and source file

Lecture 89 Defining GPIO handle and configuration structure

Lecture 90 Driver API requirements and adding API prototypes

Lecture 91 Driver API input parameters and return types

Lecture 92 Driver empty API implementation and documentation

Section 24: GPIO driver API Implementation : Clock control

Lecture 93 Implementation of GPIO peripheral clock control API

Section 25: GPIO driver API Implementation : GPIO init and de-init

Lecture 94 Writing user configurable macros

Lecture 95 Implementation of GPIO init API

Lecture 96 Implementation of GPIO init API contd.

Lecture 97 Configuring Alternate function registers

Lecture 98 GPIO de-init API implementation

Section 26: GPIO driver API Implementation : GPIO data read and write

Lecture 99 Implementation of GPIO input port read and input pin read APIs

Lecture 100 Implementation of GPIO output port write and output pin write APIs

Lecture 101 Implementation of GPIO pin toggle API

Section 27: Exercise

Lecture 102 Exercise : LED toggling with PUSH PULL configuration

Lecture 103 Exercise : LED toggling with OPEN DRAIN configuration

Lecture 104 Exercise : Handling on board LED and Button

Lecture 105 Exercise : Connecting external button and circuit explanation

Lecture 106 Exercise : Testing button interface

Lecture 107 Exercise : Button interrupt introduction

Section 28: GPIO pin Interrupt configuration

Lecture 108 GPIO pin Interrupt configuration coding : Part 1

Lecture 109 GPIO pin Interrupt configuration coding : Part 2

Lecture 110 GPIO pin Interrupt configuration coding : Part 3

Lecture 111 GPIO pin Interrupt configuration coding : Part 4

Lecture 112 GPIO pin Interrupt configuration coding : Part 5

Lecture 113 GPIO pin Interrupt configuration coding : Part 6

Lecture 114 GPIO pin Interrupt configuration coding : Part 7

Section 29: Exercise : GPIO interrupts

Lecture 115 Exercise : External button interrupt implementation

Lecture 116 Exercise : Debugging the application : Part 1

Lecture 117 Exercise : Debugging the application : Part 2

Section 30: MCU I/O Pin specifications

Lecture 118 STM32 Pin specifications

Lecture 119 Pin current characteristics

Lecture 120 Logic levels

Section 31: SPI introduction and bus details

Lecture 121 Introduction to SPI Bus

Lecture 122 SPI comparison with other protocols

Lecture 123 Importance of SPI slave select pin

Lecture 124 SPI Minimum bus configuration

Lecture 125 SPI behind the scene data communication principle

Section 32: SPI bus configuration and functional block diagram

Lecture 126 SPI bus configuration discussion : full duplex, half duplex and simplex

Lecture 127 SPI functional block diagram explanation

Section 33: STM32 NSS pin settings and management

Lecture 128 NSS settings in STM32 master and slave modes

Lecture 129 STM32 SPI hardware and software slave managements

Section 34: SPI CPOL and CPHA discussion

Lecture 130 SPI CPOL and CPHA discussion

Lecture 131 SPI CPOL and CPHA waveform example

Section 35: SPI serial clock discussion

Lecture 132 SPI peripherals of your Microcontroller

Lecture 133 SPI Serial clock frequency

Section 36: SPI Driver : API requirements and configuration structure

Lecture 134 SPI API requirements and configuration items

Lecture 135 updating MCU specific header file with SPI related details

Lecture 136 SPI adding API prototypes to driver header file

Section 37: SPI Driver API Implementation : Clock control

Lecture 137 Implementation of SPI peripheral clock control API

Section 38: SPI Driver API Implementation : SPI init

Lecture 138 SPI user configuration options writing and register bit definition macros

Lecture 139 Implementation of SPI init API : Part 1

Lecture 140 Implementation of SPI init API : Part 2

Section 39: SPI Driver API Implementation : Send Data

Lecture 141 Implementation of SPI send data API : Part 1

Lecture 142 Implementation of SPI send data API : Part 2

Lecture 143 Implementation of SPI send data API : Part 3

Lecture 144 Implementation of SPI send data API : Part 4

Section 40: Exercise : SPI Send Data

Lecture 145 Exercise to test SPI Send Data API

Lecture 146 Finding out microcontroller pins to communicate over SPI2

Lecture 147 Exercise : Code implementation : Part 1

Lecture 148 Exercise : Code implementation : Part 2

Lecture 149 Exercise : Code implementation : Part 3

Lecture 150 Exercise : Testing

Section 41: Exercise : STM32 master and Arduino Slave communication

Lecture 151 Exercise : Communicating with Arduino slave

Lecture 152 Exercise : Coding Part 1

Lecture 153 Exercise : Coding Part 2

Lecture 154 Exercise : Coding Part 3

Lecture 155 Exercise : Testing

Section 42: SPI Driver API : Receive data

Lecture 156 Implementation of SPI data receive API : Part 1

Lecture 157 Implementation of SPI data receive API : Part 2

Section 43: Exercise : SPI receive data

Lecture 158 Exercise : SPI command and response based communication

Lecture 159 Exercise : Coding Part 1

Lecture 160 Exercise : Coding Part 2

Lecture 161 Exercise : Coding Part 3

Section 44: SPI interrupts

Lecture 162 SPI peripheral interrupting the processor

Section 45: SPI interrupt mode APIs

Lecture 163 SPI interrupt mode API implementation and changes to handle structure

Lecture 164 SPI send data with interrupt API implementation

Lecture 165 SPI receive data with interrupt implementation

Section 46: SPI Driver API : IRQ handling

Lecture 166 SPI : Handling of interrupts

Lecture 167 SPI IRQ handler implementation : Part 1

Lecture 168 SPI IRQ handler implementation : Part 2

Lecture 169 SPI IRQ handler implementation : Part 3

Lecture 170 Exercise

Section 47: Common problems in SPI

Lecture 171 Common problems in SPI and Debugging Tips

Section 48: I2C introduction and I2C signals

Lecture 172 I2C introduction and differences with SPI

Lecture 173 I2C SDA and SCL signals

Section 49: I2C modes

Lecture 174 I2C standard and fast mode

Section 50: Understanding I2C Protocol

Lecture 175 I2C Protocol explanation

Lecture 176 I2C START and STOP conditions

Lecture 177 I2C ACK and NACK

Lecture 178 I2C Data validity

Section 51: I2C master and slave communication

Lecture 179 Example of master writing to slave

Lecture 180 Understanding repeated START condition

Section 52: STM32 I2C functional block diagram

Lecture 181 I2C functional block diagram

Section 53: I2C driver API requirements and config structures

Lecture 182 I2C driver API requirements

Lecture 183 I2C handle and configuration structure

Lecture 184 I2C user configurable macros

Lecture 185 I2C API prototypes

Lecture 186 Steps for I2C init implementation

Section 54: I2C serial clock discussion(SCLK)

Lecture 187 I2C serial clock settings with explanation

Lecture 188 Clock Stretching

Section 55: I2C Driver API : I2C Init

Lecture 189 Implementation of I2C init API : Part 1

Lecture 190 Implementation of I2C init API : Part 2

Lecture 191 Implementation of I2C init API : Part 3

Section 56: I2C Driver API : I2C Master send data

Lecture 192 I2C transfer sequence diagram for master sending data

Lecture 193 Implementation of I2C master sending data API : Part 1

Lecture 194 Implementation of I2C master sending data API : Part 2

Lecture 195 Implementation of I2C master sending data API : Part 3

Lecture 196 Implementation of I2C master sending data API : Part 4

Lecture 197 Implementation of I2C master sending data API : Part 5

Section 57: I2C pull up resistance , rise time and bus capacitance

Lecture 198 I2C pull up resistance , rise time and bus capacitance discussion

Lecture 199 I2C rise time calculation

Section 58: Exercise

Lecture 200 Exercise : Introduction

Lecture 201 Exercise : Coding Part 1

Lecture 202 Exercise : Coding Part 2

Lecture 203 Exercise : Testing

Section 59: I2C Driver API : I2C Master receive data

Lecture 204 I2C transfer sequence diagram for master receiving data

Lecture 205 Assignment : I2C master receive data API implementation

Lecture 206 Implementation of I2C master receive data API : Part 1

Lecture 207 Implementation of I2C master receive data API : Part 2

Section 60: Exercise

Lecture 208 Exercise : Reading data from the I2C slave

Lecture 209 Exercise : Coding Part 1

Lecture 210 Exercise : Coding Part 2

Lecture 211 Exercise : Coding Part 3

Lecture 212 Exercise : Testing repeated start

Section 61: I2C Interrupts and IRQ numbers

Lecture 213 I2C IRQ and interrupt discussion

Lecture 214 I2C errors and importance of BUSY flag

Lecture 215 I2C handle structure modification

Lecture 216 I2C adding interrupt related macros and interrupt APIs

Section 62: I2C interrupt based APIs

Lecture 217 Assignment : I2C interrupt APIs implementation

Lecture 218 Implementation of I2C interrupt based APIs

Section 63: I2C IRQ handler implementation

Lecture 219 I2C IRQ handler implementation Part 1

Lecture 220 I2C IRQ handler implementation Part 2

Lecture 221 I2C IRQ handler implementation Part 3

Lecture 222 I2C IRQ handler implementation Part 4

Lecture 223 I2C IRQ handler implementation Part 5

Lecture 224 I2C IRQ handler implementation Part 6

Lecture 225 I2C IRQ handler implementation Part 7

Lecture 226 I2C IRQ handler implementation Part 8

Lecture 227 I2C error IRQ handler implementation

Section 64: Exercise

Lecture 228 Exercise : Testing I2C interrupt APIs part 1

Lecture 229 Exercise : Testing I2C interrupt APIs part 2

Section 65: I2C slave programming

Lecture 230 I2C slave programming discussion

Lecture 231 I2C transfer sequence diagram for slave transmitter

Lecture 232 I2C slave support in driver

Section 66: Exercise

Lecture 233 Exercise : I2C slave programming

Lecture 234 Exercise : Coding Part 1

Lecture 235 Exercise : Testing

Lecture 236 Exercise : Modifying I2C transactions

Section 67: Common problems in I2C

Lecture 237 Common Problems in I2C and Debugging Tips

Section 68: UART Essentials

Lecture 238 Intro UART vs USART

Lecture 239 Understanding UART pins

Lecture 240 UART frame formats

Lecture 241 Baud Rate

Lecture 242 Synchronization bits

Lecture 243 UART Parity

Section 69: UART functional block and Peripheral Clock

Lecture 244 Exploring UART functional block

Lecture 245 UART peripheral clock

Section 70: UART Communication

Lecture 246 UART Transmitter

Lecture 247 Uart Receiver

Section 71: USART driver development

Lecture 248 USART driver development confiugrable items

Lecture 249 USART driver APIs prototypes

Lecture 250 Configuration options and USART registers

Lecture 251 USART Driver API : USART Init

Lecture 252 USART Driver API : Tx and Rx assignment

Lecture 253 USART Driver API : Send data

Section 72: USART oversampling and baudrate

Lecture 254 USART oversampling

Lecture 255 USART Baud rate calculation Part-2

Lecture 256 USART Baud rate calculation Part-2

Lecture 257 USART baudrate coding

Section 73: Exercise

Lecture 258 Exercise : USART send data to arduino

Lecture 259 communicating with PC over UART

Section 74: USART interrupts

Lecture 260 USART interrupt discussion

Lecture 261 Exercise

Lecture 262 USART IRQ handler implementation : Assignment

Section 75: Exercise : RTC on LCD

Lecture 263 Real time clock on LCD

Lecture 264 DS1307 RTC registers

Lecture 265 RTC code implementation

Lecture 266 RTC coding for set time and date

Lecture 267 RTC coding for get time and date

Lecture 268 BCD and Binary manipulation functions

Lecture 269 Writing RTC application

Lecture 270 RTC and Systick

Lecture 271 LCD connections

Lecture 272 Significance of LCD pins

Lecture 273 LCD initialization

Lecture 274 LCD initialization flowchart

Lecture 275 Sending command and data to LCD

Lecture 276 Creating LCD command code

Lecture 277 Testing

Section 76: BONUS LECTURE

Lecture 278 BONUS LECTURE