Have a Question About This Course?





    Image

    STM32 + FreeRTOS + LwIP Training

    Embedded Software Engineer Series
    This hands-on training covers the STM32 ARM-based MCU family, the FreeRTOS Real-Time Operating System, the LwIP TCP/IP Stack, and optionally, the EmWin GUI Stack. Participants will gain a deep understanding of STM32 architecture, real-time operating system concepts, and networking with LwIP.

    This course covers:

    Understand the Cortex-M architecture and its software implementation.

    Learn interrupt handling in STM32.

    Gain insights into STM32F4 architecture, including key interconnected modules (clocking, interrupt controller, DMA).

    Work with independent I/O modules like ADC and GPIOs.

    Learn STM32 peripheral programming using STM32Cube Library or ST Standard Peripheral Library.

    Master FreeRTOS architecture, services, and APIs.

    Develop and debug FreeRTOS applications.

    Understand and implement the LwIP TCP/IP stack (networking with UDP and TCP, Ethernet Controller, parameterizing, porting). (Not available for STM32F0 family).

    Optionally, explore TouchGFX and EmWin GUI Stack for graphical user interfaces.

    STM32 + FreeRTOS + LwIP Training Objectives

    • By the end of this course
    • participants will:
    • Develop real-time STM32 applications using FreeRTOS.
    • Configure power management
    • interrupts
    • and DMA.
    • Implement networking with LwIP TCP/IP stack.
    • Develop and debug multitasking applications.
    • Optionally
    • create graphical user interfaces with EmWin/TouchGFX.

    Need Assistance Finding the Right Training Solution

    Our Consultants are here to assist you

    Key Point of Training Programs

    We have different work process to go step by step for complete our working process in effective way.
    • STM32 + FreeRTOS + LwIP Prerequisites

      Familiarity with C programming for embedded systems.

      Basic knowledge of embedded processors.

      Understanding of multi-task scheduling.

      Target Audience

      Embedded systems engineers and technicians meeting the above prerequisites.

    • STM32 + FreeRTOS + LwIP Training Format

      In-Person

      Online

    • STM32 + FreeRTOS + LwIP Outline

      Day 1: Cortex-M & STM32 Architecture

      Cortex-M Overview

      v7-M architecture, core architecture, Harvard architecture, memory hierarchy.

      Bit-Banding, registers, privilege levels, system control block, SysTick timer.

      Exception/interrupt mechanism, NVIC, priority management, fault handling.

      Debug interface, CMSIS library.

      Exercises: Debugging, exception handling, MPU configuration.

      STM32F4 MCUs Overview

      SoC architecture, memory organization, DMA controller, bus matrix.

      Flash memory interface, real-time accelerators, boot configuration.

      Exercise: Flash programming.

      Day 2: Power, Clocking & Peripheral Management

      Reset, Power & Clocking

      Reset sources, bootloader, clock sources, PLLs, power modes.

      Exercise: Configuring low-power modes and measuring power consumption.

      DMA & Peripheral Overview

      DMA architecture, FIFO, double buffer mode.

      GPIO, ADC, external interrupts.

      Exercise: Using DMA to transfer data between peripherals.

      Day 3: FreeRTOS Foundations

      FreeRTOS Overview

      Architecture, task scheduling, preemption.

      Kernel structures, hooks, tracing with Tracealyzer.

      Exercise: Task creation, debugging context switches.

      Memory Management

      Heap strategies, stack monitoring, memory allocation.

      Exercise: Stack overflow detection, heap debugging.

      Day 4: FreeRTOS Synchronization & Interrupts

      Queues & Inter-Task Communication

      Message passing, blocking mechanisms.

      Exercise: Synchronizing tasks with message queues.

      Resource Management

      Mutexes, priority inheritance, deadlock handling.

      Exercise: Reader/writer problem, producer/consumer implementation.

      Interrupt Management

      Synchronization with binary semaphores, ISR-safe queues.

      Exercise: Synchronizing interrupts with tasks.

      Day 5: Advanced FreeRTOS & Networking with LwIP

      Software Timers & FreeRTOS MPU

      Timer daemon task, one-shot and auto-reload timers.

      Exercise: Timer-based event handling.

      STM32 Ethernet & LwIP TCP/IP Stack

      Ethernet MAC architecture, buffer descriptors.

      LwIP memory management, APIs (Netconn & BSD Sockets).

      Exercises: Running an HTTP server, TCP echo client/server.

      Course customisation can include optional modules

      EmWin GUI Stack: GUI design, widgets, event handling.

      Exercise: Create a touch interface.

      TouchGFX: Advanced UI development for STM32.

      Exercise: UI application deployment using CubeMX & FreeRTOS.