This class constitutes the user interface of velocity-based the Type II On-Line Trajectory Generation algorithm More...

#include <TypeIIRMLVelocity.h>

Public Member Functions
	TypeIIRMLVelocity (const unsigned int &DegreesOfFreedom, const double &CycleTimeInSeconds)
	Constructor of the class TypeIIRMLVelocity.
	TypeIIRMLVelocity (const TypeIIRMLVelocity &TypeIIRMLObject)
	Copy constructor of class TypeIIRMLVelocity.
	~TypeIIRMLVelocity (void)
	Destructor of the class TypeIIRMLVelocity.
TypeIIRMLVelocity &	operator= (const TypeIIRMLVelocity &TypeIIRMLObject)
	Copy operator.
int	GetNextStateOfMotion (const RMLVelocityInputParameters &InputValues, RMLVelocityOutputParameters *OutputValues, const RMLVelocityFlags &Flags)
	The main method of the class TypeIIRMLVelocity. It executes the velocity-based Type II On-Line Trajectory Generation algorithm
int	GetNextStateOfMotionAtTime (const double &TimeValueInSeconds, RMLVelocityOutputParameters *OutputValues) const
	Once the method of TypeIIRMLVelocity::GetNextStateOfMotion() was successfully called to compute a trajectory, this method can be used to compute a state of motion on this trajectory at a given time instant.
Protected Types
enum	FunctionResults { FUNC_SUCCESS = false, FUNC_ERROR_OCCURRED = true }
	For class-internal use only: return values of boolean methods. More...
Protected Member Functions
void	FallBackStrategy (const RMLVelocityInputParameters &InputValues, RMLVelocityOutputParameters *OutputValues)
	In case of an error, this method triggers the next layer of the safety concept.
void	CalculateExecutionTimes (void)
	Calculates the minimum execution times and corresponding motion profiles of each selected degree of freedom.
void	ComputeTrajectoryParameters (void)
	Computes all trajectory parameters for non- and phase- synchronized trajectories.
void	ComputePhaseSynchronizationParameters (void)
	Checks, whether phase-synchronization is possible. If possible the corresponding vectors are computed.
void	ComputeTimeSynchronizedTrajectoryParameters (void)
	Computes all trajectory parameters for time-synchronized trajectories.
int	ComputeAndSetOutputParameters (const double &TimeValueInSeconds, RMLVelocityOutputParameters *OP) const
	Computes the output values of the velocity-based On-line Trajectory Generation algorithm, that is, the state of motion for the next control cycle.
bool	IsPhaseSynchronizationPossible (void)
	Checks, whether the motion trajectory can be phase-synchronized.
void	CalculatePositionalExtrems (const double &TimeValueInSeconds, RMLVelocityOutputParameters *OP) const
	Set all positional extremum parameters of the output values of the algorithm (TypeIIRMLVelocity::OutputParameters)
void	SetPositionalExtremsToZero (RMLVelocityOutputParameters *OP) const
	Set all positional extremum parameters of the output values of the algorithm (TypeIIRMLVelocity::OutputParameters) to zero.
void	SetupPhaseSyncSelectionVector (void)
	Modify the current selection vector and exclude unnecessary degrees of freedom.
Protected Attributes
bool	CurrentTrajectoryIsPhaseSynchronized
	Indicates, whether the current trajectory is phase-synchronized.
bool	CurrentTrajectoryIsNotSynchronized
	Indicates, that the current trajectory is not synchronized.
bool	CalculatePositionalExtremsFlag
	Indicates, whether the positional extremes are to be calculated.
int	ReturnValue
	Contains the return value of the method TypeIIRMLVelocity::GetNextStateOfMotion()
unsigned int	NumberOfDOFs
	The number of degrees of freedom .
unsigned int	DOFWithGreatestExecutionTime
	Index of the degree of freedom that requires the greatest execution time.
double	CycleTime
	Contains the cycle time in seconds.
double	SynchronizationTime
	If the trajectory is time- or phase-synchronized, this attribute will contain the synchronization time $t_i^{\,sync}$ . Otherwise,is used for the execution time of the degree of freedom that requires the greatest time.
double	InternalClockInSeconds
	In order to prevent from recalculating the trajectory within every control cycle and to safe CPU time, this time value in seconds represents the elapsed time since the last calculation.
RMLVelocityFlags	OldFlags
	In order to check, whether a new calculation has to be started, the input values have to be compared to the input and output values of the previous cycle. This variable is used to store the flags of last cycle.
RMLBoolVector *	PhaseSyncSelectionVector
	Boolean vector, which contains the modified selection vector that is based on the original selection vector $\vec{S}_i$ in order to enable numerically robust phase-synchronization.
RMLDoubleVector *	ExecutionTimes
	Vector of `double` values, each of which represents an execution time that is used internally.
RMLDoubleVector *	PhaseSynchronizationReferenceVector
	Reference vector for phase-synchronized trajectories, $\vec{\varrho}_i$ with $_{\kappa}\varrho_i\,=\,1$ .
RMLDoubleVector *	PhaseSynchronizationCurrentVelocityVector
	Current velocity vector $\vec{V}_i$ used for the calculation of phase-synchronized motion trajectories.
RMLDoubleVector *	PhaseSynchronizationTargetVelocityVector
	Target velocity vector $\vec{V}_i^{\,trgt}$ used for the calculation of phase-synchronized motion trajectories.
RMLDoubleVector *	PhaseSynchronizationMaxAccelerationVector
	Contains the adapted maximum acceleration vector $\left.\vec{A}_i^{\,max}\right.'$ for phase-synchronized trajectories.
RMLVelocityInputParameters *	OldInputParameters
	Pointer to an RMLVelocityInputParameters object. In order to check, whether a new calculation has to be started, the input values have to be compared to the input and output values of the previous cycle. This variable is used to store the old input values.
RMLVelocityInputParameters *	CurrentInputParameters
	Pointer to an RMLVelocityInputParameters object. This object contains a complete set of input values ${\bf W}_i$ .
RMLVelocityOutputParameters *	OutputParameters
	Pointer to an RMLVelocityOutputParameters object. This object contains the output parameters of the method TypeIIRMLVelocity::GetNextStateOfMotion(). Besides the new desired state of motion ${\bf M}_{i+1}$ , further complementary values for positional extremes are provided.
MotionPolynomials *	Polynomials
	Pointer to an array of MotionPolynomials objects, which contains the actual trajectory ${\cal M}_i$ . It is a two-dimensional array of polynomial functions.

Detailed Description

This class constitutes the user interface of velocity-based the Type II On-Line Trajectory Generation algorithm

The class has to purposes:

As an independent class, it provides the possibility to on-line generate jerk-limited motion trajectories, which guide all selected degrees of freedom to desired target velocity vectors $\vec{V}_i^{\,trgt}$ (indepentendly of any position $\vec{P}_i^{\,trgt}$ . This can be useful, for example to approach for an expected contact with a certain (limited) velocity, such that the force controller can be turned on in the moment of contact.
This algorithm constitutes the second layer of the safety concept of the Reflexxes Motion Libraries. If the position-based algorithm (cf. TypeIIRMLPosition) is not capable to provide the correct solution (e.g., due to invalid input values), this algorithm will guide all selected degrees of freedom to a certain velocity vector (commonly the zero vector, but another target velocity vector can be specified as well, cf. RMLPositionFlags::KeepCurrentVelocityInCaseOfFallbackStrategy).

The algorithm is capable to generate phase-synchronized and non-synchronized motions. The only interface for the user application is the method

See also:: TypeIIRMLPosition; TypeIIRMLVelocity::GetNextStateOfMotion(); RMLVelocityInputParameters; RMLVelocityOutputParameters; ReflexxesAPI; Safety: Three Layers of Error Handling; Synchronization Behavior

Member Enumeration Documentation

enum TypeIIRMLVelocity::FunctionResults [protected]

For class-internal use only: return values of boolean methods.

Enumerator:

FUNC_SUCCESS	The method was executed without any error.
FUNC_ERROR_OCCURRED	The method was executed, and an error occurred.

Constructor & Destructor Documentation

TypeIIRMLVelocity::TypeIIRMLVelocity	(	const unsigned int &	DegreesOfFreedom,
		const double &	CycleTimeInSeconds
	)

Constructor of the class TypeIIRMLVelocity.

Warning:: The constructor is not real-time capable as heap memory has to be allocated.

Parameters:

DegreesOfFreedom	Specifies the number of degrees of freedom
CycleTimeInSeconds	Specifies the cycle time in seconds

See also:: TypeIIRMLVelocity::TypeIIRMLVelocity(); TypeIIRMLPosition::TypeIIRMLPosition()

TypeIIRMLVelocity::TypeIIRMLVelocity ( const TypeIIRMLVelocity & TypeIIRMLObject )

Copy constructor of class TypeIIRMLVelocity.

Warning:: The constructor is not real-time capable as heap memory has to be allocated.

Parameters:

TypeIIRMLObject Object to be copied

See also:: TypeIIRMLVelocity(const unsigned int &DegreesOfFreedom, const double &CycleTimeInSeconds)

TypeIIRMLVelocity::~TypeIIRMLVelocity ( void )

Destructor of the class TypeIIRMLVelocity.

Member Function Documentation

void TypeIIRMLVelocity::CalculateExecutionTimes ( void ) [protected]

Calculates the minimum execution times and corresponding motion profiles of each selected degree of freedom.

This method selects an velocity profile of the set RMLMath::FinalAccelerationProfilesForVelocityCtrl and computes the minimum execution for each single degree of freedom in seconds and writes the values into the attributes

TypeIIRMLVelocity::MotionProfiles
TypeIIRMLVelocity::ExecutionTimes

This computation step is comparable to Step 1 of the position-based On-line Trajectory Generation algorithm.

See also:: TypeIIRMLPosition::Step1(); TypeIIRMLVelocity::GetNextStateOfMotion()

void TypeIIRMLVelocity::CalculatePositionalExtrems	(	const double &	TimeValueInSeconds,
		RMLVelocityOutputParameters *	OP
	)		const `[protected]`

Set all positional extremum parameters of the output values of the algorithm (TypeIIRMLVelocity::OutputParameters)

After all trajectory parameters ${\cal M}_{i}(t)$ have been computed in TypeIIRMLVelocity::GetNextStateOfMotion(), they are stored in the attribute TypeIIRMLVelocity::Polynomials. Using this attribute, this method computes all positional extremum values and corresponding states of motion and writes the results to TypeIIRMLVelocity::OutputParameters. In particular, the following values are calculated:

All these values may be used by the user to perform further calculations based on the currently calculated motion trajectory (e.g., a check for workspace boundaries).

Parameters:

TimeValueInSeconds	Time value in seconds, at which the next state of motion is calculated. The positional extremes are calculated with respect to this value.
OP	Pointer to an object of the class RMLVelocityOutputParameters. The positional extreme values will be calculated for these data.

Note:: The calculation of these values can be disabled by setting the flag RMLVelocityFlags::EnableTheCalculationOfTheExtremumMotionStates to false when the method TypeIIRMLVelocity::GetNextStateOfMotion() is called.

See also:: Description of Output Values; RMLVelocityOutputParameters; RMLVelocityFlags::EnableTheCalculationOfTheExtremumMotionStates; TypeIIRMLVelocity::GetNextStateOfMotion(); TypeIIRMLVelocity::SetPositionalExtremsToZero(); TypeIIRMLPosition::CalculatePositionalExtrems

int TypeIIRMLVelocity::ComputeAndSetOutputParameters	(	const double &	TimeValueInSeconds,
		RMLVelocityOutputParameters *	OP
	)		const `[protected]`

Computes the output values of the velocity-based On-line Trajectory Generation algorithm, that is, the state of motion for the next control cycle.

After either

calculated all coefficients of the polynomials that piecewise describe the desired trajectory, this method computes the actual output values of algorithm, that is, the state of motion at the instant TimeValueInSeconds (commonly for the next control cycle). This part is the pendent of TypeIIRMLPosition::Step3() in the position-based On-line Trajectory Generation algorithm. The resulting values are written into the object pointed to by OP (output parameters).

The methods TypeIIRMLVelocity::GetNextStateOfMotion() and TypeIIRMLVelocity::GetNextStateOfMotionAtTime() make use of this functionality.

Parameters:

TimeValueInSeconds	Time value in seconds, at which the desired state of motion is calculated.
OP	Pointer to an object of the class RMLVelocityOutputParameters, to which the resulting output values will be written to.

See also:: TypeIIRMLPosition::Step3(); TypeIIRMLVelocity::GetNextStateOfMotion(); TypeIIRMLVelocity::GetNextStateOfMotionAtTime()

void TypeIIRMLVelocity::ComputePhaseSynchronizationParameters ( void ) [protected]

Checks, whether phase-synchronization is possible. If possible the corresponding vectors are computed.

This method checks, whether a phase-synchronized trajectory can be generated. If all input vectors are collinear, it is checks, a homothetic trajectory can be computed that meets all kinematic motion constraints. If this is the case, the constraints will be adapted such that $\vec{A}_i^{\,max}$ is also collinear to all other input values. This vectors is stored in the attribute

TypeIIRMLVelocity::PhaseSynchronizationMaxAccelerationVector.

See also:: TypeIIRMLVelocity::IsPhaseSynchronizationPossible(); TypeIIRMLVelocity::GetNextStateOfMotion()

void TypeIIRMLVelocity::ComputeTimeSynchronizedTrajectoryParameters ( void ) [protected]

Computes all trajectory parameters for time-synchronized trajectories.

This method computes the coefficients of all pieces of polynomials that are used to represent the trajectory. This part is comparable to Step 2 of the position-based On-Line Trajectory Generation algorithm.

See also:: TypeIIRMLPosition::Step2(); TypeIIRMLVelocity::GetNextStateOfMotion(); TypeIIRMLVelocity::ComputeTrajectoryParameters()

void TypeIIRMLVelocity::ComputeTrajectoryParameters ( void ) [protected]

Computes all trajectory parameters for non- and phase- synchronized trajectories.

This method computes the coefficients of all pieces of polynomials that are used to represent the trajectory. This part is comparable to Step 2 of the position-based On-Line Trajectory Generation algorithm. Based on the profile that was determined by the method TypeIIRMLVelocity::CalculateExecutionTimes() (and the change of kinematic motion constraints in case of phase-synchronized trajectories; cf. TypeIIRMLVelocity::ComputePhaseSynchronizationParameters()), the actual parameters are set-up, such that a new state of motion can be computed by calling TypeIIRMLVelocity::ComputeAndSetOutputParameters().

See also:: TypeIIRMLPosition::Step2(); TypeIIRMLVelocity::GetNextStateOfMotion()

void TypeIIRMLVelocity::FallBackStrategy	(	const RMLVelocityInputParameters &	InputValues,
		RMLVelocityOutputParameters *	OutputValues
	)		`[protected]`

In case of an error, this method triggers the next layer of the safety concept.

Depending on how the class TypeIIRMLVelocity is used, two different purposes are achieved by this method.

If an object of TypeIIRMLVelocity is used independently from the class TypeIIRMLPosition, this is the second layer of the Reflexxes safety concept. For the case that the velocity-based On-Line Trajectory Generation algorithm is not able to compute correct output values (e.g., because of wrong input values, this fall-back method is called, such that a valid state of motion is provided in any case.
If the object of TypeIIRMLVelocity is an attribute of the class TypeIIRMLPosition, this is the third layer of the Reflexxes safety concept. If no trajectory can be calculated by the position-based On-Line Trajectory Generation algorithm (TypeIIRMLPosition::GetNextStateOfMotion()), the velocity-based algorithm (TypeIIRMLVelocity::GetNextStateOfMotion()) is called in the second safety layer. For the case, that this method is also not able to compute output values, TypeIIRMLVelocity::FallBackStrategy() ensures valid output values in any case.

This method uses the current state of motion ${\bf M}_i$ and continues the current motion with $\vec{A}_{i}\,=\,\vec{0}$ . Concretely, ${\bf M}_{i+1}$ is calculated this way:

$\vec{V}_{i+1}\,=\,\vec{V}_{i}$
$\vec{P}_{i+1}\,=\,\vec{P}_{i}\,+\,\vec{V}_{i}\,\cdot\,T^{\,cycle}$

A detailed description of the three-layered safety mechanism of the Reflexxes Motion Libraries can be found at Safety: Three Layers of Error Handling.

Parameters:

InputValues	Current set of input parameters
OutputValues	Current set of output parameters the will be generated by this method

See also:: TypeIIRMLVelocity; TypeIIRMLVelocity::GetNextStateOfMotion(); TypeIIRMLPosition::GetNextStateOfMotion(); TypeIIRMLVelocity::OutputParameters; TypeIIRMLVelocity::ReturnValue; TypeIIRMLPosition::FallBackStrategy; Safety: Three Layers of Error Handling

int TypeIIRMLVelocity::GetNextStateOfMotion	(	const RMLVelocityInputParameters &	InputValues,
		RMLVelocityOutputParameters *	OutputValues,
		const RMLVelocityFlags &	Flags
	)

The main method of the class TypeIIRMLVelocity. It executes the velocity-based Type II On-Line Trajectory Generation algorithm

Given a set of InputValues consisting of

a current state of motion ${\bf M}_i$ at intstant ,
a target velocity vector $\vec{V}_i^{\,trgt}$ at intstant (with zero acceleration),
kinematic motion constraints ${\bf B}_i$ at intstant , and
a selection vector $\vec{S}_i$ at intstant

and a set of boolean Flags to control the behavior of the algorithm, this method executes the velocity-based Type II On-Line Trajectory Generation algorithm and provides a set of OutputValues, which contain

the desired state of motion ${\bf M}_{i+1}$ at intstant $T_{i+1}$ and
(optionally) further complementary values of the current trajectory.

For a detailed description, please refer to TypeIIRMLVelocity and to the start page Start Page.

Parameters:

InputValues	Input values of the velocity-based Type II On-Line Trajectory Generation algorithm. For detailed information, please refer to the class RMLVelocityInputParameters and to the page Description of Input Values.
OutputValues	Output values of the velocity-based Type II On-Line Trajectory Generation algorithm. For detailed information, please refer to the class RMLVelocityOutputParameters and to the page Description of Output Values.
Flags	A set of boolean values to configure the behavior of the algorithm (e.g., specify whether a time- or a phase-synchronized trajectory is desired, specify, whether the complementary output values are supposed to be computed). For a detailed description of this data structure and its usage, please refer to RMLVelocityFlags.

Returns:

An element of ReflexxesAPI::RMLResultValue:

ReflexxesAPI::RML_WORKING:
The On-Line Trajectory Generation algorithm is working; the final state of motion has not been reached yet.
ReflexxesAPI::RML_FINAL_STATE_REACHED:
The desired final state of motion has been reached.
ReflexxesAPI::RML_ERROR_INVALID_INPUT_VALUES:
The applied input values are invalid (cf. RMLPositionInputParameters::CheckForValidity() RMLVelocityInputParameters::CheckForValidity()).
ReflexxesAPI::RML_ERROR_NUMBER_OF_DOFS:
The number of degree of freedom of th input parameters, the output parameters, and the On-Line Trajectory Generation algorithm do not match.
ReflexxesAPI::RML_ERROR_NO_PHASE_SYNCHRONIZATION:
If the input flag RMLFlags::ONLY_PHASE_SYNCHRONIZATION is set and it is not possible to calculate a physically (and mathematically) correct phase-synchronized (i.e., homothetic) trajectory, this error value will be returned. Please note: Even if this error message is returned, feasible, steady, and continuous output values will be computed in any case.
ReflexxesAPI::RML_ERROR_NULL_POINTER:
If one of the pointers to objects of the classes
is NULL, this error value will be returned.

Note:: A complete description of the On-Line Trajectory Generation framework may be also found at

T. Kroeger.
On-Line Trajectory Generation in Robotic Systems.
Springer Tracts in Advanced Robotics, Vol. 58, Springer, January 2010.
http://www.springer.com/978-3-642-05174-6

See also:: TypeIIRMLVelocity; RMLVelocityInputParameters; RMLVelocityOutputParameters; RMLVelocityFlags; ReflexxesAPI; TypeIIRMLPosition::GetNextStateOfMotion(); TypeIIRMLVelocity::GetNextStateOfMotionAtTime(); TypeIIRMLMath; Real-Time Behavior; Synchronization Behavior

int TypeIIRMLVelocity::GetNextStateOfMotionAtTime	(	const double &	TimeValueInSeconds,
		RMLVelocityOutputParameters *	OutputValues
	)		const

Once the method of TypeIIRMLVelocity::GetNextStateOfMotion() was successfully called to compute a trajectory, this method can be used to compute a state of motion on this trajectory at a given time instant.

After the method GetNextStateOfMotion() was called and no error value was returned (i.e., ReflexxesAPI::RML_WORKING or ReflexxesAPI::RML_FINAL_STATE_REACHED was returned), a trajectory was successfully generated. In order to compute a state of motion of this trajectory at a given time instant, this method can be used. No new calculations are started by calling this method; only the existing result of the method GetNextStateOfMotion() is used. TimeValueInSeconds specifies the time of the desired state of motion, which is copied to OutputValues (cf. RMLVelocityOutputParameters).

If the method TypeIIRMLVelocity::GetNextStateOfMotion() returned an error, the same error will be returned by this method. The value of TimeValueInSeconds has to be positive and below the values of RML_MAX_EXECUTION_TIME ( $10^{10}$ seconds).

For further information, please refer to the documentation of TypeIIRMLVelocity::GetNextStateOfMotion().

Parameters:

TimeValueInSeconds	Time value in seconds, at which the desired state of motion is calculated.
OutputValues	Output values of the velocity-based Type II On-Line Trajectory Generation algorithm. For detailed information, please refer to the class RMLVelocityOutputParameters and to the page Description of Output Values.

Returns:

An element of ReflexxesAPI::RMLResultValue:

ReflexxesAPI::RML_WORKING:
The On-Line Trajectory Generation algorithm is working; the final state of motion has not been reached yet.
ReflexxesAPI::RML_FINAL_STATE_REACHED:
The desired final state of motion has been reached.
ReflexxesAPI::RML_ERROR_INVALID_INPUT_VALUES:
The applied input values are invalid (cf. RMLPositionInputParameters::CheckForValidity() RMLVelocityInputParameters::CheckForValidity()).
ReflexxesAPI::RML_ERROR_NUMBER_OF_DOFS:
The number of degree of freedom of th input parameters, the output parameters, and the On-Line Trajectory Generation algorithm do not match.
ReflexxesAPI::RML_ERROR_NO_PHASE_SYNCHRONIZATION:
If the input flag RMLFlags::ONLY_PHASE_SYNCHRONIZATION is set and it is not possible to calculate a physically (and mathematically) correct phase-synchronized (i.e., homothetic) trajectory, this error value will be returned. Please note: Even if this error message is returned, feasible, steady, and continuous output values will be computed in any case.
ReflexxesAPI::RML_ERROR_NULL_POINTER:
If one of the pointers to objects of the classes
is NULL, this error value will be returned.
ReflexxesAPI::RML_ERROR_USER_TIME_OUT_OF_RANGE:
If either
- the method ReflexxesAPI::RMLPositionAtAGivenSampleTime() or
- the method ReflexxesAPI::RMLVelocityAtAGivenSampleTime()
was used, the value of the parameter is negative or larger than the value of RML_MAX_EXECUTION_TIME ( $10^{10}\,s$ ).

See also:: TypeIIRMLVelocity; RMLVelocityOutputParameters; RMLVelocityFlags; ReflexxesAPI; TypeIIRMLVelocity::GetNextStateOfMotion(); TypeIIRMLPosition::GetNextStateOfMotionAtTime()

bool TypeIIRMLVelocity::IsPhaseSynchronizationPossible ( void ) [protected]

Checks, whether the motion trajectory can be phase-synchronized.

It is checked whether the trajectory can be phase-synchronized. Therefore, this method checks whether the input vectors

current velocity vector $\vec{V}_{i}$ and
target velocity vector $\vec{V}_{i}^{\,trgt}$

are collinear to each other. If this is the case,

true will be returned, and
the reference vector ReferenceVector ( $\vec{\varrho}_i$ ) will be calculated, and copied to TypeIIRMLVelocity::PhaseSynchronizationReferenceVector.

If this is not the case,

false will be returned, and
all elements of TypeIIRMLVelocity::PhaseSynchronizationReferenceVector are set to zero.

For all these computations, the attributes

are used.

Returns:

true if phase-synchronization is possible
false otherwise

See also:: TypeIIRMLVelocity::ComputePhaseSynchronizationParameters(); TypeIIRMLVelocity::GetNextStateOfMotion(); TypeIIRMLPosition::IsPhaseSynchronizationPossible(); Synchronization Behavior

TypeIIRMLVelocity & TypeIIRMLVelocity::operator= ( const TypeIIRMLVelocity & TypeIIRMLObject )

Copy operator.

Parameters:

TypeIIRMLObject TypeIIRMLVelocity object to be copied

void TypeIIRMLVelocity::SetPositionalExtremsToZero ( RMLVelocityOutputParameters * OP ) const [protected]

Set all positional extremum parameters of the output values of the algorithm (TypeIIRMLVelocity::OutputParameters) to zero.

If the input flag RMLVelocityFlags::EnableTheCalculationOfTheExtremumMotionStates is set to false, this method is used to set all output values that are related to the calculation of the positional extremum values to zero in order to obtain defined output values:

If the input flag RMLVelocityFlags::EnableTheCalculationOfTheExtremumMotionStates is set to true, the method TypeIIRMLVelocity::CalculatePositionalExtrems() is used to compute this part of the output values.

Parameters:

OP	Pointer to an object of the class RMLVelocityOutputParameters. The values of this data structure will be set to zero.

See also:: Description of Output Values; RMLPositionOutputParameters; RMLPositionFlags::EnableTheCalculationOfTheExtremumMotionStates; TypeIIRMLPosition::GetNextStateOfMotion(); TypeIIRMLPosition::CalculatePositionalExtrems()

void TypeIIRMLVelocity::SetupPhaseSyncSelectionVector ( void ) [protected]

Modify the current selection vector and exclude unnecessary degrees of freedom.

This method modifies the selection vector RMLVelocityInputParameters::SelectionVector of TypeIIRMLVelocity::CurrentInputParameters to TypeIIRMLVelocity::PhaseSyncSelectionVector. Degrees of freedom $ k $ , whose

current velocity and
target velocity $_kV_i^{\,trgt}$

are zero, can be excluded from the selection vector $\vec{S}_i$ in order correctly determine, whether phase-synchronization is possible and to ensure numerical stability.

See also:: RMLVelocityInputParameters::SelectionVector; TypeIIRMLVelocity::PhaseSyncSelectionVector; TypeIIRMLVelocity::GetNextStateOfMotion(); TypeIIRMLPosition::SetupModifiedSelectionVector(); Synchronization Behavior

Member Data Documentation

bool TypeIIRMLVelocity::CalculatePositionalExtremsFlag [protected]

Indicates, whether the positional extremes are to be calculated.

See also:: CalculatePositionalExtrems()

RMLVelocityInputParameters * TypeIIRMLVelocity::CurrentInputParameters [protected]

Pointer to an RMLVelocityInputParameters object. This object contains a complete set of input values ${\bf W}_i$ .

See also:: TypeIIRMLVelocity::GetNextStateOfMotion(); Description of Input Values

bool TypeIIRMLVelocity::CurrentTrajectoryIsNotSynchronized [protected]

Indicates, that the current trajectory is not synchronized.

See also:: RMLFlags::NO_SYNCHRONIZATION; TypeIIRMLPosition::CurrentTrajectoryIsNotSynchronized; Synchronization Behavior

bool TypeIIRMLVelocity::CurrentTrajectoryIsPhaseSynchronized [protected]

Indicates, whether the current trajectory is phase-synchronized.

See also:: TypeIIRMLVelocity::IsPhaseSynchronizationPossible(); RMLVelocityOutputParameters::TrajectoryIsPhaseSynchronized; TypeIIRMLPosition::CurrentTrajectoryIsPhaseSynchronized; Synchronization Behavior

double TypeIIRMLVelocity::CycleTime [protected]

Contains the cycle time in seconds.

See also:: TypeIIRMLVelocity::TypeIIRMLVelocity()

unsigned int TypeIIRMLVelocity::DOFWithGreatestExecutionTime [protected]

Index of the degree of freedom that requires the greatest execution time.

See also:: TypeIIRMLVelocity::TypeIIRMLVelocity()

RMLIntVector * TypeIIRMLVelocity::ExecutionTimes [protected]

Vector of double values, each of which represents an execution time that is used internally.

See also:: TypeIIRMLVelocity::GetNextStateOfMotion()

double TypeIIRMLVelocity::InternalClockInSeconds [protected]

In order to prevent from recalculating the trajectory within every control cycle and to safe CPU time, this time value in seconds represents the elapsed time since the last calculation.

See also:: TypeIIRMLVelocity::GetNextStateOfMotion()

unsigned int TypeIIRMLVelocity::NumberOfDOFs [protected]

The number of degrees of freedom $ K $ .

See also:: TypeIIRMLVelocity::TypeIIRMLVelocity()

RMLVelocityFlags TypeIIRMLVelocity::OldFlags [protected]

In order to check, whether a new calculation has to be started, the input values have to be compared to the input and output values of the previous cycle. This variable is used to store the flags of last cycle.

See also:: RMLOutputParameters::ANewCalculationWasPerformed; TypeIIRMLVelocity::GetNextStateOfMotion(); TypeIIRMLPosition::OldFlags; OldInputParameters; Description of Input Values

RMLVelocityInputParameters * TypeIIRMLVelocity::OldInputParameters [protected]

Pointer to an RMLVelocityInputParameters object. In order to check, whether a new calculation has to be started, the input values have to be compared to the input and output values of the previous cycle. This variable is used to store the old input values.

See also:: RMLOutputParameters::ANewCalculationWasPerformed; TypeIIRMLVelocity::GetNextStateOfMotion(); TypeIIRMLPosition::OldInputParameters; OldFlags; Description of Input Values

RMLVelocityOutputParameters * TypeIIRMLVelocity::OutputParameters [protected]

Pointer to an RMLVelocityOutputParameters object. This object contains the output parameters of the method TypeIIRMLVelocity::GetNextStateOfMotion(). Besides the new desired state of motion ${\bf M}_{i+1}$ , further complementary values for positional extremes are provided.

See also:: RMLVelocityOutputParameters; TypeIIRMLVelocity::GetNextStateOfMotion(); Description of Output Values

RMLDoubleVector * TypeIIRMLVelocity::PhaseSynchronizationCurrentVelocityVector [protected]

Current velocity vector $\vec{V}_i$ used for the calculation of phase-synchronized motion trajectories.

See also:: TypeIIRMLVelocity::IsPhaseSynchronizationPossible(); Synchronization Behavior

RMLDoubleVector * TypeIIRMLVelocity::PhaseSynchronizationMaxAccelerationVector [protected]

Contains the adapted maximum acceleration vector $\left.\vec{A}_i^{\,max}\right.'$ for phase-synchronized trajectories.

See also:: TypeIIRMLVelocity::IsPhaseSynchronizationPossible(); Synchronization Behavior

RMLDoubleVector * TypeIIRMLVelocity::PhaseSynchronizationReferenceVector [protected]

Reference vector for phase-synchronized trajectories, $\vec{\varrho}_i$ with $_{\kappa}\varrho_i\,=\,1$ .

See also:: TypeIIRMLVelocity::IsPhaseSynchronizationPossible(); Synchronization Behavior

RMLDoubleVector * TypeIIRMLVelocity::PhaseSynchronizationTargetVelocityVector [protected]

Target velocity vector $\vec{V}_i^{\,trgt}$ used for the calculation of phase-synchronized motion trajectories.

See also:: TypeIIRMLVelocity::IsPhaseSynchronizationPossible(); Synchronization Behavior

RMLBoolVector * TypeIIRMLVelocity::PhaseSyncSelectionVector [protected]

Boolean vector, which contains the modified selection vector that is based on the original selection vector $\vec{S}_i$ in order to enable numerically robust phase-synchronization.

See also:: TypeIIRMLVelocity::SetupPhaseSyncSelectionVector(); RMLVelocityInputParameters::SelectionVector; TypeIIRMLVelocity::GetNextStateOfMotion(); Synchronization Behavior

MotionPolynomials * TypeIIRMLVelocity::Polynomials [protected]

Pointer to an array of MotionPolynomials objects, which contains the actual trajectory ${\cal M}_i$ . It is a two-dimensional array of polynomial functions.

See also:: TypeIIRMLMath::TypeIIRMLPolynomial; TypeIIRMLMath::MotionPolynomials; TypeIIRMLVelocity::GetNextStateOfMotion()

int TypeIIRMLVelocity::ReturnValue [protected]

Contains the return value of the method TypeIIRMLVelocity::GetNextStateOfMotion()

See also:: TypeIIRMLVelocity::GetNextStateOfMotion()

double TypeIIRMLVelocity::SynchronizationTime [protected]

If the trajectory is time- or phase-synchronized, this attribute will contain the synchronization time $t_i^{\,sync}$ . Otherwise,is used for the execution time of the degree of freedom that requires the greatest time.

The documentation for this class was generated from the following files:

include/TypeIIRMLVelocity.h
src/TypeIIRML/TypeIIRMLVelocity.cpp
src/TypeIIRML/TypeIIRMLVelocityCalculatePositionalExtrems.cpp
src/TypeIIRML/TypeIIRMLVelocityFallBackStrategy.cpp
src/TypeIIRML/TypeIIRMLVelocityIsPhaseSynchronizationPossible.cpp
src/TypeIIRML/TypeIIRMLVelocityMethods.cpp
src/TypeIIRML/TypeIIRMLVelocitySetupPhaseSyncSelectionVector.cpp

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation