Training C language for Embedded MCUs: Learning how to program a Microcontroller (especially the Cortex-M based ones)

ac6-training, un département d'Ac6 SAS
 
Site displayed in English (USA)
Site affiché en English (USA)View the site in FrenchVoir le site en English (GB)
go-up

leftthintrapezium-20-008080 ac6 > ac6-training > Programming > Languages > C language for Embedded MCUs Inquire Download as PDF Call us Write us
L2C language for Embedded MCUs
Learning how to program a Microcontroller (especially the Cortex-M based ones)
Objectives
  • Reviewing the C language standard
  • Putting in evidence the essential C features used in embedded application
  • Discovering the Embedded context through several bare-metal labs running on an STM32F4 MCU (Cortex-M4 core based)
  • Discovering the Debug features
  • Understanding the different steps of a toolchain
  • Understanding how to configure a linker script to place code and data in memory
  • Getting an Overview on STM32F4 Architecture
  • Understanding the Cortex-M4 Application level programmers’ model
  • Reviewing the boot sequence
  • Analyzing the compiler optimization and how to write optimized code
  • Interfacing C and Assembly
  • Learning how to handle interrupts
  • Programming a serial communication
  • Configuring DMA transfers
  • Working with an ADC
  • Theoretical course
    • PDF course material (in English) supplemented by a printed version.
    • The trainer answers trainees' questions during the training and provide technical and pedagogical assistance.
  • Practical activities
    • Practical activities represent from 40% to 50% of course duration.
    • Code examples, exercises and solutions
    • One PC (Linux ou Windows) for the practical activities with, if appropriate, a target board.
      • One PC for two trainees when there are more than 6 trainees.
    • For onsite trainings:
      • An installation and test manual is provided to allow preinstallation of the needed software.
      • The trainer come with target boards if needed during the practical activities (and bring them back at the end of the course).
  • Downloadable preconfigured virtual machine for post-course practical activities
  • At the start of each session the trainer will interact with the trainees to ensure the course fits their expectations and correct if needed
  • Basic knowledge of C language (or another low-level language)
  • Knowledge of binary arithmetic
  • The knowledge of embedded processor philosophy is recommended
  • Any embedded systems engineer or technician with the above prerequisites.
  • The prerequisites indicated above are assessed before the training by the technical supervision of the traineein his company, or by the trainee himself in the exceptional case of an individual trainee.
  • Trainee progress is assessed in two different ways, depending on the course:
    • For courses lending themselves to practical exercises, the results of the exercises are checked by the trainer while, if necessary, helping trainees to carry them out by providing additional details.
    • Quizzes are offered at the end of sections that do not include practical exercises to verifythat the trainees have assimilated the points presented
  • At the end of the training, each trainee receives a certificate attesting that they have successfully completed the course.
    • In the event of a problem, discovered during the course, due to a lack of prerequisites by the trainee a different or additional training is offered to them, generally to reinforce their prerequisites,in agreement with their company manager if applicable.

Course Outline

  • Using cross compilation
  • Compiler, Assembler and Linker Purpose
  • C source program structure
  • Preprocessor
    • #define, #include instructions
    • Writing Macros with precaution
    • Writing Header files with precaution
  • Reviewing the different object file sections
  • Library inclusion
  • Startup file
  • GCC compiler options
  • Configuring the linker to place code and data in the memory, executing code from RAM
  • Makefile
Exercise:  Following the different build steps of a simple program
Exercise:  Working with Conditional Compilation
Exercise:  Working with the linker, placing code and data in the memory
  • Creating a project from scratch
  • Debug probe
  • Communicating with the Target
  • Debugger Windows : Source (C and Disassembly), Memory, Stack, Variables, Registers
  • Breakpoints
  • Variable storage class (static, automatic, register et extern) with their location and lifetime
  • Local and global variable declaration
  • Scalar types (char, halfword, int, float and double)
  • Constants
  • Strings
  • Type conversion, casting
  • The volatile attribute
  • C operators (logical, arithmetical and relational)
  • Operator priority
Exercise:  Working with types and operators
  • If/else structure
  • Switch/case structure
  • While, do/while and for loopf
  • Break, continue and go instructions
Exercise:  Working with control structures
  • Pointer definition
  • Pointer Initialization, pointer access, pointer operations
  • Constant and volatile pointer
  • The restrict attribute
  • One- and Multi-dimensional arrays
  • Array initialization, array access, array operations
  • Pointer array
Exercise:  Working with pointers
Exercise:  Working with arrays
  • Structure variable declaration
  • Structure variable pointer declaration
  • Structure field access
  • Padding, #pragma pack compilation directive
  • Big and little endian format
  • Bit field structure declaration
  • Modeling peripheral register
  • Structure array
  • Typedef type
  • Enum type
  • Union declaration
  • Union intitialization and operation
Exercise:  Modeling a STM32F2 timer to program it
  • Function prototype (arguments, return value)
  • Function definition and declaration
  • Function visibility
  • Function pointer
  • Function call
  • Passing parameter
  • Stack operation
  • Stack frame, call stack
  • The recursivity and the stack
  • Macro vs function
  • Pipeline and branch
  • Function inlining
  • Interfacing C and Assembler
Exercise:  Passing parameter to function
Exercise:  Analyzing the stack utilization
  • Stdio library
  • Getchar and putchar functions
  • Memcpy function
  • Printf and scanf functions
  • File access function review
  • Programming FIFOs
  • Programming Linked list (simple and double)
Exercise:  Working with linked list
  • Dynamic allocation functions: malloc, free function
  • Sizeof operator
  • Dynamic memory allocation vs static memory allocation
  • Stack vs Heap
  • Memory management algorithms overview
    • Buddy System
    • Best fit / First Fit
    • Pools Management
  • Memory management errors
Exercise:  Using dynamic allocation
  • Peripheral Programming
  • Peripheral register access and Memory access
  • Signed vs unsigned
  • Memory latency
  • Cache
  • Synchronization
  • Interruption necessity in an embedded context
  • Level and pulse triggered interrupts
  • Interrupt clearance
  • Interrupt handler writing
  • Vector table
  • Vector installation
  • V7-M Architecture Overview
  • Harvard Architecture, I-Code, D-Code and System Bus
  • Registers (Two stacks pointers)
  • States
  • Different Running-modes and Privileged Levels
  • System Control Block
  • Systick Timer
  • Alignment and Endianness
  • CMSIS Library
  • Exception / Interrupt Mechanism Overview
  • Vector Table
  • Interrut entry and return Overview
    • Tail-Chaining
    • Pre-emption (Nesting)
    • NVIC Integrated Interrupt Controller
    • Exception Priority Management
  • Debug Interface Ovevriew
  • Clarifying the boot sequence
Exercise:  Timer Interrupt Management
  • Compiler optimizations
  • Mixing C and Assembly
  • AAPCS
  • Function inlining
  • Unaligned Accesses, padding
  • Local and global data issues, alignment, Structure
Exercise:  Interfacing C and Assembler
Exercise:  Demo: Long Branch, Function inlining, padding
  • ARM core based architecture
  • Description of STM32F407X SoC architecture
  • Clarifying the internal data and instruction paths: Bus Matrix, AHB-lite interconnect, peripheral buses, AHB-to-APB bridges, DMAs
  • Memory Organization
    • Flash memory read interface
    • Adaptive Real-Time memory accelerator, instruction prefetch queue and branch cache
    • Sector and mass erase
    • Internal SRAMs
    • Concurrent access to 112 KB and 16 KB blocks
  • SoC mapping
  • Flash Programming methods
  • Boot Configuration
  • Power, Reset and Clocking Overview
  • DMA Overview
  • UART Overview
Exercise:  Get Metrics for a data copy using the DMA or not
Exercise:  Programming the UART to redirect the printf on the serial port
Exercise:  Displaying ADC value on LCD
Duration
4 days
Inquiry

This course can be scheduled upon request. Click the 'Inquire' button to contact us.

More

To book a training session or for more information, please contact us on info@ac6-training.com.

Registrations are accepted till one week before the start date for scheduled classes. For late registrations, please consult us.

You can also fill and send us the registration form

This course can be provided either remotely, in our Paris training center or worldwide on your premises.

Scheduled classes are confirmed as soon as there is two confirmed bookings. Bookings are accepted until 1 week before the course start.

Last update of course schedule: 10 March 2020

Booking one of our trainings is subject to our General Terms of Sales