---

canon.hh

Go to the documentation of this file.

#ifndef CANON_HH
#define CANON_HH

/*
This is the header file that all trajectory applications that use the
canonical commands for three-axis machining should include.

It is assumed in these activities that the spindle tip is always at
some location called the "current location," and the controller always
knows where that is. It is also assumed that there is always a
"selected plane" which must be the XY-plane, the YZ-plane, or the
ZX-plane of the machine.
*/

/*
  Modification history:

  23-Feb-2000  FMP added CANON_UPDATE_POSITION
*/

typedef int CANON_PLANE;
#define CANON_PLANE_XY 1
#define CANON_PLANE_YZ 2
#define CANON_PLANE_XZ 3

typedef int CANON_UNITS;
#define CANON_UNITS_INCHES 1
#define CANON_UNITS_MM 2
#define CANON_UNITS_CM 3

typedef int CANON_MOTION_MODE;
#define CANON_EXACT_STOP 1
#define CANON_EXACT_PATH 2
#define CANON_CONTINUOUS 3

typedef int CANON_SPEED_FEED_MODE;
#define CANON_SYNCHED 1
#define CANON_INDEPENDENT 2

typedef int CANON_DIRECTION;
#define CANON_STOPPED 1
#define CANON_CLOCKWISE 2
#define CANON_COUNTERCLOCKWISE 3

typedef int CANON_FEED_REFERENCE;
#define CANON_WORKPIECE 1
#define CANON_XYZ 2

typedef int CANON_AXIS;
#define CANON_AXIS_X 1
#define CANON_AXIS_Y 2
#define CANON_AXIS_Z 3
#define CANON_AXIS_A 4
#define CANON_AXIS_B 5
#define CANON_AXIS_C 6

/* Cutter comp */
#define RIGHT 1
#define LEFT 2

/* Currently using the typedefs above rather than the enums below
typedef enum {CANON_PLANE_XY, CANON_PLANE_YZ, CANON_PLANE_XZ} CANON_PLANE;
typedef enum {CANON_UNITS_INCHES, CANON_UNITS_MM, CANON_UNITS_CM} CANON_UNITS;
typedef enum {CANON_EXACT_STOP, CANON_EXACT_PATH, CANON_CONTINUOUS}
             CANON_MOTION_MODE;
typedef enum {CANON_SYNCHED, CANON_INDEPENDENT} CANON_SPEED_FEED_MODE;
typedef enum {CANON_STOPPED, CANON_CLOCKWISE, CANON_COUNTERCLOCKWISE}
             CANON_DIRECTION;
typedef enum {CANON_WORKPIECE, CANON_XYZ} CANON_FEED_REFERENCE;
typedef enum {CANON_AXIS_X, CANON_AXIS_Y, CANON_AXIS_Z, CANON_AXIS_A,
              CANON_AXIS_B, CANON_AXIS_C} CANON_AXIS;
*/

struct CANON_VECTOR
{
  CANON_VECTOR() {}
  CANON_VECTOR(double _x, double _y, double _z) {x = _x; y = _y; z = _z;}
  double x, y, z;
};

struct CANON_POSITION
{
  CANON_POSITION() {}
  CANON_POSITION(double _x, double _y, double _z,
                 double _a, double _b, double _c)
  {
    x = _x; y = _y; z = _z;
    a = _a; b = _b; c = _c;
  }
  CANON_POSITION(double _x, double _y, double _z)
  {
    x = _x; y = _y; z = _z;
    a = 0.0; b = 0.0; c = 0.0;
  }
  double x, y, z, a, b, c;
};

//  7-Nov-1997 FMP added below
/*
  Tools are numbered 1..CANON_TOOL_MAX, with tool 0 meaning no tool.
  */
#define CANON_TOOL_MAX 32       // number of tools handled
#define CANON_TOOL_ENTRY_LEN 256 // how long each file line can be

struct CANON_TOOL_TABLE
{
  int id;
  double length;
  double diameter;
};
//  7-Nov-1997 FMP added above

/* Initialization */

/* reads world model data into the canonical interface */
extern void INIT_CANON();

/* Representation */

/* Set the program origin at the point with absolute coordinates x, y, and
z. Values of x, y, and z are real numbers. The units are whatever
length units are being used at the time this command is given. */

extern void SET_ORIGIN_OFFSETS(double x, double y, double z,
                               double a=0, double b=0, double c=0);

/* Offset the origin to the point with absolute coordinates x, y, and
z.  Values of x, y, and z are real numbers. The units are whatever
length units are being used at the time this command is given. */

extern void USE_LENGTH_UNITS(CANON_UNITS u);

/* Use the specified units for length. Conceptually, the units must
be either inches or millimeters. */


extern void SELECT_PLANE(CANON_PLANE pl);

/* Use the plane designated by selected_plane as the selected plane.
Conceptually, the selected_plane must be the XY-plane, the XZ-plane, or
the YZ-plane. */

/* Free Space Motion */

extern void SET_TRAVERSE_RATE(double rate);

/* Set the traverse rate that will be used when the spindle traverses. It
is expected that no cutting will occur while a traverse move is being
made. */

extern void STRAIGHT_TRAVERSE (double x, double y, double z,
                               double a=0, double b=0, double c=0);

/*

Move at traverse rate so that at any time during the move, all axes
have covered the same proportion of their required motion. The final
XYZ position is given by x, y, and z.

*/

/* Machining Attributes */

extern void SET_FEED_RATE(double rate);

/*

SET_FEED_RATE sets the feed rate that will be used when the spindle is
told to move at the currently set feed rate. The rate is either:
1. the rate of motion of the tool tip in the workpiece coordinate system,
   which is used when the feed_reference mode is "CANON_WORKPIECE", or
2. the rate of motion of the tool tip in the XYZ axis system, ignoring
   motion of other axes, which is used when the feed_reference mode is
   "CANON_XYZ".

The units of the rate are length units (inches or millimeters
according to the setting of CANON_UNITS) per minute along the
programmed path as seen by the workpiece or the machine.

*/

extern void SET_FEED_REFERENCE(CANON_FEED_REFERENCE reference);

/*

This sets the feed_reference mode to either CANON_WORKPIECE or
CANON_XYZ. For three-axis motion, it makes no difference.

*/

extern void SET_MOTION_CONTROL_MODE(CANON_MOTION_MODE mode);
extern CANON_MOTION_MODE GET_MOTION_CONTROL_MODE();

/*

This sets the motion control mode to one of: CANON_EXACT_STOP,
CANON_EXACT_PATH, or CANON_CONTINUOUS.

*/


extern void SET_CUTTER_RADIUS_COMPENSATION(double radius);

/* Set the radius to use when performing cutter radius compensation. */

extern void START_CUTTER_RADIUS_COMPENSATION(int direction);

/* Conceptually, the direction must be left (meaning the cutter
stays to the left of the programmed path) or right. */

extern void STOP_CUTTER_RADIUS_COMPENSATION();

/* Do not apply cutter radius compensation when executing spindle
translation commands. */

extern void START_SPEED_FEED_SYNCH();
extern void STOP_SPEED_FEED_SYNCH();

/* Machining Functions */

extern void ARC_FEED(double first_end, double second_end,
                     double first_axis, double second_axis, int rotation,
                     double axis_end_point,
                     double a_position=0,
                     double b_position=0,
                     double c_position=0);

/* Move in a helical arc from the current location at the existing feed
rate. The axis of the helix is parallel to the x, y, or z axis,
according to which one is perpendicular to the selected plane. The
helical arc may degenerate to a circular arc if there is no motion
parallel to the axis of the helix.

1. If the selected plane is the xy-plane:
A. first_end is the x-coordinate of the end of the arc.
B. second_end is the y-coordinate of the end of the arc.
C. first_axis is the x-coordinate of the axis (center) of the arc.
D. second_axis is the y-coordinate of the axis.
E. axis_end_point is the z-coordinate of the end of the arc.

2. If the selected plane is the yz-plane:
A. first_end is the y-coordinate of the end of the arc.
B. second_end is the z-coordinate of the end of the arc.
C. first_axis is the y-coordinate of the axis (center) of the arc.
D. second_axis is the z-coordinate of the axis.
E. axis_end_point is the x-coordinate of the end of the arc.

3. If the selected plane is the zx-plane:
A. first_end is the z-coordinate of the end of the arc.
B. second_end is the x-coordinate of the end of the arc.
C. first_axis is the z-coordinate of the axis (center) of the arc.
D. second_axis is the x-coordinate of the axis.
E. axis_end_point is the y-coordinate of the end of the arc.

If rotation is positive, the arc is traversed counterclockwise as
viewed from the positive end of the coordinate axis perpendicular to
the currently selected plane. If rotation is negative, the arc is
traversed clockwise. If rotation is 0, first_end and second_end must
be the same as the corresponding coordinates of the current point and
no arc is made (but there may be translation parallel to the axis
perpendicular to the selected plane and motion along the rotary axes).
If rotation is 1, more than 0 but not more than 360 degrees of arc
should be made. In general, if rotation is n, the amount of rotation
in the arc should be more than ([n-1] x 360) but not more than (n x
360).

The radius of the helix is determined by the distance from the current
location to the axis of helix or by the distance from the end location
to the axis of the helix. It is recommended that the executing system
verify that the two radii are the same (within some tolerance) at the
beginning of executing this function.

*/

extern void STRAIGHT_FEED (double x, double y, double z,
                           double a=0, double b=0, double c=0);

/* Move at existing feed rate so that at any time during the move,
all axes have covered the same proportion of their required motion.
The meanings of the parameters are the same as for STRAIGHT_TRAVERSE.*/

extern void STRAIGHT_PROBE (double x, double y, double z,
                            double a=0, double b=0, double c=0);

/* Perform a probing operation. Move in a straight
line at the currently programmed feed rate from the current position
toward the programmed XYZ position. It is expected that a probe will
be in the spindle. The probe may be a touch probe or a non-contact
probe.

For a touch probe, it is expected that the probe will be tripped
before the programmed position is reached. It is an error condition
for the probe to reach that position without being tripped;
get_probe_value should return an error code if this happens. If the
probe is tripped, get_probe_value should return a success code, and
the position at which the probe was tripped should be returned by
get_probe_position.  These functions should return the same values
until after the next straight_probe function call is made. The control
should move the axes back to the trip point after the probe is
tripped. It is expected that the programmed position will be near
enough to the expected trip point that the probe can reach that
position without breaking.

For a non-contact probe, it is expected that the probe will reach the
programmed position. If it does not, get_probe_value should return
0.0, and get_probe_position should return the position at
which it stopped. If the probe does reach the progammed position,
get_probe_position should return that position, and get_probe_value
should return a numeric value (which may be 0.0).

*/

extern void STOP();

/* stop motion after current feed */

extern void DWELL(double seconds);

/* freeze x,y,z for a time */

/* Spindle Functions */

extern void SPINDLE_RETRACT_TRAVERSE();

/* Retract the spindle at traverse rate to the fully retracted position. */

extern void START_SPINDLE_CLOCKWISE();

/* Turn the spindle clockwise at the currently set speed rate. If the
spindle is already turning that way, this command has no effect. */

extern void START_SPINDLE_COUNTERCLOCKWISE();

/* Turn the spindle counterclockwise at the currently set speed rate. If
the spindle is already turning that way, this command has no effect. */

extern void SET_SPINDLE_SPEED(double r);

/* Set the spindle speed that will be used when the spindle is turning.
This is usually given in rpm and refers to the rate of spindle
rotation. If the spindle is already turning and is at a different
speed, change to the speed given with this command. */

extern void STOP_SPINDLE_TURNING();

/* Stop the spindle from turning. If the spindle is already stopped, this
command may be given, but it will have no effect. */

extern void SPINDLE_RETRACT();
extern void ORIENT_SPINDLE(double orientation, CANON_DIRECTION direction);
extern void LOCK_SPINDLE_Z();
extern void USE_SPINDLE_FORCE();
extern void USE_NO_SPINDLE_FORCE();

/* Tool Functions */
extern void USE_TOOL_LENGTH_OFFSET(double length);

extern void CHANGE_TOOL(int slot); /* slot is slot number */

/* It is assumed that each cutting tool in the machine is assigned to a
slot (intended to correspond to a slot number in a tool carousel).
This command results in the tool currently in the spindle (if any)
being returned to its slot, and the tool from the slot designated by
slot_number (if any) being inserted in the spindle.

If there is no tool in the slot designated by the slot argument, there
will be no tool in the spindle after this command is executed and no
error condition will result in the controller. Similarly, if there is
no tool in the spindle when this command is given, no tool will be
returned to the carousel and no error condition will result in the
controller, whether or not a tool was previously selected in the
program.

It is expected that when the machine tool controller is initialized,
the designated slot for a tool already in the spindle will be
established. This may be done in any manner deemed fit, including
(for, example) recording that information in a persistent, crash-proof
location so it is always available from the last time the machine was
run, or having the operator enter it. It is expected that the machine
tool controller will remember that information as long as it is
not re-initialized; in particular, it will be remembered between
programs.

For the purposes of this command, the tool includes the tool holder.

For machines which can carry out a select_tool command separately from
a change_tool command, the select_tool command must have been given
before the change_tool command, and the value of slot must be the slot
number of the selected tool. */

extern void SELECT_TOOL(int slot);

/* Miscellaneous Functions */

extern void CLAMP_AXIS(CANON_AXIS axis);

/* Clamp the given axis. If the machining center does not have a clamp
for that axis, this command should result in an error condition in the
controller.

An attempt to move an axis while it is clamped should result in an
error condition in the controller. */

extern void COMMENT(char *s);

/* This function has no physical effect. If commands are being printed or
logged, the comment command is printed or logged, including the string
which is the value of comment_text. This serves to allow formal
comments at specific locations in programs or command files. */

extern void DISABLE_FEED_OVERRIDE();
extern void ENABLE_FEED_OVERRIDE();
extern void DISABLE_SPEED_OVERRIDE();
extern void ENABLE_SPEED_OVERRIDE();
extern void FLOOD_OFF();
/* Turn flood coolant off. */
extern void FLOOD_ON();
/* Turn flood coolant on. */

extern void MESSAGE(char *s);

extern void MIST_OFF();
/* Turn mist coolant off. */

extern void MIST_ON();
/* Turn mist coolant on. */

extern void PALLET_SHUTTLE();

/* If the machining center has a pallet shuttle mechanism (a mechanism
which switches the position of two pallets), this command should cause
that switch to be made. If either or both of the pallets are missing,
this will not result in an error condition in the controller.

If the machining center does not have a pallet shuttle, this command
should result in an error condition in the controller. */

extern void TURN_PROBE_OFF();
extern void TURN_PROBE_ON();


extern void UNCLAMP_AXIS(CANON_AXIS axis);

/* Unclamp the given axis. If the machining center does not have a clamp
for that axis, this command should result in an error condition in the
controller. */

/* NURB Functions */
extern void NURB_KNOT_VECTOR(); /* double knot values, -1.0 signals done */
extern void NURB_CONTROL_POINT(int i, double x, double y, double z, double w );
extern void NURB_FEED(double sStart, double sEnd);

/* Program Functions */
extern void OPTIONAL_PROGRAM_STOP();

/* If the machining center has an optional stop switch, and it is on
when this command is read from a program, stop executing the program
at this point, but be prepared to resume with the next line of the
program. If the machining center does not have an optional stop
switch, or commands are being executed with a stop after each one
already (such as when the interpreter is being used with keyboard
input), this command has no effect.
*/

extern void PROGRAM_END();
/* If a program is being read, stop executing the program and be prepared
to accept a new program or to be shut down. */

extern void PROGRAM_STOP();
/* If this command is read from a program, stop executing the program at
this point, but be prepared to resume with the next line of the
program. If commands are being executed with a stop after each one
already (such as when the interpreter is being used with keyboard
input), this command has no effect. */

/* returns the current x, y, z origin offsets */
extern CANON_VECTOR GET_PROGRAM_ORIGIN();

/* returns the current active units */
extern CANON_UNITS GET_LENGTH_UNITS();

extern CANON_PLANE GET_PLANE();

/* returns current tool length offset */
extern double GET_TOOL_LENGTH_OFFSET();

/* Sends error message */
extern void CANON_ERROR(const char *fmt, ...);

/* Returns the current machine position. This is only valid if the
   calling program executes to completion any canonical output commands
   that may have been called for. */
extern CANON_POSITION GET_EXTERNAL_POSITION();

/* Returns the machine position at the probe trip. This is only valid
   once the probe command has executed to completion. */
extern CANON_POSITION GET_EXTERNAL_PROBE_POSITION();

/* Returns the value for any analog non-contact probing. */
extern double GET_EXTERNAL_PROBE_VALUE();

/* Returns non-zero if the queue is empty */
extern int IS_EXTERNAL_QUEUE_EMPTY();

/* Returns the CANON_TOOL_TABLE structure associated with the tool
   in the given pocket */
extern CANON_TOOL_TABLE GET_EXTERNAL_TOOL_TABLE(int pocket);

/* Returns the system feed and traverse rates */
extern double GET_EXTERNAL_FEED_RATE();
extern double GET_EXTERNAL_TRAVERSE_RATE();

/* Returns the system length units, in units / mm */
extern double GET_EXTERNAL_LENGTH_UNITS();

/* Returns the system angular units, in units / degree */
extern double GET_EXTERNAL_ANGLE_UNITS();

/* Returns the system values for tool, coolant, pocket, spindle */
extern int GET_EXTERNAL_TOOL();
extern int GET_EXTERNAL_MIST();
extern int GET_EXTERNAL_FLOOD();
extern int GET_EXTERNAL_POCKET();
extern double GET_EXTERNAL_SPEED();
extern CANON_DIRECTION GET_EXTERNAL_SPINDLE();

/* Returns maximum number of tools */
extern int GET_EXTERNAL_TOOL_MAX();

/* Updates the internal canonical position with real-world values */
extern void CANON_UPDATE_POSITION();

#ifdef NEW_INTERPRETER
extern char _parameter_file_name[]; /* in canon.cc */
#define PARAMETER_FILE_NAME_LENGTH 100
#endif



#endif

---