ippToolChanger.h

Go to the documentation of this file.

// 
// DISCLAIMER: 
//  This software was produced by the National Institute of Standards 
//  and Technology (NIST), an agency of the U.S. government, and by statute is 
//  not subject to copyright in the United States.  Recipients of this 
//  software assume all responsibility associated with its operation,
//  modification,maintenance, and subsequent redistribution. 
//
//  See NIST Administration Manual 4.09.07 b and Appendix I. 


/* ToolChanger class

See pages 53-58 of the spec.

There is currently no data giving the location of a tool. It
may be useful to add this (either to ToolChanger or to KTool).

The NoTool tool is (1) active when there is definitely no tool
currently being held and (2) what FoundTool returns when the tool last
sought by FindTool was not found. The UnDefTool is active when the
system does not know whether or not a tool is being held.

It is not clear how the BaseTool (15-word description) and the RefTool
(5-word description) should be handled.  They are mentioned only on
pages 53 and 56 the spec. It is not clear how the BaseTool differs
from the NoTool.

The "tools" data member is modeled as a vector of pointers to KTool
because when it was modeled as a vector of KTool, adding tools had to
be done by push_back(*noTool) and similar statements.  But that makes
a copy of noTool and then adds a pointer to the copy. Then findTool
finds the copy and it is not equal to noTool, so equality tests
fail. C++ strikes again.

The checkIn ippTargetVector gives the location in machine coordinates
(assuming there is no tool) to which the machine will be moved (for an
automatic tool change) or must be moved (for a manual tool changer) in
order to change the tool. The default checkIn location is (0, 0, 0).
The checkIn location can be changed with setCheckIn. The checkIn can
be used to produce a response to a GetChangeToolAction command (see
pages 57-58). To be correct, the data in a GetChangeToolActionResponse
(1) must be transformed to the current coordinate system, and (2)
since the center of the ball is the position that is being controlled,
must be offset according to the tool's dimensions and angles.

The current tool has two alignment vectors of type ippTargetVector
(defined in IppCmdRes.h). These are maintained in machine coordinates
so that they do not change if the coordinate system changes. The
alignment vectors change when an AlignTool command is given (see page
70). The vectors must be transformed from the current coordinate
system to the machine coordinate system when the AlignTool command is
carried out and must be transformed from the machine coordinate system
to the current coordinate system when a response to
GetProp(Tool.Alignment()) command is made. Since only the current tool
has alignment vectors, they are properties of the ToolChanger, not of
KTool. The default alignment is (0, 0, 0).

*/
#pragma once 
#include "ippdme/ippdme.h"
class ippGoToPars;

#include "ippTargetVector.h"
#include "ippKTool.h"
#include <vector>

EXPIMP_TEMPLATE template class IPPDME_EXT_CLASS std::allocator<ippKToolPtr>;
EXPIMP_TEMPLATE template class IPPDME_EXT_CLASS std::vector<ippKToolPtr>;

class IPPDME_EXT_CLASS ippToolChanger : public ippObject
{
private:
  
  ippKToolPtr _activeTool;
  ippKToolPtr _foundTool;
  ippKToolPtr _baseTool;
  ippKToolPtr _refTool;
  ippKToolPtr _noTool;
  ippKToolPtr _unDefTool;

  std::vector<ippKToolPtr> _tools; /* all the tools the toolchanger knows about */
  
  ippTargetVector  _checkIn;
  ippTargetVector  _alignment1;
  ippTargetVector  _alignment2;

public:
  
  ippToolChanger ();
   
  ~ippToolChanger ();

  ippKToolPtr getActiveTool()const  {return _activeTool;}

  const ippTargetVector& getCheckIn()const  {return _checkIn;}

  ippKToolPtr getFoundTool()const {return _foundTool;}

  ippKToolPtr getNoTool() const {return _noTool;}

  const std::vector<ippKToolPtr>& getToolList() const {return _tools;}

  ippKToolPtr getUnDefTool() const {return _unDefTool;}

  ippTargetVector& getAlignment1()  {return _alignment1;}
  ippTargetVector& getAlignment2()  {return _alignment2;}

  void setActiveTool( ippKToolPtr inTool);
  void setCheckIn(const ippTargetVector & inCheckIn);
  void setFoundTool( ippKToolPtr inTool);

  void addTool(ippKToolPtr addIt);
  ippKToolPtr removeTool(const ippKToolPtr removeIt);
  ippKToolPtr findTool(const char * name);
  

  // other internals
  void clear();

};
IPP_DECLARE_SMARTPOINTER(ippToolChanger);

---