Autoplay
Autocomplete
Previous Lesson
Complete and Continue
Advanced C++ Template Metaprogramming for Embedded Systems
Introduction
Welcome(Same as Promo) (1:40)
Course Requirements
IMPORTANT: About the Generic Drivers Section (1:52)
Fundamentals of Template Metaprogramming in Embedded Systems
Introduction to Template Metaprogramming in C++ (2:09)
Function Templates and Class Templates (2:00)
How Templates Enable Zero-Cost Abstractions (1:50)
Templates for Peripheral Drivers and Hardware Abstraction
Template Specialization for Microcontroller Peripherals (1:29)
Using Templates for Peripheral Drivers and Hardware Abstraction (1:29)
Variadic Templates for Flexible Driver Configuration (1:25)
Compile-Time Optimization with Template Metaprogramming
Static Polymorphism vs Virtual Functions in Embedded Systems (2:42)
Curiously Recurring Template Pattern (CRTP) for Zero Cost Inheritance (1:06)
Realworld Applcations of Template Metaprogramming in Embedded Systems (3:12)
Setting Up
Downloading CubeIDE (2:34)
Installing CubeIDE (2:38)
Getting the required documentation (7:41)
Getting the required package for bare-metal development (21:19)
Testing the project setup (15:54)
Source Code Download
Developing Some Generic Drivers for Running Examples
Important information about this section
Programming : Enabling the Floating Point Unit (FPU) (18:00)
Programming : Developing a UART Driver - Analyzing the Documentation (11:35)
Programming : Developing a UART Driver - Listing out the steps (4:00)
Programming : Developing a UART Driver - Implementing the Init. function (22:13)
Programming : Developing a UART Driver - Implementing the Write function (5:39)
Programming : Developing a UART Driver - Testing the Driver (6:39)
Programming : Developing the System Timebase - Analyzing the Documentation (8:28)
Programming : Developing the System Timebase - Implementing the Init. function (9:52)
Programming : Developing the System Timebase - The rest of the functions (12:15)
Programming : Developing the System Timebase - Testing the Timebase (5:34)
Programming : BSP : Listing the out the Required Functions (7:55)
Programming : Writing the LED Driver (5:01)
Programming : Writing the PushButton Driver (4:00)
Programming : Testing the Board Support Package (3:35)
Programming : Analyzing the Documentation (5:21)
Programming : Listing out the steps for developing the ADC Driver (5:27)
Programming : Writing the ADC Initialization function (13:21)
Programming : Writing the ADC Read function (14:05)
Programming : Analyzing the Documentation for the SPI Driver (7:34)
Programming : Intializing the GPIO Pins for SPI (11:00)
Programming : Implementaing Structures for Configruation Parameters (15:29)
Programming : Configuring the Parameters (15:41)
Programming : Writing the SPI Initialization function (14:55)
Programming : Writing the SPI Transmit Function (Pt.1) (9:27)
Programming : Writing the SPI Transmit Function (Pt.2) (10:26)
Programming : Transmitting 16-bit Data (17:54)
Programming : Transmitting 8-bit Data (6:46)
Programming : Receiving Data (11:05)
Programming : Testing the SPI Driver (15:47)
Programming : Analyzing the Documentation for the I2C Driver (10:47)
Programming : I2C : The GPIO Initialization (10:35)
Programming : Configuring the I2C Parameters (10:22)
Programming : Implementing the I2C Read function (13:44)
Programming : Implementing the I2C Burst Read function (7:25)
Programming : Implementing the I2C Write functions (10:17)
Transitioning from Procedural C to OOP in Embedded Firmware
Principles for Refactoring Embedded C Code to Embedded C++ (1:07)
Developing the GPIO C++ Class Driver
Programming: Updating the Workspace (1:05)
Programming: Configuring the Project Paths for C++ Development (5:46)
Programming: Implementing the Private Members of the Class (6:22)
Programming: Implementing the Class Constructor (10:33)
Programming: Implementing the Pin Control Methods (4:35)
Programming: Testing the GPIO Class (5:14)
Programming: Having Separate Interface and Implementation Files (8:58)
Developing the UART C++ Class Driver
Programming: Implementing the Private Members (4:42)
Programming: Implementing the Class Constructor (5:28)
Programming: Implementing the Public Methods (2:42)
Programming: Testing the UART Class (2:05)
Working with Function Templates
Generic Function Template Syntax (3:06)
Understanding the 'typename' Keyword (1:32)
Working with Multiple Template Parameters (4:48)
Overloading Function Templates (1:14)
Programming: Updating the Workspace (1:20)
Programming: Implementing the Function Template (3:11)
Programming: Testing the Function Template (13:24)
Programming: Implementing the Function Template for Multiple Data Types (4:46)
Working with Class Templates
Overview of Class Templates (1:41)
Programming: Implementing the Private Members (2:20)
Programming: Writing the Template Declaration (3:29)
Programming: Implementing the 'Push' Method (2:48)
Programming: Implementing the Rest of the Methods (3:26)
Programming: Testing the Class Template (8:47)
Working with Non-type Templates
Programming: Working with the Non-type Template (5:31)
Working with Variadic Templates
Understanding Variadic Templates (1:04)
Programming: Working with Variadic Templates(Pt.1) (6:45)
Programming: Working with Variadic Templates(Pt.2) (9:24)
Programming: Testing the Variadic Template Implementation (2:36)
The LED Class Template
Programming: Getting the Register Information from the Documentation (10:35)
Programming: Implementing the Register Namespace (10:00)
Programming: Implementing the Interface for the Run-Time LED Driver (5:56)
Programming: Run-Time LED Driver- The Constructor(Pt.1) (5:59)
Programming: Run-Time LED Driver- The Constructor(Pt.2) (7:01)
Programming: Implementing the Other Methods (2:19)
Programming: Implementing the Compile-Time LED Driver (5:29)
Programming: Implementing the LED Template Class (4:40)
Programming: Testing the Compile-Time LED Driver (8:51)
Programming: Testing the Run-Time LED Driver (2:53)
The Register Access Template
Programming: Analyzing the Memory Map for Peripheral Base Addresses (7:46)
Programming: Ordering the Namespaces (3:10)
Programming: Deriving the AHB1 and RCC Addresses (5:52)
Programming: Deriving the Base Addresses of the GPIO Peripherals (5:07)
Programming: Defining the relevant RCC Registers (3:59)
Programming: Deriving the Offsets of the various GPIO Registers (4:54)
Programming: Defining the relevant GPIO Registers (1:17)
Programming: Completing the MCAL Register Interface File (1:19)
The Template Class for Register Access
Programming: Understanding the Parameters (3:40)
Programming: Implementing the Methods of the Template Class (6:05)
Testing the Register Access Template
Programming: Enabling Clock Access to the GPIO (3:08)
Programming: Configuring the Pin as Output (3:49)
Programming: Toggling the Pin (4:42)
Template with Bit-Mapping
Programming: Implementing the BitField32 (3:41)
Programming: Implementing the Template Structure for Dynamic Register Mapping (5:49)
Programming: Testing the Dynamic Register Mapping (6:18)
Static Polymorphism vs Virtual Functions in Embedded Systems
Lesson content locked
If you're already enrolled,
you'll need to login
.
Enroll in Course to Unlock