Integrated Simulation and Verification Help

Unigraphics

Integrated Simulation and Verification Help

Version 19.0


Proprietary and Restricted Rights Notices

Proprietary & Restricted Rights Notices

Proprietary rights of Unigraphics Solutions Inc., its subcontractors, or its suppliers are included in this software, in the data, documentation, or firmware related thereto, and in information disclosed therein. Neither this software, regardless of the form in which it exists, nor such data, information, or firmware may be used by or disclosed to others for any purpose except as specifically authorized in writing by Unigraphics Solutions Inc. Recipient by accepting this document or utilizing this software agrees that neither this document nor the information disclosed herein nor any part thereof shall be reproduced or transferred to other documents or used or disclosed to others for manufacturing or for any other purpose except as specifically authorized in writing by Unigraphics Solutions Inc.

©2001 Unigraphics Solutions Inc. All rights reserved.

Restricted Rights Legend: This commercial computer software and related documentation are provided with restricted rights. Use, duplication or disclosure by the U.S. Government is subject to the protections and restrictions as set forth in the Unigraphics Solutions Inc. commercial license for the software and/or documentation as prescribed in DOD FAR 227-7202-3(a), or for Civilian agencies, in FAR 27.404(b)(2)(i), and any successor or similar regulation, as applicable. Unigraphics Solutions Inc., 10824 Hope Street, Cypress, CA 90630.

The information contained in this document is subject to change without notice and should not be construed as a commitment by Unigraphics Solutions Inc. Unigraphics Solutions Inc. assumes no responsibility for any errors or omissions that may appear in this document.

The following are trademarks of Unigraphics Solutions Inc.: Unigraphics Solutions®, Unigraphics®, GRIP®, PARASOLID®, UG®, UGI...®, UG Solutions®, iMAN®.

Information contained in this document is considered proprietary to Unigraphics Solutions Inc. and may be subject to a number of pending patent applications.

Windows NT is a trademark of Microsoft Corporation.

UNIX versions of Unigraphics use parts of the Microline Widget library. Microline is a trademark of Neuron Data Inc.

All other company and product names referenced herein are trademarks or registered trademarks of their respective owners.


Welcome to IS&V

Welcome to Integrated Simulation and Verification (IS&V)

In the past decade, machining processes and the machines used to perform these processes have become increasingly complicated. The tools and equipment used in these processes are extremely expensive and consequently, any downtime can result in substantial losses for a company. With these changes, a need has arisen for a more "close to reality" simulation and verification of the cutting process. In addition to the integrated dynamic material removal animation, gouge checking and in-process part modeling now available in UG/CAM, the new Integrated Simulation and Verification Module (IS&V) provides a fully customizable module allowing you to simulate the entire machine tool in use, thus having a more accurate overview of the entire machining process.

Up to now the machine tool has not generally been taken into account during the two major processes in a CAM session: the tool path generation process and the simulation and verification process. Only when the NC program had been created (G-code) did the machine tool come into play. IS&V entails a major conceptual change - closed loop technology. With this new technology, IS&V feeds the two main CAM processes with machine tool-specific data.

The new Machine Tool Driver (MTD) extends the functionality of the traditional UG/POST. The MTD does not just generate an NC program command file but acts as a driver participating in all aspects of the machining process that are impacted by the machine tool. All the machine tool-specific behavior and characteristics are handled by the MTD. The MTD calls Simulation and Verification Commands which are understood by the S&V Engine. This engine then collects, processes and feeds the resulting information to the graphical display or to the NC Controller panel.

When simulating the machine tool, the system will animate the exact machine tool motions and reproduce the complete machining environment. This will make the machine tool easier to program and safer to use.

The following subjects are covered in the IS&V online help:

  • Benefits of IS&V

  • IS&V Architecture

  • Setting up IS&V

  • Creating a Kinematics Model

  • Running the Simulation


Benefits of IS&V

Here is a brief summary of the benefits of machine tool simulation and verification and IS&V in particular:

  • The behavior of the actual machine tool and its controller are taken into account in the tool path generation and during simulation. This catches any problem related to the machine tool at the time the tool path is created. In the future, some of this ability can migrate to the design stage as part of a design for manufacturability (i.e., validation for the designer that the designed part can be manufactured with existing machine tools).

  • The architecture allows the controller manufacturer to plug in its software controller.

  • Configurable collision checking allows collision detection between arbitrary machine components, fixtures, tool, part, and in-process workpiece.

  • All machining operations including macros, subroutine calls, cycles, and controller M, G and H commands are previewed.

  • Machining quality is improved.

  • Design part can be compared with manufactured part.

  • Costs are reduced.

  • Expensive and time-consuming proofing and dry runs are eliminated.

  • Down-time is reduced because programming actions on the machine are avoided.

  • Risk of expensive damage to machine, fixtures tools and workpiece is reduced.

  • Machine tool utilization is increased because it is possible to perform operations that were previously avoided because of lack of validation and visualization tools.

  • The system can be used as a training system for new operators and programmers.


Architecture

IS&V Architecture


Setting up IS&V

Before you can use the machine tool model during the CAM session, the following preparation needs to be done:

1. Define the machine tool assembly - Using the UG/Assembly functionality, the machine tool geometry model as an assembly part file is defined. We recommend conforming with the master model concept meaning that the overall assembly partfile should only reference component parts or subassemblies and should not contain geometry elements directly. Especially machine components that shall become kinematics components have to be individual component parts. Please see further documentation on Assemblies in the Unigraphics Online Help.

2. Define a kinematics model – A kinematics model is created within the overall assembly created in step 1. This is done by means of the MTB application. The part then becomes the machine tool model = assembly + kinematics model.

3. Store in library - New entries for the machine tools have to be added to the appropriate machine library ( ASCII, Genius, IMAN depending on which you use). The part file of the machine tool needs to be placed in the file management of the library.

4. Define cutting tools - Define cutting tool assemblies to be used by the machine. They have to contain the mounting information as described in the chapter above. This step 4 is not mandatory. If the system doesn’t find cutting tool assemblies it creates tools based on the tool parameters (diameter, length).

5. Define machine tool driver - To simulate the real NC controller behavior of that machine, define the virtual NC controller (VNC) to control the actual simulation on the screen. This VNC is embedded in the MOM post event handler, which generates the NC program. VNC + Post define the machine tool driver for that machine.

Relationship between Machine Tool View and Machine Model

UG/CAM contains a turret/tool pocket definition in the definition file of the MOM Post. This is presented in the Machine Tool View of the Operation Navigator and allows you to assign the tools to the pockets on the machine. IS&V contains a machine model partfile. For consistency and ease-of-use reasons, it is now possible to specify these kinds of data when creating the machine model partfile. The natural place to edit these data is the K-Component Classification dialog in the Machine Tool Builder application.

If you retrieve a machine from a library which has a machine model partfile then the initial information for the Machine Tool View is taken from that partfile and no longer from the post definition file. If no partfile exists or if it doesn’t contain any turret/pocket definitions then the old functionality is maintained.

A kinematics component which also contains the mounting junction for the tool can exist for every tool pocket. If tools are retrieved from the library they are already listed in the Machine Tool View with a suitable pocket assigned. In addition, the tools will now also be automatically mounted to the machine model as assembly components. Furthermore if the user moves a tool in the machine tool view from one pocket to another then the assembly model will automatically be updated.


Define Cutting Tools

Mounting Information for the Tool

Cutting tools are assembly partfiles defining the tool geometry. The tool has to be mounted automatically to the spindle or turret of the machine. For this purpose you can create a small kinematics model in the tool assembly partfile. This is just one kinematics component which contains only a mounting junction. When the tool is mounted, the corresponding junction coordinate systems in the tool and spindle or turret will be matched.

If no mounting junction is specified in the tool, then the system looks for the adapter axis and normal axis in the tool assembly partfile. The adapter axis defines the X direction, the normal axis defines the Z direction of the mounting CSYS. The third axis is determined by the right hand rule (cross product). The origin is at absolute (0,0,0) of the tool part.

If neither a mounting junction nor an adapter axis nor a normal axis is specified, then the absolute CSYS of the tool assembly partfile is taken as the mounting junction. All sample tools are designed in this fashion.


The Machine Tool Driver

The Machine Tool Driver (MTD) comprises the traditional MOM Post plus a new Virtual NC Controller (VNC). The VNC calls S&V commands to emulate the machine tool in the graphics window and provides information to the NC control panel. Whereas the postprocessor is responsible only for generating an NC program command file, the MTD participates in all aspects of the machining process that are influenced by the machine tool in use. All machine tool-specific characteristics and behavior are represented by the Machine Tool Driver. Briefly, the MTD's purpose is to:

  • feed back the exact tool motion and the exact tool-part relationship during tool path generation. All NC controllers, at least the new ones, will reach the requested target position and orientation but, depending on the machine tool configuration (e.g., five axes with universal head or two rotary tables) and NC controller, the actual transition path from one position to another may differ. The actual path is very important when checking for collisions and part gouging.

  • play a key role in simulating the cutting process and the machine tool. As machines become more and more complicated, simulating their behaviour becomes a vital tool in using them to their full potential.

  • generate graphical and possibly audio feedback to post events that previously had no feedback. For example, machine cycles, subroutine calls and macros can have graphics such as tool path segments, icons or some audio messaging shown on the screen. In this context, any tool motion can be considered in collision detection, simulation of material removal, gouge checking and in-process part (IPW) updates.

The MTD returns machine tool information to the system through the use of simulation and verification (S&V) commands. These commands are incorporated into the MTD and can be executed in one of the following three modes:

  • the SIM_Event Mode

The SIM_Event Mode causes the post to reference (source) a separate TCL file containing the VNC. With this method, you can include S&V commands in the post with only minimal influence on the functioning post. This is the quickest way to create a simulation driver with an existing post. There are, however, several disadvantages with this system:

  • this mode requires keeping track of and reproducing logic similar to that which exists in the post when issuing the S&V commands

  • the duplication of number of events which could have a performance impact

This mode is seen more as a training and demonstration mode.

  • the Direct Mode

Unlike the SIM Event mode, in this mode the S&V commands are part of the post event handler. In each place in the post where NC code is output, equivalent S&V commands are issued to mirror the performance of the machine tool in the virtual machine tool.

  • the Plugin Mode

The Plugin mode uses only three functions:

  • SIM_PLUGIN_initialize

  • SIM_PLUGIN_exit

  • SIM_PLUGIN_execute_nc_command

These functions act as interface to the external library provided by the controller manufacturer. This external library translates G-code into elementary motion commands. These are used as input for the user functions which each have an equivalent S&V command.

  • MTD architecture


MTD Architecture


S&V Commands

The machine tool driver calls S&V commands in order to communicate the simulation instructions to the simulation engine. There are two kinds of S&V commands:

  • basic S&V commands - commands implemented in C.

  • high level S&V commands - these commands, implemented in TCL, use the basic S&V commands to create new commands that are often used by the MTD writer. These commands, for example, are responsible for linear approximation, interpolation, mapping of machine axis and devices. High level S&V commands are intended to simplify the task of writing a new driver.

S&V commands are mapped to fundamental actions that update the machine tool model and generate graphical, audio and any other feedback. There are six categories of basic commands.

  • Motion commands move slides or machine devices to specified locations.

  • Mounting commands mount or un-mount changeable devices and cutting tools.

  • Feedback commands issue graphical, messages, audio or any other feedback to be passed to the user or to the CAM processor.

  • Control commands coordinate and manage commands.

  • Query commands allow the MTD writer to get information from the machine tool model.

  • Miscellaneous commands perform anything else that doesn’t fall into the above categories.


Basic S&V Commands

The following is the list of basic S&V commands. For a more complete description, follow the hyperlink.

SIM_activate_tool | set specified tool as the current active tool
SIM_ask_axis_dof_junction | return name of the NC axis junction
SIM_ask_axis_limits | return limits of specified axis
SIM_ask_axis_position | return the axis current position in axis coordinate system
SIM_ask_cording_tol | get the cording tolerance for analytical curves (i.e., arc, spline)
SIM_ask_init_junction_xform | get the initial junction transformation with respect to the absolute coordinate system
SIM_ask_is_junction_dependent | determine whether the specified junction moves when the specified axis moves
SIM_ask_is_junction_exist | check if a junction exists
SIM_ask_junction_xform | get the junction transformation in current machine state with respect to the absolute coordinate system
SIM_ask_kim_comp_name_by_id | get component name by its class and id
SIM_ask_mtcs_junction | return name of the MTCS junction
SIM_ask_mtd_units | return the current MTD units
SIM_ask_tool_offsets | get the specified tool offsets
SIM_create_junction | create a new junction
SIM_dbg_set_output | control what data is output to the listing device
SIM_dbg_end | end S&V commands debugging
SIM_dbg_start | initialize S&V commands debugging tool
SIM_dbg_write_message | write a message to the listing device
SIM_delay | freeze simulation for specified duration (in seconds)
SIM_delete_junction | delete an existing junction
SIM_end_of_simulation | create and send end of simulation event
SIM_feedback_message | send message to the message window
SIM_mount_kim_comp | mount specified component
SIM_mount_tool | mount specified tool. The ID_CLASSes LIBRARY_REF, CATALOG_NUMBER and COMP_NAME are not yet supported.
SIM_move_linear_axis | move one linear axis in axis coordinate system
SIM_move_rotary_axis | move one rotary axis in axis coordinate system
SIM_msg_user_feedback | add feedback event that calls a user TCL procedure when event is processed
SIM_mtd_init | initialize machine tool driver
SIM_mtd_reset | exit machine tool driver
SIM_set_channel | set the current channel
SIM_set_coolant | turn on/off the coolant
SIM_set_current_zcs_junction | set the current ZCS junction
SIM_set_cutting_mode | set the current cutting mode
SIM_set_feed | set the current feed rate
SIM_set_mtd_units | set the input units of the S&V commands
SIM_set_parameter | set engine parameter
SIM_set_speed | set the current speed
SIM_start_of_simulation | create and send start of simulation event
SIM_step | create a sub-step event to perform intermediate update of the machine state
SIM_transform_matrix_acs_to_mtcs | transform specified matrix in absolute to mtcs coordinate system
SIM_transform_offset_acs_to_mtcs | transform specified offset in absolute to mtcs coordinate system
SIM_unmount_kim_comp | unmount specified component
SIM_unmount_tool | unmount tool
SIM_update | create a step event to update the state of the machine with all prior events


Basic S&V Commands - Description

Motion Commands

SIM_move_linear_axis

Syntax | SIM_move_linear_axis <duration> <axis> <value>
Description | Move the specified linear axis with specified value along its degree of freedom.
Parameters | duration: the time in seconds it takes to execute this command by the machine. axis: name of actual linear NC axis value: axis position in axis coordinate system
Output | none
Example | SIM_move_linear_axis 10.5 X 25.4

SIM_move_rotary_axis

Syntax | SIM_move_rotary_axis <duration> <axis> <value>
Description | Move the specified rotary axis with specified value around its degree of freedom. The motion to the target position will be done along the shortest distance.
Parameters | duration: the time in seconds it takes to execute this command by the machine. axis: name of the actual rotary NC axis value: axis position in degrees
Output | none
Example | SIM_move_rotary_axis 36.23 A 35

Mounting Commands

SIM_mount_kim_comp

Syntax | SIM_mount_kim_comp <duration> <comp1> <jct1> <comp2> <jct2>
Description | Mount the specified component on the target component. The two specified junctions determine the orientation of the mounted component. The transformation that it takes to make jct1 coincide with jct2 is the transformation applied to comp1. Comp1 and comp2 must be valid K-components. If comp1 is already mounted on another component, it will first be unmounted from that component. If comp2 is not specified, comp1 is mounted on the unmounted node of current KIM.
Parameters | duration: the duration in seconds that it takes to mount comp1 on comp2. comp1: the source K-component jct1: the source junction comp2: the target K-component jct2: the target junction
Output | none
Example | SIM_mount kim_comp 25 DEVICE_1 MNT1_JCT MACHINE_BASE1 BASE1_JCT

SIM_unmount_kim_comp

Syntax | SIM_unmount_kim_comp <duration> <comp>
Description | Unmount the specified K-component from the current KIM model. The unmounted component is added to the unmounted component's root node.
Parameters | duration: the duration in seconds that it takes to unmount component comp: the component name
Output | none
Example | SIM_unmount_kim_comp 15 DEVICE_1

SIM_mount_tool

Syntax | SIM_mount_tool <duration> <tool_id_class> <tool_id> <comp> <jct>
Description | Mount the specified tool on a target component. The system looks for the tool assembly model in the resource tool library. Then a mounting junction and tool tip junction are created at their standard locations (see Genius for details). The tool is mounted on the comp such that the tool-mounting junction coincides with component junction jct. If a tool assembly is not found, a solid assembly of the tool is created on the fly. The tool can be identified in the following five ways according to the tool_id_class: TOOL_NUMBER LIBRARY_REF CATALOG_NUMBER UG_NAME COMP_NAME The tool_id is specified according to the specified tool_id_class.
Parameters | duration: the duration in seconds that it takes to mount a tool on the machine tool_id_class: the class by which the tool id is specified. See list of classes in description tool_id: the tool id according to the tool_id_class comp: the target K-component name jct: the target junction
Output | The K-component name that represents the tool that has been created is returned in the global TCL variable mom_sim_result.
Example | SIM_mount_tool 15 LIBRARY_REF UGT0201005 SPINDLE SPINDLE_JCT

SIM_unmount_tool

Syntax | SIM_unmount_tool <duration> <tool_name>
Description | Unmount the specified tool name from the current KIM model. Note that tool name is the name of the K-component returned when the tool was mounted.
Parameters | duration: the duration in seconds that it takes to unmount a tool on the machine tool_name: the K-component that represents the tool
Output | none
Example | SIM_unmount_tool 15 SIM_UGT0201005

Feedback Commands

SIM_dbg_start

Syntax | SIM_dbg_start <title>
Description | This command initializes the S&V command debugging tool. When the command is executed, a new UG listing file is opened and all debugging information is written to that file. This command is normally called in the machine tool driver initialization handler, MOM_SIM_initialize_mtd.
Parameters | title: optional comment written to the listing file
Output | none
Example | SIM_dbg_start "============== Start Debugging for Driver M5ABHH ========"

SIM_dbg_end

Syntax | SIM_dbg_end
Description | This command ends S&V debugging. It is normally called in the machine tool driver initialization handler, MOM_SIM_exit_mtd.
Parameters | none
Output | none

SIM_dbg_write_message

Syntax | SIM_dbg_write_message <message>
Description | When this command is issued, the message is written to the output listing device.
Parameters | message: a text message
Output | none
Example | SIM_dbg_write_message "this is a test message for driver $driver_name"

SIM_dbg_set_output

Syntax

SIM_dbg_write_message <status><keys>

Description

This command controls what data is output to the listing device. Any combination of the following keys is possible. By default only SIM_DBG_OUTPUT_ERROR is set.

SIM_DBG_OUTPUT_ERROR - output warning and errors

SIM_DBG_OUTPUT_NC_CMD - output the NC line when processed

SIM_DBG_OUTPUT_CEVENT - output the MOM events when triggered

SIM_DBG_OUTPUT_INPUT_SV_EVENT - output the SIM event that is inserted to the input buffer. SIM events are inserted to the input buffer by the S&V commands.

SIM_DBG_OUTPUT_OUTPUT_SV_EVENT - output the SIM event that is inserted to the output buffer. This is the SIM event from the input buffer after it has been preprocessed. For example, the input SIM event can go through linearization and therefore new output SIM events are created.

SIM_DBG_OUTPUT_PROCESSED_SV_EVENT - output the events processed by the S&V engine processors. Note that the processors could also create events of their own.

SIM_DBG_OUTPUT_SV_CMD - output the S&V command that was called

SIM_DBG_OUTPUT_ALL - output all the above

Parameters

status: ON or OFF to turn on or off the specified keys

Output

none

Example

# dump the MOM events followed by the SIM events inserted to input buffer.

SIM_dbg_set_output ON SIM_DBG_OUTPUT_INPUT_SV_EVENT SIM_DBG_OUTPUT_CEVENT

SIM_feedback_message

Syntax | SIM_feedback_message <label> <message>
Description | Send a message to the info window. The system also uses this command to communicate messages to dedicated processors. In this case the label is used as a reserved keyword. The label cannot start with the $ sign unless its used as a reserved keyword.
Parameters | label: a label name or a reserved keyword (when prefixed by $ sign) message: the message
Output | none
Example | SIM_feedback_message "DEBUG:" "Running test 1"

SIM_msg_user_feedback

Syntax | SIM_msg_user_feedback <proc>
Description | This function sends a message to the feedback processor to call the specified TCL procedure when the event is processed. All events created during the processing of the TCL procedure will be appended to the current NC channel.
Parameters | proc: name of TCL procedure that exists in current TCL interpreter context.
Output | none
Example | SIM_msg_user_feedback my_tcl_proc

Control Commands

SIM_update

Syntax | SIM_update <label>
Description | Create a step event which indicates end of action (e.g., end of linear move or end of circular move). All (non-control) events prior to this event are executed simultaneously.
Parameters | label: an optional label to identify that step. Mainly used for debugging.
Output | none
Example | SIM_update end_of_circle1

SIM_step

Syntax | SIM_step <label>
Description | Create a substep event which indicates the end of an intermediate action. For example, approximation segments of a circular motion are defined as such. Also, any intermediate interpolation segments of linear motion ends with substep event. All (non-control) events prior to this event are executed simultaneously.
Parameters | label: an optional label to identify that substep. Mainly used for debugging.
Output | none
Example | SIM_step LINE_INTER

Query Commands

SIM_ask_axis_limits

Syntax | SIM_ask_axis_limits <axis name>
Description | Returns the limits of the specified NC axis.
Parameters | axis_name: the physical name of the NC axis
Output | mom_sim_result has the maximum value and mom_sim_result1 has the minimum value.
Example | # get physical axis name set x_ph [ SIM_map_logical_to_phisical_axis X ] # limits SIM_ask_axis_limits $x_ph set x_max $mom_sim_result set x_min $mom_sim_result1

SIM_ask_axis_position

Syntax | SIM_ask_axis_position <axis>
Description | Returns the current axis position. Axis can be linear or rotational. The current position is the position of the axis after all input events prior to this event have been processed. Coordinates are returned in axis coordinates.
Parameters | axis: name of actual axis
Output | The TCL variable mom_sim_result is set with the current axis position. For a rotary axis, output is returned in radians.
Example | SIM_ask_axis_position X set x_position $mom_sim_result

SIM_ask_is_junction_dependent

Syntax | SIM_ask_is_junction_dependent <jct_name> <nc_axis_name>
Description | Determines whether the specified junction moves when the specified NC axis moves.
Parameters | jct_name: the name of the junction. Since junction name is unique within a kinematics component, the junction name could also be prefixed with the kinematics name and the character @ and then followed by the junction name. For example: spindle@tool_mount_jct identifies the tool_mount_jct junction defined in the spindle kinematics component. nc_axis_name: the physical NC axis name
Output | The TCL variable mom_sim_result is set to 1 if NC axis is dependent or 0 if not.
Example | SIM_ask_is_junction_dependent spindle@tool_mount_jct X If {$mom_sim_result != 1} { .... #When the axis X moves the spindle doesn't move }

SIM_ask_is_junction_exist

Syntax | SIM_ask_is_junction_exist <jct_name>
Description | Returns whether the specified junction exists or not.
Parameters | jct_name: the name of the junction. Since junction name is unique within a kinematics component, the junction name could also be prefixed with the kinematics name and the character @ and then followed by the junction name. For example: spindle@tool_mount_jct identifies the tool_mount_jct junction defined in the spindle kinematics component.
Output | The TCL variable mom_sim_result is set to 1 if junction exists or 0 if not.
Example | SIM_ask_is_junction_exist WORK_ZCS If {$mom_sim_result == 0} { # issue an error… }

SIM_ask_junction_xform

Syntax

SIM_ask_junction_xform <jct_name>

Description

Returns the transformation of the specified junction. The first three arguments returned are the offset and the remainder is the transformation. This transformation transforms from the ACS coordinate system to the junction coordinate system. This is consistent with the MSYS.

The transformation returned is of the current state of the junction after all events in the input buffer have been processed.

Parameters

jct_name: the name of the junction. Since junction name is unique within a kinematics component, the junction name could also be prefixed with the kinematics name and the character @ and then followed by the junction name. For example: spindle@tool_mount_jct identifies the tool_mount_jct junction defined in the spindle kinematics component.

Output

The rotation transformation (M00 M01 M02 ...) is returned in the mom_sim_result TCL variable. The translation vector(V0 V1 V2) is returned in the mom_sim_result1 variable.

Example

In the following example the position defined with respect to the wrk_jct junction is transformed to the ACS coordinate system:

SIM_ask_junction_xform $wrk_jct #get transformation

set xfm_to_acs [MatInvertL $mom_sim_result] #invert matrix to get transformation from junction to ACS

set acs_position [MatMultVectorL $xfm_to_acs $position] #transform vector

set acs_position [VAddL $acs_position $mom_sim_result1] #translate vector

SIM_ask_init_junction_xform

Syntax

SIM_ask_init_junction_xform <jct_name>

Description

Returns the transformation of the specified junction. The first three arguments returned are the offset and the remainder is the transformation. This transformation transforms from the ACS coordinate system to the junction coordinate system. This is consistent with the MSYS.

The transformation returned is of the initial state of the junction before simulation is started.

Parameters

jct_name: the name of the junction. Since junction name is unique within a kinematics component, the junction name could also be prefixed with the kinematics name and the character @ and then followed by the junction name. For example: spindle@tool_mount_jct identifies the tool_mount_jct junction defined in the spindle kinematics component.

Output

The rotation transformation (M00 M01 M02 ...) is returned in the mom_sim_result TCL variable. The translation vector(V0 V1 V2) is returned in the mom_sim_result1 variable.

Example

In the following example the position defined with respect to the wrk_jct junction is transformed to ACS coordinate system:

SIM_ask_junction_xform $wrk_jct #get transformation

set xfm_to_acs [MatInvertL $mom_sim_result] #invert matrix to get transformation from junction to ACS

set acs_position [MatMultVectorL $xfm_to_acs $position] #transform vector

set acs_position [VAddL $acs_position $mom_sim_result1] #translate vector

SIM_ask_kim_comp_name_by_id

Syntax | SIM_ask_kim_comp_name_by_id <class> <id>
Description | Returns the KIM component name that belongs to the specified class with the specified id. Currently only the TOOL class is allowed.
Parameters | class: class name
Output | The name of component is returned in the mom_sim_result variable.
Example | SIM_ask_kim_comp_name_by_id "TOOL" $tool_ug_name set t_name $mom_sim_result SIM_unmount_tool "2.0" $t_name

SIM_ask_mtcs_junction

Syntax | SIM_ask_mtcs_junction
Description | Returns the name of the junction of the machine tool coordinate system (MTCS).
Parameters | none
Output | The name of the MTCS junction is returned in the mom_sim_result variable.
Example | SIM_ask_mtcs_junction set wrk_jct $mom_sim_result

SIM_ask_axis_dof_junction

Syntax | SIM_ask_axis_dof_junction <axis>
Description | Returns the name of the junction that the NC axis is referencing for the definition of the axis degree of freedom (DOF).
Parameters | axis: name of the actual axis
Output | The junction name is returned in the mom_sim_result variable. The axis direction of the DOF is returned in mom_sim_result1 variable when the: direction of x positive is 1 direction of y positive is 2 direction of z positive is 3 direction of x negative is -1 direction of y negative is -2 direction of z negative is -3
Example | SIM_ask_axis_dof_junction $axis set axis_jct $mom_sim_result set axis_num $mom_sim_result1

SIM_ask_tool_offsets

Syntax | SIM_ask_tool_offsets <tool_name>
Description | Returns the tool offsets. The offsets in X, Y and Z define the vector from the origin of the tool mounting junction to the origin of the tool tip with respect to the absolute coordinate system (ACS).
Parameters | tool_name: the K-component name of the tool
Output | The list of tool offsets (in x,y, and Z) are returned in the mom_sim_result variable.
Example | set offsets [SIM_ask_tool_offsets $tool_name]

SIM_ask_cording_tol

Syntax | SIM_ask_cording_tol
Description | Returns the tolerance used for linear approximation of circular and splinar motions.
Parameters | none
Output | The cording tolerance is returned in mom_sim_result variable.
Example | set tol [SIM_ask_cording_tol]

SIM_ask_mtd_units

Syntax | SIM_ask_mtd_units
Description | Returns the units of the machine tool driver. The interface to and from S&V commands is with those units.
Parameters | none
Output | The units "MM" or "INCH" is returned in mom_sim_result variable.
Example | set units [SIM_ask_mtd_units]

Miscellaneous Commands

SIM_delay

Syntax | SIM_delay <duration>
Description | Freeze simulation for the specified duration.
Parameters | duration: duration in seconds. Part of a second is also allowed.
Output | none
Example | # stop simulation for 10.5 seconds SIM_delay 10.5

SIM_set_parameter

Syntax | SIM_set_parameter <duration> <label> <text> <unit>
Description | A general command to set a simulation engine parameter so that the processor can make use of it or the MTD can track it.
Parameters | duration: the time in seconds it takes the machine to execute this command label: label identifier for the parameter text: value of parameter unit: the units of the parameter value. The supported units are: MM,INCH, SEC, MM_PER_MIN, REV_PER_MIN, INCH_PER_MIN, M_PER_SEC_POW2, MM_PER_REV, INCH_PER_REV and MM_PER_100REV
Output | none
Example | SIM_set_parameter 0 feed 1000 MM_PER_MIN

SIM_mtd_init

Syntax

SIM_mtd_init <mode>

Description

Initialize machine tool driver and set it to one of the three MTD modes. The supported modes are:

NC_CONTROLLER_SIM_EVENT_HANDLER is the sim event mode where sim events are generated and processed to execute the simulation tasks.

NC_CONTROLLER_MTD_EVENT_HANDLER is the direct mode where the simulation events are blended with the post generation code.

NC_CONTROLLER_PLUGIN is the plugin mode where a dedicated plugin program parses the NC program and executes S&V commands.

Parameters

mode: one of the three MTD modes

Output

none

Example

SIM_mtd_init NC_CONTROLLER_SIM_EVENT_HANDLER

SIM_mtd_reset

Syntax | SIM_mtd_reset
Description | Exit the machine tool driver and perform the corresponding cleanup.
Parameters | none
Output | none
Example | SIM_mtd_reset

SIM_transform_offset_acs_to_mtcs

Syntax | SIM_transform_offset_acs_to_mtcs <abs_xval> <abs_yval> <abs_zval>
Description | Transform the position in absolute coordinate system to machine tool coordinate system.
Parameters | abs_xval,abs_yval,abs_zval – the input position in ACS
Output | The variable mom_sim_result contains the transformed offset.
Example | Example to find the origin of a junction in MTCS: SIM_ask_junction_xform $JNC_name listToVector offset $mom_sim_result1 3 SIM_transform_offset_acs_to_mtcs $offset(1) $offset(2) $offset(3) set mtcs_offset $mom_sim_result

SIM_transform_matrix_acs_to_mtcs

Syntax | SIM_transform_matrix_acs_to_mtcs <m00> <m01> <m02> <m10> <m11> <m12> <m20> <m21> <m22>
Description | Returns the transformation that transforms from the coordinate system specified to the machine tool coordinate system (MTCS). The specified transformation is the transformation from ACS to the coordinate system that this matrix represents. For example, the specified transformation could be the transformation of the ZCS junction and the returned matrix is the matrix that transforms from ZCS to MTCS.
Parameters | <m00..m22> the source matrix transformation
Output | The resulting transformation matrix (M00 M01 M02 ..) is returned in the mom_sim_result variable
Example | Example to transform from the junction coordinate system to MTCS: SIM_ask_junction_xform $JNC_name listToVector abs_matrix $mom_sim_result 9 listToVector abs_offset $mom_sim_result1 3 SIM_transform_offset_acs_to_mtcs $abs_offset(1) $abs_offset(2) $abs_offset(3) set offset_zcs_to_mtcs $mom_sim_result SIM_transform_matrix_acs_to_mtcs $abs_matrix(1) $abs_matrix(2) $abs_matrix(3) $abs_matrix(4) $abs_matrix(5) $abs_matrix(6) $abs_matrix(7) $abs_matrix(8) $abs_matrix(9) set matrix_zcs_to_mtcs $mom_sim_result

SIM_create_junction

Syntax | SIM_create_junction <name> <dest_name> <orgX> <orgY> <orgZ> <vecXx> <vecXy> <vecXz> <vecYx> <vecYy> <vecYz> <vecZx> <vecZy> <vecZz>
Description | Create a junction and attach it to a specified component. The origin and coordinate system axes direction in absolute coordinate system are specified. The junction is created immediately.
Parameters | name: name of junction to be created dest_comp: name of K-component where the junction is attached. orgX…: the origin of the junction coordinate system in ACS vecXx…: the unit vectors of the X, Y and Z axes of the coordinate system.
Output | none
Example | Create a junction that coincides with current MCS: set origin0 [ SIM_convert_sim_to_mtd_units $mom_msys_origin(0) ] set origin1 [ SIM_convert_sim_to_mtd_units $mom_msys_origin(1) ] set origin2 [ SIM_convert_sim_to_mtd_units $mom_msys_origin(2) ] SIM_create_junction CURRENT_ZCS_JCT TABLE $origin0 $origin1 $origin2 $mom_msys_matrix(0) $mom_msys_matrix(1) $mom_msys_matrix(2) $mom_msys_matrix(3) $mom_msys_matrix(4) $mom_msys_matrix(5) $mom_msys_matrix(6) $mom_msys_matrix(7) $mom_msys_matrix(8)

SIM_delete_junction

Syntax | SIM_delete_junction <name>
Description | Delete specified junction from KIM. This command is executed immediately.
Parameters | Name: junction name. Since junction name is unique within a kinematics component, the junction name could also be prefixed with the kinematics name and the character @ and then followed by the junction name. For example: spindle@tool_mount_jct identifies the tool_mount_jct junction defined in the spindle kinematics component.
Output | none

SIM_start_of_simulation

Syntax | SIM_start_of_simulation
Description | Create an event that indicates start of simulation
Parameters | none
Output | none

SIM_end_of_simulation

Syntax | SIM_end_of_simulation
Description | Create an event that indicates end of simulation.
Parameters | none
Output | none

SIM_activate_tool

Syntax | SIM_activate_tool <tool_name>
Description | Make the specified tool current. The tool must already be mounted before this command is issued.
Parameters | tool_name: the name of the K-component that represents the tool.
Output | none
Example | After mounting the tool, make it current: SIM_mount_tool "15" "UG_NAME" $tool_name "SPINDLE" "SPINDLE_JCT" set tool_name $mom_sim_result if {$tool_name != ""} { SIM_activate_tool $tool_name }

SIM_set_current_zcs_junction

Syntax | SIM_set_current_zcs_junction <jct_name>
Description | Set the current ZCS junction
Parameters | zcs_jct: the name of the ZCS junction to make current
Output | none

SIM_set_mtd_units

Syntax | SIM_set_mtd_units <units>
Description | Set the machine tool driver units. All dimensional values to/from S&V commands are in this unit.
Parameters | units: MM or INCH
Output | none

SIM_set_feed

Syntax | SIM_set_feed <value> <unit> <duration>
Description | Set the current machine tool feedrate.
Parameters | value: feedrate value unit: one of the following values: MM_PER_MIN, INCH_PER_MIN, MM_PER_REV, INCH_PER_REV, MM_PER_100REV duration: (optional argument) the time it takes the machine tool to execute this command
Output | none

SIM_set_speed

Syntax | SIM_set_speed <value> <unit> <duration>
Description | Set the current machine tool speed.
Parameters | value: speed value unit: only REV_PER_MIN is currently supported duration: (optional argument) the time it takes the machine tool to execute this command
Output | none

SIM_set_coolant

Syntax | SIM_set_coolant <value> <duration>
Description | Set the current machine tool coolant state.
Parameters | value: ON or OFF duration: (optional argument) the time it takes the machine tool to execute this command
Output | none

SIM_set_cutting_mode

Syntax | SIM_set_cutting_mode <mode>
Description | Set cutting mode CUT or RAPID
Parameters | mode: CUT or RAPID
Output | none

SIM_set_channel

Syntax | SIM_set_channel <channel_id>
Description | Set the current NC channel number where the events will be sent. By default all events are sent to the same default channel. Four-axis lathe is an example of an application that requires two NC channels.
Parameters | Channel_id: the channel number.
Output | none

SIM_ask _channel

Syntax | SIM_set_channel <channel_id>
Description | Set the current NC channel number where the events will be sent. By default all events are sent to the same default channel. Four-axis lathe is an example of an application that requires two NC channels.
Parameters | Channel_id: the channel number.
Output | none


High Level S&V Commands

The following is the list of High Level S&V commands. For a description of the commands follow the hyperlink.

To have access to these commands, the TCL file sim_high_level_sv_commands.tcl has to be sourced first.

SIM_ask_current_ref_junction | return the current reference junction
SIM_ask_current_zcs_junction | return the name of current ZCS junction
SIM_ask_intermediate_update | return whether or not intermediate updates are set
SIM_ask_junction_origin_mtcs | return the current or initial junction origin in MTCS coordinate system
SIM_ask_last_position_mtcs | return the last reference junction position in MTCS
SIM_ask_last_position_zcs | return the last reference junction position in ZCS
SIM_ask_linear_axes_config | return the current linear axes configuration
SIM_ask_linear_axes_map | return the linear axes mapping (logical to physical axis mapping)
SIM_ask_offsets_mtcs | return offsets between two junctions in MTCS coordinates
SIM_ask_rotary_axes_config | return the current rotary axes configuration
SIM_ask_rotary_axes_map | return the rotary axes mapping (logical to physical axis mapping)
SIM_ask_tool_position_mtcs | return specified tool tip position and tool orientation with respect to the current MTCS
SIM_ask_tool_position_zcs | return specified tool tip position and tool orientation with respect to the current ZCS
SIM_compute_transform | compute transformation from source junction to target junction
SIM_convert_mtd_to_sim_units | convert machine tool driver units to simulation (part) units
SIM_convert_sim_to_mtd_units | convert a specified value from current part/simulation units to MTD units
SIM_create_zcs_junction | call utility function to create ZCS junction or return existing one
SIM_dialog_start | initialize the dialog table and define the title attribute of the dialog
SIM_dialog_end | end customized dialog definition
SIM_dialog_set_item | set attributes of an item in a customized dialog
SIM_invoke | open a shell for invoking S&V commands. This avoids command invocation if S&V not active
SIM_macro_append_sv_cmd | add an S&V command to macro
SIM_macro_call | call a predefined macro
SIM_macro_def | start a definition of new macro
SIM_macro_delete | delete an existing macro
SIM_macro_delete_all | delete all macros
SIM_macro_end | end definition of a macro
SIM_map_logical_to_phisical_axis | return physical axis corresponding to specified logical axis
SIM_move_circular_mtcs | move axes in circular mode where coordinates are in MTCS
SIM_move_circular_zcs | move axes in circular mode where coordinates are in ZCS
SIM_move_linear_mtcs | move axes in linear mode where coordinates are in MTCS
SIM_move_linear_zcs | move axes in linear mode where coordinates are in ZCS
SIM_set_current_ref_junction | set the current reference junction
SIM_set_duration_callback_fct | set callback TCL function to compute duration of a delta motion
SIM_set_intermediate_update | issue (or not) update axes command after each motion command
SIM_set_linear_axes_config | set the current linear axes configuration
SIM_set_linear_axes_map | set the linear axes mapping (logical to physical axis mapping)
SIM_set_rotary_axes_config | set the current rotary axes configuration
SIM_set_rotary_axes_map | set the rotary axes mapping (logical to physical axis mapping)
SIM_transform_mtcs_to_zcs | transform point from MTCS to ZCS coordinate system
SIM_transform_point | transform point specified in source junction to target junction
SIM_transform_vector | transform vector specified in source junction to target junction
SIM_transform_zcs_to_mtcs | transform point from ZCS to MTCS coordinate system
SIM_update_current_zcs | set current ZCS junction and update ZCS <-> MTCS transformations


High Level Commands - Description

SIM_ask_current_ref_junction

Syntax | SIM_ask_current_ref_junction
Description | Returns the name of current reference junction
Parameters | None
Output | The function returns the name of the reference junction

SIM_ask_current_zcs_junction

Syntax | SIM_ask_current_zcs_junction
Description | Returns the name of current ZCS junction
Parameters | None
Output | The function returns the name of current ZCS junction.

SIM_ask_intermediate_update

Syntax | SIM_ask_intermediate_update
Description | Returns whether or not S&V commands will be followed by SIM_update command. By default the system issues a SIM_update command at the end of the high level S&V move commands.
Parameters | None
Output | The function returns the current state 1 (yes) and 0 of this flag.

SIM_ask_junction_origin_mtcs

Syntax | SIM_ask_junction_origin_mtcs <jct_name> <state>
Description | Returns the origin of the specified junction in the current state of the KIM model if state is CURRENT. If state is set to INITIAL, the origin of the initial state of the junction (before simulation starts) is returned.
Parameters | jct_name: the name of the junction state: in what state of KIM model data is requested - INITIAL or CURRENT
Output | The function returns the junction origin in MTCS as a list of X, Y and Z coordinates.
Example | set origin [SIM_ask_junction_origin_mtcs JNCT_HEAD_1 INITIAL]

SIM_ask_last_position_mtcs

Syntax | SIM_ask_last_position_mtcs
Description | Returns the last position of the reference junction in the machine tool coordinate system.
Parameters | None
Output | The function returns last position as a list of X, Y and Z coordinates.
Example | set last_position [SIM_ask_last_position_mtcs]

SIM_ask_last_position_zcs

Syntax | SIM_ask_last_position_zcs
Description | Returns the last position of the reference junction in ZCS coordinate system.
Parameters | None
Output | The function returns the last position as a list of X, Y and Z coordinates.
Example | set last_position [SIM_ask_last_position_zcs]

SIM_ask_linear_axes_config

Syntax | SIM_ask_linear_axes_config
Description | Returns the current list of logical NC axes that will participate in executing the next linear motion command.
Parameters | None
Output | The function returns a list of NC axes names.

SIM_ask_linear_axes_map

Syntax | SIM_ask_linear_axes_map
Description | Returns a table that maps logical linear axes to physical axes.
Parameters | None
Output | The function returns a table of couples. The first member of a couple is the logical axis and the second one is the physical name.

SIM_ask_offsets_mtcs

Syntax | SIM_ask_offsets_mtcs <from_jct> <to_jct> <state>
Description | Returns offsets between two junctions in machine tool coordinate system. The offset could be returned with respect to the CURRENT state of the KIM model or in its INITIAL state.
Parameters | from_jct: return offset from this junction name to_jct: to this junction name state: CURRENT or INITIAL
Output | The offset between the two junctions is returned as a list of X, Y and Z coordinates.
Example | set vector [ SIM_ask_offsets_mtcs $from_jct $to_jct CURRENT ]

SIM_ask_rotary_axes_config

Syntax | SIM_ask_rotary_axes_config
Description | Returns the current list of logical NC axes that will participate in executing the next rotary motion command.
Parameters | none
Output | The function returns list of NC axes names.

SIM_ask_rotary_axes_map

Syntax | SIM_ask_rotary_axes_map
Description | Returns a table that maps logical rotary axes to physical axes.
Parameters | none
Output | The function returns a table of couples. The first member of a couple is the logical axis and the second one is the physical name.

SIM_ask_tool_position_mtcs

Syntax | SIM_ask_tool_position_mtcs <tip_jct>
Description | This command returns the specified tool tip position and tool orientation with respect to the current MTCS. The position is the current position of the origin of the specified junction. The tool axis orientation is assumed to be in direction of the X axis of the specified junction.
Parameters | tip_jct: tool tip junction name
Output | This returns a list with 6 values. The first three are the tip position and the other three are vectors of the tool axis. All are defined with respect to the MTCS.
Example | # get current tool position and axis set pos_and_axis [SIM_ask_tool_position_mtcs [SIM_ask_current_ref_junction] ] set tool_X [lindex $pos_and_axis 0] set tool_Y [lindex $pos_and_axis 1] set tool_Z [lindex $pos_and_axis 2] set axis_X [lindex $pos_and_axis 3] set axis_Y [lindex $pos_and_axis 4] set axis_Z [lindex $pos_and_axis 5]

SIM_ask_tool_position_zcs

Syntax | SIM_ask_tool_position_zcs <tip_jct>
Description | This command returns the specified tool tip position and tool orientation with respect to the current ZCS. The position is the current position of the origin of the specified junction. The tool axis orientation is assumed to be in direction of the X axis of the specified junction.
Parameters | tip_jct: tool tip junction name
Output | This returns a list with 6 values. The first three are the tip position and the other three are vectors of the tool axis. All are defined with respect to the ZCS.
Example | # get current tool position and axis set pos_and_axis [SIM_ask_tool_position_zcs [SIM_ask_current_ref_junction] ] set tool_X [lindex $pos_and_axis 0] set tool_Y [lindex $pos_and_axis 1] set tool_Z [lindex $pos_and_axis 2] set axis_X [lindex $pos_and_axis 3] set axis_Y [lindex $pos_and_axis 4] set axis_Z [lindex $pos_and_axis 5]

SIM_compute_transform

Syntax

SIM_compute_transform < src_jct>< target_jct>< src_state>< target_state>

Description

This commands computes the transformation from src_jct in initial or its current state to the target junction in its current or initial state.

Parameters

src_jct: This is the name of the source junction.

target_jct: This is the name of target junction.

src_state: INITIAL or CURRENT. This is an optional parameter. The default is INITIAL. INITIAL specifies that the src_jct coordinate system should be considered in the initial state of the machine. CURRENT specifies that the src_jct coordinate system should be considered in the current state of the machine.

target_state: INITIAL or CURRENT. This is an optional parameter. The default is INITIAL. INITIAL specifies that the target_jct coordinate system should be considered in the initial state of the machine. CURRENT specifies that the target_jct coordinate system should be considered in the current state of the machine.

Output

mom_sim_result contains the transformation matrix

mom_sim_result1 contains the translation vector.

Example

#get name of MTCS junction

SIM_ask_mtcs_junction

set mtcs_jct $mom_sim_result

# after this call mom_sim_result has the transformation from ZCS to MTCS

SIM_compute_transform [SIM_ask_current_zcs_junction] $mtcs_jct CURRENT CURRENT

SIM_convert_mtd_to_sim_units

Syntax | SIM_convert_mtd_to_sim_units <value>
Description | This converts machine tool driver units to simulation (part) units.
Parameters | value in MTD units
Output | The function returns the value in simulation units.
Example | set sim_pos [ SIM_convert_mtd_to_sim_units ]

SIM_convert_sim_to_mtd_units

Syntax | SIM_convert_sim_to_mtd_units <value>
Description | Converts a specified value from current part/simulation units to MTD units.
Parameters | value in simulation units
Output | The function returns the value in MTD units.
Example | Convert X coordinate of MCS to MTD units. set origin0 [ SIM_convert_sim_to_mtd_units $mom_msys_origin(0) ]

SIM_create_zcs_junction

Syntax | SIM_create_zcs_junction <zcs_name dest_cmp origin mtx>
Description | This command checks if the specified ZCS junction has already been created. If it has and all its data matches, its name is returned. If not, a new ZCS junction is created and its name is returned.
Parameters | zcs_name: name of ZCS junction dest_cmp: the ZCS junction is attached to this component origin: origin of junction in absolute coordinate system mtx: transformation of the junction coordinate system with respect to the absolute coordinate system
Output | The name of the ZCS junction.
Example | # This is a common code you may find in the MOM_msys convert part/simulation units to MTD units lappend origin [ SIM_invoke SIM_convert_sim_to_mtd_units $mom_msys_origin(0) ] lappend origin [ SIM_invoke SIM_convert_sim_to_mtd_units $mom_msys_origin(1) ] lappend origin [ SIM_invoke SIM_convert_sim_to_mtd_units $mom_msys_origin(2) ] # convert matrix vector to list for {set i 0} {$i<9} {incr i} { lappend mtx $mom_msys_matrix($i) } # Check if ZCS junction is already created. If yes, return its name. If not create a new one and return its name. This optimization is needed because this event is invoked before each operation is executed. set zcs_name [ SIM_create_zcs_junction CURRENT_ZCS_JCT $dest_cmp $origin $mtx ] SIM_invoke SIM_update_current_zcs $zcs_name }

SIM_dialog_add_item

Syntax

SIM_dialog_add_item <item type> <item_id> <item_att>

Description

This command adds a system or user-defined item to customize the NC Controller Panel dialog.

Parameters

item_type: the type identifier for the user or system item defined at creation time.

item_id: a text name to identify the item. This is used to identify the item by the SIM_dialog_set_item command. No spaces are allowed.

item_att: the item attributes according to the syntax described in the NC Controller Panel dialog.

Output

none

Example

# the following example issues the commands that set the default look of the simulation dialog (just the system items)

SIM_dialog_start "Control Panel for M5ACHH Driver"

# the following are the definitions of the default system items

SIM_dialog_add_item "SYS_ACTIVE_TOOL_ITEM S1"

SIM_dialog_add_item "SYS_SPEED_ITEM S2"

SIM_dialog_add_item "SYS_FEED_ITEM S3"

SIM_dialog_add_item "SYS_COOLANT_ITEM S4

ORIENTATION=<HORIZONTAL>"

SIM_dialog_add_item "SYS_POSITION_ITEM S5"

SIM_dialog_add_item "SYS_PROGRAM_WINDOW_ITEM S6"

SIM_dialog_add_item "SYS_MESSAGE_WINDOW_ITEM S7"

SIM_dialog_add_item "SYS_STEP_CONTROL_ITEM S8"

SIM_dialog_add_item "SYS_ANIMATION_SPEED_ITEM S9"

SIM_dialog_add_item "SYS_MACHINE_TIME_ITEM S10"

# examples of user defined items

SIM_dialog_add_item "USR_SEPARATOR_ITEM U1"

SIM_dialog_add_item "USR_LABEL_ITEM U2 LABEL=<my label>"

SIM_dialog_add_item "USR_STRING_ITEM U3 LABEL=<my string>

VALUE=<string value>"

SIM_dialog_add_item "USR_RADIO_ITEM U4 LABEL=<my radio>

ORIENTATION= <HORIZONTAL> SPAN=<3> LIST=<radio1,radio2,radio3> VALUE=<1>

FORMAT=<CHECK_BOX>"

SIM_dialog_end

SIM_dialog_end

Syntax | SIM_dialog_end
Description | This command ends the customized dialog definition. This must be defined.
Parameters | none
Output | none

SIM_dialog_set_item

Syntax

SIM_dialog_set_item <item_id> <item_att>

Description

This command sets the item attributes of the customized NC Controller Panel dialog.

Parameters

item_id: a text name to identify the item. This id is defined at creation time in SIM_dialog_add_item command.

item_att: the item attributes according to the syntax described in customized NC Controller Panel dialog.

Output

none

Example

# For system items currently only SENSITIVE attribute can be changed. The following command dims the Machine Time item from example in SIM_dialog_add_item

SIM_dialog_set_item "S10 SENSITIVE=<OFF>"

# dim the X, Y and Z axes in position item

SIM_dialog_set_item "S5 LIST=<X,Y,Z> SENSITIVE=<NO>"

# For user item all attributes can be changed

SIM_dialog_set_item "U2 LABEL=<label1> SENSITIVE=<OFF>"

SIM_dialog_set_item "U3 LABEL=<label2> VALUE=<$value1> SENSITIVE=<OFF>"

SIM_dialog_set_item "U4 LABEL=<label4> VALUE=<2> SENSITIVE=<OFF>"

SIM_dialog_start

Syntax | SIM_dialog_start <title>
Description | This command starts the definition of the customizable NC Controller Panel dialog. The simulation dialog can be customized by the machine tool driver writer. It contains system and user defined items. The system items are predefined items. By default all system items are shown in the simulation dialog. You can add and set user items during the simulation from the machine tool driver. The system items are set automatically by the S&V engine and you can only change a few of their attributes. Only the machine tool driver writer can set the user items.
Parameters | title: optional simulation dialog title
Output | none
Example | see example in SIM_dialog_add_item

SIM_invoke

Syntax | SIM_invoke <S&V command>
Description | This is a wrapper to S&V commands that validates that the MTD has been initialized before the S&V command is issued. This can be useful in posts that issue S&V commands.
Parameters | S&V command with its arguments
Output | The function returns the value in MTD units.
Example | SIM_invoke SIM_move_linear_mtcs Z $tool_change_pos(2)

SIM_macro_append_sv_cmd

Syntax | SIM_macro_append_sv_cmd <S&V command>
Description | Append S&V command to the current macro definition.
Parameters | S&V command and its arguments
Output | none
Example | See example in SIM_macro_call

SIM_macro_call

Syntax

SIM_macro_call <macro_name>

Description

Call a predefined macro. All the S&V commands associated with the macro are executed sequentially.

Parameters

macro_name: the name of existing macro

Output

none

Example

This example shows how to define a macro (cycle_200) and how to invoke it. This macro is one of the DMU50 drilling cycles.

# start macro cycle_200 definition

SIM_MTD_macro_def cycle_200

# change to rapid mode

SIM_macro_append_sv_cmd " SIM_set_cutting_mode RAPID"

# move rapid delta Z to $mom_cycle_rapid_to

SIM_macro_append_sv_cmd "SIM_move_linear_zcs Z \[ sim_mtd_get_z $mom_cycle_rapid_to \]"

# move rapid delta Z to $mom_cycle_feed_to

SIM_macro_append_sv_cmd "SIM_move_linear_zcs Z \[ sim_mtd_get_z $mom_cycle_feed_to \]"

# change value of mom_cycle_feed_to , set cutting mode and feedrate

set mom_cycle_feed_to [expr abs($mom_cycle_feed_to)]

SIM_macro_append_sv_cmd " SIM_set_cutting_mode CUT"

SIM_macro_append_sv_cmd " SIM_set_feed $mom_cycle_feed_rate INCH_PER_MIN"

# move to bottom of drill

SIM_macro_append_sv_cmd "SIM_move_linear_zcs Z \[ sim_mtd_get_z $mom_cycle_feed_to \]"

# move to retract position

SIM_macro_append_sv_cmd "SIM_move_linear_zcs Z \[ sim_mtd_get_z $mom_cycle_retract_to \]"

# end of macro definition

SIM_MTD_macro_end cycle_200

# Here is the definition of the local procedure sim_mtd_get_z. The global variables sim_last_X, sim_last_Y and sim_last_Z are set to the last tool tip position before the macro starts. This way ncremental work with respect to some starting point can be done.

proc sim_mtd_get_z { z_val } {

global sim_last_X sim_last_Y sim_last_Z

set z [expr $sim_last_Z + $z_val]

return $z

}

# Now, somewhere in the NC program the macro is called after positioning the tool at a starting point.

SIM_set_cutting_mode RAPID

SIM_move_linear_zcs X $mom_pos(0) Y $mom_pos(1) C $mom_out_angle_pos(0) B $mom_out_angle_pos(1)

SIM_macro_call cycle_200

SIM_macro_def

Syntax | SIM_macro_def macro_name
Description | Starts a definition of a new macro. If a macro exists, it will be deleted first.
Parameters | macro_name: the name of the macro
Output | none
Example | See SIM_macro_call

SIM_macro_delete

Syntax | SIM_macro_delete macro_name
Description | Delete an existing macro
Parameters | macro_name: the name of the macro
Output | none
Example | See SIM_macro_call

SIM_macro_delete_all

Syntax | SIM_macro_delete_all
Description | Delete all macros
Parameters | none
Output | none
Example | See SIM_macro_call

SIM_macro_end macro_name

Syntax | SIM_macro_end macro_name
Description | End definition of a new macro
Parameters | macro_name: the name of the macro
Output | none
Example | See SIM_macro_call

SIM_map_logical_to_phisical_axis

Syntax | SIM_map_logical_to_phisical_axis <logical_axis>
Description | Return the physical axis that corresponds to the specified logical axis. This is based on the mapping table defined by commands SIM_set_rotary_axes_map and SIM_set_linear_axes_map
Parameters | logical_axis: name of logical axis
Output | The physical axis.
Example | set ph_axis [SIM_map_logical_to_phisical_axis X]

SIM_move_circular_mtcs

Syntax

SIM_move_circular_mtcs <plane vector> <args>

Description

Perform a circular motion. Coordinates are in machine tool coordinate system (MTCS). The function approximates the specified arc by linear segments. The deviation of the segments from the arc is by cording tolerance (set by SIM_set_cording_tol). Each motion of the arc segment is executed by the SIM_move_linear_mtcs command.

Parameters

plane vector: a unit vector which defines the plane

args: the definition is consistent with the G02 and G03 commands. The center of the arc is defined by the combination of two components of I, J, or K for the 2D case and the I, J, K for the 3D case. R can replace the I, J, K definition and is explained in the example below. In the 2D case, the end point third coordinate could also be specified to define a helical motion between the start and end points.

Output

none

Example

The command syntax is very similar to the G02 or G03 G code command. This command syntax covers two types of circular motion formats: one where the center of the arc is explicitly defined and the other one by the arc radius. Here are four examples of this circular motion format:

SIM_move_circular_mtcs 0 0 1 X 10 Y 10 I 20 J 30

SIM_move_circular_mtcs 0 0 1 X 10 Y 10 R 14

SIM_move_circular_mtcs 0 0 1 X 10 Y 10 Z 34 I 20 J 30 K 34

SIM_move_circular_mtcs 0 0 1 X 10 Y 10 Z 34 R 65

The first two examples describe a circular arc in the X-Y plane. The other examples describe an arc in space. Examples one and two also represent arcs defined in other orthogonal planes (i.e., X-Z and Y-Z planes). In that case K replaces J or I respectively.

Examples one and three use the coordinates of the center point (M) of the arc given by I 20 J 30 and I 20 J 30 K 34 respectively. The arc direction is determined by the plane vector. The rotation direction is always positive (CCW) with respect to the specified vector. Figure 1 illustrates the arc direction depending on the plane vector. The end coordinates (E) are given by X, Y or X, Y and Z respectively. The start coordinate (S) is the starting point (where the tool is before this motion starts).

Figure : Rotation Direction for the Circular Interpolation in the XY-Plane and Space by a Given Center Point (M) and Rotation Vector

Examples two and four use the radius of the circle arc. There are solutions using the radius instead of the centre point as illustrated in next figure.

Figure: Center Point Mode for the Circular Interpolation in the XY-Plane and Space by a Given Radius

The rotation vector and the sign of the radius determine the right arc. Furthermore, there is a simple rule to find the correct center point:

R>0 ® 180° >= rotation angle > 0°

R<0 ® 360° > rotation angle > 180°

It is not permissible to program with the radius method if the traversing angle is 0 or 360. There a full circle must be programmed using the other method.

SIM_move_circular_zcs

Syntax | SIM_move_circular_zcs <plane vector> <args>
Description | Perform a circular move. Coordinates are specified in ZCS. See detailed description in SIM_move_circular_mtcs
Parameters | See SIM_move_circular_mtcs
Output | none

SIM_move_linear_mtcs

Syntax

SIM_move_linear_mtcs <args>

Description

This command moves the current reference junction (set by SIM_set_current_ref_junction like tool tip junction) to the target position specified in machine tool coordinate system (MTCS). The linear and rotary axes that participate in achieving the target position are defined by the SIM_set_linear_axes_config and SIM_set_rotary_axes_config respectively.

The arguments that can be passed to the command are very similar to the G01 arguments (just the motion arguments). The target position can be explicitly defined for X, Y, Z and rotary axes. But it can also omit one or more of the coordinates which means that those coordinates do not change during that motion.

Note that the axes of the MTCS coordinate system are not necessarily aligned with the actual machine tool axes.

This function also computes the duration of this motion based on the length of the linear and angular displacement and the current feed rate. The actual computation of the duration is computed by a user TCL procedure call back that is set by the S&V command SIM_set_duration_callback_fct.

Parameters

See details in description

Output

none

Example

SIM_move_linear_mtcs X 100 Y 200 Z 300 A 20 B 15

SIM_move_linear_mtcs X 20

SIM_move_linear_mtcs B 100

SIM_move_linear_zcs

Syntax | SIM_move_linear_zcs <args>
Description | This command differs from the SIM_move_linear_mtcs in two ways: first, the coordinates in this command are specified with respect to the ZCS and not MTCS. Second, the ZCS coordinate system is not fixed and can be set by call to SIM_update_current_zcs.
Parameters | See SIM_move_linear_mtcs
Output | none
Example | SIM_move_linear_zcs X 120.3 Y 300.5 A 67.5

SIM_set_current_ref_junction

Syntax | SIM_set_current_ref_junction <jct_name>
Description | Sets the current reference junction. The reference junction is taken into account in the high level S&V motion commands.
Parameters | jct_name: name of existing junction. Since junction name is unique within a kinematics component, the junction name could also be prefixed with the kinematics name and the character @ and then followed by the junction name. For example: spindle@tool_mount_jct identifies the tool_mount_jct junction defined in the spindle kinematics component.
Output | none
Example | SIM_set_current_ref_junction TOOL_TIP_JCT

SIM_set_duration_callback_fct

Syntax

SIM_set_duration_callback_fct <fct>

Description

Sets the callback function that is used to compute the duration of a motion. To get an accurate duration of a motion, one can take into account the acceleration and deceleration feed rate rather than a constant feed rate. The fct prototype should be as follows:

proc CalculateDurationTime { linear_or_angular delta }

{

...

set time ...

....

return $time

}

linear_or_angular can get the values LINEAR or ANGULAR. This specifies whether delta, the axis displacement, is for linear or rotary axes. The function has to return the time in seconds that it will take the machine tool to do this delta motion.

Parameters

fct: a TCL callback function

Output

none

Example

SIM_set_duration_callback_fct CalculateDurationTime

SIM_set_intermediate_update

Syntax | SIM_set_intermediate_update <flag>
Description | Sets flag indicating whether or not the high level S&V motion commands call the SIM_update command at the end. By default it does.
Parameters | flag: 1 to call and 0 no to call SIM_update
Output | none

SIM_set_linear_axes_config

Syntax | SIM_set_linear_axes_config <axes-list>
Description | Sets the current list of logical NC axes that will participate in executing the next linear motion command.
Parameters | axes-list: the linear axes list
Output | none
Example | SIM_set_linear_axes_config [concat X Y Z]

SIM_set_linear_axes_map

Syntax | SIM_set_linear_axes_map <map-table>
Description | Sets the current table that maps logical linear axes to physical axes.
Parameters | map_table: a list of pairs of logical and physical axes
Output | none
Example | SIM_set_linear_axes_map [concat X X_AXIS Y Y_AXIS Z Z_AXIS]

SIM_set_rotary_axes_config

Syntax | SIM_set_rotary_axes_config <axes-list>
Description | Sets the current list of logical NC axes that will participate in executing the next rotary motion command.
Parameters | axes-list: the rotary axes list
Output | none
Example | SIM_set_rotary_axes_config [concat B C]

SIM_set_rotary_axes_map

Syntax | SIM_set_rotary_axes_map <map-table>
Description | Sets the current table that maps logical rotary axes to physical axes.
Parameters | map_table: a list of pairs of logical and physical axes
Output | none
Example | SIM_set_rotary_axes_map [concat A A B SP]

SIM_transform_mtcs_to_zcs

Syntax | SIM_transform_mtcs_to_zcs <x> <y> <z>
Description | Transforms the point from MTCS to current ZCS coordinate system.
Parameters | x, y, z: X, Y and Z coordinates of point to be transformed.
Output | Returns the transformed point as a list of the three coordinates.
Example | set pt_zcs [SIM_transform_mtcs_to_zcs $mtcs_x $mtcs_y $mtcs_z]

SIM_transform_point

Syntax

SIM_transform_point <point src_jct target_jct src_state target_state>

Description

Transforms the specified point coordinates defined with respect to the src_jct coordinate system to the target_jct coordinate system. The junctions coordinate system could be defined with respect to the initial state of the machine (INITIAL) or the current state (CURRENT). The state of the junction is determined by the optional parameters src_state and target_state.

Parameters

point : list of 3 coordinates

src_jct: This is the name of the source junction. The point is defined with respect to this junction coordinate system.

target_jct: This is the name of target junction. The point is transformed to this coordinate system.

src_state: INITIAL or CURRENT values. This is an optional parameter. The default is INITIAL. INITIAL specifies that the src_jct coordinate system should be considered in the initial state of the machine. CURRENT specifies that the src_jct coordinate system should be considered in the current state of the machine.

target_state: INITIAL or CURRENT values. This is an optional parameter. The default is INITIAL. INITIAL specifies that the target_jct coordinate system should be considered in the initial state of the machine. CURRENT specifies that the target_jct coordinate system should be considered in the current state of the machine.

Output

the transformed point

Example

# Get name of MTCS junction

SIM_ask_mtcs_junction

set mtcs_jct $mom_sim_result

# return the origin of the current tool tip junction with respect to the MTCS

set point [list 0.0 0.0 0.0 ]

set origin [ SIM_transform_point $point $tool_tip_jct $mtcs_jct CURRENT CURRENT]

SIM_transform_vector

Syntax

SIM_transform_vector <vector src_jct target_jct src_state

target_state>

Description

Transforms the specified vector defined with respect to the src_jct coordinate system to the target_jct coordinate system. The junctions coordinate system could be defined with respect to the initial state of the machine (INITIAL) or the current state (CURRENT). The state of the junction is determined by the optional parameters src_state and target_state.

Parameters

vector: list of 3 coordinates

src_jct: This is the name of the source junction. The point is defined with respect to this junction coordinate system

target_jct: This is the name of the target junction. The vector is transformed to this coordinate system

src_state: INITIAL or CURRENT values. This is an optional parameter. The default is INITIAL. INITIAL specifies that the src_jct coordinate system should be considered in the initial state of the machine. CURRENT specifies that the src_jct coordinate system should be considered in the current state of the machine.

target_state: INITIAL or CURRENT values. This is an optional parameter. The default is INITIAL. INITIAL specifies that the target_jct coordinate system should be considered in the initial state of the machine. CURRENT specifies that the target_jct coordinate system should be considered in the current state of the machine.

Output

the transformed vector

Example

# get name of MTCS junction

SIM_ask_mtcs_junction

set mtcs_jct $mom_sim_result

# return the Z axis of the tool tip junction junction with respect to the MTCS

set vector [list 0.0 0.0 1.0 ]

set z_axis [SIM_transform_point $vector $tool_tip_jct $mtcs_jct CURRENT CURRENT]

SIM_transform_zcs_to_mtcs

Syntax | SIM_transform_zcs_to_mtcs <x> <y> <z>
Description | Transforms the point from current ZCS to MTCS coordinate system.
Parameters | x, y, z: X, Y and Z coordinate of point to be transformed.
Output | Returns the transformed point as a list or the three coordinates.
Example | set pt_mtcs [SIM_transform_zcs_to_mtcs $zcs_x $zcs_y $zcs_z]

SIM_update_current_zcs

Syntax | SIM_update_current_zcs <zcs_jct>
Description | Sets the current ZCS junction to be considered in the high level S&V motion commands. This also updates the transformation from ZCS to MTCS
Parameters | zcs_jct: the name of the new ZCS junction. Junction must be already created.
Output | none
Example | set origin0 [ SIM_convert_sim_to_mtd_units $mom_msys_origin(0) ] set origin1 [ SIM_convert_sim_to_mtd_units $mom_msys_origin(1) ] set origin2 [ SIM_convert_sim_to_mtd_units $mom_msys_origin(2) ] SIM_create_junction CURRENT_ZCS_JCT $dest_cmp $origin0 $origin1 $origin2 $mom_msys_matrix(0) $mom_msys_matrix(1) $mom_msys_matrix(2) $mom_msys_matrix(3) $mom_msys_matrix(4)$mom_msys_matrix(5) $mom_msys_matrix(6) $mom_msys_matrix(7) $mom_msys_matrix(8) SIM_update_current_zcs CURRENT_ZCS_JCT


Syntax Description for Dialog Table Items

Customized Simulation Dialog - Definition and Syntax Description

The items found in the Simulation Control Panel depend upon which NC controller you use. You can customize this dialog to reflect your needs. The customization is done in the machine tool driver. This way, each controller may have a different look and different items in the simulation dialog.

The following is a summary of functionality and features of the customized simulation dialog:

  • You can customize the simulation dialog from the machine tool driver. If not defined, the system provides a default dialog.

  • Dialog customization is available in the three MTD modes: direct mode, SIM event mode and plugin mode.

  • A predefined set of items is already available. These items are referred to as system items. They are handled and set by the system. Some of the system items attributes can be also altered during simulation.

  • In addition to system items, you can define your own items referred to as user items. It is your responsibility to set the user items during simulation. Note that setting an item is synchronized with the other events and may not happen at the time the command is called but when the set item event is processed.

  • All or subset of system items and user items can be mixed and positioned in any order in the dialog.

  • There are mandatory items at the bottom of dialog that the system adds after processing the user definitions. Those items are:reset, configure and stepping buttons.

The default items in the dialog are specified as a global TCL array. The default array is in the file:

\\MACH\resource\postprocessor\sim_high_level_sv_commands.tcl

and appears as follows:

# Define default system dialog table

#

set dialog_num_items 0

set mom_sim_dialog_attributes "TITLE=<Simulation Control Panel>"

set mom_sim_dialog_table(0) "SYS_ACTIVE_TOOL_ITEM S1"

set mom_sim_dialog_table(1) "SYS_SPEED_ITEM S2"

set mom_sim_dialog_table(2) "SYS_FEED_ITEM S3"

set mom_sim_dialog_table(3) "SYS_COOLANT_ITEM S4 ORIENTATION=<HORIZONTAL>"

set mom_sim_dialog_table(4) "SYS_POSITION_ITEM S5"

set mom_sim_dialog_table(5) "SYS_PROGRAM_WINDOW_ITEM S6"

set mom_sim_dialog_table(6) "SYS_MESSAGE_WINDOW_ITEM S7"

set mom_sim_dialog_table(7) "SYS_STEP_CONTROL_ITEM S8"

set mom_sim_dialog_table(8) "SYS_ANIMATION_SPEED_ITEM S9"

set mom_sim_dialog_table(9) "SYS_MACHINE_TIME_ITEM S10"

# Example of user defined items. Those are not part of the default setting this is why they are commented.

#set mom_sim_dialog_table(10) "USR_SEPARATOR_ITEM S11"

#set mom_sim_dialog_table(11) "USR_LABEL_ITEM S12 LABEL=<my label>"

#set mom_sim_dialog_table(12) "USR_STRING_ITEM S13 LABEL=<my string> VALUE=<string value>"

#set mom_sim_dialog_table(13) "USR_RADIO_ITEM S14 LABEL=<my radio> ORIENTATION=<HORIZONTAL> SPAN=<3> LIST=<radio1,radio2,radio3> FORMAT=<CHECK_BOX>"

set mom_sim_dialog_table(10) "SYS_LAST_ITEM"

You should not modify the default array, but include your own in your Machine Tool Driver.

  • Use the SIM high level commands SIM_dialog_start, SIM_dialog_end and SIM_dialog_add_item to customize the simulation dialog. Don't set the array directly. To change an item attribute during simulation, call the command SIM_dialog_set_item.

For adding and setting items in the customized dialog the following parameters are specified:

item_type: | There are two kinds of dialog items - system items and user items. System items are set directly by the S&V engine and possibly the machine tool driver. User items are set by the machine tool driver only.
item_id: | This is a text identifier that is used to uniquely identify the item by the SIM_dialog_set_item command. No spaces are allowed.
item_att: | These are the possible attributes of the items according to the syntax described bellow.

Syntax of item_type

System Item

Item Attributes (Keywords)

Figure

SYS_ACTIVE_TOOL_ITEM

  • WIDTH

  • SENSITIVITY*

SYS_SPEED_ITEM

  • WIDTH

  • SENSITIVITY*

  • UNIT*

SYS_FEED_ITEM

  • WIDTH

  • SENSITIVITY*

  • UNIT*

SYS_COOLANT_ITEM

  • ORIENTATION

  • SENSITIVITY*

SYS_POSITION_ITEM

  • LIST (of machine axes - default all)*

  • SENSITIVITY*

SYS_PROGRAM_WINDOW_ITEM

  • HEIGHT

  • SENSITIVITY*

SYS_MESSAGE_WINDOW_ITEM

  • HEIGHT

  • SENSITIVITY*

SYS_STEP_CONTROL_ITEM

  • SENSITIVITY*
SYS_ANIMATION_SPEED_ITEM
  • SENSITIVITY*

SYS_MACHINE_TIME_ITEM

  • WIDTH

  • SENSITIVITY*

SYS_LAST_ITEM

none

n/a

* indicates that the attribute can be changed during simulation.

User Items

Item Attributes (Keywords)

Figure

USR_LABEL_ITEM

  • LABEL*

  • SENSITIVITY*

USR_STRING_ITEM

  • LABEL

  • WIDTH

  • VALUE*

  • SENSITIVITY*

USR_RADIO_ITEM

  • LABEL

  • ORIENTATION

  • VALUE*

  • CENTER

  • num of rows/columns

  • LIST

  • LABEL

  • SENSITIVITY*

  • radio FORMAT (bullet or checkbox)

USR_SEPARATOR_ITEM

  • ORIENTATION

* indicates that the attribute can be changed during simulation.

Syntax of item_att

Item attributes use the following syntax:

keyword = <attribute value>

Keyword | Attribute Value
WIDTH | number of characters default 10
CENTER | YES or NO default NO
UNIT | string of characters default string=blank
LABEL | characters
ORIENTATION | HORIZONTAL or VERTICAL default VERTICAL
FORMAT | CHECK_BOX or BULLET default BULLET
VALUE | depends on the type of the item. It can be int,real, string of characters defaults (int=0,real=0.0 and string=blank)
LIST | list of items separated by "," default "item"
HEIGHT | numeric value default for number of visible lines in window 3 default for radio item is 3 columns or rows.
SENSITIVITY | YES or NO default YES
TITLE | string of characters


Coordinate Systems in the MTD

In the machine tool driver there are different coordinate systems that are used in the definition of the S&V commands. The following is a brief explanation of those coordinate systems:

MCS

The CAM Machine Coordinate System. The NC program is output with respect to this coordinate system. The MCS is used for programming your part.

ZCS

The workpiece Zero Coordinate System. Its attached to a fixed point on the workpiece. This is the origin of the part program. The MCS coincides with this coordinate system. Whereas the MCS is used for programming, the ZCS is for simulation. The ZCS can be changed during simulation by MTD.

Depending on where the ZCS is attached, it could be a static system but could also be placed on a part mounted on a rotary table and therefore moved when the part rotates. Normally, the ZCS are attached to stationary devices and don’t move during machining.

ACS

The Absolute Coordinate System of the CAM setup part file.

XCS

The aXis Coordinate System. Each axis of the machine has a coordinate system attached to it. Conceptually this coordinate system is firmly attached to the point where the associated machine element is mounted, but there can be exceptions. The degree of freedom is defined with respect to one of the XCS' main axes.

Normally the dependent machine axes don't affect each other along their degree of freedom (for example orthogonal linear axes). However, there may be cases where they could affect each other and these have to be taken into account. For example, collinear axis (i.e., two linear axes one mounted on the other moving in the same direction) or a linear axis that is mounted on a rotary table that moves when the table rotates.

TCS

The tool coordinate system. This coordinate system is firmly attached to the mounting point of the tool. The tool length is expressed in this coordinate system. The X axis of TCS points in the direction of the tool length (to be consistent with Genius definitions).

MTCS

The Machine Tool Coordinate System. This is an abstract coordinate system defined on every machine. It is not firmly attached to any point on the machine. It is used as a reference system to move or mount tools, heads and other machine devices. This has to be in sync with what is defined on the real machine tool. Normally MTCS axes are aligned with the physical machine axes. However, this will not be enforced by the system. One MTCS must be defined per machine tool.

RCJ

A Reference Coordinate Junction. This is the reference coordinate system that is used to position a K-component in a specific position. This reference junction is used in the high level S&V motion commands to determine the NC axis destination position.


Creating a Kinematics Model

The kinematics model describes the movement of a machine tool. In IS&V the kinematics model:

  • groups together assembly components from the geometric model to form kinematics components that have kinematics significance.

  • defines dependencies between kinematics components. This defines parent-child relationship between kinematics components such that when a parent component moves, its dependent children also move.

  • defines NC axes with their permissible linear or angular motion (i.e., degree of freedom).

This model is saved with the Unigraphics part file (.prt). Only one kinematics model per part file is allowed. When defining a kinematics model, only one component may be designated as a base component - the component upon which all other components are built.

A kinematics model can easily be built in IS&V using the Machine Tool Builder and modified within UG/CAM using the Machine Tool Configurator. Using the Machine Tool Builder you can create kinematics components (K-components). For these components you can create axes to define motion for these components. Junctions are needed for axis definitions and can be used by the MTD for remounting components.

  • Prerequisites for creating a kinematics model

  • The Machine Tool Builder

  • The Machine Tool Configurator

How to:

  • create K-components

  • create axes

  • create junctions


Prerequisites for Kinematics Model

Prerequisites

In order to create a kinematics model of a machine tool, you must first have a geometric model of the machine. This consists of a Unigraphics assembly part file which references the assembly for the machine tool, as well as any assemblies representing additional components to be simulated such as the machine bed, table, slide or spindle. This file will manage all the data required by IS&V. The part files for the simulation must be stored in the file management of the external library. For ASCII, these files are stored by default in the following directory:

$UGII_BASE_DIR\mach\resource\library\machine\graphics

For every machine, a subdirectory must exist here which uses the same name as the library reference of the machine. This subdirectory contains the master assembly and all the component part files of a machine.

For ASCII and Genius the system will evaluate the search path environment variable

UGII_CAM_LIBRARY_MACHINE_GRAPHICS_PATH

to locate the machine model partfile.


Machine Tool Builder

The Machine Tool Builder (MTB) is that part of the software which assists you in creating a kinematics model. It supports machine tools such as three to five axes milling machines, turning machines and mill turn machines.

In addition to the creation of the data model, the MTB application provides editing capabilities to modify the kinematics model and manually animate it for testing purposes. The geometric editing of the components is handled by other UG applications (Modeling and Assemblies). It is assumed, before beginning with the kinematics description of a machine tool, that the Unigraphics assembly model of the machine tool to be simulated already exists.

The MTB uses a kinematics tree (K-tree) to represent the kinematics model which you are creating. This tree is comprised of kinematics components (K-components). The k-tree shows the relationships between each of the kinematics components. When the parent component moves, each of the child components moves with it.

Using the Machine Tool Builder

The Machine Tool Builder can be found under Application in the main menu bar. Upon opening, an empty K-tree with the name of a fictitious machine appears. This tree is used to create the kinematics model and shows the relationships between the components being defined.

Once in the application, you may begin to build a kinematics model. To do this, MB3 on the machine name. This will allow you to choose from one of two options:

  1. Delete Model

    This will delete the current machine model.

  2. Insert

    You may insert a:

  • K-Component

A kinematics component or simply K-component is a node in the kinematics tree of a mechanical device. A K-component represents a mechanical feature. The K-component is a rigid body that has links to any Unigraphics geometry and references to other Unigraphics assembly components. It also has links to other K-components to establish parent-child relationships. Here you may choose to create, edit or delete a particular K-component.

  • Machine Base Component

One component (only) of the machine tool that you are describing must be defined as the machine base component. When the system begins a simulation, it searches for the component defined as the machine base component and displays it in the graphics window. All other components which are to be shown at the beginning of a simulation must be created as children of this parent component. Any components which are not under this machine base component in the tree hierarchy are not shown at the beginning of the simulation. Such items might be extra tables or turrets which are to be manually mounted during a machine stop and addressed through the postprocessor.


Machine Tool Configurator

The Machine Tool Configurator is available within CAM to allow you to access the K-tree and its components without leaving the CAM application. Use this when you want to add CAM-specific components (i.e., workpiece and fixture elements) to your kinematics model.

All other functions are described in the Machine Tool Builder section.


Creating K-Components

Creating and Editing K-Components

This section allows you to add a new kinematics component to the tree structure that you are using to describe the machine tool. For each component to which you would like to assign movement, you must create a unique K-component.

  1. Use MB3 on the component in the K-tree to which you want to add a new K-component.

  2. Select Edit.

    The Edit K-Component Dialog opens.

Edit K-Component Dialog
Name | Here you specify a name for the K-component. This name must be unique throughout the model. The kinematics tree structure can be modified from within the Machine Tool Driver (MTD). The name of the component will be used by the MTD in order to identify a kinematics component within certain S&V commands (mount, un-mount K-component). The MTD writer has to document the names of the components to be addressed.
Geometry Entities | Any components of an assembly which are selected via the Add New button will be listed in this list box. This list shows the names of the geometry entities that constitute the K-Component. The names listed here are identical with those in the name column of the assembly navigator. It is not necessary for a K-component to have geometry entities.
Add New | To begin the selection of a new K-component, use the Add New button. The familiar Unigraphics Class Selection dialog appears to assist you. Once chosen, the name of the assembly component selected will appear in the Geometry Entities list box.
Remove | After highlighting a component in the Geometry Entities list box, you may remove it using this button. This removes the selected geometry entity from the K-component as well.
Classification | Use this to classify your K-components.


Classifying K-Components

With this dialog you classify the K-component into different classes. This can be useful for several reasons:

  • The data which is input here can be seen in the Machine Tool View in CAM. By using the input fields in the Classification Dialog, you do not have to edit the .def file of the MOM Post.

  • The classifications specified here may be later used when collision checking, where you can select from a list of classes which you want to take into consideration for collision checking.

K-Component Classification Dialog

Predefined Classifications

You can select one of the predefined classifications. Other functions in the IS&V software perform specific actions depending on the class assigned to a K-component.

  • No Classification - No specific system class is assigned

  • Machine Base Component - You may apply this classification to only one K-component in the part file. This is normally the component with which you begin and you generally would not modify the Machine Base Component from within this dialog. Only the components in the machine base tree are considered during the actual animation. See also Create Machine Base Component.

  • Part - This identifies the design part for the collision checker. This then specifically indicates that the part is gouged in distinction to collisions of the tool with other components of the machine.

  • Workpiece - This identifies the in-process workpiece (IPW) for the collision checker and also for the material removal module. Usually at configuration the blank is classified as the workpiece. Thus the system knows from which component it has to calculate the material removal during the cutting process. The collision checker also needs to distinguish between the IPW and other components. If the cutting part of the tool touches the workpiece in cutting mode then this is not a collision in distinction to any other component of the machine.

  • Turret - This identifies the component to be presented as tool carrier in the Machine Tool View of the operation navigator. If system class turret is selected then the Postprocessor ID item becomes active.

  • Tool Pocket - This identifies the component to be presented as tool pocket in the Machine Tool View of the operation navigator. If the tool pocket class is selected then the Postprocessor ID item and the tool holding systems item become active.

If a component is classified as a Turret or Tool Pocket, its data will also be available in the Machine Tool View when the machine is loaded into a CAM part. If turret pocket data are found here, the dta in the Post definition file are ignored.

Postprocessor ID

This identifies the Turret or Tool Pocket for the Post. The value is provided in the Post variables mom_turret_id, mom_pocket_id depending on the selected system class. If you do not specify a postprocessor ID, this information will be drawn from the library resource definition file. This dialog item is only sensitive if system class Turret or Tool Pocket is selected.

Tool Holding System

This item is only sensitive if the component is classified as a Tool Pocket. The listbox shows the types of holding systems of the tools that can be mounted to this pocket. When the system automatically looks for a suitable tool for a pocket, it checks if the holding system of the tool (HLD attribute in the ASCII library for example) matches the one in this list.

New Tool Holding System

Here you may add a new Tool Holding System to the list of systems. Simply type in the name of the Holding System and then press Add. The system will add your entry to the list of Tool Holding Systems. To remove an entry from this list, highlight the entry in the list and press Remove. The highlighted Tool Holding System will disappear from the list.

User Classifications

This list shows the user classification strings that are assigned to the K-component.

New User Classification

Here you may add a new User Classification to the list of systems. Simply type in the name of the classification and then press Add. The system will add your entry to the list of User Classifications. To remove an entry from this list, highlight the entry in the list and press Remove. The highlighted User Classification will disappear from the list.


Creating Axes

Once you have created a K-component, it is possible to assign movement to this component. This is done by defining an axis for this component. Any movement is then carried out either along this axis or around it. If a K-component moves, then all K-components under it in the hierarchy will also move. The types of axes that can be assigned to a K-component are:

  • linear axis

  • rotary axis

Each NC-Axis has a unique visual representation for ease of identification. The Edit Axis dialog allows you to quickly define and edit the axes. Open this dialog by:

  1. using MB3 on the desired K-component

  2. select Edit or Insert

    If the K-component already has an axis then a yellow cone arrow is drawn in the graphics window as soon as the component is selected in the tree. This indicates the axis direction and type (linear or rotary).

Edit Axis Dialog
Name | Here the user can specify the name of the axis. This name will be used by the Machine Tool Driver to address the axis for motion input.
Select Junction | An NC axis is defined by selecting an axis of a junction coordinate system. This button leads to the Unigraphics Class Selection Dialog which allows the selection of a coordinate system on the screen. The dialog is pre-configured to allow selecting CSYS type only. Furthermore, only a junction coordinate system is accepted. For more information on using the Class Selection dialog, please consult the Unigraphics online help.
Axis of Junction | This item allows the specification of the NC axis direction by selecting an axis of the coordinate system from the previous point. The user can select either the positive or negative X, Y, Z directions. The selected axis is shown by a yellow cone head in the graphics window.
Type of Axis | Here you can assign linear (along an axis) or rotary (around an axis) movement to the K-component. If rotary is selected then an additional circle is drawn at the cone head.
Axis Limits | This limits the movement of the K-component to between the upper and lower values entered here. These values are checked during the simulation. A warning is issued if they are exceeded.
Test Axis | This is temporary data for axis testing.
Step Size | This is temporary data for axis testing. You can specify the step size for a single step motion when testing the axis.
Current Value | This is temporary data for axis testing. The field indicates the current axis value during testing. The user can also type in a value directly, press return and the component will jump to that position. If the component is at its design position then the axis value is zero.
 | The Play Backward to Lower Limit button causes the test animation to run from the current position backwards to the lower limit without stopping.
 | The Step Backward button causes the test animation to run from the current position backwards, but only by one step, the size of which is determined in the Step Size field.
 | The Play Forward button causes the test animation to run from the current position forwards, but only by one step, the size of which is determined the Step Size field.
 | The Step Forward to Upper Limit button causes the test animation to run forwards to the upper limit without stopping.


Creating Junctions

A junction is the point where two K-components meet. It is a classified and named coordinate system. The coordinate system is defined in respect to the absolute coordinate system of the device model part. A junction is a persistent object and associated with a K-component. It can be referenced by the machine tool driver for (re)mounting K-components or coordinate transformation. Junctions are also used for NC-Axis definitions.

When working with junctions, you may

  • add a junction

  • edit an existing junction

  • classify an existing junction

  • delete an existing junction

Adding a Junction

  1. MB3 on the K-component in the K-tree for which you would like to define a junction.

  2. Select Junctions to open the Junctions Dialog. This dialog box shows a listing of any junction currently defined.

  3. Select Add. This opens the Create Junction Dialog.

  4. Enter a new name for your junction or accept the default suggestion.

  5. Select Define Coordinate System which opens the CSYS Constructor dialog. Here you can define the junction coordinate system in the graphics window. The new junction is drawn in orange.

    When creating a junction you must define a CSYS.

Editing an Existing Junction

  1. MB3 on the K-component in the K-tree whose junction you would like to edit.

  2. Select Junctions to open the Junctions Dialog. This dialog box shows a listing of any junction currently defined.

  3. Select the junction to be edited from the list box.

  4. Select Edit. This opens the Edit Junction Dialog.

  5. If necessary, edit the name of your junction.

  6. If necessary, select Define Coordinate System and define a new coordinate system for your junction using the CSYS Constructor Dialog. The new junction is drawn in orange.

Classifying an Existing Junction

Other components in the IS&V system perform specific actions depending on the class assigned to a K-component.

  1. MB3 on the K-component in the K-tree whose junction you would like to classify.

  2. Select Junctions to open the Junctions Dialog. This dialog box shows a listing of any junction currently defined.

  3. Select the junction to be classified from the list box.

  4. Select Classify. This opens the Junction Classification Dialog. As some high level S&V commands in the Machine Tool Driver require a junction classified as machine zero, you may classify that junction here by checking the box.

  5. If User Classifications exist, you may select one from the list box.

  6. If you need to add or remove a User Classification, enter its name under New User Classification and add it to or remove it from the list box using Add or Remove.

Deleting an Existing Junction

  1. MB3 on the K-component in the K-tree whose junction you would like to delete.

  2. Select Delete. You will be asked if you would like to delete the junction.


Running the Simulation

Once the machine tool, its related objects and the machine tool driver are prepared, you are ready to use it while defining machining operations. The following are the steps needed to machine a part:

  1. Load the machine tool manually or from a template.

  2. Mount parts and fixtures. The part(s) and fixtures can be instanced into the CAM part file and placed on the machine tool using standard assembly tools. If needed, you can also place the blank on the machine.

  3. Add parts and fixtures to the kinematics model (see Creating a Kinematics Model). These must be added to the kinematics tree using the Machine Tool Configurator (MTC). The MTC is the same as the Machine Tool Builder but accessed in a CAM session. It can be activated from the Tools menu without leaving the CAM application and allows editing the kinematics model of the machine retrieved into the setup in step one.

  4. Define manufacturing operations as you normally would. No simulation-specific activities have to be considered here.

  5. Run the simulation by opening the Simulation Control Panel (menu bar -> Tools -> Machine Tool Simulation).

  • using the Simulation Control Panel

  • configuring the simulation

  • configuring the collision checker

  • configuring the display


Loading the Machine Tool

To load a machine tool into a new CAM part:

  1. create a new part

  2. initialize your CAM session

  3. double click on the GENERIC_MACHINE shown in the machine tool view

  4. select Replace Machine from the dialog

  5. select the type of machine you wish to load from the Library Class Selection

  6. select the desired machine from the Search Result Dialog

  7. accept the GENERIC_MACHINE dialog with OK

For more information about steps 4-6 see Unigraphics Online Help -> Manufacturing General ->Common Operations Options -> UG/Library

If the machine does not immediately appear in the graphics window, use the fit [image] icon.

The assembly model of the machine has now been added as an assembly component to the CAM part and the kinematics model of the machine has been copied into the CAM part. This model can be viewed and edited in the Machine Tool Configurator.


The NC Controller Dialog

The Simulation Control Panel

This is your virtual machine control panel. It relays the actions taking place in the graphics window. In the future, many of the items appearing in the Simulation Control Panel will be able to be customized. You will do this by editing the Machine Tool Driver.

This dialog is customizable to reflect your NC controller.

Simulation Controller Panel Options

Active Tool

This field informs you which tool is currently in use in the simulation.

Speed

In this field, the speed of the tool movement is shown for each tool movement.

Feed

For each tool movement the feed is shown in this field.

Coolant

This shows the type and status of the coolant.

Position

In this field you may select whether the position of the tool tip with respect to the CAM machine coordinate system (MCS) or the axis position with respect to the axis coordinate system (XCS) is shown in the subsequent coordinate fields. Depending upon whether you choose tool or axis, the coordinates shown will change to X, Y, Z, I, J, K, or X, Y, Z, B, C respectively.

X, Y, Z, I, J, K / X, Y, Z, SP, B

These show the positions of either the tool tip with respect to the CAM machine coordinate system (MCS) or the axis position with respect to the axis coordinate system (XCS), depending on which you choose in the position field above. If you choose tool, the coordinates shown are X, Y, Z, I, J, K and are in relation to the MCS.

NC Program

This field shows the NC code as the postprocessor feeds it to the simulation. By selecting an NC code line, the graphics window displays the state of the machine tool when this line was generated.

Message Window

This section shows messages generated from the S&V engine. These messages can be information, warnings or error messages from the S&V engine. If you select a message, the graphics window displays the state of the machine tool when this message was produced.

Step By

There are three modes by which you can step through the simulation:

  • single NC block - stops after each individual NC block (for example: G01, G02, G03, M6...)

  • single step - stops at every SIM_step command generated by the machine tool driver. Usually this is after every linear or circular motion. A single NC block can be subdivided into one or more single steps.

  • event - a display event is generated at each length or angular increment during single steps. Displaying by event causes the simulation to stop at each of these display events. Stepping by this mode, therefore, causes the most stops in the simulation.

In the Step by Event mode, each display event is shown only if the Animated Speed slider is set to 1.

Animated based on Machine Time

If this toggle is selected, the speed of the simulation is based on the real time each motion takes on the machine. Otherwise, all motions will be simulated using the same speed, regardless of whether they are cutting or rapid motions.

This toggle determines the way the Animation Speed scale is interpreted.

Animated Speed Slider

This determines how many display events are generated for a motion. If the slider is at 1, a display event is generated for each length increment. If the slider is at 10, display events are only generated for the start and end point.

This affects only the display. This does not have any effect on verification processors like collision or gouging accuracy.

Machine Time

This shows the time the real machine would need to process the operations up to the current state.

Configure

This feature allows you to configure various aspects of the simulation.

Reset

Use this button to return to the beginning of the simulation and return all the fields to their original values. This function does not reset the configuration settings.

This button takes you to the previous operation.

This button causes the simulation to play backwards.

This button causes the simulation to move one step backward.

This button causes the simulation to move one step forward.

This button causes the simulation to play forward.

This button causes the simulation to jump to the next operation.


Initializing from a Template

It is possible to speed up the preparation of a machining session by loading a template part. This template is created by performing the first three steps of a CAM setup (loading the machine, mounting parts and fixtures and adding these fixtures to the kinematics model) and saving them as a template part. The workpieces will be saved in this template as dummy parts which are flagged as such ("target") in the assembly component attributes. The machine and the fixtures have to be flagged as a resource. If such a setup template is used in the CAM part, the dummy parts will automatically be replaced by the actual part to be machined and the fixture mating conditions are also adapted automatically.


Configuring the Simulation

You may configure the various processors within the simulation using the Configure Simulation dialog. This dialog may be found as follows:

Tools -> Machine Tool Simulation (operations to simulate must be highlighted in Operation Navigator) -> Configure button

The individual options to configure the simulation are as follows:

Configure Simulation Dialog

Gouge Checker

Not yet implemented

Collision Checker

The Collision Checker checks for any unwanted contacts during the simulation. It takes into consideration any components listed in the configuration.

Display

Here you can configure various display parameters influencing the size of steps taken by the simulation and the method of curve interpolation.

IPW Resolution

(not yet implemented)

Here you may select the resolution of the In-Process workpiece. Available resolutions are:

  • None - Does not generate an IPW.

  • Fast - This is the lowest resolution. It will generate a coarse IPW which is calculated quickly and does not use much memory.

  • Normal - This is a medium resolution. It takes longer to calculate and requires more memory than Fast but the resulting IPW contains more detail.

  • Fine - This is the highest available resolution. This selection will take the longest time to calculate and consumes the most memory. On the other hand, the IPW is displayed in great detail.

Selecting an IPW resolution other than None will automatically activate the IPW processor even if the gouge and collision check processors are not selected.

Display IPW

to be completed

Delete

to be completed

History Buffer Size

Simulate Machine Time

Animation Speed

If Simulate Machine Time is activated, this scale defines a multiplier for the time each motion will take. The higher the scale value, the lesser the multiplier, allowing the animation speed to vary but keeping the time relationship between motions, for example, cutting and rapid motions.

If Simulate Machine Time is not selected then this scale controls the density of the displayed interpolated steps. The higher the selected value, the lesser the density. A scale setting of 10 results in display of components at end points only while scale 1 animates all interpolated steps.

This affects only the display. This doesn't have any effect on verification processors like collision or gouging accuracy.


Configuring the Collision Checker

The Collision Check configuration dialog assists in the configuration of the collision check processor. The collision processor takes pairs of components and/or classes and checks these pairs for collision. You can select any component, user class or predefined class found in your kinematics model. The collision check configuration dialog contains the following items:

Collision Configuration Dialog

Selection Steps

These icons take you through the steps in selecting the object pairs to be taken into consideration for collision checking. When you click on the first icon, the cue line prompts you to select an object for collision checking. This may be done

  • by using the Filter and Name buttons below

  • by selecting an item in the graphics window using MB1

  • if the Machine Tool Configurator is open, by clicking on the desired element in the K-tree.

To select the second element of the pair, first click on the second icon then select as with the first element. You complete the selection by using the Apply button.

Filter

To assist your selection of elements in the simulation, you may apply a filter permitting you to select only components or only classes. The classes are the classes that you assigned in the Machine Tool Builder.

Name

This shows a list of names of components or classes. If the filter is set to component this option menu shows a list of all the components of this machine; if the filter setting is “class” all system and user defined classes are shown.

If filter is set to component, selecting the name of a component from the option menu also highlights the component in the graphics window. Picking a component in the graphics window will also show the name of the selected component in the option menu.

If filter is set to class, selecting the name of a class from the option menu also highlights all components of this class in the graphics window. You cannot pick a component in the graphics window while the filter is set to class as a single component can be a member of more than one class.

Collision Clearance

This value represents the amount below which a collision will be indicated. This value is in the same units as your part.

Listbox showing Object 1, Object 2 and Clearance

This list shows the defined collision pairs. Object1 and Object 2 show the names of the components. If one of the members of a pair is a class then the name is preceded by the keyword class.

Each pair can be either active or inactive. An active state is shown by a small checkmark. Double clicking on a collision pair in this list switches the state of this pair. The collision clearance you assigned each pair also appears in this listbox.

Remove

You may remove a pair of elements from your collision check by highlighting the pair in the listbox above and selecting remove.

Stop on Collision

If you check this option, the simulation will stop if it finds a collision.

To change the clearance value for a pair, select the pair in the list of collision pairs, type in the new value in collision clearance and select the Apply button.


Configuring the Display

Here you can configure the number and type of steps taken in the simulation. After each step, the simulation recalculates all pertinent factors (e.g., collision checking, display). The options are as follows:

Display Configuration Dialog

Interpolation Mode

If this box is checked, additional steps are inserted between endpoints in the simulation. This is helpful if you would like a more detailed representation of the machine tool motions. You may configure the size of the steps to be interpolated as follows:

  • Length Increment - This indicates the distance from one step to the next in straight movements. The default value for this is 1 mm or 0.04 inches, depending on the units of your part.

  • Angular Increment - This indicates the step size of movements around an arc. The default value is 0.5 degrees.

Introducing interpolation points affects collision checking. The simulation checks for collision at the endpoints as well as at any interpolated points.

Cordal Tolerance

The cording tolerance refers to the distance between an arc and the cord between them. The smaller the cording tolerance, the more steps will be taken in the simulation. The default value for this option is 0.01 mm or 0.0004 inches, depending on the units of your part.

X = cording tolerance

History Buffer Size

The History Buffer Size allows you to specify the size of buffer, which stores the last recently simulated S&V events. When stepping or replaying backward, the events are taken from this buffer until you start stepping or playing forward again, or until all stored events are read from the buffer.

Write messages to listing device

If you activate this option, the system sends simulation information to an information window during the simulation and you can then process the information as needed (for example, save it, e-mail it, print it).


Terminology

Assembly Model

The assembly part that defines the geometry of a mechanical device.

CEvent

A CEvent is a MOM-Post event generated by the event generator based on the tool path events.

Check Object

This is a geometric object that is used for collision check (except the tool itself). Check object can be one of the following: IPW model, stock model (if IPW doesn’t exist), any geometric object associated with machine tool entity (e.g., machine device and fixtures) and check geometry (solid or face) defined in an operation or inherited from its parent object.

Collision Check

A process by which the system determines whether two check objects or tool object and check object violate the minimum allowed distance during cutting and non-cutting motions. During cutting motions the tool objects consist of the non-cutting portion of the cutting tool and its attachments while during non-cutting motions the tool objects consist of the entire tool and its attachments.

G-code

G-code is the NC controller dependent program in the post-processed format. This NC program can be the one which is generated by the MOM-Post as well as NC program coming from an external source.

Geometric Model

See assembly model

Gouge Check

A process by which the system determines interference during cutting motions between the cutting portion of the tool and the part geometry.

In-Process Workpiece(IPW)

This represents the state of the workpiece during the machining process. The in-process workpiece is also referred to as the in-process part.

Junction

A junction is a classified and named coordinate system. The coordinate system is defined in respect to the absolute coordinate system of the device model part.

A junction is a persistent object and associated with a K-component. It can be referenced by the machine tool driver for re(mounting) K-components or coordinate transformation. Junctions are also used for NC-Axis definitions.

Kinematics Component (K-Component)

A kinematics component or simply K-component is a node in the kinematics tree of a Mechanical Device. A K-component represents a mechanical feature. The K-component is a rigid body that references assembly components which constitute the geometry of the K-Component. This is restricted to assembly components only. A K-component also has links to other K-components to establish parent-child relationships.

Kinematics Model

This is a model attached to a mechanical device that defines its kinematics behavior. It describes the dependencies between components and their linear and angular degrees of freedom. The kinematics model can be created with the Machine Tool Builder application.

Kinematics Tree(K-Tree)

The kinematics tree or simply K-tree is a tree-like structure that defines the relationships and dependencies between the K-components. The K-tree represents the kinematics model of a mechanical device. The parent child relationship affects the motion behavior of the K-components during animation in the following sense: the motion of a child is the resulting motion of the parent and the child itself (overlay).

Machine Tool Builder(MTB)

A Machine Tool Builder is a new application to build, modify and test a kinematics model.

Machine Tool Configurator(MTC)

The Machine Tool Configurator is the machine tool builder that is used inside the CAM application to define and edit kinematics components for part, workpiece, fixtures and other process-specific kinematics modifications.

Machine Tool Driver(MTD)

The Machine Tool Driver is the UG/Post event handler that contains not only the program to generate the NC program but also the virtual NC controller program to control the machine tool simulation. The MTD also allows hooking up a CNC plug-in which emulates the real NC controller.

Mechanical Device Model

A mechanical device model is the assembly model plus the kinematics model of a mechanical device such as a machine tool or machine devices. It is represented by a UG partfile.

NC-Axis

AN NC axis defines the motion that can be accomplished by a K-component relative to a parent K-component. There are two kinds of NC-axes that are currently supported: linear and rotary.

OPTIMACH

This is a European research project: OPTImized tool path generation methods for economic and collision free multi axis MACHining. The results of this project are the basis of the IS&V project. For more details, refer to the OPTIMACH web page under http://www.mech.kuleuven.ac.be/~optimach

Resource Library

This is a database that contains manufacturing components information. In UG, this information could comprise cutters, machine tools, machine heads, etc. Records have parameters such as cutter information and geometric data such as a UG part file.

S&V command

S&V commands are procedures called from the MTD. Those commands trigger S&V Events which issue messages to be processed by the simulation processors. These commands consist of high level S&V commands (TCL procedures) and basic S&V commands (C-functions).

S&V Engine

The S&V engine comprises the core part of the S&V software module. It mainly consists of the four S&V processors: display, collision check, gouge check and material removal. It generates S&V Events from the S&V commands and passes them from one processor to the next for execution.

S&V Event

An S&V event is a simulation event that passes messages to the simulation processors for further processing. The fundamental S&V Event updates the kinematics model.

S&V Processor

The S&V processor, similar to a CAM filter, is responsible for processing certain events. Unlike a CAM filter, the S&V processor processes only S&V events. A set of S&V processors are defined in the S&V engine to define the S&V engine scope.

Safe Clearance

An additional value added to the stock model. This is to ensure that the non-cutting portion of the tool assembly maintains a specific distance from the stock model. Safe clearance does not apply to the part geometry, since any violation by more than the appropriate tolerance value is a gouge.

Stock Model

A uniform part stock overridden by customized stocks on faces define the target part geometry. This model of stocks is considered in gouging and collision checks.

Tool Assembly

This is an assembly model that represents the cutting tool and its attachments.

OSACA

OSACA is a European initiative to define vendor-neutral and open controller architecture. OSACA stands for Open System Architecture for Controls within Automation systems.

UG/Post

This is a UG/CAM module that is responsible for defining and executing the TCL program used to create the NC program output. This output depends on the controller and machine tool in use.

Virtual NC Controller(VNC)

This is one of the MTD software components that control the machine tool simulation. It is an extension of the post event handler to allow specifying commands that define the NC controller-dependent motions and features.