Motion Control: Master Arduino I2C and the MPU6050 Gyroscope

The Wiring

It’s painfully simple. I2C is famous for being easy to wire.

• VCC -> 5V

• GND -> GND

• SDA -> A4 (Uno)

• SCL -> A5 (Uno)

Note: On Arduino Mega, SDA is pin 20, SCL is pin 21. On Leonardo, they are separate pins.

Addressing: Who are you?

Every I2C device has a 7-bit address. The MPU6050 usually lives at 0x68 (Hexadecimal). If you connect the AD0 pin to 5V, it moves to 0x69. This enables you to use TWO gyros on the same robot!

Binary to Hex:

• Binary: 1101000
• Hex: 0x68
• Decimal: 104 (We usually use Hex because it’s shorter).

The Code: Reading the “Mailboxes” (Registers)

Inside the chip, there are typically 100+ “Registers”. Think of them as numbered lockers or mailboxes.

• Register 0x3B: Acceleration X (High Byte)
• Register 0x3C: Acceleration X (Low Byte)
• Register 0x75: WHO_AM_I (Returns 0x68 so you know it’s alive).

The Basic Sketch (Raw Data)

We don’t need a heavy library to verify it works. Let’s talk directly to the registers.

#include <Wire.h>

const int MPU_ADDR = 0x68; // I2C address of the MPU-6050

int16_t AcX, AcY, AcZ, Tmp, GyX, GyY, GyZ;

void setup() {
  Serial.begin(9600);
  Wire.begin();
// Wake up the MPU-6050 (It sleeps by default)
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(0x6B); // Power Management Register
  Wire.write(0);    // Wake up!
  Wire.endTransmission(true);
}

void loop() {
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(0x3B); // Start reading from register 0x3B (Accel X)
  Wire.endTransmission(false); // Restart connection, don't stop
  // Request 14 bytes (Accel X/Y/Z + Temp + Gyro X/Y/Z)
  Wire.requestFrom(MPU_ADDR, 14, true); 
  // Read byte-by-byte
  // We combine High Byte (<<8) and Low Byte (|)
  AcX = Wire.read() << 8 | Wire.read(); 
  AcY = Wire.read() << 8 | Wire.read();
  AcZ = Wire.read() << 8 | Wire.read();
  Tmp = Wire.read() << 8 | Wire.read();
  GyX = Wire.read() << 8 | Wire.read();
  GyY = Wire.read() << 8 | Wire.read();
  GyZ = Wire.read() << 8 | Wire.read();
  // Print to Serial Plotter
  Serial.print("AccelX:"); Serial.print(AcX);
  Serial.print(",");
  Serial.print("AccelY:"); Serial.print(AcY);
  Serial.print(",");
  Serial.print("AccelZ:"); Serial.println(AcZ);
  delay(100);
}

Deep Dive: Bitwise Math for Beginners

Line 35 is terrifying for new coders: AcX = Wire.read() << 8 | Wire.read(); What is happening here?

• The Problem: The acceleration value is a 16-bit number (e.g., 10,000). But I2C only sends 8 bits (1 byte) at a time.

• The Split: The chip cuts the number in half. Top half (High Byte) and Bottom half (Low Byte).

• The Reassembly:

Imagine holding two playing cards.

• Wire.read() gets the first card (High Byte).
• << 8 (Left Shift) moves it to the “Tens” place. It adds 8 zeros to the right.
• Wire.read() gets the second card (Low Byte).
• | (Bitwise OR) combines them. It pastes the Low Byte into those empty zeros. This is arguably the most common line of code in embedded engineering. Memorize it.

Physics: Accelerometer vs Gyroscope - What’s the difference?

They sound similar, but they measure totally different things.

• Accelerometer (The Joulemeter): Measures Force.

• If you sit still, it measures 1G (Gravity) pointing down.

• If you accelerate a car, it measures the force pushing you back in the seat.

• Problem: It is VERY noisy. Every vibration shakes the data.

• Gyroscope (The Spinner): Measures Rotation Speed (Degrees per Second).

• If you sit still, it measures 0.

• If you spin the board, it measures 300 deg/sec.

• Problem: It Drifts. If you integrate the speed to find the angle, small errors add up. After 1 minute, it might think “Down” is “Left”.

The Fix: Sensor Fusion (Complementary Filter)

To build a drone, you combine them.

• Trust the Gyro for fast moves.
• Trust the Accelerometer for long-term stability (Gravity always points down).
• $\text{Angle} = 0.96 \times (\text{Gyro\_Angle}) + 0.04 \times (\text{Accel\_Angle});$ This one line of math is the secret sauce behind every Segway and Quadcopter.

Understanding 2’s Complement

You typically get values ranging from -17000 to +17000. Why negative? The chip uses Signed Integers (2’s Complement). If you tilt it Left, X is positive. Tilt Right, X is negative.

• At rest flat on a table:
• X = 0
• Y = 0
• Z = 16384 (This is Gravity! 1G).

Project: The Digital Spirit Level

Let’s make this useful. We will use 4 LEDs (Up, Down, Left, Right) to show tilt.

• Connect LEDs to Pins 8, 9, 10, 11.
• If AcX > 5000, light up RIGHT LED.
• If AcX < -5000, light up LEFT LED.
• If AcY > 5000, light up UP LED.
• If AcY < -5000, light up DOWN LED.

This is the exact same logic used in:

• Game Controllers (Wiimote).

• Drone Flight Controllers (Self-leveling).

• VR Headsets.

The Logic Code

// Simple Threshold Logic
if (AcX > 4000) {
  digitalWrite(RIGHT_LED, HIGH);
} else {
  digitalWrite(RIGHT_LED, LOW);
}

if (AcX < -4000) {
  digitalWrite(LEFT_LED, HIGH);
} else {
  digitalWrite(LEFT_LED, LOW);
}
// Repeat for Y axis...

Advanced: Hacking the Registers (Sensitivity)

By default, the MPU6050 measures up to ±2G (Gravity). But what if you strap it to a rocket? 2G is nothing. We can hack Register 0x1C (ACCEL_CONFIG) to change the sensitivity.

• 0x00: ±2G (Default, most sensitive).
• 0x08: ±4G.
• 0x10: ±8G.
• 0x18: ±16G (Least sensitive, but highest range).

Wire.beginTransmission(MPU_ADDR);
Wire.write(0x1C); // Access Accel Config
Wire.write(0x18); // Set to ±16G
Wire.endTransmission(true);

If you do this, your raw math changes. Instead of dividing by 16384 for 1G, you divide by 2048. Engineering is about trade-offs: Range vs Precision.

Pro Tip: Using the INT Pin (Interrupts)

Polling the sensor in loop() is slow. The MPU6050 has a “Data Ready” interrupt pin.

• Connect INT to Arduino Pin 2.
• Use attachInterrupt(digitalPinToInterrupt(2), readData, RISING);
• The Arduino can sleep or do other math until the MPU wakes it up saying “I have new numbers!”. This is how phones save battery while tracking steps in the background.

History: From Apollo to iPhone

The MPU6050 is a marvel of MEMS (Micro-Electro-Mechanical Systems). In the 1960s, the gyroscope for the Apollo moon mission was the size of a bucket and cost millions. It used spinning metal wheels. Today, we etch microscopic silicon “tuning forks” onto a chip for $3. When you rotate the chip, the vibration of these forks changes due to the Coriolis Effect. We measure that change as capacitance. It is literally a machine running inside a piece of silicon.

Advanced Math: The Kalman Filter

I mentioned the “Complementary Filter” (Easy math). If you want to work at NASA or SpaceX, you use a Kalman Filter. This is a complex algorithm that:

• Predicts the future state of the system based on physics.
• Reads the noisy sensor data.
• Compares the two and guesses the true probability of the angle. It is computationally heavy for an Uno, but libraries like Kalman.h exist if you want absolute perfection.

Troubleshooting I2C

• System Hangs: The Wire.requestFrom never returns. Cause: Loose wire. If SDA/SCL disconnects, the Arduino waits forever.

• Fix: Check connections. Use generic “I2C Scanner” code to verify address.

• Values are erratic/noisy: Cause: Electrical noise or Motor vibration.

• Fix: Use a “Complementary Filter” (Math) or just average 10 readings.

• Address not found: Cause: AD0 pin is floating? Connect AD0 to GND for 0x68.

Serial Plotter Fun

Open the Serial Plotter (Ctrl+Shift+L). Shake the board. You will see the waves react instantly. Try to tap the table—you will see a sharp spike (Impact detection). This is how your phone counts your steps (Pedometer)!

The Bill of Materials (BOM)

The Engineer’s Glossary (Day 24)

• I2C (Inter-Integrated Circuit): A 2-wire serial protocol for connecting low-speed peripherals.
• Open Drain: An output type that can only pull voltage down to ground, requiring an external resistor to pull it up.
• Register: A storage location inside a chip that controls configuration or holds data.
• MSB / LSB: Most Significant Byte (Big end) and Least Significant Byte (Little end).
• IMU (Inertial Measurement Unit): A device combining accelerometers and gyroscopes.
• DMP (Digital Motion Processor): A proprietary engine inside InvenSense chips that calculates Quaternion angles (Euler X/Y/Z) without the Arduino helping.

Conclusion

You now speak specific dialect of “Chip Connect”. I2C is the industry standard for on-board communication. Because you know I2C, you can now use:

• OLED Screens (Day 20)
• RTC Modules (Day 19)
• Pressure Sensors (BMP180)
• Light Sensors (BH1750)
• Output Expanders (PCF8574)

You are no longer limited by the pins on your Uno. You can chain 100 sensors together.

Next Up: We have inputs. We have outputs. We have protocols. Tomorrow, we learn Logic State. We will build a machine that remembers where it is in a sequence. See you on Day 25.