Connecting to sources…

How to build AlohaMini (AlohaMini2 / AlohaMini 1): the whole process

143 steps to build AlohaMini (AlohaMini2 / AlohaMini 1), from buying parts, printing and assembly to software, calibration and training, with the bill of materials, shop…

The creators' estimates: the README lists the main parts at about $950 (leader arms excluded, frame self-printed from about 6 kg of filament); BOM.md totals the full set (base, two follower arms, two leader arms, fasteners) at CN¥7,548 / about $1,097 self-printed, excluding about 5 kg of filament and common tools such as a table clamp, soldering iron and screwdrivers. The first generation was about $600 self-printed

Bill of materials · Bill of Materials (BOM)

PartQtyUS
Servo — standard11USD 16
Servo — high-torque7USD 50
Bus servo controllers2USD 5
Compute1USD 93
Cameras5USD 17
Omni wheels3USD 40
Battery 12V2USD 16
Frame—

Bill of materials · Mobile base

PartQtyUSCN
Servo motor4USD 13.89CNY 110
Omni wheel3USD 47CNY 135
USB camera3CNY 125
(optional) Bearing3CNY 6
Bearing8CNY 3
M2×12 Phillips screw12
M3×12 hex socket screw36
M3×18 hex socket screw12
M3×30 hex socket screw8
M3 hex nut8
M3x5x4 heat-set insert36CNY 5
M4×12 hex socket screw20
M4x6x5 heat-set insert12CNY 4
Adhesive1CNY 12
Servo extension cable2CNY 3
Battery2USD 43CNY 130
USB Type-C cable1USD 10CNY 20
Waveshare Bus Servo Controller1USD 13CNY 27
3D-printed parts~4 kg filament

Buy parts

  • Prepare the mobile base and follower arms

    Prepare a mobile base and two follower arms; the follower arms reuse the SO-ARM100 design.

  • Prepare the host teleoperation equipment

    The host side uses a PC workstation and leader arms; VR controllers or other devices can replace the leader arms. Beginners are recommended to start with leader-arm teleoperation.

  • Add standalone-mode components

    To operate the base untethered over Wi‑Fi, add the standalone-mode components listed in the table.

  • Purchase components and print parts

    Purchase the components and 3D-print the parts using the BOM and 3D-print documentation.

  • Review BOM and Source Parts

    Review the component list and source the listed parts.

Print and make

  • Print the bearing covers

    Print three OB_Chassis_Bearing_Cover parts.

  • Print the servo mounts

    Print three OB_Chassis_Servo_Mount parts.

  • Print the chassis side panels

    Print three OB_Chassis_Side_Panel parts.

  • Print the wheel axle connectors

    Print three OB_Chassis_Wheel_Axle_Connector parts.

  • Print the wheel guards

    Print three OB_Chassis_Wheel_Guard parts.

  • Print the top camera back covers

    Print two OB_Top_Camera_Back_Cover parts.

  • Print the shaft sleeves

    Print three OB_Chassis_Shaft_Sleeve_12_24 parts.

  • Print the chassis dowel pins

    Print three O_Chassis_Dowel_Pin_12_37 parts.

  • Print all other files

    Print each of the other listed files once, including the lift mechanism.

  • Print the remaining parts on a standard printer

    All parts except the chassis, including the lift mechanism, can be printed on a standard 3D printer.

  • Select a large-enough chassis printer

    The chassis requires a build volume of at least 385 × 345 × 64 mm; choose a machine around 400 × 360 × 100 mm or larger.

  • Outsource the chassis printing if needed

    Because of its size, the chassis may need to be printed by an external service.

  • Print follower D files

    Print all “D_*.stl” files, x2 each.

  • Print follower F files

    Print all “F_*.stl” files, x2 each.

  • Follow the printing instructions

    Refer to the linked SO-ARM100 project README for detailed printing instructions.

  • Print leader D files

    Print all “D_*.stl” files, x2 each.

  • Print leader L files

    Print all “L_*.stl” files, x2 each.

  • Follow the printing instructions

    Refer to the linked SO-ARM100 project README for detailed printing instructions.

  • Print the hardware STL files

    The `/hardware/` directory contains printable STL files.

  • Print the Lift Tower Parts

    Prepare the lift tower parts in this order: O_POST4_Connector_Base.stl, O_Main_Assembly_Post4.stl, OB_Main_Assembly_Post3.stl, OB_Main_Assembly_Post2.stl, OB_Main_Assembly_Post1.stl.

  • Print All Structural Parts

    Print all structural parts with Bambu P2S, using approximately 6 kg of filament.

Assemble

  • Connect Servo Cables

    Connect servos 8, 9, and 10 with the included 20cm servo cables, and connect servos 10 and 11 with a 90cm servo cable.

  • Install Servo Bracket Inserts

    Install M3 heat-set inserts into the servo brackets using a soldering iron.

  • Secure the Servos

    Secure the servos using the small screws included with the servos.

  • Install Wheel Axle Connectors

    Install the wheel axle connectors. If the connector does not fit, sand it down for a better fit. After installation, tighten it with screws or use epoxy resin if it is loose; no additional treatment is needed if it is tight enough.

  • Mount Servos to Chassis

    Mount the servos to the chassis plate, following the servo order shown in the image.

  • Secure Servos with M3x14 Screws

    Secure the servos to the chassis plate using M3x14 screws.

  • Attach Omni Wheels

    Attach the omni wheels to the servo connector using M3x18 screws.

  • Install Chassis Bearings

    Optionally install the chassis bearings. Insert the 12x18x4 bearings into the dowel pin and shaft sleeves, install M4 heat-set inserts into the Chassis_Bearing_Cover, and fasten it with M4x12 screws.

  • Install Side Plate Inserts

    Install M3 heat-set inserts into the side plates.

  • Assemble Main Posts

    Assemble the main posts like building blocks; there are four in total. Use epoxy resin or double-sided tape to bond the parts together.

  • Install the Lift Axis

    Install the lift axis and prepare the materials according to the BOM list.

  • Secure the Gear

    Secure the gear using the screws included with the servo.

  • Insert Gear into Servo Mount

    Insert the gear into the Axis_Servo_Mount.

  • Secure Axis Bracket

    Secure the Axis_Bracket to the servo using the included M3x6 screws from the servo.

  • Install the T-Bracket

    Install the T-bracket.

  • Secure with Epoxy Resin

    Secure it with epoxy resin.

  • Slide Lift Axis into Bracket

    Slide the lift axis into the T-bracket.

  • Install Top and Back Cameras

    Install the Top and Back cameras, removing the two screws from the camera back cover.

  • Reinstall Camera Back Cover

    Reinstall the back cover using M2x12 screws, sandwiching the printed part between the cover and camera.

  • Route Camera Cable

    Route the camera cable through the internal channel of the printed part.

  • Secure Display

    Secure the display to the printed part using the included M3 servo screws.

  • Insert Display into Main Post

    Slide the display into the rear slot of the main post.

  • Install Front Camera

    Install the Front camera using the same method as the Top camera and slide it into the slot. File down any burrs on the printed part for a smooth fit.

  • Route Cables Through Main Post

    Route the USB Type-C data cable and DC power cable through the hole on the rear side of the main post.

  • Complete Mobile Base Assembly

    The Mobile Base assembly is complete.

  • Assemble Leader and Follower Arms

    Refer to the SO-101 Assembly Guide to assemble the Leader arms and Follower arms.

  • Secure Robotic Arm

    Secure the robotic arm to both sides of the T-bracket using four M3x30 hex screws and four M3 nuts.

  • Connect Left Arm Servo Cable

    Connect the 90cm servo cable from servo #11 to the other port on the Waveshare controller board of the left arm.

  • Attach Step-Down Converter

    Attach the 12V to 5V step-down converter to the base and connect it to the Raspberry Pi.

  • Connect Lithium Battery Power

    Connect the 12V lithium battery to the step-down converter to provide power.

  • Connect DC Splitter Cable

    Connect the male plug of the 1-to-2 DC splitter cable to the female connectors of the two DC extension cables.

  • Connect Second Lithium Battery

    Connect the second 12V lithium battery to the female connector of the 1-to-2 DC splitter cable.

  • Complete Final Assembly

    The Follower arms and Mobile Base assembly is fully complete.

  • Prepare the follower and leader arms

    Prepare the follower and leader arms using the AM-ARM200 Assembly Guide before assembling the mobile base.

  • Remove chassis print supports

    Remove all print supports from the chassis parts, especially the wheel pockets, cable channels, and dowel-pin slots.

  • Apply epoxy to mating surfaces

    Apply epoxy to the mating surfaces of the chassis parts.

  • Install the chassis locking wedge

    Insert `OB_Chassis_Locking_Wedge.stl` into the locking-pin slot. Install the three tapered chassis locking pins in the correct direction so they wedge the tower base tightly after assembly.

  • Join the chassis frame

    Apply epoxy to the `OB_Chassis_Frame_Joiner.stl` joiner, then press the chassis parts together until they are fully seated.

  • Install the three wheel servos

    Install the three wheel servos in the chassis and place them in the shown orientation after assigning their IDs.

  • Connect and secure wheel servos

    Connect servo 8 to 9, servo 9 to 10, and servo 10 to 11. Because servos 10 and 11 are far apart, use at least a 90 cm 3-pin servo cable, with 140 cm recommended, and fasten the servos with their supplied screws.

Software

  • Add AlohaMini to Existing LeRobot

    Copy the files from `alohamini/software` into the existing LeRobot workspace, then follow the configuration and command-line examples in the `lerobot_alohamini` repository.

  • Clone the Integrated LeRobot and AlohaMini Repository

    Beginners can clone the integrated `lerobot_alohamini` repository directly. It bundles LeRobot and AlohaMini together, so no manual copying or path configuration is required.

  • Assign Servo IDs
  • Set up software and teleoperation

    Install the software, connect the robot, and control it using the software guide.

  • Get lerobot_alohamini

    Clone the lerobot_alohamini repository, install its dependencies, and run commands from the repository root.

  • Install Software and Connect Control

    Install the software, connect the robot, and control it through teleoperation according to the software guide.

  • Clone and install lerobot_alohamini

    Clone and install the `lerobot_alohamini` repository.

  • Configure the separate checkout

    Set PYTHONPATH on both the PC and Pi, then confirm that the tested checkout is imported instead of another editable installation.

  • Apply Pi0.5 data transforms

    Apply horizontal and vertical image flips, then align robot actions to the Pi0.5 action space using the configured robot_dof. Create model transforms from the model config and default prompt.

  • Validate the 18-value delta mask

    delta_action_mask must contain exactly 18 values. When delta actions are enabled, use the mask to transform inputs with DeltaActions and outputs with AbsoluteActions.

Calibrate and test

  • Find device ports one at a time

    Plug in one device at a time, then identify its port.

  • Configure follower arm ports

    On the Raspberry Pi, edit src/lerobot/robots/alohamini/config_alohamini.py and set left_port to the left-bus port and right_port to the right-bus port.

  • Set stable leader arm aliases

    The PC scripts use /dev/am_arm_leader_left and /dev/am_arm_leader_right as the leader-arm aliases; set up the corresponding udev aliases as described in the persistent-arm-ports section of commands.md.

  • Keep script device paths consistent

    If different device paths are used, keep them consistent in calibrate_bi.py, teleoperate_bi.py, and record_bi.py.

  • Check preconfigured complete-kit ports

    If you purchased a complete AlohaMini, the follower-arm ports on the Raspberry Pi are already fixed by udev rules and require no action.

  • Test evaluation termination

    Verify that a Host restart or another command owner ends evaluation. Heartbeat commands do not bypass the Host watchdog.

  • Start Host teleoperation and evaluation

    Start the Host, teleoperation, and evaluation with the existing environment, robot model, and calibration.

  • Run robot recovery tests in order

    Use supported arms and a clear workspace; check ordinary teleoperation first, then test slow inference, normal stop, and reconnect. Validate hardware timing and recovery behavior on the robot because mocked tests do not establish them.

  • Test missing-image warnings

    Camera warnings follow the Host's enabled-camera list and appear once per missing-image episode.

  • Check camera warning conditions

    State-only responses do not trigger missing-image warnings. Older Hosts without camera metadata use the client configuration, and cached or placeholder images do not gain fresh capture timestamps.

  • Assign servo IDs before installation

    Assign the servo IDs before installation and configure one servo at a time to avoid ID conflicts.

  • Configure a servo ID

    Run the example from the repository root to change ID 1 to ID 8 through `/dev/ttyACM0`.

  • Use the FD Debug Tool

    Use the Feetech FD Debug Tool through the Waveshare bus servo controller with baud rate `1000000`. Scan the servo, write the target ID, then disconnect it before configuring the next servo.

  • Run the Chassis Test

    With the chassis assembled, run the debug command from the `lerobot_alohamini` repository to drive the base directly for a first test.

  • Test Wheel Driving

    Run the W/S/A/D drive test on /dev/ttyACM0.

  • Test the Lift Axis

    Run the U/J lift test on /dev/ttyACM0.

  • Configure the robot and ports

    Configure the robot and ports as described in `lerobot_alohamini`.

Data and training

  • Test blocking inference state refresh

    Blocking inference refreshes Host state before execution. A watchdog release alone does not reset inference, and new commands use the current control epoch.

  • Test joint holds and resumption

    Active joint holds pause evaluation; after release, queued predictions are cleared and evaluation resumes without an Enter prompt.

  • Test joint-protection prediction cleanup

    Resolved joint-protection events also clear old predictions.

  • Check pauses and evaluation frames

    Pauses count toward the episode's wall-clock duration. Cached observations are not saved as new evaluation frames.

  • Confirm Recording Prerequisites

    Before recording, confirm that the Pi host is running as described in §5. Replace `<Pi_IP>` with the Raspberry Pi's IP address and ensure `--robot.robot_model` matches the model running on the Pi host.

  • Set Arm and Dataset Options

    Set `--teleop.arm_profile` to the leader arm hardware configuration, not the follower robot. Recording prints the local dataset path and uploads to Hugging Face Hub by default; add `--dataset.push_to_hub=false` to keep the dataset local only or `--dataset.root /path/to/dataset` to store or resume it from a specific local directory.

  • Create a New AlohaMini 1 Dataset

    Run `record_bi.py` to create the `$HF_USER/so100_bi_test` dataset with one 45-second `pickup1` episode at 30 fps and an 8-second reset time.

  • Resume an Existing AlohaMini 1 Dataset

    Run `record_bi.py` with the same dataset configuration as the new-dataset command and add `--resume` to resume an existing dataset.

  • Create a new dataset

    Run record_bi.py to create the $HF_USER/am2_bi_test dataset, recording one 30 FPS, 45-second task episode named pickup1 with the AM-ARM leader 6-DoF configuration.

  • Resume an existing dataset

    Run record_bi.py with the same recording parameters and add --resume to continue adding data to the existing dataset.

  • Replay the dataset

    Run replay_bi.py to replay episode 0 of the $HF_USER/am2_bi_test dataset and connect to the alohamini2 robot on the Pi. If the dataset is not under $HF_LEROBOT_HOME/$HF_USER/am2_bi_test, add --dataset.root /path/to/am2_bi_test.

  • Visualize the dataset

    Run lerobot-dataset-viz to display episode 0 of the $HF_USER/am2_bi_test dataset with compressed images enabled.

  • Train the ACT policy locally

    Run lerobot-train to train an act policy on the $HF_USER/am2_bi_test dataset with the CUDA device, output to outputs/train/act_your_dataset1, wandb disabled, and the pyav video backend.

  • Use a cloud GPU

    Use any cloud GPU provider such as AutoDL, Lambda Labs, or Vast.ai. Set up the environment the same way as local, run the same training command, then copy the checkpoint back for evaluation.

  • Start Pi and select model

    Make sure the Pi host is running, then run inference from the PC. `--robot.robot_model` must match the Pi model: `alohamini1` is SO-ARM 5-DoF with 16-dim state, while `alohamini2` or `alohamini2pro` is AM-ARM 6-DoF with 18-dim state.

  • Run ACT synchronous evaluation

    Use `evaluate_bi.py` to evaluate ACT for 3 episodes of 45 seconds at 20 fps. An interpolation multiplier of 3 runs the control loop at 60 Hz after the first action and linearly interpolates between policy actions.

  • Run SmolVLA RTC evaluation

    Use RTC to run policy inference asynchronously and refresh part of the action chunk while the robot executes queued actions. Set the execution horizon to 10, maximum guidance weight to 10.0, queue threshold to 30, and interpolation multiplier to 1.

  • Check evaluation output settings

    Both examples load a local checkpoint and save the evaluation dataset locally without uploading it. Before running, set `HF_USER` or replace it with your username, ensure `--policy.path` exists with the complete pretrained model, and use a new `--dataset.repo_id` whose local output directory does not already exist.

  • Run teleoperation, data collection, and evaluation

    Run teleoperation, data collection, and evaluation from the `lerobot_alohamini` repository.

  • Configure AlohaMini2Pro training data

    Create TrainConfig named alohamini2pro with Pi0Config(pi05=True, action_horizon=10). Configure LeRobotAlohaMiniDataConfig to load /path/to/your/dataset_root, use task prompts and default_prompt, and set robot_dof and dataset_action_dim to 18.

  • Map AlohaMini observations and actions

    Map cam_high, cam_left_wrist, and cam_right_wrist to the chest, wrist_left, and wrist_right images; map state to observation.state and actions to action. Add the prompt parameter, otherwise model training will not include the task description.

  • Set native 18D delta actions

    Enable use_delta_actions and configure six delta-action joints for each arm, while keeping the grippers, base, and lift axes absolute.

  • Set dataset assets and checkpoint weights

    Set the dataset path with assets_dir and asset_id; together they form a path equivalent to repo_id. Load weights from gs://openpi-assets/checkpoints/pi05_base/params with CheckpointWeightLoader.

  • Configure pi0.5 fine-tuning

    Set 50,000 training steps, batch size 4, two workers, and disable wandb.

  • Select fine-tuning weights

    Use the pi0.5_base weights for fine-tuning and modify the weight path as needed.

  • Compute normalization statistics

    Before fine-tuning, run scripts/compute_norm_stats.py to compute data normalization statistics according to openpi requirements.

  • Start remote policy server

    Start the HTTP policy server on port 8000 with the pi05_test2 configuration, specified weight path, and a default prompt.

  • Start the AlohaMini host

    Start the AlohaMini lekiwi_host with the so-arm-5dof arm profile.

  • Evaluate a 16-DoF robot

    Run the local evaluate_bi.py receiver in remote_http mode, connect to the local policy server, and set the robot to 16 DoF.

  • Evaluate an 18-DoF robot

    For an 18-DoF robot, run evaluate_bi.py in remote_http mode, connect to the local policy server, and set the robot to 18 DoF.

Use it

  • Control the base from your PC

    Run wheels.py and axis.py with the /dev/ttyACM0 port. Use W/S/A/D to drive the base and U/J to raise or lower the lift, without installing a single-board computer on the robot.

Common problems

  • Connector STL mesh is improperly exported for printing preparation #1
  • Raspberry Pi cannot open the video device with two cameras #10
  • Virtual-machine teleoperation fails to render R32Float textures #8
  • STS3215 position default may prevent velocity commands #6

Parts

  • 11 Feetech STS3215 12V (1/345): the three wheels plus the wrist joints and grippers of both follower arms
  • 7 Feetech STS3095 12V (95 kg·cm): one for the lift, three for the shoulder and elbow joints of each follower arm
  • Leader arms: 14 STS3215 7.4V (1/147), two Waveshare driver boards, a 5V supply
  • Raspberry Pi 5 (2 GB), 32 GB microSD, a 12V→5V 5A buck converter; two 12V 11,200 mAh Li-ion packs (one for the arms, one through the buck converter for the Pi)
  • Five H65V1 720p USB cameras (2.4 mm): front, back, chest and both wrists
  • Three 127 mm omni wheels, Waveshare servo boards, eight 4×13×5 mm lift-track bearings and eight 12×18×4 mm bearings, a 20×40 extrusion and Φ12 steel pins (printed substitutes work but are much weaker)
  • 3D prints in PLA, PETG or ABS, sized for a Bambu P2S; six wall loops recommended for load-bearing parts

Tools

  • 3D printer (Bambu P2S class; the first generation needs a bed of 380 mm or more)
  • Epoxy (Loctite E‑120HP) to bond the base and lift tower
  • Table clamp, soldering iron and screwdriver set (the BOM leaves common tools out)
  • A PC as the client for the leader arms; training needs a CUDA GPU, or a cloud GPU

Skills

  • Servo ID setup (the lerobot_alohamini script or Feetech's FD debug tool at 1,000,000 baud)
  • Linux, SSH, udev port aliases and LAN setup
  • LeRobot calibration, teleoperation, recording and training (ACT, SmolVLA); advanced: π0.5 fine-tuning with OpenPI

Software

  • lerobot_alohamini v0.6.0 (2026‑07‑12, merged with LeRobot 0.6): Pi host plus PC client for calibration, teleoperation, recording, training and evaluation
  • 50 Hz host control with a watchdog and current-based stall protection
  • AlohaMini2 / 2 Pro URDFs; a first-generation ROS package (RViz and Gazebo)
  • examples/pi0.5_openpi: π0.5 fine-tuning and deployment with OpenPI

Documents