Class Motion 

Parameters:: pTriggerPosCommand – [in] A pointer to an object of the TriggerPosCommand class that contains the position command parameters.

WMX3APIFUNC StartVelToMov(TriggerPosCommand *pTriggerPosCommand)

Start a relative triggered position command for an axis that is currently executing a velocity command.

This function will override a velocity command with a position command to a relative position when the trigger condition is satisfied. The target position is relative to the command position of the axis at the time that this function is executed. The axis command mode will automatically change from Velocity mode to Position mode.

Remark

This function does not support the SameTimeCompletion, StaggeredTimeCompletion, and StaggeredDistanceCompletion trigger types. Specifying these trigger types will cause the TriggerTypeNotSupported error to be returned.

See also

Parameters:: pTriggerPosCommand – [in] A pointer to an object of the TriggerPosCommand class that contains the position command parameters.

WMX3APIFUNC StartVelToPos(unsigned int numCommands, TriggerPosCommand *pTriggerPosCommand)

Start absolute triggered position commands for multiple axes that are currently executing velocity commands.

This function executes the StartVelToPos API function for multiple axes.

Remark

Parameters:

numCommands – [in] The number of position commands. Each command controls a single axis.
pTriggerPosCommand – [in] A pointer to an array of objects of the TriggerPosCommand class that contain the parameters of the position commands. The number of elements in the array must equal numCommands.

WMX3APIFUNC StartVelToMov(unsigned int numCommands, TriggerPosCommand *pTriggerPosCommand)

Start relative triggered position commands for multiple axes that are currently executing velocity commands.

This function executes the StartVelToMov API function for multiple axes.

Remark

Parameters:

numCommands – [in] The number of position commands. Each command controls a single axis.
pTriggerPosCommand – [in] A pointer to an array of objects of the TriggerPosCommand class that contain the parameters of the position commands. The number of elements in the array must equal numCommands.

WMX3APIFUNC StartVelToPos(PosCommand *pPosCommand, TriggerEvents *pTriggerEvents)

Start an absolute triggered position command for an axis that is currently executing a velocity command. The trigger condition can have multiple trigger events.

This function will override a velocity command with a position command to an absolute position when the multiple event trigger condition is satisfied. The axis command mode will automatically change from Velocity mode to Position mode.

Remark

This function does not support the SameTimeCompletion, StaggeredTimeCompletion, and StaggeredDistanceCompletion trigger types. Specifying these trigger types will cause the TriggerTypeNotSupported error to be returned.

See also

Parameters:

pPosCommand – [in] A pointer to an object of the PosCommand class that contains the parameters of the position command.
pTriggerEvents – [in] A pointer to an object of the TriggerEvents class that contains the trigger events.

WMX3APIFUNC StartVelToMov(PosCommand *pPosCommand, TriggerEvents *pTriggerEvents)

Start a relative triggered position command for an axis that is currently executing a velocity command. The trigger condition can have multiple trigger events.

This function will override a velocity command with a position command to a relative position when the multiple event trigger condition is satisfied. The target position is relative to the command position of the axis at the time that this function is executed. The axis command mode will automatically change from Velocity mode to Position mode.

Remark

This function does not support the SameTimeCompletion, StaggeredTimeCompletion, and StaggeredDistanceCompletion trigger types. Specifying these trigger types will cause the TriggerTypeNotSupported error to be returned.

See also

Parameters:

pPosCommand – [in] A pointer to an object of the PosCommand class that contains the parameters of the position command.
pTriggerEvents – [in] A pointer to an object of the TriggerEvents class that contains the trigger events.

WMX3APIFUNC StartVelToPos(unsigned int numCommands, PosCommand *pPosCommand, TriggerEvents *pTriggerEvents)

Start absolute triggered position commands for multiple axes that are currently executing velocity commands. The trigger conditions can have multiple trigger events.

This function executes the StartVelToPos API function for multiple axes. All commanded axes share the same trigger events.

Remark

Parameters:

numCommands – [in] The number of position commands. Each command controls a single axis.
pPosCommand – [in] A pointer to an array of objects of the PosCommand class that contain the parameters of the position commands. The number of elements in the array must equal numCommands.
pTriggerEvents – [in] A pointer to an object of the TriggerEvents class that contains the trigger events.

WMX3APIFUNC StartVelToMov(unsigned int numCommands, PosCommand *pPosCommand, TriggerEvents *pTriggerEvents)

Start relative triggered position commands for multiple axes that are currently executing velocity commands. The trigger conditions can have multiple trigger events.

This function executes the StartVelToMov API function for multiple axes. All commanded axes share the same trigger events.

Remark

Parameters:

numCommands – [in] The number of position commands. Each command controls a single axis.
pPosCommand – [in] A pointer to an array of objects of the PosCommand class that contain the parameters of the position commands. The number of elements in the array must equal numCommands.
pTriggerEvents – [in] A pointer to an object of the TriggerEvents class that contains the trigger events.

WMX3APIFUNC StartTrqToPos(TriggerPosCommand *pTriggerPosCommand)

Start an absolute triggered position command for an axis that is currently executing a torque command.

This function will override a torque command with a position command to an absolute position when the trigger condition is satisfied. The axis command mode will automatically change from Torque mode to Position mode.

Remark

This function does not support the SameTimeCompletion, StaggeredTimeCompletion, and StaggeredDistanceCompletion trigger types. Specifying these trigger types will cause the TriggerTypeNotSupported error to be returned.

See also

Parameters:: pTriggerPosCommand – [in] A pointer to an object of the TriggerPosCommand class that contains the position command parameters.

WMX3APIFUNC StartTrqToMov(TriggerPosCommand *pTriggerPosCommand)

Start a relative triggered position command for an axis that is currently executing a torque command.

This function will override a torque command with a position command to a relative position when the trigger condition is satisfied. The target position is relative to the command position of the axis at the time that this function is executed. The axis command mode will automatically change from Torque mode to Position mode.

Remark

This function does not support the SameTimeCompletion, StaggeredTimeCompletion, and StaggeredDistanceCompletion trigger types. Specifying these trigger types will cause the TriggerTypeNotSupported error to be returned.

See also

Parameters:: pTriggerPosCommand – [in] A pointer to an object of the TriggerPosCommand class that contains the position command parameters.

WMX3APIFUNC StartTrqToPos(unsigned int numCommands, TriggerPosCommand *pTriggerPosCommand)

Start absolute triggered position commands for multiple axes that are currently executing torque commands.

This function executes the StartTrqToPos API function for multiple axes.

Remark

Parameters:

numCommands – [in] The number of position commands. Each command controls a single axis.
pTriggerPosCommand – [in] A pointer to an array of objects of the TriggerPosCommand class that contain the parameters of the position commands. The number of elements in the array must equal numCommands.

WMX3APIFUNC StartTrqToMov(unsigned int numCommands, TriggerPosCommand *pTriggerPosCommand)

Start relative triggered position commands for multiple axes that are currently executing torque commands.

This function executes the StartTrqToMov API function for multiple axes.

Remark

Parameters:

numCommands – [in] The number of position commands. Each command controls a single axis.
pTriggerPosCommand – [in] A pointer to an array of objects of the TriggerPosCommand class that contain the parameters of the position commands. The number of elements in the array must equal numCommands.

WMX3APIFUNC StartTrqToPos(PosCommand *pPosCommand, TriggerEvents *pTriggerEvents)

Start an absolute triggered position command for an axis that is currently executing a torque command. The trigger condition can have multiple trigger events.

This function will override a torque command with a position command to an absolute position when the multiple event trigger condition is satisfied. The axis command mode will automatically change from Torque mode to Position mode.

Remark

This function does not support the SameTimeCompletion, StaggeredTimeCompletion, and StaggeredDistanceCompletion trigger types. Specifying these trigger types will cause the TriggerTypeNotSupported error to be returned.

See also

Parameters:

pPosCommand – [in] A pointer to an object of the PosCommand class that contains the parameters of the position command.
pTriggerEvents – [in] A pointer to an object of the TriggerEvents class that contains the trigger events.

WMX3APIFUNC StartTrqToMov(PosCommand *pPosCommand, TriggerEvents *pTriggerEvents)

Start a relative triggered position command for an axis that is currently executing a torque command. The trigger condition can have multiple trigger events.

This function will override a torque command with a position command to a relative position when the multiple event trigger condition is satisfied. The target position is relative to the command position of the axis at the time that this function is executed. The axis command mode will automatically change from Torque mode to Position mode.

Remark

This function does not support the SameTimeCompletion, StaggeredTimeCompletion, and StaggeredDistanceCompletion trigger types. Specifying these trigger types will cause the TriggerTypeNotSupported error to be returned.

See also

Parameters:

pPosCommand – [in] A pointer to an object of the PosCommand class that contains the parameters of the position command.
pTriggerEvents – [in] A pointer to an object of the TriggerEvents class that contains the trigger events.

WMX3APIFUNC StartTrqToPos(unsigned int numCommands, PosCommand *pPosCommand, TriggerEvents *pTriggerEvents)

Start absolute triggered position commands for multiple axes that are currently executing torque commands. The trigger conditions can have multiple trigger events.

This function executes the StartTrqToPos API function for multiple axes. All commanded axes share the same trigger events.

Remark

Parameters:

numCommands – [in] The number of position commands. Each command controls a single axis.
pPosCommand – [in] A pointer to an array of objects of the PosCommand class that contain the parameters of the position commands. The number of elements in the array must equal numCommands.
pTriggerEvents – [in] A pointer to an object of the TriggerEvents class that contains the trigger events.

WMX3APIFUNC StartTrqToMov(unsigned int numCommands, PosCommand *pPosCommand, TriggerEvents *pTriggerEvents)

Start relative triggered position commands for multiple axes that are currently executing torque commands. The trigger conditions can have multiple trigger events.

This function executes the StartTrqToMov API function for multiple axes. All commanded axes share the same trigger events.

Remark

Parameters:

numCommands – [in] The number of position commands. Each command controls a single axis.
pPosCommand – [in] A pointer to an array of objects of the PosCommand class that contain the parameters of the position commands. The number of elements in the array must equal numCommands.
pTriggerEvents – [in] A pointer to an object of the TriggerEvents class that contains the trigger events.

WMX3APIFUNC StartJog(JogCommand *pJogCommand)

Start a jog command.

This function will command the specified axis to accelerate to the specified velocity, and then continue moving at the specified velocity until stopped. The specified velocity may be positive or negative. The axis will move in the reverse direction if the velocity is negative.

Remark

Position commands executed by StartPos (and equivalent events) can be overridden by jog commands. Jog commands can also be overridden by StartPos (and equivalent events). However, an axis that is executing trigger motion cannot be overridden by jog commands until after the trigger condition has been satisfied. Similarly, an axis that is paused with the Pause function cannot be overridden by jog commands until after it is resumed with the Resume function.

Parameters:: pJogCommand – [in] A pointer to an object of the JogCommand class that contains the jog command parameters.

WMX3APIFUNC StartJog(TimedJogCommand *pTimedJogCommand)

Start a timed jog command.

This function will command the axis to accelerate to the profile velocity in the time specified in the profile accTimeMilliseconds, run for the runTimeMilliseconds amount of time, and then decelerate to rest in the time specified in the profile decTimeMilliseconds. The total time that the axis is in motion is the sum of accTimeMilliseconds, runTimeMilliseconds, and decTimeMilliseconds.

Remark

While accelerating, or while jogging at the specified velocity, the axis will be in the Jog operation mode. While decelerating, the axis will be in the Stop operation mode.

The timer used by this function is a real time timer and not a Windows-level timer. Because of this, the specified times are followed precisely, and the total distance traveled will be exactly the same each time this function is called if the parameters are kept identical.

Like StartJog, the commanded axis can be stopped before the entire motion finishes using functions such as Stop.

Only the following ProfileTypes are supported by this function. Specifying any other ProfileType will cause this function to return an error.

Parameters:: pTimedJogCommand – [in] A pointer to an object of the TimedJogCommand class that contains the timed jog command parameters.

WMX3APIFUNC StartJog(TriggerJogCommand *pJogCommand)

Start a triggered jog command.

This function will command the specified axis to accelerate to the specified velocity, and then continue moving at the specified velocity until stopped. The specified velocity may be positive or negative. The axis will move in the reverse direction if the velocity is negative.

Remark

Position commands executed by StartPos (and equivalent events) can be overridden by jog commands. Jog commands can also be overridden by StartPos (and equivalent events). However, an axis that is executing trigger motion cannot be overridden by jog commands until after the trigger condition has been satisfied. Similarly, an axis that is paused with the Pause function cannot be overridden by jog commands until after it is resumed with the Resume function.

The motion will begin when the specified trigger condition is satisfied.

See also

Parameters:: pJogCommand – [in] A pointer to an object of the TriggerJogCommand class that contains the triggered jog command parameters.

WMX3APIFUNC StartJog(TriggerTimedJogCommand *pTimedJogCommand)

Start a triggered timed jog command.

This function will command the axis to accelerate to the profile velocity in the time specified in the profile accTimeMilliseconds, run for the runTimeMilliseconds amount of time, and then decelerate to rest in the time specified in the profile decTimeMilliseconds. The total time that the axis is in motion is the sum of accTimeMilliseconds, runTimeMilliseconds, and decTimeMilliseconds.

Remark

While accelerating, or while jogging at the specified velocity, the axis will be in the Jog operation mode. While decelerating, the axis will be in the Stop operation mode.

The timer used by this function is a real time timer and not a Windows-level timer. Because of this, the specified times are followed precisely, and the total distance traveled will be exactly the same each time this function is called if the parameters are kept identical.

Like StartJog, the commanded axis can be stopped before the entire motion finishes using functions such as Stop.

Only the following ProfileTypes are supported by this function. Specifying any other ProfileType will cause this function to return an error.

The motion will begin when the specified trigger condition is satisfied.

See also

Parameters:: pTimedJogCommand – [in] A pointer to an object of the TriggerTimedJogCommand class that contains the triggered timed jog command parameters.

WMX3APIFUNC StartJog(JogCommand *pJogCommand, TriggerEvents *pTriggerEvents)

Start a triggered jog command with multiple trigger events.

This function will command the specified axis to accelerate to the specified velocity, and then continue moving at the specified velocity until stopped. The specified velocity may be positive or negative. The axis will move in the reverse direction if the velocity is negative.

Remark

Position commands executed by StartPos (and equivalent events) can be overridden by jog commands. Jog commands can also be overridden by StartPos (and equivalent events). However, an axis that is executing trigger motion cannot be overridden by jog commands until after the trigger condition has been satisfied. Similarly, an axis that is paused with the Pause function cannot be overridden by jog commands until after it is resumed with the Resume function.

The motion will begin when the specified multi-event trigger condition is satisfied.

See also

Parameters:

pJogCommand – [in] A pointer to an object of the JogCommand class that contains the jog command parameters.
pTriggerEvents – [in] A pointer to an object of the TriggerEvents class that contains the trigger events.

WMX3APIFUNC StartJog(TimedJogCommand *pTimedJogCommand, TriggerEvents *pTriggerEvents)

Start a triggered timed jog command with multiple trigger events.

This function will command the axis to accelerate to the profile velocity in the time specified in the profile accTimeMilliseconds, run for the runTimeMilliseconds amount of time, and then decelerate to rest in the time specified in the profile decTimeMilliseconds. The total time that the axis is in motion is the sum of accTimeMilliseconds, runTimeMilliseconds, and decTimeMilliseconds.

Remark

While accelerating, or while jogging at the specified velocity, the axis will be in the Jog operation mode. While decelerating, the axis will be in the Stop operation mode.

The timer used by this function is a real time timer and not a Windows-level timer. Because of this, the specified times are followed precisely, and the total distance traveled will be exactly the same each time this function is called if the parameters are kept identical.

Like StartJog, the commanded axis can be stopped before the entire motion finishes using functions such as Stop.

Only the following ProfileTypes are supported by this function. Specifying any other ProfileType will cause this function to return an error.

The motion will begin when the specified multi-event trigger condition is satisfied.

See also

Parameters:

pTimedJogCommand – [in] A pointer to an object of the TimedJogCommand class that contains the timed jog command parameters.
pTriggerEvents – [in] A pointer to an object of the TriggerEvents class that contains the trigger events.

WMX3APIFUNC StartJog(unsigned int numCommands, JogCommand *pJogCommand)

Start jog commands for multiple axes.

This command executes the StartJog function for multiple axes.

Remark

Parameters:

numCommands – [in] The number of jog commands. Each command controls a single axis.
pJogCommand – [in] A pointer to an array of objects of the JogCommand class that contain the parameters of the jog commands. The number of elements in the array must equal numCommands.

WMX3APIFUNC StartJog(unsigned int numCommands, TimedJogCommand *pTimedJogCommand)

Start timed jog commands for multiple axes.

This command executes the StartJog function for multiple axes.

Remark

Parameters:

numCommands – [in] The number of timed jog commands. Each command controls a single axis.
pTimedJogCommand – [in] A pointer to an array of objects of the TimedJogCommand class that contain the parameters of the jog commands. The number of elements in the array must equal numCommands.

WMX3APIFUNC StartJog(unsigned int numCommands, TriggerJogCommand *pJogCommand)

Start triggered jog commands for multiple axes.

This command executes the StartJog function for multiple axes.

Remark

The motion will begin for each axis when the specified trigger condition for that axis is satisfied.

See also

Parameters:

numCommands – [in] The number of triggered jog commands. Each command controls a single axis.
pJogCommand – [in] A pointer to an array of objects of the TriggerJogCommand class that contain the parameters of the triggered jog commands. The number of elements in the array must equal numCommands.

WMX3APIFUNC StartJog(unsigned int numCommands, TriggerTimedJogCommand *pTimedJogCommand)

Start triggered timed jog commands for multiple axes.

This command executes the StartJog function for multiple axes.

Remark

The motion will begin for each axis when the specified trigger condition for that axis is satisfied.

See also

Parameters:

numCommands – [in] The number of triggered timed jog commands. Each command controls a single axis.
pTimedJogCommand – [in] A pointer to an array of objects of the TriggerTimedJogCommand class that contain the parameters of the triggered jog commands. The number of elements in the array must equal numCommands.

WMX3APIFUNC StartJog(unsigned int numCommands, JogCommand *pJogCommand, TriggerEvents *pTriggerEvents)

Start triggered jog commands with multiple trigger events for multiple axes.

This command executes the StartJog function for multiple axes.

Remark

The motion will begin for all axes when the specified multi-event trigger condition is satisfied.

See also

Parameters:

numCommands – [in] The number of jog commands. Each command controls a single axis.
pJogCommand – [in] A pointer to an array of objects of the JogCommand class that contain the parameters of the jog commands. The number of elements in the array must equal numCommands.
pTriggerEvents – [in] A pointer to an object of the TriggerEvents class that contains the trigger events. All commanded axes share the same trigger events.

WMX3APIFUNC StartJog(unsigned int numCommands, TimedJogCommand *pTimedJogCommand, TriggerEvents *pTriggerEvents)

Start triggered timed jog commands with multiple trigger events for multiple axes.

This command executes the StartJog function for multiple axes.

Remark

The motion will begin for all axes when the specified multi-event trigger condition is satisfied.

See also

Parameters:

numCommands – [in] The number of jog commands. Each command controls a single axis.
pTimedJogCommand – [in] A pointer to an array of objects of the TimedJogCommand class that contain the parameters of the timed jog commands. The number of elements in the array must equal numCommands.
pTriggerEvents – [in] A pointer to an object of the TriggerEvents class that contains the trigger events. All commanded axes share the same trigger events.

WMX3APIFUNC StartPosToJog(TriggerJogCommand *pTriggerJogCommand)

Start a triggered jog command for an axis that is currently executing a position command.

This function will override a position command with a jog command when the trigger condition is satisfied.

Remark

This function does not support the SameTimeCompletion, StaggeredTimeCompletion, and StaggeredDistanceCompletion trigger types. Specifying these trigger types will cause the TriggerTypeNotSupported error to be returned.

If the axis is not executing a position command when this function is called, the axis will change to Pos operation state, but will not move until the trigger condition is satisfied. When the trigger condition is satisfied, the jog command is started.

If the axis finishes the position command it is executing before the trigger condition is satisfied, the axis will remain in Pos operation state until the trigger condition is satisfied and the jog command is started.

If the trigger axis of the trigger condition is set to the same axis as the commanded axis, and the trigger condition is not satisfied at the end of the position command, the jog command will start immediately after the position command completes (the trigger condition is considered to be satisfied at this time).

Parameters:: pTriggerJogCommand – [in] A pointer to an object of the PosToJogCommand class that contains the position to jog command parameters.

WMX3APIFUNC StartPosToJog(unsigned int numCommands, TriggerJogCommand *pTriggerJogCommand)

Start triggered jog commands for multiple axes that are currently executing position commands.

This function executes the StartPosToJog API function for multiple axes.

Remark

Parameters:

numCommands – [in] The number of position to jog commands. Each command controls a single axis.
pTriggerJogCommand – [in] A pointer to an array of objects of the PosToJogCommand class that contain the parameters of the position to jog commands. The number of elements in the array must equal numCommands.

WMX3APIFUNC StartPosToJog(JogCommand *pJogCommand, TriggerEvents *pTriggerEvents)

Start a triggered jog command for an axis that is currently executing a position command. The trigger condition can have multiple trigger events.

This function will override a position command with a jog command when the multiple event trigger condition is satisfied.

Remark

Aside from specifying the trigger condition using the TriggerEvents class, the specifications for this function are the same as StartPosToJog.

Parameters:

pJogCommand – [in] A pointer to an object of the JogCommand class that contains the parameters of the jog command.
pTriggerEvents – [in] A pointer to an object of the TriggerEvents class that contains the trigger events.

WMX3APIFUNC StartPosToJog(unsigned int numCommands, JogCommand *pJogCommand, TriggerEvents *pTriggerEvents)

Start triggered jog commands for multiple axes that are currently executing position commands. The trigger conditions can have multiple trigger events.

This function executes the StartPosToJog API function for multiple axes. All commanded axes share the same trigger events.

Remark

Parameters:

numCommands – [in] The number of jog commands. Each command controls a single axis.
pJogCommand – [in] A pointer to an array of objects of the JogCommand class that contain the parameters of the jog commands. The number of elements in the array must equal numCommands.
pTriggerEvents – [in] A pointer to an object of the TriggerEvents class that contains the trigger events.

WMX3APIFUNC StartPosToJog(PosToJogCommand *pPosToJogCommand)

Start an absolute position command and a triggered jog command simultaneously. The position command will be overridden by the jog command when the trigger condition is satisfied.

This function starts a position command and a triggered jog command simultaneously for an axis. The position command is executed immediately, and when the trigger condition is satisfied, the position command is overridden by the jog command.

Remark

This function can be used to move the axis to a particular position, and then keep the axis moving at a constant velocity after reaching that position. To do so, set the trigger condition to be satisfied when the position command completes (such as TriggerType::RemainingTime with the trigger axis set to the commanded axis and the trigger value set to 0), and set the end velocity of the position command equal to the velocity of the jog command.

If this function is executed for an axis that is executing a position command or a jog command, the command will be overridden by the position command specified for this function. For additional information regarding overrides between jog commands and position commands, see the discussion under StartJog.

Aside from specifying the position command with the jog command, the specifications for this function are the same as StartPosToJog.

Parameters:: pPosToJogCommand – [in] A pointer to an object of the PosToJogCommand class that contains the parameters of the position and jog commands.

WMX3APIFUNC StartPosToJog(unsigned int numCommands, PosToJogCommand *pPosToJogCommand)

Start an absolute position command and a triggered jog command simultaneously for multiple axes. The position command will be overridden by the jog command when the trigger condition is satisfied.

Start an absolute position command and a triggered jog command simulataneously for multiple axes. The position command will be overridden by the jog command when the trigger condition is satisfied.

This function executes the StartPosToJog function for multiple axes.

Remark

Parameters:

numCommands – [in] The number of position and jog commands. Each command controls a single axis.
pPosToJogCommand – [in] A pointer to an array of objects of the PosToJogCommand class that contain the parameters of the motion command. The number of objects in the array must be equal to numCommands.

WMX3APIFUNC StartMovToJog(PosToJogCommand *pPosToJogCommand)

Start a relative position command and a triggered jog command simultaneously. The position command will be overridden by the jog command when the trigger condition is satisfied.

This function is similar to StartPosToJog, except the target position of the position command is specified as a relative position instead of an absolute position.

Remark

This function can be used to move the axis by a particular distance, and then keep the axis moving at a constant velocity after moving that distance. To do so, set the trigger condition to be satisfied when the position command completes (such as TriggerType::RemainingTime with the trigger axis set to the commanded axis and the trigger value set to 0), and set the end velocity of the position command equal to the velocity of the jog command.

Parameters:: pPosToJogCommand – [in] A pointer to an object of the PosToJogCommand class that contains the parameters of the position and jog commands.

WMX3APIFUNC StartMovToJog(unsigned int numCommands, PosToJogCommand *pPosToJogCommand)

Start a relative position command and a triggered jog command simultaneously for multiple axes. The position command will be overridden by the jog command when the trigger condition is satisfied.

Start a relative position command and a triggered jog command simulataneously for multiple axes. The position command will be overridden by the jog command when the trigger condition is satisfied.

This function executes the StartMovToJog function for multiple axes.

Remark

Parameters:

numCommands – [in] The number of position and jog commands. Each command controls a single axis.
pPosToJogCommand – [in] A pointer to an array of objects of the PosToJogCommand class that contain the parameters of the motion commands. The number of objects in the array must be equal to numCommands.

WMX3APIFUNC Stop(int axis)

Stop the motion of an axis.

This function stops the motion of an axis that is executing a position command, jog command, interpolation command, or home command.

Remark

This function will only stop axes running in Position command mode. To stop axes running in Velocity command mode, use the Stop function. To stop axes running in Torque command mode, use the StopTrq function.

If the axis was executing a position command or jog command, it will decelerate to rest using the profile, deceleration, and jerk deceleration parameters of the position or jog command.

If the axis was executing a home command, it will decelerate to rest using the Homing Velocity Slow Dec parameter, using a trapezoidal motion profile.

If the axis was executing an interpolation command, all interpolated axes will decelerate to rest along the composite vector of the interpolation. The profile, deceleration, and jerk deceleration parameters of the interpolation command are used to calculate the deceleration path.

This function is unable to stop the slave axis of a synchronous control pair. To stop a slave axis, specify the master axis of the synchronous control pair (this will stop both the slave and master axes).

If the commanded axis is in Idle state, this function will return no error.

If the commanded axis is executing a command for which the deceleration cannot be obtained, the axis will be stopped using the Quick Stop Dec parameter as the deceleration, as if the ExecQuickStop function was called. This might occur if this function is called during the first cycle of processing a new position command or override position command.

Parameters:: axis – [in] The axis to stop.

WMX3APIFUNC Stop(AxisSelection *pAxisSelection)

Stop the motion of multiple axes.

This function executes the Stop function for multiple axes.

If any of the commanded axes are in an invalid state, this function will return an error but the remainder of the commanded axes will be stopped. An axis is in an invalid state if the axis servo is not on, if the axis command mode is not Position, or if the axis is receiving or has received a new motion command to be started on the next communication cycle.

Parameters:: pAxisSelection – [in] A pointer to a AxisSelection class object that specifies the axes to stop.

WMX3APIFUNC Stop(int axis, double dec)

Stop the motion of an axis using the specified deceleration and a trapezoidal profile.

This function stops the motion of an axis using the specified deceleration. The axis stops using a trapezoidal profile regardless of the motion the axis was previously executing.

Remark

This function will only stop axes running in Position command mode. To stop axes running in Velocity command mode, use the Stop function. To stop axes running in Torque command mode, use the StopTrq function.

If the commanded axis is in Idle state, this function will return no error.

Parameters:

axis – [in] The axis to stop.
dec – [in] The deceleration to stop at.

WMX3APIFUNC Stop(unsigned int numCommands, StopCommand *pStopCommand)

Stop the motion of multiple axes using the specified decelerations and trapezoidal profiles.

This function executes the Stop function for multiple axes.

Remark

If any of the commanded axes are in an invalid state, this function will return an error but the remainder of the commanded axes will be stopped. An axis is in an invalid state if the axis servo is not on, if the axis command mode is not Position, or if the axis is receiving or has received a new motion command to be started on the next communication cycle.

Parameters:

numCommands – [in] The number of stop motions. Each stop motion commands a single axis.
pStopCommand – [in] A pointer to an array of objects of the StopCommand class that contain the parameters of the motion. The number of objects in the array must be equal to numCommands. The dec values specify the deceleration at which to stop the axis in.

WMX3APIFUNC ExecQuickStop(int axis)

Stop the motion of an axis using the Quick Stop Dec parameter.

This function is identical to the Stop function, except the deceleration rate is set equal to the Quick Stop Dec parameter, and the motion profile is trapezoidal.

Remark

A Stop command can be overridden by a ExecQuickStop command, but not the other way around.

If the commanded axis is in Idle state, this function will return no error.

Parameters:: axis – [in] The axis to stop.

WMX3APIFUNC ExecQuickStop(AxisSelection *pAxisSelection)

Stop the motion of multiple axes using the Quick Stop Dec parameter.

This function executes the ExecQuickStop function for multiple axes.

Remark

If any of the commanded axes are in an invalid state, this function will return an error but the remainder of the commanded axes will be stopped. An axis is in an invalid state if the axis servo is not on, if the axis command mode is not Position, or if the axis is receiving or has received a new motion command to be started on the next communication cycle.

Parameters:: pAxisSelection – [in] A pointer to a AxisSelection class object that specifies the axes to stop.

WMX3APIFUNC ExecTimedStop(int axis, double timeMilliseconds)

Stop an axis that is currently in motion in the specified amount of time using a trapezoidal profile.

This function is identical to the Stop function, except the deceleration rate is set so that the axis stops in the specified time, and the motion profile is trapezoidal.

Remark

If the commanded axis is in Idle state, this function will return no error.

Parameters:

axis – [in] The axis to stop.
timeMilliseconds – [in] The time in milliseconds to stop the axis in.

WMX3APIFUNC ExecTimedStop(AxisSelection *pAxisSelection, double timeMilliseconds)

Stop multiple axes that are currently in motion in the specified amount of time using a trapezoidal profile.

This function executes the ExecTimedStop function for multiple axes. One stop time is specified for all axes.

Remark

If any of the commanded axes are in an invalid state, this function will return an error but the remainder of the commanded axes will be stopped. An axis is in an invalid state if the axis servo is not on, if the axis command mode is not Position, or if the axis is receiving or has received a new motion command to be started on the next communication cycle.

Parameters:

pAxisSelection – [in] A pointer to a AxisSelection class object that specifies the axes to stop.
timeMilliseconds – [in] The time in milliseconds to stop the axis in.

WMX3APIFUNC ExecTimedStop(unsigned int numCommands, TimeCommand *pTimeCommand)

Stop multiple axes that are currently in motion in the specified amounts of time using a trapezoidal profile.

This function executes the ExecTimedStop function for multiple axes. A separate stop time is specified for each axis.

Remark

If any of the commanded axes are in an invalid state, this function will return an error but the remainder of the commanded axes will be stopped. An axis is in an invalid state if the axis servo is not on, if the axis command mode is not Position, or if the axis is receiving or has received a new motion command to be started on the next communication cycle.

Parameters:

numCommands – [in] The number of stop motions. Each stop motion commands a single axis.
pTimeCommand – [in] A pointer to an array of objects of the TimeCommand class that contain the parameters of the motion. The number of objects in the array must be equal to numCommands. The timeMilliseconds values specify the time in milliseconds to stop the axis in.

WMX3APIFUNC Wait(int axis)

Start a blocking wait command, returning only when the axis becomes idle.

This function will block execution and will return execution to the calling thread only when the specified axis enters the Idle operation state.

Remark

If the specified axis goes offline, generates an amp alarm, triggers a limit switch, or changes to servo off state, this function will stop blocking and return the ServoOffline, AxisAmpAlarm, AxisSoftLimit, AxisNearLimit, AxisExternalLimit, AxisHardLimit, or ServoOff error code.

Each Device can only process one Wait function at one time. If multiple threads call the Wait function, the timings at which execution is returned to the calling threads is undefined. As explained in CreateDevice, each thread should create its own device.

Parameters:: axis – [in] The axis to wait for.

WMX3APIFUNC Wait(AxisSelection *pAxisSelection)

Start a blocking wait command, returning only when the axes become idle.

This function will block execution and will return execution to the calling thread only when the specified axes enter the Idle operation state.

Remark

All specified axes must be Idle at the same time for this function to return execution to the calling thread. If one of the specified axes becomes Idle, but then receives a new position command before every other axis becomes Idle, this function will not return execution until the new position command is finished.

If any specified axis goes offline, generates an amp alarm, triggers a limit switch, or changes to servo off state, this function will stop blocking and return the ServoOffline, AxisAmpAlarm, AxisSoftLimit, AxisNearLimit, AxisExternalLimit, AxisHardLimit, or ServoOff error code.

Each Device can only process one Wait function at one time. If multiple threads call the Wait function, the timings at which execution is returned to the calling threads is undefined. As explained in CreateDevice, each thread should create its own device.

Parameters:: pAxisSelection – [in] A pointer to a AxisSelection class object that specifies the axes to wait for.

WMX3APIFUNC Wait(WaitCondition *pWaitCondition)

Start a blocking wait command, returning only when the specified wait condition becomes true.

This function will block execution and will return execution to the calling thread only when the specified wait condition becomes true. See WaitCondition for information regarding the available wait conditions.

Remark

If the specified WaitConditionType is AxisIdle, MotionStarted, or MotionStartedOverrideReady, this function will monitor the specified axes for errors. If any specified axis goes offline, generates an amp alarm, triggers a limit switch, or changes to servo off state, this function will stop blocking and return the ServoOffline, AxisAmpAlarm, AxisSoftLimit, AxisNearLimit, AxisExternalLimit, AxisHardLimit, or ServoOff error code.

Each Device can only process one Wait function at one time. If multiple threads call the Wait function, the timings at which execution is returned to the calling threads is undefined. As explained in CreateDevice, each thread should create its own device.

Parameters:: pWaitCondition – [in] A pointer to a WaitCondition that describes the wait condition.

WMX3APIFUNC Wait(int axis, unsigned int waitTimeMilliseconds)

Start a blocking wait command, returning only when the axis becomes idle or the wait time elapses.

This function is similar to Wait, except it returns execution to the calling thread if the specified wait time elapses before the specified axis becomes Idle. If the specified axis is not Idle when this function returns, it will return the WaitTimeout error.

Remark

Parameters:

axis – [in] The axis to wait for.
waitTimeMilliseconds – [in] The maximum amount of time to wait before returning. If the waitTimeMilliseconds elapses before the axis becomes Idle, a WaitTimeout error will be returned. To specify no maximum wait time and wait indefinitely until the axis becomes idle, set this value to the constant INFINITE (0xFFFFFFFF).

WMX3APIFUNC Wait(AxisSelection *pAxisSelection, unsigned int waitTimeMilliseconds)

Start a blocking wait command, returning only when the axes become idle.

This function is similar to Wait, except it returns execution to the calling thread if the specified wait time elapses before the specified axis becomes Idle. If any of the specified axes is not Idle when this function returns, it will return the WaitTimeout error.

Remark

Parameters:

pAxisSelection – [in] A pointer to a AxisSelection class object that specifies the axes to wait for.
waitTimeMilliseconds – [in] The maximum amount of time to wait before returning. If the waitTimeMilliseconds elapses before the axes become Idle, a WaitTimeout error will be returned. To specify no maximum wait time and wait indefinitely until the axes become idle, set this value to the constant INFINITE (0xFFFFFFFF).

WMX3APIFUNC Wait(WaitCondition *pWaitCondition, unsigned int waitTimeMilliseconds)

Start a blocking wait command, returning only when the specified wait condition becomes true.

This function is similar to Wait, except it returns execution to the calling thread if the specified wait time elapses before the specified wait condition becomes true. If the specified wait condition is not true when this function returns, it will return the WaitTimeout error.

Remark

Parameters:

pWaitCondition – [in] A pointer to a WaitCondition that describes the wait condition.
waitTimeMilliseconds – [in] The maximum amount of time to wait before returning. If the waitTimeMilliseconds elapses before the axes become Idle, a WaitTimeout error will be returned. To specify no maximum wait time and wait indefinitely until the axes become idle, set this value to the constant INFINITE (0xFFFFFFFF).

WMX3APIFUNC Pause(int axis)

Pause the execution of a position command or interpolation command.

This function pauses the execution of a position command or interpolation command for one axis. The axis will decelerate to rest at the deceleration rate that was specified for the position command or interpolation command.

Remark

For interpolation commands, all interpolating axes will decelerate to a stop. Only one of the interpolating axes needs to be specified to this function.

Once at rest, the axis will remain in the Pos or Intpl operation state.

The position command or interpolation command may be resumed after the axis is at rest, or while the axis is decelerating. To resume the axis, call the Resume function.

A paused or pausing axis may also be stopped using Stop, or be overridden by another position command function.

The Pause and Resume functions are compatible with the following motion functions:

Parameters:: axis – [in] The axis to pause.

WMX3APIFUNC Pause(AxisSelection *pAxisSelection)

Pause the execution of a position command or interpolation command for multiple axes.

This function executes Pause for multiple axes.

Remark

All specified axes must be executing a position command or interpolation command. If one or more specified axes are not executing a position command or interpolation command, then this function will return an error.

Parameters:: pAxisSelection – [in] A pointer to a AxisSelection class object that specifies the axes to pause.

WMX3APIFUNC Resume(int axis)

Resume the execution of a paused position command or interpolation command.

This function resumes the execution of a position command or interpolation command that was paused by the Pause function.

Remark

For interpolation commands, all interpolating axes will resume motion. Only one of the interpolating axes needs to be specified to this function.

Parameters:: axis – [in] The axis to resume.

WMX3APIFUNC Resume(AxisSelection *pAxisSelection)

Resume the execution of a paused position command or interpolation command for multiple axes.

This function executes Resume for multiple axes.

Remark

All specified axes must be paused by the Pause function. If one or more specified axes are not paused, then the function will return an error.

Parameters:: pAxisSelection – [in] A pointer to a AxisSelection class object that specifies the axes to resume.

WMX3APIFUNC OverridePos(PosCommand *pPosCommand)

Override the target position of an axis currently executing a position command. The target position is specified as an absolute position.

This function overrides the target position of an axis that is executing one of the following position commands:

Remark

StartPos / StartMov
Pause (when pausing a StartPos / StartMov command)

The new target position is specified as an absolute position.

The profile of the command will remain unchanged, except the starting velocity of the profile will be ignored and the override will be executed from the current velocity.

Parameters:: pPosCommand – [in] A pointer to an object of the PosCommand class that contains the override position. Parameters other than axis and target are ignored.

WMX3APIFUNC OverrideMov(PosCommand *pPosCommand)

Override the target position of an axis currently executing a position command. The target position is specified as a relative position.

This function overrides the target position of an axis that is executing one of the following position commands:

Remark

StartPos / StartMov
Pause (when pausing a StartPos / StartMov command)

The new target position is specified as a relative position (relative to the target position of the position command that is overridden).

The profile of the command will remain unchanged, except the starting velocity of the profile will be ignored and the override will be executed from the current velocity.

Parameters:: pPosCommand – [in] A pointer to an object of the PosCommand class that contains the override position. Parameters other than axis and target are ignored.

WMX3APIFUNC OverrideVel(PosCommand *pPosCommand)

Override the velocity of an axis currently executing a position, jog, or velocity command.

This function overrides the target velocity of an axis that is executing one of the following position, jog, or velocity commands:

Remark

StartPos / StartMov
Pause (when pausing a StartPos / StartMov command)
StartJog
StartVel

For jog and velocity commands, the target velocity may be a negative value.

The profile of the command will remain unchanged, except the starting velocity of the profile will be ignored and the override will be executed from the current velocity.

Parameters:: pPosCommand – [in] A pointer to an object of the PosCommand class that contains the override velocity. Parameters other than axis and velocity in profile are ignored.

WMX3APIFUNC OverrideAcc(PosCommand *pPosCommand)

Override the acceleration of an axis currently executing a position, jog, or velocity command.

This function overrides the acceleration of an axis that is executing one of the following position, jog, or velocity commands:

Remark

StartPos / StartMov
Pause (when pausing a StartPos / StartMov command)
StartJog
StartVel

The profile of the command will remain unchanged, except the starting velocity of the profile will be ignored and the override will be executed from the current velocity.

Parameters:: pPosCommand – [in] A pointer to an object of the PosCommand class that contains the override acceleration. Parameters other than axis and acc in profile are ignored.

WMX3APIFUNC OverrideDec(PosCommand *pPosCommand)

Override the deceleration of an axis currently executing a position, jog, or velocity command.

This function overrides the deceleration of an axis that is executing one of the following position, jog, or velocity commands:

Remark

StartPos / StartMov
Pause (when pausing a StartPos / StartMov command)
StartJog
StartVel

The profile of the command will remain unchanged, except the starting velocity of the profile will be ignored and the override will be executed from the current velocity.

Parameters:: pPosCommand – [in] A pointer to an object of the PosCommand class that contains the override deceleration. Parameters other than axis and dec in profile are ignored.

WMX3APIFUNC OverrideJerkAcc(PosCommand *pPosCommand)

Override the acceleration jerk of an axis currently executing a position, jog, or velocity command.

This function overrides the acceleration jerk of an axis that is executing one of the following position, jog, or velocity commands:

Remark

StartPos / StartMov
Pause (when pausing a StartPos / StartMov command)
StartJog
StartVel

The profile of the command will remain unchanged, except the starting velocity of the profile will be ignored and the override will be executed from the current velocity.

Parameters:: pPosCommand – [in] A pointer to an object of the PosCommand class that contains the override acceleration jerk. Parameters other than axis and jerkAcc in profile are ignored.

WMX3APIFUNC OverrideJerkDec(PosCommand *pPosCommand)

Override the deceleration jerk of an axis currently executing a position, jog, or velocity command.

This function overrides the deceleration jerk of an axis that is executing one of the following position, jog, or velocity commands:

Remark

StartPos / StartMov
Pause (when pausing a StartPos / StartMov command)
StartJog
StartVel

The profile of the command will remain unchanged, except the starting velocity of the profile will be ignored and the override will be executed from the current velocity.

Parameters:: pPosCommand – [in] A pointer to an object of the PosCommand class that contains the override deceleration jerk. Parameters other than axis and jerkDec in profile are ignored.

WMX3APIFUNC OverrideProfile(PosCommand *pPosCommand)

Override the entire profile of an axis currently executing a position, jog, or velocity command.

This function overrides the entire profile of an axis that is executing one of the following position, jog, or velocity commands:

Remark

StartPos / StartMov
Pause (when pausing a StartPos / StartMov command)
StartJog
StartVel

Only the profile is overridden. The target position for axes executing position commands or the target velocity for axes executing jog or velocity commands are not changed.

Parameters:: pPosCommand – [in] A pointer to an object of the PosCommand class that contains the override profile.

WMX3APIFUNC OverridePos(unsigned int numCommands, PosCommand *pPosCommand)

Override the target positions of multiple axes currently executing position commands. The target positions are specified as absolute positions.

This command executes the OverridePos function for multiple axes.

Remark

This function returns an error if any of the commanded axes cannot execute the override. An error is returned if any of the commanded axes are in Idle state.

Parameters:

numCommands – [in] The number of overrides. Each override commands a single axis.
pPosCommand – [in] A pointer to an array of objects of the PosCommand class that contain the parameters of the override. The number of objects in the array must be equal to numCommands.

WMX3APIFUNC OverrideMov(unsigned int numCommands, PosCommand *pPosCommand)

Override the target positions of multiple axes currently executing position commands. The target positions are specified as relative positions.

This command executes the OverrideMov function for multiple axes.

Remark

This function returns an error if any of the commanded axes cannot execute the override. An error is returned if any of the commanded axes are in Idle state.

Parameters:

numCommands – [in] The number of overrides. Each override commands a single axis.
pPosCommand – [in] A pointer to an array of objects of the PosCommand class that contain the parameters of the override. The number of objects in the array must be equal to numCommands.

WMX3APIFUNC OverrideVel(unsigned int numCommands, PosCommand *pPosCommand)

Override the velocities of multiple axes currently executing position, jog, or velocity commands.

This command executes the OverrideVel function for multiple axes.

Remark

This function returns an error if any of the commanded axes cannot execute the override. An error is returned if any of the commanded axes are in Idle state.

Parameters:

numCommands – [in] The number of overrides. Each override commands a single axis.
pPosCommand – [in] A pointer to an array of objects of the PosCommand class that contain the parameters of the override. The number of objects in the array must be equal to numCommands.

WMX3APIFUNC OverrideAcc(unsigned int numCommands, PosCommand *pPosCommand)

Override the accelerations of multiple axes currently executing position, jog, or velocity commands.

This command executes the OverrideAcc function for multiple axes.

Remark

This function returns an error if any of the commanded axes cannot execute the override. An error is returned if any of the commanded axes are in Idle state.

Parameters:

numCommands – [in] The number of overrides. Each override commands a single axis.
pPosCommand – [in] A pointer to an array of objects of the PosCommand class that contain the parameters of the override. The number of objects in the array must be equal to numCommands.

WMX3APIFUNC OverrideDec(unsigned int numCommands, PosCommand *pPosCommand)

Override the decelerations of multiple axes currently executing position, jog, or velocity commands.

This command executes the OverrideDec function for multiple axes.

Remark

This function returns an error if any of the commanded axes cannot execute the override. An error is returned if any of the commanded axes are in Idle state.

Parameters:

numCommands – [in] The number of overrides. Each override commands a single axis.
pPosCommand – [in] A pointer to an array of objects of the PosCommand class that contain the parameters of the override. The number of objects in the array must be equal to numCommands.

WMX3APIFUNC OverrideJerkAcc(unsigned int numCommands, PosCommand *pPosCommand)

Override the acceleration jerks of multiple axes currently executing position, jog, or velocity commands.

This command executes the OverrideJerkAcc function for multiple axes.

Remark

This function returns an error if any of the commanded axes cannot execute the override. An error is returned if any of the commanded axes are in Idle state.

Parameters:

numCommands – [in] The number of overrides. Each override commands a single axis.
pPosCommand – [in] A pointer to an array of objects of the PosCommand class that contain the parameters of the override. The number of objects in the array must be equal to numCommands.

WMX3APIFUNC OverrideJerkDec(unsigned int numCommands, PosCommand *pPosCommand)

Override the deceleration jerks of multiple axes currently executing position, jog, or velocity commands.

This command executes the OverrideJerkDec function for multiple axes.

Remark

This function returns an error if any of the commanded axes cannot execute the override. An error is returned if any of the commanded axes are in Idle state.

Parameters:

numCommands – [in] The number of overrides. Each override commands a single axis.
pPosCommand – [in] A pointer to an array of objects of the PosCommand class that contain the parameters of the override. The number of objects in the array must be equal to numCommands.

WMX3APIFUNC OverrideProfile(unsigned int numCommands, PosCommand *pPosCommand)

Override the entire profiles of multiple axes currently executing position, jog, or velocity commands.

This command executes the OverrideProfile function for multiple axes.

Remark

This function returns an error if any of the commanded axes cannot execute the override. An error is returned if any of the commanded axes are in Idle state.

Parameters:

numCommands – [in] The number of overrides. Each override commands a single axis.
pPosCommand – [in] A pointer to an array of objects of the PosCommand class that contain the parameters of the override. The number of objects in the array must be equal to numCommands.

WMX3APIFUNC StopJogAtPos(PosCommand *pPosCommand)

Stop an axis executing a jog command at a timing that will cause the axis to stop at exactly the specified position.

This function operates on an axis currently executing a jog command. The axis will smoothly transition from executing a jog command to executing a stop command. The final position of the axis after stopping will be at the specified target position.

Remark

When this function commands a single turn axis and the target position is between 0 and the single turn encoder count, then the axis will continue rotating in the current direction of rotation and start stopping at the position at which the axis would finish movement at the target position given the specified profile parameters.

Parameters:: pPosCommand – [in] A pointer to a PosCommand that contains the stop jog at pos motion command parameters.

WMX3APIFUNC StopJogAtPos(unsigned int numCommands, PosCommand *pPosCommand)

Stop multiple axes executing jog commands at timing that wil cause the axes to stop at exactly the specified positions.

This command executes the StopJogAtPos function for multiple axes.

Remark

Parameters:

numCommands – [in] The number of stop jog at pos motion commands. Each command controls a single axis.
pPosCommand – [in] A pointer to an array of objects of the PosCommand class that contain the parameters of the coordinated position commands. The number of objects in the array must be equal to numCommands.

WMX3APIFUNC SuperimposeMov(PosCommand *pPosCommand)

Start a relative position superimposed motion command. The superimposed motion command will execute on top of any other motion that the axis may already be executing.

This function moves the specified axis by the specified distance on top of any other motion that the axis may already be executing. During the superimposed motion, the velocity of the axis will equal the sum of the velocities of the two motions. The superimposed motion will have an acceleration segment and a deceleration segment, which may or may not coincide with the acceleration and deceleration segments of the motion the axis was executing. Depending on the profile parameters and the type of motion that the axis is already executing, the superimposed motion may complete before or after the motion that the axis is already executing.

Remark

The motion caused by this command does not affect the axis OperationState. For example, if this function is called while the axis is Idle, the axis will move, but remain in the idle operation state. To check whether an axis is executing superimposed motion, see the Exec Superimposed Motion status.

The motion caused by this command cannot be stopped using normal Stop functions. To stop superimposed motion, use the StopSuperimpose function.

This function currently supports superimposing axes in Idle, Pos, or Jog operation states. If this function is called for axes in other operation states, an error will be returned.

Parameters:: pPosCommand – [in] A pointer to an object of the PosCommand class that contains the parameters of the superimposed motion command.

WMX3APIFUNC SuperimposeMov(unsigned int numCommands, PosCommand *pPosCommand)

Start superimposed relative position commands for multiple axes. The superimposed motion commands will execute on top of any other motion that the axes may already be executing.

This command executes the SuperimposeMov function for multiple axes.

Remark

This function currently supports superimposing axes in Idle, Pos, or Jog operation states. If this function is called for axes in other operation states, an error will be returned.

Parameters:

numCommands – [in] The number of superimposed motion commands. Each command controls a single axis.
pPosCommand – [in] A pointer to an array of objects of the PosCommand class that contain the parameters of the superimposed motion commands.

WMX3APIFUNC StopSuperimpose(int axis)

Stop a superimposed motion.

This function stops the superimposed motion of an axis before it completes. The superimposed motion will decelerate to a stop using the deceleration specified for the profile of the superimposed motion. Any motion that the axis was already executing under the superimposed motion will remain unaffected. The axis will still travel an extra distance equal to the distance traveled due to the superimposed motion before the superimposed motion is stopped.

Remark

Parameters:: axis – [in] The axis to stop.

WMX3APIFUNC StopSuperimpose(AxisSelection *pAxisSelection)

Stop the superimposed motion of multiple axes.

This command executes the StopSuperimpose function for multiple axes.

Remark

Parameters:: pAxisSelection – [in] A pointer to a AxisSelection class object that specifies the axes to stop.

WMX3APIFUNC SimulatePos(SimulatePosCommand *pSimulatePosCommand, double *pPeakVelocity, double *pTotalTimeMilliseconds, double *pAccelerationTimeMilliseconds, double *pCruiseTimeMilliseconds, double *pDecelerationTimeMilliseconds)

Simulate a position command without moving any axes. The peak velocity, acceleration time, cruise time (the time the axis velocity is constant), deceleration time, and total profile time of the position command are returned.

Parameters:

pSimulatePosCommand – [in] A pointer to a SimulatePosCommand that contains the simulated position command parameters.
pPeakVelocity – [out] A pointer to a double type variable that will contain the highest absolute velocity that the axis moves at during the simulated motion command. This value is in user units per second.
pTotalTimeMilliseconds – [out] A pointer to a double type variable that will contain the total execution time of the motion command. This value is in units of milliseconds.
pAccelerationTimeMilliseconds – [out] A pointer to a double variable that will contain the time that the axis spends accelerating during the motion command. This value is in units of milliseconds.
pCruiseTimeMilliseconds – [out] A pointer to a double variable that will contain the time that the axis spends at the commanded velocity during the motion command. This value is in units of milliseconds.
pDecelerationTimeMilliseconds – [out] A pointer to a double variable that will contain the time that the axis spends decelerating during the motion command. If the axis changes direction during the motion command, the deceleration time does not include the time spent decelerating before changing direction. This value is in units of milliseconds.

WMX3APIFUNC SimulateLinearIntplPos(SimulateLinearIntplCommand *pSimulateLinearIntplCommand, double *pPeakVelocity, double *pTotalTimeMilliseconds, double *pAccelerationTimeMilliseconds, double *pCruiseTimeMilliseconds, double *pDecelerationTimeMilliseconds)

Simulate a linear interpolation motion command without moving any axes. The peak velocity, acceleration time, cruise time (the time the axis velocity is constant), deceleration time, and total profile time of the linear interpolation motion command are returned.

Parameters:

pSimulateLinearIntplCommand – [in] A pointer to a SimulateLinearIntplCommand that contains the simulated linear interpolation motion command parameters.
pPeakVelocity – [out] A pointer to a double type variable that will contain the highest composite velocity of the interpolating axes during the simulated motion command. This value is in user units per second.
pTotalTimeMilliseconds – [out] A pointer to an int type variable that will contain the total execution time of the motion command. This value is in units of milliseconds.
pAccelerationTimeMilliseconds – [out] A pointer to an int variable that will contain the time that the axis spends accelerating during the motion command. This value is in units of milliseconds.
pCruiseTimeMilliseconds – [out] A pointer to an int variable that will contain the time that the axis spends at the commanded velocity during the motion command. This value is in units of milliseconds.
pDecelerationTimeMilliseconds – [out] A pointer to an int variable that will contain the time that the axis spends decelerating during the motion command. If the axis changes direction during the motion command, the deceleration time does not include the time spent decelerating before changing direction. This value is in units of milliseconds.

WMX3APIFUNC SimulatePosAtTime(SimulatePosCommand *pSimulatePosCommand, int returnType, double timeMilliseconds, double *pCalculatedPos, double *pCalculatedVel)

Simulate a position command without moving any axes. The position and velocity of the axis after the motion command runs for the specified time are returned.

Parameters:

pSimulatePosCommand – [in] A pointer to a SimulatePosCommand that contains the simulated position command parameters.
returnType – [in] Determines whether the value specified for the “timeMilliseconds” argument represents the time elapsed or the time remaining. If 0, the “timeMilliseconds” specified is the time elapsed. If 1, the “timeMilliseconds” specified is the time remaining.
timeMilliseconds – [in] The amount of time elapsed or remaining, depending on the value specified for the “returnType” function argument. This value is in units of milliseconds.
pCalculatedPos – [out] A pointer to a double type variable that will contain the position that the axis is at after the specified amount of time elapses or remains. This value is in user units.
pCalculatedVel – [out] A pointer to a double type variable that will contain the velocity that the axis is at after the specified amount of time elapses or remains. This value is in user units per second.

WMX3APIFUNC SimulatePosAtTime(SimulateLinearIntplCommand *pSimulateLinearIntplCommand, double timeMilliseconds, double *pPosArray, double *pMoveDistance, double *pRemainDistance, double *pTotalDistance)

Simulate a linear interpolation motion command without moving any axes. The move distance, remain distance, and total distance after the linear interpolation runs for a specified amount of time are returned.

Parameters:

pSimulateLinearIntplCommand – [in] A pointer to a SimulateLinearIntplCommand that contains the simulated linear interpolation motion command parameters.
timeMilliseconds – [in] The amount of time elapsed. This value is in units of milliseconds.
pPosArray – [out] A pointer to a double type array that will contains the positions of the interpolated axes after the specified amount of time elapses. The size of the array must be equal to or greater than the axisCount of pSimulateLinearIntplCommand->linearIntplCommand.
pMoveDistance – [out] A pointer to a double type variable that will contain the total distance moved along the linear interpolation after the specified time elapses.
pRemainDistance – [out] A pointer to a double type variable that will contain the total distance remaining in the linear interpolation after the specified time elapses.
pTotalDistance – [out] A pointer to a double type variable that will contain the total distance along the entire linear interpolation. This value is always equal to the sum of the values returned by pMoveDistance and pRemainDistance.

WMX3APIFUNC SimulateTimeAtPos(SimulatePosCommand *pSimulatePosCommand, double specificPos, double *pMoveTimeMilliseconds, double *pRemainTimeMilliseconds)

Simulate a position command without moving any axes. The elapsed time and remaining time after the axis reaches the specified position are returned.

Parameters:

pSimulatePosCommand – [in] A pointer to a SimulatePosCommand that contains the simulated position command parameters.
specificPos – [in] The position at which to calculate the “move time” and “remain time” of the profile. This value is in user units.
pMoveTimeMilliseconds – [out] A pointer to an double type variable that will contain the amount of time elapsed when the axis first reaches the “specific position.” This value is in units of milliseconds.
pRemainTimeMilliseconds – [out] A pointer to an double type variable that will contain the amount of time remaining in the motion command when the axis reaches the “specific position.” This value is in units of milliseconds.

WMX3APIFUNC SimulateTimeAtDist(SimulateLinearIntplCommand *pSimulateLinearIntplCommand, double specificDistance, double *pMoveTimeMilliseconds, double *pRemainTimeMilliseconds, double *pTotalTimeMilliseconds)

Simulate a linear interpolation motion command without moving any axes. The move time, remain time, and total time after the linear interpolation runs for a specified distance are returned.

Parameters:

pSimulateLinearIntplCommand – [in] A pointer to a SimulateLinearIntplCommand that contains the simulated linear interpolation motion command parameters.
specificDistance – [in] The distance along the linear interpolation at which to calculate the move time, remain time, and total time of the linear interpolation command. This is the distance in N dimensions, where N is the number of axes in the interpolation.
pMoveTimeMilliseconds – [out] A pointer to a double type variable that will contain the amount of time elapsed when the axes travel a distance equal to specificDistance. The units are milliseconds.
pRemainTimeMilliseconds – [out] A pointer to a double type variable that will contain the amount of time remaining when the axes travel a distance equal to specificDistance. The units are milliseconds.
pTotalTimeMilliseconds – [out] A pointer to a double type variable that will contain the total time that the linear interpolation takes to complete. This value is always equal to the sum of the values returned by pMoveTime and pRemainTime. The units are milliseconds.

WMX3APIFUNC CreatePVTBuffer(int axis, unsigned int points)

Allocate buffer memory to an axis for the execution of PVT motion commands.

When the WMX3 engine is started, no memory is allocated for the execution of PVT motion commands. This function allocates memory to execute the following PVT motion commands:

Remark

StartPVT
StartPVT (Interpolation)
StartPT
StartVT
StartAT

If any of the above commands are called before this function, a default buffer memory for maxPvtAppendPoints will be allocated. If the memory allocation fails, or if more than maxPvtAppendPoints points are specified, the PVT motion command will return an error. To execute a PVT motion command with more than maxPvtAppendPoints points, this function must be called beforehand, specifying the required number of points.

For StartPVT (Interpolation), buffer memory must be separately allocated for all interpolating axes.

Allocating buffer memory space is an operation that can fail due to lack of memory space or fragmentation of memory. For deterministic operation, this function should be called during initialization to allocate memory for all axes that will potentially execute a PVT motion command.

The maximum size of the PVT buffer memory space of each axis is 2GB-1Byte (2147483647 bytes). Specifying a larger size will cause this function to return the RequestedBufferTooLarge error.

It is not necessary to call this function again after buffer memory has been allocated once. (When the WMX3 engine is restarted, this function must be called again to allocate buffer memory.)

Buffer memory that has been allocated can be freed using the FreePVTBuffer function. After freeing the PVT buffer memory of an axis, this function can be called again to reallocate a different amount of buffer memory.

It is not necessary to free allocated memory using FreePVTBuffer before exiting the program. Any allocated memory is automatically freed when the WMX3 engine is closed.

The GetPVTBufferPoints function can be used to find the amount of PVT buffer memory currently allocated to an axis.

The GetPVTBytesPerPoint function can be used to convert the buffer memory size from points to bytes.

See also

Parameters:

axis – [in] The axis to allocate the buffer memory.
points – [in] The number of points to allocate memory for. Each PVT, PT, VT, or AT point occupies one point in the memory.

WMX3APIFUNC FreePVTBuffer(int axis)

Free PVT buffer memory for an axis.

This function frees the buffer memory that has been allocated with the CreatePVTBuffer function. This allows CreatePVTBuffer to be called again to allocate a different amount of memory.

Remark

It is not necessary to call this function before exiting the program, as any allocated memory is automatically freed when the WMX3 engine closes.

The freed memory, after a brief delay, will become available for the system to use for another purpose.

Parameters:: axis – [in] The axis to free the buffer memory.

WMX3APIFUNC GetPVTBufferPoints(int axis, unsigned int *pPoints)

Get the amount of PVT buffer memory currently allocated to an axis.

This function obtains the amount of PVT buffer memory currently allocated to an axis, in units of points.

Remark

To convert the buffer memory size from the number of points to bytes, use the GetPVTBytesPerPoint function.

If no buffer memory has been allocated to the specified channel yet, this function will return 0 in the pPoints parameter.

Parameters:

axis – [in] The axis to read the buffer memory size.
pPoints – [out] A pointer to an unsigned int that will contain the number of points that can be stored in the buffer memory.

WMX3APIFUNC GetPVTBytesPerPoint(unsigned int *pBytes)

Get the number of bytes required per point data in the PVT buffer memory.

This function obtains the number of bytes of memory required to store one point data in the PVT buffer memory. This can be used to calculate the number of bytes of buffer memory required to store a particular number of points. For example, if this function returns 48, the number of bytes required to store 100000 points is 48*100000 = 4800000, or approximately 4.8MB.

Remark

Parameters:: pBytes – [out] A pointer to an unsigned int that will contain the number of bytes of memory required per point data.

WMX3APIFUNC StartPVT(PVTCommand *pPVTCommand, unsigned int numAddlCommands = 0, PVTAdditionalCommand *pPVTAddlCommand = NULL)

Start executing a PVT motion command.

A PVT motion command consists of a sequence of position-velocity-time points. The axis will travel through each point position at the specified time and velocity. The acceleration is linear between two points, but may not be continuous at the interface of each point.

Remark

The PVT command will start with the initial position equal to the current command position of the axis, the initial velocity equal to 0, and the initial time equal to 0. This initial point does not need to be specified (if the first point of PVTCommand has a timeMilliseconds of 0, that point is ignored).

The point times must be specified in ascending order. The point times do not need to be a multiple of the cycle time. The velocity is signed, and can accept positive and negative values. The minimum number of points is 1 (with a time greater than 0).

This function allocates memory dynamically when called for the first time for the commanded axis after starting the WMX3 engine. See CreatePVTBuffer for additional information. See Function Calls Related to Memory Allocation for additional information regarding dynamically allocated memory.

The numAddlCommands and pPVTAddlCommand optional arguments can be specified to append additional points to the PVT command after the points defined in pPVTCommand. The pPVTAddlCommand argument is specified as a pointer to an array, and any number of additional commands may be specified as long as the PVT memory buffer for the commanded axis (created with CreatePVTBuffer) is large enough to hold all points that are defined in pPVTCommand and pPVTAddlCommand.

See also

Parameters:

pPVTCommand – [in] A pointer to a PVTCommand that contains the PVT parameters.
numAddlCommands – [in] An optional argument that specifies the number of additional commands to append after pPVTCommand.
pPVTAddlCommand – [in] An optional argument that is a pointer to an array of PVTAdditionalCommand objects. The size of the array should be equal to numAddlCommands.

WMX3APIFUNC StartPVT(PVTCommand *pPVTCommand, Trigger *pTrigger, unsigned int numAddlCommands = 0, PVTAdditionalCommand *pPVTAddlCommand = NULL)

Start executing a triggered PVT motion command.

A PVT motion command consists of a sequence of position-velocity-time points. The axis will travel through each point position at the specified time and velocity. The acceleration is linear between two points, but may not be continuous at the interface of each point.

Remark

The PVT command will start with the initial position equal to the current command position of the axis, the initial velocity equal to 0, and the initial time equal to 0. This initial point does not need to be specified (if the first point of PVTCommand has a timeMilliseconds of 0, that point is ignored).

The point times must be specified in ascending order. The point times do not need to be a multiple of the cycle time. The velocity is signed, and can accept positive and negative values. The minimum number of points is 1 (with a time greater than 0).

This function allocates memory dynamically when called for the first time for the commanded axis after starting the WMX3 engine. See CreatePVTBuffer for additional information. See Function Calls Related to Memory Allocation for additional information regarding dynamically allocated memory.

The numAddlCommands and pPVTAddlCommand optional arguments can be specified to append additional points to the PVT command after the points defined in pPVTCommand. The pPVTAddlCommand argument is specified as a pointer to an array, and any number of additional commands may be specified as long as the PVT memory buffer for the commanded axis (created with CreatePVTBuffer) is large enough to hold all points that are defined in pPVTCommand and pPVTAddlCommand.

The motion will begin when the specified trigger condition is satisfied.

See also

Parameters:

pPVTCommand – [in] A pointer to a PVTCommand that contains the PVT parameters.
numAddlCommands – [in] An optional argument that specifies the number of additional commands to append after pPVTCommand.
pPVTAddlCommand – [in] An optional argument that is a pointer to an array of PVTAdditionalCommand objects. The size of the array should be equal to numAddlCommands.
pTrigger – [in] A pointer to an object of the Trigger class that specifies the trigger condition.

WMX3APIFUNC StartPVT(PVTCommand *pPVTCommand, TriggerEvents *pTriggerEvents, unsigned int numAddlCommands = 0, PVTAdditionalCommand *pPVTAddlCommand = NULL)

Start executing a triggered PVT motion command with multiple trigger events.

A PVT motion command consists of a sequence of position-velocity-time points. The axis will travel through each point position at the specified time and velocity. The acceleration is linear between two points, but may not be continuous at the interface of each point.

Remark

The PVT command will start with the initial position equal to the current command position of the axis, the initial velocity equal to 0, and the initial time equal to 0. This initial point does not need to be specified (if the first point of PVTCommand has a timeMilliseconds of 0, that point is ignored).

The point times must be specified in ascending order. The point times do not need to be a multiple of the cycle time. The velocity is signed, and can accept positive and negative values. The minimum number of points is 1 (with a time greater than 0).

This function allocates memory dynamically when called for the first time for the commanded axis after starting the WMX3 engine. See CreatePVTBuffer for additional information. See Function Calls Related to Memory Allocation for additional information regarding dynamically allocated memory.

The numAddlCommands and pPVTAddlCommand optional arguments can be specified to append additional points to the PVT command after the points defined in pPVTCommand. The pPVTAddlCommand argument is specified as a pointer to an array, and any number of additional commands may be specified as long as the PVT memory buffer for the commanded axis (created with CreatePVTBuffer) is large enough to hold all points that are defined in pPVTCommand and pPVTAddlCommand.

The motion will begin when the specified multi-event trigger condition is satisfied.

See also

Parameters:

pPVTCommand – [in] A pointer to a PVTCommand that contains the PVT parameters.
numAddlCommands – [in] An optional argument that specifies the number of additional commands to append after pPVTCommand.
pPVTAddlCommand – [in] An optional argument that is a pointer to an array of PVTAdditionalCommand objects. The size of the array should be equal to numAddlCommands.
pTriggerEvents – [in] A pointer to an object of the TriggerEvents class that contains the trigger events.

WMX3APIFUNC StartPVT(PVTIntplCommand *pPVTCommand, unsigned int numAddlCommands = 0, PVTIntplAdditionalCommand *pPVTAddlCommand = NULL)

Start executing a PVT interpolation motion command.

This function is a variation of StartPVT that can command up to maxPvtInterpolateAxes axes at once. The commanded axes will all start motion during the same communication cycle, allowing coordination between the axes with the careful selection of points.

Remark

This function allocates memory dynamically when called for the first time for each of the commanded axes after starting the WMX3 engine. See CreatePVTBuffer for additional information. See Function Calls Related to Memory Allocation for additional information regarding dynamically allocated memory.

The numAddlCommands and pPVTAddlCommand optional arguments can be specified to append additional points to the PVT interpolation command after the points defined in pPVTCommand. The pPVTAddlCommand argument is specified as a pointer to an array, and any number of additional commands may be specified as long as the PVT memory buffer for each commanded axis (created with CreatePVTBuffer) is large enough to hold all points that are defined for that axis in pPVTCommand and pPVTAddlCommand.

See also

Parameters:

pPVTCommand – [in] A pointer to a PVTIntplCommand that contains the PVT parameters.
numAddlCommands – [in] An optional argument that specifies the number of additional commands to append after pPVTCommand.
pPVTAddlCommand – [in] An optional argument that is a pointer to an array of PVTIntplAdditionalCommand objects. The size of the array should be equal to numAddlCommands.

WMX3APIFUNC StartPVT(PVTIntplCommand *pPVTCommand, Trigger *pTrigger, unsigned int numAddlCommands = 0, PVTIntplAdditionalCommand *pPVTAddlCommand = NULL)

Start executing a triggered PVT interpolation motion command.

This function is a variation of StartPVT that can command up to maxPvtInterpolateAxes axes at once. The commanded axes will all start motion during the same communication cycle, allowing coordination between the axes with the careful selection of points.

Remark

This function allocates memory dynamically when called for the first time for each of the commanded axes after starting the WMX3 engine. See CreatePVTBuffer for additional information. See Function Calls Related to Memory Allocation for additional information regarding dynamically allocated memory.

The numAddlCommands and pPVTAddlCommand optional arguments can be specified to append additional points to the PVT interpolation command after the points defined in pPVTCommand. The pPVTAddlCommand argument is specified as a pointer to an array, and any number of additional commands may be specified as long as the PVT memory buffer for each commanded axis (created with CreatePVTBuffer) is large enough to hold all points that are defined for that axis in pPVTCommand and pPVTAddlCommand.

The motion will begin when the specified trigger condition is satisfied.

See also

Parameters:

pPVTCommand – [in] A pointer to a PVTIntplCommand that contains the PVT parameters.
numAddlCommands – [in] An optional argument that specifies the number of additional commands to append after pPVTCommand.
pPVTAddlCommand – [in] An optional argument that is a pointer to an array of PVTIntplAdditionalCommand objects. The size of the array should be equal to numAddlCommands.
pTrigger – [in] A pointer to an object of the Trigger class that specifies the trigger condition.

WMX3APIFUNC StartPVT(PVTIntplCommand *pPVTCommand, TriggerEvents *pTriggerEvents, unsigned int numAddlCommands = 0, PVTIntplAdditionalCommand *pPVTAddlCommand = NULL)

Start executing a triggered PVT interpolation motion command with multiple trigger events.

This function is a variation of StartPVT that can command up to maxPvtInterpolateAxes axes at once. The commanded axes will all start motion during the same communication cycle, allowing coordination between the axes with the careful selection of points.

Remark

This function allocates memory dynamically when called for the first time for each of the commanded axes after starting the WMX3 engine. See CreatePVTBuffer for additional information. See Function Calls Related to Memory Allocation for additional information regarding dynamically allocated memory.

The numAddlCommands and pPVTAddlCommand optional arguments can be specified to append additional points to the PVT interpolation command after the points defined in pPVTCommand. The pPVTAddlCommand argument is specified as a pointer to an array, and any number of additional commands may be specified as long as the PVT memory buffer for each commanded axis (created with CreatePVTBuffer) is large enough to hold all points that are defined for that axis in pPVTCommand and pPVTAddlCommand.

The motion will begin when the specified multi-event trigger condition is satisfied.

See also

Parameters:

pPVTCommand – [in] A pointer to a PVTIntplCommand that contains the PVT parameters.
numAddlCommands – [in] An optional argument that specifies the number of additional commands to append after pPVTCommand.
pPVTAddlCommand – [in] An optional argument that is a pointer to an array of PVTIntplAdditionalCommand objects. The size of the array should be equal to numAddlCommands.
pTriggerEvents – [in] A pointer to an object of the TriggerEvents class that contains the trigger events.

WMX3APIFUNC StartPT(PTCommand *pPTCommand, unsigned int numAddlCommands = 0, PTAdditionalCommand *pPTAddlCommand = NULL)

Start executing a PT motion command.

A PT motion command consists of a sequence of position-time points. The axis will travel through each point position at the specified time. The velocity between two points is constant, but may not be continuous at the interface of each point.

Remark

The PT command will start with the initial position equal to the current command position of the axis, the initial velocity equal to 0, and the initial time equal to 0. This initial point does not need to be specified (if the first point of PTCommand has a timeMilliseconds of 0, that point is ignored).

The point times must be specified in ascending order. The point times do not need to be a multiple of the cycle time. The minimum number of points is 1 (with a time greater than 0).

This function will construct a rudimentary profile consisting of sequences of constant-velocity segments. The acceleration when switching from one velocity to another is infinite.

This function allocates memory dynamically when called for the first time for the commanded axis after starting the WMX3 engine. See CreatePVTBuffer for additional information. See Function Calls Related to Memory Allocation for additional information regarding dynamically allocated memory.

The numAddlCommands and pPTAddlCommand optional arguments can be specified to append additional points to the PT command after the points defined in pPTCommand. The pPTAddlCommand argument is specified as a pointer to an array, and any number of additional commands may be specified as long as the PVT memory buffer for the commanded axis (created with CreatePVTBuffer) is large enough to hold all points that are defined in pPTCommand and pPTAddlCommand.

See also

Parameters:

pPTCommand – [in] A pointer to a PTCommand that contains the PT parameters.
numAddlCommands – [in] An optional argument that specifies the number of additional commands to append after pPVTCommand.
pPTAddlCommand – [in] An optional argument that is a pointer to an array of PTAdditionalCommand objects. The size of the array should be equal to numAddlCommands.

WMX3APIFUNC StartPT(PTCommand *pPTCommand, Trigger *pTrigger, unsigned int numAddlCommands = 0, PTAdditionalCommand *pPTAddlCommand = NULL)

Start executing a triggered PT motion command.

A PT motion command consists of a sequence of position-time points. The axis will travel through each point position at the specified time. The velocity between two points is constant, but may not be continuous at the interface of each point.

Remark

The PT command will start with the initial position equal to the current command position of the axis, the initial velocity equal to 0, and the initial time equal to 0. This initial point does not need to be specified (if the first point of PTCommand has a timeMilliseconds of 0, that point is ignored).

The point times must be specified in ascending order. The point times do not need to be a multiple of the cycle time. The minimum number of points is 1 (with a time greater than 0).

This function will construct a rudimentary profile consisting of sequences of constant-velocity segments. The acceleration when switching from one velocity to another is infinite.

This function allocates memory dynamically when called for the first time for the commanded axis after starting the WMX3 engine. See CreatePVTBuffer for additional information. See Function Calls Related to Memory Allocation for additional information regarding dynamically allocated memory.

The numAddlCommands and pPTAddlCommand optional arguments can be specified to append additional points to the PT command after the points defined in pPTCommand. The pPTAddlCommand argument is specified as a pointer to an array, and any number of additional commands may be specified as long as the PVT memory buffer for the commanded axis (created with CreatePVTBuffer) is large enough to hold all points that are defined in pPTCommand and pPTAddlCommand.

The motion will begin when the specified trigger condition is satisfied.

See also

Parameters:

pPTCommand – [in] A pointer to a PTCommand that contains the PT parameters.
numAddlCommands – [in] An optional argument that specifies the number of additional commands to append after pPVTCommand.
pPTAddlCommand – [in] An optional argument that is a pointer to an array of PTAdditionalCommand objects. The size of the array should be equal to numAddlCommands.
pTrigger – [in] A pointer to an object of the Trigger class that specifies the trigger condition.

WMX3APIFUNC StartPT(PTCommand *pPTCommand, TriggerEvents *pTriggerEvents, unsigned int numAddlCommands = 0, PTAdditionalCommand *pPTAddlCommand = NULL)

Start executing a triggered PT motion command with multiple trigger events.

A PT motion command consists of a sequence of position-time points. The axis will travel through each point position at the specified time. The velocity between two points is constant, but may not be continuous at the interface of each point.

Remark

The PT command will start with the initial position equal to the current command position of the axis, the initial velocity equal to 0, and the initial time equal to 0. This initial point does not need to be specified (if the first point of PTCommand has a timeMilliseconds of 0, that point is ignored).

The point times must be specified in ascending order. The point times do not need to be a multiple of the cycle time. The minimum number of points is 1 (with a time greater than 0).

This function will construct a rudimentary profile consisting of sequences of constant-velocity segments. The acceleration when switching from one velocity to another is infinite.

This function allocates memory dynamically when called for the first time for the commanded axis after starting the WMX3 engine. See CreatePVTBuffer for additional information. See Function Calls Related to Memory Allocation for additional information regarding dynamically allocated memory.

The numAddlCommands and pPTAddlCommand optional arguments can be specified to append additional points to the PT command after the points defined in pPTCommand. The pPTAddlCommand argument is specified as a pointer to an array, and any number of additional commands may be specified as long as the PVT memory buffer for the commanded axis (created with CreatePVTBuffer) is large enough to hold all points that are defined in pPTCommand and pPTAddlCommand.

The motion will begin when the specified multi-event trigger condition is satisfied.

See also

Parameters:

pPTCommand – [in] A pointer to a PTCommand that contains the PT parameters.
numAddlCommands – [in] An optional argument that specifies the number of additional commands to append after pPVTCommand.
pPTAddlCommand – [in] An optional argument that is a pointer to an array of PTAdditionalCommand objects. The size of the array should be equal to numAddlCommands.
pTriggerEvents – [in] A pointer to an object of the TriggerEvents class that contains the trigger events.

WMX3APIFUNC StartVT(VTCommand *pVTCommand, unsigned int numAddlCommands = 0, VTAdditionalCommand *pVTAddlCommand = NULL)

Start executing a VT motion command.

A VT motion command consists of a sequence of velocity-time points. The velocity between two points is constant, and is equal to the velocity of the latter point.

Remark

The VT command will start with the initial position equal to the current command position of the axis, the initial velocity equal to 0, and the initial time equal to 0. This initial point does not need to be specified (if the first point of VTCommand has a timeMilliseconds of 0, that point is ignored).

The point times must be specified in ascending order. The point times do not need to be a multiple of the cycle time. The velocity is signed, and can accept positive and negative values. The minimum number of points is 1 (with a time greater than 0).

This function will construct a rudimentary profile consisting of sequences of constant-velocity segments. The acceleration when switching from one velocity to another is infinite.

This function allocates memory dynamically when called for the first time for the commanded axis after starting the WMX3 engine. See CreatePVTBuffer for additional information. See Function Calls Related to Memory Allocation for additional information regarding dynamically allocated memory.

The numAddlCommands and pVTAddlCommand optional arguments can be specified to append additional points to the VT command after the points defined in pVTCommand. The pVTAddlCommand argument is specified as a pointer to an array, and any number of additional commands may be specified as long as the PVT memory buffer for the commanded axis (created with CreatePVTBuffer) is large enough to hold all points that are defined in pVTCommand and pVTAddlCommand.

See also

Parameters:

pVTCommand – [in] A pointer to a VTCommand that contains the VT parameters.
numAddlCommands – [in] An optional argument that specifies the number of additional commands to append after pPVTCommand.
pVTAddlCommand – [in] An optional argument that is a pointer to an array of VTAdditionalCommand objects. The size of the array should be equal to numAddlCommands.

WMX3APIFUNC StartVT(VTCommand *pVTCommand, Trigger *pTrigger, unsigned int numAddlCommands = 0, VTAdditionalCommand *pVTAddlCommand = NULL)

Start executing a triggered VT motion command.

A VT motion command consists of a sequence of velocity-time points. The velocity between two points is constant, and is equal to the velocity of the latter point.

Remark

The VT command will start with the initial position equal to the current command position of the axis, the initial velocity equal to 0, and the initial time equal to 0. This initial point does not need to be specified (if the first point of VTCommand has a timeMilliseconds of 0, that point is ignored).

The point times must be specified in ascending order. The point times do not need to be a multiple of the cycle time. The velocity is signed, and can accept positive and negative values. The minimum number of points is 1 (with a time greater than 0).

This function will construct a rudimentary profile consisting of sequences of constant-velocity segments. The acceleration when switching from one velocity to another is infinite.

This function allocates memory dynamically when called for the first time for the commanded axis after starting the WMX3 engine. See CreatePVTBuffer for additional information. See Function Calls Related to Memory Allocation for additional information regarding dynamically allocated memory.

The numAddlCommands and pVTAddlCommand optional arguments can be specified to append additional points to the VT command after the points defined in pVTCommand. The pVTAddlCommand argument is specified as a pointer to an array, and any number of additional commands may be specified as long as the PVT memory buffer for the commanded axis (created with CreatePVTBuffer) is large enough to hold all points that are defined in pVTCommand and pVTAddlCommand.

The motion will begin when the specified trigger condition is satisfied.

See also

Parameters:

pVTCommand – [in] A pointer to a VTCommand that contains the VT parameters.
numAddlCommands – [in] An optional argument that specifies the number of additional commands to append after pPVTCommand.
pVTAddlCommand – [in] An optional argument that is a pointer to an array of VTAdditionalCommand objects. The size of the array should be equal to numAddlCommands.
pTrigger – [in] A pointer to an object of the Trigger class that specifies the trigger condition.

WMX3APIFUNC StartVT(VTCommand *pVTCommand, TriggerEvents *pTriggerEvents, unsigned int numAddlCommands = 0, VTAdditionalCommand *pVTAddlCommand = NULL)

Start executing a triggered VT motion command with multiple trigger events.

A VT motion command consists of a sequence of velocity-time points. The velocity between two points is constant, and is equal to the velocity of the latter point.

Remark

The VT command will start with the initial position equal to the current command position of the axis, the initial velocity equal to 0, and the initial time equal to 0. This initial point does not need to be specified (if the first point of VTCommand has a timeMilliseconds of 0, that point is ignored).

The point times must be specified in ascending order. The point times do not need to be a multiple of the cycle time. The velocity is signed, and can accept positive and negative values. The minimum number of points is 1 (with a time greater than 0).

This function will construct a rudimentary profile consisting of sequences of constant-velocity segments. The acceleration when switching from one velocity to another is infinite.

This function allocates memory dynamically when called for the first time for the commanded axis after starting the WMX3 engine. See CreatePVTBuffer for additional information. See Function Calls Related to Memory Allocation for additional information regarding dynamically allocated memory.

The numAddlCommands and pVTAddlCommand optional arguments can be specified to append additional points to the VT command after the points defined in pVTCommand. The pVTAddlCommand argument is specified as a pointer to an array, and any number of additional commands may be specified as long as the PVT memory buffer for the commanded axis (created with CreatePVTBuffer) is large enough to hold all points that are defined in pVTCommand and pVTAddlCommand.

The motion will begin when the specified multi-event trigger condition is satisfied.

See also

Parameters:

pVTCommand – [in] A pointer to a VTCommand that contains the VT parameters.
numAddlCommands – [in] An optional argument that specifies the number of additional commands to append after pPVTCommand.
pVTAddlCommand – [in] An optional argument that is a pointer to an array of VTAdditionalCommand objects. The size of the array should be equal to numAddlCommands.
pTriggerEvents – [in] A pointer to an object of the TriggerEvents class that contains the trigger events.

WMX3APIFUNC StartAT(ATCommand *pATCommand, unsigned int numAddlCommands = 0, ATAdditionalCommand *pATAddlCommand = NULL)

Start executing a AT motion command.

An AT motion command consists of a sequence of acceleration-time points. The acceleration between two points is constant, and is equal to the acceleration of the latter point.

Remark

The AT command will start with the initial position equal to the current command position of the axis, the initial velocity equal to 0, and the initial time equal to 0. This initial point does not need to be specified (if the first point of ATCommand has a timeMilliseconds of 0, that point is ignored).

The point times must be specified in ascending order. The point times do not need to be a multiple of the cycle time. The minimum number of points is 1 (with a time greater than 0).

This function will construct a rudimentary profile consisting of sequences of constant-acceleration segments. If the accelerations and times are not chosen carefully, the profile will end at a non-zero velocity.

This function allocates memory dynamically when called for the first time for the commanded axis after starting the WMX3 engine. See CreatePVTBuffer for additional information. See Function Calls Related to Memory Allocation for additional information regarding dynamically allocated memory.

The numAddlCommands and pATAddlCommand optional arguments can be specified to append additional points to the AT command after the points defined in pATCommand. The pATAddlCommand argument is specified as a pointer to an array, and any number of additional commands may be specified as long as the PVT memory buffer for the commanded axis (created with CreatePVTBuffer) is large enough to hold all points that are defined in pATCommand and pATAddlCommand.

See also

Parameters:

pATCommand – [in] A pointer to a ATCommand that contains the AT parameters.
numAddlCommands – [in] An optional argument that specifies the number of additional commands to append after pPVTCommand.
pATAddlCommand – [in] An optional argument that is a pointer to an array of ATAdditionalCommand objects. The size of the array should be equal to numAddlCommands.

WMX3APIFUNC StartAT(ATCommand *pATCommand, Trigger *pTrigger, unsigned int numAddlCommands = 0, ATAdditionalCommand *pATAddlCommand = NULL)

Start executing a triggered AT motion command.

An AT motion command consists of a sequence of acceleration-time points. The acceleration between two points is constant, and is equal to the acceleration of the latter point.

Remark

The AT command will start with the initial position equal to the current command position of the axis, the initial velocity equal to 0, and the initial time equal to 0. This initial point does not need to be specified (if the first point of ATCommand has a timeMilliseconds of 0, that point is ignored).

The point times must be specified in ascending order. The point times do not need to be a multiple of the cycle time. The minimum number of points is 1 (with a time greater than 0).

This function will construct a rudimentary profile consisting of sequences of constant-acceleration segments. If the accelerations and times are not chosen carefully, the profile will end at a non-zero velocity.

This function allocates memory dynamically when called for the first time for the commanded axis after starting the WMX3 engine. See CreatePVTBuffer for additional information. See Function Calls Related to Memory Allocation for additional information regarding dynamically allocated memory.

The numAddlCommands and pATAddlCommand optional arguments can be specified to append additional points to the AT command after the points defined in pATCommand. The pATAddlCommand argument is specified as a pointer to an array, and any number of additional commands may be specified as long as the PVT memory buffer for the commanded axis (created with CreatePVTBuffer) is large enough to hold all points that are defined in pATCommand and pATAddlCommand.

The motion will begin when the specified trigger condition is satisfied.

See also

Parameters:

pATCommand – [in] A pointer to a ATCommand that contains the AT parameters.
numAddlCommands – [in] An optional argument that specifies the number of additional commands to append after pPVTCommand.
pATAddlCommand – [in] An optional argument that is a pointer to an array of ATAdditionalCommand objects. The size of the array should be equal to numAddlCommands.
pTrigger – [in] A pointer to an object of the Trigger class that specifies the trigger condition.

WMX3APIFUNC StartAT(ATCommand *pATCommand, TriggerEvents *pTriggerEvents, unsigned int numAddlCommands = 0, ATAdditionalCommand *pATAddlCommand = NULL)

Start executing a triggered AT motion command with multiple trigger events.

An AT motion command consists of a sequence of acceleration-time points. The acceleration between two points is constant, and is equal to the acceleration of the latter point.

Remark

The AT command will start with the initial position equal to the current command position of the axis, the initial velocity equal to 0, and the initial time equal to 0. This initial point does not need to be specified (if the first point of ATCommand has a timeMilliseconds of 0, that point is ignored).

The point times must be specified in ascending order. The point times do not need to be a multiple of the cycle time. The minimum number of points is 1 (with a time greater than 0).

This function will construct a rudimentary profile consisting of sequences of constant-acceleration segments. If the accelerations and times are not chosen carefully, the profile will end at a non-zero velocity.

This function allocates memory dynamically when called for the first time for the commanded axis after starting the WMX3 engine. See CreatePVTBuffer for additional information. See Function Calls Related to Memory Allocation for additional information regarding dynamically allocated memory.

The numAddlCommands and pATAddlCommand optional arguments can be specified to append additional points to the AT command after the points defined in pATCommand. The pATAddlCommand argument is specified as a pointer to an array, and any number of additional commands may be specified as long as the PVT memory buffer for the commanded axis (created with CreatePVTBuffer) is large enough to hold all points that are defined in pATCommand and pATAddlCommand.

The motion will begin when the specified multi-event trigger condition is satisfied.

See also