English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 96 Lectures (11h 0m) | 5.12 GB
Mastering C++ Object-Oriented Programming for Microcontroller-Based Firmware Development
In today’s competitive embedded industry, mastering Object-Oriented Programming (OOP) in C++ isn’t just an advantage, it’s essential for success at leading tech companies such as Google, Apple, Garmin, Tesla, and Bosch.
This advanced course empowers embedded engineers with the skills needed to develop robust, maintainable, and highly performant firmware tailored for microcontrollers.
Throughout this expertly structured course, you’ll move beyond procedural C and deeply integrate advanced C++ Object-Oriented principles into embedded systems development.
Learn how industry leaders effectively implement OOP to achieve modular, maintainable, and highly performant firmware, even within strict resource constraints.
Apply everything you’ve learned in a comprehensive capstone project.
Develop a real-world embedded system incorporating advanced peripherals such as DMA, RTC, ISR , PWR and multiple environmental sensors (pressure, humidity, temperature, air quality, and light intensity).
- Build and deploy firmware using robust, scalable, and optimized object-oriented designs.
- Practical OOP Implementation: Create driver classes for GPIO, UART, SPI, I2C, and Timers, applying advanced encapsulation and RAII techniques to ensure safety and efficiency.
- Performance-Focused OOP: Learn optimization strategies to leverage OOP features without incurring unnecessary overhead in memory usage, execution speed, and code complexity.
- Advanced C++ Techniques: Master operator overloading for intuitive hardware interactions, implement safe memory management strategies (avoiding dynamic memory), and employ RAII for robust peripheral control.
- Inheritance and Polymorphism: Understand when and how to apply inheritance, explore static vs. dynamic polymorphism, and effectively manage virtual function overhead using CRTP (Curiously Recurring Template Pattern) and static polymorphism techniques.
- Practical Real-World Examples: Work through professional-grade case studies including:
– Optimizing sensor drivers for efficient resource use
– Creating a modular firmware structure for environmental data logging
– Managing interrupts and timers using OOP principles
By completing this course, you will:
- Master advanced OOP concepts essential for high-performance embedded firmware.
- Develop modular, scalable, and reusable driver architectures using C++.
- Understand and apply RAII, encapsulation, inheritance, and operator overloading for firmware optimization.
- Implement safe, efficient memory management suitable for resource-constrained systems.
- Gain professional expertise to confidently handle complex embedded firmware projects at top-tier companies.
Whether you’re transitioning from embedded C or enhancing your existing embedded C++ knowledge, this course positions you as a top candidate for advanced embedded software roles at industry-leading organizations like Google, Apple, Tesla, and Bosch.
Table of Contents
Introduction
1 Welcome(Same as Promo)
2 Course Requirements
3 IMPORTANT About the Generic Drivers Section
Introduction to Embedded Object-Oriented Programming (OOP) in C++
4 Object-Oriented Programming in Large Scale Embedded Firmware Projects
5 Misconceptions About OOP Overhead in Microcontrollers
6 When to Use Object-Oriented Programming
7 When to Use Procedural Programming
8 How C++ Features Impact Flash, RAM and Execution Speed
Microcontroller Constraints & Object-Oriented Programming Optimization
9 Why Dynamic Memory Allocation is Discrouraged
10 Why Transition from Procedural C to Object-Oriented Programming
Setting Up
11 Downloading CubeIDE
12 Installing CubeIDE
13 Getting the required documentation
14 Getting the required package for bare-metal development
15 Testing the project setup
Developing Some Generic Drivers for Running Examples
16 Important information about this section
17 Programming Enabling the Floating Point Unit (FPU)
18 Programming Developing a UART Driver – Analyzing the Documentation
19 Programming Developing a UART Driver – Listing out the steps
20 Programming Developing a UART Driver – Implementing the Init. function
21 Programming Developing a UART Driver – Implementing the Write function
22 Programming Developing a UART Driver – Testing the Driver
23 Programming Developing the System Timebase – Analyzing the Documentation
24 Programming Developing the System Timebase – Implementing the Init. function
25 Programming Developing the System Timebase – The rest of the functions
26 Programming Developing the System Timebase – Testing the Timebase
27 Programming BSP Listing the out the Required Functions
28 Programming Writing the LED Driver
29 Programming Writing the PushButton Driver
30 Programming Testing the Board Support Package
31 Programming ADC- Analyzing the Documentation
32 Programming Listing out the steps for developing the ADC Driver
33 Programming Writing the ADC Initialization function
34 Programming Writing the ADC Read function
35 Programming Analyzing the Documentation for the SPI Driver
36 Programming Intializing the GPIO Pins for SPI
37 Programming Implementaing Structures for Configruation Parameters
38 Programming Configuring the Parameters
39 Programming Writing the SPI Initialization function
40 Programming Writing the SPI Transmit Function (Pt.1)
41 Programming Writing the SPI Transmit Function (Pt.2)
42 Programming Transmitting 16-bit Data
43 Programming Transmitting 8-bit Data
44 Programming Receiving Data
45 Programming Testing the SPI Driver
46 Programming Analyzing the Documentation for the I2C Driver
47 Programming I2C The GPIO Initialization
48 Programming Configuring the I2C Parameters
49 Programming Implementing the I2C Read function
50 Programming Implementing the I2C Burst Read function
51 Programming Implementing the I2C Write functions
Transitioning from Procedural C to OOP in Embedded Firmware
52 Principles for Refactoring Embedded C Code to Embedded C++
Developing Peripheral Drivers Using C++ Classes
53 Basic Structure of a Peripheral Driver Class
54 Understanding Constructor and Destructor Based Resource Management
55 Encapsulating with Getter and Setter Methods
56 Why Direct Memory Access Needs Encapsulation
57 Understanding RAII (Resource Acquisition Is Initialization)
Developing the GPIO C++ Class Driver
58 Programming Updating the Workspace
59 Programming Configuring the Project Paths for C++ Development
60 Programming Implementing the Private Members of the Class
61 Programming Implementing the Class Constructor
62 Programming Implementing the Pin Control Methods
63 Programming Testing the GPIO Class
64 Programming Having Separate Interface and Implementation Files
Developing the UART C++ Class Driver
65 Programming Implementing the Private Members
66 Programming Implementing the Class Constructor
67 Programming Implementing the Public Methods
68 Programming Testing the UART Class
Developing the FPU C++ Class Driver
69 Programming Implementing the FPU Class Driver
Developing the SysTick Timer C++ Class Driver
70 Programming Implementing the Interface File
71 Programming Implementing the SysTick Class Driver
Developing the ADC C++ Class Driver
72 Programming Implementing the Private Members
73 Programming Implementing the Class Constructor
74 Programming; Implementing the Initialization Method
75 Programming Implementing the ADC Read Method
76 Programming Testing the ADC Class
Developing the SPI and Accelerometer C++ Class Drivers
77 Programming Analyzing the SPI Embedded-C Driver
78 Programming Analyzing the ADXL345 Embedded-C Driver
79 Programming Implementing the Interface File
80 Programming Implementing the SPI Class Constructor
81 Programming Implementing the Other Private Methods
82 Programming Implementing the Transmit Method
83 Programming Implementing the Receive and Chip Select Methods
84 Programming Implementing the ADXL345 Class- Private Members
85 Programming Implementing the ADXL345 Class- Public Members
86 Programming Implementing the Class Constructor
87 Programming Implementing the writeRegister( ) Method
88 Programming Implementing the readRegister( ) Method
89 Programming Implementing the ADXL345 Initialization Method
90 Programming Implementing the updateAccleration( ) Method
91 Programming Implementing the Methods for Returning Acceleration Data
Operator Overloading for Hardware Interaction in Embedded Systems
92 Programming Listing out the Operators
93 Programming Defining the Method Prototypes
94 Programming Implementing the Methods(Pt.1)
95 Programming Implementing the Methods(Pt.2)
96 Programming Testing the GPIO Operator Implementation
Resolve the captcha to access the links!