Build & Setup Guide · Updated Nov 2026

Building a GELLO Leader Arm for Franka FR3: Hardware Assembly, Wiring, Calibration, and Pitfalls

A complete, reproducible build of a GELLO teleoperation arm for the Franka Research 3: a $323 bill of materials, 3D-printing and assembly notes, Dynamixel wiring and ID setup, calibration against the robot, and the mistakes that cost the most time. The same arm went on to collect our lab's 10-task FR3 demonstration dataset.

GELLODynamixel XL330OpenRB-150Franka FR3TeleoperationImitation LearningLeRobot

The finished leader arm driving the FR3 in real time — each run recorded as a demonstration for imitation learning.

At a glance

Cost≈ $323 in parts, $335 with the optional 5V supply, plus 18 in-house 3D prints.
Hardware7× XL330-M288-T joints + 1× XL330-M077-T trigger on one TTL bus; OpenRB-150 bus master over USB-C.
PowerPassive leader, servo torque off: USB power is enough, no external supply needed.
Output8-D joint-velocity actions at 15 Hz, recorded straight into LeRobot v2.1 datasets with two 224×224 camera views.
InsightThe robot can follow the leader in Cartesian space (FK → end-effector delta → IK) or in joint space (P-control on joint error). IK can hide a wrong joint sign, and free-space matching cannot resolve the pitch-joint offsets: validate with whole-arm tracking and calibrate against the homed robot.

Scope. The hardware build plus the software needed to verify it. Franka FCI setup, the controller stack, and policy training live on the FR3 cell page.

On this page1Intro2Bill of materials3Assembly4Wiring5Pitfalls6Power-on checklist7Teleop behaviour8Results & lessons

01 · Introduction

What this guide is for

Fully assembled GELLO leader arm standing beside the Franka FR3
The finished GELLO leader arm beside its FR3 follower.

GELLO is a low-cost, 3D-printed leader arm: a passive kinematic twin of the robot that you move by hand while the real arm follows, so demonstrations come out smooth and intuitive, in the robot's own joint space, without a VR headset or a SpaceMouse.

This guide documents the exact build used on our lab's Franka FR3: what to buy, how to assemble and wire it, how to calibrate it against the robot, and how to confirm it works before the robot ever moves. The same leader arm has since collected the lab's 10-task FR3 demonstration dataset (§8).

My hardware setup

  • Follower robot: Franka Research 3 (7-DoF) with a Robotiq 2F-85 gripper.
  • Leader: GELLO arm built from the gello_mechanical/franka_fr3 design.
  • Actuators: 7× DYNAMIXEL XL330-M288-T (joints) + 1× XL330-M077-T (gripper trigger).
  • Controller: ROBOTIS OpenRB-150, bus master on USB-C; pinned to /dev/gello by a udev rule.
  • Software: gello_software (Dynamixel driver + offset calibration) and RLinf's real-world environment: GelloJointIntervention turns leader joints into joint-velocity commands for the Polymetis / DROID controller on the NUC.

02 · Bill of Materials

What you need to buy and print

Everything I actually used — exact models, quantities, and where I bought them. The seven joint servos are the bulk of the cost; the structural parts were printed in-house.

ItemSpec / modelQtyUnitSource
StructuralFR3 GELLO 3D-printed partsPrinted on a Bambu. Tolerances matter — some holes need sanding, drilling, or heat-set tweaks.18 pieces · gello_mechanical/franka_fr318in-houseGitHub ↗
ActuatorArm joint motorsMain joint servos. Use the TTL 3-pin version — not the RS-485 4-pin.DYNAMIXEL XL330-M288-T7$27.49ROBOTIS ↗
Frame / IdlerHinge frame + idler setXL330 hinge/idler side. Keep spares — small plastic parts are easy to lose.FPX330-H101 (4 pcs)1 set$9.80ROBOTIS ↗
ActuatorTrigger / gripper motorGripper trigger input. Needs its own gripper-range calibration in software.DYNAMIXEL XL330-M077-T1$27.49ROBOTIS ↗
ControllerGELLO controllerMotor cable into a white Dynamixel port; USB-C to the PC.OpenRB-1501$28.64ROBOTIS ↗
CableLong Dynamixel cableFor longer joint routing. Must be the 3-pin TTL JST-JST cable.Robot Cable-X3P JST-JST, 360 mm3$10.95MyBotShop (ROBOTIS reseller) ↗
CableUSB cable for OpenRBMust support data — charge-only cables power the board but hide the serial device.USB-A → USB-C, ~2 m1$8.00Amazon (search) ↗
PowerExternal DXL power supplyOptional for passive reading; required for torque / damping / virtual-spring mode. Never 12V on XL330.5V, ≥3A (5A preferred)1$12.00Amazon (search) ↗
ToolScrewsKeep several lengths — some printed holes are shallow.M2 & M3 self-tapping1 set$12.00Amazon (search) ↗
SpringJoint springs (J2 & J4)Both from one stainless torsion-spring assortment kit (box label 1.2*10*35mm-180°). The kit lets you test-fit stiffnesses.Torsion, 1.2 × 10 × 35 mm, 180°2$11.40 / kitAmazon (search) ↗
Total≈ $323$335 with the 5V supply · prints in-house

03 · Mechanical Assembly

Putting the arm together

3D-printed GELLO linkages laid out during assembly
The printed linkage set mid-build.

3D printing

The arm is 18 printed pieces from the franka_fr3 design. It doesn't carry the load a real FR3 does, but the joints still take repeated screw pressure and hand force during teleop — so I printed at ~50% infill, favoring strength over a featherweight part.

  • Supports + auto-orient: enable supports and let the slicer auto-orient each part — several are awkwardly shaped, and the default STL orientation often isn't the best one to print.
  • Hole compensation: turn it on, or screw holes print slightly undersized — and fighting (or re-drilling) every hole eats a lot of assembly time.
  • Use self-tapping screws for almost everything: ordinary machine screws are very hard to drive into printed plastic, while self-tappers cut their own clean thread.
  • Motor order: install the servos from the base outward, seating each before adding the next link — and leave their IDs unset for now (assigned one at a time during wiring).
Gravity-compensation torsion spring mounted at a GELLO joint
A torsion spring (1.2 × 10 × 35 mm, 180°) at the joint — tension and mount angle both matter.

Spring installation

Two torsion springs (the same 1.2 × 10 × 35 mm, 180° size) sit at joints 2 and 4 to offset gravity so the passive arm floats instead of sagging. The mount angle and pretension are the fiddly part: too stiff and the arm fights your hand, too loose and it droops. I set them so the arm holds a neutral pose on its own with almost no effort to move.

Cable routing & base mounting

Route each lead along its link with enough slack to survive the joint's full range — a cable that's taut at one extreme will unseat its connector or cap the motion. Finally, fix the base so the leader can't tip during teleop and its reach maps comfortably onto the robot's workspace.

04 · Wiring

From servos to the PC

The XL330s share a single 3-wire TTL bus: each servo has two ports, so you chain them servo-to-servo from the base out to the gripper. The first servo plugs into the OpenRB-150's white Dynamixel port; the board is the bus master and talks to the PC over a single USB-C cable that carries both power and data.

It enumerates as a USB CDC-ACM serial device — on my machine /dev/ttyACM0(note: ACM, not the FTDI ttyUSB* some docs assume). Confirm it before going further:

ls -l /dev/serial/by-id/      # stable name for the OpenRB-150
ls -l /dev/ttyACM0            # what gello_software expects

Set each servo's ID before you chain them

This is the step that bites everyone: every Dynamixel ships with the same factory ID (1). Put them all on one bus and they answer at once and collide, so a scan flickers between seeing one device and none. Before building the daisy-chain, connect one motor at a time and use ROBOTIS's software (Dynamixel Wizard 2.0, through the OpenRB-150) to write a unique ID to each (default baud 57600) — 1→7 for the joints from base to tip, and 8 for the gripper. Only one servo may be on the bus while you write, or the new ID gets broadcast to every ID-1 servo at once.

Soldering extended Dynamixel cables on the bench
The stock leads were too short, so I soldered my own extensions.

The cables were too short

The stock Dynamixel leads didn't reach across the longer links of this build, so I made my own: cut to length, soldered, and heat-shrunk each joint's extension. It's tedious but worth doing carefully — a cold joint here turns into the kind of intermittent bus fault that's miserable to chase later.

When external 5V is needed

For passive teleoperation — how GELLO is used here, with servo torque off — the OpenRB-150's USB-C power is enough; the arm only reads joint angles. An external supply (5V, ≥3A — 5A preferred, never 12V on XL330) only matters if you actually drive the servos: torque, damping, or virtual-spring mode. I first thought it was required and it wasn't — a misread of a torque-enable warning.

05 · Common Pitfalls

What actually cost me time

Pitch offsets look right but are 90° off

Joints 2, 4 and 6 cannot be calibrated by holding the leader in free space: the arm looks matched while an offset is a quarter turn out. Calibrate against the homed robot, a rigid reference, and validate each joint's sign and offset against its known pose.

Calibration lost with the container

Editing the installed gello_software config inside a container is lost on rebuild — ours dropped the June calibration in July. Keep the leader's DynamixelRobotConfig in your own repo and inject it into PORT_CONFIG_MAP at runtime.

GELLO ↔ FR3 pose mismatch

Calibration assumes leader and follower start matched. If they disagree at startup, every command is offset — and the leader can sit in a J1/J3 +π mirrored pose that looks identical to the eye. Align to the robot's home before enabling control, every time.

A torque warning that reads like a power fault

For passive reading, USB power is enough. I first took a torque-enable warning to mean the bus was under-powered and bought an external 5V supply; it only matters if you actually drive the servos.

Wrong Dynamixel cable type

XL330s use a specific JST connector/pitch. A lead from another Dynamixel family may fit but mis-seat — keep the cable matched to the servo.

Printed holes too tight

3D-printed seats and bores come out undersized. Ream to spec rather than forcing parts — over-pressing cracks mounts and binds joints.

Spring too stiff / wrong angle

An over-tensioned or badly-anchored gravity spring makes the arm fight you or droop. Tune pretension and mount angle so it floats neutrally.

The two classics — eight servos sharing factory ID 1, and stock cables too short for the long links — are covered in §4.

06 · First Power-On Checklist

Confirm it works before the robot moves

  • ✓Board power LED on after USB-C connect.
  • ✓Device appears under /dev/serial/by-id (and as /dev/ttyACM0). A udev rule that pins it to /dev/gello saves you from floating port numbers later.
  • ✓All 8 motors detected on a bus scan (IDs 1–7 joints, 8 gripper) at 57600 baud.
  • ✓Joint offsets derived with gello_get_offset.py from a known start pose, then validated against the homed robot, not free-space matching.
  • ✓Joint signs correct — validated by end-effector tracking, not single-joint motion (§7).
  • ✓Gripper trigger open / closed servo positions recorded.

Calibration: derive the offsets, then check them against the robot

gello_software derives each joint's offset from a known start pose: hold the leader in that pose and run the script. Offsets come out as multiples of π/2, the calibration resolution. We calibrate from the pose [0, 0, 0, -1.571, 0, 1.571, 0]and then home the robot to it, so leader and follower can be compared joint by joint.

# gello_software: offsets from a known start pose (leader held in that pose)
python scripts/gello_get_offset.py \
  --start-joints 0 0 0 -1.571 0 1.571 0 \
  --joint-signs  1 1 1 -1 1 -1 1 \
  --port /dev/gello

Reference: my calibrated config

The resulting config, kept in our repo and injected into GELLO's port map at runtime (see §5). The offsets, signs, and gripper range are build-specific, so yours will differ:

# registered into gello.agents.gello_agent.PORT_CONFIG_MAP at startup
PORT_CONFIG_MAP["/dev/gello"] = DynamixelRobotConfig(
    joint_ids      = (1, 2, 3, 4, 5, 6, 7),
    joint_offsets  = tuple(m * np.pi / 2 for m in (2, 0, 0, 1, 2, 3, 2)),
    joint_signs    = (1, 1, 1, -1, 1, -1, 1),
    gripper_config = (8, 264, 222),   # (id, open deg, closed deg)
)

07 · Notes for FR3 Teleoperation

How it behaves once it's live

Passive GELLO has no force feedback

The leader's motors are torque-off; it senses your motion and never pushes back. You feel the springs and the arm's own inertia — nothing from the robot or its contacts — so move deliberately, especially near objects. The leader is read synchronously inside the control loop, so a frame or two of lag at 15 Hz is normal, not a fault.

Two ways for the FR3 to follow the leader

RLinf ships a Cartesian path: forward kinematics on GELLO's joints gives an end-effector pose, the delta against the robot's current tool pose becomes an EE-delta action, and inverse kinematics redistributes it across the real joints. We started there, then added a joint-space path for data collection: a P-controller on the joint error emits an 8-D joint-velocity action [dq(7), gripper] at 15 Hz.

Cartesian path  (RLinf GelloIntervention)
  GELLO joints ─(offset, sign)─▶ FrankaFK ─▶ EE pose ─▶ delta vs current TCP ─▶ IK ─▶ joint commands

Joint-space path  (GelloJointIntervention — what we collect with)
  GELLO joints ─(offset, sign)─▶ v = clip(kp · (q_gello − q_robot), ±vmax) ─▶ [dq(7), gripper] @ 15 Hz
                                   kp = 4, one P-gain for all seven joints

Why the switch: joint velocity is π₀.₅-DROID's native action, so the same 8-D vector that drives the robot is what lands in the dataset, with no IK in between. It also closes a trap of the Cartesian path: because IK redistributes motion, a wrong joint sign can hide behind perfectly good end-effector tracking. Validate signs with whole-arm tracking, and keep the Cartesian path for policies that act in EE-delta space.

Always align before enabling the controller

Before each session, pose GELLO to match the robot's home, then enable teleop. Enabling with a large mismatch commands a big instantaneous jump. A live readout of leader-vs-robot joint error is worth the ten lines of code: it catches the mirrored poses the eye misses.

08 · Results & Lessons

What the arm has produced, and what I'd change

The build went from printed parts in mid-May 2026 to a calibrated leader on June 16 and the first teleop rollouts (the clips at the top) the next day. The joint-velocity collection pipeline went live on June 22 with pilot datasets (stack a cube, assemble a lamp); on July 3 the offsets were re-derived against the homed robot after a container rebuild dropped the first calibration. Since then the arm has been the lab's demonstration device for the FR3.

250

episodes across 10 tabletop tasks in the lab's FR3 dataset, 66,463 frames

15 Hz

8-D joint-velocity actions, recorded directly as the dataset action

2 × 224²

camera views per frame (LeRobot v2.1), plus full-HD SVO recordings for re-cropping

4–8 mrad

leader-to-robot joint error on J1–J4 at 1–2 frames of lag (measured Nov 2026)

Tasks range from pick-and-place and stacking to pressing a button, closing a shape-sorter lid, inserting a book into a stand, and pulling a block out from under another. The dataset was collected by lab members with this leader arm and the joint-velocity pipeline in §7.

What I'd do differently

  • Turn on hole compensation for the first print. Re-drilling undersized holes cost more time than any other assembly step.
  • Order the 360 mm cables up front instead of soldering extensions; a cold joint becomes an intermittent bus fault you chase for hours.
  • Assign servo IDs before assembly, one motor on the bus at a time, and label each servo.
  • Calibrate against the homed robot from day one. Free-space matching cannot resolve the pitch joints.
  • Keep the calibration in the repo, not in an installed package inside a container.

Resources

  • gello_mechanical — printable parts, including the franka_fr3 set used here.
  • gello_software — Dynamixel driver, PORT_CONFIG_MAP, and gello_get_offset.py.
  • GELLO paper — Wu et al., the original design and teleoperation framework.
  • XL330-M288-T e-Manual and OpenRB-150 — control tables, wiring, and the ID / baud settings.
  • Dynamixel Wizard 2.0 — the tool for writing servo IDs one motor at a time.
  • RLinf — the real-world environment, data-collection wrappers, and LeRobot export used on our bench.

How the rest of the cell is wired — the FR3 controller on the NUC, the cameras, and the zero-shot π₀.₅-DROID evaluations — is documented on the FR3 cell page →