PAROL6 - Desktop robotic arm

A robot that can be used as desktop tool for small automation and education!

Similar projects worth following
PAROL6 is 6 axes desktop robotic arm. It is a robotic arm whose design approach is driven by real needs from a robotic education standpoint, small automation, and scaling from RnD to production. It is the culmination of devolvement and feedback of 2 previous robotic arms made by me, both being very successful open-source projects. PAROL6 uses precision planetary gearboxes and belts with careful placement for optimal weight distribution. The design is modular and allows easy addition of closed-loop drivers. From the software side, it uses the custom protocol to allow for industry standard 60-100 Hz loop times. Modern GUI is inspired by industrial and cobot interfaces where all standard ways of control are implemented (resolved rate, cartesian level control, joint level control, motor jog...) It includes a simulator to test your programs without the need for a physical robot. PAROL6 is feature rich with an Isolated I/O, CAN bus, and compliant gripper...

Sign up and get notified when available:

Project log reading order: PAROL6 control boardmechanical designSoftware design

Github repo with PAROL6 Files and building instructions: Link

Github repo with PAROL commander GUI: Link

Documentation: Link

Join Discord!

Follow us on Instagram, Youtube, or Twitter!


 I first saw a need for robots such as this in my high school days where 30 students were working on one robot. At colleges, it was nothing better. I did some research and that was the situation in most colleges. My first attempt to change that and make it one robot per student was with Faze4. That project was financed by the college but was not a big hit because of its large size, imprecision, and lack of easy-to-use intuitive software. The second time I saw the need for a robot such as PAROL6 was when working as an RnD engineer on electric vehicles. Building a prototype is one thing but building a production is another much harder thing. I saw many ways robots such as PAROL6 could help companies that need to go from RnD to small production, or at least try to accelerate their RnD processes. Tasks such as adding thru-hole components, placing PCBs to test jigs, handling PCB, gluing, inserting brass bushings, and many more could be in some part automated with robots such as PAROL6.


With now a large amount of problems that I saw in education and industry I decided to try to tackle them with PAROL6. Just the idea of this kind of robot is nothing new and there are many robotic arm businesses that try to fill this gap but they either fail in terms of price, usability, or lack of support / being open. PAROL6 aims to be a low-price solution, be usable, and be as open source as possible.

PAROL6 is a desktop robotic arm. Its reach is 400mm and has 6 axes of freedom. Its capabilities are on par with industrial robots in terms of repeatability, speed, and usability.  It is equipped with stepper motors and precision planetary reducers/belt drives. Its mechanical parts can be 3D printed on any desktop 3D printer and its full weight is only 5.5 kilograms! In terms of connectivity, it has pneumatic tubes running thru the robot and the ability to connect a force-sensitive gripper that is being developed. 

The design is minimalistic and because of that can be easily modified. Stepper drivers can be upgraded to a closed loop for almost all axes without any major design changes. For that purpose closed loop stepper drivers running FOC have been developed.

Previous robots

Faze4 - Project link

Faze4 was my bachelor's degree project and was financed by my college with the goal to make a robot arm for education. This is where my realization came that robotic education is very underdeveloped. It is mostly done on simulations or with 10+ students working on one robot. Faze4 was supposed to change that. It is a fully 3D-printed behemoth of a robot with a reach of 580 mm, a weight of 15 kg, and fully 3D printed.  

Builds of Faze4

Problems of Faze4 were many: 

  • Too large a robot for students to manipulate safely
  • Printed gearboxes flex and make precision and repeatability terrible
  • Underdeveloped electronics and software
  • Because of all of the above, it was hard to work on and develop software

Nevertheless, Faze4 is still one of the most popular DIY robotic arms and is being used by multiple collages, as part of masters' and bachelor's theses, and by the maker community in general. Even 2 accelerator stage startups are using Faze4!

CM6 -Project link

CM6 was my master's degree project. It is using gimbal BLDC motors and printed planetary gearboxes paired with custom BLDC drivers called S-drive. This robot was of the experimental type where the goal was to make a robot arm that acts like a human arm (in stiffness, compliance, speed, and payload). It was achieved by using QDD actuators and experimenting with...

Read more »

  • 1 × Whole up to date BOM and list of components is always in github repository!

  • Beta batch of PAROL6 PCBS

    Petar Crnjak10/09/2023 at 14:19 0 comments

    If you are interested in the beta batch of PCBS sign up here:

    If you are interested in buying PAROL6 as a kit, fully assembled robot, or just a gripper sign up here:

  • 30 more PAROL6 robots coming soon!

    Petar Crnjak09/28/2023 at 10:57 0 comments

  • Robot testing code!

    Petar Crnjak09/27/2023 at 07:32 0 comments

    To test PAROL6 control board connection to your robot you can use stock software or use testing software. Testing software is more safe and interactive for users. It can be found at github. Once you flash your PAROL6 control board testing will start.

    Stepper drivers test

    The code will try to communicate with stepper drivers. Output1 and Output will go from high to low every 1s and LED1 and LED2 will flasg. If everything is okay you will get output like this on serial:

    If the stepper driver is faulty or not connected you will get:

    If stepper drivers are good your stepper motors should spin at a low speed using moderate current of 200-300 mA.

    Flash memory test

    In the serial terminal write # FLASH and press enter. You should get an output like this for a successful test.

    LIMIT test

    In serial terminal write # LIMIT and press enter. You should get a output like this if you activate the switch.


    In serial terminal write # IO and press enter. You should get an output like this:

    If you change the state of ESTOP, INPUT1 or INPUT2 you will see states changing. You will also be able to see the voltage of your power supply in mV!

  • Trajectory follow and script language RBTscript

    Petar Crnjak09/16/2023 at 21:01 0 comments

    PAROL6 commander software allows you to write simple robot arm scripts. The scripting language is called RBTscript. It allows you to move the robot in joint space or cartesian space, use delay functions, control outputs,  grippers, read inputs, and much more!

    How are trajectories tracked?

    Once the program starts it needs to generate and track commanded trajectories.

    There are 2 ways we can command robots' trajectory here:
    For example, we want joint 6 to move from 260 deg to 180 degrees. We want to follow trap velocity profile and get to 260 position in 2 seconds. We generated speed and position curves.
    Now if we command only the speed curve robot will follow it perfectly but if the move is too long or too fast it will miss the demanded position. Why? We are sending commands every 10 ms. but it is not always exactly 10 ms since pc is not a real-time machine that time fluctuates. another thing is that steppers execute some really small speed moves from the beginning and the ends of the speed curve. Because of that position is missed usually. How to compensate for that? Use position curve. Use your current position and commanded position and calculate how fast you need to go. After that take that speed and add commanded speed and average that.

  • Robot renders!

    Petar Crnjak09/06/2023 at 13:21 0 comments

  • PAROL6 mechanical structure

    Petar Crnjak08/21/2023 at 14:42 0 comments

    Design Approach 

    PAROL6 hardware and software design was driven in large part by Faze4 and CM6. From faze 4 mechanical design and from CM6 software and control approach. Advantage of building these robots before this one was the community and contributions to the projects from the people. People build unity simulators, ros control implementation, custom controllers, and modified STEP files... The goal is, like previous robots, to make as much open source as it can. Some of the guidelines that guided the design:

    • PAROL6 was built with a specific purpose in mind; Small automation like picking PCBs and placing them in test jigs, adding thru-hole components to PCBs... Another goal was for it to be used in an education setting where one PAROL6 can be used by one student, not 10 students per 1 robot.
    • It needs to have a robust simulator and GUI for easy offline programming. The ability to test your programs without a real robot is time-saving and is being done in most professional and industry-standard robots.
    • Previous robots of mine used plastic gearboxes and that is a big mistake. They are way too unreliable and bend too much. PAROL6 uses precision planetary gearboxes with 10-15 arcmin backlash (harmonic gearboxes usually have around 5 arcmins). By using quality gearboxes robot has much better repeatability and precision and can make smooth trajectories,
    • Robots need good connectivity to interact with the users and the world. PAROL6 has 2 isolated Inputs and 2 isolated outputs for controlling grippers, relays, pneumatics, or connection to PLC-s. It also has a CAN bus for connecting grippers or external devices. To communicate with a PC it uses USB.
    • PAROL6 was built with grippers in mind and has routed pneumatic tubes and wires for grippers to its Forearm region. 
    • A big part of PAROL6 is its software that was again built around Tkinter as GUI and Petar Corke's Python robotic toolbox. That combination has proven to be effective in CM6 and was refined here, Because of that it has a lot of features that no other open-source robotic arm has. 
    • PAROL6 was designed to be easy to build by using large 3D printed parts and an intuitive design. Also, I believe many DIY robotic arm projects suffer from bad building instructions that lock out some potential users, so PAROL6 has detailed step-by-step building instructions.

    WHY planetary gearboxes and belts?

    The robot is designed around precision planetary gearboxes on joints that are subject to most torque. These would be joints 2 and 3. Joint one uses belts and a larger motor. For joints 4 and 5 belts are used and for 6 a smaller planetary gearbox. The design was so that motors are not on the axes that they are actuating. By doing that you remove mass to the bottom of the robot and reduce the inertia of the joints. A spherical wrist was used to make inverse kinematics calculations simpler. For the forearm and upper arm section wires and tubes run thru the robot and also from the elbow to the base are hidden. The only section where wires are visible are from the upper arm to the elbow. By hiding wires and tubes they are protected from outside elements like tangling mechanical damage and more.

    Motors on most joints are not hidden. By doing that it is easy to add additional closed-loop stepper drivers to the motors and make the robot closed loop.
     For the joints, 1,2,3 installation of closed-loop drivers is just straight forward as mounting then. For joints 4,5 and 6 minor robot redesign will need to be made for esthetic parts. Only the forearm will need to be extended by 3 cm to allow for PCB to mount on Joint 6.



    Wiring is done similarly to the Faze4 robot except only visible wires are from the upper arm to the elbow.  The two images below show how the wiring is done for the robot. Blue are pneumatic tubes while green are wires.


    Belt tension is done with small ball bearings. The usual diameter of the bearing is...

    Read more »

  • PAROL6 detailed software overview and setup

    Petar Crnjak08/21/2023 at 11:19 0 comments


    PAROL6 uses serial USB communication to talk between high and low-level code.

    The protocol consists of three types of commands. Active, passive, and carrier. Active commands can only be given by the "command" argument and are represented by one byte. This means there can only be 255 commands. 

    Passive commands are for example I/O commands and gripper commands. They are always sent with the data packet. Passive commands do not affect the movement of the robot joints and because of that can be injected in any active command.

     Carrier commands are joint speeds and positions that are modifiers for active movement commands.

    The above image represents how the data is sent from and to the robot. 

    Structure of the code

    To operate the PAROL6 robot you need a:

    High-level software running on your PC
    Low-level software running on the PAROL6 control board
    For high-level software, there are multiple options:

    Use PAROL6 commander software for control, programming, and simulating
    Use our API to send commands thur your language of choice Matlab, python, c++
    Use ROS
    For low-level software only PAROL6 control board software is available.

    Control software

    Control software or the main task in the diagram above is responsible for all robot movements, communication with the robot, executing the code, and calculations...  Control software leverages 3 important Python libraries: responsible for all kinematics trajectories ...

    * Used for creating "accurate" loops in Windows and Linux

    * Python threading and multiprocessing library

    The control software will try to send data to the robot at a predetermined loop time. If you have a good enough PC it will be 10ms but 20ms will be fine if the PC is not good enough. The data it will be sending is defined by the protocol described at the top of this log post. When the robot receives the data it responds with its own parameters.

    GUI / control software

    GUI / control software is written in Python and the main components are:

    • Tkinter for a graphical interface
    • CustomTkinter for modern interface design in Tkinter
    • Robotic toolbox for Python for kinematics, trajectories...
    • multiprocessing library 

    The control software can be split into 3 processes that run in parallel and share an array of multi-process variables. The main process is then split into 3 threads: Debug, Main/Sender thread and Receive thread.

    GUI, user interface

    Gui is used for easy interaction between the user and the robot. Its design was inspired by the best of the industry robotics manufacturers. 

    Some of the features of the GUI are: 

    • Jogging window where user can perform joint jog, cartesian jog in TRF and WRF
    • I/O control 
    • Robot telemetry data view 
    • Response log that displays current commands, errors, warnings...
    • Program window that allows you to program the robot  with simple GCODE-like language


    A response log is an extremely useful tool for debugging and checking the state of your robot. It will print whatever command is sent to the robot. It will also print if there is any error or warning.

    Errors include:

    • Temperature errors
    • Inverse kinematics errors
    • Joint level speed limit error
    • Cartesian speed limit error
    • ESTOP error
    • Disable error
    • Position limit error


    Programming is done in the programming window of the GUI. Programs are saved as txt files so you can write them in your text editor of choice and open them in GUI. The programming window has options to save, open, and save as the programs.

    Commands need to end with ")".

    Some of the commands are:

    • Delay
    • Loop


    There are 2 types of trajectories used for this robot: task space trajectories and joint space trajectories.

    Joint space trajectories have faster execution time, there are no IK calculations, and Actuator motion is smooth and easy to validate. Also,...

    Read more »

  • PAROL6 control board

    Petar Crnjak08/20/2023 at 14:44 1 comment


    The PAROL6 control board is the advanced 32-bit controller for 6 AXES robotic arms like PAROL6. It works out of the box with PAROL6 and PAROL6 commander software.

    To use PAROL6 robotic arm you will need a PAROL6 control board. The PAROL6 control board is a compact robotic controller. It is by size a little bigger than a pack of playing cards. It allows PAROL6 to be a really small and portable robot without the need for a control cabinet that is usually the size of the whole robot.


    Hardware specs

    • Processor:       STM32F446RE 
    •  Processor: features Arm Cortex-M4 core with DSP and FPU, 512 Kbytes of Flash memory, 180 MHz CPU, ART Accelerator
    • Communication interfaces:     2 x CAN bus, 1 x USB  
    • Stepper drivers:       TMC5160  
    • Stepper drivers feature:        SPI comms, 10-35V, 3A max, protection features
    • Inputs:     2 x ISOLATED
    • Outputs:     2 x ISOLATED, 0.5A current output
    • Estop input:    Dedicated pin on MCU for ESTOP interrupt, 2 ESTOP connections on control board
    • Additional memory: W25Q64FV, SPI, 64Mb
    • Programming  interface:  JTAG 
    • Cooling fan connection: 5V cooling fan
    • Connection for a smart power button   

    Operating limits

    Power supply: 18V minimal, 30V maximal voltage

    Stepper drivers: Rated current 2.5A, maximal current 3A (Short burst or extreme cooling)  

    Temperature:  xx stepper driver temperature warning, xx temperature error 
    Isolated Inputs voltage: 24V nominal voltage, min 12V max 50V  

    Isolated Outputs voltage: 24V nominal voltage, min 12V max 50V

    Isolated Inputs current: 24V nominal voltage, min 12V max 50V  

    Isolated Outputs current: 24V nominal voltage, min 12V max 50V

    Fuse: Fuse is used for outputs if used in NON-ISOLATED MOD; 2A fuse
    Cooling fan: Maximal allowed current draw for the cooling fan is 0.3A 


    * 24 power connector on PAROL6 control board is XT30 MALE connector.
    * Connector for the cooling fan on the PAROL6 control is
    * Connector for the power on/off button on the PAROL6 control is
    * Connector for USB on PAROL6 control is USB female type B

    How to upload code

    The microcontroller on the PAROL6 control board is STM32F446RE. To upload code you need to use STlink device and connect it to dedicated CLK, SWDIO, 3V3, and GND pins. You can use jumper cables or dedicated stlink + cable assembly. You can compile your code or use precompiled HEX files.

    Getting connected

    Connect your PCB to the PC with USB cable. NOTE that the board will not get any power, It can be powered up in 2 ways:

    • Using 3v3 supply from stlink
    • Using 24V supply you connect to the board and then the board drops that supply to 3v3

    Once you connect the supply your board should turn on and be recognized on your PC device manager as a USB device. 

    Firmware configuration

  • PAROL6 introduction video

    Petar Crnjak08/19/2023 at 14:54 0 comments

  • Github repo split

    Petar Crnjak08/17/2023 at 17:26 0 comments

    The project repo is now split into two parts:

    Robot arm repo that has all files to build the robot and PCB files

    Commander software

    This decision was made because the commander software can be used for other robot arms. Because of that, it does not make sense to download a lot of files from the PAROL6 repo just to run the commander.

View all 17 project logs

  • 1
    Mechanical building instructions

    These instructions are made in a PDF manual you can download or print. 

    Link to building instructions!

  • 2
    Getting started manual!

    Documentation on how to get started with PAROL6 is written in a beautiful material theme for mkdocs! 

    Check it out!

View all instructions

Enjoy this project?



Theodore Giouzelis wrote 09/11/2023 at 16:39 point

Hi, I really like the robot you designed .

Do you have the 3D Step files ??

I would appreciate it 


  Are you sure? yes | no

Petar Crnjak wrote 09/13/2023 at 18:40 point

There are some modifications that need to be done to the robot. After that, the files will be available. The STL files are in the GitHub directory.

  Are you sure? yes | no

Theodore Giouzelis wrote 09/13/2023 at 22:29 point

Hi, the only reason I need the 3D step files, because I make small changes to the parts depending what orientation I print them

  Are you sure? yes | no

Marcin Kunikowski wrote 09/11/2023 at 10:33 point

I see everything can really be bought from the shelf except the custom control board. Any estimates on the price? Or maybe it can be substituted with some other board?

  Are you sure? yes | no

Petar Crnjak wrote 09/11/2023 at 17:06 point

board files for the older version are on GitHub but I don't recommend that since the software I am working on now is not compatible. I will be making a beta batch of PCBs that will be up for sale and later I hope the design will be open when it gets mature enough for people to reproduce. The link is here:

  Are you sure? yes | no

Similar Projects

Does this project spark your interest?

Become a member to follow this project and never miss any updates