Connecting to sources…

How to build reBot Arm B601 (reBot-DevArm, B601-DM): the whole process

477 steps to build reBot Arm B601 (reBot-DevArm, B601-DM), from buying parts, printing and assembly to software, calibration and training, with the bill of materials, sh…

Seeed official: the pre-assembled B601‑DM is $1,499; unassembled, a motor kit at $829, a structure kit at $169 and a gripper kit at $199; none include the power supply (adapter kit $59) or G-clamps (2026‑10‑31; the page does not say whether tax or shipping is included). BOM reference prices: DM4310 $120 each ×4, DM4340P $175 each ×3, CAN‑USB board $15, printed parts about $50 on average, CNC parts about $250 on average; the README gives no total

Bill of materials · 2.3 Bill of Materials (BOM)​

PartQty
reBot Arm B601-RS Robotic Arm · ✅1
Gripper (pre-installed) · ✅1
USB2CAN Serial Bridge · ✅1
48V Power Adapter · ✅1
USB-C / Communication Cable · ✅1
RGB-D Depth Camera (Orbbec Gemini 2 recommended) · ✅1
Camera Connector / Mounting Bracket · ✅1
Ubuntu 22.04+ Control Host (NVIDIA GPU ≥ 8 GB) · ❌ Self-provided1

Bill of materials · 🖨️ 3D Printed Parts

PartQty
Wiring Harness Clips for Two Sides of Motor 1 · DM_Motor1_wiring_harness_clip.stp · Bambu Lab Black ABS2
Robotic Arm Base Link · 01_BASE_Link.step · Bambu ABS Black1
Upper Arm Left Filler · 01_Upper_Arm_Fuller_L.step · Bambu PLA Black & Green1
Upper Arm Right Filler · 01_Upper_Arm_Fuller_R.step · Bambu PLA Black & Green1
Upper Arm Center Filler · 01_Upper_Arm_Fuller_M.step · Bambu ABS Black1
Upper Arm Horizontal Limit Block · 01_Upper_Arm_Limit.step · Bambu ABS Black1
Arm Handle · 01_Arm_Handle.step · Bambu ABS Black1
Lower Arm Left Filler · 01_Lower_Arm_Filler_L.step · Bambu PLA Black & Green1
Lower Arm Right Filler · 01_Lower_Arm_Filler_R.step · Bambu PLA Black & Green1
Lower Arm Center Filler · 01_Lower_Arm_Filler_M.step · Bambu ABS Black1
Upper Arm Cover · 01_Upper_Arm_Cover.step · Bambu PLA Green1
Lower Arm Cover · 01_Lower_Arm_Cover.step · Bambu PLA Green1
Motor 5 Protection Cover · 01_Motor_Cover.step · Bambu ABS Black1
Gripper Horizontal Limit · 01_Lower_Arm_Limit.step · Bambu PLA Green1
Gripper Slider Support Bracket · 01-Rail-Bracket.step · Bambu PLA Green1
Gripper Finger · 01_Finger.step · Bambu ABS Black2
Motor 5 Cable Restraint · 01_Joint5_Cable Restraint_A.step · Bambu PLA Green1
Motor 6 & 7 Cable Restraint A · 01_Joint6_7_Cable Restraint_A.step · Bambu ABS Black2
Motor 6 & 7 Cable Restraint B · 01_Joint6_7_Cable Restraint_B.step · Bambu ABS Black2
Average 50$

Buy parts

  • Obtain the required power accessories

    Buy the official B601-DM power adapter kit, a power supply, and a power cable separately, or use batteries, a DIY base, or consult the Mean Well solution in the BOM.

  • Choose the body motor kit

    Choose the arm body motor kit, which includes only motors and wire harnesses.

  • Choose the body structure kit

    Choose the arm body structure kit, which includes only mechanical structural components.

  • Choose the complete gripper kit

    Choose the complete gripper kit, including motors, wiring, and the gripper structure.

  • Choose the complete unassembled kit

    Choose the complete kit containing the full arm body and gripper without assembly.

  • Choose the preassembled robot arm

    Choose the preassembled robotic arm, which is fully assembled and ready to use.

  • Select a wrist camera mount

    Consult the complete camera mounts and data-collection resources catalog for models, previews, and downloads. The wrist mounts are shared by the B601-RS and B601-DM.

  • Obtain a compatible Leader Arm

    Use the Star-Arm-102 series center or its GitHub repository to obtain a Leader Arm compatible with the robot.

  • Choose an optional depth camera

    The recommended optional depth cameras are the Orbbec Gemini 2, Orbbec Gemini 336, Orbbec Gemini 335LG, SLAMTEC Aurora S, Intel RealSense D435i, and RealSense D405.

  • Choose the GMSL2 monocular camera

    Select the Sensing SG3S-ISX031C-GMSL2F 3MP GMSL2 Camera as the robot's monocular camera.

  • Choose the wide-angle USB camera

    Select the ET-S231 Megapixel 120° gran angular 1080P USB as the robot's monocular camera.

  • Choose the XIAO microphone array

    Select the reSpeaker Flex XVF3800 Circular-4 with XIAO ESP32S3 as the robot's microphone array.

  • Choose the XMOS microphone array

    Select the reSpeaker XMOS XVF3800 as the robot's microphone array.

  • Choose the Orin Nano edge controller

    Select the reComputer J3011-Orin Nano 8GB as the robot's edge controller.

  • Choose the Jetson AGX Thor controller

    Select the NVIDIA Jetson AGX Thor Developer Kit as the robot's edge controller.

  • Choose the Arm Body Motor Kit

    This kit includes only motors and wiring harnesses for the robotic arm.

  • Choose the Arm Body Structural Kit

    This kit includes only mechanical structural components.

  • Choose the Gripper Complete Kit

    This kit includes motors, wiring harnesses and structural components for the gripper.

  • Choose the Full Kit

    This kit includes the complete set of the robotic arm body and gripper.

  • Choose the Pre-assembled Robotic Arm

    This is a fully assembled finished robotic arm.

  • Download Shared Camera Mount Catalog

    Get the models, previews, and downloads from the shared camera mount catalog. The B601 wrist camera mounts are shared by B601-RS and B601-DM.

  • Buy Hot-Melt Glue

    Purchase additional hot-melt glue for thread locking the screws at each joint.

  • Choose Alternative Locking Hardware

    If using an electric screwdriver or similar tools, choose lock washers or thread-locking screws instead.

  • Choose the power supply option

    The arm does not include a power supply by default. Connect your own battery or purchase a reliable 24V 14.6A MeanWell power supply made in Taiwan; also obtain a locally compliant three-pin plug and a wiring harness with an XT30 female connector.

  • Add the DM Power Adapter Kit

    Purchase the Power Adapter Kit (B601-DM) for the DM model.

  • Add the RS Power Adapter Kit

    Purchase the Power Adapter Kit (B601-RS) for the RS model.

  • Add the DM Power Discharge Module

    Purchase the Power Discharge Module (B601-DM) for circuit protection and an emergency stop on the DM model.

  • Add the RS Bleeder Module

    Purchase the Bleeder Module (B601-RS) for circuit protection and an emergency stop on the RS model.

  • Add the Compatible Soft Gripper

    Purchase the Soft Gripper, which is compatible with both the DM and RS models.

  • Choose a Compatible Wrist Camera Mount

    Choose a UVC32, RealSense D435i, RealSense D405, or Orbbec Gemini 2 mount from the camera mount catalog. The mounts are shared by B601-RS and B601-DM.

  • Select a Compatible Leader Arm

    Use the Star Arm 102 listed for leader-arm compatibility. The document provides a Series Hub product link and a Star-Arm-102 GitHub repository.

  • Choose a DIY Soft Finger Option

    Use the Touch-Sensing Fin-Ray Gripper repository for the available touch-sensing option. A separate Soft Finger is marked “Coming soon.”

  • Choose a reBot Arm Kit

    The document lists the reBot-Arm-B601-RS-Disassembly-Kit and reBot-Arm-B601-RS-Assembly-Version.

  • Purchase HM3 Standard Screws

    Purchase 16 or more HM3-30mm screws from Amazon. The project uses standard hex socket screws.

  • Purchase Hot Melt Glue

    Purchase additional hot melt glue to lock the screw threads at each joint.

  • Choose Alternative Locking Hardware

    If using a power drill or similar tools, lock washers or thread-locking screws may be purchased instead of using hot melt glue.

  • Choose the robot power supply

    The robot arm does not include a power supply by default. Connect your own battery or purchase a reliable 48V 12.5A MeanWell power supply made in Taiwan.

  • Buy the plug and XT30 harness

    Buy a three-pin plug that complies with local standards and a wiring harness with an XT30 female connector.

  • Buy the DM power adapter kit

    Select the official B601-DM power adapter kit for the DM model.

  • Buy the RS power adapter kit

    Select the official B601-RS power adapter kit for the RS model.

Print and make

  • Browse the camera-mount asset catalog

    Open the catalog and identify the CAD or model file for the intended B601 camera mount, data collection setup, or USDZ environment asset.

  • Prefer the latest camera mounts

    For better data collection results, choose the current B601 wrist camera mounts or the V2 aluminum-extrusion camera mount.

  • Check the CAD against the hardware

    Compare the CAD geometry with the camera and robot hardware before fabrication. This README does not provide dimensions, fasteners, print settings, or verified compatibility.

  • Choose a compatible B601 wrist mount

    Use one of the three wrist camera mounts shared by B601-RS and B601-DM. Their STEP files have identical contents to the files from the B601-DM 3D printed parts collection.

  • Download the D405 305 mount

    Download the supplied D405_305_Mount.step CAD file. The source filename identifies this camera mount as D405 / 305.

  • Download the Mount 1 STEP model

    Download mount-1.stp for the tall, tapered camera mount with its stepped upper interface.

  • Inspect the Mount 1 reBot adapter

    For a reBot setup, inspect the plate-shaped reBot adapter in CAD. It has an opening and an offset attachment section and is named “mount 1 rebot insert” upstream.

  • Inspect the Mount 1 SO-ARM adapter

    For a SO-ARM setup, inspect the offset plate-shaped SO-ARM adapter in CAD. It is named “mount 1 soarm insert” upstream.

  • Select and inspect the matching adapter

    Select the adapter corresponding to your setup and inspect the mount interface in CAD. The previews show the mount and each adapter as separate CAD parts.

  • Download the Mount 2 STEP model

    Download mount-2.stp for the tapered camera mount with an upper interface different from design 1.

  • Obtain the Mount 2 SO-ARM adapter

    Obtain the separate SO-ARM adapter supplied for Mount 2. It is identified upstream as the mount 2 soarm insert.

  • Inspect how Mount 2 connects

    Inspect the mount-2 and SO-ARM adapter models together in CAD to determine how they connect. The previews show the mount and its adapter as separate CAD parts.

  • Download the Mount 3 CAD file

    Download mount-3.stp. Camera mount design 3 has a tapered support body and a rectangular raised section at the top.

  • Review the shared Mount 3/4 adapter

    The mount 3 / 4 adapter is the shared insert for designs 3 and 4. It is provided as a separate CAD part.

  • Download the Mount 4 CAD file

    Download mount-4.stp. Camera mount design 4 has a tapered support body with a broad, recessed top interface.

  • Compare Mount 3 and Mount 4

    Inspect the CAD geometry for designs 3 and 4 before choosing one. Mount 4 uses the same mount 3 / 4 adapter as Mount 3.

  • Download the V2 assembly CAD file

    Download data-collection-camera-mount-v2.stp. The file is a complete assembly containing the aluminum extrusion support and camera mounting components.

  • Inspect the V2 assembly before fabrication

    Inspect the assembly in CAD to identify its 3D-printed components and check the camera interface. Unlike V1's 3D-printed support body, V2 uses an aluminum extrusion support body; the supplied file is not a set of ready-to-print STL files.

  • Print the gripper fingers

    Print two 1-CLIP.step parts using black Bambu ABS with a 0.4 mm nozzle, 0.2 mm layer height, and 45% infill. Print each finger resting on its side to improve structural strength.

  • Print the motor wiring clips

    Print two RS_Motor1_wiring_harness_clip.stp parts using black Bambu Lab ABS with a 0.4 mm nozzle, 0.2 mm layer height, and 30% infill. Fit the clips on both sides of motor 1 to reduce wear from harness drag.

  • Obtain the wrist camera mounts

    The B601-RS and B601-DM use the same wrist camera mounts. Models, previews, and downloads are in the shared English camera-mount catalog at ../camera-mounts/README.md.

  • Set layer height and nozzle

    Set the layer height to 0.2 mm and the nozzle to 0.4 mm.

  • Add supports as needed

    Add supports as needed.

  • Choose material by use

    Use ABS at 30–80% infill for high-temperature and load-bearing parts; nylon or carbon-fiber-reinforced materials may also be used. Use PLA at 15% infill for cosmetic parts.

  • Make Motor 4–7 Cable Fixings

    Seeed Studio ships this piece as a single CNC-machined metal component integrated with another piece. For self-made hardware, it can instead be 3D-printed in ABS, with M2 nuts installed at the positions marked by red arrows.

  • Meet machining tolerance and finish requirements

    Use a tolerance of ±0.02 mm GB/T1840-M for critical dimensions and anodizing or sandblasting for the surface finish. Coupling parts should use an H7 fit with tightening or interference fitting.

  • Print the gripper finger

    Print two 1-CLIP.step parts in Bambu ABS Black with a 0.4 mm nozzle, 0.2 mm layer height, and 45% infill. Print from the side of the gripper to improve its structural strength.

  • Set printing parameters and materials

    Use a 0.2 mm layer height and 0.4 mm nozzle, and add supports as needed. Use ABS at 30–80% infill for high-temperature and load-bearing parts; nylon or carbon-fiber reinforced materials may also be used. Use PLA at 15% infill for cosmetic parts.

  • Make Motor Cable Fixing

    CNC machine 4 Motor4-7 Cable Fixing pieces from 1-O-CLIP.step using Aluminum Alloy 5052.

  • Print and Fit Cable Fixing

    Alternatively, 3D-print the part with ABS material and install M2 nuts at the positions marked by red arrows.

  • Apply Machining Specifications

    Use a key dimension tolerance of ±0.02 mm GB/T1840-M. Use anodizing or sandblasting for the surface finish, and H7 or interference fits for mating parts.

  • Print Motor 1 Wiring Harness Clips

    Print two DM_Motor1_wiring_harness_clip.stp parts using Bambu Lab Black ABS. Use a 0.4 mm nozzle, 0.2 mm layer height, and 30% infill.

  • Configure Printing Parameters

    Use a 0.2 mm layer height and 0.4 mm nozzle, and add supports as needed. High-temperature and load-bearing parts use ABS with 30–80% infill, or nylon or carbon-fiber reinforced materials; cosmetic parts use PLA with 15% infill.

  • Machine Parts to Specified Tolerances

    Machine key dimensions to ±0.02 mm GB/T1840-M and use anodizing or sandblasting. Prefer H7 or interference fits for coupling pieces.

  • Print the Motor 1 Harness Clip

    Print 2 `DM_Motor1_wiring_harness_clip.stp` pieces in black Bambu Lab ABS with a 0.4 mm nozzle, 0.2 mm layer height, and 30% infill for both sides of Motor 1.

  • Print the ArUco Checkerboard

    Print a checkerboard from the ArUco 4x4 dictionary with ID = 0 and a side length of 0.10 m (10 cm); the recommended source is aruco100x100.pdf. Precisely measure the printed side length because printers may scale the image, and use the measured value as the --marker-size parameter.

Assemble

  • Tighten screws at the lowest torque

    Set the electric screwdriver to its lowest torque setting to avoid stripping the threads, which would irreversibly damage the screws.

  • Custom-make the XT30 power cables

    Custom-make at least one 320 mm XT30 2+2 cable with right-angle ends on both ends, at least four 200 mm cables with right-angle ends on both ends, and at least one 300 mm cable with a right-angle end on one end.

  • Modify the base with printed parts

    Freely modify the base using the provided 3D-printed parts.

  • Secure with G-clamps for table thickness

    You can also use G-clamps according to the thickness of your table.

  • Connect battery or 48 V supply

    The robotic arm ships without a power supply; connect your own battery or use a reliable Mean Well 48 V, 12.5 A power supply made in Taiwan.

  • Prepare the front housing

    Prepare the printed parts and components needed for the front housing, and check that all pieces are present.

  • Assemble in wiring order

    Install each piece following the wiring order shown in the images.

  • Install the XT60 connector

    Install the XT60 connector and secure it with M3×8 304 stainless steel Phillips countersunk-head screws and M3×2.5 hex nuts.

  • Install the IEC 3 inlet

    Secure the IEC 3 inlet with M3×8 304 stainless steel Phillips countersunk-head screws.

  • Check the internal wiring

    Check the connections inside the front housing according to the wiring diagram.

  • Secure the front housing sides

    Use four M4×6 304 stainless steel Phillips countersunk-head screws to secure the front housing to both sides of the power supply.

  • Install the sliding cover

    Insert the sliding cover from the bottom of the power supply.

  • Secure the sliding cover

    Secure the sliding cover with 2 stainless steel 304 M4x6 countersunk Phillips screws.

  • Prepare the rear housing components

    Prepare the printed pieces and components needed for the rear housing assembly, and check that all accessories are complete.

  • Assemble the rear housing with the power supply

    Assemble the rear housing with the power supply and align its position.

  • Secure the rear housing on both sides

    Secure the rear housing on both sides of the power supply with 4 stainless steel 304 M4x6 countersunk Phillips screws.

  • Complete the power supply assembly

    Complete the power supply assembly and check that all screws are properly tightened.

  • Assemble and Tighten Screws

    Assemble and tighten the standard hex socket screws at each joint, using hot melt glue for thread locking.

  • Use Lowest Electric Screwdriver Torque

    Use the lowest torque setting with an electric screwdriver to avoid stripping threads, which causes irreversible damage.

  • Secure the robot base

    Modify the base freely using the provided 3D-printed parts, and use G-clamps according to the thickness of your desktop.

  • Organize the power assembly sections

    Divide the power supply assembly into front-shell and rear-shell sections.

  • Assemble the power front shell

    Carry out the power supply front-shell assembly from section 1.

  • Prepare front shell parts

    Check the parts and printed components required for front shell assembly and confirm that all parts are present.

  • Assemble by wiring sequence

    Assemble each part according to the wiring sequence and connect strictly according to that sequence.

  • Install the XT60 connector

    Install the XT60 connector and secure it with M3x8 304 countersunk cross-head screws and M3x2.5 hex nuts.

  • Install the 3-in-1 IEC socket

    Install the 3-in-1 IEC socket and secure it with M3x8 304 pan head cross-head screws.

  • Wire the front shell internals

    Complete the internal wiring of the front shell and check the connections against the wiring diagram.

  • Secure front shell to power supply

    Secure the front shell to both sides of the power supply using 4x M4x6 304 countersunk cross-head screws.

  • Install the sliding cover

    Install the sliding cover by pushing it in from the bottom of the power supply.

  • Secure the sliding cover

    Secure the sliding cover with 2x M4x6 304 countersunk cross-head screws.

  • Prepare Rear Shell Components

    Check that all accessories are complete and prepare the parts and printed components required for rear shell assembly.

  • Align Rear Shell and Power Supply

    Align and position the rear shell with the power supply.

  • Secure Rear Shell to Power Supply

    Secure the rear shell to both sides of the power supply with 4x M4x6 304 countersunk cross-head screws.

  • Check Power Supply Assembly

    Check that all screws are tightened to complete the power supply assembly.

  • Modify the base with 3D-printed parts

    Freely modify the base using the provided 3D-printed parts. You can also use G-clamps according to the thickness of your table.

  • Prepare the front housing

    Prepare all parts and printed components needed for the front housing, and check that every part is complete.

  • Assemble in the wiring order

    Consult the wiring-sequence instructions for each part and assemble accordingly; strictly follow the sequence when connecting.

  • Install the XT60 connector

    Install the XT60 connector and secure it with 304 stainless steel countersunk Phillips M3x8 screws and M3x2.5 hex nuts.

  • Install the IEC 3-in-1 base

    Install the IEC 3-in-1 base and secure it with 304 stainless steel pan-head Phillips M3x8 screws.

  • Wire the front housing

    Complete the internal wiring of the front housing and check the connections against the wiring-sequence diagram.

Software

  • Configure motors and zero positions

    Use MotorBridge Studio to write the motor parameters and set each motor's zero position.

  • Install Miniforge on Ubuntu, Jetson, or Raspberry Pi

    Download the Miniforge installer for Ubuntu, Jetson, or Raspberry Pi, then run the installer.

  • Install Miniforge on macOS

    Download the Miniforge installer for macOS, then run the installer.

  • Install Miniforge on Windows

    Open the Miniforge Releases page, find the latest Miniforge3-Windows-x86_64.exe, and download it.

  • Complete the Miniforge Installer

    During installation, press Enter to continue, enter yes to accept the terms, and enter yes when asked whether to initialize Conda.

  • Verify the Conda Installation

    Restart the terminal and verify the installation with conda --version.

  • Initialize Conda in Bash

    Load Miniforge and initialize Bash.

  • Initialize Conda in Zsh

    Load Miniforge and initialize Zsh, the default shell on current macOS versions.

  • Load Conda in Git Bash

    Git Bash users should load Conda first if conda is not found.

  • Download the PCAN firmware

    Download USB2CAN.zip to recover a PCAN device with incorrect firmware.

  • Switch USB2CAN to BOOT

    Switch the USB2CAN device to BOOT mode before running the firmware recovery script.

  • Prepare the firmware recovery files

    Extract USB2CAN.zip and place flash_pcan_ubuntu.sh and pcan_canable_hw.bin in the same directory.

  • Transfer recovery files to Ubuntu

    Copy the two recovery files to the Ubuntu machine with scp, or use a USB flash drive. The files may be placed in ~/Downloads, the current directory, or /tmp.

  • Run the firmware recovery script

    Run the PCAN firmware recovery script, enter your password, and wait for it to finish.

  • Return USB2CAN to 120R

    After the recovery script finishes, switch the USB2CAN back to 120R and reconnect it to USB.

  • Download the PEAK Linux driver

    Download peak-linux-driver-9.2.0.tar.gz for the PEAK Linux driver installation.

  • Remove brltty from Jetson

    On Jetson, remove brltty because it may occupy the USB serial port used by the leader.

  • Install the driver dependencies

    Update the package list and install build-essential, gcc, g++, make, libpopt-dev, can-utils, and ethtool.

  • Verify the kernel headers

    Check that the build directory for the current kernel headers exists.

  • Extract the PEAK driver source

    Extract peak-linux-driver-9.2.0.tar.gz and enter the extracted source directory.

  • Clean previous build artifacts

    Remove artifacts from any previous build of the PEAK Linux driver.

  • Compile the driver in netdev mode

    Compile with make netdev so PCAN-USB is registered as a Linux SocketCAN network interface. Do not use plain make because LeRobot and motorbridge-cli rely on SocketCAN interfaces.

  • Install and load the PEAK driver

    Install the compiled driver, update the module dependency information, and load the pcan kernel module.

  • Enable automatic driver loading

    Add pcan to the modules-load configuration so the driver loads automatically on boot.

  • Persist the PCAN refresh function

    Append a pcan_refresh function to ~/.bashrc. The function runs setup-pcan-if and exports the detected interface as PCAN_IF.

  • Load and run the refresh function

    Load ~/.bashrc to activate pcan_refresh. After rebooting or reconnecting the PCAN-USB adapter, run pcan_refresh and use its exported PCAN_IF value.

  • Install the macOS PCBUSB library

    Download the PCAN-USB macOS library archive, extract it, enter the PCBUSB directory, and run install.sh.

  • Add the bare PCBUSB library symlink

    Create a /usr/local/lib/PCBUSB symlink pointing to libPCBUSB.dylib. motorbridge's native loader requires the bare PCBUSB library name.

  • Configure the macOS library search path

    Create a conda activation script in the rebot environment that exports DYLD_FALLBACK_LIBRARY_PATH with /usr/local/lib. The setting is applied whenever conda activate rebot runs.

  • Install PCBUSB in the user library

    For shared machines without sudo, install PCBUSB under ~/.local/lib and create the bare PCBUSB symlink there. Point the conda activation script at $HOME/.local/lib instead of /usr/local/lib.

  • Verify the Python package and CLI

    Run the package import check and inspect the motorbridge CLI help output.

  • Check the native PCBUSB loader

    Use ctypes to load the native PCBUSB library and confirm that it loads successfully.

  • Download the USB2CAN firmware package

    Download USB2CAN.zip before performing the firmware recovery steps.

  • Switch USB2CAN into boot mode

    Put the USB2CAN device into BOOT mode before transferring and flashing the firmware.

  • Prepare the Mac firmware flashing files

    Extract USB2CAN.zip and place flash_pcan_mac.sh and pcan_canable_hw.bin together in the same directory.

  • Transfer firmware files to the Mac

    Transfer the flashing script and binary to ~/Downloads on the Mac, or copy them there using a USB flash drive.

  • Flash the PCAN firmware

    Run the Mac flashing script with the pcan_canable_hw.bin file, adjusting the paths for your actual location, then enter your password and wait for completion.

  • Return USB2CAN to normal mode

    Switch the USB2CAN back to 120R after the flashing process finishes.

  • Reconnect the USB device

    Unplug and reconnect the USB device after switching it back to 120R.

  • Install the PCAN-USB driver

    Download PEAK-System_Driver-Setup.zip and install the PCAN-USB driver.

Calibrate and test

  • Run the mock test

    Run the three specified test files; the expected result is 17 passed and 1 skipped in approximately 30 seconds.

  • Verify PyTorch and CUDA

    Load the hook in the shell, then import torch and check its version and CUDA availability. The documented expected result is torch: 2.13.0+cu130 and cuda: True.

  • Verify the converted model

    Load models/mobileclip2_b.ts and run it with a zero tensor of shape (2,77). The expected output shape is torch.Size([2, 512]), with the normalized values [1.0, 1.0].

  • Perform Hand-Eye Calibration

    Calibration determines the transformation between pixel coordinates and the robot base coordinate system. data/clip/hand_eye_top.json is a desensitized reference matrix, and your camera must be recalibrated.

  • Connect Orbbec and grant permissions

    Plug the Orbbec camera into USB 3.0 and allow all users to read and write the USB bus devices.

  • Configure robotic-arm CAN bus

    Bring down the can0 interface, set its bitrate to 1000000, and bring the interface back up.

  • List cameras and serial numbers

    Run the device-list command to see the Orbbec device index and serial number.

  • Bind the top camera serial number

    Replace xxxx with the listed camera serial number and bind that serial number to the top camera.

  • Position the top-camera calibration board

    With the top camera fixed outside the robotic arm, place the calibration board as shown in the figure.

  • Run automatic ETH calibration

    Use marker size 0.10 and 30 samples to run preset poses automatically and save the result to a local JSON file.

  • Run manual ETH calibration

    Use marker size 0.10 and 30 samples; press ENTER for each sampling operation and save the result to a local JSON file.

  • Confirm the real calibration result

    Use data/calibration/hand_eye_top.local.json as the real device calibration result; .gitignore automatically ignores this file.

  • Adjust the safe area and camera position

    If IK solving fails during grasping and placement in a large area, adjust the fixed camera position and recalibrate; the camera should be approximately 36cm × 36cm from the arm base.

  • Verify Calibration RMSE

    Do not recalibrate; directly verify using three known base-coordinate points. The expected RMSE is below 10 mm.

  • Adjust the camera and recalibrate

    If IK solving fails during grasping and placement in a large area, adjust the camera's fixed position and recalibrate. Place the camera stably approximately 36cm * 36cm away from the robotic arm base.

  • Verify the API Key Variable

    Run the echo command to check that the first eight characters of the MOONSHOT_API_KEY environment variable are active.

  • Test Run with the Kimi Profile

    Activate the wrc-demo environment and run the demo with --llm kimi, the task "list the objects", --no-view, and --no-serve without modifying demo.yaml.

  • Check the LLM stdout marker

    Check whether stdout prints "[wrc-demo] llm=kimi". A response message from the LLM counts as success, and an empty scene is also acceptable.

  • Set grasp backend and geometry

    In the grasp.* block of configs/demo.yaml, set backend to obb; obb is the default fallback, while graspgenx is learning-based. Set pregrasp_offset_m to 0.08, insertion_depth_m to 0.0, depth_fraction to 0.35, and exempt_radius_m to 0.15.

  • Set grasp motion and empty thresholds

    In the grasp.* block, set exempt_radius_m to 0.15, move_duration_s to 2.5, descend_duration_s to 2.0, release_height_m to 0.05, air_grasp_frac to 0.04, and approach_pitch_rad to 1.2. A gripper opening below air_grasp_frac means an empty grasp, and approach_pitch_rad is the angle between the approach direction and +z, approximately 69°.

  • Adjust the grasp sampling policy

    Increase n_samples for more conservative, accurate, and slower grasping with more vLLM thinking time. Decrease n_samples for more aggressive and faster grasping.

  • Set the camera extrinsics source

    In extrinsics under configs/cameras/orbbec_overhead.yaml, set source to "${repo}/data/calibration/hand_eye_top.json", mode to eye_to_hand, and add hand_eye_compensation_m.

  • Fine-tune hand-eye compensation

    Set x, y, and z under hand_eye_compensation_m; they default to 0.00 for an identity transform with no effect. These values add a manual translation offset to the calibrated T_hand_eye, while T_cam2base converts the grasp pose from camera coordinates to the base coordinate system, so deviations directly affect the grasp landing point.

  • Calibrate follower and leader arms

    Place each arm in the shown zero position with the gripper fully closed, then press ENTER when prompted. Reuse the same --robot.id and --teleop.id in later commands so LeRobot loads the saved calibration; if calibration exists, choose to reuse it or press c to recalibrate.

  • Calibrate a DM follower

    Calibrate a Rebot B601 follower using the dm motor family and /dev/ttyACM0. Calibration runs for the left follower and then the right follower.

  • Calibrate an RS follower

    Calibrate a Rebot B601 follower using the rs motor family and the can0 port. For two RS followers, set both families to rs and use separate native CAN channels for the two ports.

  • Calibrate the dual-arm follower

    Calibrate the left and right arms of a bi Rebot B601 follower with separate device ports. Per-arm calibration files use the _left and _right suffixes.

  • Calibrate the leader

    Calibrate the Rebot 102 leader using /dev/ttyUSB0.

  • Calibrate the dual-arm leader

    Calibrate the left and right arms of a bi Rebot 102 leader using separate USB ports.

  • Identify the OpenCV camera

    Identify the camera before adding it to a recording configuration.

  • Configure the single-arm RS setup

    For an RS setup, set motor_family to rs and change the robot port to the native CAN channel.

  • Remove the camera for motor-only testing

    Remove the camera argument to run a motor-only test.

  • Configure both arms for RS

    For a bimanual RS setup, set both motor families to rs and use separate native CAN channels.

  • Select a mixed DM and RS setup

    In a mixed bimanual setup, select dm for one arm and rs for the other.

  • Use shared joint positions

    Both builds expose the same joint names and public positions in degrees.

  • Keep motor signs internal

    LeRobot applies each motor family’s direction signs to actions and observations, so policies and teleoperators do not need to convert motor signs.

  • Configure DM control modes

    Use MIT control for the arm and force_pos for the gripper by default. gripper_torque_ratio defaults to 0.07, and DM also supports --robot.control_mode=pos_vel.

  • Configure RS control

    Use MIT control and a force-limited impedance gripper because MotorBridge does not provide force_pos for RobStride.

  • Set RS gripper torque caps

    Depending on measured gripper motion, cap commanded torque at 3.5 N·m while moving or 1.0 N·m while holding.

  • Handle RS feedback failure

    If feedback fails, LeRobot attempts to command zero gripper torque and then disables the arm.

Data and training

  • Teleoperate the SO101 robot

    Run the SO101 teleoperation command with the specified follower and leader ports and IDs. Use the same robot ID when teleoperating, recording, and evaluating the same setup.

  • Teleoperate with the Python API

    Create SO101Follower and SO101Leader configurations with their ports and IDs, then connect both devices. In the loop, read an action from the leader and send it to the robot.

  • Connect devices and start teleoperation

    The teleoperate command connects the robot and teleop device and starts teleoperation.

  • Record and Upload Five Episodes

    Adapt the example to the robot, then record 5 episodes of the “Grab the black cube” task and upload the dataset to ${HF_USER}/record-test with streaming encoding and two encoder threads.

  • Upload the recorded dataset

    Upload the timestamped record-test dataset to the Hugging Face Hub as a dataset.

  • Store recordings as LeRobotDataset

    lerobot-record stores recording data on disk in the LeRobotDataset format. Use --dataset.push_to_hub=False to disable uploading.

  • Keep automatic recording checkpoints

    lerobot-record automatically creates checkpoints while recording.

  • Resume an existing recording dataset

    After an issue or to add episodes, rerun the same command with --resume=true and the full timestamped --dataset.repo_id. Set --dataset.num_episodes to the number of additional episodes and set --dataset.root="local_path" to the required local save path.

  • Start a new timestamped dataset

    Rerunning without --resume=true starts a new dataset with a new timestamp. If --dataset.no_stamp=true is used, delete the existing dataset directory first.

  • Configure recording episode timing

    Set --dataset.episode_time_s=60 for each episode, --dataset.reset_time_s=60 for resetting after each episode, and --dataset.num_episodes=50 for the total episode count.

  • Control recording with the keyboard

    Press Right Arrow or n to stop the current episode or reset early and move to the next; press Left Arrow or r to cancel and re-record it. Press Escape or q to stop the session, encode videos, and upload the dataset.

  • Use recording shortcuts across sessions

    Recording control shortcuts work on X11, Wayland, and headless or SSH sessions. If a global keyboard backend is unavailable, launch lerobot-record from a focused interactive terminal; no $DISPLAY setup is required.

  • Run the policy training command

    Run the lerobot-train script with the recorded dataset, ACT policy, output directory, job name, CUDA device, Trackio enabled, and policy repository ID. Use your dataset’s full name, including the timestamp, for --dataset.repo_id.

  • Configure the ACT policy

    Select --policy.type=act to load configuration_act.py. The policy automatically adapts to the numbers of motor states, motor actions, and cameras saved in the dataset.

  • Choose the training device

    Use --policy.device=cuda when training on an Nvidia GPU. Use --policy.device=mps instead when training on Apple silicon.

  • Visualize training with Trackio

    Enable Trackio with --trackio.enable=true, then run trackio show --project lerobot to open its dashboard. To sync the run to a Hugging Face Space, pass --trackio.space_id=<user>/<space>; Trackio is optional.

  • Set the training duration

    If --steps is omitted, training runs for the default 100,000 steps. Imitation learning typically converges within 5–10 epochs, and the Compute & Hardware Guide explains how to convert epochs into a --steps value for the dataset size and batch size.

  • Locate the training checkpoints

    Allow several hours for training. The checkpoints are stored in outputs/train/act_so101_test/checkpoints.

  • Resume from a local checkpoint

    Use the checkpoint’s train_config.json with --resume=true to resume from the last checkpoint of the act_so101_test policy.

  • Resume from a Hub repository

    Set --config_path to a Hub repository ID and pass --resume=true to download its latest checkpoint and continue training. The run restores the optimizer, scheduler, step counter, and data order.

  • Disable model publication

    Add --policy.push_to_hub=false if you do not want to push the trained model to the Hub after training.

  • Set model repository metadata

    Use --policy.private=true to make the model repository private. You can also set --policy.tags=\[so101,tutorial\] and --policy.license=mit.

  • Test teleoperation safely

    Start with small movements and verify every joint direction before using the full workspace.

  • Teleoperate the DM follower

    Teleoperate a Rebot B601 follower with the dm motor family using the Rebot 102 leader on /dev/ttyUSB0.

  • Teleoperate the RS follower

    Teleoperate a Rebot B601 follower with the rs motor family using the can0 port and the Rebot 102 leader on /dev/ttyUSB0.

  • Teleoperate the dual-arm robot

    Teleoperate the left and right arms of the bi Rebot B601 follower with the corresponding arms of the bi Rebot 102 leader.

  • Test teleoperation first

    Test the teleoperation setup before recording a dataset.

  • Record five single-arm episodes

    Record five local DM episodes with one 640×480 OpenCV camera at 30 fps, using a 30-second episode time, a 10-second reset time, and local dataset storage.

  • Record bimanual DM camera episodes

    Record two bimanual DM episodes with a shared top camera and one wrist camera per arm. The camera keys are top, left_wrist, and right_wrist; the episode time is 20 seconds, the reset time is 10 seconds, and the dataset is stored locally.

  • Continue with imitation learning

    Use the linked Imitation Learning for Robots guide to upload, replay, train, and evaluate a policy.

Use it

  • Start the Real Robot Demo

    Run start_all.sh with the --repl and --real arguments to start the project.

  • Open the live control dashboard

    Open the [wrc-demo] LIVESTREAM dashboard link printed in the terminal, then control the robotic arm through dialogue.

  • Send a dialogue task command

    Enter a task after the terminal's task> prompt, such as go to home or Wave and say hello; the terminal reports success, path, steps, and summary.

  • Control the Robot with Reflex

    Choose the reflex path to use pre-loaded fixed text without running the LLM for pick-and-place, opening the gripper, listing recognized objects, and returning home.

  • Call LLM Perception and Grasp Skills

    Choose the llm path so a connected cloud model or locally deployed model can understand text and call the corresponding skills; use these skills to observe, localize, and grasp.

  • Call LLM Placement and Gripper Skills

    Use these LLM skills to place objects at coordinates or on objects and to open or close the gripper.

  • Launch the browser-based MuJoCo simulation

    Open the interactive demo without installation, switch between standard and AGV configurations, control the joints and TCP, view the global and D405 wrist cameras, and run the automatic storage and stacking demonstrations. Chrome or Edge is recommended, and the first model load may take a moment.

  • Launch the Browser-Based Robot Simulation

    Launch the reBot Arm Interactive Demo to control the reBot Arm B601-RS MuJoCo digital twin in Chrome or Edge, switch between standard arm and AGV configurations, control joints and TCP, view the overhead and D405 wrist cameras, and run the automated put-away and stacking demos.

Common problems

  • Non-commercial licensing contradicts the project's open-source claim. #17
  • CAD and BOM assets are missing, outdated, or mislabeled. #1 #73 #104
  • 48V motor substitution compatibility and differences are unclear. #19
  • Retail XT30 connectors cannot pass through the forearm filler opening. #49
  • Joint 2 accepts commands but produces no torque. #90
  • Tutorial screws are too long and may damage the motor housing. #72
  • Printed mounting parts create unclear or insufficient motor and camera clearances. #25 #41
  • Elbow lacks cable restraint while wiring moves widely during folding. #29

Parts

  • Joint motors: Damiao DM‑J4340P ×3 and DM‑J4310 ×4 (store spec table), 4340P at the base and 4310 at the wrist (LeRobot docs)
  • Damiao USB‑CAN driver board, XT30 2+2 power separation board, XT30 2+2 harnesses (package list and BOM)
  • 5052 aluminium CNC and sheet-metal links (the BOM says some can be printed in high-infill ABS instead); ABS load-bearing and PLA cosmetic prints
  • Bearings 6707ZZ, 6803ZZ ×3 and AXK5578; the gripper uses an MGN9 170 mm rail with two blocks, a module-1 16-tooth gear and racks
  • 24V power: the store lists DC 24V 10A, the wiki asks for a 24V 15A supply with XT30 output, and the BOM suggests a Mean Well LRS‑350‑24 (24V 14.6A, $27.35)

Tools

  • Hex key set (included); set an electric screwdriver to 3–6 kgf·cm to avoid stripping threads (wiki)
  • Two G-clamps of 3 inches or more to fix the arm to a desk edge
  • Self-build: a 3D printer (0.4 mm nozzle, 0.2 mm layers) plus CNC and sheet-metal machining; the BOM asks for hot-melt glue to lock joint screws

Skills

  • Ubuntu and Python 3.12 (a Miniforge environment)
  • CAN motor setup: writing motor IDs and zeroing (DMTool or MotorBridge)
  • ROS 2 Humble with MoveIt2, Pinocchio kinematics and gravity compensation
  • LeRobot teleoperation, data collection and imitation learning

Software

  • MotorBridge (MIT, a Rust core with Python/C++ bindings, v0.5.6 released 2026‑09‑20) and its web control UI
  • LeRobot: rebot_b601_follower and rebot_102_leader, shared by DM and RS
  • ROS2 Humble and MoveIt2 integration, Isaac Sim USD models, an in-browser MuJoCo digital twin
  • reBotArm_control_py (Pinocchio kinematics and gravity compensation, no licence declared)

Documents