Wheeled Self Balancing Robot: ROCKO!

For those who want to experiment with robotics, ROCKO provides an interactive platform for people to experiment with PID control tuning, joystick driving, autonomous navigation with vision sensors, and more! It was developed to provide a next step for those who have some basic programming or robotics experience already and want to dive into more advanced topics.

What makes ROCKO different from other robotics projects?

1. Can stand on two wheels in balance mode using a pitch and velocity PID controller
2. Legs fold up to convert to a tank drive mode with joystick
3. Runs on a Rasberry Pi 5 implemented with ROS2, an industry standard middleware for robotics
4. Opportunities for adding more sensors like LiDAR for vision and autonomous navigation
5. Program in Python or C++

Author's note: all the steps in this instructable contain the essential information you need to build ROCKO, but you can find even more of our documentation on the ROCKO wiki if any of these steps seem confusing or if you want more background information.

Tools you'll need:

1. Computer, preferably one running Windows
2. 3D printer, capable of printing PLA and TPU
3. Laser cutter, capable of cutting 1/4" thick acrylic
4. Soldering iron
5. Crimping tool, for small pin headers and larger power connectors
6. Joystick controller, one that can connect via USB to a computer
7. UART Interface
8. USB-C cable
9. Hex keys and wrenches
10. Screwdriver
11. Arbor press or vise
12. Utility knife
13. Wire strippers

Materials you'll need:

1. 1 x Raspberry Pi 5
2. 2 x MD10C_R3 Motor Drivers
3. 1 x BNO055 IMU (alternatively, you can use a ICM-20948 since the BNO055 was discontinued, but we found the built-in sensor fusion to be helpful)
4. 1 x Ecoworthy 12V 10Ah Lithium LiFePO4 Battery
5. 1 x DC Buck converter, 12V to 5V
6. 2 x GoBuilda gearmotors with 8mm hex shaft, 80mm in length
7. 1 x Sheet of 2ft by 2ft acrylic, 1/4in thick
8. PLA and TPU filament for printing
9. Wire, both 20AWG and 14AWG
10. Crimps for pin headers and Anderson PowerPole
11. Wago terminal connectors
12. Zip ties and cable management
13. Perf board (4x20 pin and 6x7 pin)
14. Assorted metric hardware (bolts and nuts in sizes M2, M3, M4, M6)
15. Heat set inserts (M2 and M4 sizes)

See our full Bill of Materials attached below for specific hardware, electronics, and parts quantities. It is estimated that the cost to build ROCKO is around $750, but pricing of components may be different in your region.

Some components, such as the motors, motor drivers, and IMU, could be switched out for similar products, but modifications to the CAD for mounting these are recommended. If you're feeling up to the task and have your favorite CAD software at the ready, you can download the STEP file for ROCKO here. Note that you will need to extract the STEP file from the .7z file format with an online tool like this one.

Additionally, see our full codebase on GitHub here!

ROCKO runs on a Raspberry Pi configured with ROS2. To use ROCKO, you will first need to set up the software environment that will allow you to run Python scripts in ROS2 on the Raspberry Pi.

You will need to

1. Set up Ubuntu on your Pi
2. Install ROS2 on your Pi
3. Install the ROS2_Control library
4. Install the Wiring Pi library
5. Configure the ROCKO environment on your Pi
6. Setup WSL2 and VS Code on your device

I, the primary author of this guide, am a humble MechE major who knows not the workings of low level software. Luckily, the other ROCKO devs who do know low level software wrote a complete guide explaining how to do the above actions which you can find here.

All parts for ROCKO were 3D printed on a Prusa MK3s, but any printer of a similar size will work. For PLA parts, the recommended settings are to print with at least 4 perimeters/wall loops and 20% gyroid infill to ensure parts do not break or deflect. TPU parts can handle two perimeters/wall loops, but consider increasing infill to around 30% to ensure parts can adequately absorb impacts. Refer to the full BOM for quantities of each part.

The dxfs can be cut from 1/4in (6mm) thick acrylic using a laser cutter. Check your specific laser cutter to make sure the settings are correct for your material. You will need one of each the bottom plate and front plate and two of the side plates.

Finally, prepare the following parts by adding heat set inserts where indicated (see following steps for exploded views of each subassembly).

1. 42T GT2 3mm Wheel Pulley - x8 M4 inserts for each pulley (16 total)
2. Leg Link - x1 M4 inserts for each leg link (2 total)
3. Upper Shoulder standoff - x2 M4 inserts for each (12 total)
4. Head Cross Bar - x2 M4 inserts for each (8 total)
5. Eye White - x4 M2 inserts for each (8 total)
6. Eye Pupil - x1 M2 inserts for each (2 total)

To install the inserts, preheat soldering iron temperature to around 220°C and gently apply downwards pressure to the insert with the heated soldering iron tip until the insert is flush with the face of the part.

Start building the Head Subassembly by attaching brackets and bumpers to the side plates. You will need

1. 12x M4 Bolts (16mm length)
2. 12x M4 Nuts
3. 1x Rear Bumper
4. 4x Corner Bumper
5. 2x Side Plate
6. 2x Corner Bracket
7. 2x L Bracket
8. 1x Rear Bracket, Left
9. 1x Rear Bracket, Right
10. 1x Mirror Rear Bumper

Attach the bumpers first by inserting the M4 bolts through the indicated holes and screwing a nut on the back. Pay attention to the orientation of the corner bracket. Then attach the corner brackets as indicated using more M4 bolts.

Repeat this process to create the mirrored copy of this subassembly.

Next, attach the bottom and front panels. You will need

1. 24x M4 Bolts (16mm length)
2. 24x M4 Nuts
3. Bottom Plate
4. Front Plate

Screw the bottom panel into the brackets first. Make sure the hole pattern for the Rasberry Pi goes in the back left corner of the head (see image). Wait to tighten the bolts down until all of them are in place. Attach the Front Plate to the brackets. Then, put bolts in the bumpers that connect to the front.

Next, mount the motors by screwing them into the side plates. You will need

1. 2x GoBILDA Motor (5204-8002-0005)
2. 2x Motor Mount Spacer
3. 8x M4 Bolts (12mm Length)
4. 8x M4 Lock Washer

Make sure the motor mount spacer goes up against the motor, on the inside of the side plate. Wait to tighten bolts down until all of them are in place.

To install the convenient carrying handle and IMU mount, you will need

1. 1/4in (6mm) diameter aluminum rod (2x 200mm length sections)
2. 4x Cross Bars
3. 8x M4 Bolts (16mm Length)
4. 1x RP LiDAR A1 Holder

Start by cutting the aluminum rod to length with a hack saw (or similar metal cutting tool). Glue the rod into two cross bars to make the cross bars span the whole width of the head. Once those dry, screw the cross bars in between the side panels using M4 bolts. Then, screw the RPLiDAR_A1-Holder on in the shown orientation using M4 bolts.

You are now done building the head!

This step is optional, but if you want to add more personality to ROCKO, add googly eyes and antennae! You will need

1. 10x M2 Bolts (10mm Length)
2. 10x M2 oversized washers
3. 2x Eye Pupil
4. 2x Eye White
5. 2x Antennae Holder
6. Wire (somewhere from 10 to 12 AWG but the size doesn't have to be exact)

Attach the eye whites to the front plate by screwing in the M2 bolts and washers into the installed heat set inserts. Attach the eye pupils in a similar fashion. Using zip ties, attach the antennae holders to the cross bars. Cut the wire to the desired length and glue it into the hole in top of the antennae holder.

Build x2 Wheel Hub Subassembly

Screw the Rhino Wheel to the Wheel Pulley as shown with the indicated bolts and washers.

**Note that the Rhino wheel is not symmetrical! The pulley will sit on the shallow side of the wheel. See above image for more detail.**

Press the two 8mm Round Ball Bearings as indicated in assembly drawing. One bearing should sit in the center of the wheel with the flange on the same side as the bolts. The other bearing should sit inside the 42T pulley on the side with the belt teeth.

Assemble x2 Crank Link Subassembly

Press the sleeve bearing in as shown using an arbor press or vise. Make sure the bearing flange is oriented on the side with a cutout in the top hole!

Assemble x2 Outer Shoulder Link Subassembly

Press the sleeve bearing and ball bearings as shown using an arbor press or vise. The ball bearing will sit in the recessed groove and the flange of the sleeve bearing will be pressed in from the opposite side.

Assemble both the Lower Leg Link Subassembly and its mirrored copy

Make sure heat set insert is installed facing the side with a cutout in the top of the link. Press sleeve bearings in as indicated, paying special attention to the orientation of the bearing flanges.

Build the opposite hand version and make sure the heat set insert and top flanged bearing are on the cutout side of the link.

Assemble both the Inner Shoulder Link Subassembly and its mirrored copy

Press in the ball bearing where the cutout is in the top of the link. Press in the flanged sleeve bearing from the same side. When attaching the spring plunger, make sure the ball end just barely sticks out of the nut. The length that the plunger sticks out will be adjusted in a later step.

Build the opposite hand version and make sure the bearings and spring plunger are all installed on the same side.

Assemble x2 Elbow Wheel Subassembly and x2 Double Pulley Subassembly

Insert the 8mm Round Ball bearings into the Elbow Wheel and Double Pulley as shown.

Build the Leg Assembly and its mirrored copy

You should have all the parts needed to build the leg!

Start building the Leg Assembly (left side) by attaching the Wheel Hub to the Lower Leg Link with the indicated shoulder bolt.

Avoid over-tightening the shoulder bolt on the wheel hub! Wheel should spin freely when a small force is applied.

Loop the 160T belt around the wheel pulley. Attach the Crank Link with the indicated shoulder bolt ensuring that the bolt and spacer go THROUGH the belt.

Insert a 75mm length shoulder bolt through at the top of the Lower Leg Link and then through the Outer Shoulder Link, Double Pulley, Elbow Pulley, and Inner Shoulder Link. Make sure the 160T belt is looped around the double pulley!

Loop the 150T belt over the Inner Shoulder Link and around the Double Pulley. Screw in the three standoffs on the Inner Shoulder Link side, making sure the standoffs go THROUGH the belt! Screw into the standoffs from the outer shoulder link side.

Attach the belt tensioner by screwing it into the heat set insert on the Lower Leg Link. Make sure the belt is flat against the tensioner and can spin freely when the wheel is rotated.

Build the mirrored (right hand) version of the Leg Assembly following the same procedure above.

Both assembled legs are ready to mount to the Head Subassembly!

To attach the legs to the head, start by sliding the hex bearing at the top of the shoulder joint into the motor shaft. Make sure the elbow of the leg points to the back of the robot. The flats of the shaft must line up with the bearing before it can slide on. The leg should look like the image below after this step.

Next, loop the belt around the 31T GT2 pulley. The pulley should be closer to the outside to the outer shoulder link so that the belt lines up with the double pulley. Line up the hex cutout in the pulley with the motor shaft and slide it on.

Line up the two bearings in the outer shoulder link with the motor shaft and slide the leg all the way against the head. Screw in an M4x0.75 bolt that is 12mm in length with an M4 lock washer and flat washer into the motor shaft (circled in blue on the third image).

It is recommended that you use blue thread locker on this motor shaft bolt, otherwise it will come loose. When applying thread locker, avoid getting any on the 3D printed and acrylic parts as it may chemically react and cause the parts to develop cracks.

Next, insert the 8mm diameter, 16mm length shoulder bolt into the crank link and through the flanged bearing (circled in red on the third image). This bolt receives an M6 washer and lock nut on the other side. Avoid over-tightening this bolt as it may prevent the linkage from moving up and down smoothly.

Finally, adjust how much the spring plunger sticks out of the Inner Shoulder Link by loosening the M12 bolts. The nose of the plunger should stick into the cutout holes in the head as much as possible, but not scrape the acrylic when the plunger is pulled.

Attach the other leg using the same process outlined above.

The following electronics get mounted on their associated electronics mounts to the bottom head plate as shown in the image. You will need

1. 1 x Rasberry Pi 5 and Raspberry Pi mount - M2.5x0.45 bolts, 25mm length
2. 2 x MD10C_R3 and MD10C_R3 mount - M3x0.5 bolts, 20mm length
3. 1 x Battery Mount - M6x1.0 bolts, 35 mm length
4. Note: the battery is held in place by 1” velcro straps to the battery mount

The IMU attaches to the RPLidar_A1 holder at the top of the head cross beams. You will need

1. 1 x BNO055 IMU - M2 bolts, 15mm length

Above is a diagram of all the electrical components on ROCKO. The components needed for the system are below.

Raspberry Pi 5: Single board computer used to control all electrical components

Battery: Supplies 12V power to 12V rail

12V rail: Connected to battery and supplies power to the motor controllers and DC-DC Buck Converter, which steps the voltage down to 5V

5V rail: Connected to DC-DC Buck Converter and supplies power to Raspberry Pi

3V rail: Connected to 3V and GND pins on Raspberry Pi and supplies power to IMU and built-in encoders on motors

DC-DC Buck Converter: Connected to 12V rail and converts voltage to 5V to supply 5V rail

Right and Left Encoders: Sensors built into the motors to measure the rotation of the motor shaft

IMU: Sensor to determine the robot’s pitch, roll, and yaw for balancing

MD10C_R3: Motor controllers to supply power to and control the speed of the motors

I won't list out all the steps for wiring the robot, but here are some descriptions and diagrams of the wires you need to prepare before connecting everything together.

1. Crimp the Molex 2510 connectors (included with motor controllers) onto 20 AWG wire, cutting long enough wire to neatly route to the Pi.
2. For instructions on crimping Molex 2510 connectors, see the video here.
3. Crimp JST XH connectors onto 20 AWG wire for the encoders, cutting long enough wire to neatly route to the Pi.
4. For instructions on crimping JST XH connectors, see the video here.
5. Alternatively, pre-crimped encoder cables can be purchased here.
6. Measure and cut the length of wire needed to route the USB-C cable to the 5V rail. Use a utility knife or X-ACTO knife to carefully strip the outer layer of insulation of the cable. Use wire strippers to strip the red and black internal cables, and insert them into the 5V rail. All other internal wires from the USB-C cable will not be used and can be cut.
7. Using scissors or a utility knife, cut the perf board down to a 4x20 pin piece and a 6x7 pin piece. Solder the 20x2 pin female header to the 4x20 pin perf board. Solder the signal wires for each GPIO pin needed for the Pi as shown in the diagram above. Solder the 6x1 pin female headers to the 6x7 pin perf board.
8. Plug the Pi perf board header into the Pi GPIO and the IMU perf board header into the IMU.
9. Crimp anderson or XT60 (your choice) connectors onto the wires coming from the battery, your battery charger, and onto the wires that will connect to the 12V Wago rails.
10. For instructions on crimping Powerpole connectors, see this video.
11. For instructions on soldering XT60 connectors, see this video.
12. Crimp 2.54mm Dupont female header pins onto 20 AWG wire to connect to the 12V input and 5V output of the buck converter.
13. Optional: I recommend mounting an active cooler onto you Raspberry Pi 5 if you will be running ROCKO in balancing mode for extended periods of time, as the balancing controller puts the Pi under heavy computational loads.

It's time to wire everything up! The buck converter and Wago terminals can be mounted to the head plates using adhesive mounting tape. Use the diagram in Step 14 as a guide for what electronics connect to which power rail. Make sure that wires connecting to the Wago terminals get stripped back enough to provide a good electrical connection and don't pull out of the terminal with a gentle tug.

Additionally, I recommend managing wires with zip ties and adhesive zip tie mounts. Look at the photos above to see how cables were managed on ROCKO.

ROCKO, as a system developed in ROS, achieves functionality through software entities called nodes. These are the fundamental entities that make ROS2 work.

Nodes function as discrete entities containing unique logic. They send and receive information with other nodes through topics. Topics are named interfaces for messages. Configuring one node to publish to a particular topic and another node to subscribe to it will allow them to communicate. The web of nodes communicating through topics is called the graph.

ROCKO relies heavily on controllers, a type of node unique to the ros2_control framework. Controllers are used to achieve control systems applications, meaning they perform tasks related to the motion and dynamics of the physical robot system. They allow you to implement ROCKO’s core functionality independent of a specific piece of hardware or hardware library.

Controllers and nodes, while similar, differ in a few very important ways integral to understanding ROCKO’s software environment. See the second image above to understand the difference between these two.

PID Controller

ROCKO uses 2 PID controllers to maintain balance and drive around. The built-in ros2_control PIDController class utilized has documentation that can be found here. PID controllers are a common feedback-driven controller used in robotics that take in a current reading and a desired setpoint. Based on the difference between the current reading and the desired setpoint, as well as the tuned coefficients of the controller, the PID controller will output a value that will attempt to drive the current reading towards the desired setpoint.

The first PID controller on ROCKO is the pitch controller. This controller maintains ROCKO’s balance. It takes in a desired pitch (often 0 for ROCKO to maintain vertical balance) and the current pitch reading, which comes from the IMU sensor. It outputs a value in rad/sec that gets sent to the AddFeedforwardController for the left and right wheels, which in turn gets sent to the motors that drive ROCKO.

The second PID controller on ROCKO is the velocity controller. This controller keeps ROCKO from drifting back and forth while maintaining balance. It takes in a desired velocity (0 for ROCKO to balance in place, a non-zero number for ROCKO to drive in a direction) and the current average velocity of ROCKO, which comes from the encoders on ROCKO’s motors. It outputs a pitch that then gets used by the pitch controller as its desired setpoint.

Diffdrive Controller

The diffdrive controller is a little atypical, as it is the node that commands the ROS2 control chain, but it still contains some control logic. It uses topics to take in a desired robot body vector, which is the overall linear and angular direction of ROCKO, and outputs left and right velocities that will achieve that overall vector. These left and right velocities are then sent to the velocity PID, which uses them as the desired setpoint for the controller. It also sends these velocities to the AddFeedforwardControllers to allow ROCKO to drive around.

While ROCKO uses a joystick by default to supply the desired robot body vector, you can replace the joystick with any controller that can output a robot body vector. This means that you can use a trajectory-following algorithm, path-finding software, or anything else you can come up with to control ROCKO!

Recommended reading for additional info

Official Documentation

1. ros2_control (Jazzy): Getting Started (Architecture)
2. ROS2 (Jazzy): Basic Concepts
3. PID Controller — ROS2_Control: Rolling Apr 2025 documentation

3rd Party Resources

1. ros2_control_explained by masum919
2. ROS Overview by Articulated Robotics
3. ROS Nodes, Publisher, and Subscribers by agmui
4. PID Controller Explained • PID Explained by PID Explained

Now that ROCKO is all set up, it’s time to run him! You can remote into your Pi to run the robot wirelessly by following the instructions here.

1. In your terminal, run sudo -i and type in your Raspberry Pi’s password when prompted.
2. This will give your terminal root permissions, which will let the Raspberry Pi interface with all its hardware correctly.
3. Open a second terminal and run sudo -i.
4. In the second terminal, type source /home/rocko/ROCKO-tools/deactivate_tank_mode.sh.
5. This command will deactivate ROCKO when he’s running in tank mode, so do not hit enter yet. Just have it ready to run when you’re done using ROCKO.
6. In the first terminal, run source /home/rocko/ROCKO-tools/root_startup_tank_mode.sh.
7. This will start ROCKO in tank mode. Make sure his legs are retracted before running the above command.
8. Download the joystick interface code here, or clone the repo to your laptop. Make sure that the downloaded file or repo is put where your Linux terminal can access it!
9. This code will send joystick values from an XBox-style USB controller to ROCKO so that you can drive him around!
10. Open a Linux terminal on your own computer and plug in an XBox-style USB controller to your computer.
11. In the terminal on your computer, run the joystick interface code by navigating to where you downloaded the file, then running python computer_joystick.py.
12. Try moving the left joystick. If everything worked, you should see ROCKO start moving around!
13. If he isn’t moving, make sure that the joystick code on your computer didn’t error out. If the joystick code is correct, revisit the earlier parts of this document as well as the electrical assembly instructions to verify that ROCKO is set up correctly.
14. When you’re all done running ROCKO, navigate to the second terminal on ROCKO and run the deactivate command. This will shut ROCKO down nicely.

If everything worked above, then you’re ready to start running ROCKO in balancing mode! To do so, follow the same setup as above, but get ready to send deactivate.sh to deactivate ROCKO and run root_startup.sh to start running the robot.

To modify the PID gains, navigate to rocko_env/rocko_env/bringup/config/rocko_controllers.yaml in the code and scroll down to where "gains" are listed. Here are some values we used in testing that will provide a starting point for your tuning.

To tune the PID, start by setting the velocity gains to zero to tune only the pitch controller. Once the pitch controller is tuned and ROCKO is balancing, add in velocity controller gains to get ROCKO to stay in one spot or to drive at a target velocity. For more information on how to tune the controller for ROCKO, you can visit the page on the ROCKO wiki here.

Because ROCKO is built on the industry standard, ROS, and is capable of implementing hardware libraries in C++ or Python, the opportunities to expand on the platform are limitless! Learn more about how you can add additional motors and sensors to ROCKO's software system here. Here are some ideas for ways to can expand the ROCKO platform:

1. Experiment with different PID values in balance mode
2. Add a LiDAR and implement localization and path planning. The aptly named RPLiDAR_A1-Holder that connects the cross bars was actually designed to implement this LiDAR sensor.
3. Add a camera to make ROCKO see the world (the eye mounting holes can work great for this)

**Note that advanced sensors should be implemented in ROCKO's tank mode as the controllers in balancing mode take up a significant amount of computation on the Pi.**

That's all from ROCKO for now, but we hope you enjoy learning more about robotics with your new friend!