MPU-6050 IMU Data Fusion with Complementary Filter | Arduino & Processing

Implementing I2C communication with Arduino requires understanding device addresses and register mappings. Each sensor has a unique I2C address found in datasheets or via the I2C Scanner sketch. Internal register addresses specify where data is stored—for example, the ADXL345 accelerometer stores X-axis data across registers 0x32 and 0x33. The Arduino Wire library provides essential functions: Wire.begin() initializes communication, Wire.beginTransmission() specifies the target device, Wire.write() sends register addresses, Wire.endTransmission() completes sending, Wire.requestFrom() requests data, Wire.available() checks byte availability, and Wire.read() retrieves data bytes. Raw sensor data requires mathematical conversion to obtain meaningful physical measurements, demonstrating how hardware communication protocols enable complex sensor integration through standardized two-wire interfaces.

Programming I2C communication on Arduino requires importing the Wire library and initializing with Wire.begin(). The process involves: (1) beginTransmission() with the target device address, (2) sending the register address using send(), (3) ending transmission with endTransmission(), (4) requesting data with requestFrom() specifying the number of bytes, and (5) reading the response with receive(). For temperature conversion from Celsius to Fahrenheit, use F = C × 9.0/5.0 + 32.0 with floating-point arithmetic to maintain precision. Serial.print() outputs values to the computer terminal, allowing real-time monitoring of sensor readings.

This segment covers the foundational Arduino code structure for reading sensors. The setup() function initializes pins and serial communication, while loop() handles continuous sensor reading. Constants are declared for fixed pin numbers (LM35 on A0, LDR on A1), and variables store sensor readings. The critical concept of analog reference voltage is explained: the default 5V reference wastes the voltage range for sensors like LM35 (max 1.12V). Using internal reference (1.1V) provides better precision. For Arduino Uno/Blackboard, use 'internal'; for Arduino Mega, use 'internal1v1'.

I2C (Inter-Integrated Circuit) is a serial protocol for low-speed two-wire communication, originally developed by Philips in 1982 for television manufacturing. It uses three physical connections: VDD (power, 3.3V/5V), SDA (bi-directional data), and SCL (clock signal) with pull-up resistors. The bus supports multiple speed modes: standard mode (100kHz), fast mode (400kHz), high-speed mode (3.4MHz), and ultra-fast mode (5MHz). Devices use a 7-bit addressing scheme supporting up to 128 slaves, with variants including TWI and SMBus. On Arduino, SDA is A4 and SCL is A5 on Uno, with pull-up resistors needed externally. The Wire library handles I2C operations, with master mode using Wire.begin() and slave mode using Wire.begin(slaveAddress). Master sends data via beginTransmission(), write(), endTransmission(). Slave receives data through onReceive() event function. Master requests data via requestFrom().

Arduino programming requires setup() and loop() functions. Setup runs once, loop runs repeatedly. Analog sensors use analogRead() (pins A0-A5, values 0-1023), digital sensors use digitalRead() (pins 0-13, values HIGH/LOW). Serial Monitor displays readings using Serial.begin(9600). Digital pins require pinMode() configuration (INPUT for sensors, OUTPUT for actuators). Delay() controls timing in milliseconds.

Euler angles (pitch, yaw, and roll) can be converted to a 3D view vector using trigonometric functions: the X component equals cos(yaw) × cos(pitch), the Y component equals sin(pitch), and the Z component equals sin(yaw) × cos(pitch), where pitch controls up/down mouse movement, yaw controls left/right mouse movement, and roll handles side-tilting; this conversion requires scaling by cos(pitch) to ensure the vector correctly represents the viewing direction when looking straight up.

SOHCAHTOA (Sine=Opposite/Hypotenuse, Cosine=Adjacent/Hypotenuse, Tangent=Opposite/Adjacent) provides the mathematical framework for tilt measurement. For pitch angle, the formula is theta = arctan(a_x/a_z), where a_x is X-axis acceleration and a_z is Z-axis acceleration. This relationship holds because the tangent of the tilt angle equals the ratio of the X-component to the Z-component of the gravitational vector. The approximation works best between 0-45 degrees.

Euler angles are three angles developed by Leonard Euler for describing object orientation in space. Using an aircraft example, we define two coordinate frames: the reference frame (Northeast Down - NED) and the body frame attached to the aircraft's center of gravity. The Euler rotation sequence involves three consecutive right-handed rotations: (1) yaw about the z-axis to get frame F1, (2) pitch about the common y-axis to get frame F2, and (3) bank about the common x-axis to reach the body frame. Each rotation step is represented by a 3x3 rotation matrix: R_z(ψ) for yaw, R_y(θ) for pitch, and R_x(φ) for bank. The complete transformation from reference to body frame is C_BV = R_x(φ) × R_y(θ) × R_z(ψ), yielding the Direction Cosine Matrix (DCM). Aerospace conventions specify that Euler angles are ordered as φ (bank), θ (pitch), ψ (yaw), even though the actual rotation sequence is yaw-pitch-roll (ZYX).

Given a rotation matrix, Euler angles can be recovered using specific formulas: (1) c = arctan2(R[1,2], R[1,1]) - this gives the yaw angle from the first row elements; (2) θ = -arcsin(R[1,3]) - this gives the pitch angle from the third element of the first row; (3) φ = arctan2(R[2,3], R[3,3]) - this gives the roll angle from the third column elements. These formulas allow conversion between the matrix representation and the angle representation of orientation.

This video explains how to calculate the three Euler angles (roll/chi, pitch/tita, and yaw/phi) from a rotation matrix representing the roll-pitch-yaw sequence (rotation around X-axis by chi, then Y-axis by tita, then Z-axis by phi). The method involves two cases: when cos(tita) is positive (quadrants 1 and 4), the angles are calculated as chi = arctan(r32/r33), tita = arctan(-r31/√(r11²+r21²)), and phi = arctan(r21/r11); when cos(tita) is negative (quadrants 2 and 3), the calculations use negative values for the denominator. The key insight is that r11² + r21² = cos²(tita), allowing determination of the pitch angle's quadrant, which then affects how the other angles are computed.

The serial library enables communication between Processing and Arduino. Import processing.serial.*, use serial.list() to find available ports, then create Serial instances with new Serial(parent, portName, baudRate). Send data using write(), place write() inside draw() for continuous transmission, and add \n for message separation. On Arduino, use Serial.begin(baudRate), pinMode(), and evaluate Serial.read() in loop() to control hardware based on received data.

This section covers the complete process of establishing serial communication between Arduino and Processing. Arduino sends data through its serial port using stamper() in the loop function. Processing receives this data by importing the Serial library (import processing.serial.*), creating a Serial object, and using serial.readStringUntil('\n') to read incoming data. The baud rate must match between both devices (typically 9600). This communication channel enables interactive applications where Arduino controls Processing graphics and vice versa.

Processing is a visual programming language for creating interactive graphics and animations. To prepare for serial communication: (1) Create custom fonts via Tools > Create Font, selecting a font style and size (e.g., Agency FB at 200), which generates .vlw files; (2) Load fonts using PFont font = loadFont("fontname.vlw"); (3) Set up the canvas with size(width, height); (4) Initialize serial communication using SerialPort port = new SerialPort(this, "COM3", 9600); (5) Configure buffering with port.bufferUntil('.') to wait for complete data packets terminated by a period. The draw() function continuously refreshes the display, making it ideal for real-time data visualization.

This section demonstrates the complete data flow between Arduino and Processing. Arduino sends data using Serial.print() and Serial.println() with matching baud rates. Processing reads incoming data using miPuerto.read() and displays it in the console. The demonstration shows sending integer values (0, 1, 70, 255) and explains that serial communication is limited to 8-bit values (0-255), as values exceeding 255 will be read incorrectly.

Processing is a flexible programming environment and language designed for visual arts and graphics programming. It shares its syntax with Java and is widely used for creating interactive visual projects. The Arduino programming environment was heavily influenced by Processing, making it familiar to Arduino users. Processing can be downloaded from processing.org and run directly from the extracted folder without installation. It provides a simple interface for creating graphical applications that can interface with hardware through serial communication.