Advanced Robot Language

K-ARL is an application that aims to make the robot control and programming much easier, time-saving and powerful. It is a framework consisting in two main modules. The first is a high-level program, working as a coordinator, that runs on a standard PC. It can program and control several robots in parallel and monitors the entire manufacturing process, considering sequencing constraints and ensuring commands execution. The second KARL module is a program running on each robot controller, standardized according to the specific robot manufacturer. Its function is to identify and then execute the instructions received from the coordinator.

    Improvements that such an application brings are relevant:

    • The K-ARL coordinator enables to modify the manufacturing process of an entire robotic cell from a single PC and without interrupting its current operations. In fact, once a new set of commands is created, it can be transferred to the controller of one or more robots and then saved in a buffer before being executed;
    • The use of a manufacturer independent Python interface extends the code editing also to non-expert users, making unnecessary to have specialized workers for each robot brand;
    • The coordinator module also favors the implementation of complex controls by making available advanced programming concepts.

    Traditional Approach

    Industrial robots are becoming key elements in the context of Industry 4.0 because of their relatively short setup time and high versatility. However, in contrast with those characteristics, they are in most cases programmed in a rigid and closed manner. In fact, the standard programming approach consists in generating a program file with a manufacturer-specific software, stop the task execution, uploading the file on the robot controller and then restart the robot to execute the new task.

    This approach shows different drawbacks, such as:

    • Any modifications to apport to the robot program is time-consuming;
    • If many robots have to perform the same task, the same code has to be repeated multiple times, increasing the chance to commit errors;
    • Robots of different brands imply different robot languages, so specialized personnel for each robot brand is required;
    • Only basic commands are available: no chance to perform advanced calculations and control strategies.

    Our Approach

    Our software application K-ARL aims to overcome those problems, since it is based on a new approach. The new approach consists of setting up a communication between the PC and the robot controller. The flexibility of the robotic system is greatly increased, since the robot is now controlled by the PC through a stream of commands and the rigidity given by the need to download a file on the robot controller every time a change is needed is eliminated.

    Our application consists of two types of modules: one is installed on the PC, the other one on the robot controller.

    The module installed on the PC is called “Coordinator”. It is written in C++ language (which provides a solid and efficient structure), but it is wrapped in Python language. Python is a high-level and common language, it is user-friendly and does not require high programming skills to be used. On the one hand, these features make the application usable even by non-expert or specialized programmers. On the other hand, through Python is also possible to easily include advanced calculations and/or outputs from PC applications, such as simulation programs, paths generation programs, etc., in the robot control strategy.

    The KARL module installed on the robot controller is a standard robot file, which includes vendor-specific code to properly communicate with the coordinator. This robot file will be present on every robot that makes up the robot fleet.

    The name “Coordinator” is also due to its role as sequencer. In fact, it is responsible for coordinating the activities of every robot in the fleet. In standard approach, that would be handled through a complex system of hand-shakes: with K-ARL, this crucial functionality is implemented with simple, native commands.