The future of robot off-line programming

If you drive a car, it makes little difference what brand it is: all cars are driven in essentially the same way. The same applies to computers. If you have a Windows PC, the user interfaces won’t be affected by your computer hardware. But this is definitely not the case for industrial robots.
The way you program an industrial robot strongly depends on the robot brand. You might think that a robot program looks like C++ or Visual Basic. The truth is that some robots are still programmed in assembler-like languages.
Because of the complexity of using an industrial robot, robot integrators and most manufacturers try to limit themselves to a single robot brand. Unfortunately, industrial robot manufacturers don’t offer completely equivalent product ranges, and their offers evolve constantly. Stäubli, for example, is one of the few manufacturers that offers robots suitable for humid environments, while FANUC is the only one to offer a medium-payload collaborative robot. Furthermore, a number of businesses work with calls for tenders. As a result, sometimes manufacturers end up with different robot brands.
The reason why robot-programming languages evolve slowly is probably due to the fact that industrial robots are extremely reliable and durable. Thus, robot manufacturers have to offer backward compatibility.
Further, selling spare parts and additional options is probably as lucrative as selling new robots. For this reason, robot manufacturers probably won’t change the fundamentals of their programming languages. For example, ABB is stuck using quaternions to represent orientation, even though a quaternion is as intuitive as using binary code instead of ASCII. Rather than changing quaternions with Euler angles (like every other robot manufacturer), ABB simply added functions that convert from one convention to the other. Robot programming languages probably looked fine a decade or two ago, but nowadays, engineers are used to modern programming languages like Java, C#, and Python.
FANUC, one of the leading four robot manufacturers, provides not one but two different programming languages: Teach Pendant (or TP) and KAREL. TP programs are binary files that can be edited through the robot’s teach pendant buttons (or touch screen for newer robots). TP files can also be compiled/decompiled from an LS file (human-readable ASCII file) TP programs offer a limited assembler-like functionality. Alternatively, with FANUC, you can program your own algorithms using a PC and KAREL (programming language based on Pascal), but KAREL does not allow you to do robot movements nor edit the program from the controller’s teach pendant.
You can purchase ROBOGUIDE off-line programing and simulation software for about US$2,500/year to off-line program FANUC robots. However, if you don’t have ROBOGUIDE’s WinOLP, you won’t be able to use LS programs unless you also have the option “ASCII Upload” in your FANUC robot controller, a paid software upgrade required for each robot. You also need ROBOGUIDE to edit and create KAREL programs.
Motoman robots are programmed using the INFORM programming language (JBI files). INFORM looks similar to Fanuc’s LS programs. The program variables are registers shared among all programs. However, Motoman also offers MotoCom for all their robots: a well-documented library that allows you to program the robot using C++, C# or Visual Basic (on Windows).
Programming ABB robots is simpler, and based on the RAPID programming language, which looks like Visual Basic. Furthermore, ABB provides RobotStudio, offering on-line programming and an excellent RAPID program editor for free as well as an easy file transfer through a network connection between a PC and the robot. Optionally, you can pay about US$1,500 US/year to have the simulator and offline programming tools.
KUKA robots require SRC programs written in their KRL programming language, usually edited using the free OrangeEdit editor unless you have the KUKA simulator Sim Pro (priced at about US$2,000). It is interesting to note that Kuka’s KRC4 controller is a Windows based computer and the teach pendant is a remote desktop of that computer. It is unpractical to modify programs from the teach pendant as the touch screen feels slow. One notable exception, however, is KUKA’s collaborative robot, LBR iiwa, which uses KUKA’s Sunrise controller and is programmed in Java.
We’ll stop here, because there are dozens of other robot manufacturers from all over the world. Some brands do not have offline programming software (such as Universal Robots); the user is then forced to program robots through the robot controller’s touchscreen (which is highly intuitive, but also very limited) or using an ASCII editor and their UR Script language (based on Python). Other robot manufacturers focus their efforts on having plugins for CAD software, like Mitsubishi who offers MelfaWorks for SolidWorks.
The fact that nobody has taken a step towards unifying the way robots are programmed is very disappointing. G-code was introduced in the 50s, shortly after Numerical Control, and most CNC controllers currently use it. No such common programming language exists for industrial robots.
A few companies offer robot off-line robot programming tools that support multiple robot brands, such as Octopuz, Delmia, Siemens NX, and RobotMaster. However, the price of these software tools ranges between US$15,000 and US$100,000 per license. Clearly, these solutions are too expensive for most small and medium sized companies. Furthermore, some of these software tools target very specific applications (e.g., machining only). The market of used industrial robots is growing steadily and it is now easier to find robots at affordable prices. Some robots still work perfectly even 25 years after they were manufactured. You can currently find used six-axis robots for only US$10,000, but you can’t buy second-hand off-line robot programming tools.
This is why we created RoboDK: a simulator for industrial robots that provides a new way to program industrial robots, more intuitive off-line programming and more affordable. The simulator supports a wide variety of applications, such as pick and place, painting or robot milling (optimization tools are provided to automatically convert CAM programs to robot programs). RoboDK is a spin-off from the CoRo laboratory, one of the largest robotics labs in Canada, where it was tested on all major industrial robot brands.
RoboDK’s library has more than 200 robots from 15 different robot manufacturers and we look forward to continue adding support for new robot brands. Any robot manufacturer is welcome to include their robots in RoboDK’s library, providing an open interface to be able to do off-line programming and online programming as well. Off-line programming is achieved by defining the robot’s brand post processor. The online programming is achieved by developing a robot driver that works as a bridge between the simulator and the robot. Then, it is possible to easily run robot programs step by step, retrieve the robot position or move to a specific position with a robot. This video shows an example with an UR10:
What makes RoboDK unique is that you can program any robot using Python and the RoboDK API. Python offers an immense library of tools for programming (for example, to convert SVG images to XY coordinates that can be followed by robots). You can then use object oriented programming with Python and RoboDK’s API and have code snippets like:

<span style="font-family: consolas;"># robot is an object
# target is a pose (4x4 matrix), defining position and orientation of the TCP
robot.MoveJ(target*transl(0,0,-100))    # Move (joint) to the approach position
robot.MoveL(target)                     # Move (linear) to the target
CloseGripper()                          # Custom-defined action, such as grabbing a part
robot.MoveL(target*transl(0,0,-100))    # Move back to the approach position</span>

… which will move the robot to a specific target through an approach position. Many examples are available in our library (with and without Python).
There is no doubt that one day a robot programmer will have the choice to program any robot brand using a universal programming language such as Python. Robot programmers as well as companies prefer this option as they do not depend on brand-specific tools. Kudos to Mecademic, another spin-off of CoRo, who offers the first industrial robot arm that can be controlled with any modern programming language.
RoboDK has been downloaded more than 2,000 times since we launched it in January 2015. RoboDK has also attracted universities as a tool for learning industrial robotics as well as new robot manufacturers all over the world. We also welcome integrators to develop their technology using RoboDK’s API. The advantage is that they can develop their technology with one robot brand and deploy it with any other robot brand.
RoboDK can be tried for free, it will remain free for educational purposes and is the most affordable offline programming solution available.