MPU-6050 IMU

What it is

The MPU-6050 is how a robot feels its own motion. It is a 6-axis inertial measurement unit—a gyroscope and an accelerometer on one chip—that reports how the robot is tilted, how fast it’s spinning, and how it’s accelerating. Where an ultrasonic sensor looks outward at the world, an IMU looks inward at the robot’s own body, which is what a self-balancing robot or a dead-reckoning navigator needs.

How it works

Inside are two sensors. The accelerometer measures linear acceleration on X, Y, and Z—at rest, that’s just gravity, which tells the robot which way is down (its tilt). The gyroscope measures how fast the robot is rotating about each axis. You read both over I²C (SCL/SDA).

Neither sensor is enough alone: integrate the gyro to get an angle and it slowly drifts; trust the accelerometer and it’s noisy whenever the robot moves. The fix is sensor fusion—blend them so the accelerometer corrects the gyro’s drift and the gyro smooths the accelerometer’s noise. That technique is exactly what sensor noise, bias, and filtering covers.

When to use it

Reach for an MPU-6050 when a robot needs to know its own orientation or motion:

• Self-balancing robots — the tilt angle the control loop fights to keep at zero.
• Heading and dead reckoning — sensing turns to improve odometry between encoder readings.
• Motion detection / gestures — reacting to being picked up, tipped, or shaken.

For measuring distance to things (walls, obstacles), you want a ranging sensor like the HC-SR04 or VL53L0X instead—an IMU senses the robot, not the world.

Wiring and gotchas

• I²C, 3.3–5 V. Most breakouts (the purple GY-521) have a regulator, so 5 V is fine; the raw chip is 3.3 V only.
• Fuse the gyro and accel—don’t steer on a raw reading. A single accelerometer sample under motion is unusable as a tilt angle.
• Yaw drifts without a magnetometer; use the MPU-6050 for pitch/roll and short-term turns, not absolute compass heading.
• Keep it rigid and level-mounted; a loose sensor adds vibration the filter can’t remove.

Pinout

The purple GY-521 breakout is the board almost everyone means by “MPU-6050”. Eight pins, and four of them are usually left unconnected.

AD0 is the pin that makes two MPU-6050s on one bus possible, and it is the reason the address collision has an easy answer here that most sensors do not offer.

Wiring it to an Arduino

There is a subtlety worth knowing on a 5 V Arduino. The GY-521’s pull-up resistors go to its regulated 3.3 V rail, so the I²C lines idle at 3.3 V, not 5 V. An ATmega328P reads high above 0.6 × Vcc = 3.0 V, so 3.3 V clears the threshold — but only by 0.3 V. It works reliably in practice and is one reason a long or noisy I²C run misbehaves on this board sooner than on a 5 V one.

Reading it: the registers that matter

You can drive this sensor with a library and never see a register, but four of them explain almost every problem people have with it.

The two config registers set the scale factor you divide raw counts by, and getting it wrong is the most common source of “my angles are four times too big”:

Pick the smallest range that will not saturate. A balancing robot rarely exceeds ±250 °/s, and the narrow range gives four times the resolution of ±1000 °/s for free.

Minimal working code

No library — this is the whole thing, and it is worth running once so you know what the library is doing for you.

#include <Wire.h>

const uint8_t MPU = 0x68;          // 0x69 if AD0 is tied high

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

  Wire.beginTransmission(MPU);
  Wire.write(0x6B);                 // PWR_MGMT_1
  Wire.write(0);                    // wake up — the chip boots asleep
  Wire.endTransmission(true);
}

void loop() {
  Wire.beginTransmission(MPU);
  Wire.write(0x3B);                 // ACCEL_XOUT_H
  Wire.endTransmission(false);      // repeated start, do not release the bus
  Wire.requestFrom(MPU, (uint8_t)14);

  int16_t ax = Wire.read() << 8 | Wire.read();
  int16_t ay = Wire.read() << 8 | Wire.read();
  int16_t az = Wire.read() << 8 | Wire.read();
  Wire.read(); Wire.read();         // temperature, discarded here
  int16_t gx = Wire.read() << 8 | Wire.read();
  int16_t gy = Wire.read() << 8 | Wire.read();
  int16_t gz = Wire.read() << 8 | Wire.read();

  // Default ranges: +/-2 g and +/-250 deg/s
  float pitch = atan2(ax, sqrt((float)ay * ay + (float)az * az)) * 57.2958f;
  float rateY = gy / 131.0f;        // deg/s

  Serial.print(pitch); Serial.print(' '); Serial.println(rateY);
  delay(20);
}

Two things this deliberately does not do: it never fuses the two sensors, and it never subtracts a bias. Both are next.

Calibration: the twenty lines that matter most

At rest a gyro does not read zero. It reads a small, fairly constant offset, and because you integrate the gyro to get an angle, that offset integrates into a steadily growing error. A bias of just 2 °/s left uncorrected is 120° of drift after a minute.

Average a few hundred samples with the sensor completely still, then subtract:

long sum = 0;
for (int i = 0; i < 500; i++) { sum += readGyroY(); delay(3); }
const float gyroBias = sum / 500.0f;   // subtract from every later reading

Three practical notes the datasheet will not tell you:

• Do it at every power-on, not once. Gyro bias moves with temperature, and a robot that has been running for ten minutes is not the robot you calibrated cold.
• “Still” means still. A calibration taken while the desk is being leaned on bakes that motion into the bias permanently.
• The accelerometer needs a level reference, not a zero. It should read 1 g on whichever axis points down. If it reads 0.97 g, that is your scale error, and it will show up as a tilt angle that is consistently a couple of degrees off.

Why one sensor is never enough

The two sensors fail in exactly opposite ways, which is what makes fusing them work so well.

A complementary filter takes the good half of each — trust the gyro over the short term, let the accelerometer slowly pull the estimate back toward truth:

angle = 0.98f * (angle + rate * dt) + 0.02f * accelAngle;

That 0.98 sets the crossover. Higher trusts the gyro for longer, which is smoother but drifts more; lower responds to the accelerometer’s noise. The complementary filter tutorial works through how to choose it deliberately rather than by feel.

Troubleshooting

MPU-6050 or something newer?

The MPU-6050 is end-of-life at the manufacturer and still the most widely used IMU in hobby robotics, because it is cheap, documented everywhere, and supported by every library.

The honest summary: if your robot needs pitch and roll — which is what balancing needs — the MPU-6050 is entirely sufficient and the fusion is a good thing to have written yourself. If it needs absolute heading, no amount of filtering will get it from six axes, and you want a magnetometer.