sot-core Documentation


This library implements a modular architecture to test and experiment controllers in the Stack of Tasks Framework as defined in Mansard2007. It is specifically targeted to retain real-time performance while having high level software capabilities, like plugins and python scripting.

Organization of the code

The code is based on the dynamic-graph package, which provides the framework on which sot-core relies. Hence most of the code in sot-core consists of classes that derive from dynamic_graph::Entity. These entities are usually compiled and linked in their own dynamic library, as a python module

Aside from the python modules, this package installs a core library libsot-core, that provides functions and code common to all modules. All python modules developed here link with libsot-core. For example, common mathematical entities, definitions and functions are in the core library. See Sot-core library (libsot-core.[dll|so]) for a list of what's in this code base.

This library implements

  • A solver for the control law using tasks and features: the stack of tasks
  • The framework of Tasks and Features, as defined in Mansard2007, that
  • Base classes for working with tasks and features, such as special matrices (rotation, twist) and vectors (quaternions, etc.)
  • A basic C++ "machinery", the Factory, that "makes things work"

Using the Stack of Tasks

For people who develop software to control a real robot, this package alone is insufficient to simulate and control a robot.

The following packages are recommended* in that case:

  • sot-dynamic
  • sot-pattern-generator
  • sot-openhrp (openhrp python module)

These packages are in development at the time of writing and may be separated or joined along the way. Please check their status and updates at the jrl-umi3218 web page:

Requirements and Installation

This package should be compiled and installed with cmake.

This library is based on several packages:

Their presence will be checked with the use of pkg-config.

Core library

This package is centered around a core library that implements the basic classes needed for operation of the stack of tasks. For more information, see Sot-core library (libsot-core.[dll|so]).

Python Modules

While the main library provides a basic framework for computation of a control law using the Stack of Tasks, it is not expressive enough for typical usage scenarios (for example, controlling a humanoid robot). Hence, several "specialized" features and tasks have been developed, and can be used in the Stack of Tasks. For a list of python modules and a short description, see List of python modules.

Operation of the stack of tasks


As explained in Mansard2007, tasks can be pushed on the stack of tasks (SoT), and thus assigned a priority. The SoT then calculates (in an iterative manner) the control law, or joint velocity, necessary to realize the tasks (usually, bring a feature to its desired value).


Each feature computes some information from measurements, from the robot state,or/and from others features. Features should be lightweight regarding computation and be included at this level only if necessary. See documentation of class dynamicgraph::sot::FeatureAbstract for more information.


Each task implements a specific controller which can be a free space task, visual servoing, a constraint, and so on ... a task is mainly defined by the feature it is handling and its gain.

After being defined, tasks are pushed in the Stack of Tasks which then calculates a control law as explained in Mansard2007.

See documentation of class dynamicgraph::sot::TaskAbstract for more information.


"Task sequencing for sensor-based control", N. Mansard, F. Chaumette, IEEE Trans. on Robotics, 23(1):60-72, February 2007

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines