Main Page   Class Hierarchy   Alphabetical List   Data Structures   File List   Data Fields   Globals  

rs274ngc_pre.cc File Reference

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <ctype.h>
#include "rs274ngc.hh"
#include "rs274ngc_return.hh"
#include "rs274ngc_errors.cc"

Include dependency graph for rs274ngc_pre.cc:

Include dependency graph

Go to the source code of this file.

Defines

#define DEBUG_EMC
#define ERM(error_code)
#define ERP(error_code)
#define CHK(bad, error_code)
#define CHP(try_this)
#define G83_RAPID_DELTA   0.010
#define CYCLE_MACRO(call)
#define MAX_STACK   5

Functions

int arc_data_comp_ijk (int move, int side, double tool_radius, double current_x, double current_y, double end_x, double end_y, double i_number, double j_number, double *center_x, double *center_y, int *turn, double tolerance)
int arc_data_comp_r (int move, int side, double tool_radius, double current_x, double current_y, double end_x, double end_y, double big_radius, double *center_x, double *center_y, int *turn)
int arc_data_ijk (int move, double current_x, double current_y, double end_x, double end_y, double i_number, double j_number, double *center_x, double *center_y, int *turn, double tolerance)
int arc_data_r (int move, double current_x, double current_y, double end_x, double end_y, double radius, double *center_x, double *center_y, int *turn)
int check_g_codes (block_pointer block, setup_pointer settings)
int check_items (block_pointer block, setup_pointer settings)
int check_m_codes (block_pointer block)
int check_other_codes (block_pointer block)
int close_and_downcase (char *line)
int convert_arc (int move, block_pointer block, setup_pointer settings)
int convert_arc2 (int move, block_pointer block, setup_pointer settings, double *current1, double *current2, double *current3, double end1, double end2, double end3, double offset1, double offset2)
int convert_arc_comp1 (int move, block_pointer block, setup_pointer settings, double end_x, double end_y, double end_z)
int convert_arc_comp2 (int move, block_pointer block, setup_pointer settings, double end_x, double end_y, double end_z)
int convert_axis_offsets (int g_code, block_pointer block, setup_pointer settings)
int convert_comment (char *comment)
int convert_control_mode (int g_code, setup_pointer settings)
int convert_coordinate_system (int g_code, setup_pointer settings)
int convert_cutter_compensation (int g_code, block_pointer block, setup_pointer settings)
int convert_cutter_compensation_off (setup_pointer settings)
int convert_cutter_compensation_on (int side, block_pointer block, setup_pointer settings)
int convert_cycle (int motion, block_pointer block, setup_pointer settings)
int convert_cycle_g81 (CANON_PLANE plane, double x, double y, double clear_z, double bottom_z)
int convert_cycle_g82 (CANON_PLANE plane, double x, double y, double clear_z, double bottom_z, double dwell)
int convert_cycle_g83 (CANON_PLANE plane, double x, double y, double r, double clear_z, double bottom_z, double delta)
int convert_cycle_g84 (CANON_PLANE plane, double x, double y, double clear_z, double bottom_z, CANON_DIRECTION direction, CANON_SPEED_FEED_MODE mode)
int convert_cycle_g85 (CANON_PLANE plane, double x, double y, double clear_z, double bottom_z)
int convert_cycle_g86 (CANON_PLANE plane, double x, double y, double clear_z, double bottom_z, double dwell, CANON_DIRECTION direction)
int convert_cycle_g87 (CANON_PLANE plane, double x, double offset_x, double y, double offset_y, double r, double clear_z, double middle_z, double bottom_z, CANON_DIRECTION direction)
int convert_cycle_g88 (CANON_PLANE plane, double x, double y, double bottom_z, double dwell, CANON_DIRECTION direction)
int convert_cycle_g89 (CANON_PLANE plane, double x, double y, double clear_z, double bottom_z, double dwell)
int convert_cycle_xy (int motion, block_pointer block, setup_pointer settings)
int convert_cycle_yz (int motion, block_pointer block, setup_pointer settings)
int convert_cycle_zx (int motion, block_pointer block, setup_pointer settings)
int convert_distance_mode (int g_code, setup_pointer settings)
int convert_dwell (double time)
int convert_feed_mode (int g_code, setup_pointer settings)
int convert_feed_rate (block_pointer block, setup_pointer settings)
int convert_g (block_pointer block, setup_pointer settings)
int convert_home (int move, block_pointer block, setup_pointer settings)
int convert_length_units (int g_code, setup_pointer settings)
int convert_m (block_pointer block, setup_pointer settings)
int convert_modal_0 (int code, block_pointer block, setup_pointer settings)
int convert_motion (int motion, block_pointer block, setup_pointer settings)
int convert_probe (block_pointer block, setup_pointer settings)
int convert_retract_mode (int g_code, setup_pointer settings)
int convert_setup (block_pointer block, setup_pointer settings)
int convert_set_plane (int g_code, setup_pointer settings)
int convert_speed (block_pointer block, setup_pointer settings)
int convert_stop (block_pointer block, setup_pointer settings)
int convert_straight (int move, block_pointer block, setup_pointer settings)
int convert_straight_comp1 (int move, block_pointer block, setup_pointer settings, double px, double py, double end_z)
int convert_straight_comp2 (int move, block_pointer block, setup_pointer settings, double px, double py, double end_z)
int convert_tool_change (setup_pointer settings)
int convert_tool_length_offset (int g_code, block_pointer block, setup_pointer settings)
int convert_tool_select (block_pointer block, setup_pointer settings)
int cycle_feed (CANON_PLANE plane, double end1, double end2, double end3)
int cycle_traverse (CANON_PLANE plane, double end1, double end2, double end3)
int enhance_block (block_pointer block, setup_pointer settings)
int execute_binary (double *left, int operation, double *right)
int execute_binary1 (double *left, int operation, double *right)
int execute_binary2 (double *left, int operation, double *right)
int execute_block (block_pointer block, setup_pointer settings)
int execute_unary (double *double_ptr, int operation)
double find_arc_length (double x1, double y1, double z1, double center_x, double center_y, int turn, double x2, double y2, double z2)
int find_ends (block_pointer block, setup_pointer settings, double *px, double *py, double *pz)
int find_relative (double x1, double y1, double z1, double *x2, double *y2, double *z2, setup_pointer settings)
double find_straight_length (double x2, double y2, double z2, double x1, double y1, double z1)
double find_turn (double x1, double y1, double center_x, double center_y, int turn, double x2, double y2)
int init_block (block_pointer block)
int inverse_time_rate_arc (double x1, double y1, double z1, double cx, double cy, int turn, double x2, double y2, double z2, block_pointer block, setup_pointer settings)
int inverse_time_rate_arc2 (double start_x, double start_y, int turn1, double mid_x, double mid_y, double cx, double cy, int turn2, double end_x, double end_y, double end_z, block_pointer block, setup_pointer settings)
int inverse_time_rate_as (double start_x, double start_y, int turn, double mid_x, double mid_y, double end_x, double end_y, double end_z, block_pointer block, setup_pointer settings)
int inverse_time_rate_straight (double end_x, double end_y, double end_z, block_pointer block, setup_pointer settings)
int parse_line (char *line, block_pointer block, setup_pointer settings)
int precedence (int an_operator)
int read_a (char *line, int *counter, block_pointer block, double *parameters)
int read_atan (char *line, int *counter, double *double_ptr, double *parameters)
int read_b (char *line, int *counter, block_pointer block, double *parameters)
int read_c (char *line, int *counter, block_pointer block, double *parameters)
int read_comment (char *line, int *counter, block_pointer block, double *parameters)
int read_d (char *line, int *counter, block_pointer block, double *parameters)
int read_f (char *line, int *counter, block_pointer block, double *parameters)
int read_g (char *line, int *counter, block_pointer block, double *parameters)
int read_h (char *line, int *counter, block_pointer block, double *parameters)
int read_i (char *line, int *counter, block_pointer block, double *parameters)
int read_integer_unsigned (char *line, int *counter, int *integer_ptr)
int read_integer_value (char *line, int *counter, int *integer_ptr, double *parameters)
int read_items (block_pointer block, char *line, double *parameters)
int read_j (char *line, int *counter, block_pointer block, double *parameters)
int read_k (char *line, int *counter, block_pointer block, double *parameters)
int read_l (char *line, int *counter, block_pointer block, double *parameters)
int read_line_number (char *line, int *counter, block_pointer block)
int read_m (char *line, int *counter, block_pointer block, double *parameters)
int read_one_item (char *line, int *counter, block_pointer block, double *parameters)
int read_operation (char *line, int *counter, int *operation)
int read_operation_unary (char *line, int *counter, int *operation)
int read_p (char *line, int *counter, block_pointer block, double *parameters)
int read_parameter (char *line, int *counter, double *double_ptr, double *parameters)
int read_parameter_setting (char *line, int *counter, block_pointer block, double *parameters)
int read_q (char *line, int *counter, block_pointer block, double *parameters)
int read_r (char *line, int *counter, block_pointer block, double *parameters)
int read_real_expression (char *line, int *counter, double *hold2, double *parameters)
int read_real_number (char *line, int *counter, double *double_ptr)
int read_real_value (char *line, int *counter, double *double_ptr, double *parameters)
int read_s (char *line, int *counter, block_pointer block, double *parameters)
int read_t (char *line, int *counter, block_pointer block, double *parameters)
int read_text (const char *command, FILE *inport, char *raw_line, char *line, int *length)
int read_unary (char *line, int *counter, double *double_ptr, double *parameters)
int read_x (char *line, int *counter, block_pointer block, double *parameters)
int read_y (char *line, int *counter, block_pointer block, double *parameters)
int read_z (char *line, int *counter, block_pointer block, double *parameters)
int set_probe_data (setup_pointer settings)
int write_g_codes (block_pointer block, setup_pointer settings)
int write_m_codes (block_pointer block, setup_pointer settings)
int write_settings (setup_pointer settings)
int rs274ngc_close ()
int rs274ngc_execute (const char *command)
int rs274ngc_exit ()
int rs274ngc_init ()
int rs274ngc_load_tool_table ()
int rs274ngc_open (const char *filename)
int rs274ngc_read (const char *command)
int rs274ngc_reset ()
int rs274ngc_restore_parameters (const char *filename)
int rs274ngc_save_parameters (const char *filename, const double parameters[])
int rs274ngc_synch ()
void rs274ngc_active_g_codes (int *codes)
void rs274ngc_active_m_codes (int *codes)
void rs274ngc_active_settings (double *settings)
void rs274ngc_error_text (int error_code, char *error_text, int max_size)
void rs274ngc_file_name (char *file_name, int max_size)
int rs274ngc_line_length ()
void rs274ngc_line_text (char *line_text, int max_size)
int rs274ngc_sequence_number ()
void rs274ngc_stack_name (int stack_index, char *function_name, int max_size)

Variables

setup _setup


Define Documentation

#define CHK bad,
error_code   
 

Value:

if (bad) {             \
  _setup.stack_index SET_TO 0;                      \
  strcpy(_setup.stack[_setup.stack_index++], name); \
  _setup.stack[_setup.stack_index][0] SET_TO 0;     \
  return error_code;                                \
  } else

Definition at line 139 of file rs274ngc_pre.cc.

Referenced by check_other_codes(), close_and_downcase(), convert_arc_comp2(), convert_cycle_xy(), convert_cycle_yz(), convert_cycle_zx(), convert_straight(), convert_straight_comp1(), convert_straight_comp2(), execute_binary1(), execute_unary(), and rs274ngc_read().

#define CHP try_this   
 

Value:

if ((status SET_TO (try_this)) ISNT RS274NGC_OK) {       \
     if (_setup.stack_index < 49)                          \
        {strcpy(_setup.stack[_setup.stack_index++], name); \
         _setup.stack[_setup.stack_index][0] SET_TO 0;     \
         return status;}                                   \
     else {return status;}                                 \
  } else

Definition at line 146 of file rs274ngc_pre.cc.

Referenced by convert_arc2(), convert_arc_comp1(), convert_arc_comp2(), convert_cutter_compensation(), convert_g(), convert_m(), convert_modal_0(), convert_motion(), execute_binary(), execute_block(), and read_text().

#define CYCLE_MACRO call   
 

Value:

for (repeat SET_TO block->l_number; \
                               repeat > 0;                    \
                               repeat--)                      \
     {                                                        \
       aa SET_TO (aa + aa_increment);                         \
       bb SET_TO (bb + bb_increment);                         \
       cycle_traverse(plane, aa, bb, old_cc);                 \
       if (old_cc ISNT r)                                     \
         cycle_traverse(plane, aa, bb, r);                    \
       CHP(call);                                             \
       old_cc SET_TO clear_cc;                                \
     }

Definition at line 3784 of file rs274ngc_pre.cc.

#define DEBUG_EMC
 

Definition at line 107 of file rs274ngc_pre.cc.

#define ERM error_code   
 

Value:

if (1) {                    \
  _setup.stack_index SET_TO 0;                      \
  strcpy(_setup.stack[_setup.stack_index++], name); \
  _setup.stack[_setup.stack_index][0] SET_TO 0;     \
  return error_code;                                \
  } else

Definition at line 126 of file rs274ngc_pre.cc.

Referenced by close_and_downcase(), convert_coordinate_system(), convert_cycle(), convert_straight_comp1(), convert_straight_comp2(), execute_binary1(), execute_binary2(), execute_unary(), and read_text().

#define ERP error_code   
 

Value:

if (_setup.stack_index < 49) { \
  strcpy(_setup.stack[_setup.stack_index++], name);    \
  _setup.stack[_setup.stack_index][0] SET_TO 0;        \
  return error_code;                                   \
  } else return error_code

Definition at line 133 of file rs274ngc_pre.cc.

#define G83_RAPID_DELTA   0.010
 

Definition at line 3290 of file rs274ngc_pre.cc.

#define MAX_STACK   5
 

Definition at line 10153 of file rs274ngc_pre.cc.


Function Documentation

int arc_data_comp_ijk int    move,
int    side,
double    tool_radius,
double    current_x,
double    current_y,
double    end_x,
double    end_y,
double    i_number,
double    j_number,
double *    center_x,
double *    center_y,
int *    turn,
double    tolerance
[static]
 

Definition at line 841 of file rs274ngc_pre.cc.

Referenced by convert_arc_comp1().

00855 {
00856   static char name[] SET_TO "arc_data_comp_ijk";
00857   double arc_radius;
00858   double radius2;
00859 
00860   *center_x SET_TO (current_x + i_number);
00861   *center_y SET_TO (current_y + j_number);
00862   arc_radius SET_TO hypot(i_number, j_number);
00863   radius2 SET_TO hypot((*center_x - end_x), (*center_y - end_y));
00864   radius2 SET_TO
00865     (((side IS LEFT ) AND (move IS 30)) OR
00866      ((side IS RIGHT) AND (move IS 20))) ?
00867        (radius2 - tool_radius): (radius2 + tool_radius);
00868   CHK((fabs(arc_radius - radius2) > tolerance),
00869       NCE_RADIUS_TO_END_OF_ARC_DIFFERS_FROM_RADIUS_TO_START);
00870       /* This catches an arc too small for the tool, also */
00871   if (move IS G_2)
00872     *turn SET_TO -1;
00873   else if (move IS G_3)
00874     *turn SET_TO 1;
00875   else
00876     ERM(NCE_BUG_CODE_NOT_G2_OR_G3);
00877   return RS274NGC_OK;
00878 }

int arc_data_comp_r int    move,
int    side,
double    tool_radius,
double    current_x,
double    current_y,
double    end_x,
double    end_y,
double    big_radius,
double *    center_x,
double *    center_y,
int *    turn
[static]
 

Definition at line 937 of file rs274ngc_pre.cc.

Referenced by convert_arc_comp1().

00949 {
00950   static char name[] SET_TO "arc_data_comp_r";
00951   double abs_radius; /* absolute value of big_radius          */
00952   double alpha;      /* direction of line from current to end */
00953   double distance;   /* length of line L from current to end  */
00954   double mid_length; /* length from current point to point P  */
00955   double offset;     /* length of line from P to center       */
00956   double radius2;    /* distance from center to current point */
00957   double mid_x;      /* x-value of point P                    */
00958   double mid_y;      /* y-value of point P                    */
00959   double theta;      /* direction of line from P to center    */
00960 
00961   abs_radius SET_TO fabs(big_radius);
00962   CHK(((abs_radius <= tool_radius) AND (((side IS LEFT ) AND (move IS G_3)) OR
00963                                         ((side IS RIGHT) AND (move IS G_2)))),
00964       NCE_TOOL_RADIUS_NOT_LESS_THAN_ARC_RADIUS_WITH_COMP);
00965 
00966   distance SET_TO hypot((end_x - current_x), (end_y - current_y));
00967   alpha SET_TO atan2 ((end_y - current_y), (end_x - current_x));
00968   theta SET_TO (((move IS G_3) AND (big_radius > 0)) OR
00969                 ((move IS G_2) AND (big_radius < 0))) ?
00970                   (alpha + PI2) : (alpha - PI2);
00971   radius2 SET_TO (((side IS LEFT ) AND (move IS G_3)) OR
00972                   ((side IS RIGHT) AND (move IS G_2))) ?
00973                     (abs_radius - tool_radius) : (abs_radius + tool_radius);
00974   CHK((distance > (radius2 + abs_radius)),
00975       NCE_RADIUS_TOO_SMALL_TO_REACH_END_POINT);
00976   mid_length SET_TO (((radius2 * radius2) + (distance * distance) -
00977                       (abs_radius * abs_radius)) / (2.0 * distance));
00978   mid_x SET_TO (current_x + (mid_length * cos(alpha)));
00979   mid_y SET_TO (current_y + (mid_length * sin(alpha)));
00980   CHK(((radius2 * radius2) <= (mid_length * mid_length)),
00981       NCE_BUG_IN_TOOL_RADIUS_COMP);
00982   offset SET_TO sqrt((radius2 * radius2) - (mid_length * mid_length));
00983   *center_x SET_TO mid_x + (offset * cos(theta));
00984   *center_y SET_TO mid_y + (offset * sin(theta));
00985   *turn SET_TO (move IS G_2) ? -1 : 1;
00986 
00987   return RS274NGC_OK;
00988 }

int arc_data_ijk int    move,
double    current_x,
double    current_y,
double    end_x,
double    end_y,
double    i_number,
double    j_number,
double *    center_x,
double *    center_y,
int *    turn,
double    tolerance
[static]
 

Definition at line 1019 of file rs274ngc_pre.cc.

Referenced by convert_arc_comp2().

01031 {
01032   static char name[] SET_TO "arc_data_ijk";
01033   double radius;    /* radius to current point */
01034   double radius2;   /* radius to end point     */
01035   *center_x SET_TO (current_x + i_number);
01036   *center_y SET_TO (current_y + j_number);
01037   radius SET_TO hypot((*center_x - current_x), (*center_y - current_y));
01038   radius2 SET_TO hypot((*center_x - end_x), (*center_y - end_y));
01039   CHK(((radius IS 0.0) OR (radius2 IS 0.0)), NCE_ZERO_RADIUS_ARC);
01040   CHK((fabs(radius - radius2) > tolerance),
01041       NCE_RADIUS_TO_END_OF_ARC_DIFFERS_FROM_RADIUS_TO_START);
01042   if (move IS G_2)
01043     *turn SET_TO -1;
01044   else if (move IS G_3)
01045     *turn SET_TO 1;
01046   else
01047     ERM(NCE_BUG_CODE_NOT_G2_OR_G3);
01048   return RS274NGC_OK;
01049 }

int arc_data_r int    move,
double    current_x,
double    current_y,
double    end_x,
double    end_y,
double    radius,
double *    center_x,
double *    center_y,
int *    turn
[static]
 

Definition at line 1087 of file rs274ngc_pre.cc.

Referenced by convert_arc2(), convert_arc_comp2(), convert_arc_xy(), convert_arc_yz(), and convert_arc_zx().

01097 {
01098   static char name[] SET_TO "arc_data_r";
01099   double abs_radius;  /* absolute value of given radius */
01100   double half_length; /* distance from M to end point   */
01101   double mid_x;       /* first coordinate of M          */
01102   double mid_y;       /* second coordinate of M         */
01103   double offset;      /* distance from M to center      */
01104   double theta;       /* angle of line from M to center */
01105   double turn2;       /* absolute value of half of turn */
01106 
01107   CHK(((end_x IS current_x) AND (end_y IS current_y)),
01108       NCE_CURRENT_POINT_SAME_AS_END_POINT_OF_ARC);
01109   abs_radius SET_TO fabs(radius);
01110   mid_x SET_TO (end_x + current_x)/2.0;
01111   mid_y SET_TO (end_y + current_y)/2.0;
01112   half_length SET_TO hypot((mid_x - end_x), (mid_y - end_y));
01113   CHK(((half_length/abs_radius) > (1+TINY)),
01114       NCE_ARC_RADIUS_TOO_SMALL_TO_REACH_END_POINT);
01115   if ((half_length/abs_radius) > (1-TINY))
01116     half_length SET_TO abs_radius; /* allow a small error for semicircle */
01117                                    /* check needed before calling asin   */
01118   if (((move IS G_2) AND (radius > 0)) OR
01119       ((move IS G_3) AND (radius < 0)))
01120     theta SET_TO atan2((end_y - current_y), (end_x - current_x)) - PI2;
01121   else
01122     theta SET_TO atan2((end_y - current_y), (end_x - current_x)) + PI2;
01123 
01124   turn2 SET_TO asin (half_length/abs_radius);
01125   offset SET_TO abs_radius * cos(turn2);
01126   *center_x SET_TO mid_x + (offset * cos(theta));
01127   *center_y SET_TO mid_y + (offset * sin(theta));
01128   *turn SET_TO (move IS G_2) ? -1 : 1;
01129 
01130   return RS274NGC_OK;
01131 }

int check_g_codes block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 1184 of file rs274ngc_pre.cc.

01187 {
01188   static char name[] SET_TO "check_g_codes";
01189   int mode0;
01190   int p_int;
01191 
01192   mode0 SET_TO block->g_modes[0];
01193 
01194   if (mode0 IS -1)
01195     {}
01196   else if (mode0 IS G_4)
01197     {
01198       CHK((block->p_number IS -1.0), NCE_DWELL_TIME_MISSING_WITH_G4);
01199     }
01200   else if (mode0 IS G_10)
01201     {
01202       p_int SET_TO (int)(block->p_number + 0.0001);
01203       CHK((block->l_number ISNT 2), NCE_LINE_WITH_G10_DOES_NOT_HAVE_L2);
01204       CHK((((block->p_number + 0.0001) - p_int) > 0.0002),
01205           NCE_P_VALUE_NOT_AN_INTEGER_WITH_G10_L2);
01206       CHK(((p_int < 1) OR (p_int > 9)), NCE_P_VALUE_OUT_OF_RANGE_WITH_G10_L2);
01207     }
01208   else if (mode0 IS G_28)
01209     {}
01210   else if (mode0 IS G_30)
01211     {}
01212   else if (mode0 IS G_53)
01213     {
01214       CHK(((block->motion_to_be ISNT G_0) AND (block->motion_to_be ISNT G_1)),
01215           NCE_MUST_USE_G0_OR_G1_WITH_G53);
01216       CHK(((block->g_modes[3] IS G_91) OR
01217            ((block->g_modes[3] ISNT G_90) AND
01218             (settings->distance_mode IS MODE_INCREMENTAL))),
01219           NCE_CANNOT_USE_G53_INCREMENTAL);
01220     }
01221   else if (mode0 IS G_92)
01222     {}
01223   else if ((mode0 IS G_92_1) OR (mode0 IS G_92_2) OR (mode0 IS G_92_3))
01224     {}
01225   else
01226     ERM(NCE_BUG_BAD_G_CODE_MODAL_GROUP_0);
01227   return RS274NGC_OK;
01228 }

int check_items block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 1259 of file rs274ngc_pre.cc.

01262 {
01263   static char name[] SET_TO "check_items";
01264   int status;
01265 
01266   CHP(check_g_codes(block, settings));
01267   CHP(check_m_codes(block));
01268   CHP(check_other_codes(block));
01269   return RS274NGC_OK;
01270 }

int check_m_codes block_pointer    block [static]
 

Definition at line 1292 of file rs274ngc_pre.cc.

01294 {
01295   static char name[] SET_TO "check_m_codes";
01296 
01297   CHK((block->m_count > MAX_EMS), NCE_TOO_MANY_M_CODES_ON_LINE);
01298   return RS274NGC_OK;
01299 }

int check_other_codes block_pointer    block [static]
 

Definition at line 1345 of file rs274ngc_pre.cc.

01347 {
01348   static char name[] SET_TO "check_other_codes";
01349   int motion;
01350 
01351   motion SET_TO block->motion_to_be;
01352 #ifdef AA
01353   if (block->a_flag ISNT OFF)
01354     {
01355       CHK(((block->g_modes[1] > G_80) AND (block->g_modes[1] < G_90)),
01356           NCE_CANNOT_PUT_AN_A_IN_CANNED_CYCLE);
01357     }
01358 #endif
01359 #ifdef BB
01360   if (block->b_flag ISNT OFF)
01361     {
01362       CHK(((block->g_modes[1] > G_80) AND (block->g_modes[1] < G_90)),
01363           NCE_CANNOT_PUT_A_B_IN_CANNED_CYCLE);
01364     }
01365 #endif
01366 #ifdef CC
01367   if (block->c_flag ISNT OFF)
01368     {
01369       CHK(((block->g_modes[1] > G_80) AND (block->g_modes[1] < G_90)),
01370           NCE_CANNOT_PUT_A_C_IN_CANNED_CYCLE);
01371     }
01372 #endif
01373   if (block->d_number ISNT -1)
01374     {
01375       CHK(((block->g_modes[7] ISNT G_41) AND (block->g_modes[7] ISNT G_42)),
01376           NCE_D_WORD_WITH_NO_G41_OR_G42);
01377     }
01378   if (block->h_number ISNT -1)
01379     {
01380       CHK((block->g_modes[8] ISNT G_43), NCE_H_WORD_WITH_NO_G43);
01381     }
01382 
01383   if (block->i_flag IS ON) /* could still be useless if yz_plane arc */
01384     {
01385       CHK(((motion ISNT G_2) AND (motion ISNT G_3) AND (motion ISNT G_87)),
01386           NCE_I_WORD_WITH_NO_G2_OR_G3_OR_G87_TO_USE_IT);
01387     }
01388 
01389   if (block->j_flag IS ON) /* could still be useless if xz_plane arc */
01390     {
01391       CHK(((motion ISNT G_2) AND (motion ISNT G_3) AND (motion ISNT G_87)),
01392           NCE_J_WORD_WITH_NO_G2_OR_G3_OR_G87_TO_USE_IT);
01393     }
01394 
01395   if (block->k_flag IS ON) /* could still be useless if xy_plane arc */
01396     {
01397       CHK(((motion ISNT G_2) AND (motion ISNT G_3) AND (motion ISNT G_87)),
01398           NCE_K_WORD_WITH_NO_G2_OR_G3_OR_G87_TO_USE_IT);
01399     }
01400 
01401   if (block->l_number ISNT -1)
01402     {
01403       CHK((((motion < G_81) OR (motion > G_89)) AND
01404            (block->g_modes[0] ISNT G_10)),
01405           NCE_L_WORD_WITH_NO_CANNED_CYCLE_OR_G10);
01406     }
01407 
01408   if (block->p_number ISNT -1.0)
01409     {
01410       CHK(((block->g_modes[0] ISNT G_10) AND
01411            (block->g_modes[0] ISNT G_4) AND
01412            (motion ISNT G_82) AND (motion ISNT G_86) AND
01413            (motion ISNT G_88) AND (motion ISNT G_89)),
01414           NCE_P_WORD_WITH_NO_G4_G10_G82_G86_G88_G89);
01415     }
01416 
01417   if (block->q_number ISNT -1.0)
01418     {
01419       CHK((motion ISNT G_83), NCE_Q_WORD_WITH_NO_G83);
01420     }
01421 
01422   if (block->r_flag IS ON)
01423     {
01424       CHK((((motion ISNT G_2) AND (motion ISNT G_3)) AND
01425            ((motion < G_81) OR (motion > G_89))),
01426           NCE_R_WORD_WITH_NO_G_CODE_THAT_USES_IT);
01427     }
01428 
01429   return RS274NGC_OK;
01430 }

int close_and_downcase char *    line [static]
 

Definition at line 1474 of file rs274ngc_pre.cc.

Referenced by read_text().

01475                                         : one line of NC code */
01476 {
01477   static char name[] SET_TO "close_and_downcase";
01478   int m;
01479   int n;
01480   int comment;
01481   char item;
01482   comment SET_TO 0;
01483   for (n SET_TO 0, m SET_TO 0; (item SET_TO line[m]) ISNT (char) NULL; m++)
01484     {
01485       if (comment)
01486         {
01487           line[n++] SET_TO item;
01488           if (item IS ')')
01489             {
01490               comment SET_TO 0;
01491             }
01492           else if (item IS '(')
01493             ERM(NCE_NESTED_COMMENT_FOUND);
01494         }
01495       else if ((item IS ' ') OR (item IS '\t') OR (item IS '\r'));
01496                                       /* don't copy blank or tab or CR */
01497       else if (item IS '\n')          /* don't copy newline            */
01498         {                             /* but check null follows        */
01499           CHK((line[m+1] ISNT 0), NCE_NULL_MISSING_AFTER_NEWLINE);
01500         }
01501       else if ((64 < item) AND (item < 91)) /* downcase upper case letters */
01502         {
01503           line[n++] SET_TO (32 + item);
01504         }
01505       else if (item IS '(')   /* comment is starting */
01506         {
01507           comment SET_TO 1;
01508           line[n++] SET_TO item;
01509         }
01510       else
01511         {
01512           line[n++] SET_TO item; /* copy anything else */
01513         }
01514     }
01515   CHK((comment), NCE_UNCLOSED_COMMENT_FOUND);
01516   line[n] SET_TO 0;
01517   return RS274NGC_OK;
01518 }

int convert_arc int    move,
block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 1574 of file rs274ngc_pre.cc.

01578 {
01579   static char name[] SET_TO "convert_arc";
01580   int status;
01581   int first;          /* flag set ON if this is first move after comp ON */
01582   int ijk_flag;       /* flag set ON if any of i,j,k present in NC code  */
01583   double end_x;
01584   double end_y;
01585   double end_z;
01586 #ifdef AA
01587   double AA_end;       /*AA*/
01588 #endif
01589 #ifdef BB
01590   double BB_end;       /*BB*/
01591 #endif
01592 #ifdef CC
01593   double CC_end;       /*CC*/
01594 #endif
01595 
01596   ijk_flag SET_TO
01597     ((block->i_flag OR block->j_flag) OR block->k_flag) ? ON : OFF;
01598   first SET_TO (settings->program_x IS UNKNOWN);
01599 
01600   CHK(((block->r_flag ISNT ON) AND (ijk_flag ISNT ON)),
01601       NCE_R_I_J_K_WORDS_ALL_MISSING_FOR_ARC);
01602   CHK(((block->r_flag IS ON) AND (ijk_flag IS ON)),
01603       NCE_MIXED_RADIUS_IJK_FORMAT_FOR_ARC);
01604   if (settings->feed_mode IS UNITS_PER_MINUTE)
01605     {
01606       CHK((settings->feed_rate IS 0.0),
01607           NCE_CANNOT_MAKE_ARC_WITH_ZERO_FEED_RATE);
01608     }
01609   else if (settings->feed_mode IS INVERSE_TIME)
01610     {
01611       CHK((block->f_number IS -1.0),
01612           NCE_F_WORD_MISSING_WITH_INVERSE_TIME_ARC_MOVE);
01613     }
01614   if (ijk_flag)
01615     {
01616       if (settings->plane IS CANON_PLANE_XY)
01617         {
01618           CHK((block->k_flag), NCE_K_WORD_GIVEN_FOR_ARC_IN_XY_PLANE);
01619           if (block->i_flag IS OFF) /* i or j flag on to get here */
01620             block->i_number SET_TO 0.0;
01621           else if (block->j_flag IS OFF)
01622             block->j_number SET_TO 0.0;
01623         }
01624       else if (settings->plane IS CANON_PLANE_YZ)
01625         {
01626           CHK((block->i_flag), NCE_I_WORD_GIVEN_FOR_ARC_IN_YZ_PLANE);
01627           if (block->j_flag IS OFF) /* j or k flag on to get here */
01628             block->j_number SET_TO 0.0;
01629           else if (block->k_flag IS OFF)
01630             block->k_number SET_TO 0.0;
01631         }
01632       else if (settings->plane IS CANON_PLANE_XZ)
01633         {
01634           CHK((block->j_flag), NCE_J_WORD_GIVEN_FOR_ARC_IN_XZ_PLANE);
01635           if (block->i_flag IS OFF) /* i or k flag on to get here */
01636             block->i_number SET_TO 0.0;
01637           else if (block->k_flag IS OFF)
01638             block->k_number SET_TO 0.0;
01639         }
01640       else
01641         ERM(NCE_BUG_PLANE_NOT_XY_YZ_OR_XZ);
01642     }
01643   else; /* r format arc; no other checks needed specific to this format */
01644 
01645   if (settings->plane IS CANON_PLANE_XY) /* checks for both formats */
01646     {
01647       CHK(((block->x_flag IS OFF) AND (block->y_flag IS OFF)),
01648           NCE_X_AND_Y_WORDS_MISSING_FOR_ARC_IN_XY_PLANE);
01649     }
01650   else if (settings->plane IS CANON_PLANE_YZ)
01651     {
01652       CHK(((block->y_flag IS OFF) AND (block->z_flag IS OFF)),
01653           NCE_Y_AND_Z_WORDS_MISSING_FOR_ARC_IN_YZ_PLANE);
01654     }
01655   else if (settings->plane IS CANON_PLANE_XZ)
01656     {
01657       CHK(((block->x_flag IS OFF) AND (block->z_flag IS OFF)),
01658           NCE_X_AND_Z_WORDS_MISSING_FOR_ARC_IN_XZ_PLANE);
01659     }
01660 
01661   find_ends(block, settings, &end_x, &end_y,
01662             &end_z
01663 #ifdef AA
01664 , &AA_end
01665 #endif
01666 
01667 #ifdef BB
01668 , &BB_end
01669 #endif
01670 
01671 #ifdef CC
01672 , &CC_end
01673 #endif
01674 );
01675   settings->motion_mode SET_TO move;
01676 
01677   if (settings->plane IS CANON_PLANE_XY)
01678     {
01679       if ((settings->cutter_comp_side IS OFF) OR
01680           (settings->cutter_comp_radius IS 0.0))
01681         {
01682           status SET_TO
01683             convert_arc2(move, block, settings,
01684                          &(settings->current_x), &(settings->current_y),
01685                          &(settings->current_z), end_x, end_y,
01686                          end_z
01687 #ifdef AA
01688 , AA_end
01689 #endif
01690 
01691 #ifdef BB
01692 , BB_end
01693 #endif
01694 
01695 #ifdef CC
01696 , CC_end
01697 #endif
01698 , block->i_number,
01699                          block->j_number);
01700           CHP(status);
01701         }
01702       else if (first)
01703         {
01704           status SET_TO
01705             convert_arc_comp1(move, block, settings, end_x, end_y,
01706                               end_z
01707 #ifdef AA
01708 , AA_end
01709 #endif
01710 
01711 #ifdef BB
01712 , BB_end
01713 #endif
01714 
01715 #ifdef CC
01716 , CC_end
01717 #endif
01718 );
01719           CHP(status);
01720         }
01721       else
01722         {
01723           status SET_TO
01724             convert_arc_comp2(move, block, settings, end_x, end_y,
01725                               end_z
01726 #ifdef AA
01727 , AA_end
01728 #endif
01729 
01730 #ifdef BB
01731 , BB_end
01732 #endif
01733 
01734 #ifdef CC
01735 , CC_end
01736 #endif
01737 );
01738 
01739           CHP(status);
01740         }
01741     }
01742   else if (settings->plane IS CANON_PLANE_XZ)
01743     {
01744       status SET_TO
01745         convert_arc2 (move, block, settings,
01746                       &(settings->current_z), &(settings->current_x),
01747                       &(settings->current_y), end_z, end_x,
01748                       end_y
01749 #ifdef AA
01750 , AA_end
01751 #endif
01752 
01753 #ifdef BB
01754 , BB_end
01755 #endif
01756 
01757 #ifdef CC
01758 , CC_end
01759 #endif
01760 , block->k_number,
01761                       block->i_number);
01762       CHP(status);
01763     }
01764   else if (settings->plane IS CANON_PLANE_YZ)
01765     {
01766       status SET_TO
01767         convert_arc2 (move, block, settings,
01768                       &(settings->current_y), &(settings->current_z),
01769                       &(settings->current_x), end_y, end_z,
01770                       end_x
01771 #ifdef AA
01772 , AA_end
01773 #endif
01774 
01775 #ifdef BB
01776 , BB_end
01777 #endif
01778 
01779 #ifdef CC
01780 , CC_end
01781 #endif
01782 , block->j_number,
01783                       block->k_number);
01784       CHP(status);
01785     }
01786   else
01787     ERM(NCE_BUG_PLANE_NOT_XY_YZ_OR_XZ);
01788   return RS274NGC_OK;
01789 }

int convert_arc2 int    move,
block_pointer    block,
setup_pointer    settings,
double *    current1,
double *    current2,
double *    current3,
double    end1,
double    end2,
double    end3,
double    offset1,
double    offset2
[static]
 

Definition at line 1811 of file rs274ngc_pre.cc.

01832 {
01833   static char name[] SET_TO "convert_arc2";
01834   double center1;
01835   double center2;
01836   int status;         /* status returned from CHP function call     */
01837   double tolerance;   /* tolerance for difference of radii          */
01838   int turn;           /* number of full or partial turns CCW in arc */
01839 
01840   tolerance SET_TO (settings->length_units IS CANON_UNITS_INCHES) ?
01841     TOLERANCE_INCH : TOLERANCE_MM;
01842 
01843   if (block->r_flag)
01844     {
01845       CHP(arc_data_r(move, *current1, *current2, end1, end2,
01846                      block->r_number, &center1, &center2, &turn));
01847     }
01848   else
01849     {
01850       CHP(arc_data_ijk(move, *current1, *current2, end1, end2, offset1,
01851                        offset2, &center1, &center2, &turn, tolerance));
01852     }
01853 
01854   if (settings->feed_mode IS INVERSE_TIME)
01855     inverse_time_rate_arc(*current1, *current2, *current3, center1, center2,
01856                           turn, end1, end2, end3, block, settings);
01857   ARC_FEED(end1, end2, center1, center2, turn,
01858             end3
01859 #ifdef AA
01860 , AA_end
01861 #else
01862 #ifdef ALL_AXES
01863 , 0
01864 #endif
01865 #endif
01866 #ifdef BB
01867 , BB_end
01868 #else
01869 #ifdef ALL_AXES
01870 , 0
01871 #endif
01872 #endif
01873 #ifdef CC
01874 , CC_end
01875 #else
01876 #ifdef ALL_AXES
01877 , 0
01878 #endif
01879 #endif
01880 );
01881   *current1 SET_TO end1;
01882   *current2 SET_TO end2;
01883   *current3 SET_TO end3;
01884 #ifdef AA
01885   settings->AA_current SET_TO AA_end;  /*AA*/
01886 #endif
01887 #ifdef BB
01888   settings->BB_current SET_TO BB_end;  /*BB*/
01889 #endif
01890 #ifdef CC
01891   settings->CC_current SET_TO CC_end;  /*CC*/
01892 #endif
01893   return RS274NGC_OK;
01894 }

int convert_arc_comp1 int    move,
block_pointer    block,
setup_pointer    settings,
double    end_x,
double    end_y,
double    end_z
[static]
 

Definition at line 1924 of file rs274ngc_pre.cc.

01941 {
01942   static char name[] SET_TO "convert_arc_comp1";
01943   double center_x;
01944   double center_y;
01945   double gamma;       /* direction of perpendicular to arc at end */
01946   int side;           /* offset side - right or left              */
01947   int status;         /* status returned from CHP function call   */
01948   double tolerance;   /* tolerance for difference of radii        */
01949   double tool_radius;
01950   int turn;           /* 1 for counterclockwise, -1 for clockwise */
01951 
01952   side SET_TO settings->cutter_comp_side;
01953   tool_radius SET_TO settings->cutter_comp_radius; /* always is positive */
01954   tolerance SET_TO (settings->length_units IS CANON_UNITS_INCHES) ?
01955     TOLERANCE_INCH : TOLERANCE_MM;
01956 
01957   CHK((hypot((end_x - settings->current_x),
01958              (end_y - settings->current_y)) <= tool_radius),
01959       NCE_CUTTER_GOUGING_WITH_CUTTER_RADIUS_COMP);
01960 
01961   if (block->r_flag)
01962     {
01963       CHP(arc_data_comp_r(move, side, tool_radius, settings->current_x,
01964                           settings->current_y, end_x, end_y, block->r_number,
01965                           &center_x, &center_y, &turn));
01966     }
01967   else
01968     {
01969       CHP(arc_data_comp_ijk(move, side, tool_radius, settings->current_x,
01970                             settings->current_y, end_x, end_y,
01971                             block->i_number, block->j_number,
01972                             &center_x, &center_y, &turn, tolerance));
01973     }
01974 
01975   gamma SET_TO
01976     (((side IS LEFT) AND (move IS G_3)) OR
01977      ((side IS RIGHT) AND (move IS G_2))) ?
01978        atan2 ((center_y - end_y), (center_x - end_x)) :
01979        atan2 ((end_y - center_y), (end_x - center_x));
01980 
01981   settings->program_x SET_TO end_x;
01982   settings->program_y SET_TO end_y;
01983   end_x SET_TO (end_x + (tool_radius * cos(gamma))); /* end_x reset actual */
01984   end_y SET_TO (end_y + (tool_radius * sin(gamma))); /* end_y reset actual */
01985 
01986   if (settings->feed_mode IS INVERSE_TIME)
01987     inverse_time_rate_arc(settings->current_x, settings->current_y,
01988                           settings->current_z, center_x, center_y, turn,
01989                           end_x, end_y, end_z, block, settings);
01990   ARC_FEED(end_x, end_y, center_x, center_y, turn,
01991            end_z
01992 #ifdef AA
01993 , AA_end
01994 #else
01995 #ifdef ALL_AXES
01996 , 0
01997 #endif
01998 #endif
01999 #ifdef BB
02000 , BB_end
02001 #else
02002 #ifdef ALL_AXES
02003 , 0
02004 #endif
02005 #endif
02006 #ifdef CC
02007 , CC_end
02008 #else
02009 #ifdef ALL_AXES
02010 , 0
02011 #endif
02012 #endif
02013 );
02014   settings->current_x SET_TO end_x;
02015   settings->current_y SET_TO end_y;
02016   settings->current_z SET_TO end_z;
02017 #ifdef AA
02018   settings->AA_current SET_TO AA_end;  /*AA*/
02019 #endif
02020 #ifdef BB
02021   settings->BB_current SET_TO BB_end;  /*BB*/
02022 #endif
02023 #ifdef CC
02024   settings->CC_current SET_TO CC_end;  /*CC*/
02025 #endif
02026 
02027   return RS274NGC_OK;
02028 }

int convert_arc_comp2 int    move,
block_pointer    block,
setup_pointer    settings,
double    end_x,
double    end_y,
double    end_z
[static]
 

Definition at line 2069 of file rs274ngc_pre.cc.

02086 {
02087   static char name[] SET_TO "convert_arc_comp2";
02088   double alpha;    /* direction of tangent to start of arc */
02089   double arc_radius;
02090   double beta;     /* angle between two tangents above */
02091   double center_x; /* center of arc */
02092   double center_y;
02093   double delta;    /* direction of radius from start of arc to center of arc */
02094   double gamma;    /* direction of perpendicular to arc at end */
02095   double mid_x;
02096   double mid_y;
02097   int side;
02098   double small SET_TO TOLERANCE_CONCAVE_CORNER; /* angle for testing corners */
02099   double start_x;
02100   double start_y;
02101   int status;      /* status returned from CHP function call     */
02102   double theta;    /* direction of tangent to last cut */
02103   double tolerance;
02104   double tool_radius;
02105   int turn;        /* number of full or partial circles CCW */
02106 
02107 /* find basic arc data: center_x, center_y, and turn */
02108 
02109   start_x SET_TO settings->program_x;
02110   start_y SET_TO settings->program_y;
02111   tolerance SET_TO (settings->length_units IS CANON_UNITS_INCHES) ?
02112     TOLERANCE_INCH : TOLERANCE_MM;
02113 
02114   if (block->r_flag)
02115     {
02116       CHP(arc_data_r(move, start_x, start_y, end_x, end_y,
02117                      block->r_number, &center_x, &center_y, &turn));
02118     }
02119   else
02120     {
02121       CHP(arc_data_ijk(move, start_x, start_y, end_x, end_y,
02122                        block->i_number, block->j_number,
02123                        &center_x, &center_y, &turn, tolerance));
02124     }
02125 
02126 /* compute other data */
02127   side SET_TO settings->cutter_comp_side;
02128   tool_radius SET_TO settings->cutter_comp_radius; /* always is positive */
02129   arc_radius SET_TO hypot((center_x - end_x), (center_y - end_y));
02130   theta SET_TO
02131     atan2(settings->current_y - start_y, settings->current_x - start_x);
02132   theta SET_TO (side IS LEFT) ? (theta - PI2) : (theta + PI2);
02133   delta SET_TO atan2(center_y - start_y, center_x - start_x);
02134   alpha SET_TO (move IS G_3) ? (delta - PI2) : (delta + PI2);
02135   beta SET_TO (side IS LEFT) ? (theta - alpha) : (alpha - theta);
02136   beta SET_TO (beta > (1.5 * PI))  ? (beta - TWO_PI) :
02137               (beta < -PI2) ? (beta + TWO_PI) : beta;
02138 
02139   if (((side IS LEFT)  AND (move IS G_3)) OR
02140       ((side IS RIGHT) AND (move IS G_2)))
02141     {
02142       gamma SET_TO atan2 ((center_y - end_y), (center_x - end_x));
02143       CHK((arc_radius <= tool_radius),
02144           NCE_TOOL_RADIUS_NOT_LESS_THAN_ARC_RADIUS_WITH_COMP);
02145     }
02146   else
02147     {
02148       gamma SET_TO atan2 ((end_y - center_y), (end_x - center_x));
02149       delta SET_TO (delta + PI);
02150     }
02151 
02152   settings->program_x SET_TO end_x;
02153   settings->program_y SET_TO end_y;
02154   end_x SET_TO (end_x + (tool_radius * cos(gamma))); /* end_x reset actual */
02155   end_y SET_TO (end_y + (tool_radius * sin(gamma))); /* end_y reset actual */
02156 
02157 /* check if extra arc needed and insert if so */
02158 
02159   CHK(((beta < -small) OR (beta > (PI + small))),
02160       NCE_CONCAVE_CORNER_WITH_CUTTER_RADIUS_COMP);
02161   if (beta > small) /* two arcs needed */
02162     {
02163       mid_x SET_TO (start_x + (tool_radius * cos(delta)));
02164       mid_y SET_TO (start_y + (tool_radius * sin(delta)));
02165       if (settings->feed_mode IS INVERSE_TIME)
02166         inverse_time_rate_arc2(start_x, start_y, (side IS LEFT) ? -1 : 1,
02167                                mid_x, mid_y, center_x, center_y, turn,
02168                                end_x, end_y, end_z, block, settings);
02169       ARC_FEED(mid_x, mid_y, start_x, start_y, ((side IS LEFT) ? -1 : 1),
02170                settings->current_z
02171 #ifdef AA
02172 , AA_end
02173 #else
02174 #ifdef ALL_AXES
02175 , 0
02176 #endif
02177 #endif
02178 #ifdef BB
02179 , BB_end
02180 #else
02181 #ifdef ALL_AXES
02182 , 0
02183 #endif
02184 #endif
02185 #ifdef CC
02186 , CC_end
02187 #else
02188 #ifdef ALL_AXES
02189 , 0
02190 #endif
02191 #endif
02192 );
02193       ARC_FEED(end_x, end_y, center_x, center_y, turn,
02194                end_z
02195 #ifdef AA
02196 , AA_end
02197 #else
02198 #ifdef ALL_AXES
02199 , 0
02200 #endif
02201 #endif
02202 #ifdef BB
02203 , BB_end
02204 #else
02205 #ifdef ALL_AXES
02206 , 0
02207 #endif
02208 #endif
02209 #ifdef CC
02210 , CC_end
02211 #else
02212 #ifdef ALL_AXES
02213 , 0
02214 #endif
02215 #endif
02216 );
02217     }
02218   else /* one arc needed */
02219     {
02220       if (settings->feed_mode IS INVERSE_TIME)
02221         inverse_time_rate_arc(settings->current_x, settings->current_y,
02222                               settings->current_z, center_x, center_y, turn,
02223                               end_x, end_y, end_z, block, settings);
02224       ARC_FEED(end_x, end_y, center_x, center_y, turn,
02225                end_z
02226 #ifdef AA
02227 , AA_end
02228 #else
02229 #ifdef ALL_AXES
02230 , 0
02231 #endif
02232 #endif
02233 #ifdef BB
02234 , BB_end
02235 #else
02236 #ifdef ALL_AXES
02237 , 0
02238 #endif
02239 #endif
02240 #ifdef CC
02241 , CC_end
02242 #else
02243 #ifdef ALL_AXES
02244 , 0
02245 #endif
02246 #endif
02247 );
02248     }
02249 
02250   settings->current_x SET_TO end_x;
02251   settings->current_y SET_TO end_y;
02252   settings->current_z SET_TO end_z;
02253 #ifdef AA
02254   settings->AA_current SET_TO AA_end;                      /*AA*/
02255 #endif
02256 #ifdef BB
02257   settings->BB_current SET_TO BB_end;                      /*BB*/
02258 #endif
02259 #ifdef CC
02260   settings->CC_current SET_TO CC_end;                      /*CC*/
02261 #endif
02262 
02263   return RS274NGC_OK;
02264 }

int convert_axis_offsets int    g_code,
block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 2325 of file rs274ngc_pre.cc.

02329 {
02330   static char name[] SET_TO "convert_axis_offsets";
02331   double * pars;          /* short name for settings->parameters            */
02332 
02333   CHK((settings->cutter_comp_side ISNT OFF), /* not "IS ON" */
02334       NCE_CANNOT_CHANGE_AXIS_OFFSETS_WITH_CUTTER_RADIUS_COMP);
02335   pars SET_TO settings->parameters;
02336   if (g_code IS G_92)
02337     {
02338       if (block->x_flag IS ON)
02339         {
02340           settings->axis_offset_x SET_TO
02341             (settings->current_x + settings->axis_offset_x - block->x_number);
02342           settings->current_x SET_TO block->x_number;
02343         }
02344 
02345       if (block->y_flag IS ON)
02346         {
02347           settings->axis_offset_y SET_TO
02348             (settings->current_y + settings->axis_offset_y - block->y_number);
02349           settings->current_y SET_TO block->y_number;
02350         }
02351 
02352       if (block->z_flag IS ON)
02353         {
02354           settings->axis_offset_z SET_TO
02355             (settings->current_z + settings->axis_offset_z - block->z_number);
02356           settings->current_z SET_TO block->z_number;
02357         }
02358 
02359 #ifdef AA
02360       if (block->a_flag IS ON)                                           /*AA*/
02361 #endif
02362 #ifdef AA
02363         {settings->AA_axis_offset SET_TO (settings->AA_current +         /*AA*/
02364 #endif
02365 #ifdef AA
02366                             settings->AA_axis_offset - block->a_number); /*AA*/
02367 #endif
02368 #ifdef AA
02369           settings->AA_current SET_TO block->a_number;}                  /*AA*/
02370 #endif
02371 
02372 #ifdef BB
02373       if (block->b_flag IS ON)                                           /*BB*/
02374 #endif
02375 #ifdef BB
02376         {settings->BB_axis_offset SET_TO (settings->BB_current +         /*BB*/
02377 #endif
02378 #ifdef BB
02379                             settings->BB_axis_offset - block->b_number); /*BB*/
02380 #endif
02381 #ifdef BB
02382           settings->BB_current SET_TO block->b_number;}                  /*BB*/
02383 #endif
02384 
02385 #ifdef CC
02386       if (block->c_flag IS ON)                                           /*CC*/
02387 #endif
02388 #ifdef CC
02389         {settings->CC_axis_offset SET_TO (settings->CC_current +         /*CC*/
02390 #endif
02391 #ifdef CC
02392                             settings->CC_axis_offset - block->c_number); /*CC*/
02393 #endif
02394 #ifdef CC
02395           settings->CC_current SET_TO block->c_number;}                  /*CC*/
02396 #endif
02397 
02398       SET_ORIGIN_OFFSETS(settings->origin_offset_x + settings->axis_offset_x,
02399                          settings->origin_offset_y + settings->axis_offset_y,
02400                          settings->origin_offset_z + settings->axis_offset_z
02401 #ifdef AA
02402 ,                      (settings->AA_origin_offset + settings->AA_axis_offset)
02403 #else
02404 #ifdef ALL_AXES
02405 , 0
02406 #endif
02407 #endif
02408 #ifdef BB
02409 ,                      (settings->BB_origin_offset + settings->BB_axis_offset)
02410 #else
02411 #ifdef ALL_AXES
02412 , 0
02413 #endif
02414 #endif
02415 #ifdef CC
02416 ,                      (settings->CC_origin_offset + settings->CC_axis_offset)
02417 #else
02418 #ifdef ALL_AXES
02419 , 0
02420 #endif
02421 #endif
02422 );
02423       pars[5211] SET_TO settings->axis_offset_x;
02424       pars[5212] SET_TO settings->axis_offset_y;
02425       pars[5213] SET_TO settings->axis_offset_z;
02426 #ifdef AA
02427       pars[5214] SET_TO settings->AA_axis_offset;                      /*AA*/
02428 #endif
02429 #ifdef BB
02430       pars[5215] SET_TO settings->BB_axis_offset;                      /*BB*/
02431 #endif
02432 #ifdef CC
02433       pars[5216] SET_TO settings->CC_axis_offset;                      /*CC*/
02434 #endif
02435 
02436     }
02437   else if ((g_code IS G_92_1) OR (g_code IS G_92_2))
02438     {
02439       settings->current_x SET_TO
02440         settings->current_x + settings->axis_offset_x;
02441       settings->current_y SET_TO
02442         settings->current_y + settings->axis_offset_y;
02443       settings->current_z SET_TO
02444         settings->current_z + settings->axis_offset_z;
02445 #ifdef AA
02446       settings->AA_current SET_TO                                      /*AA*/
02447 #endif
02448 #ifdef AA
02449         (settings->AA_current + settings->AA_axis_offset);             /*AA*/
02450 #endif
02451 #ifdef BB
02452       settings->BB_current SET_TO                                      /*BB*/
02453 #endif
02454 #ifdef BB
02455         (settings->BB_current + settings->BB_axis_offset);             /*BB*/
02456 #endif
02457 #ifdef CC
02458       settings->CC_current SET_TO                                      /*CC*/
02459 #endif
02460 #ifdef CC
02461         (settings->CC_current + settings->CC_axis_offset);             /*CC*/
02462 #endif
02463       SET_ORIGIN_OFFSETS(settings->origin_offset_x,
02464                          settings->origin_offset_y,
02465                          settings->origin_offset_z
02466 #ifdef AA
02467 ,                        settings->AA_origin_offset
02468 #else
02469 #ifdef ALL_AXES
02470 , 0
02471 #endif
02472 #endif
02473 #ifdef BB
02474 ,                        settings->BB_origin_offset
02475 #else
02476 #ifdef ALL_AXES
02477 , 0
02478 #endif
02479 #endif
02480 #ifdef CC
02481 ,                        settings->CC_origin_offset
02482 #else
02483 #ifdef ALL_AXES
02484 , 0
02485 #endif
02486 #endif
02487 );
02488       settings->axis_offset_x SET_TO 0.0;
02489       settings->axis_offset_y SET_TO 0.0;
02490       settings->axis_offset_z SET_TO 0.0;
02491 #ifdef AA
02492       settings->AA_axis_offset SET_TO 0.0;                             /*AA*/
02493 #endif
02494 #ifdef BB
02495       settings->BB_axis_offset SET_TO 0.0;                             /*BB*/
02496 #endif
02497 #ifdef CC
02498       settings->CC_axis_offset SET_TO 0.0;                             /*CC*/
02499 #endif
02500       if (g_code IS G_92_1)
02501         {
02502           pars[5211] SET_TO 0.0;
02503           pars[5212] SET_TO 0.0;
02504           pars[5213] SET_TO 0.0;
02505 #ifdef AA
02506           pars[5214] SET_TO 0.0;                                       /*AA*/
02507 #endif
02508 #ifdef BB
02509           pars[5215] SET_TO 0.0;                                       /*BB*/
02510 #endif
02511 #ifdef CC
02512           pars[5216] SET_TO 0.0;                                       /*CC*/
02513 #endif
02514         }
02515     }
02516   else if (g_code IS G_92_3)
02517     {
02518       settings->current_x SET_TO
02519         settings->current_x + settings->axis_offset_x - pars[5211];
02520       settings->current_y SET_TO
02521         settings->current_y + settings->axis_offset_y - pars[5212];
02522       settings->current_z SET_TO
02523         settings->current_z + settings->axis_offset_z - pars[5213];
02524 #ifdef AA
02525       settings->AA_current SET_TO                                      /*AA*/
02526 #endif
02527 #ifdef AA
02528         settings->AA_current + settings->AA_axis_offset - pars[5214];  /*AA*/
02529 #endif
02530 #ifdef BB
02531       settings->BB_current SET_TO                                      /*BB*/
02532 #endif
02533 #ifdef BB
02534         settings->BB_current + settings->BB_axis_offset - pars[5215];  /*BB*/
02535 #endif
02536 #ifdef CC
02537       settings->CC_current SET_TO                                      /*CC*/
02538 #endif
02539 #ifdef CC
02540         settings->CC_current + settings->CC_axis_offset - pars[5216];  /*CC*/
02541 #endif
02542       settings->axis_offset_x SET_TO pars[5211];
02543       settings->axis_offset_y SET_TO pars[5212];
02544       settings->axis_offset_z SET_TO pars[5213];
02545 #ifdef AA
02546       settings->AA_axis_offset SET_TO pars[5214];                      /*AA*/
02547 #endif
02548 #ifdef BB
02549       settings->BB_axis_offset SET_TO pars[5215];                      /*BB*/
02550 #endif
02551 #ifdef CC
02552       settings->CC_axis_offset SET_TO pars[5216];                      /*CC*/
02553 #endif
02554       SET_ORIGIN_OFFSETS(settings->origin_offset_x + settings->axis_offset_x,
02555                          settings->origin_offset_y + settings->axis_offset_y,
02556                          settings->origin_offset_z + settings->axis_offset_z
02557 #ifdef AA
02558 ,                      (settings->AA_origin_offset + settings->AA_axis_offset)
02559 #else
02560 #ifdef ALL_AXES
02561 , 0
02562 #endif
02563 #endif
02564 #ifdef BB
02565 ,                      (settings->BB_origin_offset + settings->BB_axis_offset)
02566 #else
02567 #ifdef ALL_AXES
02568 , 0
02569 #endif
02570 #endif
02571 #ifdef CC
02572 ,                      (settings->CC_origin_offset + settings->CC_axis_offset)
02573 #else
02574 #ifdef ALL_AXES
02575 , 0
02576 #endif
02577 #endif
02578 );
02579     }
02580   else
02581     ERM(NCE_BUG_CODE_NOT_IN_G92_SERIES);
02582 
02583   return RS274NGC_OK;
02584 }

int convert_comment char *    comment [static]
 

Definition at line 2609 of file rs274ngc_pre.cc.

Referenced by execute_block().

02611 {
02612   int m;
02613   int item;
02614 
02615   for (m SET_TO 0; ((item SET_TO comment[m]) IS ' ') OR (item IS '\t') ; m++);
02616   if ((item ISNT 'M') AND (item ISNT 'm'))
02617     {
02618       COMMENT(comment);
02619       return RS274NGC_OK;
02620     }
02621   for (m++; ((item SET_TO comment[m]) IS ' ') OR (item IS '\t') ; m++);
02622   if ((item ISNT 'S') AND (item ISNT 's'))
02623     {
02624       COMMENT(comment);
02625       return RS274NGC_OK;
02626     }
02627   for (m++; ((item SET_TO comment[m]) IS ' ') OR (item IS '\t') ; m++);
02628   if ((item ISNT 'G') AND (item ISNT 'g'))
02629     {
02630       COMMENT(comment);
02631       return RS274NGC_OK;
02632     }
02633   for (m++; ((item SET_TO comment[m]) IS ' ') OR (item IS '\t') ; m++);
02634   if (item ISNT ',')
02635     {
02636       COMMENT(comment);
02637       return RS274NGC_OK;
02638     }
02639   MESSAGE(comment + m + 1);
02640   return RS274NGC_OK;
02641 }

int convert_control_mode int    g_code,
setup_pointer    settings
[static]
 

Definition at line 2676 of file rs274ngc_pre.cc.

02679 {
02680   static char name[] SET_TO "convert_control_mode";
02681   if (g_code IS G_61)
02682     {
02683       SET_MOTION_CONTROL_MODE(CANON_EXACT_PATH);
02684       settings->control_mode SET_TO CANON_EXACT_PATH;
02685     }
02686   else if (g_code IS G_61_1)
02687     {
02688       SET_MOTION_CONTROL_MODE(CANON_EXACT_STOP);
02689       settings->control_mode SET_TO CANON_EXACT_STOP;
02690     }
02691   else if (g_code IS G_64)
02692     {
02693       SET_MOTION_CONTROL_MODE(CANON_CONTINUOUS);
02694       settings->control_mode SET_TO CANON_CONTINUOUS;
02695     }
02696   else
02697     ERM(NCE_BUG_CODE_NOT_G61_G61_1_OR_G64);
02698   return RS274NGC_OK;
02699 }

int convert_coordinate_system int    g_code,
setup_pointer    settings
[static]
 

Definition at line 2772 of file rs274ngc_pre.cc.

02775 {
02776   static char name[] SET_TO "convert_coordinate_system";
02777   int origin;
02778   double x;
02779   double y;
02780   double z;
02781 #ifdef AA
02782   double a; /*AA*/
02783 #endif
02784 #ifdef BB
02785   double b; /*BB*/
02786 #endif
02787 #ifdef CC
02788   double c; /*CC*/
02789 #endif
02790   double * parameters;
02791 
02792   parameters SET_TO settings->parameters;
02793   switch(g_code)
02794     {
02795     case 540:
02796       origin SET_TO 1;
02797       break;
02798     case 550:
02799       origin SET_TO 2;
02800       break;
02801     case 560:
02802       origin SET_TO 3;
02803       break;
02804     case 570:
02805       origin SET_TO 4;
02806       break;
02807     case 580:
02808       origin SET_TO 5;
02809       break;
02810     case 590:
02811       origin SET_TO 6;
02812       break;
02813     case 591:
02814       origin SET_TO 7;
02815       break;
02816     case 592:
02817       origin SET_TO 8;
02818       break;
02819     case 593:
02820       origin SET_TO 9;
02821       break;
02822     default:
02823       ERM(NCE_BUG_CODE_NOT_IN_RANGE_G54_TO_G593);
02824     }
02825 
02826   if (origin IS settings->origin_index) /* already using this origin */
02827     {
02828 #ifdef DEBUG_EMC
02829       COMMENT("interpreter: continuing to use same coordinate system");
02830 #endif
02831       return RS274NGC_OK;
02832     }
02833 
02834   settings->origin_index SET_TO origin;
02835   parameters[5220] SET_TO (double)origin;
02836 
02837 /* axis offsets could be included in the two set of calculations for
02838    current_x, current_y, etc., but do not need to be because the results
02839    would be the same. They would be added in then subtracted out. */
02840   settings->current_x SET_TO
02841     (settings->current_x + settings->origin_offset_x);
02842   settings->current_y SET_TO
02843     (settings->current_y + settings->origin_offset_y);
02844   settings->current_z SET_TO
02845     (settings->current_z + settings->origin_offset_z);
02846 #ifdef AA
02847   settings->AA_current SET_TO                                /*AA*/
02848 #endif
02849 #ifdef AA
02850     (settings->AA_current + settings->AA_origin_offset);     /*AA*/
02851 #endif
02852 #ifdef BB
02853   settings->BB_current SET_TO                                /*BB*/
02854 #endif
02855 #ifdef BB
02856     (settings->BB_current + settings->BB_origin_offset);     /*BB*/
02857 #endif
02858 #ifdef CC
02859   settings->CC_current SET_TO                                /*CC*/
02860 #endif
02861 #ifdef CC
02862     (settings->CC_current + settings->CC_origin_offset);     /*CC*/
02863 #endif
02864 
02865   x SET_TO parameters[5201 + (origin * 20)];
02866   y SET_TO parameters[5202 + (origin * 20)];
02867   z SET_TO parameters[5203 + (origin * 20)];
02868 #ifdef AA
02869   a SET_TO parameters[5204 + (origin * 20)]; /*AA*/
02870 #endif
02871 #ifdef BB
02872   b SET_TO parameters[5205 + (origin * 20)]; /*BB*/
02873 #endif
02874 #ifdef CC
02875   c SET_TO parameters[5206 + (origin * 20)]; /*CC*/
02876 #endif
02877 
02878   settings->origin_offset_x SET_TO x;
02879   settings->origin_offset_y SET_TO y;
02880   settings->origin_offset_z SET_TO z;
02881 #ifdef AA
02882   settings->AA_origin_offset SET_TO a;                       /*AA*/
02883 #endif
02884 #ifdef BB
02885   settings->BB_origin_offset SET_TO b;                       /*BB*/
02886 #endif
02887 #ifdef CC
02888   settings->CC_origin_offset SET_TO c;                       /*CC*/
02889 #endif
02890 
02891   settings->current_x SET_TO (settings->current_x - x);
02892   settings->current_y SET_TO (settings->current_y - y);
02893   settings->current_z SET_TO (settings->current_z - z);
02894 #ifdef AA
02895   settings->AA_current SET_TO (settings->AA_current - a);    /*AA*/
02896 #endif
02897 #ifdef BB
02898   settings->BB_current SET_TO (settings->BB_current - b);    /*BB*/
02899 #endif
02900 #ifdef CC
02901   settings->CC_current SET_TO (settings->CC_current - c);    /*CC*/
02902 #endif
02903 
02904   SET_ORIGIN_OFFSETS(x + settings->axis_offset_x,
02905                      y + settings->axis_offset_y,
02906                      z + settings->axis_offset_z
02907 #ifdef AA
02908 ,                    a + settings->AA_axis_offset
02909 #else
02910 #ifdef ALL_AXES
02911 , 0
02912 #endif
02913 #endif
02914 #ifdef BB
02915 ,                    b + settings->BB_axis_offset
02916 #else
02917 #ifdef ALL_AXES
02918 , 0
02919 #endif
02920 #endif
02921 #ifdef CC
02922 ,                    c + settings->CC_axis_offset
02923 #else
02924 #ifdef ALL_AXES
02925 , 0
02926 #endif
02927 #endif
02928 );
02929   return RS274NGC_OK;
02930 }

int convert_cutter_compensation int    g_code,
block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 2957 of file rs274ngc_pre.cc.

02961 {
02962   static char name[] SET_TO "convert_cutter_compensation";
02963   int status;
02964 
02965   if (g_code IS G_40)
02966     {
02967       CHP(convert_cutter_compensation_off(settings));
02968     }
02969   else if (g_code IS G_41)
02970     {
02971       CHP(convert_cutter_compensation_on(LEFT, block, settings));
02972     }
02973   else if (g_code IS G_42)
02974     {
02975       CHP(convert_cutter_compensation_on(RIGHT, block, settings));
02976     }
02977   else
02978     ERM(NCE_BUG_CODE_NOT_G40_G41_OR_G42);
02979 
02980   return RS274NGC_OK;
02981 }

int convert_cutter_compensation_off setup_pointer    settings [static]
 

Definition at line 3000 of file rs274ngc_pre.cc.

Referenced by convert_cutter_compensation().

03002 {
03003 #ifdef DEBUG_EMC
03004   COMMENT("interpreter: cutter radius compensation off");
03005 #endif
03006   settings->cutter_comp_side SET_TO OFF;
03007   settings->program_x SET_TO UNKNOWN;
03008   return RS274NGC_OK;
03009 }

int convert_cutter_compensation_on int    side,
block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 3063 of file rs274ngc_pre.cc.

03067 {
03068   static char name[] SET_TO "convert_cutter_compensation_on";
03069   double radius;
03070   int index;
03071 
03072   CHK((settings->plane ISNT CANON_PLANE_XY),
03073       NCE_CANNOT_TURN_CUTTER_RADIUS_COMP_ON_OUT_OF_XY_PLANE);
03074   CHK((settings->cutter_comp_side ISNT OFF),
03075       NCE_CANNOT_TURN_CUTTER_RADIUS_COMP_ON_WHEN_ON);
03076   index SET_TO
03077     (block->d_number ISNT -1) ? block->d_number : settings->current_slot;
03078   radius SET_TO ((settings->tool_table[index].diameter)/2.0);
03079 
03080   if (radius < 0.0) /* switch side & make radius positive if radius negative */
03081     {
03082       radius SET_TO -radius;
03083       if (side IS RIGHT)
03084         side SET_TO LEFT;
03085       else
03086         side SET_TO RIGHT;
03087     }
03088 
03089 #ifdef DEBUG_EMC
03090   if (side IS RIGHT)
03091     COMMENT("interpreter: cutter radius compensation on right");
03092   else
03093     COMMENT("interpreter: cutter radius compensation on left");
03094 #endif
03095 
03096   settings->cutter_comp_radius SET_TO radius;
03097   settings->tool_table_index SET_TO index;
03098   settings->cutter_comp_side SET_TO side;
03099   return RS274NGC_OK;
03100 }

int convert_cycle int    motion,
block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 3132 of file rs274ngc_pre.cc.

03136 {
03137   static char name[] SET_TO "convert_cycle";
03138   CANON_PLANE plane;
03139   int status;
03140 
03141   plane SET_TO settings->plane;
03142   if (block->r_flag IS OFF)
03143     {
03144       if (settings->motion_mode IS motion)
03145         block->r_number SET_TO settings->cycle_r;
03146       else
03147         ERM(NCE_R_CLEARANCE_PLANE_UNSPECIFIED_IN_CYCLE);
03148     }
03149 
03150   CHK((block->l_number IS 0), NCE_CANNOT_DO_ZERO_REPEATS_OF_CYCLE);
03151   if (block->l_number IS -1)
03152     block->l_number SET_TO 1;
03153 
03154   if (plane IS CANON_PLANE_XY)
03155     {
03156       CHP(convert_cycle_xy(motion, block, settings));
03157     }
03158   else if (plane IS CANON_PLANE_YZ)
03159     {
03160       CHP(convert_cycle_yz(motion, block, settings));
03161     }
03162   else if (plane IS CANON_PLANE_XZ)
03163     {
03164       CHP(convert_cycle_zx(motion, block, settings));
03165     }
03166   else
03167     ERM(NCE_BUG_PLANE_NOT_XY_YZ_OR_XZ);
03168 
03169   settings->cycle_l SET_TO block->l_number;
03170   settings->cycle_r SET_TO block->r_number;
03171   settings->motion_mode SET_TO motion;
03172   return RS274NGC_OK;
03173 }

int convert_cycle_g81 CANON_PLANE    plane,
double    x,
double    y,
double    clear_z,
double    bottom_z
[static]
 

Definition at line 3201 of file rs274ngc_pre.cc.

03207 {
03208   static char name[] SET_TO "convert_cycle_g81";
03209 
03210   cycle_feed(plane, x, y, bottom_z);
03211   cycle_traverse(plane, x, y, clear_z);
03212 
03213   return RS274NGC_OK;
03214 }

int convert_cycle_g82 CANON_PLANE    plane,
double    x,
double    y,
double    clear_z,
double    bottom_z,
double    dwell
[static]
 

Definition at line 3241 of file rs274ngc_pre.cc.

03248 {
03249   static char name[] SET_TO "convert_cycle_g82";
03250 
03251   cycle_feed(plane, x, y, bottom_z);
03252   DWELL(dwell);
03253   cycle_traverse(plane, x, y, clear_z);
03254 
03255   return RS274NGC_OK;
03256 }

int convert_cycle_g83 CANON_PLANE    plane,
double    x,
double    y,
double    r,
double    clear_z,
double    bottom_z,
double    delta
[static]
 

Definition at line 3293 of file rs274ngc_pre.cc.

03301 {
03302   static char name[] SET_TO "convert_cycle_g83";
03303   double current_depth;
03304   double rapid_delta;
03305 
03306   rapid_delta SET_TO G83_RAPID_DELTA;
03307   if (_setup.length_units IS CANON_UNITS_MM)
03308     rapid_delta SET_TO (rapid_delta * 25.4);
03309 
03310   for (current_depth SET_TO (r - delta);
03311        current_depth > bottom_z;
03312        current_depth SET_TO (current_depth - delta))
03313     {
03314       cycle_feed(plane, x, y, current_depth);
03315       cycle_traverse(plane, x, y, clear_z);
03316       cycle_traverse(plane, x, y, current_depth + rapid_delta);
03317     }
03318   cycle_feed(plane, x, y, bottom_z);
03319   cycle_traverse(plane, x, y, clear_z);
03320 
03321   return RS274NGC_OK;
03322 }

int convert_cycle_g84 CANON_PLANE    plane,
double    x,
double    y,
double    clear_z,
double    bottom_z,
CANON_DIRECTION    direction,
CANON_SPEED_FEED_MODE    mode
[static]
 

Definition at line 3358 of file rs274ngc_pre.cc.

03366 {
03367   static char name[] SET_TO "convert_cycle_g84";
03368 
03369   CHK((direction ISNT CANON_CLOCKWISE),
03370       NCE_SPINDLE_NOT_TURNING_CLOCKWISE_IN_G84);
03371   START_SPEED_FEED_SYNCH();
03372   cycle_feed(plane, x, y, bottom_z);
03373   STOP_SPINDLE_TURNING();
03374   START_SPINDLE_COUNTERCLOCKWISE();
03375   cycle_feed(plane, x, y, clear_z);
03376   if (mode ISNT CANON_SYNCHED)
03377     STOP_SPEED_FEED_SYNCH();
03378   STOP_SPINDLE_TURNING();
03379   START_SPINDLE_CLOCKWISE();
03380 
03381   return RS274NGC_OK;
03382 }

int convert_cycle_g85 CANON_PLANE    plane,
double    x,
double    y,
double    clear_z,
double    bottom_z
[static]
 

Definition at line 3409 of file rs274ngc_pre.cc.

03415 {
03416   static char name[] SET_TO "convert_cycle_g85";
03417 
03418   cycle_feed(plane, x, y, bottom_z);
03419   cycle_feed(plane, x, y, clear_z);
03420 
03421   return RS274NGC_OK;
03422 }

int convert_cycle_g86 CANON_PLANE    plane,
double    x,
double    y,
double    clear_z,
double    bottom_z,
double    dwell,
CANON_DIRECTION    direction
[static]
 

Definition at line 3455 of file rs274ngc_pre.cc.

03463 {
03464   static char name[] SET_TO "convert_cycle_g86";
03465 
03466   CHK(((direction ISNT CANON_CLOCKWISE) AND
03467        (direction ISNT CANON_COUNTERCLOCKWISE)),
03468       NCE_SPINDLE_NOT_TURNING_IN_G86);
03469 
03470   cycle_feed(plane, x, y, bottom_z);
03471   DWELL(dwell);
03472   STOP_SPINDLE_TURNING();
03473   cycle_traverse(plane, x, y, clear_z);
03474   if (direction IS CANON_CLOCKWISE)
03475     START_SPINDLE_CLOCKWISE();
03476   else
03477     START_SPINDLE_COUNTERCLOCKWISE();
03478 
03479   return RS274NGC_OK;
03480 }

int convert_cycle_g87 CANON_PLANE    plane,
double    x,
double    offset_x,
double    y,
double    offset_y,
double    r,
double    clear_z,
double    middle_z,
double    bottom_z,
CANON_DIRECTION    direction
[static]
 

Definition at line 3541 of file rs274ngc_pre.cc.

03552 {
03553   static char name[] SET_TO "convert_cycle_g87";
03554 
03555   CHK(((direction ISNT CANON_CLOCKWISE) AND
03556        (direction ISNT CANON_COUNTERCLOCKWISE)),
03557       NCE_SPINDLE_NOT_TURNING_IN_G87);
03558 
03559   cycle_traverse(plane, offset_x, offset_y, r);
03560   STOP_SPINDLE_TURNING();
03561   ORIENT_SPINDLE(0.0, direction);
03562   cycle_traverse(plane, offset_x, offset_y, bottom_z);
03563   cycle_traverse(plane, x, y, bottom_z);
03564   if (direction IS CANON_CLOCKWISE)
03565     START_SPINDLE_CLOCKWISE();
03566   else
03567     START_SPINDLE_COUNTERCLOCKWISE();
03568   cycle_feed(plane, x, y, middle_z);
03569   cycle_feed(plane, x, y, bottom_z);
03570   STOP_SPINDLE_TURNING();
03571   ORIENT_SPINDLE(0.0, direction);
03572   cycle_traverse(plane, offset_x, offset_y, bottom_z);
03573   cycle_traverse(plane, offset_x, offset_y, clear_z);
03574   cycle_traverse(plane, x, y, clear_z);
03575   if (direction IS CANON_CLOCKWISE)
03576     START_SPINDLE_CLOCKWISE();
03577   else
03578     START_SPINDLE_COUNTERCLOCKWISE();
03579 
03580   return RS274NGC_OK;
03581 }

int convert_cycle_g88 CANON_PLANE    plane,
double    x,
double    y,
double    bottom_z,
double    dwell,
CANON_DIRECTION    direction
[static]
 

Definition at line 3613 of file rs274ngc_pre.cc.

03620 {
03621   static char name[] SET_TO "convert_cycle_g88";
03622 
03623   CHK(((direction ISNT CANON_CLOCKWISE) AND
03624        (direction ISNT CANON_COUNTERCLOCKWISE)),
03625       NCE_SPINDLE_NOT_TURNING_IN_G88);
03626 
03627   cycle_feed(plane, x, y, bottom_z);
03628   DWELL(dwell);
03629   STOP_SPINDLE_TURNING();
03630   PROGRAM_STOP(); /* operator retracts the spindle here */
03631   if (direction IS CANON_CLOCKWISE)
03632     START_SPINDLE_CLOCKWISE();
03633   else
03634     START_SPINDLE_COUNTERCLOCKWISE();
03635 
03636   return RS274NGC_OK;
03637 }

int convert_cycle_g89 CANON_PLANE    plane,
double    x,
double    y,
double    clear_z,
double    bottom_z,
double    dwell
[static]
 

Definition at line 3663 of file rs274ngc_pre.cc.

03670 {
03671   static char name[] SET_TO "convert_cycle_g89";
03672 
03673   cycle_feed(plane, x, y, bottom_z);
03674   DWELL(dwell);
03675   cycle_feed(plane, x, y, clear_z);
03676 
03677   return RS274NGC_OK;
03678 }

int convert_cycle_xy int    motion,
block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 3797 of file rs274ngc_pre.cc.

03801 {
03802   static char name[] SET_TO "convert_cycle_xy";
03803   double aa;
03804   double aa_increment;
03805   double bb;
03806   double bb_increment;
03807   double cc;
03808   double clear_cc;
03809   double i;
03810   double j;
03811   double k;
03812   double old_cc;
03813   CANON_PLANE plane;
03814   double r;
03815   int repeat;
03816   CANON_MOTION_MODE save_mode;
03817   int status;
03818 
03819   plane SET_TO CANON_PLANE_XY;
03820   if (settings->motion_mode ISNT motion)
03821     {
03822       CHK((block->z_flag IS OFF),
03823           NCE_Z_VALUE_UNSPECIFIED_IN_XY_PLANE_CANNED_CYCLE);
03824     }
03825   block->z_number SET_TO
03826     block->z_flag IS ON ? block->z_number : settings->cycle_cc;
03827   old_cc SET_TO settings->current_z;
03828 
03829   if (settings->distance_mode IS MODE_ABSOLUTE)
03830     {
03831       aa_increment SET_TO 0.0;
03832       bb_increment SET_TO 0.0;
03833       r SET_TO block->r_number;
03834       cc SET_TO block->z_number;
03835       aa SET_TO block->x_flag IS ON ? block->x_number : settings->current_x;
03836       bb SET_TO block->y_flag IS ON ? block->y_number : settings->current_y;
03837     }
03838   else if (settings->distance_mode IS MODE_INCREMENTAL)
03839     {
03840       aa_increment SET_TO block->x_number;
03841       bb_increment SET_TO block->y_number;
03842       r SET_TO (block->r_number + old_cc);
03843       cc SET_TO (r + block->z_number); /* [NCMS, page 98] */
03844       aa SET_TO settings->current_x;
03845       bb SET_TO settings->current_y;
03846     }
03847   else
03848     ERM(NCE_BUG_DISTANCE_MODE_NOT_G90_OR_G91);
03849   CHK((r < cc), NCE_R_LESS_THAN_Z_IN_CYCLE_IN_XY_PLANE);
03850 
03851   if (old_cc < r)
03852     {
03853       STRAIGHT_TRAVERSE(settings->current_x, settings->current_y, r
03854 #ifdef AA
03855 ,         settings->AA_current
03856 #else
03857 #ifdef ALL_AXES
03858 , 0
03859 #endif
03860 #endif
03861 #ifdef BB
03862 ,  settings->BB_current
03863 #else
03864 #ifdef ALL_AXES
03865 , 0
03866 #endif
03867 #endif
03868 #ifdef CC
03869 ,  settings->CC_current
03870 #else
03871 #ifdef ALL_AXES
03872 , 0
03873 #endif
03874 #endif
03875 );
03876       old_cc SET_TO r;
03877     }
03878   clear_cc SET_TO (settings->retract_mode IS R_PLANE) ? r : old_cc;
03879 
03880   save_mode SET_TO GET_EXTERNAL_MOTION_CONTROL_MODE();
03881   if (save_mode ISNT CANON_EXACT_PATH)
03882     SET_MOTION_CONTROL_MODE(CANON_EXACT_PATH);
03883 
03884   switch(motion)
03885     {
03886     case G_81:
03887       CYCLE_MACRO(convert_cycle_g81(CANON_PLANE_XY, aa, bb, clear_cc, cc))
03888       break;
03889     case G_82:
03890       CHK(((settings->motion_mode ISNT G_82) AND (block->p_number IS -1.0)),
03891           NCE_DWELL_TIME_P_WORD_MISSING_WITH_G82);
03892       block->p_number SET_TO
03893         block->p_number IS -1.0 ? settings->cycle_p : block->p_number;
03894       CYCLE_MACRO(convert_cycle_g82 (CANON_PLANE_XY, aa, bb, clear_cc, cc,
03895                                      block->p_number))
03896       settings->cycle_p SET_TO block->p_number;
03897       break;
03898     case G_83:
03899       CHK(((settings->motion_mode ISNT G_83) AND (block->q_number IS -1.0)),
03900           NCE_Q_WORD_MISSING_WITH_G83);
03901       block->q_number SET_TO
03902         block->q_number IS -1.0 ? settings->cycle_q : block->q_number;
03903       CYCLE_MACRO(convert_cycle_g83 (CANON_PLANE_XY, aa, bb, r, clear_cc, cc,
03904                                      block->q_number))
03905       settings->cycle_q SET_TO block->q_number;
03906       break;
03907     case G_84:
03908       CYCLE_MACRO(convert_cycle_g84 (CANON_PLANE_XY, aa, bb, clear_cc, cc,
03909                       settings->spindle_turning, settings->speed_feed_mode))
03910       break;
03911     case G_85:
03912       CYCLE_MACRO(convert_cycle_g85 (CANON_PLANE_XY, aa, bb, clear_cc, cc))
03913       break;
03914     case G_86:
03915       CHK(((settings->motion_mode ISNT G_86) AND (block->p_number IS -1.0)),
03916           NCE_DWELL_TIME_P_WORD_MISSING_WITH_G86);
03917       block->p_number SET_TO
03918         block->p_number IS -1.0 ? settings->cycle_p : block->p_number;
03919       CYCLE_MACRO(convert_cycle_g86 (CANON_PLANE_XY, aa, bb, clear_cc, cc,
03920                             block->p_number, settings->spindle_turning))
03921       settings->cycle_p SET_TO block->p_number;
03922       break;
03923     case G_87:
03924       if (settings->motion_mode ISNT G_87)
03925         {
03926           CHK((block->i_flag IS OFF), NCE_I_WORD_MISSING_WITH_G87);
03927           CHK((block->j_flag IS OFF), NCE_J_WORD_MISSING_WITH_G87);
03928           CHK((block->k_flag IS OFF), NCE_K_WORD_MISSING_WITH_G87);
03929         }
03930       i SET_TO block->i_flag IS ON ? block->i_number : settings->cycle_i;
03931       j SET_TO block->j_flag IS ON ? block->j_number : settings->cycle_j;
03932       k SET_TO block->k_flag IS ON ? block->k_number : settings->cycle_k;
03933       settings->cycle_i SET_TO i;
03934       settings->cycle_j SET_TO j;
03935       settings->cycle_k SET_TO k;
03936       if (settings->distance_mode IS MODE_INCREMENTAL)
03937         {
03938           k SET_TO (cc + k); /* k always absolute in function call below */
03939         }
03940       CYCLE_MACRO(convert_cycle_g87 (CANON_PLANE_XY, aa, (aa + i), bb,
03941                       (bb + j), r, clear_cc, k, cc, settings->spindle_turning))
03942       break;
03943     case G_88:
03944       CHK(((settings->motion_mode ISNT G_88) AND (block->p_number IS -1.0)),
03945           NCE_DWELL_TIME_P_WORD_MISSING_WITH_G88);
03946       block->p_number SET_TO
03947         block->p_number IS -1.0 ? settings->cycle_p : block->p_number;
03948       CYCLE_MACRO(convert_cycle_g88 (CANON_PLANE_XY, aa, bb, cc,
03949                                 block->p_number, settings->spindle_turning))
03950       settings->cycle_p SET_TO block->p_number;
03951       break;
03952     case G_89:
03953       CHK(((settings->motion_mode ISNT G_89) AND (block->p_number IS -1.0)),
03954           NCE_DWELL_TIME_P_WORD_MISSING_WITH_G89);
03955       block->p_number SET_TO
03956         block->p_number IS -1.0 ? settings->cycle_p : block->p_number;
03957       CYCLE_MACRO(convert_cycle_g89 (CANON_PLANE_XY, aa, bb, clear_cc, cc,
03958                                      block->p_number))
03959       settings->cycle_p SET_TO block->p_number;
03960       break;
03961     default:
03962       ERM(NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
03963     }
03964   settings->current_x SET_TO aa; /* CYCLE_MACRO updates aa and bb */
03965   settings->current_y SET_TO bb;
03966   settings->current_z SET_TO clear_cc;
03967   settings->cycle_cc SET_TO block->z_number;
03968 
03969   if (save_mode ISNT CANON_EXACT_PATH)
03970     SET_MOTION_CONTROL_MODE(save_mode);
03971 
03972   return RS274NGC_OK;
03973 }

int convert_cycle_yz int    motion,
block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 4024 of file rs274ngc_pre.cc.

04028 {
04029   static char name[] SET_TO "convert_cycle_yz";
04030   double aa;
04031   double aa_increment;
04032   double bb;
04033   double bb_increment;
04034   double cc;
04035   double clear_cc;
04036   double i;
04037   double j;
04038   double k;
04039   double old_cc;
04040   CANON_PLANE plane;
04041   double r;
04042   int repeat;
04043   CANON_MOTION_MODE save_mode;
04044   int status;
04045 
04046   plane SET_TO CANON_PLANE_YZ;
04047   if (settings->motion_mode ISNT motion)
04048     {
04049       CHK((block->x_flag IS OFF),
04050           NCE_X_VALUE_UNSPECIFIED_IN_YZ_PLANE_CANNED_CYCLE);
04051     }
04052   block->x_number SET_TO
04053     block->x_flag IS ON ? block->x_number : settings->cycle_cc;
04054   old_cc SET_TO settings->current_x;
04055 
04056   if (settings->distance_mode IS MODE_ABSOLUTE)
04057     {
04058       aa_increment SET_TO 0.0;
04059       bb_increment SET_TO 0.0;
04060       r SET_TO block->r_number;
04061       cc SET_TO block->x_number;
04062       aa SET_TO block->y_flag IS ON ? block->y_number : settings->current_y;
04063       bb SET_TO block->z_flag IS ON ? block->z_number : settings->current_z;
04064     }
04065   else if (settings->distance_mode IS MODE_INCREMENTAL)
04066     {
04067       aa_increment SET_TO block->y_number;
04068       bb_increment SET_TO block->z_number;
04069       r SET_TO (block->r_number + old_cc);
04070       cc SET_TO (r + block->x_number); /* [NCMS, page 98] */
04071       aa SET_TO settings->current_y;
04072       bb SET_TO settings->current_z;
04073     }
04074   else
04075     ERM(NCE_BUG_DISTANCE_MODE_NOT_G90_OR_G91);
04076   CHK((r < cc), NCE_R_LESS_THAN_X_IN_CYCLE_IN_YZ_PLANE);
04077 
04078   if (old_cc < r)
04079     {
04080       STRAIGHT_TRAVERSE(r, settings->current_y, settings->current_z
04081 #ifdef AA
04082 ,          settings->AA_current
04083 #else
04084 #ifdef ALL_AXES
04085 , 0
04086 #endif
04087 #endif
04088 #ifdef BB
04089 ,  settings->BB_current
04090 #else
04091 #ifdef ALL_AXES
04092 , 0
04093 #endif
04094 #endif
04095 #ifdef CC
04096 ,  settings->CC_current
04097 #else
04098 #ifdef ALL_AXES
04099 , 0
04100 #endif
04101 #endif
04102 );
04103       old_cc SET_TO r;
04104     }
04105   clear_cc SET_TO (settings->retract_mode IS R_PLANE) ? r : old_cc;
04106 
04107   save_mode = GET_EXTERNAL_MOTION_CONTROL_MODE();
04108   if (save_mode ISNT CANON_EXACT_PATH)
04109     SET_MOTION_CONTROL_MODE(CANON_EXACT_PATH);
04110 
04111   switch(motion)
04112     {
04113     case G_81:
04114       CYCLE_MACRO(convert_cycle_g81(CANON_PLANE_YZ, aa, bb, clear_cc, cc))
04115         break;
04116     case G_82:
04117       CHK(((settings->motion_mode ISNT G_82) AND (block->p_number IS -1.0)),
04118           NCE_DWELL_TIME_P_WORD_MISSING_WITH_G82);
04119       block->p_number SET_TO
04120         block->p_number IS -1.0 ? settings->cycle_p : block->p_number;
04121       CYCLE_MACRO(convert_cycle_g82 (CANON_PLANE_YZ, aa, bb, clear_cc, cc,
04122                                      block->p_number))
04123       settings->cycle_p SET_TO block->p_number;
04124       break;
04125     case G_83:
04126       CHK(((settings->motion_mode ISNT G_83) AND (block->q_number IS -1.0)),
04127           NCE_Q_WORD_MISSING_WITH_G83);
04128       block->q_number SET_TO
04129         block->q_number IS -1.0 ? settings->cycle_q : block->q_number;
04130       CYCLE_MACRO(convert_cycle_g83 (CANON_PLANE_YZ, aa, bb, r, clear_cc, cc,
04131                                      block->q_number))
04132       settings->cycle_q SET_TO block->q_number;
04133       break;
04134     case G_84:
04135       CYCLE_MACRO(convert_cycle_g84 (CANON_PLANE_YZ, aa, bb, clear_cc, cc,
04136                       settings->spindle_turning, settings->speed_feed_mode))
04137       break;
04138     case G_85:
04139       CYCLE_MACRO(convert_cycle_g85 (CANON_PLANE_YZ, aa, bb, clear_cc, cc))
04140       break;
04141     case G_86:
04142       CHK(((settings->motion_mode ISNT G_86) AND (block->p_number IS -1.0)),
04143           NCE_DWELL_TIME_P_WORD_MISSING_WITH_G86);
04144       block->p_number SET_TO
04145         block->p_number IS -1.0 ? settings->cycle_p : block->p_number;
04146       CYCLE_MACRO(convert_cycle_g86 (CANON_PLANE_YZ, aa, bb, clear_cc, cc,
04147                             block->p_number, settings->spindle_turning))
04148       settings->cycle_p SET_TO block->p_number;
04149       break;
04150     case G_87:
04151       if (settings->motion_mode ISNT G_87)
04152         {
04153           CHK((block->i_flag IS OFF), NCE_I_WORD_MISSING_WITH_G87);
04154           CHK((block->j_flag IS OFF), NCE_J_WORD_MISSING_WITH_G87);
04155           CHK((block->k_flag IS OFF), NCE_K_WORD_MISSING_WITH_G87);
04156         }
04157       i SET_TO block->i_flag IS ON ? block->i_number : settings->cycle_i;
04158       j SET_TO block->j_flag IS ON ? block->j_number : settings->cycle_j;
04159       k SET_TO block->k_flag IS ON ? block->k_number : settings->cycle_k;
04160       settings->cycle_i SET_TO i;
04161       settings->cycle_j SET_TO j;
04162       settings->cycle_k SET_TO k;
04163       if (settings->distance_mode IS MODE_INCREMENTAL)
04164         {
04165           i SET_TO (cc + i); /* i always absolute in function call below */
04166         }
04167       CYCLE_MACRO(convert_cycle_g87 (CANON_PLANE_YZ, aa, (aa + j), bb,
04168                       (bb + k), r, clear_cc, i, cc, settings->spindle_turning))
04169       break;
04170     case G_88:
04171       CHK(((settings->motion_mode ISNT G_88) AND (block->p_number IS -1.0)),
04172           NCE_DWELL_TIME_P_WORD_MISSING_WITH_G88);
04173       block->p_number SET_TO
04174         block->p_number IS -1.0 ? settings->cycle_p : block->p_number;
04175       CYCLE_MACRO(convert_cycle_g88 (CANON_PLANE_YZ, aa, bb, cc,
04176                                 block->p_number, settings->spindle_turning))
04177       settings->cycle_p SET_TO block->p_number;
04178       break;
04179     case G_89:
04180       CHK(((settings->motion_mode ISNT G_89) AND (block->p_number IS -1.0)),
04181           NCE_DWELL_TIME_P_WORD_MISSING_WITH_G89);
04182       block->p_number SET_TO
04183         block->p_number IS -1.0 ? settings->cycle_p : block->p_number;
04184       CYCLE_MACRO(convert_cycle_g89 (CANON_PLANE_YZ, aa, bb, clear_cc, cc,
04185                                      block->p_number))
04186       settings->cycle_p SET_TO block->p_number;
04187       break;
04188     default:
04189       ERM(NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
04190     }
04191   settings->current_y SET_TO aa; /* CYCLE_MACRO updates aa and bb */
04192   settings->current_z SET_TO bb;
04193   settings->current_x SET_TO clear_cc;
04194   settings->cycle_cc SET_TO block->x_number;
04195 
04196   if (save_mode ISNT CANON_EXACT_PATH)
04197     SET_MOTION_CONTROL_MODE(save_mode);
04198 
04199   return RS274NGC_OK;
04200 }

int convert_cycle_zx int    motion,
block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 4259 of file rs274ngc_pre.cc.

04263 {
04264   static char name[] SET_TO "convert_cycle_zx";
04265   double aa;
04266   double aa_increment;
04267   double bb;
04268   double bb_increment;
04269   double cc;
04270   double clear_cc;
04271   double i;
04272   double j;
04273   double k;
04274   double old_cc;
04275   CANON_PLANE plane;
04276   double r;
04277   int repeat;
04278   CANON_MOTION_MODE save_mode;
04279   int status;
04280 
04281   plane SET_TO CANON_PLANE_XZ;
04282   if (settings->motion_mode ISNT motion)
04283     {
04284       CHK((block->y_flag IS OFF),
04285           NCE_Y_VALUE_UNSPECIFIED_IN_XZ_PLANE_CANNED_CYCLE);
04286     }
04287   block->y_number SET_TO
04288     block->y_flag IS ON ? block->y_number : settings->cycle_cc;
04289   old_cc SET_TO settings->current_y;
04290 
04291   if (settings->distance_mode IS MODE_ABSOLUTE)
04292     {
04293       aa_increment SET_TO 0.0;
04294       bb_increment SET_TO 0.0;
04295       r SET_TO block->r_number;
04296       cc SET_TO block->y_number;
04297       aa SET_TO block->z_flag IS ON ? block->z_number : settings->current_z;
04298       bb SET_TO block->x_flag IS ON ? block->x_number : settings->current_x;
04299     }
04300   else if (settings->distance_mode IS MODE_INCREMENTAL)
04301     {
04302       aa_increment SET_TO block->z_number;
04303       bb_increment SET_TO block->x_number;
04304       r SET_TO (block->r_number + old_cc);
04305       cc SET_TO (r + block->y_number); /* [NCMS, page 98] */
04306       aa SET_TO settings->current_z;
04307       bb SET_TO settings->current_x;
04308     }
04309   else
04310     ERM(NCE_BUG_DISTANCE_MODE_NOT_G90_OR_G91);
04311   CHK((r < cc), NCE_R_LESS_THAN_Y_IN_CYCLE_IN_XZ_PLANE);
04312 
04313   if (old_cc < r)
04314     {
04315       STRAIGHT_TRAVERSE(settings->current_x, r, settings->current_z
04316 #ifdef AA
04317 ,           settings->AA_current
04318 #else
04319 #ifdef ALL_AXES
04320 , 0
04321 #endif
04322 #endif
04323 #ifdef BB
04324 ,  settings->BB_current
04325 #else
04326 #ifdef ALL_AXES
04327 , 0
04328 #endif
04329 #endif
04330 #ifdef CC
04331 ,  settings->CC_current
04332 #else
04333 #ifdef ALL_AXES
04334 , 0
04335 #endif
04336 #endif
04337 );
04338       old_cc SET_TO r;
04339     }
04340   clear_cc SET_TO (settings->retract_mode IS R_PLANE) ? r : old_cc;
04341 
04342   save_mode = GET_EXTERNAL_MOTION_CONTROL_MODE();
04343   if (save_mode ISNT CANON_EXACT_PATH)
04344     SET_MOTION_CONTROL_MODE(CANON_EXACT_PATH);
04345 
04346   switch(motion)
04347     {
04348     case G_81:
04349       CYCLE_MACRO(convert_cycle_g81(CANON_PLANE_XZ, aa, bb, clear_cc, cc))
04350       break;
04351     case G_82:
04352       CHK(((settings->motion_mode ISNT G_82) AND (block->p_number IS -1.0)),
04353           NCE_DWELL_TIME_P_WORD_MISSING_WITH_G82);
04354       block->p_number SET_TO
04355         block->p_number IS -1.0 ? settings->cycle_p : block->p_number;
04356       CYCLE_MACRO(convert_cycle_g82 (CANON_PLANE_XZ, aa, bb, clear_cc, cc,
04357                                      block->p_number))
04358       settings->cycle_p SET_TO block->p_number;
04359       break;
04360     case G_83:
04361       CHK(((settings->motion_mode ISNT G_83) AND (block->q_number IS -1.0)),
04362           NCE_Q_WORD_MISSING_WITH_G83);
04363       block->q_number SET_TO
04364         block->q_number IS -1.0 ? settings->cycle_q : block->q_number;
04365       CYCLE_MACRO(convert_cycle_g83 (CANON_PLANE_XZ, aa, bb, r, clear_cc, cc,
04366                                      block->q_number))
04367       settings->cycle_q SET_TO block->q_number;
04368       break;
04369     case G_84:
04370       CYCLE_MACRO(convert_cycle_g84 (CANON_PLANE_XZ, aa, bb, clear_cc, cc,
04371                       settings->spindle_turning, settings->speed_feed_mode))
04372       break;
04373     case G_85:
04374       CYCLE_MACRO(convert_cycle_g85 (CANON_PLANE_XZ, aa, bb, clear_cc, cc))
04375       break;
04376     case G_86:
04377       CHK(((settings->motion_mode ISNT G_86) AND (block->p_number IS -1.0)),
04378           NCE_DWELL_TIME_P_WORD_MISSING_WITH_G86);
04379       block->p_number SET_TO
04380         block->p_number IS -1.0 ? settings->cycle_p : block->p_number;
04381       CYCLE_MACRO(convert_cycle_g86 (CANON_PLANE_XZ, aa, bb, clear_cc, cc,
04382                             block->p_number, settings->spindle_turning))
04383       settings->cycle_p SET_TO block->p_number;
04384       break;
04385     case G_87:
04386       if (settings->motion_mode ISNT G_87)
04387         {
04388           CHK((block->i_flag IS OFF), NCE_I_WORD_MISSING_WITH_G87);
04389           CHK((block->j_flag IS OFF), NCE_J_WORD_MISSING_WITH_G87);
04390           CHK((block->k_flag IS OFF), NCE_K_WORD_MISSING_WITH_G87);
04391         }
04392       i SET_TO block->i_flag IS ON ? block->i_number : settings->cycle_i;
04393       j SET_TO block->j_flag IS ON ? block->j_number : settings->cycle_j;
04394       k SET_TO block->k_flag IS ON ? block->k_number : settings->cycle_k;
04395       settings->cycle_i SET_TO i;
04396       settings->cycle_j SET_TO j;
04397       settings->cycle_k SET_TO k;
04398       if (settings->distance_mode IS MODE_INCREMENTAL)
04399         {
04400           j SET_TO (cc + j); /* j always absolute in function call below */
04401         }
04402       CYCLE_MACRO(convert_cycle_g87 (CANON_PLANE_XZ, aa, (aa + k), bb,
04403                       (bb + i), r, clear_cc, j, cc, settings->spindle_turning))
04404       break;
04405     case G_88:
04406       CHK(((settings->motion_mode ISNT G_88) AND (block->p_number IS -1.0)),
04407           NCE_DWELL_TIME_P_WORD_MISSING_WITH_G88);
04408       block->p_number SET_TO
04409         block->p_number IS -1.0 ? settings->cycle_p : block->p_number;
04410       CYCLE_MACRO(convert_cycle_g88 (CANON_PLANE_XZ, aa, bb, cc,
04411                                 block->p_number, settings->spindle_turning))
04412       settings->cycle_p SET_TO block->p_number;
04413       break;
04414     case G_89:
04415       CHK(((settings->motion_mode ISNT G_89) AND (block->p_number IS -1.0)),
04416           NCE_DWELL_TIME_P_WORD_MISSING_WITH_G89);
04417       block->p_number SET_TO
04418         block->p_number IS -1.0 ? settings->cycle_p : block->p_number;
04419       CYCLE_MACRO(convert_cycle_g89 (CANON_PLANE_XZ, aa, bb, clear_cc, cc,
04420                                      block->p_number))
04421       settings->cycle_p SET_TO block->p_number;
04422       break;
04423     default:
04424       ERM(NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
04425     }
04426   settings->current_z SET_TO aa; /* CYCLE_MACRO updates aa and bb */
04427   settings->current_x SET_TO bb;
04428   settings->current_y SET_TO clear_cc;
04429   settings->cycle_cc SET_TO block->y_number;
04430 
04431   if (save_mode ISNT CANON_EXACT_PATH)
04432     SET_MOTION_CONTROL_MODE(save_mode);
04433 
04434   return RS274NGC_OK;
04435 }

int convert_distance_mode int    g_code,
setup_pointer    settings
[static]
 

Definition at line 4459 of file rs274ngc_pre.cc.

04462 {
04463   static char name[] SET_TO "convert_distance_mode";
04464   if (g_code IS G_90)
04465     {
04466       if (settings->distance_mode ISNT MODE_ABSOLUTE)
04467         {
04468 #ifdef DEBUG_EMC
04469           COMMENT("interpreter: distance mode changed to absolute");
04470 #endif
04471           settings->distance_mode SET_TO MODE_ABSOLUTE;
04472         }
04473     }
04474   else if (g_code IS G_91)
04475     {
04476       if (settings->distance_mode ISNT MODE_INCREMENTAL)
04477         {
04478 #ifdef DEBUG_EMC
04479           COMMENT("interpreter: distance mode changed to incremental");
04480 #endif
04481           settings->distance_mode SET_TO MODE_INCREMENTAL;
04482         }
04483     }
04484   else
04485     ERM(NCE_BUG_CODE_NOT_G90_OR_G91);
04486   return RS274NGC_OK;
04487 }

int convert_dwell double    time [static]
 

Definition at line 4502 of file rs274ngc_pre.cc.

Referenced by convert_g().

04504 {
04505   DWELL(time);
04506   return RS274NGC_OK;
04507 }

int convert_feed_mode int    g_code,
setup_pointer    settings
[static]
 

Definition at line 4531 of file rs274ngc_pre.cc.

04534 {
04535   static char name[] SET_TO "convert_feed_mode";
04536   if (g_code IS G_93)
04537     {
04538 #ifdef DEBUG_EMC
04539       COMMENT("interpreter: feed mode set to inverse time");
04540 #endif
04541       settings->feed_mode SET_TO INVERSE_TIME;
04542     }
04543   else if (g_code IS G_94)
04544     {
04545 #ifdef DEBUG_EMC
04546       COMMENT("interpreter: feed mode set to units per minute");
04547 #endif
04548       settings->feed_mode SET_TO UNITS_PER_MINUTE;
04549     }
04550   else
04551     ERM(NCE_BUG_CODE_NOT_G93_OR_G94);
04552   return RS274NGC_OK;
04553 }

int convert_feed_rate block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 4572 of file rs274ngc_pre.cc.

04575 {
04576   SET_FEED_RATE(block->f_number);
04577   settings->feed_rate SET_TO block->f_number;
04578   return RS274NGC_OK;
04579 }

int convert_g block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 4637 of file rs274ngc_pre.cc.

04640 {
04641   static char name[] SET_TO "convert_g";
04642   int status;
04643 
04644   if (block->g_modes[0] IS G_4)
04645     {
04646       CHP(convert_dwell(block->p_number));
04647     }
04648   if (block->g_modes[2] ISNT -1)
04649     {
04650       CHP(convert_set_plane(block->g_modes[2], settings));
04651     }
04652   if (block->g_modes[6] ISNT -1)
04653     {
04654       CHP(convert_length_units(block->g_modes[6], settings));
04655     }
04656   if (block->g_modes[7] ISNT -1)
04657     {
04658       CHP(convert_cutter_compensation(block->g_modes[7], block, settings));
04659     }
04660   if (block->g_modes[8] ISNT -1)
04661     {
04662       CHP(convert_tool_length_offset(block->g_modes[8], block, settings));
04663     }
04664   if (block->g_modes[12] ISNT -1)
04665     {
04666       CHP(convert_coordinate_system(block->g_modes[12], settings));
04667     }
04668   if (block->g_modes[13] ISNT -1)
04669     {
04670       CHP(convert_control_mode(block->g_modes[13], settings));
04671     }
04672   if (block->g_modes[3] ISNT -1)
04673     {
04674       CHP(convert_distance_mode(block->g_modes[3], settings));
04675     }
04676   if (block->g_modes[10] ISNT -1)
04677     {
04678       CHP(convert_retract_mode(block->g_modes[10], settings));
04679     }
04680   if (block->g_modes[0] ISNT -1)
04681     {
04682       CHP(convert_modal_0(block->g_modes[0], block, settings));
04683     }
04684   if (block->motion_to_be ISNT -1)
04685     {
04686       CHP(convert_motion(block->motion_to_be, block, settings));
04687     }
04688   return RS274NGC_OK;
04689 }

int convert_home int    move,
block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 4721 of file rs274ngc_pre.cc.

04725 {
04726   static char name[] SET_TO "convert_home";
04727   double end_x;
04728   double end_y;
04729   double end_z;
04730 #ifdef AA
04731   double AA_end;        /*AA*/
04732 #endif
04733 #ifdef AA
04734   double AA_end2;       /*AA*/
04735 #endif
04736 #ifdef BB
04737   double BB_end;        /*BB*/
04738 #endif
04739 #ifdef BB
04740   double BB_end2;       /*BB*/
04741 #endif
04742 #ifdef CC
04743   double CC_end;        /*CC*/
04744 #endif
04745 #ifdef CC
04746   double CC_end2;       /*CC*/
04747 #endif
04748   double * parameters;
04749 
04750   parameters SET_TO settings->parameters;
04751   find_ends(block, settings, &end_x, &end_y,
04752             &end_z
04753 #ifdef AA
04754 , &AA_end
04755 #endif
04756 
04757 #ifdef BB
04758 , &BB_end
04759 #endif
04760 
04761 #ifdef CC
04762 , &CC_end
04763 #endif
04764 );
04765 
04766   CHK((settings->cutter_comp_side ISNT OFF),
04767       NCE_CANNOT_USE_G28_OR_G30_WITH_CUTTER_RADIUS_COMP);
04768   STRAIGHT_TRAVERSE(end_x, end_y, end_z
04769 #ifdef AA
04770 ,                   AA_end
04771 #else
04772 #ifdef ALL_AXES
04773 , 0
04774 #endif
04775 #endif
04776 #ifdef BB
04777 ,  BB_end
04778 #else
04779 #ifdef ALL_AXES
04780 , 0
04781 #endif
04782 #endif
04783 #ifdef CC
04784 ,  CC_end
04785 #else
04786 #ifdef ALL_AXES
04787 , 0
04788 #endif
04789 #endif
04790 );
04791   if (move IS G_28)
04792     {
04793       find_relative
04794         (parameters[5161], parameters[5162], parameters[5163],
04795 #ifdef AA
04796          parameters[5164],  /*AA*/
04797 #endif
04798 #ifdef BB
04799          parameters[5165],  /*BB*/
04800 #endif
04801 #ifdef CC
04802          parameters[5166],  /*CC*/
04803 #endif
04804          &end_x, &end_y, &end_z
04805 #ifdef AA
04806 , &AA_end2
04807 #endif
04808 
04809 #ifdef BB
04810 , &BB_end2
04811 #endif
04812 
04813 #ifdef CC
04814 , &CC_end2
04815 #endif
04816 , settings);
04817     }
04818   else if (move IS G_30)
04819     {
04820       find_relative
04821         (parameters[5181], parameters[5182], parameters[5183],
04822 #ifdef AA
04823          parameters[5184],  /*AA*/
04824 #endif
04825 #ifdef BB
04826          parameters[5185],  /*BB*/
04827 #endif
04828 #ifdef CC
04829          parameters[5186],  /*CC*/
04830 #endif
04831          &end_x, &end_y, &end_z
04832 #ifdef AA
04833 , &AA_end2
04834 #endif
04835 
04836 #ifdef BB
04837 , &BB_end2
04838 #endif
04839 
04840 #ifdef CC
04841 , &CC_end2
04842 #endif
04843 , settings);
04844     }
04845   else
04846     ERM(NCE_BUG_CODE_NOT_G28_OR_G30);
04847   STRAIGHT_TRAVERSE(end_x, end_y, end_z
04848 #ifdef AA
04849 ,                   AA_end
04850 #else
04851 #ifdef ALL_AXES
04852 , 0
04853 #endif
04854 #endif
04855 #ifdef BB
04856 ,  BB_end
04857 #else
04858 #ifdef ALL_AXES
04859 , 0
04860 #endif
04861 #endif
04862 #ifdef CC
04863 ,  CC_end
04864 #else
04865 #ifdef ALL_AXES
04866 , 0
04867 #endif
04868 #endif
04869 );
04870   settings->current_x SET_TO end_x;
04871   settings->current_y SET_TO end_y;
04872   settings->current_z SET_TO end_z;
04873 #ifdef AA
04874   settings->AA_current SET_TO AA_end2;       /*AA*/
04875 #endif
04876 #ifdef BB
04877   settings->BB_current SET_TO BB_end2;       /*BB*/
04878 #endif
04879 #ifdef CC
04880   settings->CC_current SET_TO CC_end2;       /*CC*/
04881 #endif
04882   return RS274NGC_OK;
04883 }

int convert_length_units int    g_code,
setup_pointer    settings
[static]
 

Definition at line 4927 of file rs274ngc_pre.cc.

04930 {
04931   static char name[] SET_TO "convert_length_units";
04932   CHK((settings->cutter_comp_side ISNT OFF),
04933       NCE_CANNOT_CHANGE_UNITS_WITH_CUTTER_RADIUS_COMP);
04934   if (g_code IS G_20)
04935     {
04936       USE_LENGTH_UNITS(CANON_UNITS_INCHES);
04937       if (settings->length_units ISNT CANON_UNITS_INCHES)
04938         {
04939           settings->length_units SET_TO CANON_UNITS_INCHES;
04940           settings->current_x SET_TO (settings->current_x * INCH_PER_MM);
04941           settings->current_y SET_TO (settings->current_y * INCH_PER_MM);
04942           settings->current_z SET_TO (settings->current_z * INCH_PER_MM);
04943           settings->axis_offset_x SET_TO
04944             (settings->axis_offset_x * INCH_PER_MM);
04945           settings->axis_offset_y SET_TO
04946             (settings->axis_offset_y * INCH_PER_MM);
04947           settings->axis_offset_z SET_TO
04948             (settings->axis_offset_z * INCH_PER_MM);
04949           settings->origin_offset_x SET_TO
04950             (settings->origin_offset_x * INCH_PER_MM);
04951           settings->origin_offset_y SET_TO
04952             (settings->origin_offset_y * INCH_PER_MM);
04953           settings->origin_offset_z SET_TO
04954             (settings->origin_offset_z * INCH_PER_MM);
04955         }
04956     }
04957   else if (g_code IS G_21)
04958     {
04959       USE_LENGTH_UNITS(CANON_UNITS_MM);
04960       if (settings->length_units ISNT CANON_UNITS_MM)
04961         {
04962           settings->length_units SET_TO CANON_UNITS_MM;
04963           settings->current_x SET_TO (settings->current_x * MM_PER_INCH);
04964           settings->current_y SET_TO (settings->current_y * MM_PER_INCH);
04965           settings->current_z SET_TO (settings->current_z * MM_PER_INCH);
04966           settings->axis_offset_x SET_TO
04967             (settings->axis_offset_x * MM_PER_INCH);
04968           settings->axis_offset_y SET_TO
04969             (settings->axis_offset_y * MM_PER_INCH);
04970           settings->axis_offset_z SET_TO
04971             (settings->axis_offset_z * MM_PER_INCH);
04972           settings->origin_offset_x SET_TO
04973             (settings->origin_offset_x * MM_PER_INCH);
04974           settings->origin_offset_y SET_TO
04975             (settings->origin_offset_y * MM_PER_INCH);
04976           settings->origin_offset_z SET_TO
04977             (settings->origin_offset_z * MM_PER_INCH);
04978         }
04979     }
04980   else
04981     ERM(NCE_BUG_CODE_NOT_G20_OR_G21);
04982   return RS274NGC_OK;
04983 }

int convert_m block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 5013 of file rs274ngc_pre.cc.

05016 {
05017   static char name[] SET_TO "convert_m";
05018   int status;
05019 
05020   if (block->m_modes[6] ISNT -1)
05021     {
05022       CHP(convert_tool_change(settings));
05023     }
05024 
05025   if (block->m_modes[7] IS 3)
05026     {
05027       START_SPINDLE_CLOCKWISE();
05028       settings->spindle_turning SET_TO CANON_CLOCKWISE;
05029     }
05030   else if (block->m_modes[7] IS 4)
05031     {
05032       START_SPINDLE_COUNTERCLOCKWISE();
05033       settings->spindle_turning SET_TO CANON_COUNTERCLOCKWISE;
05034     }
05035   else if (block->m_modes[7] IS 5)
05036     {
05037       STOP_SPINDLE_TURNING();
05038       settings->spindle_turning SET_TO CANON_STOPPED;
05039     }
05040 
05041   if (block->m_modes[8] IS 7)
05042     {
05043       MIST_ON();
05044       settings->mist SET_TO ON;
05045     }
05046   else if (block->m_modes[8] IS 8)
05047     {
05048       FLOOD_ON();
05049       settings->flood SET_TO ON;
05050     }
05051   else if (block->m_modes[8] IS 9)
05052     {
05053       MIST_OFF();
05054       settings->mist SET_TO OFF;
05055       FLOOD_OFF();
05056       settings->flood SET_TO OFF;
05057     }
05058 
05059 /* No axis clamps in this version
05060   if (block->m_modes[2] IS 26)
05061     {
05062 #ifdef DEBUG_EMC
05063       COMMENT("interpreter: automatic A-axis clamping turned on");
05064 #endif
05065       settings->a_axis_clamping SET_TO ON;
05066     }
05067   else if (block->m_modes[2] IS 27)
05068     {
05069 #ifdef DEBUG_EMC
05070       COMMENT("interpreter: automatic A-axis clamping turned off");
05071 #endif
05072       settings->a_axis_clamping SET_TO OFF;
05073     }
05074 */
05075 
05076   if (block->m_modes[9] IS 48)
05077     {
05078       ENABLE_FEED_OVERRIDE();
05079       ENABLE_SPEED_OVERRIDE();
05080       settings->feed_override SET_TO ON;
05081       settings->speed_override SET_TO ON;
05082     }
05083   else if (block->m_modes[9] IS 49)
05084     {
05085       DISABLE_FEED_OVERRIDE();
05086       DISABLE_SPEED_OVERRIDE();
05087       settings->feed_override SET_TO OFF;
05088       settings->speed_override SET_TO OFF;
05089     }
05090 
05091   return RS274NGC_OK;
05092 }

int convert_modal_0 int    code,
block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 5119 of file rs274ngc_pre.cc.

05123 {
05124   static char name[] SET_TO "convert_modal_0";
05125   int status;
05126 
05127   if (code IS G_10)
05128     {
05129       CHP(convert_setup(block, settings));
05130     }
05131   else if ((code IS G_28) OR (code IS G_30))
05132     {
05133       CHP(convert_home(code, block, settings));
05134     }
05135   else if ((code IS G_92)   OR (code IS G_92_1) OR
05136            (code IS G_92_2) OR (code IS G_92_3))
05137     {
05138       CHP(convert_axis_offsets(code, block, settings));
05139     }
05140   else if ((code IS G_4) OR (code IS G_53)); /* handled elsewhere */
05141   else
05142     ERM(NCE_BUG_CODE_NOT_G4_G10_G28_G30_G53_OR_G92_SERIES);
05143   return RS274NGC_OK;
05144 }

int convert_motion int    motion,
block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 5169 of file rs274ngc_pre.cc.

05173 {
05174   static char name[] SET_TO "convert_motion";
05175   int status;
05176 
05177   if ((motion IS G_0) OR (motion IS G_1))
05178     {
05179       CHP(convert_straight(motion, block, settings));
05180     }
05181   else if ((motion IS G_3) OR (motion IS G_2))
05182     {
05183       CHP(convert_arc(motion, block, settings));
05184     }
05185   else if (motion IS G_38_2)
05186     {
05187       CHP(convert_probe(block, settings));
05188     }
05189   else if (motion IS G_80)
05190     {
05191 #ifdef DEBUG_EMC
05192       COMMENT("interpreter: motion mode set to none");
05193 #endif
05194       settings->motion_mode SET_TO G_80;
05195     }
05196   else if ((motion > G_80) AND (motion < G_90))
05197     {
05198       CHP(convert_cycle(motion, block, settings));
05199     }
05200   else
05201     ERM(NCE_BUG_UNKNOWN_MOTION_CODE);
05202 
05203   return RS274NGC_OK;
05204 }

int convert_probe block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 5243 of file rs274ngc_pre.cc.

05246 {
05247   static char name[] SET_TO "convert_probe";
05248   double distance;
05249   double end_x;
05250   double end_y;
05251   double end_z;
05252 #ifdef AA
05253   double AA_end;        /*AA*/
05254 #endif
05255 #ifdef BB
05256   double BB_end;        /*BB*/
05257 #endif
05258 #ifdef CC
05259   double CC_end;        /*CC*/
05260 #endif
05261 
05262   CHK((((block->x_flag IS OFF) AND (block->y_flag IS OFF)) AND
05263        (block->z_flag IS OFF)), NCE_X_Y_AND_Z_WORDS_ALL_MISSING_WITH_G38_2);
05264   CHK((settings->feed_mode IS INVERSE_TIME),
05265       NCE_CANNOT_PROBE_IN_INVERSE_TIME_FEED_MODE);
05266   CHK((settings->cutter_comp_side ISNT OFF),
05267       NCE_CANNOT_PROBE_WITH_CUTTER_RADIUS_COMP_ON);
05268   CHK((settings->feed_rate IS 0.0), NCE_CANNOT_PROBE_WITH_ZERO_FEED_RATE);
05269   find_ends(block, settings, &end_x, &end_y,
05270             &end_z
05271 #ifdef AA
05272 , &AA_end
05273 #endif
05274 
05275 #ifdef BB
05276 , &BB_end
05277 #endif
05278 
05279 #ifdef CC
05280 , &CC_end
05281 #endif
05282 );
05283   if (0
05284 #ifdef AA
05285       OR (AA_end ISNT settings->AA_current)    /*AA*/
05286 #endif
05287 #ifdef BB
05288       OR (BB_end ISNT settings->BB_current)    /*BB*/
05289 #endif
05290 #ifdef CC
05291       OR (CC_end ISNT settings->CC_current)    /*CC*/
05292 #endif
05293       )
05294     ERM(NCE_CANNOT_MOVE_ROTARY_AXES_DURING_PROBING);
05295   distance SET_TO sqrt(pow((settings->current_x - end_x), 2) +
05296                        pow((settings->current_y - end_y), 2) +
05297                        pow((settings->current_z - end_z), 2));
05298   CHK((distance < ((settings->length_units IS CANON_UNITS_MM) ? 0.254 : 0.01)),
05299       NCE_START_POINT_TOO_CLOSE_TO_PROBE_POINT);
05300   TURN_PROBE_ON();
05301   STRAIGHT_PROBE(end_x, end_y, end_z
05302 #ifdef AA
05303 ,                AA_end
05304 #else
05305 #ifdef ALL_AXES
05306 , 0
05307 #endif
05308 #endif
05309 #ifdef BB
05310 ,  BB_end
05311 #else
05312 #ifdef ALL_AXES
05313 , 0
05314 #endif
05315 #endif
05316 #ifdef CC
05317 ,  CC_end
05318 #else
05319 #ifdef ALL_AXES
05320 , 0
05321 #endif
05322 #endif
05323 );
05324   TURN_PROBE_OFF();
05325   settings->motion_mode SET_TO G_38_2;
05326   settings->probe_flag SET_TO ON;
05327   return RS274NGC_OK;
05328 }

int convert_retract_mode int    g_code,
setup_pointer    settings
[static]
 

Definition at line 5351 of file rs274ngc_pre.cc.

05354 {
05355   static char name[] SET_TO "convert_retract_mode";
05356   if (g_code IS G_98)
05357     {
05358 #ifdef DEBUG_EMC
05359       COMMENT("interpreter: retract mode set to old_z");
05360 #endif
05361       settings->retract_mode SET_TO OLD_Z;
05362     }
05363   else if (g_code IS G_99)
05364     {
05365 #ifdef DEBUG_EMC
05366       COMMENT("interpreter: retract mode set to r_plane");
05367 #endif
05368       settings->retract_mode SET_TO R_PLANE;
05369     }
05370   else
05371     ERM(NCE_BUG_CODE_NOT_G98_OR_G99);
05372   return RS274NGC_OK;
05373 }

int convert_set_plane int    g_code,
setup_pointer    settings
[static]
 

Definition at line 5588 of file rs274ngc_pre.cc.

05591 {
05592   static char name[] SET_TO "convert_set_plane";
05593   if (g_code IS G_17)
05594     {
05595       SELECT_PLANE(CANON_PLANE_XY);
05596       settings->plane SET_TO CANON_PLANE_XY;
05597     }
05598   else if (g_code IS G_18)
05599     {
05600       CHK((settings->cutter_comp_side ISNT OFF),
05601           NCE_CANNOT_USE_XZ_PLANE_WITH_CUTTER_RADIUS_COMP);
05602       SELECT_PLANE(CANON_PLANE_XZ);
05603       settings->plane SET_TO CANON_PLANE_XZ;
05604     }
05605   else if (g_code IS G_19)
05606     {
05607       CHK((settings->cutter_comp_side ISNT OFF),
05608           NCE_CANNOT_USE_YZ_PLANE_WITH_CUTTER_RADIUS_COMP);
05609       SELECT_PLANE(CANON_PLANE_YZ);
05610       settings->plane SET_TO CANON_PLANE_YZ;
05611     }
05612   else
05613     ERM(NCE_BUG_CODE_NOT_G17_G18_OR_G19);
05614   return RS274NGC_OK;
05615 }

int convert_setup block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 5403 of file rs274ngc_pre.cc.

Referenced by convert_modal_0().

05406 {
05407   static char name[] SET_TO "convert_setup";
05408   double x;
05409   double y;
05410   double z;
05411 #ifdef AA
05412   double a;  /*AA*/
05413 #endif
05414 #ifdef BB
05415   double b;  /*BB*/
05416 #endif
05417 #ifdef CC
05418   double c;  /*CC*/
05419 #endif
05420   double * parameters;
05421   int p_int;
05422 
05423   parameters SET_TO settings->parameters;
05424   p_int SET_TO (int)(block->p_number + 0.0001);
05425 
05426   if (block->x_flag IS ON)
05427     {
05428       x SET_TO block->x_number;
05429       parameters[5201 + (p_int * 20)] SET_TO x;
05430     }
05431   else
05432     x SET_TO parameters[5201 + (p_int * 20)];
05433 
05434   if (block->y_flag IS ON)
05435     {
05436       y SET_TO block->y_number;
05437       parameters[5202 + (p_int * 20)] SET_TO y;
05438     }
05439   else
05440     y SET_TO parameters[5202 + (p_int * 20)];
05441   if (block->z_flag IS ON)
05442     {
05443       z SET_TO block->z_number;
05444       parameters[5203 + (p_int * 20)] SET_TO z;
05445     }
05446   else
05447    z SET_TO parameters[5203 + (p_int * 20)];
05448 
05449 #ifdef AA
05450   if (block->a_flag IS ON)
05451     {
05452       a SET_TO block->a_number;
05453       parameters[5204 + (p_int * 20)] SET_TO a;
05454     }
05455   else
05456     a SET_TO parameters[5204 + (p_int * 20)];
05457 #endif
05458 
05459 #ifdef BB
05460   if (block->b_flag IS ON)
05461     {
05462       b SET_TO block->b_number;
05463       parameters[5205 + (p_int * 20)] SET_TO b;
05464     }
05465   else
05466     b SET_TO parameters[5205 + (p_int * 20)];
05467 #endif
05468 
05469 #ifdef CC
05470   if (block->c_flag IS ON)
05471     {
05472       c SET_TO block->c_number;
05473       parameters[5206 + (p_int * 20)] SET_TO c;
05474     }
05475   else
05476     c SET_TO parameters[5206 + (p_int * 20)];
05477 #endif
05478 
05479 /* axis offsets could be included in the two sets of calculations for
05480    current_x, current_y, etc., but do not need to be because the results
05481    would be the same. They would be added in then subtracted out. */
05482   if (p_int IS settings->origin_index) /* system is currently used */
05483     {
05484       settings->current_x SET_TO
05485         (settings->current_x + settings->origin_offset_x);
05486       settings->current_y SET_TO
05487         (settings->current_y + settings->origin_offset_y);
05488       settings->current_z SET_TO
05489         (settings->current_z + settings->origin_offset_z);
05490 #ifdef AA
05491       settings->AA_current SET_TO                                        /*AA*/
05492 #endif
05493 #ifdef AA
05494         (settings->AA_current + settings->AA_origin_offset);             /*AA*/
05495 #endif
05496 #ifdef BB
05497       settings->BB_current SET_TO                                        /*BB*/
05498 #endif
05499 #ifdef BB
05500         (settings->BB_current + settings->BB_origin_offset);             /*BB*/
05501 #endif
05502 #ifdef CC
05503       settings->CC_current SET_TO                                        /*CC*/
05504 #endif
05505 #ifdef CC
05506         (settings->CC_current + settings->CC_origin_offset);             /*CC*/
05507 #endif
05508 
05509       settings->origin_offset_x SET_TO x;
05510       settings->origin_offset_y SET_TO y;
05511       settings->origin_offset_z SET_TO z;
05512 #ifdef AA
05513       settings->AA_origin_offset SET_TO a;                               /*AA*/
05514 #endif
05515 #ifdef BB
05516       settings->BB_origin_offset SET_TO b;                               /*BB*/
05517 #endif
05518 #ifdef CC
05519       settings->CC_origin_offset SET_TO c;                               /*CC*/
05520 #endif
05521 
05522       settings->current_x SET_TO (settings->current_x - x);
05523       settings->current_y SET_TO (settings->current_y - y);
05524       settings->current_z SET_TO (settings->current_z - z);
05525 #ifdef AA
05526       settings->AA_current SET_TO (settings->AA_current - a);            /*AA*/
05527 #endif
05528 #ifdef BB
05529       settings->BB_current SET_TO (settings->BB_current - b);            /*BB*/
05530 #endif
05531 #ifdef CC
05532       settings->CC_current SET_TO (settings->CC_current - c);            /*CC*/
05533 #endif
05534 
05535       SET_ORIGIN_OFFSETS(x + settings->axis_offset_x,
05536                          y + settings->axis_offset_y,
05537                          z + settings->axis_offset_z
05538 #ifdef AA
05539 ,                        a + settings->AA_axis_offset
05540 #else
05541 #ifdef ALL_AXES
05542 , 0
05543 #endif
05544 #endif
05545 #ifdef BB
05546 ,                        b + settings->BB_axis_offset
05547 #else
05548 #ifdef ALL_AXES
05549 , 0
05550 #endif
05551 #endif
05552 #ifdef CC
05553 ,                        c + settings->CC_axis_offset
05554 #else
05555 #ifdef ALL_AXES
05556 , 0
05557 #endif
05558 #endif
05559 );
05560     }
05561 #ifdef DEBUG_EMC
05562   else
05563     COMMENT("interpreter: setting coordinate system origin");
05564 #endif
05565   return RS274NGC_OK;
05566 }

int convert_speed block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 5632 of file rs274ngc_pre.cc.

05635 {
05636   SET_SPINDLE_SPEED(block->s_number);
05637   settings->speed SET_TO block->s_number;
05638   return RS274NGC_OK;
05639 }

int convert_stop block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 5704 of file rs274ngc_pre.cc.

05707 {
05708   static char name[] SET_TO "convert_stop";
05709   int index;
05710   char * line;
05711   int length;
05712 
05713   if (block->m_modes[4] IS 0)
05714     {
05715       PROGRAM_STOP();
05716     }
05717   else if (block->m_modes[4] IS 60)
05718     {
05719       PALLET_SHUTTLE();
05720       PROGRAM_STOP();
05721     }
05722   else if (block->m_modes[4] IS 1)
05723     {
05724       OPTIONAL_PROGRAM_STOP();
05725     }
05726   else if ((block->m_modes[4] IS 2) OR (block->m_modes[4] IS 30))
05727     { /* reset stuff here */
05728 /*1*/
05729       settings->current_x SET_TO settings->current_x
05730         + settings->origin_offset_x + settings->axis_offset_x;
05731       settings->current_y SET_TO settings->current_y
05732         + settings->origin_offset_y + settings->axis_offset_y;
05733       settings->current_z SET_TO settings->current_z
05734         + settings->origin_offset_z + settings->axis_offset_z;
05735 #ifdef AA
05736       settings->AA_current SET_TO settings->AA_current              /*AA*/
05737 #endif
05738 #ifdef AA
05739         + settings->AA_origin_offset + settings->AA_axis_offset;    /*AA*/
05740 #endif
05741 #ifdef BB
05742       settings->BB_current SET_TO settings->BB_current              /*BB*/
05743 #endif
05744 #ifdef BB
05745         + settings->BB_origin_offset + settings->BB_axis_offset;    /*BB*/
05746 #endif
05747 #ifdef CC
05748       settings->CC_current SET_TO settings->CC_current              /*CC*/
05749 #endif
05750 #ifdef CC
05751         + settings->CC_origin_offset + settings->CC_axis_offset;    /*CC*/
05752 #endif
05753 
05754       settings->origin_index SET_TO 1;
05755       settings->parameters[5220] SET_TO 1.0;
05756       settings->origin_offset_x SET_TO settings->parameters[5221];
05757       settings->origin_offset_y SET_TO settings->parameters[5222];
05758       settings->origin_offset_z SET_TO settings->parameters[5223];
05759 #ifdef AA
05760       settings->AA_origin_offset SET_TO settings->parameters[5224]; /*AA*/
05761 #endif
05762 #ifdef BB
05763       settings->BB_origin_offset SET_TO settings->parameters[5225]; /*BB*/
05764 #endif
05765 #ifdef CC
05766       settings->CC_origin_offset SET_TO settings->parameters[5226]; /*CC*/
05767 #endif
05768 
05769       settings->axis_offset_x SET_TO 0;
05770       settings->axis_offset_x SET_TO 0;
05771       settings->axis_offset_x SET_TO 0;
05772 #ifdef AA
05773       settings->AA_axis_offset SET_TO 0;                            /*AA*/
05774 #endif
05775 #ifdef BB
05776       settings->BB_axis_offset SET_TO 0;                            /*BB*/
05777 #endif
05778 #ifdef CC
05779       settings->CC_axis_offset SET_TO 0;                            /*CC*/
05780 #endif
05781 
05782       settings->current_x SET_TO settings->current_x -
05783         settings->origin_offset_x;
05784       settings->current_y SET_TO settings->current_y -
05785         settings->origin_offset_y;
05786       settings->current_z SET_TO settings->current_z -
05787         settings->origin_offset_z;
05788 #ifdef AA
05789       settings->AA_current SET_TO settings->AA_current -            /*AA*/
05790 #endif
05791 #ifdef AA
05792         settings->AA_origin_offset;                                 /*AA*/
05793 #endif
05794 #ifdef BB
05795       settings->BB_current SET_TO settings->BB_current -            /*BB*/
05796 #endif
05797 #ifdef BB
05798         settings->BB_origin_offset;                                 /*BB*/
05799 #endif
05800 #ifdef CC
05801       settings->CC_current SET_TO settings->CC_current -            /*CC*/
05802 #endif
05803 #ifdef CC
05804         settings->CC_origin_offset;                                 /*CC*/
05805 #endif
05806 
05807       SET_ORIGIN_OFFSETS(settings->origin_offset_x,
05808                          settings->origin_offset_y,
05809                          settings->origin_offset_z
05810 #ifdef AA
05811 ,                        settings->AA_origin_offset
05812 #else
05813 #ifdef ALL_AXES
05814 , 0
05815 #endif
05816 #endif
05817 #ifdef BB
05818 ,                        settings->BB_origin_offset
05819 #else
05820 #ifdef ALL_AXES
05821 , 0
05822 #endif
05823 #endif
05824 #ifdef CC
05825 ,                        settings->CC_origin_offset
05826 #else
05827 #ifdef ALL_AXES
05828 , 0
05829 #endif
05830 #endif
05831 );
05832 
05833 /*2*/ if (settings->plane ISNT CANON_PLANE_XY)
05834         {
05835           SELECT_PLANE(CANON_PLANE_XY);
05836           settings->plane SET_TO CANON_PLANE_XY;
05837         }
05838 
05839 /*3*/ settings->distance_mode SET_TO MODE_ABSOLUTE;
05840 
05841 /*4*/ settings->feed_mode SET_TO UNITS_PER_MINUTE;
05842 
05843 /*5*/ if (settings->feed_override ISNT ON)
05844         {
05845           ENABLE_FEED_OVERRIDE();
05846           settings->feed_override SET_TO ON;
05847         }
05848       if (settings->speed_override ISNT ON)
05849         {
05850           ENABLE_SPEED_OVERRIDE();
05851           settings->speed_override SET_TO ON;
05852         }
05853 
05854 /*6*/ settings->cutter_comp_side SET_TO OFF;
05855       settings->program_x SET_TO UNKNOWN;
05856 
05857 /*7*/ STOP_SPINDLE_TURNING();
05858       settings->spindle_turning SET_TO CANON_STOPPED;
05859 
05860 /*8*/ settings->motion_mode SET_TO G_1;
05861 
05862 /*9*/ if (settings->mist IS ON)
05863         {
05864           MIST_OFF();
05865           settings->mist SET_TO OFF;
05866         }
05867       if (settings->flood IS ON)
05868         {
05869           FLOOD_OFF();
05870           settings->flood SET_TO OFF;
05871         }
05872 
05873       if (block->m_modes[4] IS 30)
05874         PALLET_SHUTTLE();
05875       PROGRAM_END();
05876       if (_setup.percent_flag IS ON)
05877         {
05878           CHK((_setup.file_pointer IS NULL), NCE_UNABLE_TO_OPEN_FILE);
05879           line SET_TO _setup.linetext;
05880           for(; ;) /* check for ending percent sign and comment if missing */
05881             {
05882               if (fgets(line, RS274NGC_TEXT_SIZE, _setup.file_pointer) IS NULL)
05883                 {
05884                   COMMENT
05885                     ("interpreter: percent sign missing from end of file");
05886                   break;
05887                 }
05888               length SET_TO strlen(line);
05889               if (length IS (RS274NGC_TEXT_SIZE - 1))
05890                 { // line is too long. need to finish reading the line
05891                   for(;fgetc(_setup.file_pointer) ISNT '\n';);
05892                   continue;
05893                 }
05894               for(index SET_TO (length -1); // index set on last char
05895                   (index >= 0) AND (isspace(line[index]));
05896                   index--);
05897               if (line[index] IS '%') // found line with % at end
05898                 {
05899                   for(index--; (index >= 0)AND(isspace(line[index])); index--);
05900                   if (index IS -1) // found line with only percent sign
05901                     break;
05902                 }
05903             }
05904         }
05905       return RS274NGC_EXIT;
05906     }
05907   else
05908     ERM(NCE_BUG_CODE_NOT_M0_M1_M2_M30_M60);
05909   return RS274NGC_OK;
05910 }

int convert_straight int    move,
block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 5954 of file rs274ngc_pre.cc.

Referenced by convert_motion().

05958 {
05959   static char name[] SET_TO "convert_straight";
05960   double end_x;
05961   double end_y;
05962   double end_z;
05963 #ifdef AA
05964   double AA_end;        /*AA*/
05965 #endif
05966 #ifdef BB
05967   double BB_end;        /*BB*/
05968 #endif
05969 #ifdef CC
05970   double CC_end;        /*CC*/
05971 #endif
05972   int status;
05973 
05974   if (move IS G_1)
05975     {
05976       if (settings->feed_mode IS UNITS_PER_MINUTE)
05977         {
05978           CHK((settings->feed_rate IS 0.0),
05979               NCE_CANNOT_DO_G1_WITH_ZERO_FEED_RATE);
05980         }
05981       else if (settings->feed_mode IS INVERSE_TIME)
05982         {
05983           CHK((block->f_number IS -1.0),
05984               NCE_F_WORD_MISSING_WITH_INVERSE_TIME_G1_MOVE);
05985         }
05986     }
05987 
05988   settings->motion_mode SET_TO move;
05989   find_ends(block, settings, &end_x, &end_y,
05990             &end_z
05991 #ifdef AA
05992 , &AA_end
05993 #endif
05994 
05995 #ifdef BB
05996 , &BB_end
05997 #endif
05998 
05999 #ifdef CC
06000 , &CC_end
06001 #endif
06002 );
06003   if ((settings->cutter_comp_side ISNT OFF) AND /* NOT "IS ON" */
06004       (settings->cutter_comp_radius > 0.0))     /* radius always is >= 0 */
06005     {
06006       CHK((block->g_modes[0] IS G_53),
06007           NCE_CANNOT_USE_G53_WITH_CUTTER_RADIUS_COMP);
06008       if (settings->program_x IS UNKNOWN)
06009         {
06010           status SET_TO
06011             convert_straight_comp1(move, block, settings, end_x, end_y,
06012                                    end_z
06013 #ifdef AA
06014 , AA_end
06015 #endif
06016 
06017 #ifdef BB
06018 , BB_end
06019 #endif
06020 
06021 #ifdef CC
06022 , CC_end
06023 #endif
06024 );
06025           CHP(status);
06026         }
06027       else
06028         {
06029           status SET_TO
06030             convert_straight_comp2 (move, block, settings, end_x, end_y,
06031                                     end_z
06032 #ifdef AA
06033 , AA_end
06034 #endif
06035 
06036 #ifdef BB
06037 , BB_end
06038 #endif
06039 
06040 #ifdef CC
06041 , CC_end
06042 #endif
06043 );
06044           CHP(status);
06045         }
06046     }
06047   else if (move IS G_0)
06048     {
06049       STRAIGHT_TRAVERSE(end_x, end_y, end_z
06050 #ifdef AA
06051 ,                       AA_end
06052 #else
06053 #ifdef ALL_AXES
06054 , 0
06055 #endif
06056 #endif
06057 #ifdef BB
06058 ,  BB_end
06059 #else
06060 #ifdef ALL_AXES
06061 , 0
06062 #endif
06063 #endif
06064 #ifdef CC
06065 ,  CC_end
06066 #else
06067 #ifdef ALL_AXES
06068 , 0
06069 #endif
06070 #endif
06071 );
06072       settings->current_x SET_TO end_x;
06073       settings->current_y SET_TO end_y;
06074     }
06075   else if (move IS G_1)
06076     {
06077       if (settings->feed_mode IS INVERSE_TIME)
06078         inverse_time_rate_straight
06079           (end_x, end_y, end_z
06080 #ifdef AA
06081 , AA_end
06082 #endif
06083 
06084 #ifdef BB
06085 , BB_end
06086 #endif
06087 
06088 #ifdef CC
06089 , CC_end
06090 #endif
06091 , block, settings);
06092       STRAIGHT_FEED(end_x, end_y, end_z
06093 #ifdef AA
06094 ,                   AA_end
06095 #else
06096 #ifdef ALL_AXES
06097 , 0
06098 #endif
06099 #endif
06100 #ifdef BB
06101 ,  BB_end
06102 #else
06103 #ifdef ALL_AXES
06104 , 0
06105 #endif
06106 #endif
06107 #ifdef CC
06108 ,  CC_end
06109 #else
06110 #ifdef ALL_AXES
06111 , 0
06112 #endif
06113 #endif
06114 );
06115       settings->current_x SET_TO end_x;
06116       settings->current_y SET_TO end_y;
06117     }
06118   else
06119     ERM(NCE_BUG_CODE_NOT_G0_OR_G1);
06120 
06121   settings->current_z SET_TO end_z;
06122 #ifdef AA
06123   settings->AA_current SET_TO AA_end;                           /*AA*/
06124 #endif
06125 #ifdef BB
06126   settings->BB_current SET_TO BB_end;                           /*BB*/
06127 #endif
06128 #ifdef CC
06129   settings->CC_current SET_TO CC_end;                           /*CC*/
06130 #endif
06131   return RS274NGC_OK;
06132 }

int convert_straight_comp1 int    move,
block_pointer    block,
setup_pointer    settings,
double    px,
double    py,
double    end_z
[static]
 

Definition at line 6170 of file rs274ngc_pre.cc.

06187 {
06188   static char name[] SET_TO "convert_straight_comp1";
06189   double alpha;
06190   double cx;        /* first current point x then end point x */
06191   double cy;        /* first current point y then end point y */
06192   double distance;
06193   double radius;
06194   int side;
06195   double theta;
06196 
06197   side SET_TO settings->cutter_comp_side;
06198   cx SET_TO settings->current_x;
06199   cy SET_TO settings->current_y;
06200 
06201   radius SET_TO settings->cutter_comp_radius; /* always will be positive */
06202   distance SET_TO hypot((px - cx), (py -cy));
06203 
06204   CHK(((side ISNT LEFT) AND (side ISNT RIGHT)),NCE_BUG_SIDE_NOT_RIGHT_OR_LEFT);
06205   CHK((distance <= radius), NCE_CUTTER_GOUGING_WITH_CUTTER_RADIUS_COMP);
06206 
06207   theta SET_TO acos(radius/distance);
06208   alpha SET_TO (side IS LEFT) ? (atan2((cy - py), (cx - px)) - theta) :
06209                                 (atan2((cy - py), (cx - px)) + theta);
06210   cx SET_TO (px + (radius * cos(alpha))); /* reset to end location */
06211   cy SET_TO (py + (radius * sin(alpha)));
06212   if (move IS G_0)
06213     STRAIGHT_TRAVERSE(cx, cy, end_z
06214 #ifdef AA
06215 ,                     AA_end
06216 #else
06217 #ifdef ALL_AXES
06218 , 0
06219 #endif
06220 #endif
06221 #ifdef BB
06222 ,  BB_end
06223 #else
06224 #ifdef ALL_AXES
06225 , 0
06226 #endif
06227 #endif
06228 #ifdef CC
06229 ,  CC_end
06230 #else
06231 #ifdef ALL_AXES
06232 , 0
06233 #endif
06234 #endif
06235 );
06236   else if (move IS G_1)
06237     {
06238       if (settings->feed_mode IS INVERSE_TIME)
06239         inverse_time_rate_straight
06240           (cx, cy, end_z
06241 #ifdef AA
06242 , AA_end
06243 #endif
06244 
06245 #ifdef BB
06246 , BB_end
06247 #endif
06248 
06249 #ifdef CC
06250 , CC_end
06251 #endif
06252 , block, settings);
06253       STRAIGHT_FEED(cx, cy, end_z
06254 #ifdef AA
06255 ,                   AA_end
06256 #else
06257 #ifdef ALL_AXES
06258 , 0
06259 #endif
06260 #endif
06261 #ifdef BB
06262 ,  BB_end
06263 #else
06264 #ifdef ALL_AXES
06265 , 0
06266 #endif
06267 #endif
06268 #ifdef CC
06269 ,  CC_end
06270 #else
06271 #ifdef ALL_AXES
06272 , 0
06273 #endif
06274 #endif
06275 );
06276     }
06277   else
06278     ERM(NCE_BUG_CODE_NOT_G0_OR_G1);
06279 
06280   settings->current_x SET_TO cx;
06281   settings->current_y SET_TO cy;
06282   settings->program_x SET_TO px;
06283   settings->program_y SET_TO py;
06284   return RS274NGC_OK;
06285 }

int convert_straight_comp2 int    move,
block_pointer    block,
setup_pointer    settings,
double    px,
double    py,
double    end_z
[static]
 

Definition at line 6359 of file rs274ngc_pre.cc.

06376 {
06377   static char name[] SET_TO "convert_straight_comp2";
06378   double alpha;
06379   double beta;
06380   double end_x; /* x-coordinate of actual end point */
06381   double end_y; /* y-coordinate of actual end point */
06382   double gamma;
06383   double mid_x; /* x-coordinate of end of added arc, if needed */
06384   double mid_y; /* y-coordinate of end of added arc, if needed */
06385   double radius;
06386   int side;
06387   double small SET_TO TOLERANCE_CONCAVE_CORNER; /* radians, testing corners */
06388   double start_x, start_y; /* programmed beginning point */
06389   double theta;
06390 
06391   start_x SET_TO settings->program_x;
06392   start_y SET_TO settings->program_y;
06393   if ((py IS start_y) AND (px IS start_x)) /* no XY motion */
06394     {
06395       end_x SET_TO settings->current_x;
06396       end_y SET_TO settings->current_y;
06397       if (move IS G_0)
06398         STRAIGHT_TRAVERSE(end_x, end_y, end_z
06399 #ifdef AA
06400 ,                         AA_end
06401 #else
06402 #ifdef ALL_AXES
06403 , 0
06404 #endif
06405 #endif
06406 #ifdef BB
06407 ,  BB_end
06408 #else
06409 #ifdef ALL_AXES
06410 , 0
06411 #endif
06412 #endif
06413 #ifdef CC
06414 ,  CC_end
06415 #else
06416 #ifdef ALL_AXES
06417 , 0
06418 #endif
06419 #endif
06420 );
06421       else if (move IS G_1)
06422         {
06423           if (settings->feed_mode IS INVERSE_TIME)
06424             inverse_time_rate_straight
06425               (end_x, end_y, end_z
06426 #ifdef AA
06427 , AA_end
06428 #endif
06429 
06430 #ifdef BB
06431 , BB_end
06432 #endif
06433 
06434 #ifdef CC
06435 , CC_end
06436 #endif
06437 , block, settings);
06438           STRAIGHT_FEED(end_x, end_y, end_z
06439 #ifdef AA
06440 ,                       AA_end
06441 #else
06442 #ifdef ALL_AXES
06443 , 0
06444 #endif
06445 #endif
06446 #ifdef BB
06447 ,  BB_end
06448 #else
06449 #ifdef ALL_AXES
06450 , 0
06451 #endif
06452 #endif
06453 #ifdef CC
06454 ,  CC_end
06455 #else
06456 #ifdef ALL_AXES
06457 , 0
06458 #endif
06459 #endif
06460 );
06461         }
06462       else
06463         ERM(NCE_BUG_CODE_NOT_G0_OR_G1);
06464     }
06465   else
06466     {
06467       side SET_TO settings->cutter_comp_side;
06468       radius SET_TO settings->cutter_comp_radius; /* will always be positive */
06469       theta SET_TO atan2(settings->current_y - start_y,
06470                          settings->current_x - start_x);
06471       alpha SET_TO atan2(py - start_y, px - start_x);
06472 
06473       if (side IS LEFT)
06474         {
06475           if (theta < alpha)
06476             theta SET_TO (theta + TWO_PI);
06477           beta SET_TO ((theta - alpha) - PI2);
06478           gamma SET_TO PI2;
06479         }
06480       else if (side IS RIGHT)
06481         {
06482           if (alpha < theta)
06483             alpha SET_TO (alpha + TWO_PI);
06484           beta SET_TO ((alpha - theta) - PI2);
06485           gamma SET_TO -PI2;
06486         }
06487       else
06488         ERM(NCE_BUG_SIDE_NOT_RIGHT_OR_LEFT);
06489       end_x SET_TO (px + (radius * cos(alpha + gamma)));
06490       end_y SET_TO (py + (radius * sin(alpha + gamma)));
06491       mid_x SET_TO (start_x + (radius * cos(alpha + gamma)));
06492       mid_y SET_TO (start_y + (radius * sin(alpha + gamma)));
06493 
06494       CHK(((beta < -small) OR (beta > (PI + small))),
06495           NCE_CONCAVE_CORNER_WITH_CUTTER_RADIUS_COMP);
06496       if (move IS G_0)
06497         STRAIGHT_TRAVERSE(end_x, end_y, end_z
06498 #ifdef AA
06499 ,                         AA_end
06500 #else
06501 #ifdef ALL_AXES
06502 , 0
06503 #endif
06504 #endif
06505 #ifdef BB
06506 ,  BB_end
06507 #else
06508 #ifdef ALL_AXES
06509 , 0
06510 #endif
06511 #endif
06512 #ifdef CC
06513 ,  CC_end
06514 #else
06515 #ifdef ALL_AXES
06516 , 0
06517 #endif
06518 #endif
06519 );
06520       else if (move IS G_1)
06521         {
06522           if (beta > small) /* ARC NEEDED */
06523             {
06524               if (settings->feed_mode IS INVERSE_TIME)
06525                 inverse_time_rate_as(start_x, start_y, (side IS LEFT) ? -1 : 1,
06526                                      mid_x, mid_y, end_x, end_y,
06527                                      end_z
06528 #ifdef AA
06529 , AA_end
06530 #endif
06531 
06532 #ifdef BB
06533 , BB_end
06534 #endif
06535 
06536 #ifdef CC
06537 , CC_end
06538 #endif
06539 ,
06540                                      block, settings);
06541               ARC_FEED(mid_x,mid_y,start_x, start_y,((side IS LEFT) ? -1 : 1),
06542                        settings->current_z
06543 #ifdef AA
06544 , AA_end
06545 #else
06546 #ifdef ALL_AXES
06547 , 0
06548 #endif
06549 #endif
06550 #ifdef BB
06551 , BB_end
06552 #else
06553 #ifdef ALL_AXES
06554 , 0
06555 #endif
06556 #endif
06557 #ifdef CC
06558 , CC_end
06559 #else
06560 #ifdef ALL_AXES
06561 , 0
06562 #endif
06563 #endif
06564 );
06565               STRAIGHT_FEED(end_x, end_y, end_z
06566 #ifdef AA
06567 ,                           AA_end
06568 #else
06569 #ifdef ALL_AXES
06570 , 0
06571 #endif
06572 #endif
06573 #ifdef BB
06574 ,  BB_end
06575 #else
06576 #ifdef ALL_AXES
06577 , 0
06578 #endif
06579 #endif
06580 #ifdef CC
06581 ,  CC_end
06582 #else
06583 #ifdef ALL_AXES
06584 , 0
06585 #endif
06586 #endif
06587 );
06588             }
06589           else
06590             {
06591               if (settings->feed_mode IS INVERSE_TIME)
06592                 inverse_time_rate_straight
06593                   (end_x,end_y,end_z
06594 #ifdef AA
06595 , AA_end
06596 #endif
06597 
06598 #ifdef BB
06599 , BB_end
06600 #endif
06601 
06602 #ifdef CC
06603 , CC_end
06604 #endif
06605 , block, settings);
06606               STRAIGHT_FEED(end_x, end_y, end_z
06607 #ifdef AA
06608 ,                           AA_end
06609 #else
06610 #ifdef ALL_AXES
06611 , 0
06612 #endif
06613 #endif
06614 #ifdef BB
06615 ,  BB_end
06616 #else
06617 #ifdef ALL_AXES
06618 , 0
06619 #endif
06620 #endif
06621 #ifdef CC
06622 ,  CC_end
06623 #else
06624 #ifdef ALL_AXES
06625 , 0
06626 #endif
06627 #endif
06628 );
06629             }
06630         }
06631       else
06632         ERM(NCE_BUG_CODE_NOT_G0_OR_G1);
06633     }
06634 
06635   settings->current_x SET_TO end_x;
06636   settings->current_y SET_TO end_y;
06637   settings->program_x SET_TO px;
06638   settings->program_y SET_TO py;
06639   return RS274NGC_OK;
06640 }

int convert_tool_change setup_pointer    settings [static]
 

Definition at line 6701 of file rs274ngc_pre.cc.

Referenced by convert_m().

06703 {
06704   static char name[] SET_TO "convert_tool_change";
06705 
06706   CHANGE_TOOL(settings->selected_tool_slot);
06707   settings->current_slot SET_TO settings->selected_tool_slot;
06708   settings->spindle_turning SET_TO CANON_STOPPED;
06709 
06710   return RS274NGC_OK;
06711 }

int convert_tool_length_offset int    g_code,
block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 6744 of file rs274ngc_pre.cc.

06748 {
06749   static char name[] SET_TO "convert_tool_length_offset";
06750   int index;
06751   double offset;
06752 
06753   if (g_code IS G_49)
06754     {
06755       USE_TOOL_LENGTH_OFFSET(0.0);
06756       settings->current_z SET_TO (settings->current_z +
06757                                   settings->tool_length_offset);
06758       settings->tool_length_offset SET_TO 0.0;
06759       settings->length_offset_index SET_TO 0;
06760     }
06761   else if (g_code IS G_43)
06762     {
06763       index SET_TO block->h_number;
06764       CHK((index IS -1), NCE_OFFSET_INDEX_MISSING);
06765       offset SET_TO settings->tool_table[index].length;
06766       USE_TOOL_LENGTH_OFFSET(offset);
06767       settings->current_z SET_TO
06768         (settings->current_z + settings->tool_length_offset - offset);
06769       settings->tool_length_offset SET_TO offset;
06770       settings->length_offset_index SET_TO index;
06771     }
06772   else
06773     ERM(NCE_BUG_CODE_NOT_G43_OR_G49);
06774   return RS274NGC_OK;
06775 }

int convert_tool_select block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 6803 of file rs274ngc_pre.cc.

06806 {
06807   static char name[] SET_TO "convert_tool_select";
06808 
06809   CHK((block->t_number > settings->tool_max),
06810       NCE_SELECTED_TOOL_SLOT_NUMBER_TOO_LARGE);
06811   SELECT_TOOL(block->t_number);
06812   settings->selected_tool_slot SET_TO block->t_number;
06813   return RS274NGC_OK;
06814 }

int cycle_feed CANON_PLANE    plane,
double    end1,
double    end2,
double    end3
[static]
 

Definition at line 6841 of file rs274ngc_pre.cc.

06846 {
06847   static char name[] SET_TO "cycle_feed";
06848 
06849   if (plane IS CANON_PLANE_XY)
06850     STRAIGHT_FEED(end1, end2, end3
06851 #ifdef AA
06852 ,                 _setup.AA_current
06853 #else
06854 #ifdef ALL_AXES
06855 , 0
06856 #endif
06857 #endif
06858 #ifdef BB
06859 ,  _setup.BB_current
06860 #else
06861 #ifdef ALL_AXES
06862 , 0
06863 #endif
06864 #endif
06865 #ifdef CC
06866 ,  _setup.CC_current
06867 #else
06868 #ifdef ALL_AXES
06869 , 0
06870 #endif
06871 #endif
06872 );
06873   else if (plane IS CANON_PLANE_YZ)
06874     STRAIGHT_FEED(end3, end1, end2
06875 #ifdef AA
06876 ,                 _setup.AA_current
06877 #else
06878 #ifdef ALL_AXES
06879 , 0
06880 #endif
06881 #endif
06882 #ifdef BB
06883 ,  _setup.BB_current
06884 #else
06885 #ifdef ALL_AXES
06886 , 0
06887 #endif
06888 #endif
06889 #ifdef CC
06890 ,  _setup.CC_current
06891 #else
06892 #ifdef ALL_AXES
06893 , 0
06894 #endif
06895 #endif
06896 );
06897   else /* if (plane IS CANON_PLANE_XZ) */
06898     STRAIGHT_FEED(end2, end3, end1
06899 #ifdef AA
06900 ,                 _setup.AA_current
06901 #else
06902 #ifdef ALL_AXES
06903 , 0
06904 #endif
06905 #endif
06906 #ifdef BB
06907 ,  _setup.BB_current
06908 #else
06909 #ifdef ALL_AXES
06910 , 0
06911 #endif
06912 #endif
06913 #ifdef CC
06914 ,  _setup.CC_current
06915 #else
06916 #ifdef ALL_AXES
06917 , 0
06918 #endif
06919 #endif
06920 );
06921 
06922   return RS274NGC_OK;
06923 }

int cycle_traverse CANON_PLANE    plane,
double    end1,
double    end2,
double    end3
[static]
 

Definition at line 6950 of file rs274ngc_pre.cc.

06955 {
06956   static char name[] SET_TO "cycle_traverse";
06957   if (plane IS CANON_PLANE_XY)
06958     STRAIGHT_TRAVERSE(end1, end2, end3
06959 #ifdef AA
06960 ,                     _setup.AA_current
06961 #else
06962 #ifdef ALL_AXES
06963 , 0
06964 #endif
06965 #endif
06966 #ifdef BB
06967 ,  _setup.BB_current
06968 #else
06969 #ifdef ALL_AXES
06970 , 0
06971 #endif
06972 #endif
06973 #ifdef CC
06974 ,  _setup.CC_current
06975 #else
06976 #ifdef ALL_AXES
06977 , 0
06978 #endif
06979 #endif
06980 );
06981   else if (plane IS CANON_PLANE_YZ)
06982     STRAIGHT_TRAVERSE(end3, end1, end2
06983 #ifdef AA
06984 ,                     _setup.AA_current
06985 #else
06986 #ifdef ALL_AXES
06987 , 0
06988 #endif
06989 #endif
06990 #ifdef BB
06991 ,  _setup.BB_current
06992 #else
06993 #ifdef ALL_AXES
06994 , 0
06995 #endif
06996 #endif
06997 #ifdef CC
06998 ,  _setup.CC_current
06999 #else
07000 #ifdef ALL_AXES
07001 , 0
07002 #endif
07003 #endif
07004 );
07005   else /* if (plane IS CANON_PLANE_XZ) */
07006     STRAIGHT_TRAVERSE(end2, end3, end1
07007 #ifdef AA
07008 ,                     _setup.AA_current
07009 #else
07010 #ifdef ALL_AXES
07011 , 0
07012 #endif
07013 #endif
07014 #ifdef BB
07015 ,  _setup.BB_current
07016 #else
07017 #ifdef ALL_AXES
07018 , 0
07019 #endif
07020 #endif
07021 #ifdef CC
07022 ,  _setup.CC_current
07023 #else
07024 #ifdef ALL_AXES
07025 , 0
07026 #endif
07027 #endif
07028 );
07029   return RS274NGC_OK;
07030 }

int enhance_block block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 7068 of file rs274ngc_pre.cc.

07071 {
07072   static char name[] SET_TO "enhance_block";
07073   int axis_flag;
07074   int mode_zero_covets_axes;
07075 
07076   axis_flag SET_TO ((block->x_flag IS ON) OR
07077                     (block->y_flag IS ON) OR
07078 #ifdef AA
07079                     (block->a_flag IS ON) OR /*AA*/
07080 #endif
07081 #ifdef BB
07082                     (block->b_flag IS ON) OR /*BB*/
07083 #endif
07084 #ifdef CC
07085                     (block->c_flag IS ON) OR /*CC*/
07086 #endif
07087                     (block->z_flag IS ON));
07088   mode_zero_covets_axes SET_TO ((block->g_modes[0] IS G_10) OR
07089                                 (block->g_modes[0] IS G_28) OR
07090                                 (block->g_modes[0] IS G_30) OR
07091                                 (block->g_modes[0] IS G_92));
07092 
07093   if (block->g_modes[1] ISNT -1)
07094     {
07095       if (block->g_modes[1] IS G_80)
07096         {
07097           CHK((axis_flag AND (NOT mode_zero_covets_axes)),
07098               NCE_CANNOT_USE_AXIS_VALUES_WITH_G80);
07099           CHK(((NOT axis_flag) AND (block->g_modes[0] IS G_92)),
07100               NCE_ALL_AXES_MISSING_WITH_G92);
07101         }
07102       else
07103         {
07104           CHK(mode_zero_covets_axes,
07105               NCE_CANNOT_USE_TWO_G_CODES_THAT_BOTH_USE_AXIS_VALUES);
07106           CHK((NOT axis_flag), NCE_ALL_AXES_MISSING_WITH_MOTION_CODE);
07107         }
07108       block->motion_to_be SET_TO block->g_modes[1];
07109     }
07110   else if (mode_zero_covets_axes)
07111     { /* other 3 can get by without axes but not G92 */
07112       CHK(((NOT axis_flag) AND (block->g_modes[0] IS G_92)),
07113           NCE_ALL_AXES_MISSING_WITH_G92);
07114     }
07115   else if (axis_flag)
07116     {
07117       CHK(((settings->motion_mode IS -1) OR (settings->motion_mode IS G_80)),
07118           NCE_CANNOT_USE_AXIS_VALUES_WITHOUT_A_G_CODE_THAT_USES_THEM);
07119       block->motion_to_be SET_TO settings->motion_mode;
07120     }
07121   return RS274NGC_OK;
07122 }

int execute_binary double *    left,
int    operation,
double *    right
[static]
 

Definition at line 7142 of file rs274ngc_pre.cc.

07146 {
07147   static char name[] SET_TO "execute_binary";
07148   int status;
07149 
07150   if (operation < AND2)
07151     CHP(execute_binary1(left, operation, right));
07152   else
07153     CHP(execute_binary2(left, operation, right));
07154   return RS274NGC_OK;
07155 }

int execute_binary1 double *    left,
int    operation,
double *    right
[static]
 

Definition at line 7178 of file rs274ngc_pre.cc.

Referenced by execute_binary().

07182 {
07183   static char name[] SET_TO "execute_binary1";
07184   switch (operation)
07185     {
07186     case DIVIDED_BY:
07187       CHK((*right IS 0.0), NCE_ATTEMPT_TO_DIVIDE_BY_ZERO);
07188       *left SET_TO (*left / *right);
07189       break;
07190     case MODULO: /* always calculates a positive answer */
07191       *left SET_TO fmod(*left, *right);
07192       if (*left < 0.0)
07193         {
07194           *left SET_TO (*left + fabs(*right));
07195         }
07196       break;
07197     case POWER:
07198       CHK(((*left < 0.0) AND (floor(*right) ISNT *right)),
07199           NCE_ATTEMPT_TO_RAISE_NEGATIVE_TO_NON_INTEGER_POWER);
07200       *left SET_TO pow(*left, *right);
07201       break;
07202     case TIMES:
07203       *left SET_TO (*left * *right);
07204       break;
07205     default:
07206       ERM(NCE_BUG_UNKNOWN_OPERATION);
07207     }
07208   return RS274NGC_OK;
07209 }

int execute_binary2 double *    left,
int    operation,
double *    right
[static]
 

Definition at line 7235 of file rs274ngc_pre.cc.

Referenced by execute_binary().

07239 {
07240   static char name[] SET_TO "execute_binary2";
07241   switch (operation)
07242     {
07243     case AND2:
07244       *left SET_TO ((*left IS 0.0) OR (*right IS 0.0)) ? 0.0 : 1.0;
07245       break;
07246     case EXCLUSIVE_OR:
07247       *left SET_TO (((*left IS 0.0) AND (*right ISNT 0.0)) OR
07248                     ((*left ISNT 0.0) AND (*right IS 0.0))) ? 1.0 : 0.0;
07249       break;
07250     case MINUS:
07251       *left SET_TO (*left - *right);
07252       break;
07253     case NON_EXCLUSIVE_OR:
07254       *left SET_TO ((*left ISNT 0.0) OR (*right ISNT 0.0)) ? 1.0 : 0.0;
07255       break;
07256     case PLUS:
07257       *left SET_TO (*left + *right);
07258       break;
07259     default:
07260       ERM(NCE_BUG_UNKNOWN_OPERATION);
07261     }
07262   return RS274NGC_OK;
07263 }

int execute_block block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 7313 of file rs274ngc_pre.cc.

07316 {
07317   static char name[] SET_TO "execute_block";
07318   int status;
07319 
07320   if (block->comment[0] ISNT 0)
07321     {
07322       CHP(convert_comment(block->comment));
07323     }
07324   if (block->g_modes[5] ISNT -1)
07325     {
07326       CHP(convert_feed_mode(block->g_modes[5], settings));
07327     }
07328   if (block->f_number > -1.0)
07329     {
07330       if (settings->feed_mode IS INVERSE_TIME); /* handle elsewhere */
07331       else
07332         {
07333           CHP(convert_feed_rate(block, settings));
07334         }
07335     }
07336   if (block->s_number > -1.0)
07337     {
07338       CHP(convert_speed(block, settings));
07339     }
07340   if (block->t_number ISNT -1)
07341     {
07342       CHP(convert_tool_select(block, settings));
07343     }
07344   CHP(convert_m(block, settings));
07345   CHP(convert_g(block, settings));
07346   if (block->m_modes[4] ISNT -1) /* converts m0, m1, m2, m30, or m60 */
07347     {
07348       status SET_TO convert_stop(block, settings);
07349       if (status IS RS274NGC_EXIT)
07350         return RS274NGC_EXIT;
07351       else if (status ISNT RS274NGC_OK)
07352         ERP(status);
07353     }
07354   return ((settings->probe_flag IS ON) ? RS274NGC_EXECUTE_FINISH: RS274NGC_OK);
07355 }

int execute_unary double *    double_ptr,
int    operation
[static]
 

Definition at line 7387 of file rs274ngc_pre.cc.

07390 {
07391   static char name[] SET_TO "execute_unary";
07392   switch (operation)
07393     {
07394     case ABS:
07395       if (*double_ptr < 0.0)
07396         *double_ptr SET_TO (-1.0 * *double_ptr);
07397       break;
07398     case ACOS:
07399       CHK(((*double_ptr < -1.0) OR (*double_ptr > 1.0)),
07400           NCE_ARGUMENT_TO_ACOS_OUT_OF_RANGE);
07401       *double_ptr SET_TO acos(*double_ptr);
07402       *double_ptr SET_TO ((*double_ptr * 180.0)/ PI);
07403       break;
07404     case ASIN:
07405       CHK(((*double_ptr < -1.0) OR (*double_ptr > 1.0)),
07406           NCE_ARGUMENT_TO_ASIN_OUT_OF_RANGE);
07407       *double_ptr SET_TO asin(*double_ptr);
07408       *double_ptr SET_TO ((*double_ptr * 180.0)/ PI);
07409       break;
07410     case COS:
07411       *double_ptr SET_TO cos((*double_ptr * PI)/180.0);
07412       break;
07413     case EXP:
07414       *double_ptr SET_TO exp(*double_ptr);
07415       break;
07416     case FIX:
07417       *double_ptr SET_TO floor(*double_ptr);
07418       break;
07419     case FUP:
07420       *double_ptr SET_TO ceil(*double_ptr);
07421       break;
07422     case LN:
07423       CHK((*double_ptr <= 0.0), NCE_ZERO_OR_NEGATIVE_ARGUMENT_TO_LN);
07424       *double_ptr SET_TO log(*double_ptr);
07425       break;
07426     case ROUND:
07427       *double_ptr SET_TO (double)
07428         ((int) (*double_ptr + ((*double_ptr < 0.0) ? -0.5 : 0.5)));
07429       break;
07430     case SIN:
07431       *double_ptr SET_TO sin((*double_ptr * PI)/180.0);
07432       break;
07433     case SQRT:
07434       CHK((*double_ptr < 0.0), NCE_NEGATIVE_ARGUMENT_TO_SQRT);
07435       *double_ptr SET_TO sqrt(*double_ptr);
07436       break;
07437     case TAN:
07438       *double_ptr SET_TO tan((*double_ptr * PI)/180.0);
07439       break;
07440     default:
07441       ERM(NCE_BUG_UNKNOWN_OPERATION);
07442     }
07443   return RS274NGC_OK;
07444 }

double find_arc_length double    x1,
double    y1,
double    z1,
double    center_x,
double    center_y,
int    turn,
double    x2,
double    y2,
double    z2
[static]
 

Definition at line 7481 of file rs274ngc_pre.cc.

07491 {
07492   double radius;
07493   double theta;  /* amount of turn of arc in radians */
07494 
07495   radius SET_TO hypot((center_x - x1), (center_y - y1));
07496   theta SET_TO find_turn(x1, y1, center_x, center_y, turn, x2, y2);
07497   if (z2 IS z1)
07498     return (radius * fabs(theta));
07499   else
07500     return hypot((radius * theta), (z2 - z1));
07501 }

int find_ends block_pointer    block,
setup_pointer    settings,
double *    px,
double *    py,
double *    pz
[static]
 

Definition at line 7543 of file rs274ngc_pre.cc.

07559 {
07560   int mode;
07561   int middle;
07562   int comp;
07563 
07564   mode SET_TO settings->distance_mode;
07565   middle SET_TO (settings->program_x ISNT UNKNOWN);
07566   comp SET_TO (settings->cutter_comp_side ISNT OFF);
07567 
07568   if (block->g_modes[0] IS G_53) /* distance mode is absolute in this case */
07569     {
07570 #ifdef DEBUG_EMC
07571       COMMENT("interpreter: offsets temporarily suspended");
07572 #endif
07573       *px SET_TO (block->x_flag IS ON) ? (block->x_number -
07574                    (settings->origin_offset_x + settings->axis_offset_x)) :
07575                      settings->current_x;
07576       *py SET_TO (block->y_flag IS ON) ? (block->y_number -
07577                    (settings->origin_offset_y + settings->axis_offset_y)) :
07578                      settings->current_y;
07579       *pz SET_TO (block->z_flag IS ON) ? (block->z_number -
07580                    (settings->tool_length_offset + settings->origin_offset_z
07581                     + settings->axis_offset_z)) : settings->current_z;
07582 #ifdef AA
07583       *AA_p SET_TO (block->a_flag IS ON) ? (block->a_number -            /*AA*/
07584 #endif
07585 #ifdef AA
07586               (settings->AA_origin_offset + settings->AA_axis_offset)) : /*AA*/
07587 #endif
07588 #ifdef AA
07589                    settings->AA_current;                                 /*AA*/
07590 #endif
07591 #ifdef BB
07592       *BB_p SET_TO (block->b_flag IS ON) ? (block->b_number -            /*BB*/
07593 #endif
07594 #ifdef BB
07595               (settings->BB_origin_offset + settings->BB_axis_offset)) : /*BB*/
07596 #endif
07597 #ifdef BB
07598                    settings->BB_current;                                 /*BB*/
07599 #endif
07600 #ifdef CC
07601       *CC_p SET_TO (block->c_flag IS ON) ? (block->c_number -            /*CC*/
07602 #endif
07603 #ifdef CC
07604               (settings->tool_length_offset + settings->CC_origin_offset /*CC*/
07605 #endif
07606 #ifdef CC
07607                 + settings->CC_axis_offset)) : settings->CC_current;     /*CC*/
07608 #endif
07609     }
07610   else if (mode IS MODE_ABSOLUTE)
07611     {
07612       *px SET_TO (block->x_flag IS ON) ? block->x_number     :
07613                  (comp AND middle)     ? settings->program_x :
07614                                          settings->current_x ;
07615 
07616       *py SET_TO (block->y_flag IS ON) ? block->y_number     :
07617                  (comp AND middle)     ? settings->program_y :
07618                                          settings->current_y ;
07619 
07620       *pz SET_TO (block->z_flag IS ON) ? block->z_number     :
07621                                          settings->current_z ;
07622 #ifdef AA
07623       *AA_p SET_TO (block->a_flag IS ON) ? block->a_number     :       /*AA*/
07624 #endif
07625 #ifdef AA
07626                                           settings->AA_current ;       /*AA*/
07627 #endif
07628 #ifdef BB
07629       *BB_p SET_TO (block->b_flag IS ON) ? block->b_number     :       /*BB*/
07630 #endif
07631 #ifdef BB
07632                                           settings->BB_current ;       /*BB*/
07633 #endif
07634 #ifdef CC
07635       *CC_p SET_TO (block->c_flag IS ON) ? block->c_number     :       /*CC*/
07636 #endif
07637 #ifdef CC
07638                                           settings->CC_current ;       /*CC*/
07639 #endif
07640     }
07641   else /* mode is MODE_INCREMENTAL */
07642     {
07643       *px SET_TO (block->x_flag IS ON)
07644         ? ((comp AND middle) ? (block->x_number + settings->program_x)
07645                              : (block->x_number + settings->current_x))
07646         : ((comp AND middle) ? settings->program_x
07647                              : settings->current_x);
07648 
07649       *py SET_TO (block->y_flag IS ON)
07650         ? ((comp AND middle) ? (block->y_number + settings->program_y)
07651                              : (block->y_number + settings->current_y))
07652         : ((comp AND middle) ? settings->program_y
07653                              : settings->current_y);
07654 
07655       *pz SET_TO (block->z_flag IS ON) ?
07656         (settings->current_z + block->z_number) : settings->current_z;
07657 #ifdef AA
07658       *AA_p SET_TO (block->a_flag IS ON) ?                               /*AA*/
07659 #endif
07660 #ifdef AA
07661         (settings->AA_current + block->a_number) : settings->AA_current; /*AA*/
07662 #endif
07663 #ifdef BB
07664       *BB_p SET_TO (block->b_flag IS ON) ?                               /*BB*/
07665 #endif
07666 #ifdef BB
07667         (settings->BB_current + block->b_number) : settings->BB_current; /*BB*/
07668 #endif
07669 #ifdef CC
07670       *CC_p SET_TO (block->c_flag IS ON) ?                               /*CC*/
07671 #endif
07672 #ifdef CC
07673         (settings->CC_current + block->c_number) : settings->CC_current; /*CC*/
07674 #endif
07675     }
07676   return RS274NGC_OK;
07677 }

int find_relative double    x1,
double    y1,
double    z1,
double *    x2,
double *    y2,
double *    z2,
setup_pointer    settings
[static]
 

Definition at line 7701 of file rs274ngc_pre.cc.

07727 {
07728   *x2 SET_TO (x1 - (settings->origin_offset_x + settings->axis_offset_x));
07729   *y2 SET_TO (y1 - (settings->origin_offset_y + settings->axis_offset_y));
07730   *z2 SET_TO (z1 - (settings->tool_length_offset +
07731                     settings->origin_offset_z + settings->axis_offset_z));
07732 #ifdef AA
07733   *AA_2 SET_TO (AA_1 - (settings->AA_origin_offset +    /*AA*/
07734 #endif
07735 #ifdef AA
07736                         settings->AA_axis_offset));     /*AA*/
07737 #endif
07738 #ifdef BB
07739   *BB_2 SET_TO (BB_1 - (settings->BB_origin_offset +    /*BB*/
07740 #endif
07741 #ifdef BB
07742                         settings->BB_axis_offset));     /*BB*/
07743 #endif
07744 #ifdef CC
07745   *CC_2 SET_TO (CC_1 - (settings->CC_origin_offset +    /*CC*/
07746 #endif
07747 #ifdef CC
07748                         settings->CC_axis_offset));     /*CC*/
07749 #endif
07750   return RS274NGC_OK;
07751 }

double find_straight_length double    x2,
double    y2,
double    z2,
double    x1,
double    y1,
double    z1
[static]
 

Definition at line 7786 of file rs274ngc_pre.cc.

07812 {
07813   if ((x1 ISNT x2) OR (y1 ISNT y2) OR (z1 ISNT z2) OR
07814       (1
07815 #ifdef AA
07816        AND (AA_2 IS AA_1)   /*AA*/
07817 #endif
07818 #ifdef BB
07819        AND (BB_2 IS BB_1)   /*BB*/
07820 #endif
07821 #ifdef CC
07822        AND (CC_2 IS CC_1)   /*CC*/
07823 #endif
07824        )) /* straight line */
07825     return sqrt(pow((x2 - x1),2) + pow((y2 - y1),2) + pow((z2 - z1),2));
07826   else
07827     return sqrt(0 +
07828 #ifdef AA
07829                 pow((AA_2 - AA_1), 2) +  /*AA*/
07830 #endif
07831 #ifdef BB
07832                 pow((BB_2 - BB_1), 2) +  /*BB*/
07833 #endif
07834 #ifdef CC
07835                 pow((CC_2 - CC_1), 2) +  /*CC*/
07836 #endif
07837                 0);
07838 }

double find_turn double    x1,
double    y1,
double    center_x,
double    center_y,
int    turn,
double    x2,
double    y2
[static]
 

Definition at line 7854 of file rs274ngc_pre.cc.

07862 {
07863   double alpha;  /* angle of first radius                      */
07864   double beta;   /* angle of second radius                     */
07865   double theta;  /* amount of turn of arc CCW - negative if CW */
07866 
07867   if (turn IS 0)
07868     return 0.0;
07869   alpha SET_TO atan2((y1 - center_y), (x1 - center_x));
07870   beta SET_TO atan2((y2 - center_y), (x2 - center_x));
07871   if (turn > 0)
07872     {
07873       if (beta <= alpha)
07874         beta SET_TO (beta + TWO_PI);
07875       theta SET_TO ((beta - alpha) + ((turn - 1) * TWO_PI));
07876     }
07877   else /* turn < 0 */
07878     {
07879       if (alpha <= beta)
07880         alpha SET_TO (alpha + TWO_PI);
07881       theta SET_TO ((beta - alpha) + ((turn + 1) * TWO_PI));
07882     }
07883   return (theta);
07884 }

int init_block block_pointer    block [static]
 

Definition at line 7924 of file rs274ngc_pre.cc.

07926 {
07927   int n;
07928 #ifdef AA
07929   block->a_flag SET_TO OFF;  /*AA*/
07930 #endif
07931 #ifdef BB
07932   block->b_flag SET_TO OFF;  /*BB*/
07933 #endif
07934 #ifdef CC
07935   block->c_flag SET_TO OFF;  /*CC*/
07936 #endif
07937   block->comment[0] SET_TO 0;
07938   block->d_number SET_TO -1;
07939   block->f_number SET_TO -1.0;
07940   for (n SET_TO 0; n < 14; n++)
07941     {
07942       block->g_modes[n] SET_TO -1;
07943     }
07944   block->h_number SET_TO -1;
07945   block->i_flag SET_TO OFF;
07946   block->j_flag SET_TO OFF;
07947   block->k_flag SET_TO OFF;
07948   block->l_number SET_TO -1;
07949   block->line_number SET_TO -1;
07950   block->motion_to_be SET_TO -1;
07951   block->m_count SET_TO 0;
07952   for (n SET_TO 0; n < 10; n++)
07953     {
07954       block->m_modes[n] SET_TO -1;
07955     }
07956   block->p_number SET_TO -1.0;
07957   block->q_number SET_TO -1.0;
07958   block->r_flag SET_TO OFF;
07959   block->s_number SET_TO -1.0;
07960   block->t_number SET_TO -1;
07961   block->x_flag SET_TO OFF;
07962   block->y_flag SET_TO OFF;
07963   block->z_flag SET_TO OFF;
07964 
07965   return RS274NGC_OK;
07966 }

int inverse_time_rate_arc double    x1,
double    y1,
double    z1,
double    cx,
double    cy,
int    turn,
double    x2,
double    y2,
double    z2,
block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 7987 of file rs274ngc_pre.cc.

Referenced by convert_arc_comp1(), and convert_arc_comp2().

07999 {
08000   double length;
08001   double rate;
08002 
08003   length SET_TO find_arc_length (x1, y1, z1, cx, cy, turn, x2, y2, z2);
08004   rate SET_TO MAX(0.1, (length * block->f_number));
08005   SET_FEED_RATE (rate);
08006   settings->feed_rate SET_TO rate;
08007 
08008   return RS274NGC_OK;
08009 }

int inverse_time_rate_arc2 double    start_x,
double    start_y,
int    turn1,
double    mid_x,
double    mid_y,
double    cx,
double    cy,
int    turn2,
double    end_x,
double    end_y,
double    end_z,
block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 8034 of file rs274ngc_pre.cc.

Referenced by convert_arc_comp2().

08048 {
08049   double length;
08050   double rate;
08051 
08052   length SET_TO (find_arc_length (settings->current_x, settings->current_y,
08053                                   settings->current_z, start_x, start_y,
08054                                   turn1, mid_x, mid_y, settings->current_z) +
08055                  find_arc_length(mid_x, mid_y, settings->current_z,
08056                                  cx, cy, turn2, end_x, end_y, end_z));
08057   rate SET_TO MAX(0.1, (length * block->f_number));
08058   SET_FEED_RATE (rate);
08059   settings->feed_rate SET_TO rate;
08060 
08061   return RS274NGC_OK;
08062 }

int inverse_time_rate_as double    start_x,
double    start_y,
int    turn,
double    mid_x,
double    mid_y,
double    end_x,
double    end_y,
double    end_z,
block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 8087 of file rs274ngc_pre.cc.

Referenced by convert_straight_comp2().

08107 {
08108   double length;
08109   double rate;
08110 
08111   length SET_TO (find_arc_length (settings->current_x, settings->current_y,
08112                                   settings->current_z, start_x, start_y,
08113                                   turn, mid_x, mid_y, settings->current_z) +
08114                  find_straight_length(end_x, end_y,
08115                                 end_z
08116 #ifdef AA
08117 , AA_end
08118 #endif
08119 
08120 #ifdef BB
08121 , BB_end
08122 #endif
08123 
08124 #ifdef CC
08125 , CC_end
08126 #endif
08127 , mid_x, mid_y,
08128                                 settings->current_z
08129 #ifdef AA
08130 , AA_end
08131 #endif
08132 
08133 #ifdef BB
08134 , BB_end
08135 #endif
08136 
08137 #ifdef CC
08138 , CC_end
08139 #endif
08140 ));
08141   rate SET_TO MAX(0.1, (length * block->f_number));
08142   SET_FEED_RATE (rate);
08143   settings->feed_rate SET_TO rate;
08144 
08145   return RS274NGC_OK;
08146 }

int inverse_time_rate_straight double    end_x,
double    end_y,
double    end_z,
block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 8166 of file rs274ngc_pre.cc.

08181 {
08182   static char name[] SET_TO "inverse_time_rate_straight";
08183   double length;
08184   double rate;
08185 
08186   length SET_TO find_straight_length
08187     (end_x, end_y, end_z
08188 #ifdef AA
08189 , AA_end
08190 #endif
08191 
08192 #ifdef BB
08193 , BB_end
08194 #endif
08195 
08196 #ifdef CC
08197 , CC_end
08198 #endif
08199 , settings->current_x,
08200      settings->current_y, settings->current_z
08201 
08202 #ifdef AA
08203 , settings->AA_current
08204 #endif
08205 
08206 #ifdef BB
08207 , settings->BB_current
08208 #endif
08209 
08210 #ifdef CC
08211 , settings->CC_current
08212 #endif
08213 );
08214   rate SET_TO MAX(0.1, (length * block->f_number));
08215   SET_FEED_RATE (rate);
08216   settings->feed_rate SET_TO rate;
08217 
08218   return RS274NGC_OK;
08219 }

int parse_line char *    line,
block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 8242 of file rs274ngc_pre.cc.

08246 {
08247   static char name[] SET_TO "parse_line";
08248   int status;
08249 
08250   CHP(init_block (block));
08251   CHP(read_items(block, line, settings->parameters));
08252   CHP(enhance_block(block, settings));
08253   CHP(check_items (block, settings));
08254   return RS274NGC_OK;
08255 }

int precedence int    an_operator [static]
 

Definition at line 8273 of file rs274ngc_pre.cc.

08275 {
08276   if (an_operator IS RIGHT_BRACKET)
08277     return 1;
08278   else if (an_operator IS POWER)
08279     return 4;
08280   else if (an_operator >= AND2)
08281     return 2;
08282   else
08283     return 3;
08284 }

int read_a char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 8325 of file rs274ngc_pre.cc.

08326                                : line of RS274/NGC code being processed */
08327  int * counter,       /* pointer to a counter for position on the line  */
08328  block_pointer block, /* pointer to a block being filled from the line  */
08329  double * parameters) /* array of system parameters                     */
08330 {
08331   static char name[] SET_TO "read_a";
08332   double value;
08333   int status;
08334 
08335   CHK((line[*counter] ISNT 'a'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
08336   *counter SET_TO (*counter + 1);
08337 #ifdef AA
08338   CHK((block->a_flag ISNT OFF), NCE_MULTIPLE_A_WORDS_ON_ONE_LINE); /*AA*/
08339 #endif
08340   CHP(read_real_value(line, counter, &value, parameters));
08341 #ifdef AA
08342   block->a_flag SET_TO ON;
08343   block->a_number SET_TO value;
08344 #else
08345 #ifdef AXIS_ERROR
08346   ERM(NCE_CANNOT_USE_A_WORD);
08347 #endif /* ifdef AXIS_ERROR */
08348 #endif /* ifdef AA */
08349   return RS274NGC_OK;
08350 }

int read_atan char *    line,
int *    counter,
double *    double_ptr,
double *    parameters
[static]
 

Definition at line 8388 of file rs274ngc_pre.cc.

08389                                : line of RS274/NGC code being processed */
08390  int * counter,       /* pointer to a counter for position on line      */
08391  double * double_ptr, /* pointer to double to be read                   */
08392  double * parameters) /* array of system parameters                     */
08393 {
08394   static char name[] SET_TO "read_atan";
08395   double argument2;
08396   int status;
08397 
08398   CHK((line [*counter] ISNT '/'), NCE_SLASH_MISSING_AFTER_FIRST_ATAN_ARGUMENT);
08399   *counter SET_TO (*counter + 1);
08400   CHK((line[*counter] ISNT '['),
08401       NCE_LEFT_BRACKET_MISSING_AFTER_SLASH_WITH_ATAN);
08402   CHP(read_real_expression (line, counter, &argument2, parameters));
08403   *double_ptr SET_TO atan2(*double_ptr, argument2); /* value in radians */
08404   *double_ptr SET_TO ((*double_ptr * 180.0)/PI);    /* convert to degrees */
08405   return RS274NGC_OK;
08406 }

int read_b char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 8447 of file rs274ngc_pre.cc.

08448                                : line of RS274/NGC code being processed */
08449  int * counter,       /* pointer to a counter for position on the line  */
08450  block_pointer block, /* pointer to a block being filled from the line  */
08451  double * parameters) /* array of system parameters                     */
08452 {
08453   static char name[] SET_TO "read_b";
08454   double value;
08455   int status;
08456 
08457   CHK((line[*counter] ISNT 'b'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
08458   *counter SET_TO (*counter + 1);
08459 #ifdef BB
08460   CHK((block->b_flag ISNT OFF), NCE_MULTIPLE_B_WORDS_ON_ONE_LINE); /*BB*/
08461 #endif
08462   CHP(read_real_value(line, counter, &value, parameters));
08463 #ifdef BB
08464   block->b_flag SET_TO ON;
08465   block->b_number SET_TO value;
08466 #else
08467 #ifdef AXIS_ERROR
08468   ERM(NCE_CANNOT_USE_B_WORD);
08469 #endif /* ifdef AXIS_ERROR */
08470 #endif /* ifdef BB */
08471   return RS274NGC_OK;
08472 }

int read_c char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 8513 of file rs274ngc_pre.cc.

08514                                : line of RS274/NGC code being processed */
08515  int * counter,       /* pointer to a counter for position on the line  */
08516  block_pointer block, /* pointer to a block being filled from the line  */
08517  double * parameters) /* array of system parameters                     */
08518 {
08519   static char name[] SET_TO "read_c";
08520   double value;
08521   int status;
08522 
08523   CHK((line[*counter] ISNT 'c'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
08524   *counter SET_TO (*counter + 1);
08525 #ifdef CC
08526   CHK((block->c_flag ISNT OFF), NCE_MULTIPLE_C_WORDS_ON_ONE_LINE); /*CC*/
08527 #endif
08528   CHP(read_real_value(line, counter, &value, parameters));
08529 #ifdef CC
08530   block->c_flag SET_TO ON;
08531   block->c_number SET_TO value;
08532 #else
08533 #ifdef AXIS_ERROR
08534   ERM(NCE_CANNOT_USE_C_WORD);
08535 #endif /* ifdef AXIS_ERROR */
08536 #endif /* ifdef CC */
08537   return RS274NGC_OK;
08538 }

int read_comment char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 8574 of file rs274ngc_pre.cc.

08575                                   : line of RS274 code being processed    */
08576  int * counter,          /* pointer to a counter for position on the line */
08577  block_pointer block,    /* pointer to a block being filled from the line */
08578  double * parameters)    /* array of system parameters                    */
08579 {
08580   static char name[] SET_TO "read_comment";
08581   int n;
08582 
08583   CHK((line[*counter] ISNT '('), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
08584   (*counter)++;
08585   for (n SET_TO 0; line[*counter] ISNT ')' ; (*counter)++, n++)
08586     {
08587       block->comment[n] SET_TO line[*counter];
08588     }
08589   block->comment[n] SET_TO 0;
08590   (*counter)++;
08591   return RS274NGC_OK;
08592 }

int read_d char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 8627 of file rs274ngc_pre.cc.

08628                                : line of RS274 code being processed    */
08629  int * counter,       /* pointer to a counter for position on the line */
08630  block_pointer block, /* pointer to a block being filled from the line */
08631  double * parameters) /* array of system parameters                    */
08632 {
08633   static char name[] SET_TO "read_d";
08634   int value;
08635   int status;
08636 
08637   CHK((line[*counter] ISNT 'd'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
08638   *counter SET_TO (*counter + 1);
08639   CHK((block->d_number > -1), NCE_MULTIPLE_D_WORDS_ON_ONE_LINE);
08640   CHP(read_integer_value(line, counter, &value, parameters));
08641   CHK((value < 0), NCE_NEGATIVE_D_WORD_TOOL_RADIUS_INDEX_USED);
08642   CHK((value > _setup.tool_max), NCE_TOOL_RADIUS_INDEX_TOO_BIG);
08643   block->d_number SET_TO value;
08644   return RS274NGC_OK;
08645 }

int read_f char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 8679 of file rs274ngc_pre.cc.

08680                                : line of RS274 code being processed    */
08681  int * counter,       /* pointer to a counter for position on the line */
08682  block_pointer block, /* pointer to a block being filled from the line */
08683  double * parameters) /* array of system parameters                    */
08684 {
08685   static char name[] SET_TO "read_f";
08686   double value;
08687   int status;
08688 
08689   CHK((line[*counter] ISNT 'f'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
08690   *counter SET_TO (*counter + 1);
08691   CHK((block->f_number > -1.0), NCE_MULTIPLE_F_WORDS_ON_ONE_LINE);
08692   CHP(read_real_value(line, counter, &value, parameters));
08693   CHK((value < 0.0), NCE_NEGATIVE_F_WORD_USED);
08694   block->f_number SET_TO value;
08695   return RS274NGC_OK;
08696 }

int read_g char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 8747 of file rs274ngc_pre.cc.

08748                                : line of RS274/NGC code being processed */
08749  int * counter,       /* pointer to a counter for position on the line  */
08750  block_pointer block, /* pointer to a block being filled from the line  */
08751  double * parameters) /* array of system parameters                     */
08752 {
08753   static char name[] SET_TO "read_g";
08754   double value_read;
08755   int value;
08756   int mode;
08757   int status;
08758 
08759   CHK((line[*counter] ISNT 'g'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
08760   *counter SET_TO (*counter + 1);
08761   CHP(read_real_value(line, counter, &value_read, parameters));
08762   value_read SET_TO (10.0 * value_read);
08763   value SET_TO (int)floor(value_read);
08764 
08765   if ((value_read - value) > 0.999)
08766     value SET_TO (int)ceil(value_read);
08767   else if ((value_read - value) > 0.001)
08768     ERM(NCE_G_CODE_OUT_OF_RANGE);
08769 
08770   CHK((value > 999), NCE_G_CODE_OUT_OF_RANGE);
08771   CHK((value < 0), NCE_NEGATIVE_G_CODE_USED);
08772   mode SET_TO _gees[value];
08773   CHK((mode IS -1), NCE_UNKNOWN_G_CODE_USED);
08774   CHK((block->g_modes[mode] ISNT -1),
08775       NCE_TWO_G_CODES_USED_FROM_SAME_MODAL_GROUP);
08776   block->g_modes[mode] SET_TO value;
08777   return RS274NGC_OK;
08778 }

int read_h char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 8810 of file rs274ngc_pre.cc.

08811                                : line of RS274/NGC code being processed */
08812  int * counter,       /* pointer to a counter for position on the line  */
08813  block_pointer block, /* pointer to a block being filled from the line  */
08814  double * parameters) /* array of system parameters                     */
08815 {
08816   static char name[] SET_TO "read_h";
08817   int value;
08818   int status;
08819 
08820   CHK((line[*counter] ISNT 'h'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
08821   *counter SET_TO (*counter + 1);
08822   CHK((block->h_number > -1), NCE_MULTIPLE_H_WORDS_ON_ONE_LINE);
08823   CHP(read_integer_value(line, counter, &value, parameters));
08824   CHK((value < 0), NCE_NEGATIVE_H_WORD_TOOL_LENGTH_OFFSET_INDEX_USED);
08825   CHK((value > _setup.tool_max), NCE_TOOL_LENGTH_OFFSET_INDEX_TOO_BIG);
08826   block->h_number SET_TO value;
08827   return RS274NGC_OK;
08828 }

int read_i char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 8863 of file rs274ngc_pre.cc.

08864                                : line of RS274 code being processed     */
08865  int * counter,       /* pointer to a counter for position on the line  */
08866  block_pointer block, /* pointer to a block being filled from the line  */
08867  double * parameters) /* array of system parameters                     */
08868 {
08869   static char name[] SET_TO "read_i";
08870   double value;
08871   int status;
08872 
08873   CHK((line[*counter] ISNT 'i'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
08874   *counter SET_TO (*counter + 1);
08875   CHK((block->i_flag ISNT OFF), NCE_MULTIPLE_I_WORDS_ON_ONE_LINE);
08876   CHP(read_real_value(line, counter, &value, parameters));
08877   block->i_flag SET_TO ON;
08878   block->i_number SET_TO value;
08879   return RS274NGC_OK;
08880 }

int read_integer_unsigned char *    line,
int *    counter,
int *    integer_ptr
[static]
 

Definition at line 8905 of file rs274ngc_pre.cc.

08906                                : line of RS274 code being processed    */
08907  int * counter,       /* pointer to a counter for position on the line */
08908  int * integer_ptr)   /* pointer to the value being read               */
08909 {
08910   static char name[] SET_TO "read_integer_unsigned";
08911   int n;
08912   char c;
08913 
08914   for (n SET_TO *counter; ; n++)
08915     {
08916       c SET_TO line[n];
08917       if ((c < 48) OR (c > 57))
08918         break;
08919     }
08920   CHK((n IS *counter), NCE_BAD_FORMAT_UNSIGNED_INTEGER);
08921   if (sscanf(line + *counter, "%d", integer_ptr) IS 0)
08922     ERM(NCE_SSCANF_FAILED);
08923   *counter SET_TO n;
08924   return RS274NGC_OK;
08925 }

int read_integer_value char *    line,
int *    counter,
int *    integer_ptr,
double *    parameters
[static]
 

Definition at line 8961 of file rs274ngc_pre.cc.

08962                                    : line of RS274/NGC code being processed */
08963  int * counter,           /* pointer to a counter for position on the line  */
08964  int * integer_ptr,       /* pointer to the value being read                */
08965  double * parameters)     /* array of system parameters                     */
08966 {
08967   static char name[] SET_TO "read_integer_value";
08968   double float_value;
08969   int status;
08970 
08971   CHP(read_real_value(line, counter, &float_value, parameters));
08972   *integer_ptr SET_TO (int)floor(float_value);
08973   if ((float_value - *integer_ptr) > 0.9999)
08974     {
08975       *integer_ptr SET_TO (int)ceil(float_value);
08976     }
08977   else if ((float_value - *integer_ptr) > 0.0001)
08978     ERM(NCE_NON_INTEGER_VALUE_FOR_INTEGER);
08979   return RS274NGC_OK;
08980 }

int read_items block_pointer    block,
char *    line,
double *    parameters
[static]
 

Definition at line 9000 of file rs274ngc_pre.cc.

09002                                 : line of RS274/NGC code being processed */
09003  double * parameters)  /* array of system parameters                     */
09004 {
09005   static char name[] SET_TO "read_items";
09006   int counter;
09007   int length;
09008   int status;
09009 
09010   length SET_TO strlen(line);
09011   counter SET_TO 0;
09012 
09013   if (line[counter] IS '/') /* skip the slash character if first */
09014     counter++;
09015   if (line[counter] IS 'n')
09016     {
09017       CHP(read_line_number(line, &counter, block));
09018     }
09019   for ( ; counter < length; )
09020     {
09021       CHP(read_one_item (line, &counter, block, parameters));
09022     }
09023   return RS274NGC_OK;
09024 }

int read_j char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 9059 of file rs274ngc_pre.cc.

09060                                : line of RS274 code being processed     */
09061  int * counter,       /* pointer to a counter for position on the line  */
09062  block_pointer block, /* pointer to a block being filled from the line  */
09063  double * parameters) /* array of system parameters                     */
09064 {
09065   static char name[] SET_TO "read_j";
09066   double value;
09067   int status;
09068 
09069   CHK((line[*counter] ISNT 'j'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
09070   *counter SET_TO (*counter + 1);
09071   CHK((block->j_flag ISNT OFF), NCE_MULTIPLE_J_WORDS_ON_ONE_LINE);
09072   CHP(read_real_value(line, counter, &value, parameters));
09073   block->j_flag SET_TO ON;
09074   block->j_number SET_TO value;
09075   return RS274NGC_OK;
09076 }

int read_k char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 9111 of file rs274ngc_pre.cc.

09112                                : line of RS274 code being processed     */
09113  int * counter,       /* pointer to a counter for position on the line  */
09114  block_pointer block, /* pointer to a block being filled from the line  */
09115  double * parameters) /* array of system parameters                     */
09116 {
09117   static char name[] SET_TO "read_k";
09118   double value;
09119   int status;
09120 
09121   CHK((line[*counter] ISNT 'k'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
09122   *counter SET_TO (*counter + 1);
09123   CHK((block->k_flag ISNT OFF), NCE_MULTIPLE_K_WORDS_ON_ONE_LINE);
09124   CHP(read_real_value(line, counter, &value, parameters));
09125   block->k_flag SET_TO ON;
09126   block->k_number SET_TO value;
09127   return RS274NGC_OK;
09128 }

int read_l char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 9161 of file rs274ngc_pre.cc.

09162                                : line of RS274/NGC code being processed */
09163  int * counter,       /* pointer to a counter for position on the line  */
09164  block_pointer block, /* pointer to a block being filled from the line  */
09165  double * parameters) /* array of system parameters                     */
09166 {
09167   static char name[] SET_TO "read_l";
09168   int value;
09169   int status;
09170 
09171   CHK((line[*counter] ISNT 'l'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
09172   *counter SET_TO (*counter + 1);
09173   CHK((block->l_number > -1), NCE_MULTIPLE_L_WORDS_ON_ONE_LINE);
09174   CHP(read_integer_value(line, counter, &value, parameters));
09175   CHK((value < 0), NCE_NEGATIVE_L_WORD_USED);
09176   block->l_number SET_TO value;
09177   return RS274NGC_OK;
09178 }

int read_line_number char *    line,
int *    counter,
block_pointer    block
[static]
 

Definition at line 9209 of file rs274ngc_pre.cc.

09210                                : line of RS274    code being processed  */
09211  int * counter,       /* pointer to a counter for position on the line  */
09212  block_pointer block) /* pointer to a block being filled from the line  */
09213 {
09214   static char name[] SET_TO "read_line_number";
09215   int value;
09216   int status;
09217 
09218   CHK((line[*counter] ISNT 'n'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
09219   *counter SET_TO (*counter + 1);
09220   CHP(read_integer_unsigned(line, counter, &value));
09221   CHK((value > 99999), NCE_LINE_NUMBER_GREATER_THAN_99999);
09222   block->line_number SET_TO value;
09223   return RS274NGC_OK;
09224 }

int read_m char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 9260 of file rs274ngc_pre.cc.

09261                                : line of RS274 code being processed    */
09262  int * counter,       /* pointer to a counter for position on the line */
09263  block_pointer block, /* pointer to a block being filled from the line */
09264  double * parameters) /* array of system parameters                    */
09265 {
09266   static char name[] SET_TO "read_m";
09267   int value;
09268   int mode;
09269   int status;
09270 
09271   CHK((line[*counter] ISNT 'm'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
09272   *counter SET_TO (*counter + 1);
09273   CHP(read_integer_value(line, counter, &value, parameters));
09274   CHK((value < 0), NCE_NEGATIVE_M_CODE_USED);
09275   CHK((value > 99), NCE_M_CODE_GREATER_THAN_99);
09276   mode SET_TO _ems[value];
09277   CHK((mode IS -1), NCE_UNKNOWN_M_CODE_USED);
09278   CHK((block->m_modes[mode] ISNT -1),
09279       NCE_TWO_M_CODES_USED_FROM_SAME_MODAL_GROUP);
09280   block->m_modes[mode] SET_TO value;
09281   block->m_count++;
09282   return RS274NGC_OK;
09283 }

int read_one_item char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 9330 of file rs274ngc_pre.cc.

09331                                    : line of RS274/NGC code being processed */
09332  int * counter,           /* pointer to a counter for position on the line  */
09333  block_pointer block,     /* pointer to a block being filled from the line  */
09334  double * parameters)     /* array of system parameters                     */
09335 {
09336   static char name[] SET_TO "read_one_item";
09337   int status;
09338   read_function_pointer function_pointer;
09339   char letter;
09340 
09341   letter SET_TO line[*counter];  /* check if in array range */
09342   CHK(((letter < 0) OR (letter > 'z')), NCE_BAD_CHARACTER_USED);
09343   function_pointer SET_TO _readers[letter];
09344   CHK((function_pointer IS 0), NCE_BAD_CHARACTER_USED);
09345   CHP(function_pointer(line, counter, block, parameters));
09346   return RS274NGC_OK;
09347 }

int read_operation char *    line,
int *    counter,
int *    operation
[static]
 

Definition at line 9378 of file rs274ngc_pre.cc.

09379                                     : line of RS274/NGC code being processed */
09380  int * counter,            /* pointer to a counter for position on the line  */
09381  int * operation)          /* pointer to operation to be read                */
09382 {
09383   static char name[] SET_TO "read_operation";
09384   char c;
09385 
09386   c SET_TO line[*counter];
09387   *counter SET_TO (*counter + 1);
09388   switch(c)
09389     {
09390     case '+':
09391       *operation SET_TO PLUS;
09392       break;
09393     case '-':
09394       *operation SET_TO MINUS;
09395       break;
09396     case '/':
09397       *operation SET_TO DIVIDED_BY;
09398       break;
09399     case '*':
09400       if(line[*counter] IS '*')
09401         {
09402           *operation SET_TO POWER;
09403           *counter SET_TO (*counter + 1);
09404         }
09405       else
09406         *operation SET_TO TIMES;
09407       break;
09408     case ']':
09409       *operation SET_TO RIGHT_BRACKET;
09410       break;
09411     case 'a':
09412       if((line[*counter] IS 'n') AND (line[(*counter)+1] IS 'd'))
09413         {
09414           *operation SET_TO AND2;
09415           *counter SET_TO (*counter + 2);
09416         }
09417       else
09418         ERM(NCE_UNKNOWN_OPERATION_NAME_STARTING_WITH_A);
09419       break;
09420     case 'm':
09421       if((line[*counter] IS 'o') AND (line[(*counter)+1] IS 'd'))
09422         {
09423           *operation SET_TO MODULO;
09424           *counter SET_TO (*counter + 2);
09425         }
09426       else
09427         ERM(NCE_UNKNOWN_OPERATION_NAME_STARTING_WITH_M);
09428       break;
09429     case 'o':
09430       if(line[*counter] IS 'r')
09431         {
09432           *operation SET_TO NON_EXCLUSIVE_OR;
09433           *counter SET_TO (*counter + 1);
09434         }
09435       else
09436         ERM(NCE_UNKNOWN_OPERATION_NAME_STARTING_WITH_O);
09437       break;
09438     case 'x':
09439       if((line[*counter] IS 'o') AND (line[(*counter)+1] IS 'r'))
09440         {
09441           *operation SET_TO EXCLUSIVE_OR;
09442           *counter SET_TO (*counter + 2);
09443         }
09444       else
09445         ERM(NCE_UNKNOWN_OPERATION_NAME_STARTING_WITH_X);
09446       break;
09447     case 0:
09448       ERM(NCE_UNCLOSED_EXPRESSION);
09449     default:
09450       ERM(NCE_UNKNOWN_OPERATION);
09451     }
09452   return RS274NGC_OK;
09453 }

int read_operation_unary char *    line,
int *    counter,
int *    operation
[static]
 

Definition at line 9488 of file rs274ngc_pre.cc.

09489                                    : line of RS274/NGC code being processed */
09490  int * counter,           /* pointer to a counter for position on the line  */
09491  int * operation)         /* pointer to operation to be read                */
09492 {
09493   static char name[] SET_TO "read_operation_unary";
09494   char c;
09495 
09496   c SET_TO line[*counter];
09497   *counter SET_TO (*counter + 1);
09498   switch (c)
09499     {
09500     case 'a':
09501       if((line[*counter] IS 'b') AND (line[(*counter)+1] IS 's'))
09502         {
09503           *operation SET_TO ABS;
09504           *counter SET_TO (*counter + 2);
09505         }
09506       else if(strncmp((line + *counter), "cos", 3) IS 0)
09507         {
09508           *operation SET_TO ACOS;
09509           *counter SET_TO (*counter + 3);
09510         }
09511       else if(strncmp((line + *counter), "sin", 3) IS 0)
09512         {
09513           *operation SET_TO ASIN;
09514           *counter SET_TO (*counter + 3);
09515         }
09516       else if(strncmp((line + *counter), "tan", 3) IS 0)
09517         {
09518           *operation SET_TO ATAN;
09519           *counter SET_TO (*counter + 3);
09520         }
09521       else
09522         ERM(NCE_UNKNOWN_WORD_STARTING_WITH_A);
09523       break;
09524     case 'c':
09525       if((line[*counter] IS 'o') AND (line[(*counter)+1] IS 's'))
09526         {
09527           *operation SET_TO COS;
09528           *counter SET_TO (*counter + 2);
09529         }
09530       else
09531         ERM(NCE_UNKNOWN_WORD_STARTING_WITH_C);
09532       break;
09533     case 'e':
09534       if((line[*counter] IS 'x') AND (line[(*counter)+1] IS 'p'))
09535         {
09536           *operation SET_TO EXP;
09537           *counter SET_TO (*counter + 2);
09538         }
09539       else
09540         ERM(NCE_UNKNOWN_WORD_STARTING_WITH_E);
09541       break;
09542     case 'f':
09543       if((line[*counter] IS 'i') AND (line[(*counter)+1] IS 'x'))
09544         {
09545           *operation SET_TO FIX;
09546           *counter SET_TO (*counter + 2);
09547         }
09548       else if((line[*counter] IS 'u') AND (line[(*counter)+1] IS 'p'))
09549         {
09550           *operation SET_TO FUP;
09551           *counter SET_TO (*counter + 2);
09552         }
09553       else
09554         ERM(NCE_UNKNOWN_WORD_STARTING_WITH_F);
09555       break;
09556     case 'l':
09557       if(line[*counter] IS 'n')
09558         {
09559           *operation SET_TO LN;
09560           *counter SET_TO (*counter + 1);
09561         }
09562       else
09563         ERM(NCE_UNKNOWN_WORD_STARTING_WITH_L);
09564       break;
09565     case 'r':
09566       if(strncmp((line + *counter), "ound", 4) IS 0)
09567         {
09568           *operation SET_TO ROUND;
09569           *counter SET_TO (*counter + 4);
09570         }
09571       else
09572         ERM(NCE_UNKNOWN_WORD_STARTING_WITH_R);
09573       break;
09574     case 's':
09575       if((line[*counter] IS 'i') AND (line[(*counter)+1] IS 'n'))
09576         {
09577           *operation SET_TO SIN;
09578           *counter SET_TO (*counter + 2);
09579         }
09580       else if(strncmp((line + *counter), "qrt", 3) IS 0)
09581         {
09582           *operation SET_TO SQRT;
09583           *counter SET_TO (*counter + 3);
09584         }
09585       else
09586         ERM(NCE_UNKNOWN_WORD_STARTING_WITH_S);
09587       break;
09588     case 't':
09589       if((line[*counter] IS 'a') AND (line[(*counter)+1] IS 'n'))
09590         {
09591           *operation SET_TO TAN;
09592           *counter SET_TO (*counter + 2);
09593         }
09594       else
09595         ERM(NCE_UNKNOWN_WORD_STARTING_WITH_T);
09596       break;
09597     default:
09598       ERM(NCE_UNKNOWN_WORD_WHERE_UNARY_OPERATION_COULD_BE);
09599     }
09600   return RS274NGC_OK;
09601 }

int read_p char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 9635 of file rs274ngc_pre.cc.

09636                                : line of RS274/NGC code being processed */
09637  int * counter,       /* pointer to a counter for position on the line  */
09638  block_pointer block, /* pointer to a block being filled from the line  */
09639  double * parameters) /* array of system parameters                     */
09640 {
09641   static char name[] SET_TO "read_p";
09642   double value;
09643   int status;
09644 
09645   CHK((line[*counter] ISNT 'p'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
09646   *counter SET_TO (*counter + 1);
09647   CHK((block->p_number > -1.0), NCE_MULTIPLE_P_WORDS_ON_ONE_LINE);
09648   CHP(read_real_value(line, counter, &value, parameters));
09649   CHK((value < 0.0), NCE_NEGATIVE_P_WORD_USED);
09650   block->p_number SET_TO value;
09651   return RS274NGC_OK;
09652 }

int read_parameter char *    line,
int *    counter,
double *    double_ptr,
double *    parameters
[static]
 

Definition at line 9691 of file rs274ngc_pre.cc.

09692                                     : line of RS274/NGC code being processed */
09693  int * counter,            /* pointer to a counter for position on the line  */
09694  double * double_ptr,      /* pointer to double to be read                   */
09695  double * parameters)      /* array of system parameters                     */
09696 {
09697   static char name[] SET_TO "read_parameter";
09698   int index;
09699   int status;
09700 
09701   CHK((line[*counter] ISNT '#'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
09702   *counter SET_TO (*counter + 1);
09703   CHP(read_integer_value(line, counter, &index, parameters));
09704   CHK(((index < 1) OR (index >= RS274NGC_MAX_PARAMETERS)),
09705       NCE_PARAMETER_NUMBER_OUT_OF_RANGE);
09706   *double_ptr SET_TO parameters[index];
09707   return RS274NGC_OK;
09708 }

int read_parameter_setting char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 9777 of file rs274ngc_pre.cc.

09778                                : line of RS274/NGC code being processed */
09779  int * counter,       /* pointer to a counter for position on the line  */
09780  block_pointer block, /* pointer to a block being filled from the line  */
09781  double * parameters) /* array of system parameters                     */
09782 {
09783   static char name[] SET_TO "read_parameter_setting";
09784   int index;
09785   double value;
09786   int status;
09787 
09788   CHK((line[*counter] ISNT '#'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
09789   *counter SET_TO (*counter + 1);
09790   CHP(read_integer_value(line, counter, &index, parameters));
09791   CHK(((index < 1) OR (index >= RS274NGC_MAX_PARAMETERS)),
09792       NCE_PARAMETER_NUMBER_OUT_OF_RANGE);
09793   CHK((line[*counter] ISNT '='), NCE_EQUAL_SIGN_MISSING_IN_PARAMETER_SETTING);
09794   *counter SET_TO (*counter + 1);
09795   CHP(read_real_value(line, counter, &value, parameters));
09796   _setup.parameter_numbers[_setup.parameter_occurrence] SET_TO index;
09797   _setup.parameter_values[_setup.parameter_occurrence] SET_TO value;
09798   _setup.parameter_occurrence++;
09799   return RS274NGC_OK;
09800 }

int read_q char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 9833 of file rs274ngc_pre.cc.

09834                                : line of RS274/NGC code being processed */
09835  int * counter,       /* pointer to a counter for position on the line  */
09836  block_pointer block, /* pointer to a block being filled from the line  */
09837  double * parameters) /* array of system parameters                     */
09838 {
09839   static char name[] SET_TO "read_q";
09840   double value;
09841   int status;
09842 
09843   CHK((line[*counter] ISNT 'q'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
09844   *counter SET_TO (*counter + 1);
09845   CHK((block->q_number > -1.0), NCE_MULTIPLE_Q_WORDS_ON_ONE_LINE);
09846   CHP(read_real_value(line, counter, &value, parameters));
09847   CHK((value <= 0.0), NCE_NEGATIVE_OR_ZERO_Q_VALUE_USED);
09848   block->q_number SET_TO value;
09849   return RS274NGC_OK;
09850 }

int read_r char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 9887 of file rs274ngc_pre.cc.

09888                                : line of RS274 code being processed    */
09889  int * counter,       /* pointer to a counter for position on the line */
09890  block_pointer block, /* pointer to a block being filled from the line */
09891  double * parameters) /* array of system parameters                    */
09892 {
09893   static char name[] SET_TO "read_r";
09894   double value;
09895   int status;
09896 
09897   CHK((line[*counter] ISNT 'r'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
09898   *counter SET_TO (*counter + 1);
09899   CHK((block->r_flag ISNT OFF), NCE_MULTIPLE_R_WORDS_ON_ONE_LINE);
09900   CHP(read_real_value(line, counter, &value, parameters));
09901   block->r_flag SET_TO ON;
09902   block->r_number SET_TO value;
09903   return RS274NGC_OK;
09904 }

int read_real_expression char *    line,
int *    counter,
double *    value,
double *    parameters
[static]
 

Definition at line 10155 of file rs274ngc_pre.cc.

10156                                    : line of RS274/NGC code being processed */
10157  int * counter,           /* pointer to a counter for position on the line  */
10158  double * value,          /* pointer to double to be computed               */
10159  double * parameters)     /* array of system parameters                     */
10160 {
10161   static char name[] SET_TO "read_real_expression";
10162   double values[MAX_STACK];
10163   int operators[MAX_STACK];
10164   int stack_index;
10165   int status;
10166 
10167   CHK((line[*counter] ISNT '['), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
10168   *counter SET_TO (*counter + 1);
10169   CHP(read_real_value(line, counter, values, parameters));
10170   CHP(read_operation(line, counter, operators));
10171   stack_index SET_TO 1;
10172   for(; operators[0] ISNT RIGHT_BRACKET ;)
10173     {
10174       CHP(read_real_value(line, counter, values+stack_index, parameters));
10175       CHP(read_operation(line, counter, operators+stack_index));
10176       if (precedence(operators[stack_index]) >
10177           precedence(operators[stack_index - 1]))
10178         stack_index++;
10179       else /* precedence of latest operator is <= previous precedence */
10180         {
10181           for (;precedence(operators[stack_index]) <=
10182                  precedence(operators[stack_index - 1]); )
10183             {
10184               CHP(execute_binary((values + stack_index - 1),
10185                                  operators[stack_index -1],
10186                                  (values + stack_index)));
10187               operators[stack_index - 1] SET_TO operators[stack_index];
10188               if ((stack_index > 1) AND
10189                   (precedence(operators[stack_index - 1]) <=
10190                    precedence(operators[stack_index - 2])))
10191                 stack_index--;
10192               else
10193                 break;
10194             }
10195         }
10196     }
10197   *value SET_TO values[0];
10198   return RS274NGC_OK;
10199 }

int read_real_number char *    line,
int *    counter,
double *    double_ptr
[static]
 

Definition at line 10239 of file rs274ngc_pre.cc.

10240                                : line of RS274/NGC code being processed */
10241  int * counter,       /* pointer to a counter for position on the line  */
10242  double * double_ptr) /* pointer to double to be read                   */
10243 {
10244   static char name[] SET_TO "read_real_number";
10245   char c;          /* for character being processed    */
10246   int flag_digit;  /* set to ON if digit found         */
10247   int flag_point;  /* set to ON if decimal point found */
10248   int n;           /* for indexing line                */
10249 
10250   n SET_TO *counter;
10251   flag_point SET_TO OFF;
10252   flag_digit SET_TO OFF;
10253 
10254 /* check first character */
10255   c SET_TO line[n];
10256   if (c IS '+')
10257     {
10258       *counter SET_TO (*counter + 1); /* skip plus sign */
10259       n++;
10260     }
10261   else if (c IS '-')
10262     {
10263       n++;
10264     }
10265   else if ((c ISNT '.') AND ((c < 48) OR (c > 57)))
10266     ERM(NCE_BAD_NUMBER_FORMAT);
10267 
10268 /* check out rest of characters (must be digit or decimal point) */
10269   for (; (c SET_TO line[n]) ISNT (char) NULL; n++)
10270     {
10271       if (( 47 < c) AND ( c < 58))
10272         {
10273           flag_digit SET_TO ON;
10274         }
10275       else if (c IS '.')
10276         {
10277           if (flag_point IS OFF)
10278             {
10279               flag_point SET_TO ON;
10280             }
10281           else
10282             break; /* two decimal points, error appears on reading next item */
10283         }
10284       else
10285         break;
10286     }
10287 
10288   CHK((flag_digit IS OFF), NCE_NO_DIGITS_FOUND_WHERE_REAL_NUMBER_SHOULD_BE);
10289   line[n] SET_TO (char) NULL; /* temporary string termination for sscanf */
10290   if (sscanf(line + *counter, "%lf", double_ptr) IS 0)
10291     {
10292       line[n] SET_TO c;
10293       ERM(NCE_SSCANF_FAILED);
10294     }
10295   else
10296     {
10297       line[n] SET_TO c;
10298       *counter SET_TO n;
10299     }
10300   return RS274NGC_OK;
10301 }

int read_real_value char *    line,
int *    counter,
double *    double_ptr,
double *    parameters
[static]
 

Definition at line 10350 of file rs274ngc_pre.cc.

10351                                : line of RS274/NGC code being processed */
10352  int * counter,       /* pointer to a counter for position on the line  */
10353  double * double_ptr, /* pointer to double to be read                   */
10354  double * parameters) /* array of system parameters                     */
10355 {
10356   static char name[] SET_TO "read_real_value";
10357   char c;
10358   int status;
10359 
10360   c SET_TO line[*counter];
10361   CHK((c IS 0), NCE_NO_CHARACTERS_FOUND_IN_READING_REAL_VALUE);
10362   if (c IS '[')
10363     CHP(read_real_expression (line, counter, double_ptr, parameters));
10364   else if (c IS '#')
10365     CHP(read_parameter(line, counter, double_ptr, parameters));
10366   else if ((c >= 'a') AND (c <= 'z'))
10367     CHP(read_unary(line, counter, double_ptr, parameters));
10368   else
10369     CHP(read_real_number(line, counter, double_ptr));
10370 
10371   return RS274NGC_OK;
10372 }

int read_s char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 10524 of file rs274ngc_pre.cc.

10525                                : line of RS274NGC code being processed */
10526  int * counter,       /* pointer to a counter for position on the line */
10527  block_pointer block, /* pointer to a block being filled from the line */
10528  double * parameters) /* array of system parameters                    */
10529 {
10530   static char name[] SET_TO "read_s";
10531   double value;
10532   int status;
10533 
10534   CHK((line[*counter] ISNT 's'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
10535   *counter SET_TO (*counter + 1);
10536   CHK((block->s_number > -1.0), NCE_MULTIPLE_S_WORDS_ON_ONE_LINE);
10537   CHP(read_real_value(line, counter, &value, parameters));
10538   CHK((value < 0.0), NCE_NEGATIVE_SPINDLE_SPEED_USED);
10539   block->s_number SET_TO value;
10540   return RS274NGC_OK;
10541 }

int read_t char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 10574 of file rs274ngc_pre.cc.

10575                                : line of RS274/NGC code being processed */
10576  int * counter,       /* pointer to a counter for position on the line  */
10577  block_pointer block, /* pointer to a block being filled from the line  */
10578  double * parameters) /* array of system parameters                     */
10579 {
10580   static char name[] SET_TO "read_t";
10581   int value;
10582   int status;
10583 
10584   CHK((line[*counter] ISNT 't'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
10585   *counter SET_TO (*counter + 1);
10586   CHK((block->t_number > -1), NCE_MULTIPLE_T_WORDS_ON_ONE_LINE);
10587   CHP(read_integer_value(line, counter, &value, parameters));
10588   CHK((value < 0), NCE_NEGATIVE_TOOL_ID_USED);
10589   block->t_number SET_TO value;
10590   return RS274NGC_OK;
10591 }

int read_text const char *    command,
FILE *    inport,
char *    raw_line,
char *    line,
int *    length
[static]
 

Definition at line 10658 of file rs274ngc_pre.cc.

Referenced by rs274ngc_read().

10664 {
10665   static char name[] SET_TO "read_text";
10666   int status;          /* used in CHP */
10667   int index;
10668 
10669 
10670   if (command IS NULL)
10671     {
10672       if(fgets(raw_line, RS274NGC_TEXT_SIZE, inport) IS NULL)
10673         {
10674           if (_setup.percent_flag IS ON)
10675             ERM(NCE_FILE_ENDED_WITH_NO_PERCENT_SIGN);
10676           else
10677             ERM(NCE_FILE_ENDED_WITH_NO_PERCENT_SIGN_OR_PROGRAM_END);
10678         }
10679       _setup.sequence_number++;
10680       if (strlen(raw_line) IS (RS274NGC_TEXT_SIZE - 1))
10681         { // line is too long. need to finish reading the line to recover
10682           for(;fgetc(inport) ISNT '\n';){} // could also look for EOF
10683           ERM(NCE_COMMAND_TOO_LONG);
10684         }
10685       for(index SET_TO (strlen(raw_line) -1); // index set on last char
10686           (index >= 0) AND (isspace(raw_line[index]));
10687           index--)
10688         {        // remove space at end of raw_line, especially CR & LF
10689           raw_line[index] SET_TO 0;
10690         }
10691       strcpy(line, raw_line);
10692       CHP(close_and_downcase(line));
10693       if ((line[0] IS '%') AND (line[1] IS 0) AND (_setup.percent_flag IS ON))
10694         return RS274NGC_ENDFILE;
10695     }
10696   else
10697     {
10698       CHK((strlen(command) >= RS274NGC_TEXT_SIZE), NCE_COMMAND_TOO_LONG);
10699       strcpy(raw_line, command);
10700       strcpy(line, command);
10701       CHP(close_and_downcase(line));
10702     }
10703   _setup.parameter_occurrence SET_TO 0; /* initialize parameter buffer */
10704   if ((line[0] IS 0) OR ((line[0] IS '/') AND (line[1] IS 0)))
10705     *length SET_TO 0;
10706   else
10707     *length SET_TO strlen(line);
10708 
10709   return ((line[0] IS '/')? RS274NGC_EXECUTE_FINISH : RS274NGC_OK);
10710 }

int read_unary char *    line,
int *    counter,
double *    double_ptr,
double *    parameters
[static]
 

Definition at line 10741 of file rs274ngc_pre.cc.

10742                                 : line of RS274/NGC code being processed */
10743  int * counter,        /* pointer to a counter for position on the line  */
10744  double * double_ptr,  /* pointer to double to be read                   */
10745  double * parameters)  /* array of system parameters                     */
10746 {
10747   static char name[] SET_TO "read_unary";
10748   int operation;
10749   int status;
10750 
10751   CHP(read_operation_unary (line, counter, &operation));
10752   CHK((line[*counter] ISNT '['),
10753       NCE_LEFT_BRACKET_MISSING_AFTER_UNARY_OPERATION_NAME);
10754   CHP(read_real_expression (line, counter, double_ptr, parameters));
10755 
10756   if (operation IS ATAN)
10757     CHP(read_atan(line, counter, double_ptr, parameters));
10758   else
10759     CHP(execute_unary(double_ptr, operation));
10760   return RS274NGC_OK;
10761 }

int read_x char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 10796 of file rs274ngc_pre.cc.

10797                                : line of RS274 code being processed     */
10798  int * counter,       /* pointer to a counter for position on the line  */
10799  block_pointer block, /* pointer to a block being filled from the line  */
10800  double * parameters) /* array of system parameters                     */
10801 {
10802   static char name[] SET_TO "read_x";
10803   double value;
10804   int status;
10805 
10806   CHK((line[*counter] ISNT 'x'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
10807   *counter SET_TO (*counter + 1);
10808   CHK((block->x_flag ISNT OFF), NCE_MULTIPLE_X_WORDS_ON_ONE_LINE);
10809   CHP(read_real_value(line, counter, &value, parameters));
10810   block->x_flag SET_TO ON;
10811   block->x_number SET_TO value;
10812   return RS274NGC_OK;
10813 }

int read_y char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 10848 of file rs274ngc_pre.cc.

10849                                : line of RS274 code being processed     */
10850  int * counter,       /* pointer to a counter for position on the line  */
10851  block_pointer block, /* pointer to a block being filled from the line  */
10852  double * parameters) /* array of system parameters                     */
10853 {
10854   static char name[] SET_TO "read_y";
10855   double value;
10856   int status;
10857 
10858   CHK((line[*counter] ISNT 'y'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
10859   *counter SET_TO (*counter + 1);
10860   CHK((block->y_flag ISNT OFF), NCE_MULTIPLE_Y_WORDS_ON_ONE_LINE);
10861   CHP(read_real_value(line, counter, &value, parameters));
10862   block->y_flag SET_TO ON;
10863   block->y_number SET_TO value;
10864   return RS274NGC_OK;
10865 }

int read_z char *    line,
int *    counter,
block_pointer    block,
double *    parameters
[static]
 

Definition at line 10900 of file rs274ngc_pre.cc.

10901                                : line of RS274 code being processed     */
10902  int * counter,       /* pointer to a counter for position on the line  */
10903  block_pointer block, /* pointer to a block being filled from the line  */
10904  double * parameters) /* array of system parameters                     */
10905 {
10906   static char name[] SET_TO "read_z";
10907   double value;
10908   int status;
10909 
10910   CHK((line[*counter] ISNT 'z'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
10911   *counter SET_TO (*counter + 1);
10912   CHK((block->z_flag ISNT OFF), NCE_MULTIPLE_Z_WORDS_ON_ONE_LINE);
10913   CHP(read_real_value(line, counter, &value, parameters));
10914   block->z_flag SET_TO ON;
10915   block->z_number SET_TO value;
10916   return RS274NGC_OK;
10917 }

void rs274ngc_active_g_codes int *    codes
 

Definition at line 11940 of file rs274ngc_pre.cc.

Referenced by emcTaskUpdate(), and main().

11942 {
11943   int n;
11944 
11945   for (n SET_TO 0; n < RS274NGC_ACTIVE_G_CODES; n++)
11946     {
11947       codes[n] SET_TO _setup.active_g_codes[n];
11948     }
11949 }

void rs274ngc_active_m_codes int *    codes
 

Definition at line 11965 of file rs274ngc_pre.cc.

Referenced by emcTaskUpdate(), and main().

11967 {
11968   int n;
11969 
11970   for (n SET_TO 0; n < RS274NGC_ACTIVE_M_CODES; n++)
11971     {
11972       codes[n] SET_TO _setup.active_m_codes[n];
11973     }
11974 }

void rs274ngc_active_settings double *    settings
 

Definition at line 11990 of file rs274ngc_pre.cc.

Referenced by emcTaskUpdate(), and main().

11992 {
11993   int n;
11994 
11995   for (n SET_TO 0; n < RS274NGC_ACTIVE_SETTINGS; n++)
11996     {
11997       settings[n] SET_TO _setup.active_settings[n];
11998     }
11999 }

int rs274ngc_close  
 

Definition at line 11144 of file rs274ngc_pre.cc.

11145 {
11146   if (_setup.file_pointer ISNT NULL)
11147   {
11148     fclose(_setup.file_pointer);
11149     _setup.file_pointer SET_TO NULL;
11150   }
11151   rs274ngc_reset();
11152 
11153   return RS274NGC_OK;
11154 }

void rs274ngc_error_text int    error_code,
char *    error_text,
int    max_size
 

Definition at line 12020 of file rs274ngc_pre.cc.

Referenced by waitFlag().

12024 {
12025   if (((error_code >= RS274NGC_MIN_ERROR) AND
12026        (error_code <= RS274NGC_MAX_ERROR)) AND
12027       (strlen(_rs274ngc_errors[error_code]) < ((size_t) max_size) ))
12028     {
12029       strcpy(error_text, _rs274ngc_errors[error_code]);
12030     }
12031   else
12032     error_text[0] SET_TO 0;
12033 }

int rs274ngc_execute const char *    command = 0
 

Definition at line 11179 of file rs274ngc_pre.cc.

Referenced by emcTaskPlanExecute(), emcTaskPlanInit(), interpret_from_file(), and interpret_from_keyboard().

11183 {
11184   static char name[] SET_TO "rs274ngc_execute";
11185   int status;
11186   int n;
11187 
11188 #ifndef NOT_OLD_EMC_INTERP_COMPATIBLE
11189   if(NULL != command)
11190     {
11191       status = rs274ngc_read(command);
11192     }
11193 #endif
11194 
11195   for (n SET_TO 0; n < _setup.parameter_occurrence; n++)
11196     { // copy parameter settings from parameter buffer into parameter table
11197       _setup.parameters[_setup.parameter_numbers[n]]
11198         SET_TO _setup.parameter_values[n];
11199     }
11200   if (_setup.line_length ISNT 0) /* line not blank */
11201     {
11202       status SET_TO execute_block (&(_setup.block1), &_setup);
11203       write_g_codes(&(_setup.block1), &_setup);
11204       write_m_codes(&(_setup.block1), &_setup);
11205       write_settings(&_setup);
11206       if ((status ISNT RS274NGC_OK) AND
11207           (status ISNT RS274NGC_EXECUTE_FINISH) AND
11208           (status ISNT RS274NGC_EXIT))
11209         ERP(status);
11210     }
11211   else /* blank line is OK */
11212     status SET_TO RS274NGC_OK;
11213   return status;
11214 }

int rs274ngc_exit  
 

Definition at line 11233 of file rs274ngc_pre.cc.

11234 {
11235   char file_name[RS274NGC_TEXT_SIZE];
11236 
11237   GET_EXTERNAL_PARAMETER_FILE_NAME(file_name, (RS274NGC_TEXT_SIZE - 1));
11238   rs274ngc_save_parameters
11239     (((file_name[0] IS 0) ? RS274NGC_PARAMETER_FILE_NAME_DEFAULT : file_name),
11240      _setup.parameters);
11241   rs274ngc_reset();
11242 
11243   return RS274NGC_OK;
11244 }

void rs274ngc_file_name char *    file_name,
int    max_size
 

Definition at line 12052 of file rs274ngc_pre.cc.

Referenced by main(), and rs274ngc_file().

12053                                   : to copy file name into       */
12054  int max_size)           /* maximum number of characters to copy */
12055 {
12056   if (strlen(_setup.filename) < ((size_t) max_size) )
12057     strcpy(file_name, _setup.filename);
12058   else
12059     file_name[0] SET_TO 0;
12060 }

int rs274ngc_init  
 

Definition at line 11273 of file rs274ngc_pre.cc.

11274 {
11275   static char name[] SET_TO "rs274ngc_init";
11276   int k; // starting index in parameters of origin offsets
11277   int status;
11278   char filename[RS274NGC_TEXT_SIZE];
11279   double * pars; // short name for _setup.parameters
11280 
11281   INIT_CANON();
11282   _setup.length_units SET_TO GET_EXTERNAL_LENGTH_UNIT_TYPE();
11283   USE_LENGTH_UNITS(_setup.length_units);
11284   GET_EXTERNAL_PARAMETER_FILE_NAME(filename, RS274NGC_TEXT_SIZE);
11285   if (filename[0] IS 0)
11286     strcpy(filename, RS274NGC_PARAMETER_FILE_NAME_DEFAULT);
11287   CHP(rs274ngc_restore_parameters(filename));
11288   pars SET_TO _setup.parameters;
11289   _setup.origin_index SET_TO (int)(pars[5220] + 0.0001);
11290   CHK(((_setup.origin_index < 1) OR (_setup.origin_index > 9)),
11291       NCE_COORDINATE_SYSTEM_INDEX_PARAMETER_5220_OUT_OF_RANGE);
11292   k SET_TO (5200 + (_setup.origin_index * 20));
11293   SET_ORIGIN_OFFSETS((pars[k + 1] + pars[5211]),
11294                      (pars[k + 2] + pars[5212]),
11295                      (pars[k + 3] + pars[5213])
11296 #ifdef AA
11297 ,                    (pars[k + 4] + pars[5214])
11298 #else
11299 #ifdef ALL_AXES
11300 , 0
11301 #endif
11302 #endif
11303 #ifdef BB
11304 ,                    (pars[k + 5] + pars[5215])
11305 #else
11306 #ifdef ALL_AXES
11307 , 0
11308 #endif
11309 #endif
11310 #ifdef CC
11311 ,                    (pars[k + 6] + pars[5216])
11312 #else
11313 #ifdef ALL_AXES
11314 , 0
11315 #endif
11316 #endif
11317 );
11318   SET_FEED_REFERENCE(CANON_XYZ);
11319 #ifdef AA
11320   _setup.AA_axis_offset SET_TO pars[5214];                 /*AA*/
11321 #endif
11322 //_setup.Aa_current set in rs274ngc_synch
11323 #ifdef AA
11324   _setup.AA_origin_offset SET_TO pars[k + 4];              /*AA*/
11325 #endif
11326 //_setup.active_g_codes initialized below
11327 //_setup.active_m_codes initialized below
11328 //_setup.active_settings initialized below
11329   _setup.axis_offset_x SET_TO pars[5211];
11330   _setup.axis_offset_y SET_TO pars[5212];
11331   _setup.axis_offset_z SET_TO pars[5213];
11332 #ifdef BB
11333   _setup.BB_axis_offset SET_TO pars[5215];                 /*BB*/
11334 #endif
11335 //_setup.Bb_current set in rs274ngc_synch
11336 #ifdef BB
11337   _setup.BB_origin_offset SET_TO pars[k + 5];              /*BB*/
11338 #endif
11339 //_setup.block1 does not need initialization
11340   _setup.blocktext[0] SET_TO 0;
11341 #ifdef CC
11342   _setup.CC_axis_offset SET_TO pars[5216];                 /*CC*/
11343 #endif
11344 //_setup.Cc_current set in rs274ngc_synch
11345 #ifdef CC
11346   _setup.CC_origin_offset SET_TO pars[k + 6];              /*CC*/
11347 #endif
11348 //_setup.current_slot set in rs274ngc_synch
11349 //_setup.current_x set in rs274ngc_synch
11350 //_setup.current_y set in rs274ngc_synch
11351 //_setup.current_z set in rs274ngc_synch
11352   _setup.cutter_comp_side SET_TO OFF;
11353 //_setup.cycle values do not need initialization
11354   _setup.distance_mode SET_TO MODE_ABSOLUTE;
11355   _setup.feed_mode SET_TO UNITS_PER_MINUTE;
11356   _setup.feed_override SET_TO ON;
11357 //_setup.feed_rate set in rs274ngc_synch
11358   _setup.filename[0] SET_TO 0;
11359   _setup.file_pointer SET_TO NULL;
11360 //_setup.flood set in rs274ngc_synch
11361   _setup.length_offset_index SET_TO 1;
11362 //_setup.length_units set in rs274ngc_synch
11363   _setup.line_length SET_TO 0;
11364   _setup.linetext[0] SET_TO 0;
11365 //_setup.mist set in rs274ngc_synch
11366   _setup.motion_mode SET_TO G_80;
11367 //_setup.origin_index set above
11368   _setup.origin_offset_x SET_TO pars[k + 1];
11369   _setup.origin_offset_y SET_TO pars[k + 2];
11370   _setup.origin_offset_z SET_TO pars[k + 3];
11371 //_setup.parameters set above
11372 //_setup.parameter_occurrence does not need initialization
11373 //_setup.parameter_numbers does not need initialization
11374 //_setup.parameter_values does not need initialization
11375 //_setup.percent_flag does not need initialization
11376 //_setup.plane set in rs274ngc_synch
11377   _setup.probe_flag SET_TO OFF;
11378   _setup.program_x SET_TO UNKNOWN; /* for cutter comp */
11379   _setup.program_y SET_TO UNKNOWN; /* for cutter comp */
11380 //_setup.retract_mode does not need initialization
11381 //_setup.selected_tool_slot set in rs274ngc_synch
11382   _setup.sequence_number SET_TO 0; /*DOES THIS NEED TO BE AT TOP? */
11383 //_setup.speed set in rs274ngc_synch
11384   _setup.speed_feed_mode SET_TO CANON_INDEPENDENT;
11385   _setup.speed_override SET_TO ON;
11386 //_setup.spindle_turning set in rs274ngc_synch
11387 //_setup.stack does not need initialization
11388 //_setup.stack_index does not need initialization
11389   _setup.tool_length_offset SET_TO 0.0;
11390 //_setup.tool_max set in rs274ngc_synch
11391 //_setup.tool_table set in rs274ngc_synch
11392   _setup.tool_table_index SET_TO 1;
11393 //_setup.traverse_rate set in rs274ngc_synch
11394 
11395   write_g_codes((block_pointer)NULL, &_setup);
11396   write_m_codes((block_pointer)NULL, &_setup);
11397   write_settings(&_setup);
11398 
11399   // Synch rest of settings to external world
11400   rs274ngc_synch();
11401 
11402   return RS274NGC_OK;
11403 }

int rs274ngc_line_length  
 

Definition at line 12074 of file rs274ngc_pre.cc.

12075 {
12076   return _setup.line_length;
12077 }

void rs274ngc_line_text char *    line_text,
int    max_size
 

Definition at line 12095 of file rs274ngc_pre.cc.

Referenced by print_nc_line_number(), and rs274ngc_command().

12096                                   : to copy line into            */
12097  int max_size)           /* maximum number of characters to copy */
12098 {
12099   int n;
12100   char * the_text;
12101 
12102   the_text SET_TO _setup.linetext;
12103   for (n SET_TO 0; n < (max_size - 1); n++)
12104     {
12105       if (the_text[n] ISNT 0)
12106         line_text[n] SET_TO the_text[n];
12107       else
12108         break;
12109     }
12110   line_text[n] SET_TO 0;
12111 }

int rs274ngc_load_tool_table  
 

Definition at line 11429 of file rs274ngc_pre.cc.

11430 {
11431   static char name[] SET_TO "rs274ngc_load_tool_table";
11432   int n;
11433 
11434   CHK((_setup.tool_max > CANON_TOOL_MAX), NCE_TOOL_MAX_TOO_LARGE);
11435   for (n SET_TO 0; n <= _setup.tool_max; n++)
11436     {
11437       _setup.tool_table[n] SET_TO GET_EXTERNAL_TOOL_TABLE(n);
11438     }
11439   for(; n <= CANON_TOOL_MAX; n++)
11440     {
11441       _setup.tool_table[n].id SET_TO 0;
11442       _setup.tool_table[n].length SET_TO 0;
11443       _setup.tool_table[n].diameter SET_TO 0;
11444     }
11445 
11446   return RS274NGC_OK;
11447 }

int rs274ngc_open const char *    filename
 

Definition at line 11495 of file rs274ngc_pre.cc.

Referenced by emcTaskPlanOpen(), emcTaskPlanRead(), interpret_from_file(), and main().

11496                                   : the name of the input NC-program file */
11497 {
11498   static char name[] SET_TO "rs274ngc_open";
11499   char * line;
11500   int index;
11501   int length;
11502 
11503   CHK((_setup.file_pointer ISNT NULL), NCE_A_FILE_IS_ALREADY_OPEN);
11504   CHK((strlen(filename) > (RS274NGC_TEXT_SIZE - 1)), NCE_FILE_NAME_TOO_LONG);
11505   _setup.file_pointer SET_TO fopen(filename, "r");
11506   CHK((_setup.file_pointer IS NULL), NCE_UNABLE_TO_OPEN_FILE);
11507   line SET_TO _setup.linetext;
11508   for(index SET_TO -1; index IS -1;) /* skip blank lines */
11509     {
11510       CHK((fgets(line, RS274NGC_TEXT_SIZE, _setup.file_pointer) IS NULL),
11511           NCE_FILE_ENDED_WITH_NO_PERCENT_SIGN);
11512       length SET_TO strlen(line);
11513       if (length IS (RS274NGC_TEXT_SIZE - 1))
11514         { // line is too long. need to finish reading the line to recover
11515           for(;fgetc(_setup.file_pointer) ISNT '\n';); // could look for EOF
11516           ERM(NCE_COMMAND_TOO_LONG);
11517         }
11518       for(index SET_TO (length -1); // index set on last char
11519           (index >= 0) AND (isspace(line[index]));
11520           index--);
11521     }
11522   if(line[index] IS '%')
11523     {
11524       for(index--; (index >= 0) AND (isspace(line[index])); index--);
11525       if (index IS -1)
11526         {
11527           _setup.percent_flag SET_TO ON;
11528           _setup.sequence_number=1; // We have already read the first line
11529           // and we are not going back to it.
11530         }
11531       else
11532         {
11533           fseek(_setup.file_pointer, 0, SEEK_SET);
11534           _setup.percent_flag SET_TO OFF;
11535           _setup.sequence_number=0; // Going back to line 0
11536         }
11537     }
11538   else
11539     {
11540       fseek(_setup.file_pointer, 0, SEEK_SET);
11541       _setup.percent_flag SET_TO OFF;
11542       _setup.sequence_number=0; // Going back to line 0
11543     }
11544   strcpy(_setup.filename, filename);
11545   rs274ngc_reset();
11546   return RS274NGC_OK;
11547 }

int rs274ngc_read const char *    command = 0
 

Definition at line 11580 of file rs274ngc_pre.cc.

11582 {
11583   static char name[] SET_TO "rs274ngc_read";
11584   int status;
11585   int read_status;
11586 
11587   if (_setup.probe_flag IS ON)
11588     {
11589       CHK((GET_EXTERNAL_QUEUE_EMPTY() IS 0),
11590           NCE_QUEUE_IS_NOT_EMPTY_AFTER_PROBING);
11591       set_probe_data(&_setup);
11592       _setup.probe_flag SET_TO OFF;
11593     }
11594   CHK(((command IS NULL) AND (_setup.file_pointer IS NULL)),
11595       NCE_FILE_NOT_OPEN);
11596   read_status SET_TO read_text(command, _setup.file_pointer, _setup.linetext,
11597                                _setup.blocktext, &_setup.line_length);
11598   if ((read_status IS RS274NGC_EXECUTE_FINISH) OR
11599       (read_status IS RS274NGC_OK))
11600     {
11601       if (_setup.line_length ISNT 0)
11602         {
11603           CHP(parse_line(_setup.blocktext, &(_setup.block1), &_setup));
11604         }
11605     }
11606   else if (read_status IS RS274NGC_ENDFILE);
11607   else
11608     ERP(read_status);
11609   return read_status;
11610 }

int rs274ngc_reset  
 

Definition at line 11643 of file rs274ngc_pre.cc.

11644 {
11645   _setup.linetext[0] SET_TO 0;
11646   _setup.blocktext[0] SET_TO 0;
11647   _setup.line_length SET_TO 0;
11648 
11649   return RS274NGC_OK;
11650 }

int rs274ngc_restore_parameters const char *    filename
 

Definition at line 11689 of file rs274ngc_pre.cc.

Referenced by rs274ngc_init().

11691 {
11692   static char name[] SET_TO "rs274ngc_restore_parameters";
11693   FILE * infile;
11694   char line[256];
11695   int variable;
11696   double value;
11697   int required;    // number of next required parameter
11698   int index;       // index into _required_parameters
11699   double * pars;      // short name for _setup.parameters
11700   int k;
11701 
11702   // open original for reading
11703   infile SET_TO fopen(filename, "r");
11704   CHK((infile IS NULL), NCE_UNABLE_TO_OPEN_FILE);
11705 
11706   pars SET_TO _setup.parameters;
11707   k SET_TO 0;
11708   index SET_TO 0;
11709   required SET_TO _required_parameters[index++];
11710   while (feof(infile) IS 0)
11711     {
11712       if (fgets(line, 256, infile) IS NULL)
11713         {
11714           break;
11715         }
11716 
11717       // try for a variable-value match in the file
11718       if (sscanf(line, "%d %lf", &variable, &value) IS 2)
11719         {
11720           CHK(((variable <= 0) OR (variable >= RS274NGC_MAX_PARAMETERS)),
11721               NCE_PARAMETER_NUMBER_OUT_OF_RANGE);
11722           for (; k < RS274NGC_MAX_PARAMETERS; k++)
11723             {
11724               if (k > variable)
11725                 ERM(NCE_PARAMETER_FILE_OUT_OF_ORDER);
11726               else if (k IS variable)
11727                 {
11728                   pars[k] SET_TO value;
11729                   if (k IS required)
11730                     required SET_TO _required_parameters[index++];
11731                   k++;
11732                   break;
11733                 }
11734               else // if (k < variable)
11735                 {
11736                   if (k IS required)
11737                     ERM(NCE_REQUIRED_PARAMETER_MISSING);
11738                   else
11739                     pars[k] SET_TO 0;
11740                 }
11741             }
11742         }
11743     }
11744   fclose(infile);
11745   CHK((required ISNT RS274NGC_MAX_PARAMETERS), NCE_REQUIRED_PARAMETER_MISSING);
11746   for (; k < RS274NGC_MAX_PARAMETERS; k++)
11747     {
11748       pars[k] SET_TO 0;
11749     }
11750   return RS274NGC_OK;
11751 }

int rs274ngc_save_parameters const char *    filename,
const double    parameters[]
 

Definition at line 11787 of file rs274ngc_pre.cc.

Referenced by rs274ngc_exit().

11790 {
11791   static char name[] SET_TO "rs274ngc_save_parameters";
11792   FILE * infile;
11793   FILE * outfile;
11794   char line[256];
11795   int variable;
11796   double value;
11797   int required;    // number of next required parameter
11798   int index;       // index into _required_parameters
11799   int k;
11800 
11801   // rename as .bak
11802   strcpy(line, filename);
11803   strcat(line, RS274NGC_PARAMETER_FILE_BACKUP_SUFFIX);
11804   CHK((rename(filename, line) ISNT 0), NCE_CANNOT_CREATE_BACKUP_FILE);
11805 
11806   // open backup for reading
11807   infile SET_TO fopen(line, "r");
11808   CHK((infile IS NULL), NCE_CANNOT_OPEN_BACKUP_FILE);
11809 
11810   // open original for writing
11811   outfile SET_TO fopen(filename, "w");
11812   CHK((outfile IS NULL), NCE_CANNOT_OPEN_VARIABLE_FILE);
11813 
11814   k SET_TO 0;
11815   index SET_TO 0;
11816   required SET_TO _required_parameters[index++];
11817   while (feof(infile) IS 0)
11818     {
11819       if (fgets(line, 256, infile) IS NULL)
11820         {
11821           break;
11822         }
11823       // try for a variable-value match
11824       if (sscanf(line, "%d %lf", &variable, &value) IS 2)
11825         {
11826           CHK(((variable <= 0) OR (variable >= RS274NGC_MAX_PARAMETERS)),
11827               NCE_PARAMETER_NUMBER_OUT_OF_RANGE);
11828           for (; k < RS274NGC_MAX_PARAMETERS; k++)
11829             {
11830               if (k > variable)
11831                 ERM(NCE_PARAMETER_FILE_OUT_OF_ORDER);
11832               else if (k IS variable)
11833                 {
11834                   sprintf(line, "%d\t%f\n", k, parameters[k]);
11835                   fputs(line, outfile);
11836                   if (k IS required)
11837                     required SET_TO _required_parameters[index++];
11838                   k++;
11839                   break;
11840                 }
11841               else if (k IS required) // know (k < variable)
11842                 {
11843                   sprintf(line, "%d\t%f\n", k, parameters[k]);
11844                   fputs(line, outfile);
11845                   required SET_TO _required_parameters[index++];
11846                 }
11847             }
11848         }
11849     }
11850   fclose(infile);
11851   for (; k < RS274NGC_MAX_PARAMETERS; k++)
11852     {
11853       if (k IS required)
11854         {
11855           sprintf(line, "%d\t%f\n", k, parameters[k]);
11856           fputs(line, outfile);
11857           required SET_TO _required_parameters[index++];
11858         }
11859     }
11860   fclose(outfile);
11861 
11862   return RS274NGC_OK;
11863 }

int rs274ngc_sequence_number  
 

Definition at line 12127 of file rs274ngc_pre.cc.

12128 {
12129   return _setup.sequence_number;
12130 }

void rs274ngc_stack_name int    stack_index,
char *    function_name,
int    max_size
 

Definition at line 12156 of file rs274ngc_pre.cc.

Referenced by waitFlag().

12158                                    : to copy function name into   */
12159  int max_size)            /* maximum number of characters to copy */
12160 {
12161   int n;
12162   char * the_name;
12163 
12164   if ((stack_index > -1) AND (stack_index < 20))
12165     {
12166       the_name SET_TO _setup.stack[stack_index];
12167       for (n SET_TO 0; n < (max_size - 1); n++)
12168         {
12169           if (the_name[n] ISNT 0)
12170             function_name[n] SET_TO the_name[n];
12171           else
12172             break;
12173         }
12174       function_name[n] SET_TO 0;
12175     }
12176   else
12177     function_name[0] SET_TO 0;
12178 }

int rs274ngc_synch  
 

Definition at line 11884 of file rs274ngc_pre.cc.

11885 {
11886   _setup.control_mode SET_TO GET_EXTERNAL_MOTION_CONTROL_MODE();
11887 #ifdef AA
11888   _setup.AA_current SET_TO GET_EXTERNAL_POSITION_A(); /*AA*/
11889 #endif
11890 #ifdef BB
11891   _setup.BB_current SET_TO GET_EXTERNAL_POSITION_B(); /*BB*/
11892 #endif
11893 #ifdef CC
11894   _setup.CC_current SET_TO GET_EXTERNAL_POSITION_C(); /*CC*/
11895 #endif
11896   _setup.current_slot SET_TO GET_EXTERNAL_TOOL_SLOT();
11897   _setup.current_x SET_TO GET_EXTERNAL_POSITION_X();
11898   _setup.current_y SET_TO GET_EXTERNAL_POSITION_Y();
11899   _setup.current_z SET_TO GET_EXTERNAL_POSITION_Z();
11900   _setup.feed_rate SET_TO GET_EXTERNAL_FEED_RATE();
11901   _setup.flood SET_TO (GET_EXTERNAL_FLOOD() ISNT 0) ? ON : OFF;
11902   _setup.length_units SET_TO GET_EXTERNAL_LENGTH_UNIT_TYPE();
11903   _setup.mist SET_TO (GET_EXTERNAL_MIST() ISNT 0) ? ON : OFF;
11904   _setup.plane SET_TO GET_EXTERNAL_PLANE();
11905   _setup.selected_tool_slot SET_TO GET_EXTERNAL_TOOL_SLOT();
11906   _setup.speed SET_TO GET_EXTERNAL_SPEED();
11907   _setup.spindle_turning SET_TO GET_EXTERNAL_SPINDLE();
11908   _setup.tool_max SET_TO GET_EXTERNAL_TOOL_MAX();
11909   _setup.traverse_rate SET_TO GET_EXTERNAL_TRAVERSE_RATE();
11910 
11911   rs274ngc_load_tool_table(); /*  must set  _setup.tool_max first */
11912 
11913   return RS274NGC_OK;
11914 }

int set_probe_data setup_pointer    settings [static]
 

Definition at line 10933 of file rs274ngc_pre.cc.

Referenced by rs274ngc_execute(), and rs274ngc_read().

10935 {
10936   static char name[] SET_TO "set_probe_data";
10937 
10938   settings->current_x SET_TO GET_EXTERNAL_POSITION_X();
10939   settings->current_y SET_TO GET_EXTERNAL_POSITION_Y();
10940   settings->current_z SET_TO GET_EXTERNAL_POSITION_Z();
10941 #ifdef AA
10942   settings->AA_current SET_TO GET_EXTERNAL_POSITION_A();  /*AA*/
10943 #endif
10944 #ifdef BB
10945   settings->BB_current SET_TO GET_EXTERNAL_POSITION_B();  /*BB*/
10946 #endif
10947 #ifdef CC
10948   settings->CC_current SET_TO GET_EXTERNAL_POSITION_C();  /*CC*/
10949 #endif
10950   settings->parameters[5061] SET_TO GET_EXTERNAL_PROBE_POSITION_X();
10951   settings->parameters[5062] SET_TO GET_EXTERNAL_PROBE_POSITION_Y();
10952   settings->parameters[5063] SET_TO GET_EXTERNAL_PROBE_POSITION_Z();
10953 #ifdef AA
10954   settings->parameters[5064] SET_TO GET_EXTERNAL_PROBE_POSITION_A();  /*AA*/
10955 #endif
10956 #ifdef BB
10957   settings->parameters[5065] SET_TO GET_EXTERNAL_PROBE_POSITION_B();  /*BB*/
10958 #endif
10959 #ifdef CC
10960   settings->parameters[5066] SET_TO GET_EXTERNAL_PROBE_POSITION_C();  /*CC*/
10961 #endif
10962   settings->parameters[5067] SET_TO GET_EXTERNAL_PROBE_VALUE();
10963   return RS274NGC_OK;
10964 }

int write_g_codes block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 11010 of file rs274ngc_pre.cc.

Referenced by rs274ngc_init().

11013 {
11014   int * gez;
11015 
11016   gez SET_TO settings->active_g_codes;
11017   gez[0] SET_TO settings->sequence_number;
11018   gez[1] SET_TO settings->motion_mode;
11019   gez[2] SET_TO ((block IS NULL) ? -1 : block->g_modes[0]);
11020   gez[3] SET_TO
11021     (settings->plane IS CANON_PLANE_XY) ? G_17 :
11022     (settings->plane IS CANON_PLANE_XZ) ? G_18 : G_19;
11023   gez[4] SET_TO
11024     (settings->cutter_comp_side IS RIGHT) ? G_42 :
11025     (settings->cutter_comp_side IS LEFT) ? G_41 : G_40;
11026   gez[5] SET_TO
11027     (settings->length_units IS CANON_UNITS_INCHES) ? G_20 : G_21;
11028   gez[6] SET_TO
11029     (settings->distance_mode IS MODE_ABSOLUTE) ? G_90 : G_91;
11030   gez[7] SET_TO
11031     (settings->feed_mode IS INVERSE_TIME) ? G_93 : G_94;
11032   gez[8] SET_TO
11033     (settings->origin_index < 7) ? (530 + (10 * settings->origin_index)) :
11034                                    (584 + settings->origin_index);
11035   gez[9] SET_TO
11036     (settings->tool_length_offset IS 0.0) ? G_49 : G_43;
11037   gez[10] SET_TO
11038     (settings->retract_mode IS OLD_Z) ? G_98 : G_99;
11039   gez[11] SET_TO
11040     (settings->control_mode IS CANON_CONTINUOUS) ? G_64 :
11041     (settings->control_mode IS CANON_EXACT_PATH) ? G_61 : G_61_1;
11042 
11043   return RS274NGC_OK;
11044 }

int write_m_codes block_pointer    block,
setup_pointer    settings
[static]
 

Definition at line 11064 of file rs274ngc_pre.cc.

Referenced by rs274ngc_init().

11067 {
11068   int * emz;
11069 
11070   emz SET_TO settings->active_m_codes;
11071   emz[0] SET_TO settings->sequence_number;                /* 0 seq number  */
11072   emz[1] SET_TO
11073     (block IS NULL) ? -1 : block->m_modes[4];             /* 1 stopping    */
11074   emz[2] SET_TO
11075     (settings->spindle_turning IS CANON_STOPPED) ? 5 :    /* 2 spindle     */
11076     (settings->spindle_turning IS CANON_CLOCKWISE) ? 3 : 4;
11077   emz[3] SET_TO                                           /* 3 tool change */
11078     (block IS NULL) ? -1 : block->m_modes[6];
11079   emz[4] SET_TO                                           /* 4 mist        */
11080     (settings->mist IS ON) ? 7 :
11081     (settings->flood IS ON) ? -1 : 9;
11082   emz[5] SET_TO                                           /* 5 flood       */
11083     (settings->flood IS ON) ? 8 : -1;
11084   emz[6] SET_TO                                           /* 6 overrides   */
11085     (settings->feed_override IS ON) ? 48 : 49;
11086 
11087   return RS274NGC_OK;
11088 }

int write_settings setup_pointer    settings [static]
 

Definition at line 11106 of file rs274ngc_pre.cc.

Referenced by rs274ngc_init().

11108 {
11109   double * vals;
11110 
11111   vals SET_TO settings->active_settings;
11112   vals[0] SET_TO settings->sequence_number; /* 0 sequence number */
11113   vals[1] SET_TO settings->feed_rate;       /* 1 feed rate       */
11114   vals[2] SET_TO settings->speed;           /* 2 spindle speed   */
11115 
11116   return RS274NGC_OK;
11117 }


Variable Documentation

setup _setup [static]
 

Definition at line 800 of file rs274ngc_pre.cc.


Generated on Sun Dec 2 15:28:24 2001 for EMC by doxygen1.2.11.1 written by Dimitri van Heesch,  1997-2001