IMU Sensor (MPU-6050)

What is an IMU?

An inertial measurement unit (IMU) is a sensor that measures the forces and rotations acting on a body. The MPU-6050 integrates two sensors on a single die:

• 3-axis accelerometer — measures proper acceleration (force per unit mass) along X, Y, and Z axes. At rest on a flat surface, it reads approximately 1g on the vertical axis due to the normal force from the surface.
• 3-axis gyroscope — measures angular velocity (rotation rate) around X, Y, and Z axes in degrees per second.

Together they provide a 6-DOF (degrees of freedom) motion measurement — three translational and three rotational — which is the minimum needed to track orientation in 3D space.

Why it matters for AI builders

The IMU is the vestibular system of a robot. Without it, a bipedal robot cannot balance, a drone cannot hover, and a wheeled robot cannot detect the terrain slope that would cause it to tip. Modern robot learning algorithms that output control signals at 20–50 Hz rely on IMU feedback to close the loop:

• Balance control — ankle and hip servos in bipedal robots receive correction signals computed from IMU tilt angle
• Dead reckoning — integrating IMU acceleration to estimate position when GPS is unavailable
• Gait phase detection — detecting foot strike and liftoff in walking robots from acceleration peaks
• Vibration monitoring — detecting motor imbalance, bearing wear, or resonance before failure
• Gesture recognition — classifying motion patterns for human-machine interface

Working principle

The MPU-6050 uses MEMS (Micro-Electro-Mechanical Systems) technology — silicon structures etched at microscale that deflect under force or rotation.

Accelerometer: A proof mass is suspended by silicon springs. When the chip accelerates, the mass displaces relative to fixed electrodes, changing capacitance. The capacitance change is proportional to acceleration. Three orthogonal axes are measured simultaneously.

Gyroscope: Uses the Coriolis effect. A vibrating proof mass is driven at a known frequency. When the chip rotates, Coriolis force deflects the mass perpendicular to its vibration, proportional to angular velocity. Again, three axes are measured.

Digital Motion Processor (DMP). The MPU-6050 contains an onboard DMP that can run sensor fusion algorithms in hardware, producing quaternion orientation estimates without loading the main MCU.

Key parameters

Pinout

Wiring

I2C pull-up resistors: Most MPU-6050 breakout boards include 4.7 kΩ pull-up resistors on SDA and SCL. If your bus has multiple I2C devices, only one set of pull-ups should be active — additional pull-ups lower the total resistance and reduce signal integrity.

Code

Read raw accelerometer and gyroscope data

#include <Wire.h>

const int MPU_ADDR = 0x68;

void setup() {
  Wire.begin();
  Serial.begin(115200);

  // Wake the MPU-6050 (exits sleep mode)
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(0x6B);  // PWR_MGMT_1 register
  Wire.write(0x00);  // Set to zero — clears sleep bit
  Wire.endTransmission(true);
}

void loop() {
  // Request 14 bytes starting at register 0x3B (ACCEL_XOUT_H)
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(0x3B);
  Wire.endTransmission(false);
  Wire.requestFrom(MPU_ADDR, 14, true);

  int16_t ax = Wire.read() << 8 | Wire.read();
  int16_t ay = Wire.read() << 8 | Wire.read();
  int16_t az = Wire.read() << 8 | Wire.read();
  int16_t temp = Wire.read() << 8 | Wire.read();  // temperature (skip)
  int16_t gx = Wire.read() << 8 | Wire.read();
  int16_t gy = Wire.read() << 8 | Wire.read();
  int16_t gz = Wire.read() << 8 | Wire.read();

  // Convert to physical units
  float ax_g = ax / 16384.0;   // g-force (±2g range)
  float ay_g = ay / 16384.0;
  float az_g = az / 16384.0;
  float gx_dps = gx / 131.0;   // degrees per second (±250°/s range)
  float gy_dps = gy / 131.0;
  float gz_dps = gz / 131.0;

  Serial.print("Ax:"); Serial.print(ax_g, 3);
  Serial.print(" Ay:"); Serial.print(ay_g, 3);
  Serial.print(" Az:"); Serial.print(az_g, 3);
  Serial.print(" | Gx:"); Serial.print(gx_dps, 2);
  Serial.print(" Gy:"); Serial.print(gy_dps, 2);
  Serial.print(" Gz:"); Serial.println(gz_dps, 2);

  delay(50);
}

Complementary filter for roll and pitch

A complementary filter fuses accelerometer tilt angle (accurate but noisy) with gyroscope integration (smooth but drifts):

#include <Wire.h>

const int MPU_ADDR = 0x68;
const float ALPHA = 0.98;     // gyro weight — higher = less accelerometer noise
unsigned long prevTime = 0;
float roll = 0, pitch = 0;

void setup() {
  Wire.begin();
  Serial.begin(115200);
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(0x6B); Wire.write(0x00);
  Wire.endTransmission(true);
  prevTime = millis();
}

void readIMU(float &ax, float &ay, float &az, float &gx, float &gy, float &gz) {
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(0x3B);
  Wire.endTransmission(false);
  Wire.requestFrom(MPU_ADDR, 14, true);
  ax = (Wire.read() << 8 | Wire.read()) / 16384.0;
  ay = (Wire.read() << 8 | Wire.read()) / 16384.0;
  az = (Wire.read() << 8 | Wire.read()) / 16384.0;
  Wire.read(); Wire.read();  // skip temperature
  gx = (Wire.read() << 8 | Wire.read()) / 131.0;
  gy = (Wire.read() << 8 | Wire.read()) / 131.0;
  gz = (Wire.read() << 8 | Wire.read()) / 131.0;
}

void loop() {
  float ax, ay, az, gx, gy, gz;
  readIMU(ax, ay, az, gx, gy, gz);

  unsigned long now = millis();
  float dt = (now - prevTime) / 1000.0;  // seconds
  prevTime = now;

  // Accelerometer tilt estimate (noisy)
  float accel_roll  = atan2(ay, az) * 180.0 / PI;
  float accel_pitch = atan2(-ax, sqrt(ay*ay + az*az)) * 180.0 / PI;

  // Complementary filter: trust gyro short-term, accel long-term
  roll  = ALPHA * (roll  + gx * dt) + (1 - ALPHA) * accel_roll;
  pitch = ALPHA * (pitch + gy * dt) + (1 - ALPHA) * accel_pitch;

  Serial.print("Roll:"); Serial.print(roll, 1);
  Serial.print("  Pitch:"); Serial.println(pitch, 1);

  delay(10);
}

Test procedure

Common mistakes

Robotics and AI use cases

Beginner project — Digital spirit level

Display roll and pitch angles on the Serial Monitor. Place a marble or small ball on top of the board — observe the angles change as you tilt. Build a simple threshold: if roll > 10° or pitch > 10°, print "TILTED".

Key learning: Converting raw ADC counts to physical units, atan2 geometry, threshold-based logic.

Advanced project — Self-balancing platform

Build a platform that automatically stays level using two servo motors and an IMU. Measure roll and pitch. Run a PD controller: proportional to current tilt angle, derivative to damp oscillation. Output servo angles that counteract the measured tilt.

Components: Arduino, MPU-6050, 2× SG90 servos in a pan-tilt configuration, rigid platform (cut acrylic or cardboard).

Key learning: PD control tuning, sensor fusion, mechanical design for stability, the physics of inverted pendulum control.