---

canon_stand_alone.cc

Go to the documentation of this file.

/*

This is a set of dummy definitions for the canonical machining
functions given in canon.hh. These functions just print. On each
output line is printed:
1. an output line number (sequential, starting with 1).
2. an input line number read from the input (or ... if not provided).
3. a printed representation of the function call which was made.

If an interpreter which makes these calls is compiled with this set of
definitions, it can be used as a translator by redirecting output from
stdout to a file.

*/

/*
  Modification history:

   1-Nov-2000 WPS added unused variables a,b,c to ARC_FEED,STRAIHT_FEED, etc.
  24-Feb-2000  FMP added CANON_UPDATE_POSITION()
*/

#include <stdio.h>
#include "rs274ngc.hh"

extern block _interpreter_block;
extern setup _interpreter_settings;
void print_nc_line_number()
{
  int line_number SET_TO _interpreter_block.line_number;
  if (line_number IS -1)
    printf(" N ... ");
  else if (line_number < 10)
    printf("    N%d ", line_number);
  else if (line_number < 100)
    printf("   N%d ", line_number);
  else if (line_number < 1000)
    printf("  N%d ", line_number);
  else if (line_number < 10000)
    printf(" N%d ", line_number);
  else
    printf("N%d ", line_number);
}

#define PRINT0(control) if (1)               \
          {printf("%5d ", line_number++);    \
           print_nc_line_number();           \
           printf(control);                  \
          } else
#define PRINT1(control, arg1) if (1)         \
          {printf("%5d ", line_number++);    \
           print_nc_line_number();           \
           printf(control, arg1);            \
          } else
#define PRINT2(control, arg1, arg2) if (1)   \
          {printf("%5d ", line_number++);    \
           print_nc_line_number();           \
           printf(control, arg1, arg2);      \
          } else
#define PRINT3(control, arg1, arg2, arg3) if (1)         \
          {printf("%5d ", line_number++);                \
           print_nc_line_number();                       \
           printf(control, arg1, arg2, arg3);            \
          } else
#define PRINT4(control, arg1, arg2, arg3, arg4) if (1)   \
          {printf("%5d ", line_number++);                \
           print_nc_line_number();                       \
           printf(control, arg1, arg2, arg3, arg4);      \
          } else
#define PRINT6(control, arg1, arg2, arg3, arg4, arg5, arg6) if (1) \
          {printf("%5d ", line_number++);                          \
           print_nc_line_number();                                 \
           printf(control, arg1, arg2, arg3, arg4, arg5, arg6);    \
          } else
static int line_number SET_TO 1;
static CANON_VECTOR program_origin;
static CANON_UNITS length_units = CANON_UNITS_MM;
static CANON_PLANE active_plane = CANON_PLANE_XY;

/* Representation */

void SET_ORIGIN_OFFSETS(double x, double y, double z,
                        double a, double b, double c)
{PRINT3("SET_ORIGIN_OFFSETS(%.4f, %.4f, %.4f)\n", x, y, z);
  program_origin.x SET_TO x;
  program_origin.y SET_TO y;
  program_origin.z SET_TO z;
}

void USE_LENGTH_UNITS(CANON_UNITS in_unit)
{PRINT1("USE_LENGTH_UNITS(%s)\n",
        (in_unit IS CANON_UNITS_INCHES) ? "CANON_UNITS_INCHES" :
        (in_unit IS CANON_UNITS_MM)     ? "CANON_UNITS_MM" : "UNKNOWN");
}

/* Free Space Motion */
void SET_TRAVERSE_RATE(double rate)
{PRINT1("SET_TRAVERSE_RATE(%.4f)\n", rate);}

void STRAIGHT_TRAVERSE (double x, double y, double z,
                        double a, double b , double c)
{PRINT3("STRAIGHT_TRAVERSE(%.4f, %.4f, %.4f)\n", x, y, z);}

/* Machining Attributes */
void SET_FEED_RATE(double rate)
{PRINT1("SET_FEED_RATE(%.4f)\n", rate);}

void SET_FEED_REFERENCE(CANON_FEED_REFERENCE reference)
{PRINT1("SET_FEED_REFERENCE(%s)\n",
        (reference IS CANON_WORKPIECE) ? "CANON_WORKPIECE" : "CANON_XYZ");}

void SET_MOTION_CONTROL_MODE(CANON_MOTION_MODE mode)
{PRINT1("SET_MOTION_CONTROL_MODE(%s)\n",
        (mode IS CANON_EXACT_PATH) ? "CANON_EXACT_PATH" :
        (mode IS CANON_EXACT_STOP) ? "CANON_EXACT_STOP" : "CANON_CONTINUOUS");}

void SELECT_PLANE(CANON_PLANE in_plane)
{PRINT1("SELECT_PLANE(%s)\n",
        (in_plane IS CANON_PLANE_XY) ? "CANON_PLANE_XY" :
        (in_plane IS CANON_PLANE_YZ) ? "CANON_PLANE_YZ" :
        (in_plane IS CANON_PLANE_XZ) ? "CANON_PLANE_XZ" : "UNKNOWN");
}

void SET_CUTTER_RADIUS_COMPENSATION(double radius)
{PRINT1("SET_CUTTER_RADIUS_COMPENSATION(%.4f)\n", radius);}

void START_CUTTER_RADIUS_COMPENSATION(int side)
{PRINT1("START_CUTTER_RADIUS_COMPENSATION(%s)\n",
        (side IS LEFT)  ? "LEFT"  :
        (side IS RIGHT) ? "RIGHT" : "UNKNOWN");
}

void STOP_CUTTER_RADIUS_COMPENSATION()
{PRINT0 ("STOP_CUTTER_RADIUS_COMPENSATION()\n");}

void START_SPEED_FEED_SYNCH()
{PRINT0 ("START_SPEED_FEED_SYNCH()\n");}

void STOP_SPEED_FEED_SYNCH()
{PRINT0 ("STOP_SPEED_FEED_SYNCH()\n");}

void SELECT_MOTION_MODE(CANON_MOTION_MODE mode)
{PRINT1("SELECT_MOTION_MODE(%s)\n",
        (mode IS CANON_EXACT_STOP) ? "CANON_EXACT_STOP" :
        (mode IS CANON_EXACT_PATH) ? "CANON_EXACT_PATH" :
        (mode IS CANON_CONTINUOUS) ? "CANON_CONTINUOUS" :
                                          "UNKNOWN");
}

/* Machining Functions */
void ARC_FEED(double first_end, double second_end,
              double first_axis, double second_axis, int rotation,
              double axis_end_point,
              double a, double b, double c)
{PRINT6("ARC_FEED(%.4f, %.4f, %.4f, %.4f, %d, %.4f)\n",
        first_end, second_end, first_axis, second_axis, rotation,
        axis_end_point);}

void STRAIGHT_FEED (double x, double y, double z,
                    double a, double b, double c)
{PRINT3("STRAIGHT_FEED(%.4f, %.4f, %.4f)\n", x, y, z);}

void STRAIGHT_PROBE (double x, double y, double z,
                     double a, double b, double c)
{PRINT3("STRAIGHT_PROBE(%.4f, %.4f, %.4f)\n", x, y, z);}


/*
void PARAMETRIC_2D_CURVE_FEED(FunctionPtr f1, FunctionPtr f2,
                              double start_parameter_value,
                              double end_parameter_value) {}

void PARAMETRIC_3D_CURVE_FEED(FunctionPtr xfcn, FunctionPtr yfcn,
        FunctionPtr zfcn, double start_parameter_value,
                              double end_parameter_value) {}
*/

void DWELL(double seconds)
{PRINT1("DWELL(%.4f)\n", seconds);}

/* Spindle Functions */
void SPINDLE_RETRACT_TRAVERSE()
{PRINT0("SPINDLE_RETRACT_TRAVERSE()\n");}

void START_SPINDLE_CLOCKWISE()
{PRINT0("START_SPINDLE_CLOCKWISE()\n");}

void START_SPINDLE_COUNTERCLOCKWISE()
{PRINT0("START_SPINDLE_COUNTERCLOCKWISE()\n");}

void SET_SPINDLE_SPEED(double r)
{PRINT1("SET_SPINDLE_SPEED(%.4f)\n", r);}

void STOP_SPINDLE_TURNING()
{PRINT0("STOP_SPINDLE_TURNING()\n");}

void SPINDLE_RETRACT()
{PRINT0("SPINDLE_RETRACT()\n");}

void ORIENT_SPINDLE(double orientation, CANON_DIRECTION direction)
{PRINT2("ORIENT_SPINDLE(%.4f, %s)\n", orientation,
        (direction IS CANON_CLOCKWISE) ? "CANON_CLOCKWISE" :
                                         "CANON_COUNTERCLOCKWISE");
}

void USE_NO_SPINDLE_FORCE()
{PRINT0("USE_NO_SPINDLE_FORCE()\n");}

/* Tool Functions */

void USE_TOOL_LENGTH_OFFSET(double length)
{PRINT1("USE_TOOL_LENGTH_OFFSET(%.4f)\n", length);}

void CHANGE_TOOL(int slot)
{PRINT1("CHANGE_TOOL(%d)\n", slot);}

void SELECT_TOOL(int slot)
{PRINT1("SELECT_TOOL(%d)\n", slot);}


/* Misc Functions */

void CLAMP_AXIS(CANON_AXIS axis)
{PRINT1("CLAMP_AXIS(%s)\n",
        (axis IS CANON_AXIS_X) ? "CANON_AXIS_X" :
        (axis IS CANON_AXIS_Y) ? "CANON_AXIS_Y" :
        (axis IS CANON_AXIS_Z) ? "CANON_AXIS_Z" : "UNKNOWN");}

void COMMENT(char *s)
{PRINT1("COMMENT(\"%s\")\n", s);}

void DISABLE_FEED_OVERRIDE()
{PRINT0("DISABLE_FEED_OVERRIDE()\n");}

void DISABLE_SPEED_OVERRIDE()
{PRINT0("DISABLE_SPEED_OVERRIDE()\n");}

void ENABLE_FEED_OVERRIDE()
{PRINT0("ENABLE_FEED_OVERRIDE()\n");}

void ENABLE_SPEED_OVERRIDE()
{PRINT0("ENABLE_SPEED_OVERRIDE()\n");}

void FLOOD_OFF()
{PRINT0("FLOOD_OFF()\n");}

void FLOOD_ON()
{PRINT0("FLOOD_ON()\n");}

void MESSAGE(char *s)
{PRINT1("MESSAGE(\"%s\")\n", s);}

void MIST_OFF()
{PRINT0("MIST_OFF()\n");}

void MIST_ON()
{PRINT0("MIST_ON()\n");}

void PALLET_SHUTTLE()
{PRINT0("PALLET_SHUTTLE()\n");}

void TURN_PROBE_OFF()
{PRINT0("TURN_PROBE_OFF()\n");}

void TURN_PROBE_ON()
{PRINT0("TURN_PROBE_ON()\n");}

void UNCLAMP_AXIS(CANON_AXIS axis)
{PRINT1("UNCLAMP_AXIS(%s)\n",
        (axis IS CANON_AXIS_X) ? "CANON_AXIS_X" :
        (axis IS CANON_AXIS_Y) ? "CANON_AXIS_Y" :
        (axis IS CANON_AXIS_Z) ? "CANON_AXIS_Z" : "UNKNOWN");}

/* Program Functions */

void PROGRAM_STOP()
{PRINT0("PROGRAM_STOP()\n");}

void OPTIONAL_PROGRAM_STOP()
{PRINT0("OPTIONAL_PROGRAM_STOP()\n");}

void PROGRAM_END()
{PRINT0("PROGRAM_END()\n");}

/* returns the current x, y, z origin offsets */
CANON_VECTOR GET_PROGRAM_ORIGIN()
{
  return program_origin;
}

/* returns the current active units */
CANON_UNITS GET_LENGTH_UNITS()
{
  return length_units;
}

CANON_PLANE GET_PLANE()
{
  return active_plane;
}

/*********************************************************************/

/*

The purpose of these GET_XXX (and other) functions is to provide for
local emulation of the world modeling done by the EMC system.

/*********************************************************************/

/* GET_EXTERNAL_FEED_RATE

called by: rs274ngc_synch

This is a stub.

*/

double GET_EXTERNAL_FEED_RATE()
{
  return 15;
}

/*********************************************************************/

int GET_EXTERNAL_FLOOD()
{
  return OFF;
}

/*********************************************************************/

int GET_EXTERNAL_MIST()
{
  return OFF;
}

/*********************************************************************/

int GET_EXTERNAL_POCKET()
{
  return 1;
}

/*********************************************************************/

CANON_POSITION GET_EXTERNAL_POSITION()
{
  return CANON_POSITION(_interpreter_settings.current_x,
                        _interpreter_settings.current_y,
                        _interpreter_settings.current_z,
                        0.0,
                        0.0,
                        0.0);
}

/*********************************************************************/

CANON_POSITION GET_EXTERNAL_PROBE_POSITION()
{
  return CANON_POSITION(_interpreter_settings.current_x,
                        _interpreter_settings.current_y,
                        _interpreter_settings.current_z,
                        0.0,
                        0.0,
                        0.0);
}

/*********************************************************************/

double GET_EXTERNAL_PROBE_VALUE()
{
  return 1.0;
}

/*********************************************************************/

double GET_EXTERNAL_SPEED()
{
  // speed is in RPMs everywhere
  return 1000;
}

/*********************************************************************/

CANON_DIRECTION GET_EXTERNAL_SPINDLE()
{
  return CANON_STOPPED;
}

/*********************************************************************/

int GET_EXTERNAL_TOOL()
{
  return 1;
}

/*********************************************************************/

int GET_EXTERNAL_TOOL_MAX()
{
  return CANON_TOOL_MAX;
}

/*********************************************************************/

CANON_TOOL_TABLE GET_EXTERNAL_TOOL_TABLE(int pocket)
{
  CANON_TOOL_TABLE retval;

  if (pocket == 0)
    {
      retval.id = 1;
      retval.length = 2.0;
      retval.diameter = 1.0;
    }
  else if (pocket == 1)
    {
      retval.id = 1;
      retval.length = 2.0;
      retval.diameter = 1.0;
    }
  else if (pocket == 2)
    {
      retval.id = 2;
      retval.length = 1.0;
      retval.diameter = 2.0;
    }
  else
    {
      retval.id = 0;
      retval.length = 0.0;
      retval.diameter = 0.0;
    }

  return retval;
}


/*********************************************************************/

double GET_EXTERNAL_TRAVERSE_RATE()
{
  return 100.0;
}

/*********************************************************************/

CANON_MOTION_MODE GET_MOTION_CONTROL_MODE()
{
  return CANON_EXACT_PATH;
}

/*********************************************************************/

/* INIT_CANON()

called by: rs274ngc_init

This is a stub.

*/

void INIT_CANON()
{}

/*********************************************************************/

/*

IS_EXTERNAL_QUEUE_EMPTY emulates the EMC external to the
interpreter. It just returns 1, meaning the queue is empty (any
non-zero means the queue is empty).

*/

int IS_EXTERNAL_QUEUE_EMPTY()
{
  return 1;
}

/*********************************************************************/

/*

CANON_UPDATE_POSITION tells the canonical interface that it should
update the end position it may have been saving, due to an abort other
other external event that may have made the end position different.
Here it does nothing since the standalone interpreter doesn't keep track
of the end position.

*/

void CANON_UPDATE_POSITION()
{
  return;
}

/*********************************************************************/

---