|English term or phrase: robtarget|
|Motion step execution|
In motion step mode you step between motion instructions. Other types of instruction in between are automatically executed in the step.
The execution stops just before a motion instruction is executed. If Motion step is commanded at this stage the motion instruction is executed and the execution stops directly after the motion instruction. This stop is made to enable ModPos operations.
If executing NOSTEPIN procedures with named ***robtargets*** as parameters the motion step stops when these parameters are used within motion instructions in the NOSTEPIN routine. It is therefore also possible to do ModPos on these robtargets even if the code is hidden.
To execute a service routine without losing the call hierarchy
A pre-configured service routine without parameters can be executed without losing the call hierarchy and program settings, e.g. program displacement, mechanical unit activation etc.
• Choose Special: Call Service Routine
A dialog box appears, displaying all possible service routines.
• Select the desired service routine and press OK.
When the program pointer reaches the end of a called service routine, you are asked whether to run the service routine again or to return to the original program pointer where the "Call Service Routine" was performed.
To go to a position without moving the program pointer
Place the cursor on the position argument in the instruction. You can also select a position (***robtarget***) in the Program Data window.
• Choose Special: Go to selected position.
Press the function key Start to start the movement.
8.3 Tuning position during program execution
The tuning command makes it possible to tune the x, y and z coordinates of a ***robtarget*** during program execution. The function is valid only for named ***robtargets*** of the datatypes constant and persistent. It is not valid for positions represented by '*' and ***robtargets*** of the datatype variable. The change is also valid in stopped mode.
• Start with the Program Test window.
• Press Start.
The window Program Run Info appears
• Select the field ***Robtarget*** and press Enter [ to confirm the choice.
The x, y and z values of the chosen position are displayed
9.2 Mirroring routine
The mirror function can be applied to any routine in a program.
Mirroring a routine means that a copy of the routine is created with all positions mirrored in a specific mirror plane.
The new, mirrored routine will be given a new name (a default name is proposed). All stored data of type ***robtarget***, used in the routine, will be mirrored and stored with a new name (the old name ending with _m). All immediate ***robtarget*** data, shown with an "*", in movement instructions will also be mirrored.
What does mirrored mean?
In general, all data of the type ***robtarget***, used in the routine, will be mirrored. It makes no difference whether the ***robtarget*** data is declared as a constant (which it should be), as a persistent or as an ordinary variable. Any other data, e.g. of type pos, pose, orient, etc., will not be mirrored. Mirroring data only affects the initialization value, i.e. any current value will be ignored. This means that if a ***robtarget*** variable has been defined without an init value, this variable will not be mirrored.
The mirroring works as follows:
• The new routine is scanned for any local ***robtarget*** data, declared inside the routine
with an init value. All such data's init values are mirrored.
• Then the new routine is scanned for any statement with one or more arguments of type
• When such a statement is found, the following actions will take place:
- If the argument is programmed with a reference to a local variable or a constant,
this argument will be ignored, since it has already been mirrored as described
- If the argument is programmed with an immediate ***robtarget*** data, shown with
an asterisk "*", then this value will be mirrored directly.
- If the argument is programmed with a reference to a global variable, persistent
or a constant, defined outside the routine with an init value, then a duplicate is
created and stored in the module with a new name (the old name ending with
_m). The init value of this new data is mirrored, and after that the argument in
the statement is changed to the new name. This means that the module data list
will expand with a number of new mirrored ***robtarget*** data.
Error handlers or backward handlers, if any, in the routine, are not mirrored.
***robtarget*** data are expressed relative to this work object frame (see the figure above). Furthermore, the mirrored position will be related to the same work object frame.
In the dialogue, before mirroring, this specific work object must be stated. This work object will be used as the reference frame for all variables that are to be mirrored.
Be sure to state the same work object as was originally used when defining the ***robtarget*** data, and which was used as a parameter in the movement instructions. If no work object was used, the wobjO should be stated.
Mirroring of orientation
The orientation of the ***robtarget*** position is also mirrored. This mirroring of the orientation can be done in two different ways, where either the x and z axes are mirrored or the y and z axes (see Figure 39). The method used, x or y axis (the z axis is always mirrored), is dependent on the tool used and how the tool coordinate system is defined. In the mirror dialogue, the method must be stated
Field: Work object
Description: The work object to be used when applying the mirror function on ***robtarget*** variables. If the Enter |-«-»| key is pressed, the work object selection dialogue will be displayed
Data is used to store values that can be used at a later, stage in the program. Data is grouped into different data types that describe its contents and its field of application.
Data type----------------Used for:
num----------------Numeric values (registers, counters)
bool----------------Logical values (true or false)
tooldata----------------Tool data (see Chapter 8 Coordinate Systems)
wobjdata----------------Work objects (see Chapter 8 Coordinate Systems)
pose----------------Program displacement frames (see Chapter 8 Coordinate Systems
14.3 Defining programming rule for robot positions
It is possible to select whether or not to automatically create new ***robtargets*** when programming move instructions.
A utomatic name sequence
When a Move instruction is programmed, a new ***robtarget*** is automatically created. If the last used ToPoint was named, i.e not a "*", a new ***robtarget*** will be created and named according to a sequential naming rule. For example plO, p20, p30 or p 12, pi3, pl4 etc.
Dialog with next ***robtarget*** selected
This rule is used when ***robtargets*** are created in advance. When a Move instruction is programmed no ***robtarget*** is created. Instead the instruction argument dialog is opened with the next sequential ***robtarget*** selected. For example, if the last used ***robtarget*** was pi 00, the instruction argument dialog will be opened with pi 10 selected.
Dialog with * selected
Same as "Dialog with next ***robtarget*** selected" except that the instruction argument dialog is opened with the "*" selected.
• Choose File: Preferences.
• Select ***Robtarget*** programming rule
• Select a programming rule and press OK
This word is used not only as a proper name. Offen it is used without 'data' , 'value' etc. Could you please explain what does it mean?