Linear Algebra with CMSIS Math Library on STM32 MCUs

C programming is the most common language for embedded software development and should be the first language learned. To truly master C for embedded systems, one must understand pointers and memory addresses, multi-threading concepts, and data structures. Proficiency requires knowing which methods are faster or slower for optimization purposes, as performance and power efficiency are critical in embedded systems.

C programming is the foundation of embedded systems development. Unlike system C (socket programming, multi-threading on Linux), embedded C means your code is the only thing running on the system, giving full control over CPU operations including hardware interrupts. Essential concepts include if/else statements, switch cases, while loops, pointers, structs, and unions. Critical data types are unsigned integers (uints) and bit masks, which are fundamental in embedded devices. Understanding bits and bit manipulation is essential since embedded work often requires working at the bit level rather than byte level.

Pointers in C are variables that store memory addresses. Every variable in C has an address in memory, and the ampersand (&) operator retrieves this address. A pointer is a special variable type that holds an address. Pointer types determine how memory is accessed, with different pointer types having different sizes (16-bit on AVR, 32-bit on STM32, 64-bit on x86). The compiler uses this information to correctly interpret memory contents. In embedded programming, all hardware registers are accessed through pointers because registers are physical memory addresses. Understanding pointers is fundamental to embedded programming and hardware manipulation. Additionally, pointers are essential for efficient memory usage in embedded systems, allowing passing references rather than making copies when RAM is limited.

In C programming, to create a pointer that points to an array, you declare a pointer with the same data type as the array elements and assign it the array name (e.g., int *p = v;), which automatically points to the first element of the array; alternatively, you can use the address-of operator with a specific array element (e.g., int *p = &v[0];) to point to any element, and the compiler handles the memory address assignment without requiring the size specification.

Pointers store addresses (typically 4-8 bytes) versus dereferenced values (data type size). Pointer declarations matter: int *c[2] is array of 2 pointers; int (*c)[2] is pointer to array of 2 integers. Array address calculation: 1D uses Address(a[i]) = Address(a[0]) + i × size_of_element. 2D row-major: Address(a[i][j]) = Address(a[0][0]) + i × cols × size + j × size. Column-major differs: Address(a[i][j]) = Address(a[0][0]) + j × rows × size + i × size. 3D extends further: Address(a[i][j][k]) = Address(a[0][0][0]) + i × cols × rows × size + j × rows × size + k × size. Understanding these distinctions prevents bugs in array and pointer manipulation.

STM32CubeIDE is a powerful integrated development environment for STM32 microcontrollers. It allows users to select microcontrollers based on parameters, configure all peripherals, program and flash the device, and debug using imported breakpoints. The environment also provides real-time register viewing. The built-in programmer can be used for both programming and debugging, making it a convenient tool for development.

STM32CubeIDE is the official free IDE from STMicroelectronics for STM32 development. It provides code editing, compilation, and debugging capabilities. The IDE is available for multiple operating systems and can be downloaded from the ST website. Installation involves running the installer wizard, which sets up the development environment with default settings.

This video provides a comprehensive beginner's guide to STM32 microcontroller programming, covering the essential tools STM32CubeMX and STM32CubeIDE, hardware platform selection (recommending the Nucleo board with STM32F411 for its integrated ST-LINK programmer and hardware reset), and the complete workflow from setting up development environment to writing simple programs that control LEDs and read button inputs using the HAL library.

STM32CubeIDE is a free integrated development environment provided by STMicroelectronics for developing applications on STM32 microcontrollers. The IDE offers a comprehensive workspace with multiple perspectives including Explorer for file navigation, Build Targets for compilation status, and Code Generator for creating hardware abstraction layer (HAL) code. Users can select specific microcontrollers and development boards (such as Nucleo boards), configure pins for different modes (GPIO, ADC, USART), set clock configurations, and generate ready-to-use code with default peripheral settings. The IDE supports debugging capabilities and provides access to reference manuals and data sheets for the selected microcontroller, making it an essential tool for embedded system development.

STM32CubeIDE is an integrated development environment provided by STMicroelectronics for STM32 microcontroller development. It consists of two main components: (1) STM32CubeMX - a graphical configuration tool for setting up pins, peripherals, and generating code, and (2) STM32CubeF4 - the code generation component that produces HAL (Hardware Abstraction Layer) code. The IDE supports both HAL-based programming (using pre-written APIs) and direct register-level programming for advanced users. The HAL layer abstracts hardware details, providing high-level functions for peripheral control.

Fixed-point representation uses a fixed decimal point position, limiting the range of values that can be represented. For example, with 4 digits, you can only represent values from 0 to 9999. Floating-point representation solves this limitation by using additional bits as an exponent to shift the decimal point position. This allows the same number of digits to represent both very large values (like 999,999) and very small values (like 0.001), dramatically expanding the range of representable values without requiring more digits.

Fixed point arithmetic is a computational technique that enables efficient fractional calculations on microcontrollers by representing numbers with an imaginary decimal point within a standard integer data type, allowing for faster operations than floating point while sacrificing some range for increased resolution; key operations include: addition/subtraction work directly, multiplication requires casting to 64-bit integers, shifting to remove overflow/underflow, and casting back to 32-bit fixed point, while conversions between integers and fixed point use bit shifts and between floating point and fixed point use multiplication/division by 2^fractional_bits (e.g., 32768 for 15 fractional bits).

Fixed Point arithmetic uses integer data types (int, long, int8-64) with a fixed decimal point position, while Floating Point uses float (32-bit) and double (64-bit) types with variable decimal point positions. Microcontrollers like STM32 M3 and below lack hardware FPU support, requiring software implementation for floating point calculations. Fixed point numbers use Q format notation (Q15, Q30) where multiplying by 2^15 converts decimal to integer representation. When multiplying two Q15 numbers, the result is in Q30 format. Fixed point arithmetic has inherent precision limitations—multiplying two Q15 numbers yields Q30, requiring division by 2^30 to convert back. In the example 0.123 × 10.456, fixed point yields 1.285939 (accurate to 2 decimal places) versus exact floating point result 1.286088. Fixed point is essential for PID controllers on microcontrollers without FPU. Performance measurements on STM32F411RE at 16 MHz show floating point with hardware FPU takes approximately 480 microseconds, while software floating point (non-FPU) takes approximately 1,240 microseconds (2.5-3x improvement). Fixed point arithmetic (Q30 format) takes approximately 660 microseconds, making it faster than software floating point but slower than hardware FPU. Fixed point format selection involves trade-offs between precision and range—Q5 format provides 32 values while Q15 provides 32,768 values. Fixed point is essential for real-time embedded applications on microcontrollers without hardware FPU, such as motor control, PWM generation, and high-frequency control loops (10-100 kHz). Major semiconductor companies provide example code using fixed point for these applications, enabling code portability across different microcontroller platforms while maintaining real-time performance requirements.

Fixed point representation allocates a predetermined number of bits to integer and fractional parts, providing consistent precision but limited range. Floating point uses scientific notation with a sign bit, exponent, and significand, enabling representation of both very large and very small numbers with varying scales. Fixed point is simpler but less flexible, while floating point offers greater dynamic range at the cost of increased complexity and potential rounding errors.

This section traces the evolution from fixed-point to floating-point representation. Fixed-point systems place the binary point at a fixed position, limiting them to either integers or fractions but not both. The key insight is that fixed-point wastes precision on insignificant trailing digits for large numbers and cannot represent small fractions. Floating-point solves this by allowing the binary point to float to different positions, enabling representation of both very large and very small numbers within the same format. This fundamental trade-off between precision and range is the core philosophical foundation of floating-point design.