NYCe 4000
Multi-axis motion control system NYCeRocks User Manual
Reference R911345561
Edition 05
NYCe 4000
Multi-axis motion control system NYCeRocks User Manual Reference
DOK-NY4000-NYROCKS*V46-RE05-EN-E
RS-f38c0a7ea8f9bcb00a6846a5005893e3-5-en-US-4
Edition Release Date Notes
DOK-NY4000-NYROCKS*V46-RE01-EN-
E 11/2014 First edition 46V02
DOK-NY4000-NYROCKS*V46-RE02-EN-
E 04/2016 2nd edition 46V06
DOK-NY4000-NYROCKS*V46-RE03-EN-
E 11/2016 3rd edition 46V08
DOK-NY4000-NYROCKS*V46-RE04-EN-
E 12/2017 4th edition 45V13
DOK-NY4000-NYROCKS*V46-RE05-EN-
E 03/2018 5th edition 46V14
List of trademarks Products in this publication are referred to by their general trade names. In most, if not all cases, these designations are claimed as trademarks or registered trademarks of their respective companies.
Copyright © Bosch Rexroth AG 2018
All rights reserved, also regarding any disposal, exploitation, reproduction, editing, distribution, as well as in the event of applications for industrial property rights.
Liability The specified data is intended for product description purposes only and shall not be deemed to be a guaranteed characteristic unless expressly stipulated in the contract. All rights are reserved with respect to the content of this documentation and the availability of the product.
Published by Bosch Rexroth AG
P.O. Box 7170 ■ 5605 JD Eindhoven ■ The Netherlands http://www.boschrexroth.com
Title
Type of Documentation Document Typecode Internal File Reference
Record of Revision
Table of Contents
Page
1 NYCe 4000 NYCeRocks... 3
1.1 Introduction... 3
1.2 NYCeRocks implementation methods... 5
1.3 Software overview... 6
1.4 Used abbreviations in this manual... 7
2 Definition of a mechanism... 9
2.1 Introduction... 9
2.2 Mechanism creation... 9
3 Trajectory generation... 11
3.1 Introduction... 11
3.2 Standard trajectory generation functions... 11
3.2.1 Introduction... 11
3.2.2 Sinusoidal shaped acceleration profile... 11
3.2.3 Third order acceleration profile... 15
3.3 Concatenate trajectories... 18
3.4 Adding a new trajectory generator... 21
3.5 Reuse trajectory... 22
4 Kinematics... 23
4.1 Introduction... 23
4.2 Cartesian XYZ... 23
4.3 Gantry... 24
4.4 Translation and rotation... 26
4.5 Adding additional transformations... 27
4.6 Adding an application-specific kinematics... 27
5 Streamer... 29
6 Support functions... 31
6.1 Introduction... 31
6.2 Conversion... 31
6.3 Outputs... 32
6.4 Latches... 33
6.5 Synchronization groups... 33
6.6 Miscellaneous... 34
7 List of NYCeRocks error codes... 35
Table of Contents
1 NYCe 4000 NYCeRocks
1.1 Introduction
NYCeRocks is a software package to move coordinated axes of a manipulator. "NYCeRocks" is an abbreviation of NYCe 4000 Robot Control &
Kinematic Software. NYCeRocks is not embedded in the NYCe 4000 Software, but runs on top of it, see fig. 1-2 "NYCeRocks layered model on top of NYCe 4000" on page 4.
Fig. 1-1: NYCeRocks Control Hierarchy
NYCeRocks is targeted for the Semiconductor Industry, where manipulators normally do not have complex kinematics, nevertheless accuracy and speed are important aspects. Exact end points are often recalculated for the repetitive similar movements (for example based on camera input) and the movements cover short distances.
NYCeRocks allows the application to move several axes of the same mechanism on the same NYCe 4000 node in a simultaneous coordinated way. By default, all axes of a mechanism start and stop a movement simultaneously. However, it is also possible to start a movement simultaneously or stop a movement simultaneously, with an optimal speed per axis.
The NYCeRocks layered model
The NYCeRocks model consists of 3 layers. Each layer performs specific functions.
NYCe 4000 NYCeRocks
Fig. 1-2: NYCeRocks layered model on top of NYCe 4000 1. "Trajectory Generator" layer
The "Trajectory Generator" layer is the application interface of the NYCe 4000 NYCeRocks package. It offers functions to generate paths in world coordinates to move from one position to an other position, using a linear, circular or a user-defined curved path.
2. "Kinematic" layer
The "Kinematic" layer splits the trajectory path, calculated by the Trajectory Generator, into splines that each joint of the mechanism must execute. The generated splines are stored in spline buffers.
3. "Streamer" layer
The "Streamer" layer reads the generated splines from the spline buffers and "streams" the spline information to the joints, using the SAC and NHI API of NYCe 4000. See the NYCe 4000 Software User Manual for more information about splines.
NYCeRocks can have more than one layer of the same type. Typically, the Trajectory Generator and Streamer layer will not change, but the Kinematic layer depends on the mechanism which is used, for example XYZ, gantry XYYZ, Scara, etc.
NYCe 4000 NYCeRocks
1.2 NYCeRocks implementation methods
The NYCeRocks package can be used in 3 different methods, see fig. 1-3
"Implementation methods for NYCeRocks" on page 5.
1. NYCeRocks implemented as a DLL.
2. NYCeRocks implemented as a library for sequences on the node.
3. NYCeRocks implemented as a sequence on the node.
1 2 13
Fig. 1-3: Implementation methods for NYCeRocks NYCeRocks implemented as a DLL
NYCeRocks implemented as a DLL runs in the context of the application on the PC. The application includes the header file "rocksapi.h" and links the application with the "n4krocks.lib" library.
NYCeRocks implemented as a library for sequences on the node
NYCeRocks implemented as a library for sequences on the node runs in the context of the sequence. If another sequence or the PC application wants to access that instance of NYCeRocks, it must communicate with the sequence that includes this instance. The application includes the header file
"rocksapi.h" and links the application with the "n4krocks.lib" library.
NYCeRocks implemented as a library for sequences on the node is not yet supported. This functionality will become available in a future release of NYCe 4000.
NYCeRocks implemented as a sequence on the node
If NYCeRocks is implemented as a separate sequence on the node, it operates as a server for multiple clients. The client can be an other sequence or a PC application.
If the application is the server you must include the header files
"rocksapi.h" and "rocksseq.h", and link the application with the
"n4krocks.lib" and "n4krockssrv.lib" libraries.
NYCe 4000 NYCeRocks
If the application is a client you must include the header file "rocksapi.h", and link the application with the "n4krocksclient.lib" and
"n4krocksseq.lib" libraries.
With the command-line tool NYCeGenRocksServ you can generate a NYCeRocks server sequence (N4kRocksSrvSeq.out) that can be downloaded into the node where NYCeRocks must run as a server by using the function RocksMechCreateAtSrvSeq. The node to which you download N4kRocksSrvSeq.out must be connected and the sequence areas for rocksServerArea and dataArea must already be created with seqDefineAreas before you use the tool NYCeGenRocksServ. When this is successfully executed, the generated server sequence can be loaded and started with SeqLoad and SeqStart respectively, see the NYCe 4000 Sequencer User Manual for more information. After the server sequence is started you can call RocksMechCreateAtSrvSeq.
1.3 Software overview
The NYCeRocks application allows the user to program the movements of a mechanism in world coordinates. For example, in fig. 1-4 "Movement in world coordinates space" on page 6, the joints A and B are controlled to move from point P1 to point P2, and then to point P3. NYCeRocks generates the path between the points (with the trajectory generator), and subsequently splits the path into splines for the individual joints using the kinematic layer.
With the streamer layer NYCeRocks executes the actual movement. The physical construction that includes joint A and B is called a "mechanism" in NYCeRocks.
P1
P2
P3
P4
joint A joint B
Fig. 1-4: Movement in world coordinates space
Each mechanism has its typical kinematic model. See fig. 1-1 "NYCeRocks Control Hierarchy" on page 3 for some examples of mechanisms. If the mechanism is different, the kinematic model is also different, but the trajectory generator and the streamer may be the same. However, it is also possible that a different trajectory generator is chosen while the kinematic model and the streamer stays the same. This flexibility is shown in fig. 1-5
"NYCeRocks application software overview" on page 7.
NYCe 4000 NYCeRocks
Fig. 1-5: NYCeRocks application software overview
The following chapters in this manual describe how you define a mechanism, how you use the standard trajectory generator and how you can add your own trajectory generator, and describe the standard kinematic model for a cartesian XYZ model.
1.4 Used abbreviations in this manual
tab. 1-1 "Summary of used abbreviations" on page 7 gives a summary of abbreviations used in this manual.
Abbreviation Description
API Application Programming Interface.
C67 A preprocessor directive for the compiler to generate code executed on the MCU.
DLL Dynamic Link Library.
HMI Human Machine Interface.
NHI Node Hardware Interface (NYCe 4000 subsystem).
NT A preprocessor directive for the compiler to generate code executed on the PC.
SAC Single Axis Control (NYCe 4000 subsystem).
SERCOS III Third generation SERCOS (Serial Real time Communication System ) drive communication protocol based on the Ethernet physical hardware architecture.
SEQ Sequencer (NYCe 4000 subsystem).
UDSX User Defined Sample Extension.
Tab. 1-1: Summary of used abbreviations
NYCe 4000 NYCeRocks
2 Definition of a mechanism
2.1 Introduction
All layers of the NYCeRocks software operate on a mechanism. NYCeRocks can handle more than 1 mechanism. This chapter describes how a mechanism can be created and deleted.
2.2 Mechanism creation
The structure ROCKS_MECH defines the properties for each mechanism.
Program:
// Definition of the structure rocks_mech typedef struct rocks_mech
{ BOOL dof[ROCKS_MECH_MAX_DOF]; // Degrees Of Freedom uint32_t nrOfJoints; // number of joints SAC_AXIS jointAxisId[ROCKS_MECH_MAX_NR_OF_JOINTS]; // SAC axis identifiers ROCKS_MECH_VAR var; // variables
} ROCKS_MECH;
The member dof is an array of 6 booleans. If the value is TRUE, the degree of freedom is used. The order is X, Y, Z, Rx, Ry, Rz.
The member nrOfJoints specifies the number of joints. For a cartesian mechanism this is equal to the number of dof. For the standard gantry this is equal to the number of dof + 1.
The member jointAxisId specifies the axis identifiers of the joints.
The application can call functions of the trajectory generator, the kinematics and the streamer after a mechnism has been created. The mechanism is created and deleted with one of the following functions.
● RocksMechCreate
● RocksMechCreateAtSrvSeq
● RocksMechDelete
All axes of the mechanism must be on the same node.
The function RocksMechCreate is used in a process where NYCeRocks runs in the context of the same process, see fig. 1-3 "Implementation methods for NYCeRocks" on page 5, method ① and ②. The input for this function is a pointer to a mechanism structure. The members dof, nrOfJoints, and jointAxisId of the structure ROCKS_MECH must be specified by the application. The member var is maintained by NYCeRocks.
It is the responsibility of the application to set the axes in the SAC_READY state. See the NYCe 4000 Software User Manual for more information about axis states.
The function RocksMechCreateAtSrvSeq is used by a sequence when NYCeRocks runs in an other (server) sequence. The input for this function is a pointer to a mechanism structure, and 3 arguments pNodeName, rocksServerArea, and dataArea. The members dof, nrOfJoints, and jointAxisId of the structure ROCKS_MECH must be specified by the application. The member var is maintained by NYCeRocks. The argument Definition of a mechanism
pNodeName is the name of the node where NYCeRocks runs. The argument rocksServerArea is the area number where the NYCeRocks server sequence runs. The argument dataArea is the area number of a sequence memory area that will be used for client/server communication data. It is the responsibility of the application to set the axes in the SAC_READY state.
● When the function RocksMechCreateAtSrvSeq is called from the PC, the function also executes a SeqConnect of the node.
● The function RocksMechCreateAtSrvSeq is implemented in n4krocksseq.dll. Link with the library n4krocksseq.lib. To use the client/server implementation of the NYCeRocks API, link with the library n4krocksclient.lib and use the correct preprocessor directive ("C67" if the client runs on the MCU, "NT" if the client runs on the PC).
The mechanism must be terminated when the mechanism is no longer needed to free allocated system resources. A mechanism is deleted with the function RocksMechDelete and has 1 argument, the pointer to the stucture ROCKS_MECH. When the last mechanism on a node is deleted, the function RocksMechDelete also executes a SeqDisconnect of the node.
All functions, RocksMechCreate, RocksMechCreateAtSrvSeq, and RocksMechDelete return a status of type NYCE_STATUS. When the returned status is NYCE_OK, the call of the function was successful.
Definition of a mechanism
3 Trajectory generation
3.1 Introduction
This chapter describes the standard trajectory generation functions. A trajectory is a path from one point to an other point in real world coordinates.
Further, this chapter describes how trajectories can be concatenated, how to add an application specific trajectory generator, and how you can reuse trajectories.
3.2 Standard trajectory generation functions
3.2.1 Introduction
The standard trajectory generation uses sinusoidal shaped acceleration profiles or third order profiles to generate a path.
The complete profile is calculated for all trajectories from start to end before the mechanism starts to move. The movement is started with the function RocksStream, see chapter 5
"Streamer" on page 29. It is not possible to add path sections while the mechanism is moving. Further, there is no quick stop or smooth stop possible on a path.
3.2.2 Sinusoidal shaped acceleration profile
The sinusoidal shaped acceleration profile has two functions.
● RocksTrajSineAccPtp
● RocksTrajSineAccCircle
Both functions have 2 arguments. The first argument is a pointer to the structure ROCKS_MECH, which defines the mechanism for which the profile is generated.
The function RocksTrajSineAccPtp generates a trajectory with a sinusoidal shaped acceleration profile along a straight line from the specified start position to the specified end position. The start and end position, and other profile parameters are specified by the second argument of the
function, a pointer to a structure of type
ROCKS_TRAJ_SINE_ACC_PTP_PARS.
Program:
// Definition of the structure ROCKS_TRAJ_SINE_ACC_PTP_PARS typedef struct rocks_traj_sine_acc_ptp_pars
{ double startPos[ROCKS_MECH_MAX_DOF]; // start position in world coordinates double endPos[ROCKS_MECH_MAX_DOF]; // end position in world coordinates double maxVelocity; // path velocity constraint
double maxAcceleration; // path acceleration constraint double splineTime; // spline time
uint32_t maxNrOfSplines; //
double* pPositionSplineBuffer; //
double* pVelocitySplineBuffer; //
} ROCKS_TRAJ_SINE_ACC_PTP_PARS;
Trajectory generation
The function RocksTrajSineAccPtp uses the specified maxAcceleration and maxVelocity to calculate a time-optimal profile.
All generated splines have the same duration, which is specified with the member splineTime. Normally, the start position is current position which can be retrieved with a function from the kinematic module, for example RocksKinCartesianPosition for a Cartesian kinematic module, see chapter chapter 4 "Kinematics" on page 23).
The member maxNrOfSplines is normally set to 0, and the members pPositionSplineBuffer and pVelocitySplineBuffer are normally set to NULL. However, if you want to use spline buffers defined in your application, set maxNrOfSplines to the number of spline elements in the user-supplied spline buffers. pPositionSplineBuffer points to the buffer that stores path position segments, and pVelocitySplineBuffer points to the buffer that stores path velocity segments. It is advised to use the values 0, NULL, NULL, respectively, to force the trajectory generator to allocate the memory for the path data dynamically.
fig. 3-1 "RocksTrajSineAccPtp(X, Y, Z) generated position" on page 12, fig.
3-2 "RocksTrajSineAccPtp(X, Y, Z) generated velocity" on page 12, and fig.
3-3 "RocksTrajSineAccPtp(X, Y, Z) generated acceleration" on page 13 show NYCeScope output of the profiles generated with the function RocksTrajSineAccPtp.
Fig. 3-1: RocksTrajSineAccPtp(X, Y, Z) generated position
Fig. 3-2: RocksTrajSineAccPtp(X, Y, Z) generated velocity Trajectory generation
Fig. 3-3: RocksTrajSineAccPtp(X, Y, Z) generated acceleration
The function RocksTrajSineAccCircle generates a trajectory with a sinusoidal shaped acceleration profile along an arc, or a circle, with a specified angle starting from the specified start position. See fig. 3-4
"Trajectory specification along an arc or circle" on page 13. The arc is specified by the center of the circle "c" of which the arc is a part. The circle is in the defined plane. The angle "α" is specified in radians, and a positive angle defines a counter-clockwise movement. The start position is "s" in the figure, and "e" is the resulting end position. The trajectory path is shown by the red line.
s
c α e
Fig. 3-4: Trajectory specification along an arc or circle
The start position, and other profile parameters are specified by the second argument of the function, a pointer to a structure of type ROCKS_TRAJ_SINE_ACC_CIRCLE_PARS.
Program:
// Definition of the structure ROCKS_TRAJ_SINE_ACC_CIRCLE_PARS typedef struct rocks_traj_sine_acc_circle_pars
{ double startPos[ROCKS_MECH_MAX_DOF]; // start position in world coordinates double center[2]; // center of circular move
double angle; // angle of circular move ROCKS_PLANE plane; // plane of the circular move double maxVelocity; // path velocity constraint double maxAcceleration; // path acceleration constraint double splineTime; // spline time
uint32_t maxNrOfSplines; //
double* pPositionSplineBuffer; //
double* pVelocitySplineBuffer; //
} ROCKS_TRAJ_SINE_ACC_CIRCLE_PARS;
Trajectory generation
The function RocksTrajSineAccCircle uses the specified maxAcceleration and maxVelocity to calculate a time-optimal profile.
All generated splines have the same duration, which is specified with the member splineTime.
The member maxNrOfSplines is normally set to 0, and the members pPositionSplineBuffer and pVelocitySplineBuffer are normally set to NULL. However, if you want to use spline buffers defined in your application, set maxNrOfSplines to the number of elements in the user- supplied buffers. pPositionSplineBuffer points to the buffer that stores path position segments, and pVelocitySplineBuffer points to the buffer that stores path velocity segments. It is advised to use the values 0, NULL, NULL, respectively, to force the trajectory generator to allocate the memory for the path data dynamically.
fig. 3-5 "RocksTrajSineAccCircle(360, X, Y) generated position" on page 14, fig. 3-6 "RocksTrajSineAccCircle(360, X, Y) generated velocity" on page 14, and fig. 3-7 "RocksTrajSineAccCircle(360, X, Y) generated acceleration"
on page 15 show NYCeScope output of the profiles generated with the function RocksTrajSineAccCircle.
Fig. 3-5: RocksTrajSineAccCircle(360, X, Y) generated position
Fig. 3-6: RocksTrajSineAccCircle(360, X, Y) generated velocity Trajectory generation
Fig. 3-7: RocksTrajSineAccCircle(360, X, Y) generated acceleration
3.2.3 Third order acceleration profile
The 3rd order profile has three functions.
● RocksTrajCubicPtp
● RocksTrajCubicCircle
● RocksTrajCubicSeparateJointSpeed
The first argument for all 3 functions is a pointer to the structure ROCKS_MECH, which defines the mechanism for which the profile is generated.
The function RocksTrajCubicPtp generates a trajectory with a 3rd order profile along a straight line from the specified start position to the specified end position. The start and end position, and other profile parameters are specified by the second argument of the function, a pointer to a structure of type ROCKS_TRAJ_CUBIC_PTP_PARS.
Program:
// definition of the structure ROCKS_TRAJ_CUBIC_PTP_PARS typedef struct rocks_traj_cubic_ptp_pars
{ double startPos[ROCKS_MECH_MAX_DOF]; // start position in world coordinates double endPos[ROCKS_MECH_MAX_DOF]; // end position in world coordinates double maxVelocity; // path velocity constraint
double maxAcceleration; // path acceleration constraint double maxJerk; // path jerk constraint
uint32_t maxNrOfSplines; //
double* pPositionSplineBuffer; //
double* pVelocitySplineBuffer; //
double* pTimeSplineBuffer; //
} ROCKS_TRAJ_CUBIC_PTP_PARS;
The member maxNrOfSplines is normally set to 0, and the members pPositionSplineBuffer, pVelocitySplineBuffer, and pTimeSplineBuffer are normally set to NULL. However, if you want to use spline buffers defined in your application, set maxNrOfSplines to the number of elements in the user-supplied buffers.
pPositionSplineBuffer points to the buffer that stores path position segments, pVelocitySplineBuffer points to the buffer that stores path velocity segments, and pTimeSplineBuffer points to the buffer that stores the duration of the segments. It is advised to use the values 0, NULL, NULL, Trajectory generation
NULL, respectively, to force the trajectory generator to allocate the memory for the path data dynamically.
This trajectory generates a maximum of 8 splines. If no separate joint speed is used, it only uses 7 splines.
fig. 3-8 "RocksTrajCubicPtp(X, Y, Z) generated position" on page 16, fig.
3-9 "RocksTrajCubicPtp(X, Y, Z) generated velocity" on page 16, and fig.
3-10 "RocksTrajCubicPtp(X, Y, Z) generated acceleration" on page 17 show NYCeScope output of the profiles generated with the function RocksTrajCubicPtp.
Fig. 3-8: RocksTrajCubicPtp(X, Y, Z) generated position
Fig. 3-9: RocksTrajCubicPtp(X, Y, Z) generated velocity Trajectory generation
Fig. 3-10: RocksTrajCubicPtp(X, Y, Z) generated acceleration
The function RocksTrajCubicCircle generates a trajectory with a 3rd order profile along an arc, or a circle, with a specified angle starting from the specified start position. The arc is well-defined, but not always part of a circle.
For larger arcs it is part of an ellipse due to different velocities and accelerations of the axes of the mechanism. The circle is specified by the center in the defined plane. The angle is specified in radians, and a positive angle defines a counter-clockwise movement. The start position, and other profile parameters are specified by the second argument of the function, a pointer to a structure of type ROCKS_TRAJ_CUBIC_CIRCLE_PARS.
Program:
//definition of the structure ROCKS_TRAJ_CUBIC_CIRCLE_PARS typedef struct rocks_traj_cubic_circle_pars
{ double startPos[ROCKS_MECH_MAX_DOF]; // start position in world coordinates double center[2]; // center of circular move
double angle; // angle of circular move ROCKS_PLANE plane; // plane of the circular move double maxVelocity; // path velocity constraint double maxAcceleration; // path acceleration constraint double maxJerk; // path jerk constraint
uint32_t maxNrOfSplines; //
double* pPositionSplineBuffer; //
double* pVelocitySplineBuffer; //
double* pTimeSplineBuffer; //
} ROCKS_TRAJ_CUBIC_CIRCLE_PARS;
Both functions, RocksTrajCubicPtp and RocksTrajCubicCircle, use the specified path constraints maxJerk, maxAcceleration, and maxVelocity to calculate a time-optimal profile. This traject generator generates 7 splines with variable time segments.
The member maxNrOfSplines is normally set to 0, and the members pPositionSplineBuffer, pVelocitySplineBuffer, and pTimeSplineBuffer are normally set to NULL. However, if you want to use spline buffers defined in your application, set maxNrOfSplines to the number of elements in the user-supplied buffers.
pPositionSplineBuffer points to the buffer that stores path position segments, pVelocitySplineBuffer points to the buffer that stores path velocity segments, and pTimeSplineBuffer points to the buffer that stores the duration of the segments. It is advised to use the values 0, NULL, NULL, Trajectory generation
NULL, respectively, to force the trajectory generator to allocate the memory for the path data dynamically.
● This trajectory generates a maximum of 8 splines. If no separate joint speed is used, it only uses 7 splines.
● The circle becomes less accurate if the angle is increased, because only a limited number of splines is used. The maximum angle is π radians.
Normally, the joints of a mechanism start and stop simultaneously. However, sometimes it can be desirable to have one or more joints run at a more optimal faster speed.
With the function RocksTrajCubicSeparateJointSpeed you can set the joint constraints for a specific joint and determine if the joint should start simultaneously or stop simultaneously with the other joints of the mechanism.
It may seem contradictory, but if the path calculation causes the joint to move faster than the specified joint constraints, these joint constraints are ignored.
The application can lower the path constraints in this case. The function RocksTrajCubicSeparateJointSpeed has 2 additional arguments, joint specifies the joint number of the mechanism, and pJointInfo points to a structure of type ROCKS_TRAJ_CUBIC_JOINT_INFO.
Program:
//definition of the structure ROCKS_TRAJ_CUBIC_JOINT_INFO typedef struct rocks_traj_cubic_joint_info
{ double velocity; // max velocity double acceleration; // max acceleration
double jerk; // max jerk or SAC_INDEFINITE for 2nd order double baseVelocity; // base velocity for steppers
TRAJ_CUBIC_JOINT_BEHAVIOR jointBehavior; // default is START_STOP_SIMULTANEOUS } ROCKS_TRAJ_CUBIC_JOINT_INFO;
The members velocity, acceleration, jerk, and baseVelocity are only used if the member jointBehavior is not equal to START_STOP_SIMULTANEOUS.
3.3 Concatenate trajectories
The following functions are available to concatenate path trajectories.
● RocksTrajSegmentStart
● RocksTrajSegmentLine
● RocksTrajSegmentArc
The functions RocksTrajSegmentStart, RocksTrajSegmentLine, and RocksTrajSegmentArc are used to concatenate line and circle segments.
The function RocksTrajSegmentStart must be called once before a number of RocksTrajSegmentLine and RocksTrajSegmentArc can be called. The function RocksTrajSegmentStart defines the start position, the spline time, the maximum number of splines, and the spline buffers used to store the path splines.
Trajectory generation
All 3 functions have 2 arguments. The first argument is a pointer to the structure ROCKS_MECH, which defines the mechanism for which the splines are generated.
The second argument of the function RocksTrajSegmentStart is a pointer to a structure of type ROCKS_TRAJ_SEGMENT_START_PARS.
Program:
// definition of the structure ROCKS_TRAJ_SEGMENT_START_PARS typedef struct rocks_traj_segment_start_pars
{ double splineTime; // spline time uint32_t maxNrOfSplines; //
double* pPositionSplineBuffer; //
double* pVelocitySplineBuffer; //
double startPos[ROCKS_MECH_MAX_DOF]; // start position in world coordinates } ROCKS_TRAJ_SEGMENT_START_PARS;
The member maxNrOfSplines is normally set to 0, and the members pPositionSplineBuffer and pVelocitySplineBuffer are normally set to NULL. However, if you want to use spline buffers defined in your application, set maxNrOfSplines to the number of elements in the user- supplied buffers. pPositionSplineBuffer points to the buffer that stores path position segments, and pVelocitySplineBuffer points to the buffer that stores path velocity segments. It is advised to use the values 0, NULL, NULL, respectively, to force the trajectory generator to allocate the memory for the path data dynamically.
The function RocksTrajSegmentStart starts the concatenation of line and arc segments. The function returns NYCE_OK if the function is executed succesfully.
The second argument of the function RocksTrajSegmentLine is a pointer to a structure of type ROCKS_TRAJ_SEGMENT_LINE_PARS.
Program:
// definition of the structure ROCKS_TRAJ_SEGMENT_LINE_PARS typedef struct rocks_traj_segment_line_pars
{ double endPos[2]; // end position in world coordinates (XY, XZ, or YZ) double endVelocity; // end velocity
double maxAcceleration; // path acceleration constraint ROCKS_PLANE plane; // plane of the segment
ROCKS_POSE originOffset; // reference frame rotation offsets to be added before the line } ROCKS_TRAJ_SEGMENT_LINE_PARS;
With the function RocksTrajSegmentLine you can add a line segment to a trajectory. The start position of the line segment is the end position of the start segment or a previous line or arc segment. The function returns NYCE_OK if the function is executed succesfully.
The second argument of the function RocksTrajSegmentArc is a pointer to a structure of type ROCKS_TRAJ_SEGMENT_ARC_PARS.
Program:
// definition of the structure ROCKS_TRAJ_SEGMENT_ARC_PARS typedef struct rocks_traj_segment_arc_pars
{ double endPos[2]; // end position in 2 world coordinates (XY, XZ, or YZ) double center[2]; // center of the arc (XY, XZ, or YZ)
BOOL positiveAngle; // direction: TRUE=positive (CCW), FALSE=negative (CW)
Trajectory generation
double endVelocity; // end velocity
double maxAcceleration; // path acceleration constraint ROCKS_PLANE plane; // plane of the segment
ROCKS_POSE originOffset; // reference frame rotation offsets to be added before the line } ROCKS_TRAJ_SEGMENT_ARC_PARS;
With the function RocksTrajSegmentArc you can add an arc segment to a trajectory. The start position of the arc segment is the end position of the start segment or a previous line or arc segment. The function returns NYCE_OK if the function is executed succesfully.
Example of a concatenated trajectory
Fig. 3-11: Concatenated segments shown in 3D Trajectory generation
X
Y R
X Y
0
1 2
3 4 6 5
7
8 9
Fig. 3-12: Concatenated segments shown in 2D (XY plot)
fig. 3-12 "Concatenated segments shown in 2D (XY plot)" on page 21 shows a trajectory in the XY plane using line and arc concatenated trajectories. The trajectory path ⓞ is generated with the function RocksTrajSegmentStart.
The trajectory paths ①, ③, ⑤, ⑦, and ⑨ are generated with the function RocksTrajSegmentLine, and the trajectory paths ②, ④, ⑥, and ⑧ are generated with the function RocksTrajSegmentArc. fig. 3-13 "X, Y, and Z position plot against time of the executed concatenated trajectory paths" on page 21 shows a NYCeScope plot of the position movement for each axis of the mechanism.
Fig. 3-13: X, Y, and Z position plot against time of the executed concatenated trajectory paths
In the structures ROCKS_TRAJ_SEGMENT_LINE_PARS and ROCKS_TRAJ_SEGMENT_ARC_PARS the line and arc segments are defined in a plane (XY, XZ or YZ). Besides the plane, a rotation can be defined, to enable all degrees of freedom.
3.4 Adding a new trajectory generator
Adding a new trajectory generator requires inside knowledge of the mechanism descriptor. This is outside the scope of this manual.
Trajectory generation
3.5 Reuse trajectory
The application can reuse a generated trajectory path. The precondition is that the start and end points are identical, or that the reference frame is changed so that start and end points become identical. The following functions are available.
● RocksTrajGetPath
● RocksTrajLoadPath
● RocksTrajDeletePath
With the function RocksTrajGetPath you can retrieve the last generated path spline for the mechanism. The retrieved path spline can only be used as input argument for the functions RocksTrajLoadPath and RocksTrajDeletePath.
With the function RocksTrajLoadPath you can load path splines for the mechanism. The path splines must have been retrieved with the function RocksTrajGetPath.
With the function RocksTrajDeletePath you can delete a path that has been retrieved with the function RocksTrajGetPath.
All 3 functions have the following 2 arguments.
The first argument is a pointer to the structure ROCKS_MECH, which defines the mechanism for which the path spline is generated.
The second argument specifies the type of trajectory and trajectory path. This argument is a pointer to a structure of type ROCKS_TRAJ_PATH. The structure ROCKS_TRAJ_PATH contains 2 members, the enumeration ROCKS_TRAJ_TYPE and the union ROCKS_TRAJ_PATH_PARS.
Program:
// definition of the enumeration of ROCKS_TRAJ_TYPE typedef enum rocks_traj_type
{ ROCKS_TRAJ_TYPE_NONE = -1, ROCKS_TRAJ_TYPE_SINE_ACC_PTP = 0, ROCKS_TRAJ_TYPE_SINE_ACC_CIRCLE, ROCKS_TRAJ_TYPE_CUBIC_PTP, ROCKS_TRAJ_TYPE_CUBIC_CIRCLE, ROCKS_TRAJ_TYPE_SEGMENTS } ROCKS_TRAJ_TYPE;
The structure ROCKS_TRAJ_PATH_PARS is a union of structures. The selected structure must match the selected trajectory type.
Program:
// definition of the union ROCKS_TRAJ_PATH_PARS typedef union rocks_traj_path_pars
{ ROCKS_TRAJ_SINE_ACC_PTP_PARS sineAccPtpPars;
ROCKS_TRAJ_SINE_ACC_CIRCLE_PARS sineAccCirclePars;
ROCKS_TRAJ_CUBIC_PTP_PARS cubicPtpPars;
ROCKS_TRAJ_CUBIC_CIRCLE_PARS cubicCirclePars;
ROCKS_TRAJ_SEGMENT_START_PARS segmentPars;
} ROCKS_TRAJ_PATH_PARS;
Trajectory generation
4 Kinematics
4.1 Introduction
This chapter describes the standard NYCeRocks kinematics, and how you can add an application-specific kinematics.
Fig. 4-1: Kinematic layer between trajectory generator and streamer
4.2 Cartesian XYZ
The standard module for cartesian XYZ kinematics translates the path splines to the joint splines, with a joint for X, a joint for Y, and a joint for Z. An Rz coordinate can also be used. The layer has the following functions.
● RocksKinForwardCartesian
● RocksKinInverseCartesian
● RocksKinCartesianPosition
The function RocksKinForwardCartesian translates joint coordinates to world coordinates. The function has 3 arguments. The first argument is a pointer to the structure ROCKS_MECH, which defines the mechanism. The second argument, jointPos, is an array of joint positions. The size of the array jointPos depends on the number of joints in the mechanism. The third argument, cartesianPos, is an array of cartesian positions. The size of the array cartesianPos is always ROCKS_MECH_MAX_DOF.
The function RocksKinInverseCartesian generates joint splines for a cartesian mechanism. The function has 2 arguments. The first argument is a pointer to the structure ROCKS_MECH, which defines the mechanism. The second argument is a pointer to a structure of type ROCKS_KIN_INV_PARS.
The structure defines the buffers for joint splines after an inverse kinematic Kinematics
transformation. Both members of the structure are normally set to NULL.
However, if you want to use buffers defined in your application, pJointPositionBuffer points to the buffer that stores joint position segments, and pJointVelocityBuffer points to the buffer that stores joint velocity segments. It is advised to set the values to NULL for all joints, to force the kinematics to allocate the memory dynamically.
Program:
// definition of the structure ROCKS_KIN_INV_PARS typedef struct rocks_kin_inv_pars
{ double* pJointPositionBuffer[ROCKS_MECH_MAX_NR_OF_JOINTS];
double* pJointVelocityBuffer[ROCKS_MECH_MAX_NR_OF_JOINTS];
} ROCKS_KIN_INV_PARS;
The function RocksKinCartesianPosition translates an actual joint coordinate to world coordinate. The function has 2 arguments. The first argument is a pointer to the structure ROCKS_MECH, which defines the mechanism. The second argument, cartesianPos, is an array of the world coordinates. The size of the array cartesianPos must always be ROCKS_MECH_MAX_DOF.
4.3 Gantry
The standard module for gantry kinematics is also a cartesian kind of kinematics. It only has 2 joints in X or in Y. So, it is for XXYZ or XYYZ kinematics with an optional Rz, see fig. 4-2 "Example of a gantry with two X axes and one Y axis" on page 24 and fig. 4-3 "Example of a gantry with one X axis two Y axes" on page 25.
Fig. 4-2: Example of a gantry with two X axes and one Y axis Kinematics
Fig. 4-3: Example of a gantry with one X axis two Y axes The following functions are available.
● RocksKinDefineGantry
● RocksKinForwardGantry
● RocksKinInverseGantry
● RocksKinGantryPosition
A gantry has two X axes or two Y axes. With the function RocksKinDefineGantry you can set the X or the Y axes. The function must be called after the mechanism is created, see chapter 2 "Definition of a mechanism" on page 9. If the direction is ROCKS_GANTRY_X, the joints are X1, X2, and Y. If the direction is ROCKS_GANTRY_Y, the joints are X, Y1, and Y2. You can specify additional joints for other degrees of freedom, after the 3 mandatory joints are defined. The function RocksKinDefineGantry has 2 arguments. The first argument is a pointer to the structure ROCKS_MECH, which defines the mechanism. The second argument is defines the gantry direction, which can be ROCKS_GANTRY_X or ROCKS_GANTRY_Y.
The function RocksKinForwardGantry translates joint coordinates to world coordinates. The function has 3 arguments. The first argument is a pointer to the structure ROCKS_MECH, which defines the mechanism. The second argument, jointPos, is an array of joint positions. The size of the array jointPos depends on the number of joints in the mechanism. The third argument, gantryPos, is an array of cartesian positions. The size of the array gantryPos is always ROCKS_MECH_MAX_DOF.
The function RocksKinInverseGantry generates joint splines for a gantry mechanism. The function has 2 arguments. The first argument is a pointer to the structure ROCKS_MECH, which defines the mechanism. The second argument is a pointer to a structure of type ROCKS_KIN_INV_PARS. The Kinematics
structure defines the buffers for joint splines after an inverse kinematic transformation. Both members of the structure are normally set to NULL.
However, if you want to use buffers defined in your application, pJointPositionBuffer points to the buffer that stores joint position segments, and pJointVelocityBuffer points to the buffer that stores joint velocity segments. It is advised to set the values to NULL for all joints, to force the kinematics to allocate the memory dynamically.
The function RocksKinGantryPosition translates the actual joint coordinates to world coordinates. The function has 2 arguments. The first argument is a pointer to the structure ROCKS_MECH, which defines the mechanism. The second argument, gantryPos, is an array of the world coordinates. The size of the array gantryPos must always be ROCKS_MECH_MAX_DOF.
4.4 Translation and rotation
The translation and rotation function translates and rotates the origin. The translation and rotation are relative. This means that, if several translations or rotations are executed, they all add up.
X Y
Z
Fig. 4-4: Example of the combination of a translation and a rotation The module has the following functions.
● RocksKinMoveOrigin
● RocksKinResetOrigin
The function RocksKinMoveOrigin translates and rotates the reference frame. The function has 2 arguments. The first argument is a pointer to the structure ROCKS_MECH, which defines the mechanism. The second argument is a pointer to a structure of type ROCKS_POSE. The structure ROCKS_POSE contains a 3-dimensional translation vector and a 3-dimensional rotation vector. The translation and rotation defined in the structure are added to the previous translation and rotation offsets.
Program:
// definition of the structure ROCKS_POSE typedef struct rocks_pose
{ ROCKS_E3_VECTOR t; // 3 translation coordinates ROCKS_E3_VECTOR r; // 3 rotation coordinates } ROCKS_POSE;
Kinematics
The function RocksKinResetOrigin resets the origin to its original position. The function has 1 argument, a pointer to the structure ROCKS_MECH, which defines the mechanism.
4.5 Adding additional transformations
You can add additional transformations, see fig. 4-1 "Kinematic layer between trajectory generator and streamer" on page 23. The following functions are available.
● RocksKinSetForwardCompensation
● RocksKinSetInverseCompensation
With the function RocksKinSetForwardCompensation you can set a user-defined forward conversion function. Only one function can be defined.
The function has 2 arguments. The first argument is a pointer to the structure ROCKS_MECH, which defines the mechanism. The second argument is a pointer to the function of type ROCKS_KIN_CONVERSION. To delete the function, specify NULL as conversion function.
With the function RocksKinSetInverseCompensation you can set a user-defined inverse conversion function. Only one function can be defined.
The function has 2 arguments. The first argument is a pointer to the structure ROCKS_MECH, which defines the mechanism. The second argument is a pointer to the function of type ROCKS_KIN_CONVERSION. To delete the function, specify NULL as conversion function.
4.6 Adding an application-specific kinematics
Adding a new application-specific kinematic model requires inside knowledge of the mechanism descriptor. This is outside the scope of this manual.
Kinematics
5 Streamer
The NYCeRocks streamer has the following functions.
● RocksStream
● RocksStreamSynchronize
● RocksStreamReleaseGroup
With the function RocksStream you start the streaming of splines of the joint spline buffers to the axes. The function puts all joints of the mechanism in a MAC group and an error group. See the NYCe 4000 Software User Manual for more information. The function RocksStream has one argument which is a pointer to the structure ROCKS_MECH, which defines the mechanism.
You can use the function RocksStreamSynchronize to check whether the streaming is finished. The function RocksStreamSynchronize returns successful when all axes of the mechanism finished their motion. The function has 2 arguments. The first argument is a pointer to the structure ROCKS_MECH, which defines the mechanism. The second argument specifies a time-out, or NYCE_INFINITE if no time-out is used.
With the function RocksStreamReleaseGroup the defined MAC group and error group are released. The function has one argument which is a pointer to the structure ROCKS_MECH.
Streamer
6 Support functions
6.1 Introduction
This chapter describes the support functions available in NYCeRocks.
6.2 Conversion
Conversion functions are defined in a separate header file, rocksenums.h.
These functions convert a definition to a printable text string and vice versa, or check that the specified enumeration identifier is valid. The conversion functions all have an identical naming scheme. The first part of the function name is the name of the enumeration type for which the conversion is performed. The last part of the function name represents the actual performed conversion. The conversion functions are available for the following defined ROCKS enumeration types.
● RocksPlane<conversion>
● RocksGantryDirection<conversion>
● RocksMoveType<conversion>
● RocksTrajType<conversion>
● RocksTrajCubicJointBehavior<conversion>
● RocksMechStep<conversion>
The following conversions are available.
● ToString ‑ enumeration identifier to exact string representation.
● ToUserString ‑ enumeration identifier to human readable string.
● ToDescription ‑ enumeration identifier to descriptive string.
● FromString ‑ specified string to enumeration value.
● IsValid ‑ check validity of specified value of the enumeration identifier.
As an example, the conversion functions for the enumeration type ROCKS_TRAJ_TYPE are listed here. See the header file for other defined conversion functions.
RocksTrajTypeToString RocksTrajTypeToUserString RocksTrajTypeToDescription RocksTrajTypeFromString RocksTrajTypeIsValid
If the specified argument string is NULL, the error ROCKS_ERR_INVALID_PARAMETER is returned. If the specified argument string is not correct, the error ROCKS_ERR_UNKNOWN_ENUM_STRING is returned.
If the specified argument value is incorrect, the returned string is
"<unknown("X")>", where "X" is the ROCKS enumeration type.
Support functions
6.3 Outputs
With the output functionality you can set, clear, or toggle a specified digital output at a certain defined moment in time during the execution of a sinusoidal shaped acceleration profile or segmented profile. The resolution of the relative time is equal to the maximum of the user supplied spline time and
the MCU sample time. You can define up to
ROCKS_MECH_MAX_OUTPUT_CHANGES (32) output actions per profile. If
more output actions are specified, the error
ROCKS_ERR_TOO_MANY_OUTPUT_CHANGES is returned. The error ROCKS_ERR_INVALID_OUTPUT is returned when the output or output action is not correct. The following functions are available.
● RocksTrajClearOutput
● RocksTrajSetOutput
● RocksTrajToggleOutput RocksTrajClearOutput,
RocksTrajSetOutput, RocksTrajToggleOutput
With the functions RocksTrajClearOutput, RocksTrajSetOutput, and RocksTrajToggleOutput you can respectively clear, set, and toggle a specified output relative to a path event. All 3 functions have the same arguments. The first two arguments, pMech and outId, specify the mechanism and the digital output identifier. The argument timeReference defines the reference point in time. It is an enumeration and defines the following reference time moments.
● ROCKS_START_OF_PROFILE
The time reference moment is at the start of a complete profile.
● ROCKS_END_OF_PROFILE
The time reference moment is at the end of a complete profile.
● ROCKS_START_OF_NEXT_SEGMENT
The time reference moment is at the start of the next arc or line segment. This event covers both end of segment and start of next segment.
The argument time defines the time (specified in [s]) relative to the specified time reference moment that the function action (clear, set, or toggle) is executed for the specified output. If the reference moment is the start of the profile or segment, time can only be a positive number or 0. If the reference moment is the end of the profile or relative to a segment boundary, time can be a negative number, positive number, or 0. If a negative time value is specified, the output action moment cannot be earlier than the start of the profile.
If an error occurs it is the responsibility of the application to set the output(s) in the correct state.
At setpoint level, the time as specified with the functions RocksTrajClearOutput, RocksTrajSetOutput, and RocksTrajToggleOutput is accurate within the mentioned resolution increased by one MCU sample. At actual position level, accuracy in addition depends on the system delays for the actual configuration of the axes, and the tracking performance of the mechanism. Actual hardware switching delays (typical 50 µs for standard digital outputs, and typical 2 µs for fast digital outputs) are negligible with respect to these times.
Support functions
6.4 Latches
A latch stores the position of an axis (or axes) when a digital input is activated. The NYCe 4000 latch functionality is used to latch a mechanism position based on an input event, see the NYCe 4000 Software User Manual for more information. First, a latch must be defined with the function NhiDefineLatch.
● RocksMechDefineProbe
● RocksMechActivateProbe
● RocksMechGetProbeStatus
● RocksMechGetProbePosition
● RocksMechDeleteProbe
With the function RocksMechDefineProbe a probe is defined to latch the joint positions of the specified mechanism. The function has 3 arguments.
The first argument is a pointer to the structure ROCKS_MECH, which specifies the mechanism. The second argument specifies the latch number (0 .. 3), and the third argument specifies the digital input. RocksMechDefineProbe is not supported for an IndraDrive-based axis. If the third argument, io, is NYCE_INDRA_SLOT, the error ROCKS_ERR_PROBE_ERROR is returned.
The function RocksMechActivateProbe activates the probe signal detection. When the signal is detected, the probe is deactivated. Note that you must call RocksMechActivateProbe to activate the probe signal detection again after the signal has been detected. The function RocksMechActivateProbe has 2 arguments which specify the mechanism and the latch number.
With the function RocksMechGetProbeStatus the status of the latch can be read. The function has 4 arguments. The first two arguments specify the mechanism and the latch number. The third and fourth argument return, respectively, the probe status, which can be active or inactive, and the latch status, which can be latched or not latched.
With the function RocksMechGetProbePosition you can retrieve the latched positions of the joints of the mechanism (if the latch is activated). The function has 3 arguments. The first two arguments specify the mechanism and the latch number. The third argument is an array that holds the latched positions of the joints of the mechanism. The array must be allocated before the function RocksMechGetProbePosition is called.
With the function RocksMechDeleteProbe a probe defined with the function RocksMechDefineProbe can be deleted. The function RocksMechDeleteProbe has 2 arguments which specify the mechanism and the latch number.
6.5 Synchronization groups
NYCeRocks supports the synchronization of a group of mechanisms. After mechanisms have been added to a so-called sync group, it is possible to synchronize the start of certain actions for all mechanisms in the sync group.
See the NYCe 4000 Software User Manual for more information about sync groups. The following functions are available.
● RocksMechDefineSyncGroup
● RocksMechStartSyncGroup
● RocskMechDeleteSyncGroup
Support functions
With the function RocksMechDefineSyncGroup you can specify the mechanisms which must be in a sync group. The function has 2 arguments.
The first argument is an array that holds the mechanisms that must be grouped, and the second argument specifies the number of mechanisms.
Note that the NYCe 4000 function MacDefineSyncGroup returns a group identifier, but the function RocksMechDefineSyncGroup does not return a group identifier. Instead, the sync group is identified by the first mechanism in the group.
The function RocksMechStartSyncGroup starts the execution of a certain action simultaneously for all mechanisms in the sync group. The function has 2 arguments. The first argument is a pointer to the structure ROCKS_MECH, which must be the first mechanism in the sync group. The second argument specifies the synchronization action, which can be MAC_SYNC_MOTION,
MAC_SYNC_FEED_OVERRIDE, MAC_SYNC_SMOOTH_STOP,
MAC_SYNC_QUICK_STOP, or MAC_SYNC_FULL_STOP.
The function RocksMechDeleteSyncGroup deletes the defined sync group. The function has one argument, a pointer to the structure ROCKS_MECH, which must be the first mechanism in the sync group.
6.6 Miscellaneous
● RocksGetVersion
The function RocksGetVersion returns the version of the NYCeRocks runtime system. The function has no input arguments, only one return argument, a pointer of type NYCE_VERSION_TYPE.
Support functions
7 List of NYCeRocks error codes
This chapter gives an alphabetically sorted list of all NYCeRocks error codes.
Error code Description
ROCKS_ERR_ALLOC_FAILURE Unable to allocate sufficient memory for the spline buffers (pPositionSplineBuffer and pVelocitySplineBuffer).
⇒ Increase splineTime or / and maxVelocity and try again.
ROCKS_ERR_ALREADY_IN_GROUP Mechanism is already previously added to a group by the function RocksMechDefineSyncGroup.
⇒ Mechanism cannot belong to two sync groups at the same time.
ROCKS_ERR_ANGLE_TOO_LARGE Cubic angle specified in the function RocksTrajCubicCircle is larger than π radians.
⇒ Reduce angle or execute for example the function RocksTrajSineAccCircle.
ROCKS_ERR_AXIS_ERROR Underlying invoked SAC function failed. Fatal error, should not occur.
ROCKS_ERR_COMMUNICATION_ERROR Failure to execute specified NYCeRocks function in NYCeRocks when running as a sequence server.
⇒ Restart NYCeRocks server sequence and try again.
ROCKS_ERR_ILLEGAL_TRAJECTORY Specified trajectory type (trajType) in calling function (RocksTrajGetPath, RocksTrajLoadPath or RocksTrajDeletePath) does not belong to the ROCKS_TRAJ_TYPE enumeration.
⇒ Check and correct specified trajectory type.
ROCKS_ERR_INVALID_LATCH Invalid latch number (latchNr) specified in calling function (RocksMechDefineProbe, RocksMechDeleteProbe, RocksMechActivateProbe, RocksMechGetProbeStatus or RocksMechGetProbePosition).
⇒ Correct latch number. Vaild latch number range is 0 ... 3.
ROCKS_ERR_INVALID_OUTPUT Invalid output or output action is specified with the function RocksTrajSetOutput, RocksTrajClearOutput, or RocksTrajToggleOutput.
⇒ Check and correct the output parameter.
ROCKS_ERR_INVALID_PARAMETER Invalid parameter specified in called function.
⇒ Check and correct input parameter(s) and try again.
ROCKS_ERR_MAX_ACCELERATION_EXCEEDED Acceleration path constraint (maxAcceleration) exceeded while executing the function RocksTrajSegmentLine.
⇒ Modify constraints and try again.
ROCKS_ERR_NOT_IMPLEMENTED Called functionality is not available, because it will be implemented in a future release of NYCeRocks.
Examples are the functions RocksMechDefineSyncGroup, RocksMechStartSyncGroup, RocksMechDeleteSyncGroup when NYCeRocks runs as server sequence on the node, and RocksTrajGetPath when NYCeRocks runs as a sequence on the node.
List of NYCeRocks error codes
Error code Description
ROCKS_ERR_NO_AXIS Unable to create a mechanism (RocksMechCreate) with 0 joints (nrOfJoints).
⇒ A mechanism must at least contain one joint.
ROCKS_ERR_NO_GROUP Unable to create a mechanism sync group
(RocksMechDefineSyncGroup) with only one or less mechanisms.
⇒ A mechanism sync group must at least contain two mechanisms.
ROCKS_ERR_NO_PATH No path is generated. End and start position of the trajectory are the same.
⇒ Call trajectory generation module function and try again.
ROCKS_ERR_NO_VALID_INV_KINEMATICS Error returned by the function RocksStream when no proper kinematics is previously generated.
⇒ Call an inverse kinematics module function (RocksKinInverseCartesian or RocksKinInverseGantry) and try again.
ROCKS_ERR_NO_VALID_PATH Error returned by the functions RocksKinInverseGantry and RocksKinInverseCartesian when no proper trajectory path is previously generated.
⇒ Call trajectory generation module function and try again.
ROCKS_ERR_PROBE_ERROR Underlying invoked SAC function called from RocksMechDefineProbe, RocksMechDeleteProbe, RocksMechActivateProbe, RocksMechGetProbeStatus or RocksMechGetProbePosition failed.
⇒ Check for example I/O latch definition in the node and try again.
ROCKS_ERR_START_ERROR Error returned by the function RocksStream when the current world coordinates setpoint position does not match the start position of the trajectory path.
⇒ Recalculate trajectory path and try again.
ROCKS_ERR_STATE_ERROR Error returned by the function RocksStream when not all joints of the mechanisms are homed and in the SAC_READY state.
⇒ Home and lock all joints and try again.
ROCKS_ERR_TOO_MANY_MECHANISMS When NYCeRocks runs as a server sequence on the node, a maximum of 8 (ROCKS_SRV_MAX_NR_OF_MECHANISMS_PER_NODE) mechanisms can be created.
⇒ Reduce the number of mechanisms.
ROCKS_ERR_TOO_MANY_OUTPUT_CHANGES Too many output changes are defined with the functions RocksTrajSetOutput, RocksTrajClearOutput, and RocksTrajToggleOutput.
⇒ Decrease the number of output actions.
ROCKS_ERR_TOO_MANY_SPLINES User supplied buffers (pPositionSplineBuffer and pVelocitySplineBuffer) are too small or reallocation failed.
⇒ Increase the size of the user supplied buffers or increase the splineTime or / and maxVelocity and try again.
List of NYCeRocks error codes
Error code Description
ROCKS_ERR_UNKNOWN_ENUM_STRING The argument passed to the conversion function is not valid.
ROCKS_ERR_WRONG_VERSION The version numbers of the NYCe 4000 DLLs are not consistent.
Tab. 7-1: NYCeRocks error codes
List of NYCeRocks error codes
Notes
97803 Lohr, Germany Bgm.-Dr.-Nebel-Str. 2 97816 Lohr, Germany Phone +49 9352 18 0 Fax +49 9352 18 8400
www.boschrexroth.com/electrics
*R911345561*
R911345561DOK-NY4000-NYROCKS*V46-RE05-EN-E
