Tags
Language
Tags
June 2025
Su Mo Tu We Th Fr Sa
1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 1 2 3 4 5
    Attention❗ To save your time, in order to download anything on this site, you must be registered 👉 HERE. If you do not have a registration yet, it is better to do it right away. ✌

    ( • )( • ) ( ͡⚆ ͜ʖ ͡⚆ ) (‿ˠ‿)
    SpicyMags.xyz

    Microcontroller Embedded C Programming: Absolute Beginners

    Posted By: ELK1nG
    Microcontroller Embedded C Programming: Absolute Beginners

    Microcontroller Embedded C Programming: Absolute Beginners
    Last updated 6/2022
    MP4 | Video: h264, 1280x720 | Audio: AAC, 44.1 KHz
    Language: English | Size: 4.80 GB | Duration: 16h 37m

    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