***********************************************

BUY HERE: https://source-robotics.com

****************************************************

BUILD YOUR OWN!

Project log reading order: PAROL6 control board, mechanical design, Software design

Github repo with PAROL6 Files and building instructions: Link

Github repo with PAROL commander GUI: Link

Documentation: Link

Join Discord!

Join forum: https://discourse.source-robotics.com

Follow us on Instagram, Youtube, or Twitter!

 Problem

 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.
Solution

Solution

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: 

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 writing motor control software. The results were great and the robot's performance was impressive but the project was not polished enough and I lacked knowledge in motor control and PCB design to make it more presentable to the public. It was lightweight, safe, and easy to operate. It also had a developed control GUI that allowed for easy programming. CM6 was actually the base for all the work done on PAROL6. On top of that CM6 was the finalist of the Hackaday Prize 2021, it was reassuring I was on the right track to achieving my goals of building a usable desktop robotic arm that everyone can use.

S-drives were the base for the development of closed-loop stepper drivers and the next version of S-drive called spectral drivers. 

PAROL6 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, 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:

Software design

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

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.

The main building block of this control software is its communication protocol and multiprocessing arrays. Communication is done by USB serial by driver board and PC. Baud rates are in the range of 2-5Mbit. The protocol is fixed in size and its data packets always look like this:

All data sent and received by the control software is saved in multi-process arrays. The main process has its main task is sending data thru serial every 10-20ms. data is sent even if no command is given by the GUI or trajectory planner. That command is called dummy command and it serves as a heartbeat of the robot. If the heartbeat is not received after a specific time robot goes into error mode. The whole package size is: from the robot 60 bytes to the robot 52 bytes. This allows very fast loop times and is simple to maintain. The main task executes all trajectory planning, control logic, and GUI command handling... It is the most important task and is responsible for the operation of the robot. When developing new firmware it could be used as a separate segment of code independent of the other processes.

Receive task runs in the same main loop and is responsible to handle all incoming data. If the robot sends the correct data format with the same start bytes and end bytes, data can be checked with CRC and if it passes, saved to the multi-process variables that GUI, simulator, or main task can use. 

The simulator is its own process that runs in real-time. Having a simulator and visual aid when operating a robotic arm is crucial and I am sad that not a lot of other projects try to implement something similar. It should not be a feature reserved for expensive proprietary robots and solutions!

The simulator is a simple skeleton of the robot with an end effector represented as a coordinate frame. It uses matplotlib.

Driver board software

The driver board software is in charge of controlling the stepper motors and other peripherals like I/O, CAN bus, ESTOP... After it receives the package from GUI and confirms that it is good by checking CRC, start and end bytes, and package length it unpacks the package. After the package is unpacked robot responds to it with its own package.

User interface (GUI)

GUI was inspired by industrial robot control programs. It was simplified as much as possible to be usable by students but also has all the necessary features that are included in professional software solutions. It can be divided into a few sections. On the left side, we have motor jog and cart jog menus. Under them, we can see the robot's current position. In the middle, we have a programming window and underneath him a response log window. On the right side, we have a commands window for a quick selection of commands for programming.

The programming window is used to write programs that will run on your robot. It includes functions like:

The Whole GUI was designed in Tkinter and uses a custom Tkinter module for modern design. It can run on Linux, Windows, and MAC machines.  

Mechanical design

Robot specifications:

The whole robot should be printed in PETG material since motors and gearboxes can get quite hot. 

The placement of the motors was done to minimize the weight the robot joints need to carry and to reduce the inertia of the robot when accelerating.

Pneumatic tubes are run thru the robot. They have twofold purpose firstly they allow the connection of pneumatic grippers and vacuum grippers to the robot. Second, since the wires also run thru the robot the tubes act as a solid guide and support for the wires not to twist too much or get tangled.

The Noctua fan is used to cool the stepper drivers, and it is the loudest part of the robot. Disconnecting the fan makes to robot completely silent. The side of the robot has connectors to connect ESTOP, Inputs/Outputs, and CAN bus... On the same side, there is also an on/off button, power connector wire, and programming port.

Electronics

Driver board

The driver board's main purpose is to execute commands from PC sent to the robot. It is a 6-layer PCB designed to fit the base of the robot. In the future connection to the PC will not be needed since there is room to fit a raspberry pi compute module inside the base of the robot.

 Its main components are:

Compliant gripper

This here will be a small intro to the gripper since it is still a work in progress. It is also in itself really complex project that will be its own Hackaday project I hope. Same as a PAROL6, a compliant gripper fills the gap in the market. There is, unlike PAROL6 NO open-source compliant force-sensitive gripper that you can build. There are at least dozens of decent robotic arm projects you can build and no decent gripper that is close to the industry level.

The gripper uses Geared DC motor with inline bidirectional current sensing to detect impacts and measure forces. The position loop is closed with a linear potentiometer. Communication is done with the CAN bus.