#### Motivation

This work is motivated by the desire of integrating sensors in robotic environments.
The generation of command variables for robtic manipulators has two functions: specification of the
geometric path *(path planning)* and specification of the
progression of position, velocity, acceleration, and jerk in
dependence of time *(trajectory planning)*. The literature
provides a very rich set of approaches and algorithms in both
fields, which can be subdivided into many sections. But there is no approach at all, which
enables the generation of trajectories starting from any state of motion. This is one very essential
requirement when integrating sensors into robot work cells with the aim of realizing sensor-guided and
sensor guarded motions. The robot has to react on sensor events within one control cycle only, and hence
trajectory parameters can change arbitrarily. To comply with these demands the trajectory generator must be
able to handle and proceed with arbitrary input values. Furthermore, its output values have to result in a
jerk-limited, time-optimal, and synchronized trajectory.

#### Scope

Here the addressed field of trajectory generation can be outlined concretely as:- The
*input values*for the trajectory generator are completely*arbitrary*, i.e. except the position vector of the last control cycle, the velocity vector of the last cycle, and the respective acceleration vector all values may change from one control cycle to another. This means that the target position vector, the target velocity vector, the max. velocity vector, the max. acceleration vector, and the max. jerk vector are neither considered as constant nor as continuous. - The trajectory is calculated
*on-line*, i.e. in real-time during*every*control cycle. Because the input values may change unpredictably, only the next state of motion, i.e. position, velocity, and acceleration vectors, is calculated within one control cycle. *Synchronization:*For trajectories a*N*-dimensional space is considered, where*N*is the number of degrees of freedom. In general the output vectors for position, velocity, and acceleration can be mapped to any space. Synchronization leads to the important requirement that all*N*degrees of freedom have to reach their target position and velocity simultaneously at zero acceleration.- The generated trajectory for the degree of freedom with the largest
execution time is
*time-optimal*. The constraints for all other degrees of freedom are adapted for synchronization. *No path planning.*Path planning is not considered in the context of this paper. The desired trajectory parameters are assumed as user-given.

Figure 1: Input and output parameters for a third order on-line trajectory generator.

*z*is the variable of the

*z*-transformation. Its inverse represents a hold element.

#### The Approach of Decision Trees

Decision trees are used as basis for the approach to realize on-line trajectory generation for*N*-dimensional space with arbitrary input values (Fig. 1) and synchronization between all degrees of fredom as shown in Fig. 2. The figure illustrates a simple case for third-order on-line trajectory generation with and without synchronization for three degrees of fredom. In correspondence to Fig. 1 a function, which maps the

*8N*-dimensional space onto

*3N*-dimensional space must be specified (with

*N*= 6 for Cartesian space). Defining this function is the major part of this reasearch work. Once defined it would result in the classical trajectory progression with rectangular jerks as shown in Fig. 3, which depicts the most trivial case of a third-order trajectory.

Figure 2: Position and velocity diagrams showing the difference between time-synchronized trajectories and non-synchronized trajectories.

Figure 3: Position, velocity, acceleration, and jerk of a simple 7-phase jerk-limited trajectory.

The decision tree approach basically requires three steps:

- Calculation of the execution time for the time-optimal trajectory for each degree of freedom. Due to the requirement of permitting arbitrary states of motion, the algorithm must check a number of conditions before deciding, what kind of trajectory profile goes along with the given input values. Depending on this, the execution time can be calculated individually for each degree of freedom.
- In the second step all degrees of freedom are synchronized. The degree of freedom with the largest execution time is determined, such that all other degrees of freedom can be synchronized to this one.
- Calculation of the output values under consideration of discretization errors.

Further information may be found in our
Publications.
In case of any further questions please contact
Friedrich M. Wahl.