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.
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
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:
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: https://github.com/jrl-umi3218
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.
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]).
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.
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.