Last modified 4 years ago Last modified on 03/29/16 11:09:00

Lab Course: Distributed Task Planning for a Group of Mobile Robots - Winter term 2015/2016 The goal of this lab course is to design, develop and test a distributed task planning system for a group of mobile robots in a production logistics scenario.


to be announced


  • Tim Niemueller
  • Martin Liebenberg


The Knowledge Based Systems Group has implemented an autonomous agent competing in the RoboCup Logistics League as part of the Carologistics RoboCup Team. In our specific case a rule set describes a "production game" where robots must operate production lines. The CLIPS-based agent is implemented using the rule-based reasoning system CLIPS.

The presented approach follows a local-scope, incremental, distributed approach. That means that each robot plans individually (distributed) only for itself (local-scope) and only for the next action to take (incremental). The idea for this lab course is to develop and test an alternative approach based distributed planning which especially means going from incremental action determination to full plan generation (multiple steps into the future) and to extend the local scope towards a global one, i.e. coordinate plans such that the strategies are (more) optimal and free of resource conflicts for the overall group of robots.

The basis for the lab course will be our 3D environment simulation for the RoboCup Logistics League. We want the participants' planning systems to compete against each other and the existing agent. We are interested to learn about the modeling requirements of a distributed planning system and if it provides better or worse extensibility and performance.

If you want to test things right now you can use our software release for 2014.



This section contains references that describe the systems that drive our robots and simulation.

Design Principles of the Component-Based Robot Software Framework Fawkes
(Tim Niemueller, Alexander Ferrein, Daniel Beck, Gerhard Lakemeyer; SIMPAR 2010)
Overview of the robot software framework Fawkes.
A Lua-based Behavior Engine for Controlling the Humanoid Robot Nao
(Tim Niemueller, Alexander Ferrein, Gerhard Lakemeyer; RoboCup Symposium 2009)
Paper about the Lua-based Behavior Engine, the mid-level reactive behavior layer that the agent instructs for skill execution.
Incremental Task-level Reasoning in a Competitive Factory Automation Scenario
(Tim Niemueller, Gerhard Lakemeyer, Alexander Ferrein; AAAI Spring Symposium 2013)
Description of the infrastructure used for the CLIPS-based agent.
Simulation for the RoboCup Logistics League with Real-World Environment Agency and Multi-level Abstraction
(Frederik Zwilling, Tim Niemueller, Gerhard Lakemeyer; RoboCup Symposium 2014)
Overview and principles of the Gazebo-based simulation for the RoboCup Logistics League.
The Carologistics RoboCup Logistics Team 2014
(Tim Niemueller, Sebastian Reuter, Daniel Ewert, Alexander Ferrein, Sabina Jeschke, Gerhard Lakemeyer; RoboCup 2014)
Description of the major features of the Carologistics RoboCup Team's robot systems.

Multi-robot systems (MRS) and RoboCup Logistics League (RCLL)

General literature relevant for multi-robot systems.

An Introduction to MultiAgent Systems
(Michael Wooldridge; 2002)
Basic introduction and consideration for multi-agent systems.
The RoboCup Logistics League as a Benchmark for Planning in Robotics
(Tim Niemueller, Gerhard Lakemeyer, Alexander Ferrein; 2015)
Characterization of the RCLL as a planning domain and explanation of terminology, e.g. local vs. global scope.
RoboCup Logistics League Sponsored by Festo: A Competitive Factory Automation Testbed
(Tim Niemueller, Daniel Ewert, Sebastian Reuter, Alexander Ferrein, Sabina Jeschke, Gerhard Lakemeyer; RoboCup Symposium 2013)
Description of the RoboCup Logistics League, covers the basics and game-specifics of 2013.
Proposal for Advancements to the LLSF in 2014 and beyond
(Tim Niemueller, Gerhard Lakemeyer, Alexander Ferrein, Sebastian Reuter, Daniel Ewert, Sabina Jeschke, Dirk Pensky, Ulrich Karras; WDRL at ICAR 2013)
Description of the changes in the LLSF in 2014 and in part 2014.
RoboCup Logistics League - Rules and Regulations 2015
(RoboCup Logistics League Technical Committee)
The rules of the RoboCup Logistics League as played in 2015.

Distributed Planning Systems

Literature explaining distributed planning systems and their applications.

Multi-Robot Coordination Through Incremental Plan-Merging
(R. Alami, F. Robert, F.F. Ingrand, S. Suzuki; ICRA 1995)
Describes one approach by means of the plan-merging paradigm.
Multi-robot cooperation in the MARTHA project
(R. Alami, S. Fleury, M. Herrb, F.F. Ingrand, F. Robert; IEEE Robotics & Automation Magazine, vol. 5, issue, Mar 1998)
A particular application scenario for plan-merging. MARTHA EU cordis esprit info
A general framework for multi-robot cooperation and its implementation on a set of three Hilare robots (PDF)
(R. Alami, L. Aguilar, H. Bullata, S. Fleury, M. Herrb, F. Ingrand, M. Khatib, F. Robert)
Plan merging paradigm with some code that shows how missions and plans are represented (leans on PRS).
A Software component for simultaneous plan execution and adaptation
(S. Joyeux, R. Alami, S. Lacroix; IROS 2007)
An extended approach based on a plan database pDB. This is what the roby plan management is based on.
A Plan Manager for Multi-robot Systems
(S. Joyeux, R. Alami, S. Lacroix, R. Philippsen; IJRR vol. 28 no. 2, February 2009)
Based on the plan database but with a more elaborate focus on multi-robot systems.

Source Code

Implementation of the plan manager. git doc
Procedural Reasoning System used for supervisor in plan merging git
OpenPRS agent
Agent from last lab course, see fawkes-robotino/src/agents/openprs in the labprogramr git branches in the fawkes-robotino repository.

Source Files of Interest

Here are a few hints where to look for certain things.

  • cfg/conf.d: configuration files, in particular openprs-agent.yaml (e.g. to set mode to XOPRS for introspection)
  • src/lua/skills/robotino: skill source files where you can find documentation about the available parameters.
  • src/agents/llsf2015: the current clips-agent. Here you can see how protobuf msgs can be created and which interfaces and skills you may also want to use.
  • cfg/gazsim-configurations/default/host_robotino_X.yaml: Here you can override default config-values for the three robot instances. (Might be interesting for later coordination.)

First Milestone: Exploration

To get the exploration running, we discussed the following steps:

  1. get used to the system and have the agent drive to certain places
  2. react to the GameState message (cf. net.clp) and drive to the place when the game state changes to RUNNING.
  3. Listen to the ExplorationInfo message and store information about which machines are your own in the database.
  4. If the phase of the refbox is set to EXPLORATION and state is RUNNING drive to all of your own machines (not including the recycling and delivery machines, of course) one after another.
  5. Open the light signal interface. When you have reached a machine, stand still and wait until the light signal visibility history is above 30, then read the signal state and remember it.
  6. Map the recognized light signals to types using the information received in the ExplorationInfo message. Then periodically send a MachineReport message with your recognized machines and their types.
  7. Split the machines to drive to to the overall groups of robots. For example, you can have them driving "rows" of the machines that you calculate based on the ExplorationInfo.

Starting the System

You can find the scripts to start the simulation in ~/fawkes-robotino/bin:

  • "./gazsim.bash -x start -n 1 -m m-openprs" starts the simulation with the refbox, and one Fawkes-instance to control one robot.
  • "./skillgui" starts the skillgui to try out and monitor skills or load plugins (e.g. the openprs-agent).
  • "rosrun rviz rviz" starts the ros-visualization where you can see the navgraph and localize the first robot.
  • "./gazsim-publish-initial-pose -d" localizes all robots on the default start positions.
  • in any browser: Fawkes-Webview for robot number X. Here you can look into interfaces (e.g. detected light-signal in RobotinoLightInterface:/machine-signal/best) and also start plugins.

How to test playing as Magenta

  • In the ~/gazebo-rcll, fetch and merge origin/fzwilling/two-teams
  • In ~/.bashrc change GAZEBO_WORLD_PATH to ~/gazebo-rcll/worlds/carologistics/
  • Start Simulation in fawkes-robotino/bin with ./gazsim.bash -x start -r -n 3 -f 4 -m your-meta-plugin
  • When you use robot-specific configurations, you may need to change config values in fawkes-robotino/cfg/gazsim-configurations/default/host-robotino[4|5|6].yaml

Starting the competition

To start the competition you need to checkout the branch origin/fzwilling/current-praktikum-competition.

  • Check the configuration file for the automated competition: cfg/gazsim-configurations/automated-competition-conf.bash (especially teamname, your branches, number robots)
  • Check the refbox config (~/llsf-refbox/cfg/config.yaml). Add the missing Team-names and the Crypto-key randomkey for all teams
  • In ~/.bashrc change GAZEBO_WORLD_PATH to ~/gazebo-rcll/worlds/carologistics/
  • Start with ./gazsim-schedule.bash . First, it checks out the branches of the teams that are going to play and compiles them. That might take a while. If you want to skip this step when you start it a second time add the flag "-d".
  • The results can be seen in the console or in the result file in ~/gazsim-automated-competition
  • If there are any other problems, write us.

Meetings and Milestones

  • 2015/10/06: introductory meeting (slides)
  • 2015/10/13: first hands-on session, base software running


to be done