STM32 HAL I2C Tutorial: Interfacing MPU6050 IMU Sensor

For efficient applications, STM32 HAL provides interrupt-based SPI functions (HAL_SPI_Transmit_IT, HAL_SPI_Receive_IT) that return immediately without blocking program execution. When transmission/reception completes, callback functions are automatically invoked. To use interrupts: enable SPI global interrupt in NVIC settings via CubeMX, implement volatile global flags for completion tracking (preventing compiler optimization), and use a finite state machine to manage complex sequences. The state machine progresses through states: initializing buffers, sending commands, waiting for completion flags, reading data, and printing results. Interrupt callbacks set flags that advance the state machine, enabling concurrent operation.

This segment explains Direct Memory Access (DMA) for I2C communication. DMA allows hardware to transfer data directly to memory without CPU intervention, enabling non-blocking I2C operations. The video introduces the Pico I2C DMA library, which uses FreeRTOS semaphores to sleep threads while waiting for I2C transactions to complete. The segment demonstrates replacing blocking I2C operations with DMA-based alternatives, showing how to configure DMA channels and claim unused channels for data transfers.

This video tutorial explains how to receive UART data on STM32 microcontrollers using two methods: blocking mode (HAL_UART_Receive) which blocks CPU execution until data arrives or timeout occurs, and interrupt mode (HAL_UART_Receive_IT) which allows the CPU to continue executing other tasks while waiting for data; the interrupt method can be extended to handle variable-length data by receiving one byte at a time and storing it in a circular buffer, with the RX complete callback processing the data once a complete message is received.

This section covers the complete STM32 I2C peripheral setup process. Key topics include: selecting I2C standard mode (covering 90% of use cases) with 100 kHz clock frequency, configuring 7-bit addressing for most devices, and setting up DMA channels 4 and 5 for efficient data transfer. The driver architecture includes a base class with write(), read(), and transfer() methods, along with initialization and deinitialization functions. The implementation uses STM32CubeMX-generated code with MX_I2C_Init() and MX_I2C_DeInit() functions, with proper handle and instance management. The class structure supports future interrupt-based and DMA-based implementations with circular buffers and state machine support.

I2C (Inter-Integrated Circuit) is a synchronous communication protocol using two pins: SDA for bidirectional data and SCL for clock synchronization. The protocol supports one master communicating with multiple slaves, each having a unique 7-bit address plus a read/write bit. Communication is framed by Start Condition (SDA high-to-low while SCL high) and Stop Condition (SDA low-to-high while SCL low). Write operation: Start, slave address+write bit, memory address, data, Stop. Read operation: Start, slave address+write bit, memory address, repeated Start, slave address+read bit, read data, Stop. The HAL library simplifies implementation through functions like HAL_I2C_Master_Transmit(), HAL_I2C_Master_Receive(), HAL_I2C_Mem_Write(), and HAL_I2C_Mem_Read().

The Kalman filter compensates for gyroscope bias drift by fusing gyroscope data (fast response for short-term accuracy) with accelerometer data (long-term stability) through a state estimation process involving prediction and correction steps, where the system matrix A describes state evolution, measurement matrix C maps states to measurements, and process noise matrices Q and R determine sensor trust weights; implementation requires separate filters per axis and careful parameter tuning (typically starting with values of 1, with accelerometer parameters 100-10,000 times higher than gyroscope parameters) to balance responsiveness and robustness.

Calibration is the first method to fix gyroscope drift. The process involves measuring the gyro offset while the sensor is stationary and then subtracting this offset value from all future readings. This compensates for the inherent bias in the sensor.

Gyroscopes measure angular velocity but have inherent bias that causes drift when stationary. To remove this bias, keep the sensor at rest and take hundreds of measurements; the average equals the bias. The ICM-20948 sensor provides hardware registers (X/Y/Z gyroscope offset cancellation) that automatically subtract computed bias values without code modification. The computed average must be divided by 4000 before writing to registers. This hardware-based approach eliminates the need for software compensation in application code.

Raw gyroscope data contains an offset that must be corrected by taking the average of all values during startup and subtracting this average from every reading. This centers the data around zero when the craft is stationary. Minimal filtering should be applied to gyroscope values because excessive filtering delays response time, causing the quadcopter to react slowly to changes in orientation.

To solve magnetometer interference and gyroscope drift, complementary filtering combines gyroscope and accelerometer data with dynamic weight adjustment. Euler angles must be converted to quaternions to avoid gimbal lock and enable smooth interpolation. Zero-point calibration detects stationary periods (when deviceorientation events are suppressed) and captures gyroscope readings as reference values, subtracting these from subsequent readings to eliminate accumulated drift.

The MPU6050 uses Digital Motion Processing (DMP) to combine accelerometer and gyroscope data onboard. This library, developed by Jeff Rowberg under MIT license, provides processed orientation data (pitch and roll angles) without requiring complex sensor fusion calculations in the main code.

The MPU6050 Digital Motion Processing (DMP) is an onboard motion processing unit that simplifies sensor data calculations by performing complex computations internally, enabling direct access to processed data like yaw, pitch, and roll angles without manual calculations; successful DMP implementation requires proper initialization, interrupt handling, FIFO buffer management, and overflow detection to ensure reliable sensor data acquisition.

The MPU6050 library simplifies motion sensing by handling complex calculations. Installation is done through Arduino IDE's Library Manager. The DMP (Dynamic Motion Processor) feature enables obtaining 6 types of motion information including quaternions (4 parameters representing 3D orientation) and Euler angles (pitch, roll, yaw). The library reads data from FIFO buffers and applies gravity correction to convert raw acceleration into meaningful measurements. This eliminates the need for manual mathematical transformations that would otherwise be required to obtain accurate orientation data.

The MPU6050 measures 3D orientation through complementary sensor techniques. The gravitometer trick uses accelerometer readings to detect pitch and roll by measuring gravitational force changes during tilt, similar to how a scale reading decreases when leaning against a wall. The gyro integration trick applies calculus to integrate angular acceleration measurements for yaw, though this accumulates error over time due to bias. These methods are complementary: the accelerometer handles static orientation while the gyro tracks dynamic rotation. The Digital Motion Processor (DMP) inside the MPU6050 fuses these data streams for accurate orientation estimation. Hardware setup requires wiring VCC to 5V, SCL to Arduino's SCL, SDA to Arduino's SDA, and using AD0 pin 8 to select I2C address (0x68 or 0x69). When selecting an Arduino library, search for 'mpu600' and verify DMP support by checking for 'dmp' in the repository—only the Electronic Cats library passes this test. Modern software design principles improve maintainability: interfaces define method signatures without implementation, enabling loose coupling. Dependency injection passes dependencies through constructors. The wrapper class pattern bridges incompatible libraries. The config class pattern centralizes implementation decisions, enabling easy swapping between different libraries or versions.

Integrating the MPU6050 requires installing the i2cDev and mpu6050 libraries from Jeff Rowberg's GitHub. The Wire.h library enables I2C communication through pins A4 (SDA) and A5 (SCL). Key setup steps include defining a quaternion object for orientation representation, configuring the interrupt pin (pin 2) for DMP data readiness, and initializing the Digital Motion Processor. The DMP performs complex motion calculations internally, reducing CPU load. Calibration involves determining offset values through experimental testing, as these values vary between individual sensors. The setup function initializes serial communication at 9600 baud, tests I2C connection, initializes the MPU6050, enables the DMP, attaches the interrupt handler, and configures motor driver pins as outputs.