-
Robot renders!
09/06/2023 at 13:21 • 0 comments -
PAROL6 mechanical structure
08/21/2023 at 14:42 • 0 commentsDesign 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.MOTOR LOCATIONS
WIRING
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.
BELTS AND TENSION
Belt tension is done with small ball bearings. The usual diameter of the bearing is 8mm if you see that that tension is not enough you can use a 10mm bearing. Bearings can be mounted on both sides of the belts. Joint 1 also uses a belt but it is hidden so taking pictures of it is really hard.
-
PAROL6 detailed software overview and setup
08/21/2023 at 11:19 • 0 commentsPROTOCOL
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:
* https://github.com/petercorke/robotics-toolbox-python responsible for all kinematics trajectories ...
* https://github.com/ovinc/oclock 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
RESPONSE LOG
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
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
TRAJECTORIES
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, there are no inverse kinematics errors or singularities to avoid. Cons are that it is hard to validate where the joints will move in task space thus making it harder to not hit stuff.
Cartesian space trajectories have more predictable motions and are better for handling obstacles and collisions. Cons are that they have slower execution since they need to calculate inverse kinematics at each step. Robots can really easily hit singularities and the robot joints can reach high speeds.
The image shows trajectories that can be generated with PAROL6 control software.
JOG
The Jog window allows you to move to the robot in real-time. There are 2 types of jogging: Joint level jogging and Cartesian jogging.
Joint level jog jogs only the individual motors.
Cartesian level jogging jogs the robot in x,y, and z axes or rotates around those axes. This means that not only one motor will move to execute that move but all motors of the robot. There are 2 types of cartesian jogging: tool reference frame jogging and world reference frame jogging.
Tool reference frame jog allows you to move/rotate in the x,y, and z axes of the END EFFECTOR reference frame.
World reference frame jog allows you to move/rotate in the x,y, and z axes of the WORLD/Base reference frame.
-
PAROL6 control board
08/20/2023 at 14:44 • 1 commentIntroduction
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.
Features
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 50VIsolated 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.3AConnections
* 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 BHow 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
08/19/2023 at 14:54 • 0 comments -
Github repo split
08/17/2023 at 17:26 • 0 commentsThe project repo is now split into two parts:
Robot arm repo that has all files to build the robot and PCB files
https://github.com/PCrnjak/PAROL6-Desktop-robot-arm
Commander software
https://github.com/PCrnjak/PAROL-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.
-
Printing table
08/17/2023 at 13:35 • 0 commentsThis table lists all values needed for 3D-printed parts of the PAROL6 robotic arm.
-
Faze4, CM6 and PAROL6 how do they fit together?
08/12/2023 at 09:15 • 0 commentsFAZE4
As some of you may know I also designed 2 other 3D-printed DIY robot arms; Faze4 and CM6. I would say Faze4 did well in the open-source community and has an active user base. It is mostly used by students as thesis work and just like a DIY robot project. The big mistake I did on the part of Faze4 was that its software and electronics were underdeveloped. It was mostly used as mechanical construction that people used with their own software and electronics. That drove a lot of people away from the project since they wanted a complete solution.
CM6
CM6 is a compliant robot arm that is much more complex in terms of control and electronics. It uses BLDC gimbal motors paired with custom-made BLDC drivers called S-drives. CM6 compared to Faze4 was technologically much more complex and I contribute that to its moderate success. The drives I designed were hard to make and were hit hard by covid and chip shortage. People that wanted to build it could not and to be honest there was I lot of work that needed to be done on the software and control side that I just did not know how to do at that time. Driver electronics were also quite basic. At the time I believed I did everything right and that S-drives were something special but I was way too wrong. Since then I worked in startups designing inverters and electronics for electric vehicles like cars, bikes, and delivery vehicles. And only now I can say that I could design industry-level electronics and control algorithms for something like CM6.
PAROL6
Now we come to PAROL6. Best of both worlds. Mechanical elegance of Faze4 and control and electronics inspired by CM6. PAROL6 was created to be a new standard for open-source robotic arms. But it was also designed with the goal to revive Faze4 and CM6. It was also designed to assist any robot arm builder by providing a electronics and control software/GUI/API stack they can build their mechanical structure on top of.
PAROL6 and FAZE4 integration
PAROL6 electronics and software will be really easy to integrate into Faze4 since both are open-loop stepper-controlled robot arms with limit switches. What this means is that ANY open loop 6 axes stepper robot will be able to use PAROL6 electronics and software platform to develop.
PAROL6 and CM6 integration
PAROL6 uses open-loop steppers. The trinamic stepper drivers are in the base of the robot and are responsible for the movement of the joints. This works really well but robots need to be a closed-loop for much better performance and safety. PAROL6 was made with that in mind and can be easily upgraded with closed-loop stepper drivers that are being developed.
By doing that robot becomes closer to CM6 and guess what, new drivers for CM6 are also being developed. They would be able to daisy chain and reduce wiring, have current sensing for torque control, 14-bit magnetic encoders, safety features, and much more.
Image of stepper driver for PAROL6. It is a small 39mm x 39mm board that fits on top of the NEMA 17 stepper module. The driver can run the FOC algorithm on stepper motors.
This is a driver for small BLDC gimbal motors. It is by design really similar to the stepper driver for PAROL6 except it is designed for 3-phase gimbal motors. It is perfect for CM6 robotic arm and expect to see a post about the new and upgraded CM6 soon!
-
3D printing waste and prototyping
08/12/2023 at 08:51 • 0 commentsThe picture above shows all the failed parts printed for PAROL6 robot. It was not the printer that failed but the engineer. I will write a short entry on how to reduce waste when 3D printing by doing the right design choices and checks.
* Do not rush to start printing your (LARGE) parts! If printing something bigger like 24h+ prints double-check all the features you need for your part to have are there.
* With small prints you don't need to worry about failing, they take 30 mins to print and in the same batch you can place several different versions of the same part and test what is a better fit or what works best.
* If printing large parts that need to mate with a lot of other parts first print some segments of that parts where tolerances need to be hit to a spot. For example, I have a print that will take 30h and one of the things that NEEDS to work is that bearing that that part holds is a tight fit. What I usually do is print just a hole that holds a bearing from the original part and test the tolerances. This will save you a ton of time trust me
* Top-down design and bottom-up design.
Top-down modeling involves generating and designing the geometry exclusively within an assembly, a technique often referred to as "in-context design." In this method, all elements are crafted within the assembly's framework.
Conversely, the alternative approach is known as bottom-up assembly modeling, where each individual part is conceived independently.
These are 2 methods you can use to design your complex assemblies. I usually go with Top-down design since I have more control over the project as a whole. For example, for PAROL6 the design was from the wrist to the base. So the first part I designed was the wrist part and then in the context of an assembly, I designed the forearm, then the elbow... Then I printed every part as I was designing it ( after designing the next part it mates too) So after designing the wrist I still did not print it, it was printed after the forearm was designed.
By printing part by part like that you can see if you did a mistake somewhere and just redesign that part and print a new one. You will not need to disassemble the whole robot that way to replace that part.
* Place all the screws and mechanical parts in your assembly! I know it is boring and you want to print your part as soon as possible but placing parts you did not draw (like screws, bearings, nuts...) really helps.