Connecting to sources…

How to build PAROL6: the whole process

50 steps to build PAROL6, from buying parts, printing and assembly to software, calibration and training, with the bill of materials, shop links and the official sources.

PAROL6 is a high-performance 3D-printed desktop robotic arm. The repository provides the robot's STL files, a bill of materials (BOM), and assembly instructions for building it from source.

Bill of materials · Belts

PartQtyEU
Joint 1 belt · HTD3 396 · 6 mm width1
Joint 3 belt · HTD3 342 · 6 mm width1
Joint 4 belt · HTD3 201 · 6 mm width1
Joint 5 belt · HTD3 246 · 6 mm width1

Bill of materials · Pulleys

PartQtyEU
J4 pulley, J5 pulley · HTD3M 12 tooth · 5mm bore, 10mm width2
J1 pulley · HTD3M 15 tooth · 5mm bore, 10mm width1

Buy parts

  • Obtain the extra hardware

    Obtain the reamers, steel dowel pins, and two-part epoxy listed under **Small print bed modification** in the BOM.

Print and make

  • Choose parts that need replacing

    Use these replacement files only if the standard parts do not fit. The upper arm needs a containing cube of 160.5 mm, and the turret blocker needs 154.1 mm; neither can be rotated to fit.

  • Read the modification PDF

    Read `Building instructions/Parol small print bed modification.pdf` before printing. It covers the required reamers, dowel pins, epoxy, and assembly steps for both parts.

  • Print the required folder

    Print only the folder for the replacement parts that do not fit, or print both folders if neither standard part fits. Every other robot part is unchanged.

  • Check the printer bed size

    Use the small printer bed modification only if the printer bed cannot accommodate `J1_turret_rework_blocker` and `Upper_arm`.

  • Print the split parts

    Get the STL files from `STL/SMALL_PRINT_BED` and print `J1_turret_rework_blocker` and `Upper_arm`; both parts are split into two pieces.

  • Use split parts for a small bed

    If the printer bed is too small for `J1_turret_rework_blocker` and `Upper_arm`, use the split versions from `STL/SMALL_PRINT_BED`. Join each split part with dowel pins and epoxy after printing; nothing else in the build changes.

Assemble

  • Join the printed parts

    After printing, join the two halves of each part with dowel pins and epoxy.

  • Keep the rest unchanged

    This printer bed modification requires no other changes to the build.

  • Assemble the replacement upper arm

    Follow the PDF assembly procedure for `Upper_arm`. Join its two printed halves with steel dowel pins and two-part epoxy.

  • Assemble the replacement turret blocker

    Follow the PDF assembly procedure for `J1_turret_rework_blocker`. Join its two printed halves with steel dowel pins and two-part epoxy, using the specified reamers and assembly steps.

Software

  • Choose an end effector

    Select an end-effector configuration containing the corresponding joints, collision geometry, masses, materials, and TCP frame. Use the source-checkout links or downloaded packages, which contain the same entry files.

  • Open the model in MuJoCo

    Open the selected `scene_*.xml` in the MuJoCo viewer. Run the first command from the extracted ZIP directory, or the second from the root of the central `robot_descriptions` checkout.

  • Extract the model package

    Extract the model download into a separate working directory or ROS workspace to use the actual model package.

  • Open the URDF model

    Open `parol6_description/parol6_msg.urdf` while keeping the `meshes/` directory alongside it. If a web viewer requests a ZIP or folder, provide the URDF package with all its assets.

  • Launch the model in RViz

    Install the extracted `parol6_description` package with colcon using the ROS 2 guide, source the workspace, and launch RViz with the joint sliders. Use `jaws:=soft_tpu` for MSG Soft TPU or `end_effector:=ssg48 jaws:=fin_ray` for SSG48 Fin-ray.

  • Launch the model with ROS 1

    For ROS 1, run `roslaunch parol6_description display.launch end_effector:=msg` to display the selected model.

  • Download the MoveIt 2 configuration

    Download parol6_moveit_config.zip alongside the PAROL6 URDF ZIP from the same release.

  • Install MoveIt 2 and open RViz

    Follow the linked MoveIt 2 installation and RViz walkthrough before launching the demonstration.

  • Launch the PAROL6 MoveIt demo

    Run the demo with the ssg48 end effector and fin_ray jaws.

  • Install Python and Git on Windows

    Download Python 3.11.9 and run the Windows installer (64-bit), ticking “Add python.exe to PATH” before selecting “Install Now”. Download Git from git-scm.com and install it with the proposed settings.

  • Open and navigate a Windows terminal

    Press the Windows key, type cmd, and press Enter to open the terminal. The commands on the page begin with cd %USERPROFILE%\Documents; if that path is not found, use cd %USERPROFILE%\OneDrive\Documents instead, or open cmd from the address bar in File Explorer.

  • Install Git and Python on Ubuntu

    Open a terminal with Ctrl+Alt+T or from the applications menu, then install Git with sudo apt install git. Install Python 3.11 with its virtual environments and window toolkit using the deadsnakes PPA, then verify python3.11 --version and git --version.

  • Install Python and Git on macOS

    Download and run the macOS 64-bit universal2 installer for Python 3.11.9. Open Terminal with Cmd+Space, install Git using xcode-select --install, confirm the opening window, then verify python3.11 --version and git --version.

  • Install commander software on Linux or macOS

    Clone the commander software into Documents, create a .venv with Python 3.11, activate it, and install requirements.txt.

  • Install Python API on Linux or macOS

    Clone the Python API into Documents, switch to version 0.9.1, create a .venv with Python 3.11, activate it, and install the package.

  • Verify the software installation

    Check that the installation ends without an ERROR line. If an ERROR appears, use the Commander installation or Python API installation guide.

Calibrate and test

  • Verify Python and Git installation

    Check that the terminal reports Python 3.11 followed by a number and git version followed by a number. If a command is not found, install that program again, tick “Add python.exe to PATH” on Windows if needed, and open a new terminal.

  • Open the Python Environment

    Open a second terminal and enter the PAROL6-python-API directory. Activate .venv\Scripts\activate and run python. On Linux and macOS, use cd ~/Documents/PAROL6-python-API, source .venv/bin/activate, and python.

  • Ping the Robot

    Import RobotClient, create a RobotClient instance, and call ping() while keeping the second terminal open. Confirm that the response log shows robot data or that ping() returns hardware_connected=True; if it does not, use Communication troubleshooting.

  • Check Joint Directions

    Before homing, briefly move each joint only a few degrees and compare its motion with the figure showing each joint's positive direction. Keep the second terminal open for the Python commands.

  • Observe Pre-Home Limits

    Until the robot is homed, joint 2 can jog only negatively, opposite to the positive-direction figure. Joints 3 and 6 can jog only positively, while joints 1, 4, and 5 can jog in both directions.

  • Jog Joints in Commander

    In the Joint jog menu, briefly press the left positive arrow for joints 1 and 3 through 6. Press the right negative arrow for joint 2. A refused jog does not move and is logged as Error: Robot jog -> Position out of range.

  • Jog Joints with Python

    In the second terminal, jog joint 1 positively for half a second and joint 2 negatively with the listed speed and duration. The Python API checks the joint limits and stops a joint before a jog that would start outside the allowed range.

  • Correct Wrong Joint Direction

    If a joint turns the wrong way, correct the direction in the firmware using the Firmware and first run guidance rather than changing it by trial.

  • Run the movement program

    Paste the program into the program window and press Start. The program bends the arm, turns the base, and returns to the after-homing pose.

  • Move the arm with Python

    Type the lines at the >>> prompt one at a time. The API bends the arm, moves 30 mm down and 30 mm back up, turns the base, and returns to the after-homing pose.

  • Use the gripper presets

    Select the gripper group to use its open and closed presets.

  • Check the MSG camera configuration

    For MSG configurations, use the linked built-in camera view.

  • Review the dimensioned PAROL6 sheets

    Check the dimensioned PAROL6 review sheets for the robot's dimensions.

  • Review the PAROL6 DH convention

    Check the PAROL6 DH convention document for the kinematic convention.

  • Compare PAR6 and PAROL6 kinematics

    Review the PAR6 and PAROL6 comparison for their kinematic differences.

  • Check mass COM and inertia

    Check the documented status of mass, center of mass, and inertia.

  • Check the actuator settings

    Check the documented actuator settings for PAROL6.

  • Check pneumatic jaw controls

    Review the documented pneumatic jaw motion and controls.

  • Distinguish flange and TCP frames

    Treat flange as the physical tool-mounting face and tcp as the configured control frame. Jaw-specific grasp centers have not been calibrated.

  • Account for different flange offsets

    PAR6 and PAROL6 share the public joint conventions and a 177 mm forearm, but their shorter and longer wrist housings require different flange offsets.

Use it

  • Park the arm

    Press Park to write the three-line park program into the program window. Press Start to run it.

  • Switch off the robot

    After the arm is parked, hold the forearm and press the power button. The arm goes limp when the motors lose power.

  • Plan and check TCP movements

    Plan TCP movements, check for collisions, and execute the movements with mock controllers. All six tool options are supported.

Common problems

  • Builders cannot clearly complete arm calibration after assembly. #13
  • BOM and documentation contain broken links, outdated targets, and incorrect details. #1 #2 #3 #17 #18
  • PCB purchasing options and design schematics are unclear. #8 #10
  • Printing material and slicer settings are missing or outdated. #6 #11
  • Provided STL files have mesh errors or mismatched mating dimensions. #15 #20
  • Source-file licensing may not comply with GPLv3. #12
  • A working arm remains difficult to adapt to real-world tasks. #14

Documents