Customizing Tool Path Computation on Axial Operations

Machining	NC Review	Customizing Tool Path Computation on Axial Operations Implementing the CATIMfgComputeToolPathCustom interface
Use Case

Abstract

This article discusses the CAAMaiToolPathCustomization use case and explains how to implement the CATIMfgComputeToolPathCustom manufacturing interface.

What You Will Learn With This Use Case
The CAAMaiToolPathCustomization Use Case
Step-by-Step
In Short
References

What You Will Learn With This Use Case

This use case is intended to help you customize the tool path computation of a prismatic machining activity, namely an axial operation, by implementing the CATIMfgComputeToolPathCustom manufacturing interface. This involves the following:

Creating an extension class to implement CATIMfgComputeToolPathCustom for an axial operation, here a drilling operation
Implementing the ComputeToolPath method of CATIMfgComputeToolPathCustom to:
- Read the manufacturing activity parameters,
- Read the tool parameters
- Create a tool path.

[Top]

The CAAMaiToolPathCustomization Use Case

CAAMaiToolPathCustomization is a use case of the CAAManufacturingItf.edu framework that illustrates ManufacturingInterfaces framework capabilities.

[Top]

What Does CAAMaiToolPathCustomization Do

CAAMaiToolPathCustomization runs with the Process document shown on Fig.1 that contains the Drilling operation to use, the part to be machined, and the tool to use. The Drilling operation is accessible from the ProcessList, the part is in the ProductList, and the tool is stored in the ResourcesList. The five holes of the part are machined. The use case computes the tool path to enable the end user to replay the drilling operation.

Fig. 1: The customized tool path of a drilling operation

[Top]

How to Launch CAAMaiToolPathCustomization

To launch CAAMaiToolPathCustomization, you will need to:

Set up the build time environment, then compile CAAMaiToolPathCustomization.m module along with its prerequisites [1]

Edit the interface dictionary, that is, the CAAManufacturingItf.edu.dico file located in:

Windows	`InstallRootDirectory\CAADoc\CAAManufacturingItf.edu\CNext\code\dictionary\`
Unix	`InstallRootDirectory/CAADoc/CAAManufacturingItf.edu/CNext/code/dictionary/`

where InstallRootDirectory is the directory where the CAA CD-ROM is installed, and decomment the following line by removing the '#' character:

Drilling CATIMfgComputeToolPathCustom libCAAMaiToolPathCustomization

Set up the run time environment
Launch a CATIA V5 session

Open the CAAMaiToolPathCustomization.CATPart file located in:

Windows	`InstallRootDirectory\CAADoc\CAAManufacturingItf.edu\CNext\resources\graphic\`
Unix	`InstallRootDirectory/CAADoc/CAAManufacturingItf.edu/CNext/resources/graphic/`

Using the Start menu, select the Prismatic Machining workbench in NC Manufacturing

This displays the PPR document:
In the PPR Tree, select Manufacturing Program.1 and create a Drilling operation using the Drilling command in the Insert->Prismatic Operations->Drilling Operations.
The following dialog box appears:

Note: at this step, the Drilling operation is not completed. The icon in the second tab page shows a red traffic light. The Replay push button is grayed. You have to select the geometry to machine.
In the sensitive icon, select the orange hole plane, and select the hole plane in the Process document. The hole plane becomes green in the Process document 3D view and in the sensitive icon
In the sensitive icon, select hole extension type to set it as Through, select the red hole depth, and select one of the holes in the Process document. Double click to exit
Now the Drilling operation is completed. You can replay it by clicking on the Replay push button in the Drilling operation dialog box.
Replay the tool path using the push buttons in the Drilling.1 dialog box

[Top]

Where to Find the CAAMaiToolPathCustomization Code

The CAAMaiToolPathCustomization use case is made of a class named CAAEMaiToolPathDrillingCustomization located in the CAAMaiToolPathCustomization.m module of the CAAManufacturingItf.edu framework:

Windows	`InstallRootDirectory\CAADoc\CAAManufacturingItf.edu\CAAMaiToolPathCustomization.m`
Unix	`InstallRootDirectory/CAADoc/CAAManufacturingItf.edu/CAAMaiToolPathCustomization.m`

where InstallRootDirectory is the directory where the CAA CD-ROM is installed.

[Top]

Step-by-Step

There are four logical steps in CAAMaiToolPathCustomization:

Creating an Extension Class to Implement CATIMfgComputeToolPathCustom for an Axial Operation
Reading the Manufacturing Activity Parameters
Reading the Tool Parameters
Creating a Tool Path

We now comment each of those sections by looking at the code.

[Top]

Creating an Extension Class to Implement CATIMfgComputeToolPathCustom for an Axial Operation

The extension class that will implement CATIMfgComputeToolPathCustom is named CAAEMaiToolPathDrillingCustomization. Creating this class is done is three sub steps:

Create the CAAEMaiToolPathDrillingCustomization class header file:

// Infrastructure interfaces
#include "CATBaseUnknown.h"
#include "CATIContainer.h"

// Manufacturing Interfaces
#include "CATIMfgToolPath.h"

class CAAEMaiToolPathDrillingCustomization : public CATBaseUnknown
{
  // Used in conjonction with CATImplementClass in the .cpp file
	CATDeclareClass;
  
public:
    CAAEMaiToolPathDrillingCustomization();
    virtual ~CAAEMaiToolPathDrillingCustomization();
 
    // ComputeToolPath
	//================
	// Compute the tool path of the current Drilling operation
	//
	//  ispContainer : Interface on the tool path container
	//  ospToolPath  : Computed tool path
	virtual HRESULT ComputeToolPath(const CATIContainer_var   &ispContainer,
                                          CATIMfgToolPath_var &ospToolPath);
  private:

    // Copy constructor, not implemented
    // Set as private to prevent from compiler automatic creation as public.
    CAAEMaiToolPathDrillingCustomization
		(const CAAEMaiToolPathDrillingCustomization &iObjectToCopy);
 
    // Assignment operator, not implemented
    // Set as private to prevent from compiler automatic creation as public.
    CAAEMaiToolPathDrillingCustomization & operator  = 
		(const CAAEMaiToolPathDrillingCustomization &iObjectToCopy);
 
};

The CAAEMaiToolPathDrillingCustomization class C++-derives from CATBaseUnknown. The CATDeclareClass macro declares that the class CAAEMaiToolPathDrillingCustomization belongs to a component. The class has a constructor, a destructor, and the ComputeToolPath method of CATIMfgComputeToolPathCustom, and a copy constructor. Note that the copy constructor is set as private. This is very important for extensions. Since extensions must never be directly instantiated by client applications, this prevents the compiler from creating the copy constructor as public without you know. This copy constructor is not implemented in the source file.

Create the CAAEMaiToolPathDrillingCustomization class source file. It begins as follows:

...
#include "TIE_CATIMfgComputeToolPathCustom.h"
TIE_CATIMfgComputeToolPathCustom(CAAEMaiToolPathDrillingCustomization);
CATImplementClass(CAAEMaiToolPathDrillingCustomization,
                  DataExtension,
                  CATBaseUnknown,
                  Drilling);
...
HRESULT CAAEMaiToolPathDrillingCustomization::ComputeToolPath(const CATIContainer_var   &spContainer,
					   		  CATIMfgToolPath_var &spToolPath)
{
  HRESULT RC = E_FAIL;
  ...

The CAAEMaiToolPathDrillingCustomization class states that it implements the CATIMfgComputeToolPathCustom interface thanks to the TIE_CATIMfgComputeToolPathCustom macro. The CATImplementClass macro declares that the CAAEMaiToolPathDrillingCustomization class is data extension class, thanks to the DataExtension keyword, and that it extends the feature whose type is Drilling. The third parameter must always be set to CATBaseUnknown, makes no sense, and is unused for extensions.

Extending the Drilling feature using the CAAEMaiToolPathDrillingCustomization class that implements CATIMfgComputeToolPathCustom means fitting this feature with your customized behavior for drilling which will replace the default one. The ComputeToolPath method implementation is shown in the next steps. It has a smart pointer to the Process document manufacturing container as input parameter, and a smart pointer to the created tool path as output parameter.

Update the dictionary

Update the interface dictionary, that is a file named, for example in this case, CAAManufacturingItf.edu.dico, whose directory's pathname is concatenated at run time in the CATDictionaryPath environment variable, and containing the following declaration to state that the Drilling feature implements the CATIMfgComputeToolPathCustom interface, and whose code is located in the libCAAMaiToolPathCustomization shared library or DLL. Pay attention to remove the comment (#) in the supplied dictionary.

Drilling CATIMfgComputeToolPathCustom libCAAMaiToolPathCustomization

The CAAManufacturingItf.edu.dico file is located in:

Windows InstallRootDirectory\CAADoc\CAAManufacturingItf.edu\CNext\code\dictionary\

Unix InstallRootDirectory/CAADoc/CAAManufacturingItf.edu/Cnext/code/dictionary/

[Top]

Reading the Manufacturing Activity Parameters

The Manufacturing Activity parameters are:

The tip approach clearance
The tip depth mode
The machining tool axis
The hole depth
The pattern.

The Manufacturing Activity parameters are retrieved as follows:

  ...
  CATIMfgAxialOperation *piAxialOperationOnDrilling = NULL;
  RC = QueryInterface(IID_CATIMfgAxialOperation,(void**) &piAxialOperationOnDrilling);  
  if (FAILED(RC))
    return RC;
  
  CATUnicodeString depthMode;
  CATMathVector machiningToolAxis(0,0,0);
  double clearTipValue = .0;
  double depthValue = .0;
  
  // -1.1-b Read Tip Approach Clearance 2nd Solution
  RC = piAxialOperationOnDrilling->GetClearTip(clearTipValue);
  if (SUCCEEDED(RC))    
  {
	  // -1.2- Read Tip Depth Mode : by Tip, by Shoulder, by Diameter
	  RC = piAxialOperationOnDrilling->GetDepthComputationMode(depthMode); 
	  if (SUCCEEDED(RC))      
	  {        // -1.3- Read the Machining Tool Axis
		  RC = piAxialOperationOnDrilling->GetOperationAxis(machiningToolAxis);
		  if (SUCCEEDED(RC))        
		  {          
			  // -1.4- Read the hole Depth 
			  RC = piAxialOperationOnDrilling->GetFeatureDepth(depthValue);
		  }
		  
	  }   
	  
  }
  
  piAxialOperationOnDrilling->Release();
  piAxialOperationOnDrilling = NULL;
  if (FAILED(RC))   
	  return RC;  

  }
  ...

To get all the activity parameters, use the methods of the CATIMfgAxialOperation interface that the Drilling feature already implements.

The pattern data is read as follows:

  ...
  // -1.5- Read Pattern Information
  CATMathSetOfPoints pointsInPattern; // Points in the pattern
  CATListOfDouble    entryDistances;  // Entry distances associated with the points
  CATListOfDouble    exitDistances;   // Exit distances associated with the points
  int                nbOfPts = 0;     // Number of points in the pattern 
  
  CATIMfgAxialToolPathGeneratorBase * piAxialTPGenBaseOnDrilling = NULL;
  RC = QueryInterface(IID_CATIMfgAxialToolPathGeneratorBase, 
	  (void**) &piAxialTPGenBaseOnDrilling);
  if (SUCCEEDED(RC)) 
  {
      piAxialTPGenBaseOnDrilling->GetOperationPattern(pointsInPattern, 
		  entryDistances, exitDistances, nbOfPts);
      piAxialTPGenBaseOnDrilling->Release();    
      piAxialTPGenBaseOnDrilling = NULL;
  }  
  else    
      return RC;
  ...

The GetOperationPattern method of the CATIMfgAxialToolPathGeneratorBase interface implemented by the Drilling feature enables you to retrieve the pattern as a set of points. This interface provides additional methods dedicated to axial tool path computation.

[Top]

Reading the Tool Parameters

The tool parameters are read as follows:

  ...
  //********************************************************************************************
  // -2- Reading Tool Parameters 
  //********************************************************************************************
  CATIMfgActivity_var spActivity(this);
  if (NULL_var == spActivity) 
      return E_FAIL;
  
  CATBaseUnknown_var spUnknownOnTool;
  spUnknownOnTool = spActivity->GetTool();  
  if (NULL_var == spUnknownOnTool)
      return E_FAIL;  
  
  CATIMfgTool * piToolOnTool = NULL;
  RC = spUnknownOnTool->QueryInterface(IID_CATIMfgTool, (void**) & piToolOnTool);
  if (FAILED(RC))
      return E_FAIL;  
  
  // -3.1- Tool Diameter
  double toolDiamValue = .0;
  RC = piToolOnTool->GetValue(MfgNominalDiameter, toolDiamValue);
  
  // -3.2- Way Of Rotation  
  CATUnicodeString wayOfRotation;  
  if (SUCCEEDED(RC))
      RC = piToolOnTool->GetValue(MfgWayOfRotation, wayOfRotation);
  
  piToolOnTool->Release();  
  piToolOnTool = NULL;  
  if (FAILED(RC))    
      return RC;
  ...

The activity is retrieved as a smart pointer to CATIMfgActivity, and will be used to retrieve the tool and to initialize the tool path. The tool is retrieved from the activity thanks to the GetTool method of CATIMfgActivity, as a smart pointer to CATBaseUnknown. To get the tool parameter, a pointer to CATIMfgTool must first be retrieved from the tool. The GetValue method of CATIMfgTool enables you to retrieve the tool diameter thanks to the keyword MfgNominalDiameter, and its way of rotation thanks to the keyword MfgWayOfRotation.

Note that the keywords are defined in the CATMfgToolConstant.h file.

[Top]

Creating a Tool Path

...
  CATIMfgToolPathFactory *piToolPathFactoryOnContainer = NULL;
  RC= spContainer->QueryInterface(IID_CATIMfgToolPathFactory,
	  (void**) &piToolPathFactoryOnContainer);
  if (FAILED (RC)) return E_FAIL;
  
  //==============================
  // Creation of tool path element
  //==============================
  CATIMfgCompoundTraject_var spCompoundTraject = 
	  piToolPathFactoryOnContainer->CreateMfgCompoundTraject();
  if (NULL_var == spCompoundTraject) return E_FAIL;
  CATIMfgToolPathComponents_var spToolPathComponentsOnCompound(spCompoundTraject); 
  if (NULL_var == spToolPathComponentsOnCompound) return E_FAIL;

  //=============================================================================
  // Initialization of tool path from activity (copy of feedrates, spindle, ....)
  //=============================================================================
  spCompoundTraject->Init(spActivity);

  //=========================================
  // Initialization of tool axis on tool path
  //=========================================
  CATIMfgToolPathConstantToolAxis_var spToolAxis = 
	  piToolPathFactoryOnContainer->CreateMfgToolPathConstantToolAxis(machiningToolAxis);
  if (NULL_var == spToolAxis) return E_FAIL;
  spCompoundTraject->SetToolAxis(spToolAxis);
  //==================================================================================
  // Creation of the objet dedicated to the description of motions
  // This objet is linked to the tool path
  //
  // In the sample,only linear motions are described
  // Note that it is also possible to describe circular motions and PP Instructions
  // PP Instructions are described through NC_Commands and NC_Instructions of PP Table
  //==================================================================================
  CATIMfgTPMultipleMotion_var spMultipleMotion = 
	  piToolPathFactoryOnContainer->CreateMfgTPMultipleMotion();
  if (NULL_var == spMultipleMotion) return E_FAIL;
  spToolPathComponentsOnCompound->AddElement(spMultipleMotion);
  //==============================
  // Description of linear motions
  //==============================
  CATMathPoint previousClearPoint;
  for (int I = 1; I<=nbOfPts; I++)      
  {
	  CATListOfDouble X,Y,Z;
	  CATMathPoint point = pointsInPattern.GetPoint(I-1);
	  CATMathPoint clearPoint = point + machiningToolAxis * clearTipValue;
	  CATMathPoint depthPoint = point - machiningToolAxis * depthValue;
	  //=======================================================
	  // Linking traject in rapid feedrate between clear points
	  //=======================================================
	  if (I>1)
	  {
		  CATListOfDouble X2,Y2,Z2;
		  X2.Append (previousClearPoint.GetX()); 
		  Y2.Append (previousClearPoint.GetY()); 
		  Z2.Append (previousClearPoint.GetZ());
		  X2.Append (clearPoint.GetX()); 
		  Y2.Append (clearPoint.GetY()); 
		  Z2.Append (clearPoint.GetZ());
		  spMultipleMotion->AddPolyline (TPLinkingTraject,TPRapidFeedrate,X2,Y2,Z2);
	  }
	  //======================================
	  // Machining Traject to machine the hole
	  //======================================
	  X.Append (clearPoint.GetX()); 
	  Y.Append (clearPoint.GetY()); 
	  Z.Append (clearPoint.GetZ());
	  X.Append (depthPoint.GetX()); 
	  Y.Append (depthPoint.GetY()); 
	  Z.Append (depthPoint.GetZ());
	  X.Append (clearPoint.GetX()); 
	  Y.Append (clearPoint.GetY()); 
	  Z.Append (clearPoint.GetZ());
	  spMultipleMotion->AddPolyline (TPMachiningTraject,TPMachiningFeedrate,X,Y,Z);

	  previousClearPoint = clearPoint;
  }

  //========================
  // Save tool path in model
  //========================
  CATIMfgTPSaveData_var spSaveData (spToolPathComponentsOnCompound);
  if (NULL_var == spSaveData) return E_FAIL;
  spSaveData->SaveData();

  //=======
  // Return
  //=======
  ospToolPath = spToolPathComponentsOnCompound;
  if (NULL_var == ospToolPath) return E_FAIL;
  
  piToolPathFactoryOnContainer->Release();
  piToolPathFactoryOnContainer = NULL;
  
  return RC;
}

The tool path is created and returned as a CATIMfgCompoundTraject smart pointer using the CreateMfgCompoundTraject method of the CATIMfgToolPathFactory interface implemented by the Process document manufacturing container passed as input parameter. Then, a smart pointer to CATIMfgToolPathComponents is retrieved from the tool path and the tool path is initialized from the activity using the Init method of CATIMfgCompoundTraject. The tool axis is created thanks to the CreateMfgToolPathConstantToolAxis method of CATIMfgToolPathFactory to which the machining tool axis retrieved in the data reading step is passed. This tool axis is set to the tool path using the SetToolAxis method of CATIMfgCompoundTraject.

The tool path data can now be created from the pattern. First, a set of points is created and filled in, for each point in the pattern, with:

a clearance point, used at the beginning and at the end of each machining sequence
a depth point that represents the drilling depth.

The CreateMfgTPMultipleMotion method of CATIMfgToolPathFactory creates the object which contains the motions (linear or circular motion) and PP Instructions (NC_Command). This object is added to the tool path thanks to the AddElement method of CATIMfgToolPathComponents.

In this sample, two linear motions are stored for each point of the pattern :

If there are at least two points in the pattern, a linking path (TPLinkingTraject) in rapid feedrate (TPRapidFeedrate) between the previous hole to the current one.
a machining path (TPMachiningTraject) in machining feedrate (TPMachiningFeedrate) to machine the current point.

With interface CATIMfgTPSaveData on tool path, the tool path is saved in the model with the method SaveData.

Then, the tool path is passed to the output parameter as a pointer to CATIMfgToolPath.

Note that the keywords such as TPMachiningFeedrate, TPMachiningTraject, used for tool path computation are located in the CATMfgToolPathDefs.h file.

[Top]

In Short

This article provides an example on how to use the manufacturing interface classes, and has illustrated them on a axial tool path customization. It shows how to implement the CATIMfgComputeToolPath interface to compute the tool path of a drilling operation in a process document that includes this operation as an activity, and that also include the part to be machined, and the tool resources.

The Drilling feature behavior is modified by implementing CATIMfgComputeToolPath in a data extension class. The only method to implement is ComputeToolPath, to successively retrieve the manufacturing parameters from the activity thanks to methods of either the CATIMfgActivityParameters interface, or to the CATIMfgAxialOperation interface, both implemented by the Drilling feature. The pattern is retrieved thanks to the CATIMfgAxialToolPathGeneratorBase interface also implemented by the Drilling feature, and the tool parameters are retrieved using the CATIMfgTool interface.

The tool path is created and handled as a CATIMfgCompoundTraject pointer using the CreateMfgCompoundTraject method of the CATIMfgToolPathFactory interface implemented by the Process document manufacturing container. The tool axis, and the object that makes up the tool path created from the pattern as a CATIMfgTPMultipleMotion, are set or added to the tool path handled as a CATIMfgToolPathComponents. Then, the tool path is passed to the output parameter as a pointer to CATIMfgToolPath.

[Top]

References

[1]	Building and Launching a CAA V5 Use Case
[2]	Process Modeler Home Page
[Top]

History

Version: 1 [Sep 2000]	Document created
[Top]

Machining

NC Review