Microcontroller Embedded C Programming: Absolute Beginners

Foundation course on Embedded C programming using STM32 Microcontroller.

What you'll learn
'C' programming from scratch
Data types,variables, declarations,
Importance of Bit-Wise operators in "Embedded" programming
Bit manipulation techniques using bit-wise operators and examples
Bit extraction and working with memory mapped peripheral registers
Other operators of 'C' (arithmatic, logical, relation, assignment )
Functions in 'C'
Implicit and explicit casting and its importance
Pointers and casting
Pointers arithmetic and importance of pointer datatypes
Accessing memory mapped peripheral registers using pointers
Structures and unions
Importance of structures in peripheral register access
Structure and bit fields
Configuring peripheral register addresses using bit fields
Structures and pointers
interfacing LEDs, Keypad
Const and volatile type qualifiers
importance of volatile during compiler optimization
const data, const pointer, cont volatile explanation with examples
Importance of const
Loops : for, while, do while
Requirements
Basic understanding of number systems , logic gates , bits and bytes.
STM32F407 discovery board is required if you want to try out code on the target
Description
==> This should be your very first course to dive into the exciting world of "Embedded Systems." <==This is our new course mainly targeted for absolute beginners to learn microcontroller programming using the 'C ' programming language. Please note that "Embedded C" is NOT a separate programming language. 'Embedded C' is rather embedded target aware programming using traditional 'C' programming language.Some of the critical microcontroller-related 'C' concepts such as Importance of bitwise operatorsUsage of bit manipulation techniques to program MCU peripheral registersaccessing memory-mapped registers using pointers pointers and casting structures, bitfields, unions, and bit extraction techniques representing hardware registers details and configuring them using 'C' structure definitions Usage of const and volatile type qualifiersInterpret complex variable definitions involving the combination of const and volatile The precise usage of const pointers, const data, volatile const, with pointer and non-pointer variables The behavior of the code during compiler optimization and solution using volatileFunctions and friends Data types, variables definitions, storage class specifiers and much moreLoops: while, for, do. while MCU internal architecture and programming peripherals Interfacing projectsAll these concepts are discussed with clear examples and writing code for the target embedded board. According to 2017 embedded dot com survey still 'C' is one of the most widely used programming languages  for embedded code developmentThis course gives particular emphasis to learn 'C' programming concepts practically for microcontroller use cases. Hardware:1. You need ARM Cortex M4 based STM32F407 DISCOVERY board from ST if you want to try out code on the target. 2. Additional interfacing components may be required for interfacing projects 3. You can also be able to follow this course if you have any other boards from ST such as Nucleo or evaluation. Software:1. In this course, Eclipse-based STM32CubeIDE is used as the  IDE ( works on Windows/Linux/Mac) (FREE)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) Embedded System Design using UML State Machines(State machine)6) Mastering RTOS: Hands-on FreeRTOS and STM32Fx with Debugging(RTOS)7) ARM Cortex M Microcontroller DMA Programming Demystified(DMA)8) STM32Fx Microcontroller Custom Bootloader Development(Bootloader)9) Embedded Linux Step by Step using Beaglebone Black(Linux)10) Linux device driver programming using Beaglebone Black(LDD1)

Overview

Section 1: Introduction

Lecture 1 About the instructor

Lecture 2 Programming languages for Embedded Systems

Lecture 3 History of 'C' and standardization

Lecture 4 Course repository

Lecture 5 Important Note

Section 2: IDE installation

Lecture 6 Downloading IDE

Lecture 7 Downloading IDE

Lecture 8 Key features of the STM32CubeIDE

Lecture 9 Installing STM32CubeIDE

Lecture 10 Installing STM32CubeIDE on Linux

Lecture 11 Installing compiler (GCC) for host

Lecture 12 Installing compiler (GCC) for host (WINDOWS)

Lecture 13 Installing compiler (GCC) for host (LINUX)

Lecture 14 Installing compiler (GCC) for host (MAC)

Lecture 15 Importing course projects in to workspace

Lecture 16 Creating a project for the HOST

Lecture 17 Creating a project for the Target

Lecture 18 FPU warning fix

Lecture 19 Hardware/Software Requirements

Lecture 20 Meet the embedded target of this course

Section 3: Your first 'C' program

Lecture 21 OnlineGDB web tool

Lecture 22 Printf and Hello World

Lecture 23 Printf exercise solution

Lecture 24 Escape sequences in 'C'

Lecture 25 Printf exercise solution

Lecture 26 Printf exercise solution

Lecture 27 Commenting in 'C'

Section 4: Data types and variables

Lecture 28 Data types in 'C'

Lecture 29 'C' Integer data types and value ranges

Lecture 30 Char data type and variable definition

Lecture 31 Variable definition exercise

Lecture 32 Range calculation for 'char' data type

Lecture 33 Integer data type 'short int' and value range

Lecture 34 Integer data type 'int' and 'long'

Lecture 35 Sizeof

Lecture 36 Variables naming rules and definition vs declaration

Lecture 37 Declaration vs definition : An illustration

Lecture 38 Variables scope and illustration

Lecture 39 Variables scope and illustration contd

Lecture 40 Summary of local and global variables

Section 5: Address of variable

Lecture 41 Address of variables

Lecture 42 Address of variables contd.

Section 6: Storage classes

Lecture 43 Storage class specifiers in 'C'

Lecture 44 Use cases of 'static' with variables

Lecture 45 Use cases of 'static' with functions

Lecture 46 'Extern' storage class specifier

Lecture 47 ASCII codes

Section 7: functions

Lecture 48 Introduction to functions in 'C'

Lecture 49 Function prototypes

Lecture 50 Returning data from a function

Lecture 51 Function exercise

Lecture 52 Typecasting in 'C'

Lecture 53 Typecasting in 'C' contd

Section 8: Microcontroller and Hello World

Lecture 54 Embedded - 'Hello World'

Lecture 55 Testing printf over ARM Cortex M4 ITM+SWO line

Lecture 56 Issues with IDE

Lecture 57 Testing printf over OpenOCD semihosting

Lecture 58 Run Sizeof on Embedded Target

Lecture 59 Sizeof testing

Lecture 60 Compiler settings on STM32CubeIDE

Section 9: Build process

Lecture 61 Embedded project build process

Section 10: Analyzing Embedded C code

Lecture 62 What is a Microcontroller ?

Lecture 63 Code memory of the microcontroller

Lecture 64 Code and Data of the program using memory browser

Lecture 65 Analyzing ELF file using GNU tools

Lecture 66 Disassembly

Lecture 67 IDE option for Instruction level debugging

Section 11: Data types to manipulate floating point data

Lecture 68 Manipulating decimal numbers in 'C'

Lecture 69 Single vs double precision

Lecture 70 Working with float and double variables

Section 12: Taking input from the user using scanf()

Lecture 71 Scanf introduction

Lecture 72 Scanf exercise implementation

Lecture 73 Scanf exercise implementation contd.

Lecture 74 Scanf exercise

Lecture 75 Scanf exercise implementation

Lecture 76 Scanf and float with scientific notation

Section 13: Pointers

Lecture 77 Pointers in 'C'

Lecture 78 Pointer variables and pointer data types

Lecture 79 Pointer variables and initialization

Lecture 80 Read and Write operation on pointers

Lecture 81 Pointer exercise implementation

Lecture 82 Significance of pointer data types

Lecture 83 Significance of pointer data types

Section 14: Importance of

Lecture 84 Importance of

Section 15: Operators

Lecture 85 Operators in 'C'

Lecture 86 Unary operator in 'C'

Lecture 87 Unary operators with pointers

Lecture 88 Relational operators in 'C'

Lecture 89 Logical operators in 'C'

Section 16: decision making

Lecture 90 'if' statement

Lecture 91 if statement exercise

Lecture 92 'if' statement exercise solution

Lecture 93 'if' and 'else'

Lecture 94 'if' and 'else' exercise implementation part-1

Lecture 95 'if' and 'else' exercise implementation part-2

Lecture 96 'if' and 'else' exercise implementation part-3

Lecture 97 'if -else-if' ladder statements

Lecture 98 'if-else-if' ladder exercise

Lecture 99 'if-else-if' ladder exercise solution

Lecture 100 Conditional operator

Lecture 101 switch case statement in 'C'

Lecture 102 switch case exercise

Lecture 103 switch case exercise solution

Lecture 104 switch case exercise solution contd.

Section 17: Bitwise operators

Lecture 105 Bitwise operators in 'C'

Lecture 106 Bitwise AND and bitwise OR

Lecture 107 Applicability of bitwise operators : Testing of bits

Lecture 108 Finding a number even or odd using testing of bits

Lecture 109 Applicability of bitwise operators : Setting of bits

Lecture 110 Applicability of bitwise operators : Clearing of bits

Lecture 111 Applicability of bitwise operators : xor

Section 18: Embedded C coding exercise for LED

Lecture 112 Coding to Turn on an LED

Lecture 113 Controlling IO pin using software

Lecture 114 Processor addressable memory regions

Lecture 115 STM32 memory map

Lecture 116 Memory mapped peripheral registers and IO access

Lecture 117 Procedure to turn ON the LED

Lecture 118 Enabling peripheral clock

Lecture 119 Calculating peripheral register addresses

Lecture 120 LED ON exercise coding

Section 19: Bitwise shift operators

Lecture 121 Bitwise right shift operator

Lecture 122 Bitwise left shift operator

Lecture 123 Applicability of bitwise shift operators

Lecture 124 Modifying LED on exercise using bitwise shift operators

Lecture 125 Bit Extraction

Section 20: Looping

Lecture 126 Looping in 'C'

Lecture 127 While loop

Lecture 128 while loop exercise

Lecture 129 while loop and semicolon

Lecture 130 while loop exercise

Lecture 131 'do while' loop

Lecture 132 'for' loop

Lecture 133 'for' loop exercise

Lecture 134 'for' loop number pyramid exercise

Lecture 135 'for' loop exercise solution

Lecture 136 modifying LED on with software delay

Lecture 137 LED toggle using software delay

Section 21: Type qualifier 'const'

Lecture 138 'const' type qualifier

Lecture 139 placements of 'const' variables in memory

Lecture 140 'const' usage and different case studies

Lecture 141 'const' usage and different case studies contd

Section 22: Pin-read

Lecture 142 IO pin read exercise

Lecture 143 IO pin read exercise implementation

Section 23: Optimization

Lecture 144 Compiler optimization and flags

Lecture 145 Different compiler optimization levels

Lecture 146 Analyzing pin read exercise disassembly with O0 and O2

Section 24: 'volatile' type qualifier

Lecture 147 volatile and effect of optimization

Lecture 148 When to use volatile qualifier ?

Lecture 149 Using volatile to fix issues with the pin-read exercise

Lecture 150 Using 'volatile' with ISR Part-1

Lecture 151 Using 'volatile' with ISR Part-2

Lecture 152 Usage of const and volatile together

Section 25: Structures and Bit fields

Lecture 153 Introduction to structures

Lecture 154 Accessing structure member elements

Lecture 155 Sizeof of a structure

Lecture 156 Aligned and un-aligned data storage

Lecture 157 Structure padding

Lecture 158 Calculating structure size manually with and without padding

Lecture 159 Assembly code analysis of packed and non packed structure

Lecture 160 Typedef and structure

Lecture 161 Structures and pointers

Lecture 162 Structure exercise

Lecture 163 Structure exercise implementation

Lecture 164 Structure and bit fields

Lecture 165 Structure and bit fields contd.

Section 26: Unions

Lecture 166 Unions

Lecture 167 Applicability of unions

Section 27: Usage of bit-fields in embedded code

Lecture 168 Bit-field exercise : Creating bit-field structure for peripheral registers

Lecture 169 Bit-field structure for RCC_AHB1ENR

Lecture 170 Bit-field structure for GPIOx_ODR

Lecture 171 Modifying led toggle exercise with structures and bit fields

Lecture 172 Testing

Section 28: Keypad interfacing

Lecture 173 Keypad interfacing

Lecture 174 Why pull-up resistors?

Lecture 175 Detecting key press event

Lecture 176 Flow chart for implementation

Lecture 177 Keypad key read code implementation

Lecture 178 Delay analysis

Section 29: Arrays

Lecture 179 Arrays in 'C'

Lecture 180 Read-Write operation on an array

Lecture 181 Passing array to a function

Lecture 182 Swapping of arrays

Lecture 183 Swapping of arrays contd.

Section 30: Strings

Lecture 184 Strings in 'C'

Lecture 185 String literal

Lecture 186 String variable Vs string literal

Lecture 187 Inputting a string

Lecture 188 Scanf and scanset

Lecture 189 Exercise

Section 31: Pre-Processor directives in 'C'

Lecture 190 Pre-Processor directives in 'C'

Lecture 191 Conditional compilation directives

Lecture 192 'defined' operator

Lecture 193 Modifying led toggle exercise with macros

Lecture 194 BONUS LECTURE

Beginners curious about embedded systems and microcontroller programming