OhhO Bench
From a box of parts to a robot that powers on.
Design is the easy half. OhhO Bench takes the bill of materials you exported from Build and walks you all the way to a robot that powers on — guided mechanical assembly, a wiring map, firmware flashing, and hardware self-tests that prove every motor, sensor and servo actually works.
- Step-by-step assembly from your BOM
- Wiring & port map (serial / power / bus)
- One-click firmware flashing
- Hardware self-test & diagnostics
- Sensor, camera and arm calibration
What you get
Between a sourced bill of materials and a working software stack lies the part nobody writes documentation for: bolting the robot together, wiring the motor board, flashing firmware, and discovering — usually the hard way — which connector is in backwards. OhhO Bench turns that into a guided, checked workflow.
Bench reads your OhhO Build design and generates the exact assembly order, a wiring and port map (which controller talks over which serial port at which baud rate), and a firmware bring-up sequence. As you go, it runs hardware self-tests — spin each motor, read the encoders and IMU, sweep every arm servo — so a mistake is caught at the bench, not in the field.
When the mechanics are sound, Bench runs the calibration routines: motor direction and odometry geometry, IMU bias, camera intrinsics and the surround-view rig, and arm joint homing. It writes the deployment profile the rest of the stack consumes — so the moment Bench turns green, OhhO Frame, View and Autonomy come up on real, calibrated hardware.
Built to do the hard parts for you
Bench expands your Build BOM into an ordered, illustrated assembly sequence — what bolts to what, in what order, with torque and orientation called out.
A generated harness diagram: motor board, arm bus, cameras and compute, with the serial ports, baud rates and power budget each one needs.
Flash the motor-controller and microcontroller firmware from the browser, with the right protocol and configuration for your base — no hand-edited config.
Spin each wheel, read encoders and IMU, and sweep every arm joint to confirm wiring and direction before any autonomy runs.
Walk through odometry geometry, IMU bias, camera intrinsics, the surround-view rig and arm homing — and write them into the deployment profile.
A green Bench produces the deployment profile and calibration files that OhhO Frame, View and Autonomy pick up with zero re-entry.
How it works
Bench pulls the BOM, wiring and component specs from your OhhO Build design.
Follow the ordered assembly steps and the generated wiring / port map.
Flash firmware and run the hardware self-tests until every subsystem reports healthy.
Run the calibration routines; Bench writes the deployment profile for the rest of the stack.
Specifications
- Input
- OhhO Build BOM + wiring + component specs
- Firmware
- Motor board + MCU, protocol-aware flashing
- Self-test
- Motors, encoders, IMU, arm servos, cameras
- Calibration
- Odometry, IMU bias, camera intrinsics, BEV rig, arm homing
- Output
- Deployment profile + calibration files
- Handoff
- OhhO Frame, View, Autonomy
Which plan do I need for OhhO Bench?
We recommend the Builder plan. Anyone building their first unit wants Builder for firmware flashing and the guided calibration routines. Teams bringing up many identical robots move to Fleet for batch bring-up, and manufacturing partners use Forge for a handoff pack.
Common questions
It's smoothest end-to-end, but Bench also works from a manually-entered parts list — you just fill in the wiring and ports it would otherwise infer.
Yes — Bench is the step where software meets metal. The self-tests and calibration run against the physical robot over its serial / USB buses.
Works better together
Ready to build with OhhO Bench?
Start free and simulate first — no hardware required. Upgrade when you're ready to deploy.