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