>>> Your Search for in-depth Microcontroller Programming Course ends here !!<<<
The course is designed for Beginners to Advanced audience.
- 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
- Basic knowledge of C and Micro controller could be added advantage but not mandatory.
Brief Description By Course Instructor-
This Course Demystifies the internal working of the Microcontroller and its Peripherals.
Coding for the Peripherals STEP-BY-STEP and Developing software drivers completely from scratch by extracting maximum information from Datasheets,Reference manuals, specs,etc
Protocol Decoding Using logic analyzers, Debugging, Testing along with Hints and Tips.
Learning Embedded System Programming, can be a challenge. Since it’s a relatively little complex field, there’s no real 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 able to connect the dots and this is the motivation behind creating this course to help engineers and students to learn different aspects of embedded systems by providing high quality advanced lectures with relatively low price.
Learn at your own pace using progressive method, with each of my short, info-packed lectures.
Master Behind the Scene working !
I 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 are going to learn writing your own peripheral driver for most of the commonly used peripherals such as GPIOs, I2C, SPI, USART, etc. and interesting thing is that you are going to learn everything from scratch.
No 3rd party libraries !
No blind coding !
Write your own 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 procedure how to Configure various Peripherals like GPIOs,SPI,USART,I2C by taking you into the reference manual and data sheet. We will develop 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 definitely learn something new that you can definitely use in your work or projects. You’ll find yourself handling these peripherals with much more clarity and you will be able to quickly speculate and debug the problem and I’ll show you tricks and tips to debug the most common problems using debugging tools such as logic analyzers.
This is not Arduino Style of programming!
I believe Arduino is for quick prototyping of products but not for Mastering Working of microcontrollers and its peripherals. Unlike Arduino programming where you come up with quick solution and prototyping of products using third party libraries, this course is entirely different. In this course no 3rd party libraries is used. Everything we will code by referring to the Technical reference manual of the MCU and create our own library. The Power of this approach is when things go wrong in your project work due to bugs, you can quickly able to speculate problem and debug like a pro. If one thing me and my students are good at is “debugging”. To achieve good debugging skills its very important you code by understanding how things works behind the scene but no by just blindly using some third party libraries and that’s the biggest TAKE away from this Course.
The course is designed and explained in such a way that, it is generic across any kind of microcontroller. The code we develop can be used as templates to quickly come with peripheral driver for your MCUs on chip peripherals.
In this course, the code is developed such a way that, It can be ported to any MCU you have at your hand. If you need any help in 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 which runs with ARM-Cortex M3/M4 processor, then I recommend you to continue using it. But if you don’t have any Development board, then checkout the below Development boards.
1. STM32F407xx based Discovery board ( This is the board used in this course )
MCU Vendor : STMicroelectronics
2. STM32 Nucleo-64 development board( New in the market )
MCU Vendor : STMicroelectronic
3. FRDM-K64F: Freedom Development Platform
MCU Vendor : NXP
4. STM32F429IDISCOVERY with LCD
MCU Vendor : STMicroelectronics
- 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