Circuit and wiring

This page takes you from a bag of parts to a robot that talks to your computer. You get the whole circuit in one picture, a hole-by-hole build of the one board you solder, where every wire runs along the strap, and a bring-up sequence with the meter reading you should see at each step. The reference tables (pin map, power budget, firmware behaviour, packet formats, netlist) sit at the end for when you need them.

The circuit is new and has few builds behind it, so treat the meter readings in the bring-up as gates: do not move to the next step until you get the reading the table gives.

What you are building

Drawings: schematic.svg, wiring.svg (where every cable runs along the strap), perfboard.svg (the power board, hole by hole). The netlist, pin map and wire list in machine-readable form: electronics.json. All four come from one model, which checks that every perfboard net is connected and nothing is shorted, that every schematic net appears at both ends, and that no labels overlap.

How it works

A two-cell LiPo (7.4 V nominal, 8.4 V full) stands on its long edge on link s3. Its current goes through an XT30 plug and a resettable fuse (both lying beside the pack at −y), along a red and black 22 AWG pair down the −y edge of s4 and across joints 4 and 5, to the power board on link s5.

On the power board the battery voltage feeds two identical 5 V buck converters. Buck A makes the servo rail. Its output passes through the INA219's current-sense resistor (the module's 0.1 Ω plus an added 0.1 Ω in parallel), then to the "+" row of an 8 × 3 servo header. Buck B makes 5 V only for the ESP32. The ESP32 board's own regulator turns that into 3.3 V for itself, both IMUs and the INA219's logic. There are two bucks because eight servos starting together pull the servo rail down hard, and a shared rail would reset the radio at exactly the moment the robot needs it.

A 100k/33k divider scales the battery (up to 8.4 V) to under 2.1 V for the ESP32's ADC on GPIO34.

The ESP32 on link s4 drives eight servo signal wires (one LEDC hardware PWM channel each, 50 Hz) to the header. It talks I2C at 400 kHz to three chips on one bus: the mid IMU next to it (address 0x68), the INA219 on the power board (0x40), and the head IMU on link s8 (0x69, because its AD0 pin is tied high). The bus is about 330 mm long and crosses four joints.

The latch sensor is two steel screws in the head. One goes to GPIO27 (pulled up inside the ESP32), the other to ground. When the head bites the tail, both screws drop onto a bare wire laid across the tail's notches, GPIO27 reads low, and the firmware reports latch = 1 after 15 ms of steady contact.

Every 5 ms the firmware moves each servo pulse a little toward the last command (at most 32 µs per step, which is 10 rad/s, the fastest servo the simulator trains on). Every 10 ms it reads the sensors and broadcasts a 38-byte packet over ESP-NOW. A second ESP32, the dongle, sits on the computer's USB: it copies those packets to serial and copies serial command frames to ESP-NOW. Python on the computer does everything else (see Software).

The robot goes limp (no servo pulses) when any of these happens: no valid command for 300 ms, a command with the enable bit cleared, or the pack sitting under 6.6 V for 2 s. The low-battery state latches. 30 s later the ESP32 puts the sensors and itself to sleep, to cut the drain on a pack that has no protection circuit.

Why the circuit looks like this

The protection and wiring parts in this list add about $2.75 per robot, inside a $5 allowance. The architecture is simple on purpose: the ESP32 on the robot only relays, ESP-NOW goes to a dongle, the actuators are hobby servos, and power is two bucks.

Parts on this page

Per robot. Mechanical parts and sources are on the Parts page.

Tools: fine-tip iron at 330–350 °C, 0.8 mm rosin-core solder, flux pen, multimeter with a continuity beeper (and a 10 A current range for bring-up).

Battery safety and charging

Read this before you cut a battery lead.

• When re-terminating a pack to XT30, cut and solder one wire at a time, and heat-shrink it before you cut the other.
• Charge at 0.5 A (1 C) or less, in a LiPo bag or metal tray, attended, off the robot.
• Use a charger that connects to the 3-pin XH balance lead. Some cheap "1-to-2 USB" kit chargers charge through the discharge plug without balancing. If yours does, build a 5 cm adapter (XT30 male to the charger's plug, from the spare pigtail). Then check each cell monthly with a meter on the balance lead: the cells should agree within 0.05 V.
• Store at 3.8 V per cell. Retire any pack that puffs, gets dented, or measures under 3.0 V per cell.
• Unplug the battery at the end of every run. Never store the robot plugged in. Even after the low-battery cut-off puts the ESP32 to sleep, the robot draws roughly 55 mA (see Low-voltage cut-off).
• There is no reverse-polarity protection. The keyed XT30 is the protection, so the moment that matters is when you solder the pigtail. Bring-up step 1 checks it with a meter.

Build the power board

Work from perfboard.svg, which draws the top and the mirrored bottom.

Board hole map

The power board is 26 columns (1–26, across the link: column 1 at link y −31.7, column 26 at +31.8) by 8 rows (A–H, along the body: row A faces s4, row H faces s6). It sits on the s5 front block at link x 19.0–39.5 on 1 mm foam.

Bottom: bridges 1A–1C (VBAT), 1D–1E (VSENSE), 1F–1H (GND); GND row F 1–13, 13C–13F, row H 1–22, column 26; 5V_SERVO row G 13–22, column 25; SIG bridges 23x–24x. Two insulated 24 AWG jumpers on the bottom cross the signal bridges: JB1 22G → 25G (servo +) and JB2 22H → 26H (GND). On one layer a crossing is unavoidable here: the 8 signal columns sit between the power source and the header's + and − columns, and the board has no spare row.

Steps

1. Cut the board to 26 × 8 holes (66 × 20.5 mm). Mark column 1 and row A on both sides with a pen.
2. Bottom traces first. Lay bare tinned wire on the bottom pads and solder at every hole: GND row F (1–13), GND row H (1–22), 5V_SERVO row G (13–22), GND column 26 and 5V column 25 (A–H); then the bridges 1A–1C, 1D–1E, 1F–1H, 13C–13F and the eight 23x–24x. Last, the two insulated 24 AWG jumpers JB1 (22G → 25G) and JB2 (22H → 26H), lying flat across the signal bridges. Meter (unpowered): 1A–1C beep; 1F–1H–13C beep; 13G–22G beep.
3. Header J1 in columns 24–26, rows A–H. Meter: every column-25 pin beeps to 13G; every column-26 pin beeps to 1H; 24A–24B, 1A–1H, 13G–13H and 25A–26A must not beep.
4. R1 standing in 1C–1D. R2 standing in 1E–1F, with C3 in the same two holes.
5. Bucks. Test each one first, on its own, from the battery pigtail: output 4.9–5.1 V with no load. If it reads 0 V and has an EN pad, see Troubleshooting. Tape U3 (ESP32 buck) to columns 2–12 with 1 mm foam, 18 mm side along the board's short edge, IN pads toward column 1. Solder its legs (short 22 AWG): IN+ → 1B, GND → 1G, OUT+ → 13A. Tape U1 (servo buck) on top of U3 with 1 mm foam, same orientation; its IN+ and GND legs go into the same holes 1B and 1G. U1 sits on top so its heat goes to air, not into the ESP32's buck.
6. Battery lead. Solder the robot-side XT30 male to 150 mm of red and black 22 AWG. Splice F1 into the red lead 20 mm from the plug and heat-shrink it. Red into 1A, black into 1H. Meter, pack plugged in: 1A to 1H reads the pack voltage, 7.0–8.4 V, positive on red (if it reads negative, unplug at once and swap the wires). 13A to 1H reads 5.0 ± 0.1 V. U1's OUT+ pad to 1H reads 5.0 ± 0.1 V. 1D to 1H reads 0.248 × the pack voltage (for example 1.98 V at 8.0 V). Unplug.
7. INA219. Leave out the screw terminal block. Solder R5 (0.1 Ω 1 W) into the two Vin terminal holes, lying flat. Stick the module flat on columns 14–22 with 1 mm foam, its header pads facing column 13. Solder its GND pad to 13C with a short leg. W1: 22 AWG from U1's OUT+ pad to the module's VIN+ pad. W2: 22 AWG from VIN− to 13G. Lay C2 on its side on top of the module, on a strip of tape, + lead into 13G, − lead into 13H. Meter, pack plugged in: 25A (servo +) to 26A reads 5.0 ± 0.1 V. If it reads 0 V but U1's OUT+ pad reads 5 V, W1 or W2 is open. If U1's output itself is 0 V, it latched at start-up: unplug for 10 s and retry.
8. Harnesses, per the wire list: H1 into 23A–23H, 13A, 13B, 13D, 1D and onto the U2 VCC, SCL and SDA pads; H2 onto the U2 VCC, GND, SCL and SDA pads and into 13B (second wire in each). Strain-relieve the bundles to the board with a dab of hot glue on the insulation, not on the joints.
9. Mount the board on the s5 front block (link x 19.0–39.5) with 1 mm foam, column 1 toward −y. Use foam pads under the bucks and the INA, so the bottom wires and jumpers press into the foam rather than rocking the board.

Heights above the link plane (board top at z 10.6): buck stack 23.4, INA with C2 on it about 21, R1/R2 about 20.5, J1 with servo plugs 27.1. Everything except the plugs sits under z 24.

Wire the strap

wiring.svg shows every run. Lengths include a 15 mm slack loop for every joint crossed. Flat 3-wire servo leads lie flat across the hinges, which is the bend they tolerate best.

Where everything sits

These positions match the Mechanical page (mounting the electronics).

The real board layout differs from the block stand-ins in the CAD but stays inside the same envelope. Across the board the bands are: buck stack at y −30.5…−1.5 (z ≤ 23.4), INA at y 0…23 (z ≤ 21 with C2 on it), J1 at y 24.4…33 (z 27.1). The CAD stand-ins put the bucks at y −33…−19, the INA at −18…7 and a lying cap at 10.5…20.5. The x extent (19.0–39.5) and the maximum height (27.1) are the same.

Clearance above the plugs. The servo wires leave the top of each plug and must turn flat into the lead channel. Bent tight at the plug, that takes about 2 mm (z ≈ 29); a relaxed bend takes 4 mm. Check that z 29 over y 24–33 clears at the j5 and j6 extremes before you close up. A right-angle header is no help here: the plugs would stick out past y 33.

Cable runs

Servo leads

Servo k sits in the front cradle of segment s(k−1) and drives joint k. Lead lengths are the routed numbers from cad/check_fit.py, against a 240 mm MG90S lead. Measure one of your leads before ordering extensions. The same numbers are on the Mechanical page (mounting the electronics).

The three plug-to-plug joints (about 30 × 8 × 3 mm each) lie in the lead channel; with these lengths they land on s3 or s4. Coil spare lead in the channel. Do not cut it.

Wire list

H1 signal colours follow the resistor colour code: the colour is the servo number.

Set up the firmware toolchain

You flash four sketches during bring-up: i2c_scan, servo_center, ouro_robot and the dongle's ouro_dongle. Install the toolchain first.

brew install arduino-cli
arduino-cli core update-index && arduino-cli core install esp32:esp32     # 3.3.12 tested
arduino-cli lib install ESP32Servo                                        # 3.0.9 tested
arduino-cli compile -b esp32:esp32:esp32 firmware/ouro_robot
arduino-cli upload  -b esp32:esp32:esp32 -p /dev/cu.usbserial-XXXX firmware/ouro_robot

In the Arduino IDE the board is "ESP32 Dev Module" (FQBN esp32:esp32:esp32) with its defaults: 240 MHz, 4 MB flash, QIO 80 MHz, default partition scheme, PSRAM disabled. Two exceptions. If upload fails at 921600 on a CH340 board, set Upload Speed to 460800 (-b esp32:esp32:esp32:UploadSpeed=460800). If it hangs at "Connecting…", hold BOOT.

The sketches compile with zero warnings (core 3.3.12, --warnings all). Expect these sizes:

ROBOT_ID and WIFI_CHANNEL live in ouro_common.h, which exists in both the robot and dongle sketches. The two copies must be identical.

Bring-up, step by step

Each step has an expected reading. Do not move on until you get it.

Once step 12 passes, the robot is ready for the gaits and policies on the Software and Simulation and RL pages.

Troubleshooting

Reference