Reflexxes Motion Libraries: Description of Input Values

The input values of the position-based On-Line Trajectory Generation (OTG) algorithm are set-up through the classes RMLPositionInputParameters and RMLPositionFlags, and the input values of the velocity-based On-Line Trajectory Generation algorithm are set-up through the classes RMLVelocityInputParameters and RMLVelocityFlags. For a detailed description of these classes, please refer to the class documentation, and for a description of the output values, please refer to the Description of Output Values.

This page contains three sections:

Input Values for the Position-based On-Line Trajectory Generation Algorithm

Input and output values of the position-based Type II On-Line Trajectory Generation algorithm of the Reflexxes Motion Libraries.

The position-based Type II On-Line Trajectory Generation algorithm is executed by a call of ReflexxesAPI::RMLPosition(). The input values for the algorithm at a time instant $ T_i $ are contained in RMLPositionInputParameters:

the current state of motion consisting of
- the current position/pose vector $\vec{P}_i \ \Longrightarrow \$ RMLPositionInputParameters::CurrentPositionVector and
- the current velocity vector $\vec{V}_i \ \Longrightarrow \$ RMLPositionInputParameters::CurrentVelocityVector,
the kinematic motion constraints consisting of
- the current maximum velocity vector $\vec{V}_i^{\,max} \ \Longrightarrow \$ RMLPositionInputParameters::MaxVelocityVector and
- the current maximum acceleration vector $\vec{A}_i^{\,max} \ \Longrightarrow \$ RMLPositionInputParameters::MaxAccelerationVector,
the target state of motion consisting of
- the target position/pose vector $\vec{P}_i^{\,trgt} \ \Longrightarrow \$ RMLPositionInputParameters::TargetPositionVector and
- the target velocity vector $\vec{V}_i^{\,trgt} \ \Longrightarrow \$ RMLPositionInputParameters::TargetVelocityVector,
the boolean selection vector $\vec{S}_i \ \Longrightarrow \$ RMLPositionInputParameters::SelectionVector, and
an optional value for the minimum synchronization time $\vec{S}_i \ \Longrightarrow \$ RMLPositionInputParameters::MinimumSynchronizationTime.

Each vector contains the values for all degrees of freedom $1,\,\dots,\,K$ , for instance,

$\vec{P}_i\ =\ \left(\,\!_1P_i,\,\dots,\,_kP_i,\,\dots,\,_KP_i\right)^T$

such that the current position value of the degree of freedom with the index $ k $ is represented by $ _kP_i $ .

The selection vector $\vec{S}_i$ can be used to mask degrees of freedom individually. If the value of $ _kS_i $ is false, the degree of freedom with the index $ k $ will not be considered by the algorithm.

Besides the input values RMLPositionInputParameters, the class RMLPositionFlags can be used to determine and obtain a certain behavior. The following flags may be used:

A first and simple example that shows, how the position-based input values are commonly set-up, please refer to the Example 1 — Introduction to the Position-based algorithm. A description of the output values of this example can be found at the page Description of Output Values. Please also refer to the Section Input Requirements for Numerical Stability, which describes the input domains of the algorithm.

Note:

The variables

RMLPositionInputParameters::CurrentAccelerationVector (containing the the current acceleration vector $\vec{A}_i$ and
RMLPositionInputParameters::MaxJerkVector (containing the maximum jerk vector $\vec{J}_i^{\,max}$

are only used by the Type IV Reflexxes Motion Library.

See also:: RMLPositionInputParameters; RMLPositionFlags; Description of Output Values

Input Values for the Velocity-based On-Line Trajectory Generation Algorithm

Input and output values of the velocity-based Type II On-Line Trajectory Generation algorithm of the Reflexxes Motion Libraries.

The velocity-based Type II On-Line Trajectory Generation algorithm is executed by a call of ReflexxesAPI::RMLVelocity(), and its input values are the very same as for the position-based algorithm (see above), but the values for the target position $_kP_i^{\,trgt}$ and the maximum velocity vector $\vec{V}_i^{\,max}$ are not considered, and the flag RMLPositionFlags::KeepCurrentVelocityInCaseOfFallbackStrategy is not available.

The input values for the velocity-based algorithm at a time instant $ T_i $ are contained in RMLVelocityInputParameters:

the current state of motion consisting of
- the current position/pose vector $\vec{P}_i \ \Longrightarrow \$ RMLVelocityInputParameters::CurrentPositionVector and
- the current velocity vector $\vec{V}_i \ \Longrightarrow \$ RMLVelocityInputParameters::CurrentVelocityVector,
the kinematic motion constraints consisting of
- the current maximum acceleration vector $\vec{A}_i^{\,max} \ \Longrightarrow \$ RMLVelocityInputParameters::MaxAccelerationVector,
the target state of motion consisting of
- the target velocity vector $\vec{V}_i^{\,trgt} \ \Longrightarrow \$ RMLPositionInputParameters::TargetVelocityVector,
the boolean selection vector $\vec{S}_i \ \Longrightarrow \$ RMLVelocityInputParameters::SelectionVector, and
an optional value for the minimum synchronization time $\vec{S}_i \ \Longrightarrow \$ RMLVelocityInputParameters::MinimumSynchronizationTime.

Besides the input values RMLVelocityInputParameters, the class RMLVelocityFlags can be used to determine and obtain a certain behavior. The following flags may be used:

A first and simple example that shows, how the velocity-based input values are commonly set-up, please refer to the Example 4 — Introduction to the Velocity-based algorithm. A description of the output values of this example can be found at the page Description of Output Values. Please also refer to the Section Input Requirements for Numerical Stability, which describes the input domains of the algorithm.

Note:

The variables

RMLPositionInputParameters::CurrentAccelerationVector (containing the the current acceleration vector $\vec{A}_i$ and
RMLPositionInputParameters::MaxJerkVector (containing the maximum jerk vector $\vec{J}_i^{\,max}$

are only used by the Type IV Reflexxes Motion Library.

Note:: The velocity-based algorithm is also used in the second layer of the safety mechanism to guarantee valid output value for any given set of input values (cf. Safety: Three Layers of Error Handling).

See also:: RMLVelocityInputParameters; RMLVelocityFlags; Description of Output Values

Input Requirements for Numerical Stability

In order to assure feasibility and numerical stability, two basic conditions have to be fulfilled for each selected degree of freedom $ k $ in order to obtain correct output values:

The maximum velocity and the maximum acceleration must be greater than zero:
- $_kV_i^{\,max} \ > \ 0$
- $_kA_i^{\,max} \ > \ 0$
For the position-based algorithm, the elements of the maximum velocity vector $\vec{V}_i^{\,max}$ has to be greater or equal to the elements of the target velocity $\vec{V}_i^{\,trgt}$ .
$_kV_i^{\,trgt}\ \le \ _kV_i^{\,max}\ \forall\ \left\{1,\,\dots,\,K\right\}$
All input values have to be within a certain range of magnitude. For the position-based algorithm this is range is specified by
$\frac{\displaystyle \mbox{max}\left( \,\!_kA_i^{\,max}, \, \,\!_kV_i^{\,max}, \, \left|\,\!_kP_i\right|, \, \left|\,\!_kP_i^{\,trgt}\right|, \, \left|\,\!_kV_i\right| \right)}{\displaystyle \mbox{min}\left(\,\!_kA_i^{\,max}, \, \,\!_kV_i^{\,max} \right)} \ \le\ 10^8$
and for the velocity-based algorithm
$\frac{\displaystyle \mbox{max}\left( \,\!_kA_i^{\,max}, \, \left|\,\!_kP_i\right|, \, \left|\,\!_kV_i^{\,trgt}\right|, \, \left|\,\!_kV_i\right| \right)}{\displaystyle \mbox{min}\left(\,\!_kA_i^{\,max} \right)} \ \le\ 10^{10}$

Note:

Although this condition looks like a limitation, in real-world systems it does not lead to a disadvantage, because the range of eight orders of magnitude should be very sufficient for any application. As the velocity-based algorithm is much simpler from a numerical point of view, ten orders of magnitude are allowed here.
If this condition is not fulfilled, the Type II Reflexxes Motion Library will try to provide correct output values, and in many cases this will be possible, but no guarantee can be given. Valid output values that lead to steady, continuous and jerk-limited motion trajectories are guaranteed in any case (cf. Safety: Three Layers of Error Handling).

Example for a set of valid input values for one degree of freedom at time instant used for the position-based algorithm:

$\begin{array}{rcl} _kV_i^{\,max}&=&10000000\\[2ex] _kA_i^{\,max}&=&500\\[2ex] _kP_i&=&25\\[2ex] _kV_i&=&-35\\[2ex] _kP_i^{\,trgt}&=&5\\[2ex] _kV_i^{\,trgt}&=&5000\\[2ex] \end{array}$

Reason: $\frac{\displaystyle _kV_i^{\,max}}{\displaystyle _kP_i^{\,trgt}} \ =\ \frac{\displaystyle 10^7}{\displaystyle 5}\ =\ 2\cdot10^6\ \le 10^8$ .

Example for a set of invalid input values for one degree of freedom at time instant used for the position-based algorithm:

$\begin{array}{rcl} _kV_i^{\,max}&=&10000000\\[2ex] _kA_i^{\,max}&=&0.001\\[2ex] _kP_i&=&25\\[2ex] _kV_i&=&-35\\[2ex] _kP_i^{\,trgt}&=&5\\[2ex] _kV_i^{\,trgt}&=&5000\\[2ex] \end{array}$

Reason: $\frac{\displaystyle _kV_i^{\,max}}{\displaystyle _kA_i^{\,max}} \ =\ \frac{\displaystyle 10^7}{\displaystyle 10^{-3}}\ =\ 10^{10}\ \not\leq 10^8$ .

The check, whether the input values are valid, can be done with the methods RMLPositionInputParameters::CheckForValidity() and RMLVelocityInputParameters::CheckForValidity().