Last modified 4 years ago Last modified on 26/01/17 14:04:48

Skill Execution Runtime

This plugin implements the concepts of the Lua-based Behavior Engine. It provides the integration for the Lua code to embed into the Fawkes main loop. Skills are modeled as hybrid state machines.

The skiller typically is the (only) interface for action execution to high-level reasoning and planning components.

The core of the skiller is implemented in pure Lua. This plugin only provides the outer shell and integration with Fawkes. The execution, monitoring, and management of skills is performed in Lua only.

For more specific information on writing skills, please refer to the BehaviorEngine page.


The current version of the skiller plugin requires Lua 5.1 or 5.2, it is not currently compatible with 5.3 (mostly due to changes in the way modules are handled).

There is an optional requirement for ROS, which allows to deeply integrate the skiller with ROS through the use of roslua. However, due to some deficiencies in roslua, this is only compatible up to ROS Fuerte at this time (check the roslua repository for updates).

The skiller provides a domain-specific set of skills (see below) which may have particular dependencies to other Lua modules, plugins, or ROS nodes. This is must be documented per skill or on the respective skill space overview page.

BlackBoard Interfaces

  • SkillerInterface::skiller (writing): Skill status information and messaging for controller registration and skill execution.

In addition, the skills may specify any reading or writing interface instances to communicate with the remaining system.

Skills and Skill Spaces

Skills are reactive behavior entities which fulfill a particular sub-task which involves on local (tactic) decisions, not global (strategic) ones which alter the overall task structure. Skills are implemented as hybrid state machines (cf. BehaviorEngine) and can be structured hierarchically (skills may call other skills, as long as no cyclic dependency is introduced).

A skill space denotes a particular set of skills which is domain- and platform dependent. While there are some generic skills, most skills are specific to their deployment.

Example skill spaces:

Calling and Executing Skills

From the outside, skills are represented as a simple function, or more precisely, a Lua skill string consisting of one (or potentially more) such function calls, for example ppgoto{place="Kitchen-Counter"} could call a skill that instructs (and monitors) components to go to a place named "Kitchen-Counter". Typically, a skill string consists of a single function representing the one skill to execute. In the following, we assume make the assumption that this is the case and will use "skill string", "skill", and "skill function" interchangeably.

A skill string is executed by sending a SkillerInterface::ExecSkillMessage via the SkillerInterface "skiller". Typically, this is done by an executive that determines the course of action. Especially during development, skills can be executed through the SkillGUI?. In addition to ordering skill execution, it also allows to monitor the state machines of the skills on-line, manage plugins, and read the log.

During execution, the skill string is evaluated in every iteration of the main loop. The function, however, is embedded into a state context. Each call will thus evaluate the state machine once (cf. BehaviorEngine). The status of the execution is conveyed through the blackboard. INACTIVE means no skill is running, FINAL is that it succeeded, FAILED that the execution could not be completed, an error message may be provided, and RUNNING if the skill is currently in operation.

The skiller implements an exclusive controller pattern. At any one time, it will accept execution commands from only one other component (blackboard interface reader). That reader must have acquire the exclusive control. This is granted if there is no other controller at the moment, otherwise denied. There is an option to "steal" the exclusive control. This is useful especially during the deployments of an autonomous executive to ensure that it always gains control once loaded. The SkillGUI will automatically try to acquire exclusive control upon connecting (indicated by the button at the top), which is one of the reasons why stealing control is useful in executives.


  # Skill space
  skillspace: test

  # Watch lua files for modification and automatically reload
  # Lua if files have been changed; true to enable
  watch_files: true

  # Feature-specific configuration

      # Enable access to navgraph, adds a dependency on the navgraph
      # plugin such that a valid graph must be loaded first
      enable: false

      enable: false

Note, to execute without ROS, disable ROS here. Also note that if using the navgraph feature this might again depend on ROS. So make sure to disable it for the navgraph plugin, too.

Usage Instructions

This will demonstrate the basic workflow using the core repository, the test skill space, and the flite speech synthesis plugin.

First, run Fawkes and load the respective modules.

bin/fawkes -p flite,skiller

Then use either SkillGUI? or the skillet console tool to execute the following skill string:

say{text="Hello World", wait=true}

The wait parameter will cause the skill to finish only after completing the utterance. Without, it will return as soon as it instructed the component to synthesize the sentence. Note that the parameters are passed by name, rather than as positional arguments. While the skiller technically supports both, it has proven useful to use the more verbose form to better explain what is going on.

ROS Integration

The skiller may be integrated deeply with ROS. For one, it can participate as a separate ROS node to access any features provided through the ROS middleware. For another, through the additional ros-skiller plugin it allows for providing skill execution and status reporting from and to ROS.

To enable deep ROS integration through roslua, you must have roslua installed and working on your system. Then set the config value /skiller/features/ros/enable: true in skiller.yaml. Then, skills can be extended with depends_topics, depends_services etc. and use all of roslua's features to interact with ROS.

Note that the deep ROS integration is independent of the ros plugin. Through roslua, it creates its own and independent ROS node.

See the ros-skiller documentation on how to call and monitor skills from ROS.