Robot Programming Languages

Robot software is the coded commands that tell a mechanical device (known as
a robot) what tasks to perform and control its actions. Robot software is used to
perform tasks and automate tasks to be performed. Programming robots is a non-
trivial task. Many software systems and frameworks have been proposed to make
programming robots easier.
Some robot software aims at developing intelligent mechanical devices. Though
common in science fiction stories, such programs are yet to become common-place
in reality and much development is yet required in the fields of artificial
intelligence before they even begin to approach the science fiction possibilities.
Pre-programmed hardware may include feedback loops such that it can interact
with its environment, but does not display actual intelligence

Introduction

Robot Software consists of the instructions that control a robot's actions and
provide information regarding required tasks. When a program is written using this
software, the robot is able to execute commands and perform tasks. Programming
robots can be a complex and challenging process, and while it has become easier
over the years, the lack of cross-platform industry standards has affected the
development of software tools for robots compared to other automated control
systems such as programmable logic controllers(PLCs).
Dataflow programming techniques are used by most robot manufacturers, and is
based on the concept that when the value of a variable changes, the values of other
variables affected should also change. A programming language that incorporates
dataflow principles is called adataflow language. In addition to numeric
processing, dataflow languages also incorporate functional concepts. Unlike other
programming languages which use imperative programming, dataflow
programming is modeled as a sequence of functions.
With any programming software, the state of a program at any given time is an
important consideration. The state provides an indication of the various conditions
at a particular instant. In order to function properly, most programming languages
require a significant amount of state information. This information is invisible to
the programmer.
Another key concept which is associated with any type of robot programming, is
the concept of runtime. When a program is running, or executing, it is said to be in
runtime. The term runtime is also used as a short form when referring to a runtime
library, which is a library of code instructions used by a computer language to
manage a program written in the language. The term is also used by software
developers to specify when errors in a program can occur. A runtime error is an
error that happens while the program is executing. For example, if a robot arm was
programmed to turn left, and it turned right, then that would be a runtime error.
The software architecture of a system consists of the various software components
used to design and operate the software. All programming methods rely on
software architecture as a method of organizing a software system since it not only
provides communication support but is also a critical component in hardware and
software interfaces.

Software for industrial robots consists of data objects and lists of instructions,
known as program flow (list of instructions). For example
Go to Jig1
is an instruction to the robot to go to positional data named Jig1. Of course
programs can also contain implicit data for example
Tell axis 1 move 30 degrees.
Data and program usually reside in separate sections of the robot controller
memory. One can change the data without changing the program and vice versa.
For example one can write a different program using the same Jig1 or one can
adjust the position of Jig1 without changing the program which uses it.

Examples of programming languages for Industrial Robots

Due to the highly proprietary nature of robot software, most manufacturers of
robot hardware also provide their own software. While this is not unusual in other
automated control systems, the lack of standardization of programming methods
for robots does pose certain challenges. For example, there are over 30 different
manufacturers of industrial robots, so there are also 30 different robot
programming languages required. Fortunately, there are enough similarities
between the different robots that it is possible to gain a broad-based understanding
of robot programming without having to learn each manufacturer's proprietary
language.
Some examples of published robot programming languages are shown below.

Move to P1 (a general safe position)

Move to P2 (an approach to P3)
Move to P3 (a position to pick the object)
Close gripper
Move to P4 (an approach to P5)
Move to P5 (a position to place the object)
Open gripper
Move to P1 and finish

VAL was one of the first robot languages and was used in Unimate robots.
Variants of VAL have been used by other manufacturers includingAdept
Technology. Stubli currently use VAL3. Example program:

PROGRAM PICKPLACE
1. MOVE P1
2. MOVE P2
3. MOVE P3
4. CLOSEI 0.00
5. MOVE P4
6. MOVE P5
7. OPENI 0.00
8. MOVE P1
.END

Epson RC+ (example for a vacuum pickup)

Function PickPlace
Jump P1
Jump P2
 Jump P3
On vacuum
Wait .1
Jump P4
Jump P5
Off vacuum
Wait .1
Jump P1
Fend

ROBOFORTH (a language based on FORTH).

: PICKPLACE
P1 P3 GRIP P5 UNGRIP P1
;

(With Roboforth you can specify approach positions for places so you do not need
P2 and P4.)
Clearly the robot should not continue the next move until the gripper is completely
closed. Confirmation or allowed time is implicit in the above examples of CLOSEI
and GRIP whereas the On vacuum command requires a time delay to ensure
satisfactory suction.

Other robot programming languages

Visual programming languages
The software system for the Lego Mindstorms NXT robots is worthy of mention. It
is based on and written by Labview. The approach is to start with the program
rather than the data. The program is constructed by dragging icons into the
program area and adding or inserting into the sequence. For each icon you then
specify the parameters (data). For example for the motor drive icon you specify
which motors and by how much they move. When the program is written it is
downloaded into the Lego NXT 'brick' (microcontroller) for test.
Scripting Languages
A scripting language is a high-level programming language that is used to control
the software application, and is interpreted in real-time, or "translated on the fly",
instead of being compiled in advance. A scripting language may be a general-
purpose programming language or it may be limited to specific functions used to
augment the running of an application or system program. Some scripting
languages, such asRoboLogix, have data objects residing in registers, and the
program flow represents the list of instructions, or instruction set, that is used to
program the robot.

RoboLogix Instruction Set.

Programming languages are generally designed for building data

structures and algorithms from scratch, while scripting languages are intended
more for connecting, or gluing, components and instructions together.
Consequently, the scripting language instruction set is usually a streamlined list of
program commands that are used to simplify the programming process and provide
rapid application development.

Parallel languages
Another interesting approach is worthy of mention. All robotic applications need
parallelism and event-based programming. Parallelism is where the robot does two
or more things at the same time. This requires appropriate hardware and software.
Most programming languages rely on threads or complex abstraction classes to
handle parallelism and the complexity that comes with it, like concurrent access to
shared ressources. URBI provides a higher level of abstraction by integrating
parallelism and events in the core of the language semantics.
whenever(face.visible)
{
headPan.val += camera.xfov * face.x
&
headTilt.val += camera.yfov * face.y
}

The above code will move the headPan and headTilt motors in parallel to make the
robot head follow the human face visible on the video taken by its camera
whenever a face is seen by the robot.