Project Logs

Collapse

• Trajectory follow and script language RBTscript

  Petar Crnjak • 5 days ago • 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 Crnjak • 09/06/2023 at 13:21 • 0 comments

• PAROL6 mechanical structure

  Petar Crnjak • 08/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.

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

  Read more »

• PAROL6 detailed software overview and setup

  Petar Crnjak • 08/21/2023 at 11:19 • 0 comments

  PROTOCOL 

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

  Read more »

• PAROL6 control board

  Petar Crnjak • 08/20/2023 at 14:44 • 1 comment

  Introduction

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

  Connections

  * 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

  Schematic

  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 Crnjak • 08/19/2023 at 14:54 • 0 comments

• Github repo split

  Petar Crnjak • 08/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

  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

  Petar Crnjak • 08/17/2023 at 13:35 • 0 comments

  This table lists all values needed for 3D-printed parts of the PAROL6 robotic arm.
  
  

• Faze4, CM6 and PAROL6 how do they fit together?

  Petar Crnjak • 08/12/2023 at 09:15 • 0 comments

  FAZE4

  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

  Petar Crnjak • 08/12/2023 at 08:51 • 0 comments

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

View all 14 project logs