Robotic programming languages

Many robotic controllers are implemented using special programming languages. For example, many programs for generalizing architecture were implemented in the language of behavior that was defined by Brooks. This language is a rule-based, real-time control language, the result of which is compiled from AFSM controllers. Separate rules of this language, defined using a syntax similar to Lisp , are compiled into AFSM automata, and groups of AFSM automata are combined using a combination of local and global message transfer mechanisms.

As well as the generalized architecture, the language of behavior is limited, since it aims to create simple AFSM automata with a relatively narrow definition of the communication flow between modules. But recently, on the basis of this idea, new research has been carried out, which led to the creation of a number of programming languages ​​that are similar in spirit to the language of behavior, but more powerful and ensure faster execution.

One of these languages ​​is the universal robotic language , or abbreviated GRL (Generic Robot Language). GRL is a functional programming language for creating large modular control systems. As in the language of behavior, the GRL uses state machines as the main building blocks. But as a setting over these automata, the GRL language offers a much wider list of constructs for defining the communication flow and synchronizing constraints between different modules than the language of behavior. GRL programs are compiled into effective programs in command languages ​​such as C.

Another important programming language (and its associated architecture) for parallel robotic software is the reactive action planning system, or abbreviated as RAPS (Reactive Action Plan System). RAPS allows programmers to set goals, plans related to these goals (or partially define a policy), and also to set the conditions under which these plans are likely to be successfully completed.

It is extremely important that the RAPS system also provides means to cope with the inevitable failures that occur in real-world robotic systems. The programmer can define procedures for detecting different types of failures and provide for a procedure to eliminate the exception for each type of failure. In three-tier architectures, RAPS is often used at the executive level, which makes it possible to successfully cope with unforeseen situations that do not require rescheduling.

There are also several other languages ​​that provide the use of reasoning and learning tools in robots. For example, Golog is a programming language that allows for perfect interaction between the means of algorithmic problem solving (planning) and reactive control tools specified directly by means of a specification.

Golog programs are formulated in terms of situational calculus with the additional possibility of using operators of nondeterministic actions. In addition to the specification of a control program with non-deterministic action capabilities, the programmer must also provide a complete model of the robot and its environment.

As soon as the control program reaches the point of non-deterministic choice, the scheduler (specified in the form of the theorem proof program) is called to determine what to do next. Thus, the programmer can determine partially defined controllers and rely on the use of built-in schedulers to make a final choice of management plan.

The main attractive feature of the Golog language is the immaculate integration of the means of reactive control and algorithmic control provided for in it. Despite the fact that when using the Golog language, one has to comply with strict requirements (complete observability, discrete states, full model), using this language, high-level controls were developed for a number of mobile robots intended for indoor use.

The JSk CES language (short for C ++ for embedded systems - C ++ for embedded systems) is a C ++ language extension that combines probabilistic tools and learning tools. CES data types include probability distributions that allow a programmer to perform calculations using unspecified information without spending the efforts that are usually associated with the implementation of probabilistic methods.

More importantly, the CES language provides for the configuration of robotic software using training based on examples, much the same way as is done in the learning algorithms. The CES language allows programmers to leave “gaps” in the code, which are filled with learning functions; usually such gaps are differentiable parametric representations, such as neural networks. In the future, at individual stages of learning, for which the teacher must specify the desired output behavior, inductive learning takes place using these functions. Practice has shown that the CES language can be successfully applied in problem areas characteristic of a partially observable and continuous environment.

The ALisp language is an extension of the Lisp language. The ALisp language allows programmers to specify nondeterministic selection points, similar to the selection points in the Golog language. But in the ALisp language, for decision-making, it is not the program to prove theorems that is used, but the means for determining the correct action through inductive learning, which use reinforcement training. Therefore, the ALisp language can be considered as a convenient way of introducing knowledge about the problem area into the reinforcement learning procedure, especially knowledge about the hierarchical structure of the “procedures” of the desired behavior. Until now, the ALisp language has been used to solve problems of robotics only in simulation studies, but it can become the basis of a promising methodology for creating robots capable of learning as a result of interaction with its environment.