Research plan 2008-2010

Task 1: Development of control architectures for individual and multiple GIM system

The starting point of the development work is the currently most widely-used control architecture, the hybrid deliberative/reactive architecture. The five elementary modules normally present in it are: mission planner, sequencer agent, behavioural (resource) manager, cartographer, and performance monitoring & problem-solving agent.

The hierarchical deliberative system consists of a mission planner, cartographer, and a sequencer agent. This system is coupled to the reactive controller. The highest level is the mission planner, which elaborates the high-level goals given, for example, by the operator. It uses a priori knowledge (for example, from the cartographer that stores the long-term environment information) to come up with a sequence of sub-paths that the robot must travel in order to complete its mission. The sequencer agent will then translate each of these sub-paths into a set of motor behaviours. After that these sets are sent to the behaviour manager, which controls the actuators and uses the sensors.

The deliberative part “sleeps” until a failure has been detected by the performance monitoring & problem-solving agent. In the event of a failure the deliberative part tries to correct the situation. This happens through re-invoking one stage at a time, starting from the sequencer agent. If it cannot solve the problem the mission planner will contact the operator in order to get help.

The above framework, in one form or another, has been tested in various applications; however, further extensive testing and evaluation are required. The best components from available systems will be considered and used as building blocks for GIM’s future standard control architecture.

Multiple GIM - special considerations

The use of a single robot/intelligent machine in a well-defined problem in a stable and structured environment is usually much more economically sound than the configuration of a multi-machine system. Unfortunately, the world in which most mobile machines are operating is neither stable nor structured. That is the basic reason why the trend in intelligent machines, and especially in robotics, is currently heading towards multi-robot systems.

Furthermore, in many cases, the breaking down of a complex task into parallel sub-tasks is the only reasonable approach or at least speeds up the performance. In some cases, such as several machines working on the same sub-task, it can also increase the redundancy of the system. Redundancy itself can be of the utmost importance in certain special applications, such as in long-term and highly expensive planetary missions.

Other natural domains for multi-robots are tasks where the environmental conditions set some limitations, for example for the size of the robot. In such cases the only possible solution is to divide in some way the individual robot into several smaller robots. As an example, one can consider an environment where the robot has to go through some very tight spots, such as in a nuclear power plant, where a cleaning task has to be performed inside a highly radioactive area. In addition, there can be tasks where successful completion of the mission requires close cooperation between the robots, for example when small robots are collectively carrying a large object. The performance of a task like this is far from being trivial. It requires some sort of interaction between robots, whether it is direct communication, for instance through radio transmissions, or indirect communication, such as through sensing the forces in the object to be transported.

The first objective of this research task is to find alternative and optimal system architectures for the multi-robot/multi-entity systems considered above. When designing these multi-robot systems, some fundamental problems need to be solved. These elementary problems include at least the following:

  • How do we formulate, describe, break down, and allocate problems among a group of intelligent robots?
  • How do we enable robots to communicate and interact?
  • How do we ensure that robots act coherently in their actions?
  • How do we allow robots to recognize and reconcile conflicts?

To answer these questions some new generic control architectures for distributed autonomous robotic or intelligent machine systems will be studied and developed. Questions such as whether we should build up the system from identical units or specify clusters of different types of units having different sensing and communication capabilities, or what the optimal communication structure between the units and between the units and the base station is, are of primary interest.

Expected results: new control architectures and design principles for GIM software

Task 2: Definition and development of a standard internal command language for GIM

In the future, the use of an intelligent machine should be as easy as possible, especially when controlling multiple machines. One way to do it is to use natural language-type command language. In this task a standard internal script language (SICL) will be developed for the use of GIM.

SICL should make it easier for the operator to design a new task for intelligent machines. It should act as a link from the user or from an intelligent mission planner to the machine’s behaviour manager. It should offer all the features that are required to control the machine effectively. These features contain naturally sequential and concurrent task execution and fast responses to exceptions.

SICL should be used with some higher-level abstract languages, such as sign language or even natural spoken language. The set of elementary commands in SICL should support the use of natural language, and therefore cooperation between SICL and the high-level mission planner should be easy to obtain. The operator should be able to use SICL commands directly to control the machine or to create subtasks as scripts of SICL commands.

Expected results: a standard internal script language for GIM to facilitate software structuring and subsystem utilization processes.