DEV Community

Tanvir Singh
Tanvir Singh

Posted on

What building a Self-Balancing Robot without any robotics experience taught me

How I Built a Self-Balancing Robot and What I Learned Along the Way

Hey there! I'm a software developer by trade, with a background in web development and DevOps. But back in my final year of pursuing a Bachelor's in Electronics and Communication Engineering, I decided to take on a hardware project that was way outside my comfort zone. Instead of opting for something straightforward like a smart-home automation Telegram bot, I went for a challenge: building a Self-Balancing Robot.

What's a Self-Balancing Robot?

In case you're wondering, a Self-Balancing Robot is a two-wheeled robot that uses a gyroscope to measure its tilt. It counters the tilt by powering the stepper motors connected to its wheels. Essentially, it stays upright by constantly adjusting its position, like a mini-Segway. Sounds cool, right? But it required more than just knowing how to program an Arduino. I had to understand the mechanics of the robot, calculate the center of gravity, and get into a lot of stuff that was way beyond my usual software development realm. I was excited about the challenge!

The Journey Begins

So, I started with some research. After scouring the internet, I found an open-source project on GitHub called BalancingWii. Turns out, a lot of folks used this as a baseline for their self-balancing robots. I thought, "Great, this should make things easier." Spoiler alert: I was wrong.

The Rollercoaster Ride

First Attempt

  • Bought Parts: Ordered all the necessary components. This included a gyroscope, stepper motors, an Arduino board, motor drivers, and various other electronics.
  • Parts Arrived: Time to get to work! Receiving all the parts was like Christmas morning, filled with excitement and anticipation.
  • Learned to Solder: First time soldering, not too shabby. I had to learn how to solder components onto a PCB, which was a new skill for me.
  • Edited Code: Tweaked the open-source code to fit my needs. I modified the BalancingWii code to work with my specific setup and components.
  • Uploaded Code: Hit my first snag with a driver issue. My computer wasn't recognizing the Arduino board due to a missing driver. After some digging, I found a driver that worked. Nice!
  • Test Run: Tested the tilt functionality without a body—it worked! The gyroscope was detecting tilt and the motors were responding correctly.
  • Major Setback: I accidentally short-circuited the main board and fried everything. Oops. I learned the hard way about the importance of careful handling and proper insulation.

At this point, the project was getting expensive since it was all out of my own pocket. I had to add more people to my team in order to fund the project. My college didn't fund projects, so I had to start over.

Second Attempt

  • Ordered Parts Again: New parts arrived, and I was ready for round two. I reordered the components and braced myself for another attempt.

  • Soldered Again: Getting better at this. With practice, my soldering skills improved, resulting in cleaner and more reliable connections.

  • Made Adjustments: Improved the robustness of the setup. I made some
    design changes to make the setup more durable and less prone to short circuits.

  • Test Run: Things were looking good. The initial tests were promising, and the system seemed to be functioning as expected.

  • Fabricated Test Body: Created a basic structure to test the center of balance. Using some basic materials, I built a test frame to see how well the robot could balance.

  • Another Setback: Fried a stepper motor driver this time. Ordered a replacement. This was another frustrating moment, but I didn't let it stop me.

Final Stretch

  • Replaced Driver: Installed the new motor driver. Once the replacement arrived, I also edited the circuit to add a voltage regulator to save prevent any over voltage.

  • PID Calculations: Spent a lot of time tweaking the PID settings. The Proportional-Integral-Derivative (PID) controller settings are crucial for maintaining balance, and getting them right was a matter of trial and error.

  • Persistent Testing: Kept trying different setups until something finally clicked. I spent hours testing and adjusting, fine-tuning every aspect of the robot's behavior.

  • It Worked: After countless attempts and adjustments, it finally worked! Seeing the robot balance on its own was incredibly satisfying and made all the effort worth it.

Images and Videos

  • Circuit Design:
    Image description

  • Soldering after a lot of iterations:
    Image description

  • Body V1:
    Image description

  • Body V2:
    Image description

  • Body V3:
    Image description

  • Video: Google Drive Link

Lessons Learned

  1. Never Give Up: Persistence pays off. Even when things go wrong, keep pushing forward. Every setback is a learning opportunity, and determination is key to overcoming obstacles.

  2. How to Solder: Gained a new skill that's pretty handy. Soldering is essential for many electronics projects, and getting good at it can open up a lot of possibilities.

  3. Robotics: Got a crash course in robotics and mechanical engineering. Building the robot gave me a deeper understanding of the principles behind robotics, including kinematics and dynamics.

  4. Embedded C: Improved my programming skills in a new language.
    Writing code for embedded systems is different from web development, and it broadened my programming horizons.

  5. New Outlook on Life: This project taught me that stepping out of your comfort zone can lead to incredible growth and learning. Embracing challenges and tackling unfamiliar problems can be incredibly rewarding.

Top comments (0)