Vantaphage, a Walking Robot Build Guide

492

2026-07-09 | By Odd_Jayy (Jorvon Moss)

License: Attribution Non-commercial 3D Printing Robot Kits Filament Microcontrollers DC Motor Servo Arduino Qwiic Raspberry Pi MCU

INTRODUCTION

Welcome to my Vantaphage tutorial — a project I have been building for the past month or so. The goal was simple: create a walking quadruped robot crowned with a glowing light, inspired by the strange, leggy shape of the bacteriophage virus. In this guide, I break the build down into the steps I found easiest for assembling it from scratch.

project_1

What is the Vantaphage?

The idea came from a project I saw out of Japan a few years back: a hexapod that doubled as a walking night light. It carried a large glowing cube on its back and walked around at night to light the way from room to room.

Vantaphage, a Walking Robot Build Guide

I wanted to capture that same friendly, ambient feel in a four-legged design of my own.

The Vantaphage is a fully functional, twelve-servo quadruped. It can stand, walk forward, and turn using a creep gait, with inverse kinematics translating foot positions into joint angles. An onboard IMU provides real-time balance correction, keeping the body level as the robot moves. Beyond basic walking, it performs nine choreographed tricks — including shake-off, stretch, wave, and a breathing/heartbeat routine — and carries a 16-pixel RGB LED ring for expressive lighting.

Best of all, the whole robot runs untethered. It broadcasts its own WiFi access point and serves a web interface you can open from a phone or laptop, withhold-to-repeat movement controls, trick triggers, and full LED color control.

WHAT YOU'LL BE ABLE TO DO WHEN YOU'RE DONE

Stand, walk forward, and turn on a stable creep gait
Stay level on uneven ground thanks to onboard IMU balance correction
Trigger nine built-in tricks and animations
Drive the whole thing wirelessly from a web page, with full RGB lighting control

What You'll Need

Here's the core parts list for the build. Quantities and exact brands can be adjusted — this is simply the combination I used and tested.

Electronics & hardware

SparkFun XRP Controller (RP2350B) — The brain. Runs MicroPython.
PCA9685 16-channel servo driver — Talks to the XRP over I2C (Qwiic).
SunFounder SF3218MG servos (20 kg, 270°) — Three per leg: coxa, femur, tibia.
16-pixel RGB LED ring (NeoPixel-style) × 4 — The glowing crown.
Metal servo horns / arms × 12 — Hold the joints far better than plastic.
Qwiic cable — For the I2C connection to the PCA9685.
Separate servo power supply — The servos need their own high-current supply.
Battery pack for the XRP board — Powers the controller untethered.
M2 heat-set inserts + 2 mm screws × 12 — For the printed joint holders.
10 mm magnets — To attach the light cube on top.
DC-DC buck converter 7-24V to 5V — For servo Power, it can take about 6v.

3D-printed parts

XRPholder_vantaphage — the electronics tray (print this first; see note below)
Body — the central hexagonal chassis
Leg parts — coxa, femur, and tibia segments for all four legs
Joint_Holder × 12 — reinforces each servo joint
Light cube / top cover — the glowing crown

Tools & software

A 3D printer (this project does require print access)
A soldering iron (for the heat-set inserts and LED wiring)
Thonny IDE — for flashing MicroPython and managing files on the XRP

A NOTE ON THE CODE FILES

These are the scripts referenced throughout the guide. You'll add the libraries to the XRP's lib folder and run the test scripts in order as you build.

ik.py — Inverse kinematics — turns foot positions into joint angles
pca9685.py — Driver that lets the XRP talk to the servo board
LEDtest.py — Quick test for the LED ring
Standingtest.py — Moves the servos into the standing pose
sunfoundergait.py — Walking-gait test for tuning servo placement
Walk_web.py — The full WiFi web controller (your final program)

Download Project Files

Step 1. Print the Parts

This project does require access to a 3D printer. I recommend printing the XRPholder_vantaphage first — it takes the longest to wire up, so you can get the electronics going while the rest of the parts print in the background.

After the holder, print the body next. While the body is printing, it is a perfect time to start on the code (Step 3). Then move on to the leg parts and the rest of the chassis.

PRINT ORDER THAT SAVES TIME

XRP holder → body (start coding while it prints) → legs → joint holders → light cube.

Step 2. Wire the Electronics

The XRP controller mounts on top of the holder, and the PCA9685 servo driver sits on the bottom. They connect to each other over I2C using the XRP's Qwiic 0 port.

port_2

Use the Qwiic 0 port on the XRP to reach the PCA9685.

From Qwiic 0, wire the four I2C lines down to the PCA9685 servo controller: SCL, SDA, VCC, and GND. For the lighting, I wired the LED rings in parallel and ran the data line to the Servo 1 signal header on the XRP.

WIRING SUMMARY

XRP — Qwiic 0 -> PCA9685
- SCL, SDA, VCC, GND
LED ring (16 px) -> XRP — Servo 1 header
- data (pixels in parallel)
12 servos -> PCA9685 channels 0–11
- see Step 4 map

Vantaphage, a Walking Robot Build Guide

Fully assembled, the stack looks like this — LED rings on sides, PCA9685 underneath.

Step 3. Set Up the Code

I used Thonny to set up MicroPython on the XRP board. Once MicroPython is flashed, open the XRP's lib folder and add ik.py and pca9685.py. These two files are what let the XRP talk to the PCA9685 servo board and convert foot positions into joint angles.

With the libraries in place, run LEDtest.py to confirm the LED ring lights up correctly before you go any further. It's much easier to catch a lighting issue now than after the body is sealed up.

WHY THONNY

Thonny makes flashing MicroPython and copying files onto the board painless, and it keeps you out of fiddly REPL issues. Get the LEDs confirmed working here before moving on.

Step 4. Assemble the Legs & Place the Servos

Each leg has three joints. Remember the naming: the coxa is the hip, the femur is the upper leg, and the tibia is the foot. Build each leg so it matches the layout below.

leg_3

A single leg: coxa (hip), femur (upper leg), and tibia (foot).

I use metal servo arms rather than the plastic ones — they grip the servo splines much more securely and hold up far better under the weight of the robot.

metal_4

Metal servo arms hold the joints solidly under load.

To get every servo in the right place, follow this channel map. Each leg uses three consecutive channels on the PCA9685, in coxa → femur → tibia order.

place_5

Servo-to-channel map for all four legs.

table_6

Step 5. Stand It Up

With the servos inserted into their correct joint positions, run Standingtest.py. This drives every servo to the angle it needs for the robot to stand. Keep assembling and adjusting until it stands cleanly on all four legs — it should sit about 74 mm off the ground.

IMPORTANT — POWER

You must power the XRP board and the servo controller from separate supplies. The servos draw far too much current to run off the board's supply, and sharing power will cause brownouts and erratic motion.

motion_7

Standing pose, measured to ~74 mm. The height can be altered — this is just how I set mine.

Step 6. Reinforce the Joints

Next, take the 3D-printed Joint_Holder parts — you'll need 12 of them, one per joint. They press into the robot to keep each joint solid and stop it from flexing under load.

Each holder has a hole for an M2 heat-set insert. Melt an insert into place, then drive a 2 mm screw through it to lock the joint down and add real strength.

joint_8

The joint holder, with an M2 heat-set insert and a 2 mm screw for strength.

Step 7. Tune the Stance & Test the Gait

This is where things get a little fiddly, because now you'll start fine-tuning the robot. When it's right, the legs should sit in a clean X-shape, radiating diagonally from the corners of the body — like the reference below.

reference_9

Aim for this geometry — legs splayed into a symmetric X-pattern.

Run sunfoundergait.py to test the robot's movement. If a servo was mounted at a slightly wrong angle, the walking will look off — this is your chance to pull the affected horns and reseat them at the correct angle until everything moves evenly. Take your time here; clean servo placement is what makes the gait smooth.

top_10

Top-down during a gait test — each leg labelled (FL, FR, BL, BR) for easy tuning.

IF A LEG LOOKS WRONG

Don't force it in software. First, remove that servo's metal arm, re-center the servo while the test is running, and reinstall the arm so the leg sits in the correct X-stance. A correctly seated horn fixes most gait problems.

Step 8. Go Wireless

Once the robot walks well, upload Walk_web.py. This program makes the XRP broadcast its own WiFi access point — connect your phone or laptop to it, open the web page it serves, and you can drive the robot wirelessly with hold-to-repeat controls, trick buttons, and the LED color picker.

CONNECTING TO THE ROBOT

Join the network the robot broadcasts, then open its address in a browser. In my build, the access point is named XRP_QUAD, and the controller lives at 192.168.4.1.

When the wireless control is working the way you want, save the program as main.py on the XRP board. That way, the controller boots straight into it — power on the XRP and the robot is ready to drive, no computer needed.

Step 9. Add the Light Cube

To finish, I attached the glowing top using 10 mm magnets, as shown below. This makes the top quick to lift off whenever you need to get at the electronics, while holding firmly during walking.

walking_11

The magnetic top lifts straight off for easy access to the XRP and PCA9685.

And that's it — you should be good to go. Power up, connect, and take your Vantaphage for its first walk.

Vantaphage, a Walking Robot Build Guide

Quick Troubleshooting

Robot resets or twitches while walking
- Power brownout. Make sure the servos run on their own supply, separate from the XRP board.
One leg sits wrong / gait looks lopsided
- Servo horn seated at the wrong angle. Re-center that servo with sunfoundergait.py running and reinstall the arm.
LEDs don't light
- Recheck the data line on the Servo 1 header and confirm with LEDtest.py.
Servos don't respond at all
- Check the Qwiic 0 wiring to the PCA9685 (SCL, SDA, VCC, GND) and that ik.py and pca9685.py are in the XRP's lib folder.
Can't find the WiFi network
- Confirm Walk_web.py is running (or saved as main.py) and the board has power.
Joints flex or wobble
- Install the 12 joint holders with M2 heat-set inserts and 2 mm screws.