Last modified 6 years ago Last modified on 18/06/15 11:24:34

Lab Course "Procedural Reasoning on a Group of Adaptive Mobile Robots" - Winter term 2014/2015 The goal of this lab course is to design, develop and test a task-level reasoning and execution system for a group of mobile robots in a production logistics scenario using OpenPRS. OpenPRS is a Procedural Reasoning System (PRS) implementing the Belief-Desire-Intention (BDI) software model.


  • Paul Dingil
  • Ji Hou
  • Mostafa Ashraf
  • Mostafa Gomaa


  • Tim Niemueller
  • Stefan Schiffer
  • Martin Liebenberg


Recently the Knowledge Based Systems Group have 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 idea for this lab course is to develop and test an alternative approach based on PRS. The basis for the lab course will be our 3D environment simulation for the RoboCup Logistics League. We want the participants' agents to compete against each other and the existing agent. We are interested to see if a PRS could simplify modeling of the robot behavior, provides better or worse extensibility, and the effort required to build a capable agent.



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 Sponsored by Festo (LLSF)

General literature relevant for multi-robot systems.

An Introduction to MultiAgent Systems
(Michael Wooldridge; 2002)
Basic introduction and consideration for multi-agent systems.
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 sponsored by Festo - Rules and Regulations 2014
(RoboCup Logistics League Technical Committee)
The rules of the RoboCup Logistics League as played in 2014.

Procedural Reasoning Systems (PRS)

Literature explaining PRS details and applications.

An architecture for real-time reasoning and system control
(F.F. Ingrand, M.P. Georgeff, A.S. Rao; IEEE Expert Dec 1992)
Describes the architecture of PRS.
An Architecture for Autonomy
(R. Alami, R. Chatila, S. Fleury, M. Ghallab and F. Ingrand; IJRR 1998)
Journal article describing the overall PRS architecture in a larger context (full text available when accessed from RWTH)
PRS: A High Level Supervision and1 Control Language for Autonomous Mobile Robots
(Franpis Felix Ingrand, Raja Chatila, Rachid Alami, Frederic Robert; ICRA 1996)
Describes PRS with the specific focus on autonomous robots.
OpenPRS 1.1b10 Manual
(Felix Ingrand; 2014)
In-depth manual of OpenPRS.

Course Material

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)
  • fawkes/src/plugins/openprs: OpenPRS base plugin, in the data sub-directory you find the OP files, in mod_* the C-part of some.
  • fawkes/src/plugins/openprs-agent: OpenPRS agent plugin which provides the run-time environment for your agent. Again, data and mod_* are most interesting.
  • src/agents/openprs: this is where your agent resides and where you can place your OP, DB, and inc files.
  • src/lua/skills/robotino: skill source files where you can find documentation about the available parameters.
  • src/agents/llsf2014: 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.

Get your agent ready for the competition

The competition gets your agent from the current version of your branch. So be sure to keep it up to date. Furthermore you need to ensure the following things:

  • Set your team name (e.g. Lab-1, Lab-2) in your configuration (cfg/conf.d/openprs-agent.yaml)
  • Merge the current version of the origin/common/praktikum-openprs branch in fawkes-robotino
  • Not now, but before the competition: Merge the current version of the origin/common/praktikum-openprs branch in fawkes
  • Be sure that you can also play as magenta (same team but the refbox assignes you a different color => other set of machines, ins and deliver)

Starting the competition

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

  • Check the configuration file for the automated competition: cfg/gazsim-configurations/automated-competition-conf.bash (especially teamname, your branch, number robots)
  • Check the refbox config (~/llsf-refbox/cfg/config.yaml). Add the missing Team-names and the Crypto-key randomkey for all teams
  • Add export GAZEBO_WORLD_PATH=~/gazebo-models/llsf_world_two_teams/ in your .bashrc
  • Start with ./gazsim-schedule.bash . First it checks out the branches of the teams that are going to play and compiles it. 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 the game does not start automatically, please look into the fawkes-comm console and check if there is a "Static TLS" error. In this case some other packages have to be installed. Just write us.
  • If there are any other problems, write us.

Particular Scenario

to be done


to be done