How to build AhaRobot low-cost open-source bimanual mobile manipulator (Astra hardware): the whole process
80 steps to build AhaRobot low-cost open-source bimanual mobile manipulator (Astra hardware), from buying parts, printing and assembly to software, calibration and train…
Creator's estimate: the website puts hardware at $1,000–2,000 ($1,000 without compute, $2,000 with an RTX 4060 Mini‑ITX computer), and its price table gives a hardware subtotal of $826.1 and $1,950.8 with compute. The docs' parts list totals $990 (CN¥7,132.57) for the base, lift frame and power plus the arms and head pan-tilt, $1,124 (CN¥8,098) for compute and its power supply, and $33 (CN¥239) for RoboPilot teleoperation; most parts come from Taobao and the aluminium profiles are ordered by MISUMI part number from JLC FA, and the list gives no shipping. The purchase form lists only add-ons (+$100 for assembly, +$1,500 for computer and battery) and no base price
Buy parts
- Contact Sales for Parts Packages
The sales team offers parts packages at cost price; contact sales and pay only additional shipping and taxes.
- Buy the ITX PC
Buy one ITX PC (RTX 5060) for RMB 5999. Lower-spec computers such as Raspberry Pi can also be chosen; this configuration is intended for running models locally and can also perform remote inference.
- Buy the Jackery Power Station
Buy one Jackery Explorer 600Plus 220V 800W Portable Power Station for RMB 2099. It powers the main computer.
- Clone the PyAV repository
If PyAV has not been cloned yet, clone the repository using the specified branch.
Print and make
- Print the Marker Pages
Download the PDF file and print the Markers using duplex printing at 100% scaling with no resizing.
Assemble
- View Astra.STEP assembly orientation
Open the Astra.STEP file to determine the accurate installation orientation and position. If CAD software is not installed, Autodesk Fusion is recommended as the viewing tool.
- Assemble and secure chassis frame
Use aluminum profiles to assemble the chassis frame, and secure the framework firmly using M8*30 socket head cap screws.
- Install motors and photoelectric switches
First install the motors and photoelectric switches on the rails.
- Mount rails to chassis
Use two flat aluminum corner brackets to mount the rails to the chassis. Ensure that the stepper motor’s top surface is flush with the 3060 aluminum profile and the rail’s front surface is 20.3 mm from the profile; do not fully tighten the screws during installation.
- Install blocks and front reinforcement
Continue using corner brackets to install the two connecting blocks, then install the front 30120 aluminum profile reinforcement structure and secure it with M8 bolts. Ensure that the 3090 aluminum profile and 30120 aluminum profile form a right-angle relationship after installation.
- Install the drive wheels
Lay the assembled robot down and install the drive wheels. Install the hub motor front fork brackets first, then install the motors.
- Install the computer support structure
Install the corresponding profiles as shown in the images, then secure the installation with M8 screws and flat corner brackets.
- Install the shoulder dual-motor module
Secure the servos to the structural components with Phillips countersunk screws of the same specification. Connect the servo horns to the mechanisms with appropriate M3 screws.
- Install the elbow dual-motor module
Complete the installation of the elbow dual-motor module following the document images.
- Assemble the upper and lower arms
Connect the assembled dual-motor modules to the profiles to complete the upper arm and lower arm. The left arm installation follows the same steps as the right arm.
- Install the wrist sequentially
Using the right wrist as an example, connect one joint at a time in series. Install an AXK2035 thrust needle roller bearing between each servo and the next structural component to bear non-axial moments.
- Install the gripper mechanism
Install the rail first, then mount the two gripper heads to the gripper. Ensure that the rack and pinion are properly connected.
- Install the head pan-tilt unit
Complete the installation of the head pan-tilt unit using the same sequential steps as the wrist.
- Complete the gripper and robot assembly
Mount the gripper to the arm, then install the arms and head pan-tilt unit onto the lifting platform to complete the installation.
- Cut Along the Dotted Lines
Cut the printed Marker pages along the dotted lines.
- Attach the Right Handle Markers
Use Markers ID 0–16 on the right handle and ignore Marker ID 17. Apply the Markers counterclockwise from the top using double-sided tape for best results.
- Attach the Left Handle Markers
Use Markers ID 18–30 on the left handle. Apply the Markers counterclockwise from the top using double-sided tape for best results.
- Follow the Notion hardware assembly guide
The document gives no assembly details; it directs you to the project's Notion hardware assembly guide.
Software
- Clone the astra_ws workspace
Clone the astra_ws project with its submodules, then change into the astra_ws directory.
- Improve slow Docker downloads
If downloads are slow, configure an APT mirror in the Dockerfile or set an HTTP(S) proxy with the http(s)_proxy environment variables.
- Install packages and configure ROS
Install several patched Python packages from source to enable AhaRobot’s features. When using Docker, run the following commands inside the container. Do not install ROS together with Conda.
- Update package indexes
Run the apt and rosdep updates from the project root.
- Install ROS dependencies
Install ROS dependencies from the packages in src.
- Install aiortc
Enter non_ros_src/aiortc, install the required development packages, and install aiortc in editable mode.
- Install pyribbit
Enter non_ros_src/pyribbit, pin the setuptools version, and install pyribbit in editable mode.
- Install urchin
Enter non_ros_src/urchin and install urchin in editable mode.
- Install MR URDF loader
Enter non_ros_src/mr_urdf_loader and install mr_urdf_loader in editable mode.
- Install ModernRobotics Python package
Enter the ModernRobotics Python package directory, update packaging, and install the package in editable mode.
- Install astra_teleop
Enter non_ros_src/astra_teleop and install astra_teleop in editable mode.
- Install astra_teleop_web
Enter non_ros_src/astra_teleop_web and install astra_teleop_web in editable mode.
- Build PyAV dependencies
Enter non_ros_src/PyAV, install build dependencies, set PYAV_LIBRARY, activate the environment, and build PyAV.
- Install FFmpeg with libsvtav1 support
Add the Ubuntu PPA repository and install FFmpeg with libsvtav1 support.
- Install lerobot
Enter non_ros_src/lerobot, install lerobot, and pin huggingface_hub below version 0.25.
- Install odrive-can
Enter non_ros_src/odrive-can, install can-utils, and install odrive-can in editable mode.
- Install serial and CAN Python libraries
Install pyserial and python-can.
- Build the ROS 2 workspace
Build all packages in the current ROS 2 workspace and install them into the workspace.
- Build the ROS Workspace at the Root
Build the ROS workspace with colcon at the project root, then load the generated environment setup.
- Bring Up the CAN Bus on the Host
Outside Docker, bring up can0 at a bitrate of 250000 with a transmit queue length of 100. To reset it, bring can0 down first.
- Find the USB device KERNEL value
Run udevadm or lsusb to obtain the KERNEL value for the device at /dev/video0, because the USB device name changes after each Linux reboot.
- Bind the USB device port
Follow the format of the 99-astra-fixed-port.rules file to bind the USB device in /etc/udev/rules.d/99-astra-fixed-port.rules; in the example, 1-6.2:1.0 represents tty_puppet_left.
- Configure ODrive udev rules
Download the ODrive udev rules and install them as /etc/udev/rules.d/91-odrive.rules.
- Reload the udev configuration
Reload the udev rules and trigger udev to apply the modified configuration.
- Clone the firmware project and subprojects
Clone the AstraFirmwares project and its subprojects.
- Open the arm controller source directory
Open the AstraFirmwares/AstraArmController firmware source directory with VSCode or Cursor.
- Install the PlatformIO plugin
Install the PlatformIO plugin in VSCode or Cursor.
- Compile and flash the right controller
Compile the project and flash its firmware to the right arm controller.
- Flash the left arm controller firmware
Change upload_port to /dev/tty_puppet_left in platformio.ini and save it, then compile the project as for the right arm and flash the firmware to the left arm controller.
- Open lift controller firmware
Use VSCode/Cursor to open the lift controller firmware source directory, compile the project, and first flash the right lift controller firmware similarly to the arm controller.
- Configure left lift controller
In main.cpp, disable the normal right-side STEPPER_CORRECT_DIR definition and enable the reversed left-side definition. Change upload_port to /dev/tty_puppet_lift_left in platformio.ini, save the compilation project, and flash the left lift controller firmware.
- Flash head controller firmware
Use VSCode/Cursor to open the head controller firmware source directory, compile the project, and flash the head controller firmware.
- Flash pedal controller firmware
Calibrate and test
- Ignore Illegal Hall State Error
Configure the axis0 encoder to ignore illegal hall-state errors.
- Configure Axis 1 Motor and Encoder
Set up the axis1 motor and encoder in the same way, including current limit, pole pairs, encoder mode, CPR, and bandwidth.
- Finish Axis 1 Calibration Settings
Set the axis1 resistance-calibration maximum voltage, calibration range, calibration scan distance, current-control bandwidth, and ignore illegal hall-state errors.
- Save Configuration and Reboot
Wait 1 second for communication between the upper and lower computer to complete, then save the configuration and reboot.
- Start Axis 0 Encoder Calibration
Set the axis0 requested state to the full calibration sequence to begin encoder calibration.
- Let Axis 0 Motor Complete Rotation
A beep will come from the driver board; make sure the motor is not touching the ground. The motor will then rotate several times by itself, so wait for it to stop.
- Save Axis 0 Calibration and Reboot
After the motor stops, mark the axis0 encoder and motor as pre-calibrated, wait 1 second, save the calibration parameters, and reboot.
- Start Axis 1 Encoder Calibration
Begin calibrating the other motor in the same way by setting the axis1 requested state to the full calibration sequence.
- Pre-calibrate Axis 1 and Save Configuration
Mark the axis1 encoder and motor as pre-calibrated, wait for 1 second, then save the configuration and reboot the ODrive.
- Set Axis 0 Position Control Parameters
Set axis0 to position-control mode with a position gain of 20, velocity gain of 0.10, and velocity integrator gain of 0.
- Set Axis 0 Trapezoidal Motion Limits
Configure axis0 for trapezoidal-trajectory input with a velocity limit of 20, acceleration limit of 1, and deceleration limit of 1.
- Set Axis 1 Position Control Parameters
In the same way, set axis1 to position-control mode with a position gain of 20, velocity gain of 0.10, and velocity integrator gain of 0.
- Set Axis 1 Trapezoidal Motion Limits
Configure axis1 for trapezoidal-trajectory input with a velocity limit of 20, acceleration limit of 1, and deceleration limit of 1.
- Optionally Start Closed-Loop Control and Test
The document provides optional closed-loop startup settings: request axis0 to enter closed-loop control and enable startup closed-loop control.
- Prepare the Calibration Board
Download calibration_board.png and attach it to a flat surface.
- Install Teleoperation Dependencies
Clone the astra_teleop repository and install the package with pip.
- Collect Camera Calibration Images
Collect calibration images from /dev/video0 and save them in ./calibration_images.
- Move the Board Before the Camera
Move the calibration board in front of the camera.
- Process Calibration Images
Process the calibration images in ./calibration_images and generate the camera matrix and distortion coefficients.
- Review Calibration Results
Results are saved in calibration_images/teleoperation_calibration_results_{%Y%m%d%H%M%S}.yaml with camera intrinsic parameters and distortion coefficients.
- Test the chassis and lifting platform
Perform the initial tests as directed in the Flashing Firmware chapter. Raise the frame while testing hub motors, and ensure the lifting platform photoelectric switches are correctly installed and connected to the ESP32.
Data and training
- Train the model
Train an ACT policy on the collected dataset and save the output to the specified directory.
- Evaluate the model in reality
Run the trained model at 30 FPS on the Astra Joint robot for the task of grasping floor toys and placing them on the tabletop.
Use it
- Start the Robot and Web Teleoperation UI
Start the AhaRobot controller and the web teleoperation user interface.
Parts
- 26 Feetech STS3215 magnetic-encoder bus servos (12 per arm, with dual-motor modules at shoulder and elbow, and 2 for the head pan-tilt) on 3 Waveshare ESP32 servo driver boards; the docs warn the servos break easily and suggest spares
- Lift: two GT45‑1200 slide modules (left and right) with 57115 steppers and photoelectric switches, DM542 drivers, and ESP32 boards relaying USB‑TTL commands
- Base: two HB‑139 hub brushless motors driven by an ODrive 3.6, plus a 5-inch caster, on a frame of MISUMI 3030, 3060 and 30120 aluminium profiles
- Arms: 2040 aluminium-profile links, MGN7C linear rails for gripper opening, AXK2035 thrust needle bearings, with structural parts best printed in PETG‑CF
- Vision: three USB cameras (top and both wrists), UGREEN USB 3.0 hubs and extension cables
- Power: a 24V 20,000 mAh battery with a 3A charger, a 24V-to-12V 30A module and an emergency stop; optionally a Jackery Explorer 600 Plus power station for the computer
- RoboPilot: four Hall-effect pedals on an ESP32, 3D-printed 26-faced marker handles and an optional camera
Tools
- A 3D printer (the docs use a Bambu Lab P1P and advise against A1 and other i3-style printers, which can tip tall prints over), a hardened-steel nozzle (needed for PETG‑CF) and bed adhesive; printed parts can also be bought from the team
- A soldering iron (for heat-set inserts), a screwdriver set, hex keys and needle-nose pliers; mounting the rails is best done by two people
- CAD software such as Autodesk Fusion to read Astra.STEP for part orientation
Skills
- Assembling the aluminium-profile frame and rails; raising the frame when testing the hub motors
- Flashing ESP32 firmware for the arm, lift, head and pedal controllers, setting ODrive motor parameters and calibrating encoders
- Ubuntu 24.04, Docker and ROS 2 Humble; collecting datasets, training and inference with LeRobot (VLA inference needs an NVIDIA GPU, RTX 2060 at minimum)
Software
- astra_ws: the ROS 2 workspace; astra_controller talks to the firmware, solves inverse kinematics and launches web teleoperation, with the URDF and a Nav2 navigation simulator
- AstraFirmwares: firmware for the arm, lift, head and pedal controllers
- astra_teleop (MIT) and astra_teleop_web: RoboPilot marker detection and PnP pose estimation (Python and WebAssembly)
- LeRobot data collection, training and evaluation