Self-Balancing Two-Wheel Robot with PID Control

A self-balancing robot is an inverted pendulum on wheels — the classic controls-lab problem made physical. It stays upright only because a fast feedback loop measures tilt and drives the wheels under the falling body hundreds of times per second; get the PID gains wrong and it face-plants, which is exactly why examiners love asking about the tuning. This project builds the full system: a compact two-wheel chassis, an MPU6050 IMU with a complementary filter for clean tilt angle, geared DC motors on H-bridge drivers, and an Arduino running the PID loop at approximately 100 Hz. Bluetooth adds remote drive commands that lean the setpoint to move. The heart of the deliverable is the tuning procedure — Ziegler–Nichols-flavoured, student-performed — so the report's gains are earned, not copied.

1. The MPU6050 measures acceleration and angular velocity; a complementary filter produces the current tilt angle.
2. The Arduino compares tilt against the upright setpoint and runs the PID computation at approximately 100 Hz.
3. The PID output drives both wheels through the H-bridges — forward when falling forward, backward when falling back.
4. Bluetooth commands offset the setpoint slightly, so the robot leans and drives in the commanded direction while balancing.
5. The student follows the tuning procedure, raising proportional gain to oscillation then setting P, I and D from the documented method.
6. Final gains, filter constants and balance endurance are recorded in the report.

Tech stack:

• Arduino Nano (ATmega328P)
• MPU6050 6-axis IMU
• 2 geared DC motors (high-torque)
• L298N / TB6612 H-bridge driver
• HC-05 Bluetooth module
• Li-ion battery + 5 V regulator
• Fabricated compact chassis
• Arduino IDE (C/C++ firmware)

• [MPU6050 tilt sensing] A 6-axis IMU with a complementary filter fuses accelerometer and gyroscope data into a clean, drift-resistant tilt angle.
• [PID balance loop at ~100 Hz] The Arduino runs the proportional-integral-derivative loop fast enough to catch the fall, with gains the student tunes.
• [Documented PID tuning procedure] A step-by-step tuning guide (oscillation method) takes the student from wobbling to stable, and the final gains go in the report.
• [Geared DC drive with H-bridges] High-torque geared motors and H-bridge drivers give the fast wheel corrections balancing demands.
• [Bluetooth drive commands] A phone app sends forward/back/turn commands that shift the balance setpoint, so the robot drives while staying upright.
• [Compact fabricated chassis] A low, rigid two-wheel chassis keeps the center of mass where the controller expects it.
• [Battery and power management] A Li-ion pack with a regulated 5 V rail keeps the logic stable as motors draw surge current.

• Two-wheel balancing chassis with motors, IMU and drivers
• Arduino firmware (complementary filter, PID loop, Bluetooth drive)
• PID tuning procedure document
• Wiring diagram and assembly guide
• Project report PDF (inverted-pendulum theory, tuning log, results)
• PPT presentation and viva Q&A document

• Balance quality depends entirely on the buyer-run PID tuning — the kit ships with starting gains, not magic numbers.
• Flat, hard floors are required; slopes, carpet and bumps defeat the controller's model.
• The design balances an unloaded chassis; carrying payloads changes the dynamics and needs retuning.
• Approximately 100 Hz loop rate is a design target on the Nano; heavy additional code can slow it.
• No obstacle sensing is included — the robot balances where it is driven (sensing is future scope).