Open Source Robotics

A curated collection of high-quality open source robotics projects, tools, and software to propel the robotics community forward.

Assembly guide for Berkeley Humanoid Lite

Open-source sub-$5K humanoid robot with 3D-printed gearboxes and full sim-to-real pipeline

License

MIT

Assembly guide

1. Materials and Parts (BOM)

Gather all required components including motors, bearings, ESCs, encoders, electronics, and 3D printing filament. Reference the official BOM spreadsheet for exact quantities and sourcing links.

1.1 Source actuator components

Order all parts for both actuator types: M6C12 (high-torque, qty 10) and 5010 (medium-torque, qty 12).

  1. Open the official BOM spreadsheet and review its three tabs: M6C12 Actuator, 5010 Actuator and Humanoid. The two actuator tabs list the parts for one actuator. The Humanoid tab lists how many of each actuator the whole robot needs.
  2. Order 10 MAD Components M6C12 150KV motors, one for each M6C12 actuator. The M6C12 Actuator tab lists one 'MAD Components M6C12 150KV' per actuator. The Humanoid tab lists 8 M6C12 actuators for the legs and 2 for the arms. The paper and the release notes call this the 6512 actuator.
  3. Order 12 MAD Components 5010 110KV motors, one for each 5010 actuator. The 5010 Actuator tab lists 'MAD Components 5010 110KV'. The Humanoid tab lists 4 5010 actuators for the legs and 8 for the arms. Check the KV of the motor you buy: the firmware also carries profiles for other 5010 motors (310KV and 370KV in the Flashing page, and a 200KV profile added to the firmware on 2025-09-07), but the BOM motor is 110KV.
  4. Order B-G431B-ESC1 motor controllers (qty 22 total) from Digikey or equivalent.
  5. Order AS5600 magnetic encoders (qty 22) with radially-magnetized magnets.
  6. Order the bearings listed on each actuator tab. M6C12 actuator, per actuator: 13 MR106-2RS, 2 6701-2RS and 2 6811ZZ. 5010 actuator, per actuator: 13 MR106-2RS, 2 6701-2RS and 2 6809ZZ. The Humanoid tab also lists 6 6803-2RS, described as 'Bearing between the linkage on the pitch actuators on legs'. The release log says the 6803 bearing and an M2 insert were missing from the Humanoid tab until 2025-05-29, and that the MR106-2RS and 6701-2RS descriptions were swapped until 2025-05-23, so check the current sheet if you bought from an older copy.
  7. Order M3 screws, M2/M3 threaded inserts, and M4 hex standoffs per BOM quantities.

1.2 Source electronics and structural components

Order the main electronics (computer, IMU, CAN adapters) and structural materials.

  1. Order an Intel N95 Mini PC (or equivalent) for onboard computing.
  2. Order a BNO085 9-axis IMU or the IM10A IMU module from Hiwonder. The docs strongly recommend the IM10A because it connects directly by USB. The original BNO085 version used an Arduino Nano to connect the IMU to the computer, and the BOM does not list an Arduino Nano.
  3. Order 4x USB-CAN adapters (1 Mbps) and 2x USB hubs.
  4. Order a 6S LiPo battery. The BOM lists 'LiPo battery 6S', and the paper gives the robot's battery as 6S 4000 mAh.
  5. The Humanoid tab also lists these parts for the whole robot: 24V to 12V regulator (1), 12V to 5V regulator (1), Voltage monitor (1), Current monitor (1), Circuit breaker (1), Aluminum extrusion 250 mm (2), 200 mm (4), 150 mm (2) and 100 mm (3), Aluminum inner bracket (24), Servo motor claw (2). It also lists a 3D print filament row of 1 each for the legs and the arms.
  6. LiPo safety, from the author's lab notes (not part of the build guide): never leave a charging battery unattended. Check that the cell type, cell count and maximum charge current set on the charger match the label on the battery. The maximum charging current is the capacity divided by one hour, for example 2200 mAh gives 2.2 A. Never discharge a LiPo below 3 V under load. If the battery is swelling, stop immediately and dispose of it.
  7. Order PLA filament — Bambu Lab PLA Basic or Hatchbox PLA recommended.
  8. Order wiring supplies: 14 AWG power cables, 30 AWG signal cables, XT60 and XT30 connectors, WAGO connectors.

2. Preparing the Tools

Set up your workspace with all required tools before starting assembly.

2.1 Prepare 3D printer and workspace

Ensure your 3D printer meets requirements and workspace is ready for assembly.

  1. Verify your 3D printer has a build volume of at least 200 x 200 x 200 mm. The Bambu Lab X1C Carbon is recommended. The Creality Ender-3 V3 SE has also been successfully tested.
  2. Set up a soldering station with SUGON A9 210 or equivalent soldering iron.
  3. Prepare a heat insert stand for installing threaded inserts into 3D-printed parts.
  4. Have a hot glue gun ready for mounting magnets to motor shafts.
  5. Gather hex wrench set: M2, M2.5, M3, M4, and M6 sizes.
  6. Have a Phillips (+) and a flat-head (-) screwdriver available. Often these are included with the components you buy.

3. 3D Printing

Print all structural components using the provided STL files and recommended print profiles from the Releases page.

3.1 Print actuator components

Print all cycloidal gearbox housings, shafts, and motor shells using the Actuator Housing and Actuator Shaft print profiles.

  1. Download 3D printing files from the Releases page (Bambu Lab MakerWorld links provided).
  2. Use the Actuator Housing Profile for the housing, output shaft and motor shell. The profile settings are shown as screenshots on the 3D Printing Instructions page (tabs Quality, Strength, Speed, Support, Others).
  3. Release log, 2025-05-21: upstream fixed the MakerWorld .3mf files of the 6512 actuator. Release log, 2025-08-23: upstream fixed the 3D print file on MakerWorld, 'replacing the wrong 5010-5010 housing part and add the missing limit stopper part', and added an instruction on mounting the magnet on the motor shaft. If you downloaded or printed actuator parts before those dates, compare them with the current files.
  4. Use the Actuator Shaft Profile for cycloidal disks, input shafts, motor shafts, and spacers — these need higher precision.
  5. Print profiles are tuned for Bambu Lab X1C. Adjust settings if using a different printer.
  6. Print 10 complete M6C12 actuator part sets and 12 complete 5010 actuator part sets.

3.2 Print body structural parts

Print the upper body, lower body, and all structural frame components.

  1. Print upper body parts — each piece needs to be printed TWICE, with the second copy mirrored along the X axis.
  2. Print lower body parts — same mirroring requirement as upper body.
  3. Structural parts can be printed at faster speed settings since precision is less critical.
  4. The BOM lists the gripper as a bought part, 'Servo motor claw', quantity 2 on the Humanoid tab. The 3D Printing Instructions page does not describe printing a gripper.
  5. Clean up the printed parts before assembly. The M6C12 actuator video starts with a chapter called 'Clean up parts'.
  6. Install M2 and M3 threaded inserts into all designated holes using the heat insert stand and soldering iron.

4. Building the Actuators

Assemble all 22 cycloidal actuators (10x M6C12 high-torque, 12x 5010 medium-torque) following the video guides.

4.1 Prepare the magnetic encoders

Modify the AS5600 magnetic encoder boards for integration into the actuator housing.

  1. Follow the AS5600 Encoder Modification video guide (by -T.K.-).
  2. Use the radially-magnetized magnet that comes with the AS5600 encoder — do NOT substitute regular magnets.
  3. Modify all 22 encoder boards following the same procedure.
  4. Refer to the external tutorial at notes.tk233.xyz/electrical/as5600-modification for additional details.
  5. The modification is done by changing resistors on the board. The AS5600 Modification page lists these options: to use 5V on the VCC port, remove R1. To restore PGO to normal operation, remove R4. For counter-clockwise rotation, tie DIR to VDD; a 0R jumper can tie the DIR pad to the top of R1, which is connected to VCC (near the 'R1' text side).
  6. After moving the resistors, also solder the VCC, GND, SDA and SCL wires on the corresponding pads.

4.2 Prepare the motors

Mount magnets to motor shafts and prepare motors for actuator integration.

  1. Use some hot glue to stick the magnet to the shaft of the motor rotor. The page shows a 5010 motor as its example, which has a clip on the shaft. The M6C12 motor has a screw at the end of the shaft instead, but the way the magnet is mounted is the same.
  2. Prepare all 10 M6C12 motors and 12 5010 motors.

4.3 Assemble the M6C12 actuators

Build the high-torque actuators with cycloidal gearboxes, bearings, and encoders.

  1. Follow the "Assembling the M6C12 Actuator" video guide by -T.K.-.
  2. Fit the bearings as the BOM describes them. MR106-2RS: between the input shaft and the cycloidal disk, and between the input shaft and the output shaft. 6701-2RS: between the cycloidal disk and the output shaft. 6811ZZ: between the output shaft and the housing.
  3. Assemble the 15:1 cycloidal gearbox with the printed cycloidal disk and input shaft.
  4. Mount the M6C12 motor into the motor shell and connect to the gearbox.
  5. Attach the modified AS5600 encoder over the magnet that you glued to the motor rotor shaft (video chapter 'Attach encoder'). The encoder reads the motor shaft. Upstream notes that the joint actuators have only a single encoder on the motor shaft.
  6. Repeat for all 10 M6C12 actuators.

4.4 Assemble the 5010 actuators

Build the medium-torque actuators following the same process with 5010-specific parts.

  1. Upstream publishes an assembly video for the M6C12 actuator only. It publishes no separate 5010 assembly video or text. The 5010 actuator is covered by its BOM tab, its Onshape CAD and its MakerWorld print files, all linked from the Releases page.
  2. The 5010 actuators are smaller but use the same cycloidal gearbox principle.
  3. Fit the bearings listed on the 5010 Actuator tab: MR106-2RS, 6701-2RS and 6809ZZ.
  4. Repeat for all 12 5010 actuators.

4.5 Solder ESC connections

Solder power, CAN bus, and signal cables to all B-G431B-ESC1 motor controllers.

  1. Use 14 AWG wire for power cables (positive=white/red, ground=black).
  2. Use 30 AWG stranded silicone wire for the CAN cables. Colour coding: yellow for CAN-H and SDA, green for CAN-L and SCL.
  3. Warning: the CAN port solder pads on the ESC are very fragile and very susceptible to breaking off the FR4 base layer. Be extra cautious when soldering and handling the board. Do not apply excessive force on the cables and the pads.
  4. Solder all 22 ESC boards with consistent color coding.
  5. The solder pads of the encoder and CAN are tricky to work with. Upstream suggests adding more flux, which makes a more solid solder joint easier.
  6. Connect the encoder, the motor and the motor controller according to the wiring diagram on the Building the Actuator page. The diagram is an image and is not reproduced here.

5. Flashing Motor Controllers

Flash firmware to all B-G431B-ESC1 motor controllers and calibrate each actuator.

5.1 Flash firmware using STM32CubeIDE

Install and flash the Recoil Motor Controller firmware to each ESC.

  1. Install STM32CubeIDE on your computer.
  2. Download the firmware with: git clone https://github.com/T-K-233/Recoil-Motor-Controller-BESC.git
  3. Open Core/Inc/motor_controller_conf.h and set the FIRST_TIME_BOOTUP flag to 1. This configures the Flash protection, because the internal Flash of the STM32 stores the motor configuration parameters.
  4. Connect the motor controller to the computer through the Micro USB port on the controller board. STM32CubeIDE should detect the new device. Click the Run button. A brand new board prompts for an ST-LINK debugger firmware update: accept it, follow its instructions, then click Run again.
  5. Power-cycle the board by unplugging and plugging in the USB cable again. Then change the FIRST_TIME_BOOTUP flag back to 0.
  6. Follow the "Flashing the Motor Controller Firmware" video guide.
  7. Flash all 22 ESC boards.

5.2 Configure actuator parameters

Set the CAN ID and select the motor profile in motor_controller_conf.h for each actuator, then flash it.

  1. For an M6C12 actuator, uncomment #define MOTORPROFILE_MAD_M6C12_150KV. Use the current firmware: the M6C12 profile was re-measured on 2025-09-07 (torque constant 0.08958, previously 0.0919).
  2. For a 5010 actuator, uncomment #define MOTORPROFILE_MAD_5010_110KV, because the BOM motor is the MAD Components 5010 110KV. Do not use MOTORPROFILE_MAD_5010_310KV or MOTORPROFILE_MAD_5010_370KV: in the firmware those two profiles have the MOTOR_TORQUE_CONSTANT line commented out. The robot's saved joint configuration for the 5010 joints carries torque constant 0.1176, which is the 110KV profile.
  3. Set DEVICE_CAN_ID in motor_controller_conf.h according to the Joint ID Mapping page. IDs are unique on each CAN bus, not across the whole robot. Left arm (CAN0): 1, 3, 5, 7, 9. Right arm (CAN1): 2, 4, 6, 8, 10. Left leg (CAN2): hip roll 1, hip yaw 3, hip pitch 5, knee pitch 7, ankle pitch 11, ankle roll 13. Right leg (CAN3): hip roll 2, hip yaw 4, hip pitch 6, knee pitch 8, ankle pitch 12, ankle roll 14. The firmware accepts values from 1 to 63.
  4. Scroll down in the same file and set LOAD_ID_FROM_FLASH and LOAD_CONFIG_FROM_FLASH to 0, so that the program overrides the default random values in the Flash. Click Run. Then unplug and plug the USB cable again to make sure the flash option loaded. The LED should blink at around 1 Hz, which shows the program is loaded and running.
  5. Change LOAD_ID_FROM_FLASH and LOAD_CONFIG_FROM_FLASH back to 1 and click Run to flash one last time. At this point the Run button has been clicked four times, and both the firmware and the configuration parameters are loaded.

5.3 Calibrate all actuators

Run the calibration routine on each actuator over CAN bus using the provided Python scripts.

  1. Connect the CAN bus of the actuator to the computer through the USB-CAN adapter, then power on the actuator. Start the CAN transport with: sudo ip link set can0 up type can bitrate 1000000
  2. Check the connection with: uv run ./source/berkeley_humanoid_lite_lowlevel/scripts/motor/ping.py -c can0 -i 1 (the -c argument is the CAN transport, the -i argument is the CAN ID). The script should print 'Motor is online'. If it prints 'Motor is offline', check the signal cable connection, the power and the CAN ID settings.
  3. Make sure nothing is attached to the actuator and it is free to spin. Run: uv run ./source/berkeley_humanoid_lite_lowlevel/scripts/motor/calibrate_electrical_offset.py -c can0 -i 1. Warning from upstream: the motor will spin and draw quite an amount of current (about 1 A from the power supply). Make sure the power cables are connected properly and the actuator is free to spin. The motor slowly increases the holding torque until the phase current reaches the target value, rotates counter-clockwise for one full mechanical rotation, then rotates back clockwise for one rotation.
  4. If the rotation direction is flipped (clockwise first, then counter-clockwise), either swap any two of the three motor phase wires, or change MOTOR_PHASE_ORDER in the firmware to -1. The release log added this note on 2025-07-07.
  5. Follow the "Motor Calibration" video for the correct procedure.
  6. To check the actuator, run: uv run ./source/berkeley_humanoid_lite_lowlevel/scripts/motor/move_actuator.py -c can0 -i 1. It commands the actuator along a sinusoidal position curve. Caution from upstream: the motor will spin. Start with a small kP, kD and torque limit value. If anything unexpected happens, press Ctrl+C to stop the program and the actuator.
  7. Calibrate all 22 actuators.

6. Building the Robot

Assemble the arms, legs, and full body using the calibrated actuators and 3D-printed structural parts.

6.1 Assemble the arms

Build both arm assemblies with shoulder (3 DOF) and elbow (2 DOF: elbow pitch and elbow yaw) joints, then attach a gripper to each.

  1. Follow the "Assembling the Arm" video guide by -T.K.-.
  2. Install 5010 actuators for shoulder roll, shoulder yaw, elbow pitch and elbow yaw: four 5010 actuators per arm. The Humanoid tab lists 8 5010 actuators for the two arms.
  3. Install an M6C12 actuator for the shoulder pitch joint, one per arm. The Humanoid tab lists 2 M6C12 actuators for the arms. Upstream's text does not name the actuator for each arm joint; it is shown in the Assembling the Arm video, which was not watched. This assignment follows the BOM counts and the robot's saved joint configuration.
  4. Attach gripper assemblies to each arm.
  5. Build both left and right arms (mirrored assemblies).

6.2 Assemble the legs

Build both leg assemblies with hip (3 DOF), knee (1 DOF), and ankle (2 DOF) joints.

  1. Follow the "Assembling the Leg" video guide by -T.K.-.
  2. Install M6C12 actuators for hip roll, hip yaw, hip pitch and knee pitch: four M6C12 actuators per leg. The Humanoid tab lists 8 M6C12 actuators for the legs.
  3. Install 5010 actuators for ankle pitch and ankle roll: two 5010 actuators per leg. The Humanoid tab lists 4 5010 actuators for the legs. Upstream's text does not name the actuator for each joint; the assignment follows the BOM counts and the files named above, and the Assembling the Leg video may show it. That video was not watched.
  4. The Assembling the Leg video has these chapters: Hip Base, Hip Roll, Hip Yaw, Hip Pitch, Knee Pitch, Ankle Pitch & Roll. Correction in the video description: 'in the video, I assembled the hip structure incorrectly. The hip pitch should be mounted the otherway --- I messed up with the left leg and right leg.' Mount the hip pitch the other way round from the video.
  5. The Humanoid tab lists 6 6803-2RS bearings for the legs, described as 'Bearing between the linkage on the pitch actuators on legs'.
  6. Build both left and right legs (mirrored assemblies).

6.3 Assemble the full body

Combine arms, legs, and torso into the complete humanoid robot.

  1. Follow the "Assembling the Body" video guide by -T.K.-.
  2. The Assembling the Body video has these chapters: Attaching the battery holder, Preparing the hip, Base structure, Attaching the base, Attach the arm.

6.4 Wiring and electronics

Complete all electrical connections including CAN bus, power distribution, and onboard computer.

  1. Attach the CAN cables directly to the screw terminal on the USB-CAN adapter board. The order is CAN-L, CAN-H, GND, and the signal names are also labelled on the back of the PCB. The robot uses four buses: CAN0 left arm, CAN1 right arm, CAN2 left leg, CAN3 right leg.
  2. Signal cables: solder them together directly and protect the joints with heat shrink tubes. Power cables: when first connecting, WAGO connectors (the robot uses the two, three and five port types) can join and detach each actuator from the main power bus without soldering, which makes debugging easier. For a more permanent build, solder the cables together directly.
  3. Between the actuators the cables can be connected with XT30 and XT60 connectors. Upstream uses XT60 to connect the main cable together, with each actuator connected to the main power bus using an XT30 connector.
  4. Mount the Intel N95 Mini PC and connect USB hubs.
  5. Connect USB-CAN adapters to the USB hubs.
  6. Install the IMU (IM10A recommended) via direct USB connection to the onboard computer.
  7. Mount the 6S LiPo battery in the torso.
  8. Warning from upstream's home page: 'This is not just a software project. It includes designs for high power electronics. It has not yet burned down any UC Berkeley labs or anyone's houses, but there are no guarantees : )' 'Please follow all steps with extra caution.' Check polarity before connecting power: white or red is positive and black is ground in upstream's colour coding.

7. Software Setup and Testing

Set up the software environment, deploy policies, and verify the robot operates correctly.

7.1 Set up the onboard computer

Install the operating system and required software on the Intel N95 Mini PC.

  1. Install Ubuntu 22.04 on the on-board computer. Upstream says 22.04 works well with its software and hardware stack, and names the computer as the BeeLink N95 NUC. The page leaves the BIOS key as 'XXXX'.
  2. Clone the Berkeley-Humanoid-Lite repository.
  3. Install the packages the page lists: sudo apt install build-essential cmake net-tools can-utils python3-pip. The commands run Python through uv; the Training Environment page gives the command that installs uv. The workspace pyproject.toml requires Python 3.11 (requires-python >=3.11,<3.12).
  4. Upstream says only the contents of source/berkeley_humanoid_lite_lowlevel/ are required on the robot.
  5. Start the CAN transports with: source ./scripts/start_can_transports.sh. It brings up can0 to can3 at bitrate 1000000. To stop them: source ./scripts/stop_can_transports.sh

7.2 Test actuator communication

Verify all 22 actuators respond correctly over CAN bus from the onboard computer.

  1. Test one actuator with the ping script. The Flashing page gives: uv run ./source/berkeley_humanoid_lite_lowlevel/scripts/motor/ping.py -c can0 -i 1. The On-board Computer page gives an older path and flags (python ./berkeley_humanoid_lite_lowlevel/motor/ping.py --port can0 --id 1) that no longer exist in the Lowlevel repository. With two arms and two legs connected the CAN port is one of can0, can1, can2 or can3, and the CAN ID is in the range 1 to 14.
  2. Check each joint with the move_actuator.py script from the previous step, starting with a small kP, kD and torque limit.
  3. Check that each actuator's CAN ID and bus match the Joint ID Mapping page. The joint list the software uses is in berkeley_humanoid_lite_lowlevel/robot/humanoid.py, which lists the legs and has the arm joints commented out.

7.3 Deploy locomotion policy

Load a trained locomotion policy and test basic walking.

  1. The repository holds ONNX policies in checkpoints/ (for example policy_humanoid.onnx and policy_humanoid_legs.onnx) with matching YAML files in configs/. The play.py training script exports a trained policy as ONNX and updates configs/policy_latest.yaml.
  2. To run everything together, first make sure the CAN transports are started. There are two ways to run the low-level code. C codebase, recommended for locomotion for better real-time guarantee: in ./csrc/ run make, then ./build/real_humanoid. If the USB-CAN adapter cannot keep up the communication frequency, the page suggests the xanmod real-time kernel. Python codebase: run uv run ./scripts/python/run_locomotion.py from the lowlevel directory. In the current Lowlevel repository the script is scripts/run_locomotion.py, so the page's path is out of date. The robot follows the same state transition as in the MuJoCo sim2sim simulation.

This website requires JavaScript to function properly. Please enable JavaScript to explore our collection of open source robotics projects.