ZINGU

The idea

Zingu is an inverted-pendulum robot built around an ESP32. It holds itself upright with a cascaded PID controller, and when it falls over — because it always eventually does — it detects the fall, waits for the chassis to settle, and performs a wheel-torque kick-up to swing itself back into the balance envelope.

I want this to be a project a beginner can actually start from, and finish. Every version of Zingu is open source all the way down:

• Sketches and CAD. The original design files, not just an exported mesh.
• Printable parts. STLs and print settings for the whole chassis.
• Electronics. A full parts list, wiring and pinout.
• Firmware. The ESP32 code that balances, recovers and streams telemetry.
• Simulation and RL. The robot model and the training code behind any learned policy.

The project grows one robot version at a time. Each version is a complete robot with its own key feature — and, for the parts worth learning in simulation before touching hardware, its own sim-to-real story. Today that is a self-balancing robot. Next it gets legs, then a camera and the perception to use it.

I chose balance and self-recovery to start on purpose. It is about the smallest robot that still forces you through the entire real-to-sim-to-real loop: an unstable system where a hand-tuned controller runs out of road and a learned policy has something to prove — and a build you can finish on a desk. Everything after this is the same loop with more degrees of freedom.

The longer arc is an outdoor companion — the robot-dog idea on two wheels, smarter, and open to whatever task I can imagine giving it. Zingu Brain, the perception and decision side, comes next.

Versions

Every version is a finished robot, so you can start at your level and go as far as you want.

I version the robot so you can start from the basics: printing, wiring, building it, and simple RL training. Each version after that adds one thing on top.

v0.2.0 In CAD

Legs

v0.2.0 puts a leg between the chassis and each wheel.

• Articulated legs. A linkage on each side lets the body change height and ride over ground the rigid chassis simply scrapes across.
• Larger spoked wheels. More ground clearance and a longer contact arc to catch a fall with.
• Redesigned chassis. Electronics move into an enclosed box instead of riding exposed on the top plate.

The point is not the mechanism for its own sake: more degrees of freedom is exactly where a hand-tuned PID stops being enough and a learned policy starts to earn its keep.

Control loop

IDLE ──arm──> RECOVERING ──in envelope──> BALANCING ▲ │ └────── fall detected ───────┘ │ FAULT ── (stall / overcurrent / IMU loss)

Angle estimation from the IMU feeds an inner torque loop and an outer position loop. The state machine is what makes the robot recoverable rather than fragile: a fall is a transition, not a crash.

Links