@@ -0,0 +1,508 @@
<?xml version="1.0" encoding="utf-8"?>
<TcPlcObject Version="1.1.0.1" ProductVersion="3.1.4026.12">
<DUT Name="Mecademic_MotionCommandID" Id="{8933b420-bc36-4903-be24-f2a98be9229b}">
<Declaration><![CDATA[{attribute 'qualified_only'}
TYPE Mecademic_MotionCommandID :
(
/// No Motion command active
NO_COMMAND := 0,
/// This command makes the robot rotate simultaneously its joints to the specified joint set.
/// All joint rotations start and stop at the same time. The path that the robot takes is linear in
/// the joint space, but nonlinear in the Cartesian space. Therefore, the TCP trajectory is not
/// easily predictable. Finally, with MoveJoints, the robot can cross singularities.
/// All six subindices are in degrees.
MOVE_JOINTS := 1,
/// This command makes the robot move its TRF to a specific pose with respect TO the WRF.
/// Essentially, the robot controller calculates all possible joint sets corresponding to the desired
/// pose and for which euler angle 6 is in the range +/-180°, except those corresponding to a singular robot
/// posture. Then, it either chooses the joint set that corresponds to the desired configuration guration or
/// the one that is fastest to reach (see SetConf and SetAutoConf). Finally, it executes internally
/// a MoveJoints command with the chosen joint set.
/// Thus, all joint rotations start and stop at the same time. The path the robot takes is
/// linear in the joint-space, but nonlinear in Cartesian space. Therefore, the path the TCP will
/// follow to its final destination is not easily predictable, as illustrated in Fig. 7.
/// Using this command, the robot can cross a singularity or start from a singular robot
/// posture, as long as SetAutoConf is enabled. However, the robot cannot go to a singular robot
/// posture using MovePose. For example, assuming that the TRF coincides with the FRF, you
/// cannot execute the command MovePose(190,0,308,0,90,0), since this pose corresponds only
/// to singular robot posture (e.g., the joint set {0,0,0,0,0,0}). You can only use the MovePose
/// command with a pose that corresponds to at least one non-singular robot posture.
/// As with the MoveJoints command, if the complete motion cannot be performed due to
/// singularities or joint limits, it will normally not even start, and an error will be generated.
/// Finally, note that this command will make the robot move to a joint set (corresponding
/// to the desired pose) for which euler angle 6 is in the range +/-180°. Finally, note that this command will
/// be executed only if euler angle 6 is already in the range +/-180°.
/// Subindices 1, 2, 3 are in mm and 4, 5, 6 are in degrees.
MOVE_POSE := 2,
/// This command makes the robot move its TRF to a specific pose with respect to the WRF
/// while keeping the TCP along a linear path in Cartesian space, as illustrated in Fig. 8. If the
/// final (desired) orientation of the TRF is different from the initial orientation, the orientation
/// will be modified along the path using LERP interpolation.
/// Using this command, the robot cannot move to or through a singular robot posture or one
/// that is too close to being singular. This command cannot automatically change the robot
/// configuration. Furthermore, note that when executing this command, euler angle 6 must already be in
/// the the range +/-180° and will remain in that range during the execution of the command.
/// Finally, note that if the motion requires that a joint rotates more than 180°, it will not be
/// executed (unless you are upgrading from firmware 7). Furthermore, if the complete motion
/// cannot be performed due to singularities or joint limits, it will normally not even start, and
/// an error will be generated.
/// Subindices 1, 2, 3 are in mm and 4, 5, 6 are in degrees.
MOVE_LIN := 3,
/// This command is similar to the MoveLin command, but allows a desired pose to be specified
/// relative to the current pose of the TRF. Thus, the arguments X, Y, Z, Rx, Ry, Rz represent the
/// desired pose of the TRF with respect to the current pose of the TRF (i.e., the pose of the
/// TRF just before executing the MoveLinRelTRF command).
/// As with the MoveLin command, if the complete motion cannot be performed due to
/// singularities or joint limits, it will normally not even start and an error will be generated.
/// These joint limits include the fact that joint 6 must be in the range +/-180° at all times and
/// no joint can rotate more than 180° (in a single linear displacement).
/// Subindices 1, 2, 3 are in mm and 4, 5, 6 are in degrees.
MOVE_LIN_REL_TRF := 4,
/// This command is similar to the MoveLinRelTRF command, but instead of defening the
/// desired pose with respect to the current pose of the TRF it is defined with respect to a
/// reference frame that has the same orientation as the WRF but its origin is at the current
/// position of the TCP.
/// As with the MoveLin command, if the complete motion cannot be performed due to
/// singularities or joint limits, it will not even start. These joint limits include the fact that
/// joint 6 must be in the range +/-180° at all times and no joint can rotate more than 180° (in
/// a single linear displacement).
/// Subindices 1, 2, 3 are in mm and 4, 5, 6 are in degrees.
MOVE_LIN_REL_WRF := 5,
/// This command is used to add a time delay after a motion command. In other words, the
/// robot completes all movements sent before the Delay command and stops temporarily. (In
/// contrast, the PauseMotion command interrupts the motion as soon as received by the robot.)
/// Subindex 1 is the pause in seconds.
DELAY := 6,
/// This command enables/disables the robot's blending feature (recall Section 2.2.2). Note
/// that the commands MoveLin, MovePose, and MoveJoints will only send "[3004][End of move-
/// ment.]" responses when the robot comes to a complete stop and the command SetEOM(1)
/// was used. Therefore, enabling blending may suppress these responses.
/// Also, note that there is blending only between consecutive movements with the commands
/// MoveJoints and MovePose, or between consecutive movements with the commands MoveLin,
/// MoveLinRelTRF and MoveLinRelTRF. In other words, there will never be blending between
/// the trajectories of a MovePose command followed by a MoveLin command.
/// Subindex 1 is the percentage of blending, from 0 or 100.
SET_BLENDING := 7,
/// This command limits the angular velocities of the robot joints. It affects the movements
/// generated by the MovePose and MoveJoints commands.
/// It is not possible to limit the velocity of only one joint. With this command, the maximum
/// velocities of all joints are limited proportionally. The maximum velocity of each joint will
/// be reduced to a percentage p of its top velocity. The top velocity of joints 1 and 2 is 150°/s,
/// of joint 3 is 180°/s, of joints 4 and 5 is 300°/s, and of joint 6 is 500°/s.
/// Subindex 1 is the percentage of maximum joint velocities, from 0.001 to 100.
SET_JOINT_VEL := 8,
/// This command limits the acceleration of the joints during movements resulting from joint-
/// space commands (see Fig. 6). Note that this command makes the robot stop, even if blending
/// is enabled.
/// Note that the argument of this command is exceptionally limited to 150. This is because
/// in firmware 8, a scaling was applied so that if this argument is kept at 100, most joint-
/// space movements are feasible even at full payload. More precisely, if you are upgrading from
/// firmware 7 and you want to keep the same joint accelerations, you need to multiply the
/// arguments of your SetJointAcc commands by the factor 1.43.
/// Subindex 1 is the percentage of maximum joint accelerations, from 0.001 to 150.
SET_JOINT_ACC := 9,
/// This command limits the angular velocity of the robot TRF with respect to its WRF. It only
/// affects the movements generated by the MoveLin, MoveLinRelTRF and MoveLinRelWRF
/// commands.
/// Subindex 1 is the Cartesian angular velocity limit, from 0.001 to 300, measured in °/s.
SET_CART_ANG_VEL := 10,
/// This command limits the Cartesian linear velocity of the robot's TRF with respect to
/// its WRF. It only affects the movements generated by the MoveLin, MoveLinRelTRF and
/// MoveLinRelWRF commands.
/// Subindex 1 is the linear velocity limit for the TCP, from 0.001 to 1,000, measured in mm/s.
SET_CART_LIN_VEL := 11,
/// This command limits the Cartesian acceleration (both the linear and the angular) of the
/// end-effector during movements resulting from Cartesian-space commands (see Fig. 6). Note
/// that this command makes the robot come to a complete stop, even if blending is enabled.
/// Note that the argument OF THIS command is exceptionally limited TO 600. THIS is because
/// in firmware 8, a change was made to allow the robot to accelerate much faster. For backwards
/// compatibility, however, 100% now corresponds to 100% in firmware 7 and before.
/// Subindex 1 is the percentage of maximum Cartesian accelerations, ranging from 0.001 to 100.
SET_CART_ACC := 12,
/// This command defines the pose of the TRF with respect to the FRF. Note that this command
/// makes the robot come to a complete stop, even if blending is enabled.
/// Subindices 1, 2, 3 are in mm and 4, 5, 6 are in degrees.
SET_TRF := 13,
/// This command defines the pose of the WRF with respect to the BRF. Note that this com-
/// mand makes the robot come to a complete stop, even if blending is enabled.
/// Subindices 1, 2, 3 are in mm and 4, 5, 6 are in degrees.
SET_WRF := 14,
/// This command sets the desired robot inverse kinematic configuration to be observed in the
/// MovePose command.
/// The robot inverse kinematic configuration (see Fig. 5) can be automatically selected by
/// using the SetAutoConf command. Using SetConf automatically disables the automatic con-
/// figuration selection.
/// Subindices 1, 2, and 3 are -1 or 1.
SET_CONF := 15,
/// This command enables or disables the automatic robot configuration selection and has effect
/// only on the MovePose command. This automatic selection allows the controller to choose
/// the "closest" joint set corresponding to the desired pose (the arguments of the MovePose
/// command) and for which Euler Angle 6 is in the range +/-180°
/// Subindex 1 is 0 or 1.
SET_AUTO_CONF := 16,
/// This command defines a checkpoint in the motion queue. Thus, if you send a sequence
/// of motion commands to the robot, then the command SetCheckpoint, then other motion
/// commands, you will be able to know the exact moment when the motion command sent just
/// before the SetCheckpoint command was completed. At that precise moment, the robot will
/// send you back the response [3030][n], where n is a positive integer number defined by you. If
/// blending was activated, the checkpoint response will be sent somewhere along the blending.
/// Finally, note that you can use the same checkpoint number multiple times.
/// Using a checkpoint is the only reliable way to know whether a particular motion sequence
/// was completed. Do not rely on the EOM or EOB messages as they may be received well
/// before the completion of a motion or a motion sequence (or, of course, not at all, if these
/// messages were not enabled).
/// Subindex 1 in an integer number, ranging from 1 to 8,000.
SET_CHECKPOINT := 17,
/// This command is used to open or close Mecademic's optional MEGP 25 gripper.
/// The gripper will move its fingers apart or closer until the grip force reaches 40 N. You can
/// reduce this maximum grip force with the SetGripperForce command. In addition, you can
/// control the speed of the gripper with the SetGripperVel command.
/// It is very important to understand that the GripperOpen and GripperClose commands
/// have the same behavior as a robot motion command, being executed only after the preceding
/// motion command has been completed. Currently, however, if a robot motion command is
/// sent after the GripperOpen or GripperClose command, the robot will start executing the
/// motion command without waiting for the gripper to finish its action. You must therefore
/// send a Delay command after GripperOpen and GripperClose commands.
/// Subindex 1 is 0 for GripperClose, and 1 for GripperOpen.
/// Meca500 only.
GRIPPER := 18,
/// This command limits the velocity of the gripper fingers (with respect to the gripper).
/// Subindex 1 is the percentage of maximum eger velocity (~100 mm/s), from 10 to 100.
/// Meca500 only.
SET_GRIPPER_VEL := 19,
/// This command limits the grip force of the MEGP 25 gripper.
/// Subindex 1 is the percentage of maximum grip force (~40 N), from 10 to 100.
/// Meca500 only.
SET_GRIPPER_FORCE := 20,
/// This command makes the robot rotate simultaneously its joints with the specified joint
/// velocities. All joint rotations start and stop at the same time. The path that the robot
/// takes is linear in the joint space, but nonlinear in the Cartesian space. Therefore, the TCP
/// path is not easily predictable (Fig. 7). With MoveJointsVel, the robot can cross singularities
/// without any problem.
/// Note that the robot will decelerate to a full stop after a period defined by the command
/// SetVelTimeout, unless another MoveJointsVel command is sent. Also, bear in mind that
/// the MoveJointsVel command, unlike position-mode motion commands, generates no motion
/// errors when a joint limit is reached. The robot simply stops slightly before the limit.
/// Subindices 1 trhough 6 are in °/s.
MOVE_JOINTS_VEL := 21,
/// This command makes the robot move its TRF with the specified instantaneous Cartesian
/// velocity, defined with respect to the WRF.
/// Note that the robot will decelerate to a complete stop after a period of time defined
/// by the SetVelTimeout command, unless another MoveLinVelWRF or a MoveLinVelTRF
/// command is sent and, of course, unless a PauseMotion command is sent or some motion
/// limit is encountered. Also, bear in mind that this command, unlike position-mode motion
/// commands, generates no motion errors when a joint limit (including the +/-180° limit on
/// joint 6) or a singularity is reached. The robot simply stops slightly before the limit.
/// Subindices 1, 2, 3 are in mm/s and 4, 5, 6 are in are in °/s.
MOVE_LIN_VEL_WRF := 22,
/// This command makes the robot move its TRF with the specified instantaneous Cartesian
/// velocity, defined with respect to the TRF.
/// Note that the robot will decelerate to a complete stop after a period of time defined
/// by the SetVelTimeout command, unless another MoveLinVelTRF or a MoveLinVelWRF
/// command is sent and, of course, unless a PauseMotion command is sent or some motion
/// limit is encountered. Also, bear in mind that this command, unlike position-mode motion
/// commands, generates no motion errors when a joint limit (including the +/-180° limit on
/// joint 6) or a singularity is reached. The robot simply stops slightly before the limit.
/// Subindices 1, 2, 3 are in mm/s and 4, 5, 6 are in are in °/s.
MOVE_LIN_VEL_TRF := 23,
/// This command sets the timeout after a velocity-mode motion command (MoveJointsVel,
/// MoveLinVelTRF, or MoveLinVelWRF), after which all joint speeds will be set to zero unless
/// another velocity-mode motion command is received. The SetVelTimeout command should
/// be regarded simply as a safety precaution.
/// Subindex 1 is in seconds.
SET_VEL_TIMEOUT := 24,
/// THIS command sets the desired turn configuration FOR joint 6 TO be observed in the MovePose AND
/// MoveLin* commands (see Section 1.2.1 and Section 1.2.2). When a turn configuration is set, a MovePose
/// command is executed only if the final robot position can be in the desired turn configuration. In
/// contrast, when a desired turn configuration is set, a MoveLin* command will be executed only if the
/// final robot position can be and the initial robot position already is in the desired turn configuration. The
/// turn configuration can be automatically selected, when executing a MovePose or MoveLin* command,
/// by using the SetAutoConf command. Using SetConfTurn automatically disables the automatic turn
/// configuration selection.
/// Subindex 1 turn configuration, an integer between −
/// The turn configuration parameter defines the desired range for joint 6, according to the following
/// equation: −
SET_CONF_TURN := 25,
/// This command enables or disables the automatic turn selection for joint 6.
/// It affects the MovePose command, and all MoveLin* commands. When the automatic turn
/// selection is enabled, and a MovePose command is executed, joint 6 will always take the shortest path,
/// and rotate no more than 180°. In the case of a MoveLin* command, however, enabling the automatic
/// turn selection simply allows the change of turn configuration along the linear move.
/// Subindex1 enable (1) or disable (0) automatic turn configuration selection.
SET_AUTO_CONF_TURN := 26,
/// THIS command sets the thresholds FOR the torques applied TO each joint, as percentages OF the maximum
/// allowable torques that can be applied at each joint. When a torque limit is exceeded, a customizable
/// event is created. The event behavior can be set by the command SetTorqueLimitsCfg.
/// This command is intended only for improving the chances of protecting your robot, its end-effector, and
/// the surrounded equipment, in the case of a collision. The torque in each joint is estimated by measuring
/// the current in the corresponding drive.
/// Unlike the SetJointLimits commands, the SetTorqueLimits command can only be applied after the
/// robot has been homed. Note that high accelerations or large movements may also produce high torque
/// peaks. Therefore, you should rely on this command only in the vicinity of obstacles, for example, while
/// applying an adhesive. Remember that SetTorqueLimits is a motion command and will therefore be
/// inserted in the motion queue and not necessarily executed immediately.
/// Subindex 1,2,3,4,5,6 percentage of the maximum allowable torque that can be applied at joint i,
/// ranging from 0.001% to 100%.
SET_TORQUE_LIMITS := 27,
/// THIS command sets the robot behavior when a joint torque exceeds the threshold set BY the
/// SetTorqueLimits command. It also sets the filtering TYPE used FOR accurate detection. It also sends a
/// torque limit status every time torque limit status changes (exceeded or not) for events severity greater
/// than 0. Torque limit error is sent when torque exceeds the limit for severity 4.
/// Arguments
/// • s: integer defining the torque limit event severity as
/// –
/// –
/// –
/// –
/// –
/// • m: integer defining the detection mode as 0, always detect; 1, skip detection during acceleration/
/// deceleration and blending.
SET_TORQUE_LIMIT_CFG := 28,
/// THIS command has the exact behavior as the MoveJoints command, but instead OF accepting the
/// desired (target) joint set as arguments, it takes the desired relative joint displacements. The command is
/// particularly useful when you need to displace certain joints a certain amount, but you do not know the
/// current joint position and wish to avoid having to use the command GetRtTargetJointPos.
/// Arguments
/// • Δθi: the desired relative displacement of joint i (i = 1, 2, ..., 6), in degrees. The value of the argument
/// can be positive, negative or even zero.
MOVE_JOINTS_REL := 29,
/// THIS command is use TO control independently each OF the two valves in the MPM500 pneumatic module.
/// Arguments
/// • v1: open (1), close (0) or keep unchanged (−
/// • v2: open (1), close (0) or keep unchanged (−
/// Meca500 only.
SET_VALVE_STATE := 30,
/// THIS command sets the closed AND open states OF the gripper AND is used mainly TO redefine the actions
/// of the GripperClose and GripperOpen commands, respectively. The SetGripperRange command is
/// useful for the MEGP 25LS gripper. If, for example, you are manipulating parts that require fingers
/// opening between 10 mm and 20 mm, but the allowable range of the gripper as detected during
/// the homing is 48 mm, it would be more efficient to redefine the actions of the GripperClose and
/// GripperOpen commands by calling SetGripperRange(8,22), or else the fingers will move more than
/// necessary, and therefore increase your cycle time.
/// The SetGripperRange command does not limit the accessible range of the gripper, in contrast to the
/// SetJointLimits command, which limits the range of a joint. For example, if during homing, the robot
/// detected that the range for the finger opening was [0, 15], and then you sent SetGripperRange(8,13),
/// you can still open the gripper more with MoveGripper(14). However, using the commands GripperOpen
/// and GripperClose will be equivalent to using the commands MoveGripper(8) and MoveGripper(13),
/// respectively. Furthermore, when the fingers opening is 8 mm (or less) or 13 mm (or more), the state of
/// the gripper will be “gripper open” or “gripper close”, respectively (see GetRtGripperState).
/// Arguments
/// • dclosed: fingers opening that should correspond to closed state, in mm;
/// • dopen: fingers opening that should correspond to open state, in mm.
/// Meca500 only.
SET_GRIPPER_RANGE := 31,
/// The MEGP 25E AND MEGP 25LS grippers are equipped with incremental encoders, so it is impossible TO
/// directly measure the absolute positions of the gripper jaws. Thus, during the homing of the robot, the
/// gripper is also homed by completely closing and then opening its fingers, until resistance is met in each
/// direction. The maximum fingers opening is detected and is a positive number not larger than 6 mm
/// (MEGP 25E) or 48 mm (MEGP 25LS). Most importantly, the fingers opening, a non-negative distance,
/// is defined as the sum of the distances traveled by each jaw from their fully-closed positions detected
/// during homing.
/// The MoveGripper command makes the gripper fingers move towards the specified fingers opening.
/// Meca500 only.
/// Arguments
/// • d: desired fingers opening, a
MOVE_GRIPPER := 32,
//In revision 4 OF the Meca500, we have introduced the possibility TO go beyond the maximum rated joint
//velocities in any type of movement. For compatibility reasons, we introduced this new command.
//The SetJointVelLimit overrides the default joint velocity limits. Unlike the SetJointVel command, this
//command affects the movements generated by all Move* commands (even the MoveLinVel* ones).
SetJointVelLimit :=33,
//This queued command is used to control the digital outputs of the MVK01 vacuum and I/O module.
//the arguments are BankId (a 32-BIT integer), output-values (32 bits, one BIT per output,
//only the first eight are used), and output-mask (32 bits, one bit per output, only the first eight are used).
//The mask defines which outputs are changed; outputs with corresponding bit equal to 0 in the mask won't
//be changed.
//Meca500 only.
SetOutputState:=34,
//This is the same command as SetOutputState, but it is instantaneous, rather than queued and can be
//executed even when the robot is deactivated.
//Meca500 only.
SetOutputState_Immediate:=35,
//THIS instantaneous command, availably only FOR the Meca500, toggles the simulation mode FOR the MVK01
//vacuum and I/O module. With the simulation enabled, you can use all the MVK01 commands (e.g.,
//VacuumGrip, SetOutputState) and if the MVK01 is physically present, these commands will not have any
//physical impact (i.e., they will only be simulated).
//Meca500 only.
SetIoSim:=36,
//This queued command activate the suction in the MVK01 vacuum and I/O module for the
//Meca500 SCARA robot.
//all six arguments are ignored.
//Meca500 only.
VacuumGrip:=37,
//These instantaneous commands activate the suction in the MVK01 vacuum and I/O module
//for the Meca500 SCARA robot. Unlike their queued equivalents (VacuumGrip and VaccumRelease), they
//can be executed even when the robot is deactivated.
//all six arguments are ignored.
//Meca500 only.
VacuumGrip_Immediate:=38,
//This queued command deactivate the suction in the MVK01 vacuum and I/O module for the
//Meca500 SCARA robot.
//all six arguments are ignored.
//Meca500 only.
VacuumRelease:=39,
//These instantaneous commands deactivate the suction in the MVK01 vacuum and I/O module
//for the Meca500 SCARA robot. Unlike their queued equivalents (VacuumGrip and VaccumRelease), they
//can be executed even when the robot is deactivated.
//all six arguments are ignored.
//Meca500 only.
VacuumRelease_Immediate:=40,
//THIS queued command sets the thresholds FOR the vacuum sensor (which measures only negative
//pressure) in the MVK01 vacuum and I/O module that will be used for reporting whether a part is being
//hold or not.
//Meca500 only.
//Arguments
//1: when the negative pressure sensed is smaller than ph, the robot reports that a part is being
//held. The value for this argument ranges from − −
//2: when the value of the negative pressure sensed is larger than pr, the robot reports no part is
//being held. The value for this argument ranges from −
//than the value of ph by at least 5 KPa.
//Default values
//By default, ph = − −
//command SetVacuumThreshold(0,0).
SetVacuumThreshold:=41,
//THIS is the same command as SetVacuumThreshold, but it is instantaneous, rather than queued AND can
//be executed even when the robot is deactivated.
//Meca500 only.
SetVacuumThreshold_Immediate:=42,
//THIS queued command sets the duration OF the air purge FOR ejecting a part when using the commands
//VacuumRelease*.
//Meca500 only.
//Arguments
//1: duration in seconds.
//Default values
//By default, tp= 0.1.
SetVacuumPurgeDuration:=43,
//THIS is the same command as SetVacuumPurgeDuration, but it is instantaneous, rather than queued AND
//can be executed even when the robot is deactivated.
//Meca500 only.
SetVacuumPurgeDuration_Immediate:=44,
//THIS command can only be used on the Meca500. Essentially, the robot moves up/down its end-effector
//a certain distance (retract motion along a line and without changing its orientation), then moves it to a
//pose that is a certain distance over/under the desired pose (lateral motion), and finally moves it down/
//up to the desired pose (approach linear motion without changing its orientation)
//The MoveJump command is highly optimized for fast pick and place motion and results in much
//faster cycle times than when using a simple sequence of MoveLin - MovePose - MoveLin commands.
//Meca500 only.
//Arguments
//• x, y, z: the coordinates of the origin of the TRF with respect to the WRF, in mm;
//• γ
//As with the MovePose command, the joint set corresponding TO the FINAL desired pose is calculated
//according to the desired robot posture and turn configurations, if such were set, or the one that is
//fastest to reach. Also, as with the MovePose command, if the complete motion cannot be performed
//due to joint limits, it will not even start, and an error will be generated. Note that since the robot uses
//the optimal (quickest) path in joint space, in the lateral motion, the end-effector follows a complex
//non-linear path. Finally, the speed and the acceleration during the MoveJump motion are defined by the
//SetJointVel and SetJointAcc commands.
//The parameters defining the trajectory of the end-effector in a MoveJump motion are set by the
//commands SetMoveJumpHeight and SetMoveJumpApproachVel
MoveJump:=45,
//THIS command prescribes the exact distances the end-effector must MOVE up OR down, with a pure
//vertical translational motion, during the vertical portions of the MoveJump movement. It also prescribes
//the minimum AND maximum allowed heights FOR the lateral motion.
//Meca500 only.
//Arguments
//• hstart: height of the initial pure vertical translation, in mm, from −
//• hend: height of the final pure vertical translation, in mm, from −
//• hmin: minimum height to reach while performing the lateral motion, with respect to the highest (if
//hstart and hend are positive) or lowest (if hstart and hend are negative) between the start and end poses,
//in mm, from −
//• hmax: maximum height allowed to reach while performing the lateral motion, with respect to the
//highest (if hstart and hend are positive) or lowest (if hstart and hend are negative) between the start and
//end poses, in mm, from −
//The direction the heights (positive OR negative) is with respect TO the z-axis OF the BRF.
//Default values
//By default, hstart = hend = 10, hmin = 0, hmax = 102. The default values for hmin and hmax give full freedom
//to choose the optimal (quickest) path between the start and end poses. You may change hmin and hmax
//to avoid obstacles between the start and end poses, but be aware that this may result in slower (suboptimal)
//cycle times. Also, note that the highest point during the lateral motion can happen anywhere,
//not necessary in the middle. In addition, note that changing the joint velocities with the command
//SetJointVel will also change the profile of the lateral motion.
SetMoveJumpHeight:=46,
//THIS command is intended FOR reducing the speed during the initial AND FINAL moments OF the MoveJump
//motion.
//Meca500 only.
//Arguments
//• vstart: maximum allowed vertical speed near the start pose, in mm/s, from 0.001 to 700;
//• pstart: initial portion of the retreat motion during which vstart is applied, in mm, from 0 to 102;
//• vend: maximum allowed vertical speed near the end pose, in mm/s, from 0.001 to 700;
//• pend: final portion of the approach motion during which vstart is applied, in mm, from 0 to 102.
//Default values
//By default, vstart = vend = 10 and pstart = pend = 1.
//Note that if pstart ≥ |hstart|, then the complete retract vertical motion will be limited in speed to vstart.
//Similarly, if pend ≥ |hend|, then the complete approach vertical motion will be limited in speed to vend. Also,
//if vstart or vend is larger than the speed resulting from the SetJointVel command, it will be ignored
SetMoveJumpApproachVel:=47,
//THIS command sets the TIME scaling (in percentage) OF the trajectory generator. BY calling THIS command
//with p < 100, all robot motions remain exactly the same (i.e., the path remains the same), but everything
//becomes p% slower, including time delays (e.g., the pause set by the command Delay). In other words,
//this command is more than a simple velocity override.
//When using the MecaPortal, you can change the time scaling in real time with the "Time Scaling" slider at
//the bottom of the program panel.
//Arguments
//• p: time scaling percentage, from 0.001 to 100.
//Default values
//By default, p = 100.
SetTimeScaling:=48,
/// THIS command starts a PROGRAM that has been previously saved in the robot's memory. The robot must
/// be activated and homed before running a program. Executing this command will launch the program n
/// only once.
/// Alternately, pressing the Start/Stop button on the robot base will start program 1 (and only program 1)
/// and execute it the number of times defined by the SetOfflineProgramLoop command.
/// Arguments
/// • n: program number, where n ≤ 500 (maximum number of programs that can be stored).
START_PROGRAM := 100
)UDINT;
END_TYPE]]></Declaration>
</DUT>
</TcPlcObject>
