Self-Balancing Robot: Arduino, PID & MPU6050

Learning Goal: Build and program an autonomous, self-balancing two-wheeled robot using an Arduino microcontroller, implementing a PID control loop and sensor fusion with an MPU-6050 IMU.

Prerequisites: Basic knowledge of electronics (voltage, current, breadboarding) and foundational programming concepts in C++ (variables, loops, conditional statements).
Estimated Total Study Time: 28 Hours

Module 1: Electronics Foundations & Arduino Motor Control

This module builds the physical and electrical foundation of your robot. You will learn how the Arduino microcontroller functions, write your first basic programs to control I/O pins, and dive into the mechanics of DC motor control. You will understand how H-Bridge drivers (such as the classic L298N) utilize Pulse Width Modulation (PWM) to regulate motor speed and direction from a low-voltage microcontroller.

Knowledge Checkpoint

Install the Arduino IDE and successfully upload a basic sketch (e.g., Blink) to verify hardware communication.
Understand the role of an H-bridge in reversing DC motor polarity to control direction.
Explain how Pulse Width Modulation (PWM) changes the average voltage delivered to a motor, altering its speed.
Draw a basic wiring diagram showing how an external battery supply, an L298N driver, and an Arduino share a common ground.

Module 2: Inertial Measurement Units & Sensor Fusion

A self-balancing robot must continuously calculate its angular deviation from the vertical axis. In this module, you will explore the inner workings of Micro-Electro-Mechanical Systems (MEMS) sensors inside the MPU-6050 Inertial Measurement Unit (IMU). You will interface the sensor using the I2C protocol, read raw data, and implement a complementary filter to resolve raw values into clean, real-time tilt angles.

Knowledge Checkpoint

Connect the MPU-6050 to the Arduino using the hardware I2C interface pins (SDA/SCL) and pull-up resistors.
Write a sketch that successfully reads raw 16-bit integer values from the MPU-6050 accelerometer and gyroscope registers.
Explain why a gyroscope's raw output must be integrated over time ( $\Delta t$ ) to compute change in angle, and why this process introduces drift.
Implement the complementary filter equation in your Arduino code: $\theta_{\text{filter}} = \alpha \cdot (\theta_{\text{filter}} + \omega \cdot \Delta t) + (1 - \alpha) \cdot \theta_{\text{accel}}$ where $\alpha \approx 0.98$ and $\omega$ is gyro angular velocity.

Module 3: Mechanical Design and Chassis Assembly

To balance reliably, a physical robot must conform to strict mechanical constraints. The distribution of mass, structural rigidity, and motor torque are key determinants of control loop stability. Since the video pool has limited dedicated tutorials on physical custom frames, this module supplements existing videos with comprehensive mechanical design rules. You will learn to construct a physical chassis, align its center of gravity, and select high-performance components.

⚠️ Video Pool Gap Notice: High-quality videos detailing step-by-step custom physical assembly for self-balancing robots are scarce in the pool. To bridge this gap, study the structural concepts below and search YouTube for "DIY self balancing robot chassis design physics" and "3D printed self balancing robot assembly" to view additional community-built physical layouts.

Structural Design Blueprint

When physical structures flex, they introduce uncontrolled mechanical delay into your feedback loop, which can cause erratic vibrations. Use the following design guidelines to assemble your hardware platform:

+-----------------------------------+ <- TOP LEVEL: Battery (Heavy) & MPU-6050 | [Li-Ion Battery] | (Higher CoG reduces required angular acceleration) | [MPU-6050] | +-----------------------------------+ | | Rigid Threaded Brass Standouts (M3) | +-----------------------------------+ <- MID LEVEL: Arduino Uno & L298N Controller | [Arduino] [L298N] | (Keeps logic board safe from motor noise) +-----------------------------------+ | | Rigid Threaded Brass Standouts (M3) | +===================================+ <- BASE LEVEL: Geared Motors & Wheels | [Motor L] [Motor R] | (Directly coupled to wheels with zero-backlash) +===================================+ (O) (O) <- High-grip rubber or silicone tires

Center of Gravity (CoG) Elevation: Mount heavy batteries at the top tier of the chassis. While counterintuitive, a taller inverted pendulum falls more slowly, allowing the control loop more time to react.
Backlash Reduction: Avoid cheap toy motors with loose plastic gears. Use high-quality metal-geared DC motors. Any physical play in the gears (backlash) creates a dead-band where the motors spin but the robot does not move, leading to persistent jitter.
Sensor Alignment: Mount the MPU-6050 as close to the central vertical axis as possible, oriented perfectly perpendicular to the wheel axis, to ensure rotational accelerations are measured accurately without translating as linear offsets.

Knowledge Checkpoint

Assemble a rigid, multi-tier chassis using acrylic, plywood, or 3D-printed plates secured with M3 standoffs.
Verify that there is zero physical play or wobble between the motor shafts and your wheels.
Position the battery pack at the upper tier of the chassis to raise the center of mass.
Securely mount the MPU-6050 IMU flat, leveled, and aligned with your drive shaft's centerline.

Module 4: PID Control Theory and Math

This module covers the mathematical foundation of dynamic stabilization: the Proportional-Integral-Derivative (PID) control loop. You will learn how each term computes corrections based on the system's tracking error, explore transfer functions, and study tuning models like the Ziegler-Nichols method to systematically balance your physical system.

Mathematical Model

The controller output $u(t)$ is computed from the error signal $e(t) = \theta_{\text{target}} - \theta_{\text{actual}}$ using the following equation:

$u(t) = K_p \, e(t) + K_i \int_{0}^{t} e(\tau) \, d\tau + K_d \, \frac{de(t)}{dt}$

                            +---------+
                            |  Kp * e |
                       +--->| (Prop)  |---+
                       |    +---------+   |

Setpoint | v (0 deg) Error | +---------+ Sum Control Output [+] ------(X)---------+--->| Ki * ∫e |->[+]--->[To Motors] ^ ^ | | (Integ) | ^ | [-] | +---------+ | | | | | | Filtered | +---------+ | | Angle +--->| Kd * de |--+ | | | (Deriv) | | | +---------+ +---------------+ | MPU-6050 | | (Comp Filter) | +---------------+

Proportional ( $K_p$ ): Generates a restorative force proportional to the current tilt angle. If the robot tilts slightly forward, the motors drive slowly forward; if it tilts severely, the motors drive rapidly.
Integral ( $K_i$ ): Accumulates persistent errors over time, ensuring the motors run fast enough to overcome static friction and center the robot perfectly rather than settling at a slight tilt.
Derivative ( $K_d$ ): Measures the rate of change of the tilt angle to predict future motion, damping oscillations and slowing down motor corrections as the robot approaches center.

Knowledge Checkpoint

Write down the mathematical equation for a standard PID controller and describe the purpose of each term.
Understand how numerical integration ( $\int e \, dt \approx \sum e \cdot \Delta t$ ) and numerical differentiation ( $\frac{de}{dt} \approx \frac{e - e_{\text{prev}}}{\Delta t}$ ) are implemented in discrete microcontroller firmware.
Define "windup" in control systems and explain why limiting the maximum accumulated integral sum is crucial.
Explain how the $K_p$ , $K_i$ , and $K_d$ parameters influence system stability, rise time, and overshoot.

Module 5: Software Integration and Real-Time Tuning

In this final module, you will combine your MPU-6050 sensor fusion, C++ PID control loops, and motor driver logic into a unified, non-blocking Arduino program. You will implement timed control loops using millis() instead of blocking delays to ensure high-frequency, reliable calculations. You will then manually calibrate and tune your controller coefficients on physical hardware to achieve stable balance.

⚠️ Video Pool Gap Notice: Step-by-step videos demonstrating integrated firmware walkthroughs and empirical PID tuning for physical self-balancing systems are sparse in the pool. To bridge this gap, review the non-blocking software templates and tuning workflows below. Search YouTube for "Arduino non blocking PID control loop tutorial" and "Tuning PID self balancing robot step by step" to see these principles implemented in various community builds.

Non-Blocking Loop Design

Your control loop must execute at a fixed, reliable rate (e.g., every 10 milliseconds or 100 Hz). This non-blocking C++ template ensures precise timing without interrupting sensor reading or motor execution:

#include <Wire.h>

const unsigned long SAMPLE_TIME_MS = 10; // 100 Hz Control Loop unsigned long lastLoopTime = 0;

float targetAngle = 0.0; // Desired balance point float inputAngle = 0.0; // Filtered angle from MPU-6050 float errorSum = 0.0; float lastError = 0.0;

// PID Tuning Parameters float Kp = 0.0, Ki = 0.0, Kd = 0.0;

void setup() { Wire.begin(); // Configure MPU-6050 & L298N Pins here }

void loop() { unsigned long currentTime = millis();

if (currentTime - lastLoopTime >= SAMPLE_TIME_MS) { float dt = (currentTime - lastLoopTime) / 1000.0; lastLoopTime = currentTime;

// 1. Read IMU Data & Run Complementary Filter
inputAngle = readComplementaryFilterAngle(dt);

// 2. Compute PID Algorithm
float error = targetAngle - inputAngle;
errorSum += error * dt;
errorSum = constrain(errorSum, -200, 200); // Anti-windup
float errorDeriv = (error - lastError) / dt;
lastError = error;

float pidOutput = (Kp * error) + (Ki * errorSum) + (Kd * errorDeriv);

// 3. Drive H-Bridge Motors
driveMotors(pidOutput);

} }

float readComplementaryFilterAngle(float dt) { // Placeholder: Insert complementary filter implementation from Module 2 here return 0.0; }

void driveMotors(float output) { // Placeholder: Insert PWM and pin control from Module 1 here }

Empirical Tuning Guide

Once your code is uploaded, place your robot on a smooth surface and follow this manual tuning procedure:

Initialize Values: Set $K_p = 0$ , $K_i = 0$ , and $K_d = 0$ .
Tune Proportional Gain ( $K_p$ ): Slowly increase $K_p$ in small increments. Hold the robot upright and let go. Continue increasing $K_p$ until the robot begins to oscillate back and forth about the center point. Set $K_p$ to roughly 50% of this threshold value.
Tune Derivative Gain ( $K_d$ ): Gradually increase $K_d$ to damp out the oscillations. This term acts like a shock absorber, helping the robot recover smoothly when tilted. Increase $K_d$ until any rapid jitter or high-frequency shaking is introduced, then back it off slightly.
Tune Integral Gain ( $K_i$ ): If the robot balances but slowly drifts away in one direction, increase $K_i$ in small increments. This will increase motor drive to overcome static friction and keep the robot centered.

Knowledge Checkpoint

Explain why using delay() inside your main control loop causes system instability.
Implement a timed, non-blocking executive loop using millis() running at a constant frequency (e.g., 100 Hz).
Implement an anti-windup clamping threshold on your accumulated integral error.
Systematically tune $K_p$ , $K_d$ , and $K_i$ parameters on your physical robot to achieve upright balance.

Course Map

This flowchart maps the optimal path through the modules. You should build the physical frame and master sensor reading before diving into control theory and tuning.

Key People Index

The following engineers, educators, and makers are featured in this curriculum:

Vlad Romanov (@VladRomanov89): An electronics engineer who specializes in explaining the architecture and programming of register-level motion sensors, such as the MPU-6050.
James Bruton (@jamesbruton): A former toy designer and robotics maker known for his experimental designs and explanations of robot physics, balance systems, and center of gravity dynamics.
Carey Ian (@careyian): A systems designer who breaks down mathematical algorithms and control structures into accessible, custom C++ code.
DroneBot Workshop (@Dronebotworkshop): An educational channel focused on open-source hardware, motor controllers, and step-by-step breadboard wiring tutorials.

Final Self-Assessment

Complete these tasks to verify that your robot is fully functional and stable:

Power Safety: Your robot's motor power and logic power circuits must share a common ground, with all wires neatly secured to prevent short circuits.
Rigid Chassis: The robot frame must be mechanically rigid, with zero play or flex in the standoffs or motor mounts.
CoG Check: The battery is mounted at the upper tier of the chassis, and the MPU-6050 is mounted flat, centered, and level.
Sensor Fusion Validation: The complementary filter reliably outputs zero degrees when the robot is held perfectly vertical, with minimal noise and no drift over time.
Non-Blocking Execution: The main loop runs at a fixed, reliable rate (e.g., 100 Hz) using millis() with zero blocking delays.
Anti-Windup Protection: Your code restricts the maximum value of the integrated error sum to prevent runaway motor drive when the robot is held tilted.
Stable Balance: The robot can balance upright on a flat surface for at least 60 seconds without drifting away or falling over.
Recovery from Disturbance: When gently nudged or pushed, the robot drives to correct itself, dampening any oscillations to return to a stable, upright state.

Explore Further

Related Engineering Roadmaps

View All→

engineering

Self-Balancing Robot: Arduino, PID & MPU6050

Module 1: Electronics Foundations & Arduino Motor Control

Recommended Videos

Knowledge Checkpoint

Module 2: Inertial Measurement Units & Sensor Fusion

Recommended Videos

Knowledge Checkpoint

Module 3: Mechanical Design and Chassis Assembly

Recommended Videos

Structural Design Blueprint

Knowledge Checkpoint

Module 4: PID Control Theory and Math

Recommended Videos

Mathematical Model

Knowledge Checkpoint

Module 5: Software Integration and Real-Time Tuning

Recommended Videos

Non-Blocking Loop Design

Empirical Tuning Guide

Knowledge Checkpoint

Course Map

Key People Index

Final Self-Assessment

Related Engineering Roadmaps

ECG Monitor Design: Op-Amps, Filters & Noise

Soft Robotics (Molding, Arduino & Control)

Building EMG Prosthetics: Arduino & 3D Print

Building a CNC Plotter: GRBL & G-Code Setup