c-rob++ exploits code synthesis from high level intuitive and convenient multi-body system (MBS) model descriptions. It relies on an object-oriented C++ library of MBS components tailored to the computations required for example in robot control such as forward and inverse kinematics, and inverse dynamics.
The main goal of c-rob++ is to fulfil the demands for fast computations and robust evaluations needed in a real-time environment. Furthermore, the hierarchical class concept can help to reduce modelling efforts and enables non-domain engineers to synthesize code from high-level model descriptions without sacrificing performance. It also allows high level analysis to operate on the model to verify its functional correctness.
The mechanical structure from which c-rob++ generates the code can be any arbitrary mechanical system. Here, the mechanical structure is described by means of a multi-body robotic model that can contain kinematic loops, see below figure, which are solved analytically for a certain class of loop structures or be of tree structure (second figure below).
The robot is approximated by a rigid MBS representation, i.e. a set of
- joints (revolute, prismatic, etc.),
- rigid links and bodies,
- springs, dampers, and external forces,
- drive-trains, and
- custom-specific or more abstract parts.
Relations between objects of a MBS model are established by a connection. The MBS interpretation of a connection is a modeled physical interaction between two or more components, e.g., the direct physical contact of two bodies in one certain coordinate frame.
This interconnection of several components is illustrated in the below figure for a generic robotic structure.
In order to synthesize a complete application from the above model several steps are necessary. An additional object is introduced, the Manipulator, that
- creates a set of run-time primitive objects and connects them according to the model description given either by code or by a textual representation,
- interprets the description to prohibit non-physical configurations in addition to the input-output semantics,
- detects special configurations such as kinematic loops and singularities,
- forms a graph describing the connections between the run-time primitives as required for the parameterization of the domain specific solvers. These manage computations and data-flow in the graph of executable instances of the model primitives in order to compute the desired quantities.
- is an interface function to provide user-friendly access to the solvers (forward and inverse kinematic, inverse dynamic).
This Manipulator is the domain specific code generator that maps the model description to an executable application.
In summary, a directed graph of computational nodes (executable instances of transmission objects) and data-flow edges, together with the solver objects prepared by the Manipulator, which in fact are mere data-flow managers, forms the run-time computational model. The Manipulator keeps all structural information about the model. It is therefore able to perform model reconfiguration during run-time, e.g., in case of tooling of a manufacturing robot or treatment of contact dynamics, when picking a part with a dextrous robot hand. Because of the modular conception of the library it is possible to remove an existing connection between two components of the current model.
This approach starts from the model definition to include as many MBS specific constraints as possible, and integrates several parts of the code generator in one object, the Manipulator. This results in a small and handy library, that is inherently applicable on all platforms providing a C++-compiler and that can be integrated easily in existing applications.
Robert Höpler and Martin Otter, "A Versatile C++ Toolbox for Model Based, Real Time Control Systems of Robotic Manipulators", Proceedings of the 2001 IEEE/RSJ.