NR3NXP + FreeRTOS + West
FreeRTOS with NXP MCUXpresso
|
Objectives
|
- C Language knowledge (see for example our L2 training course)
- Familiarity with Git and command-line tools
- Theoretical course
- PDF course material (in English) supplemented by a printed version for face-to-face courses.
- Online courses are dispensed using the Teams video-conferencing system.
- 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
- For remote trainings:
- One Online Linux PC per trainee for the practical activities.
- The trainer has access to trainees' Online PCs for technical and pedagogical assistance.
- QEMU Emulated board or physical board connected to the online PC (depending on the course).
- Some Labs may be completed between sessions and are checked by the trainer on the next session.
- For face-to-face trainings:
- 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
- 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
- SDK structure and components
- Toolchains, CMake and Ninja integration
- Application structure and examples
- Overview
- Application components and structure
- Application
- Modules
- West workspace
- Why West? Problems solved
- West as a meta-tool: repository + commands
- Alternatives (git submodules, repo) and limitations
- West
- West structure
- Using west
- West manifest
- West commands
- West topologies
- Anatomy of west.yml
- Specific commands and common extensions
- Init, update, list, config
- Build, debug, attach, flash
- Other common commands
- Extending West with custom commands
| Exercise: | Getting started with West and MCUXpresso SDK | |
| Exercise: | Create a custom workspace manifest while importing only required projects | |
- Setting up host tools (Git, Python, CMake, Ninja)
- Integrating LinkServer, Jlink and other debuggers
- Debugging workflow with GDB
- VSCode integration (tasks, debug sessions)
- MCUXpresso for VSCode
| Exercise: | Build, flash and debug using command line and customize IDE | |
- Overview of the configuration tool suite (Pins, Clocks, Peripherals, Device settings)
- How Config Tools integrate with MCUXpresso SDK and West builds
- Generating initialization code (pin_mux.c/h, clock_config.c/h, peripheral setup)
- Using the graphical interface to configure GPIO, UART, and system clocks
- Exporting configuration files and re-integrating them into applications
- Limitations and best practices when combining with Kconfig/prj.conf
| Exercise: | Customize existing boards | |
- Custom manifests for minimal projects
- Writing custom West commands
- Modifying in-tree applications (LED blinky)
- Freestanding applications outside the SDK
| Exercise: | Extend west commands | |
| Exercise: | Create a custom freestanding application | |
- Adding FreeRTOS using West
- Multicore projects with Sysbuild
- SPDX analysis and compliance check
- Memory footprint and Puncover analysis
| Exercise: | Extend the workflow with FreeRTOS and advanced tools | |
| Exercise: | Using west memory analysis features | |
- Configuration phase in West/CMake
- Kconfig framework:
- Enabling/disabling global features
- Tuning and conditional compilation
- Default values and symbol dependencies
- Role of prj.conf and fragments
- Interactive configuration (menuconfig, guiconfig)
- Generated config files: .config, mcux_config.h
- Writing new Kconfig entries (symbols, menus, defaults)
- Limitations and best practices
- MCUXpresso SDK specifics (custom prefixes, no CONFIG_ macros)
| Exercise: | Customize prj.conf | |
| Exercise: | Create and use custom kconfig options | |
- Board Architecture Overview
- Structure and components of a board port
- Creating a New Board Definition
- Configuring custom boards
- Board debuggers
- Linker Script
- Integrating the custom Board into the SDK
| Exercise: | Write a custom board | |
- Why to use modules?
- Module structure
- Out-of-tree module
- Module’s YAML
- Module CMakeLists.txt
| Exercise: | Create a custom library module | |
- Cortex-M Architecture Overview
- Two stacks pointers
- Different Running-modes and Privileged Levels
- MPU Overview
- Systick Timer Description
- ARMv8-M evolutions
- Exception / Interrupt Mechanism Overview
- Interrupt entry and return Overview
- SVC / PendSV / Systick Interrupt Presentation
- Developing with the IDE
| Exercise: | Interrupt Management on Cortex-M | |
- Base real time concepts
- The Real Time constraints
- Multi-task and real time
- Tasks and Task Descriptors
- Context Switch
- Task Scheduling and Preemption
- Tick based or tickless scheduling
- Scheduling systems and schedulability proof
- Scheduling through FreeRTOS
| Exercise: | Implement a Context Switch routine | |
- The Task life-cycle
- Creating Tasks
- Task Priorities
- Task States
- The idle task
- Delays
- Changing Task Priority
- Deleting Tasks
- Suspending Tasks
- Kernel Structures
- Thread Local Storage
- Kernel Interrupts on Cortex-M
- Scheduling Traces
- Visual trace diagnostics using Tracealyzer
| Exercise: | Managing tasks | |
- Memory management algorithms
- FreeRTOS-provided memory allocation schemes
- Allocate-only scheme
- Best-fit without coalescing
- Thread-safe default malloc
- Checking remaining free memory
- Adding an application-specific memory allocator
- Memory management errors
- Stack monitoring
| Exercise: | Enhance the memory manager for memory error detection | |
| Exercise: | Detect stack overflow | |
- Critical sections
- Critical sections
- Suspending (locking) the scheduler
- Mutual Exclusion
- Spinlocks and interrupt masking
- Mutex or Semaphore
- Recursive or not recursive mutexes
- Priority inversion problem
- Priority inheritance (the automatic answer)
- Priority ceiling (the design centric answer)
- Gatekeeper tasks
| Exercise: | Implement mutual exclusion between two tasks | |
- Introduction
- Waiting and waking up tasks
- Semaphores
- Events
- Mailboxes
- FreeRTOS Binary Semaphores
- FreeRTOS Queue Management
- Creation
- Sending on a queue
- Receiving from a queue
- Data management
- Sending compound types
- Transferring large data
- Queue sets
- Event Groups
- Task Notifications
| Exercise: | Synchronizing a task with another one through queues | |
| Exercise: | Synchronizing a task with another one through binary semaphores | |
- Parallel programming problems
- Uncontrolled parallel access
- Deadlocks
- Livelocks
- Starvation
| Exercise: | The producer-consumer problem, illustrating (and avoiding) concurrent access problems | |
| Exercise: | The philosophers’ dinner problem, illustrating (and avoiding) deadlock, livelock and starvation | |
| Exercise: | The readers-writer problem, illustrating complex concurrent access solving | |
- Need for interrupts in a real time system
- Software Interrupt
- Time Interrupts
- Device Interrupts
- Level or Edge interrupts
- Hardware and Software acknowledge
- Interrupt vectoring
- Interrupts and scheduling
- Deferred interrupt processing through FreeRTOS
- Tasks with interrupt synchronization
- Using semaphores within an ISR
- Counting semaphores
- Using queues within an ISR
- FreeRTOS interrupt processing
- Writing ISRs in C
- Interrupt safe functions
- Interrupt nesting
| Exercise: | Synchronize Interrupts with tasks | |
- The Timer Daemon Task
- Timer Configuration
- One-shot / Auto-reload Timer
- Software Timer API
| Exercise: | Use Software Timers | |
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: 22 October 2025
Booking one of our trainings is subject to our General Terms of Sales