ruckig Namespace Reference

Classes
class	Block
	Which times are possible for synchronization?
class	BrakeProfile
	Calculates (pre- or post-) profile to get current or final state below the limits. More...
class	Calculator
	Internal interface for the main calculator and its hyperparameters. More...
class	CloudClient
class	InputParameter
	Input of the Ruckig algorithm. More...
class	OutputParameter
	Output of the Ruckig algorithm. More...
struct	PositionExtrema
	Information about the position extrema. More...
class	PositionFirstOrderStep1
	Mathematical equations for Step 1 in first-order position interface: Extremal profiles.
class	PositionFirstOrderStep2
	Mathematical equations for Step 2 in first-order position interface: Time synchronization.
class	PositionSecondOrderStep1
	Mathematical equations for Step 1 in second-order position interface: Extremal profiles.
class	PositionSecondOrderStep2
	Mathematical equations for Step 2 in second-order position interface: Time synchronization.
class	PositionThirdOrderStep1
	Mathematical equations for Step 1 in third-order position interface: Extremal profiles.
class	PositionThirdOrderStep2
	Mathematical equations for Step 2 in third-order position interface: Time synchronization.
class	Profile
	A single-dof kinematic profile with position, velocity, acceleration and jerk. More...
class	Ruckig
	Main interface for the Ruckig algorithm. More...
struct	RuckigError
	The base class for all exceptions. More...
class	TargetCalculator
	Calculation class for a state-to-state trajectory.
class	TargetState
	The kinematic target state for Trackig. More...
class	Trackig
	The main interface for the Trackig algorithm. More...
class	Trajectory
	Interface for the generated trajectory. More...
class	VelocitySecondOrderStep1
	Mathematical equations for Step 1 in second-order velocity interface: Extremal profiles.
class	VelocitySecondOrderStep2
	Mathematical equations for Step 2 in second-order velocity interface: Time synchronization.
class	VelocityThirdOrderStep1
	Mathematical equations for Step 1 in third-order velocity interface: Extremal profiles.
class	VelocityThirdOrderStep2
	Mathematical equations for Step 2 in third-order velocity interface: Time synchronization.
class	WaypointsCalculator
	Calculation class for a trajectory along waypoints.

Typedefs
template<size_t DOFs, template< class, size_t > class CustomVector = StandardVector>
using	RuckigThrow = Ruckig< DOFs, CustomVector, true >
template<class T , size_t DOFs>
using	StandardVector = typename std::conditional< DOFs >=1, std::array< T, DOFs >, std::vector< T > >::type
	Vector data type based on the C++ standard library.
template<class T , size_t DOFs, size_t SIZE>
using	StandardSizeVector = typename std::conditional< DOFs >=1, std::array< T, SIZE >, std::vector< T > >::type

Enumerations
enum class	ControlInterface { Position , Velocity }
enum class	Synchronization { Time , TimeIfNecessary , Phase , None }
enum class	DurationDiscretization { Continuous , Discrete }
enum	Result {   Working = 0 , Finished = 1 , Error = -1 , ErrorInvalidInput = -100 ,   ErrorTrajectoryDuration = -101 , ErrorPositionalLimits = -102 , ErrorZeroLimits = -104 , ErrorExecutionTimeCalculation = -110 ,   ErrorSynchronizationCalculation = -111 }
	Result type of Ruckig's update function. More...

Functions
template<typename T >
T	pow2 (T v)
template<class Vector >
std::string	join (const Vector &array, size_t size)
	Vector data type based on the Eigen matrix type. Eigen needs to be included seperately.
std::tuple< double, double, double >	integrate (double t, double p0, double v0, double a0, double j)
	Integrate with constant jerk for duration t. Returns new position, new velocity, and new acceleration.
double	v_at_t (double v0, double a0, double j, double t)
double	v_at_a_zero (double v0, double a0, double j)

Variables
static constexpr size_t	DynamicDOFs {0}
	Constant for indicating a dynamic (run-time settable) number of DoFs.

Typedef Documentation

RuckigThrow

template<size_t DOFs, template< class, size_t > class CustomVector = StandardVector>

using ruckig::RuckigThrow = typedef Ruckig<DOFs, CustomVector, true>

StandardSizeVector

template<class T , size_t DOFs, size_t SIZE>

using ruckig::StandardSizeVector = typedef typename std::conditional<DOFs >= 1, std::array<T, SIZE>, std::vector<T> >::type

StandardVector

template<class T , size_t DOFs>

using ruckig::StandardVector = typedef typename std::conditional<DOFs >= 1, std::array<T, DOFs>, std::vector<T> >::type

Vector data type based on the C++ standard library.

Enumeration Type Documentation

ControlInterface

enum class ruckig::ControlInterface

strong

Enumerator
Position	Position-control: Full control over the entire kinematic state (Default)
Velocity	Velocity-control: Ignores the current position, target position, and velocity limits.

DurationDiscretization

enum class ruckig::DurationDiscretization

strong

Enumerator
Continuous	Every trajectory synchronization duration is allowed (Default)
Discrete	The trajectory synchronization duration must be a multiple of the control cycle.

Result

enum ruckig::Result

Result type of Ruckig's update function.

Enumerator
Working	The trajectory is calculated normally.
Finished	The trajectory has reached its final position.
Error	Unclassified error.
ErrorInvalidInput	Error in the input parameter.
ErrorTrajectoryDuration	The trajectory duration exceeds its numerical limits.
ErrorPositionalLimits	The trajectory exceeds the given positional limits (only in Ruckig Pro)
ErrorZeroLimits	The trajectory is not valid due to a conflict with zero limits.
ErrorExecutionTimeCalculation	Error during the extremel time calculation (Step 1)
ErrorSynchronizationCalculation	Error during the synchronization calculation (Step 2)

Synchronization

enum class ruckig::Synchronization

strong

Enumerator
Time	Always synchronize the DoFs to reach the target at the same time (Default)
TimeIfNecessary	Synchronize only when necessary (e.g. for non-zero target velocity or acceleration)
Phase	Phase synchronize the DoFs when this is possible, else fallback to "Time" strategy. Phase synchronization will result a straight-line trajectory.
None	Calculate every DoF independently.

Function Documentation

integrate()

std::tuple< double, double, double > ruckig::integrate ( double  t, double  p0, double  v0, double  a0, double  j  )

inline

Integrate with constant jerk for duration t. Returns new position, new velocity, and new acceleration.

join()

template<class Vector >

std::string ruckig::join ( const Vector &  array, size_t  size  )

inline

Vector data type based on the Eigen matrix type. Eigen needs to be included seperately.

pow2()

template<typename T >

T ruckig::pow2 ( T  v )

inline

v_at_a_zero()

double ruckig::v_at_a_zero ( double  v0, double  a0, double  j  )

inline

v_at_t()

double ruckig::v_at_t ( double  v0, double  a0, double  j, double  t  )

inline

Variable Documentation

DynamicDOFs

constexpr size_t ruckig::DynamicDOFs {0}

staticconstexpr

Constant for indicating a dynamic (run-time settable) number of DoFs.