---

rs274ngc.cc File Reference

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <ctype.h>
#include "canon.hh"
#include "rs274ngc.hh"
#include "inifile.h"

Include dependency graph for rs274ngc.cc:

Go to the source code of this file.

Defines
#define	DEBUG_EMC
#define	G83_RAPID_DELTA   0.010
#define	CYCLE_MACRO(call)
Typedefs
typedef int(*	_function_pointer )(char *, int *, block_pointer, double *)
Functions
int	read_real_value (char *line, int *counter, double *double_ptr, double *parameters)
int	read_real_expression (char *line, int *counter, double *hold2, double *parameters)
int	utility_error_number (char *message, char *error_array[], int index)
int	execute_binary1 (double *left, int operation, double *right)
int	execute_binary2 (double *left, int operation, double *right)
int	execute_unary (double *double_ptr, int operation)
int	read_atan (char *line, int *counter, double *double_ptr, double *parameters)
int	read_integer_value (char *line, int *counter, int *integer_ptr, double *parameters)
int	read_operation (char *line, int *counter, int *operation)
int	read_operation_unary (char *line, int *counter, int *operation)
double	utility_find_turn (double x1, double y1, double center_x, double center_y, int turn, double x2, double y2)
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	read_parameter (char *line, int *counter, double *double_ptr, double *parameters)
int	read_real_number (char *line, int *counter, double *double_ptr)
int	read_unary (char *line, int *counter, double *double_ptr, double *parameters)
double	utility_find_arc_length (double x1, double y1, double z1, double center_x, double center_y, int turn, double x2, double y2, double z2)
double	utility_find_straight_length (double x2, double y2, double z2, double x1, double y1, double z1)
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_arc_xy (int move, block_pointer block, setup_pointer settings, double end_x, double end_y, double end_z)
int	convert_arc_yz (int move, block_pointer block, setup_pointer settings, double end_y, double end_z, double end_x)
int	convert_arc_zx (int move, block_pointer block, setup_pointer settings, double end_z, double end_x, double end_y)
int	convert_cycle_g81 (double x, double y, double clear_z, double bottom_z)
int	convert_cycle_g82 (double x, double y, double clear_z, double bottom_z, double dwell)
int	convert_cycle_g83 (double x, double y, double r, double clear_z, double bottom_z, double delta)
int	convert_cycle_g84 (double x, double y, double clear_z, double bottom_z, CANON_DIRECTION direction, CANON_SPEED_FEED_MODE mode)
int	convert_cycle_g85 (double x, double y, double clear_z, double bottom_z)
int	convert_cycle_g86 (double x, double y, double clear_z, double bottom_z, double dwell, CANON_DIRECTION direction)
int	convert_cycle_g87 (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 (double x, double y, double bottom_z, double dwell, CANON_DIRECTION direction)
int	convert_cycle_g89 (double x, double y, double clear_z, double bottom_z, double dwell)
int	convert_straight_comp1 (setup_pointer settings, double px, double py, double end_z)
int	convert_straight_comp2 (setup_pointer settings, double program_end_x, double program_end_y, double end_z)
int	read_integer_unsigned (char *line, int *counter, int *integer_ptr)
int	utility_find_ends (block_pointer block, setup_pointer settings, double *px, double *py, double *pz)
int	convert_arc (int move, block_pointer block, setup_pointer settings)
int	convert_axis_offsets (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_probe (block_pointer block, setup_pointer settings)
int	convert_setup (block_pointer block, setup_pointer settings)
int	convert_straight (int move, block_pointer block, setup_pointer settings)
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_i (char *line, int *counter, block_pointer block, 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_m (char *line, int *counter, block_pointer block, double *parameters)
int	read_p (char *line, int *counter, block_pointer block, 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_spindle_speed (char *line, int *counter, block_pointer block, double *parameters)
int	read_tool (char *line, int *counter, block_pointer block, double *parameters)
int	read_tool_length_offset (char *line, int *counter, block_pointer block, 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	check_g_codes (block_pointer block, setup_pointer settings)
int	check_m_codes (block_pointer block, setup_pointer settings)
int	check_other_codes (block_pointer block, setup_pointer settings)
int	convert_control_mode (int g_code, block_pointer block, setup_pointer settings)
int	convert_coordinate_system (int g_code, block_pointer block, setup_pointer settings)
int	convert_cutter_compensation (int g_code, block_pointer block, setup_pointer settings)
int	convert_distance_mode (int g_code, block_pointer block, setup_pointer settings)
int	convert_dwell (double time)
int	convert_length_units (int g_code, 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_retract_mode (int g_code, block_pointer block, setup_pointer settings)
int	convert_set_plane (int g_code, block_pointer block, setup_pointer settings)
int	convert_tool_change (block_pointer block, setup_pointer settings)
int	convert_tool_length_offset (int g_code, block_pointer block, setup_pointer settings)
int	read_line_number (char *line, int *counter, block_pointer block)
int	read_one_item (char *line, int *counter, block_pointer block, double *parameters)
int	check_items (block_pointer block, setup_pointer settings)
int	close_and_downcase (char *line)
int	convert_comment (char *comment)
int	convert_feed_mode (int g_code, block_pointer block, setup_pointer settings)
int	convert_feed_rate (block_pointer block, setup_pointer settings)
int	convert_g (block_pointer block, setup_pointer settings)
int	convert_m (block_pointer block, setup_pointer settings)
int	convert_speed (block_pointer block, setup_pointer settings)
int	convert_stop (block_pointer block, setup_pointer settings)
int	convert_tool_select (block_pointer block, setup_pointer settings)
int	init_block (block_pointer block)
int	read_items (block_pointer block, char *line, double *parameters)
int	utility_enhance_block (block_pointer block, setup_pointer settings)
int	write_g_codes (block_pointer block, setup_pointer settings, int line_number, int *gez)
int	write_m_codes (block_pointer block, setup_pointer settings, int line_number, int *ems)
int	write_settings (block_pointer block, setup_pointer settings, int line_number, double *vals)
int	execute_block (block_pointer block, setup_pointer settings, int line_number)
int	read_line (char *line, block_pointer block, setup_pointer settings)
int	read_text (const char *command, FILE *inport, char *raw_line, char *line, int *length, ON_OFF block_delete)
int	set_probe_data (setup_pointer settings)
int	rs274ngc_reset ()
const char *	rs274ngc_command ()
const char *	rs274ngc_file ()
int	rs274ngc_line ()
int	rs274ngc_close ()
int	rs274ngc_execute (const char *command)
int	rs274ngc_exit ()
int	rs274ngc_synch ()
int	rs274ngc_init ()
int	rs274ngc_open (const char *filename)
int	rs274ngc_read ()
int	rs274ngc_load_tool_table ()
int	rs274ngc_restore_parameters (const char *filename, double parameters[])
	restore interpreter variables from file. More...
int	rs274ngc_save_parameters (const char *filename, const double parameters[])
	save interpreter variables to file. More...
int	rs274ngc_ini_load (const char *filename)
	load settings from INI file. More...
int	rs274ngc_active_g_codes (int *codes)
int	rs274ngc_active_m_codes (int *codes)
int	rs274ngc_active_settings (double *settings)
Variables
char	ident [] = "$Id: rs274ngc.cc,v 1.4 2000/10/27 20:34:44 terrylr Exp $"
setup	_interpreter_settings
int _textline	SET_TO
char	_interpreter_filename [INTERP_TEXT_SIZE]
char	_interpreter_linetext [INTERP_TEXT_SIZE]
char	_interpreter_blocktext [INTERP_TEXT_SIZE]
FILE *_interpreter_fp SET_TO	NULL
int	_interpreter_active_g_codes [RS274NGC_ACTIVE_G_CODES]
int	_interpreter_active_m_codes [RS274NGC_ACTIVE_M_CODES]
double	_interpreter_active_settings [RS274NGC_ACTIVE_SETTINGS]
char	RS274NGC_PARAMETER_FILE [INTERP_TEXT_SIZE]

---

Define Documentation

#define CYCLE_MACRO (  call    )

Value: for (repeat SET_TO block->l_number; \ repeat > 0; \ repeat--) \ { \ x SET_TO (x + x_increment); \ y SET_TO (y + y_increment); \ STRAIGHT_TRAVERSE(x, y, old_z); \ if (old_z ISNT r) \ STRAIGHT_TRAVERSE(x, y, r); \ if (call IS RS274NGC_ERROR) \ ERROR_MACRO_PASS(name); \ old_z SET_TO clear_z; \ } Definition at line 3895 of file rs274ngc.cc.

#define DEBUG_EMC

Definition at line 110 of file rs274ngc.cc.

#define G83_RAPID_DELTA   0.010

Definition at line 2721 of file rs274ngc.cc.

---

Typedef Documentation

typedef int(* _function_pointer)(char *, int *, block_pointer, double *)

Definition at line 6632 of file rs274ngc.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 )

Definition at line 1218 of file rs274ngc.cc. { static char name[] SET_TO "arc_data_comp_ijk"; double arc_radius; double radius2; *center_x SET_TO (current_x + i_number); *center_y SET_TO (current_y + j_number); arc_radius SET_TO hypot((*center_x - current_x), (*center_y - current_y)); radius2 SET_TO hypot((*center_x - end_x), (*center_y - end_y)); radius2 SET_TO (((side IS LEFT ) AND (move IS 30)) OR ((side IS RIGHT) AND (move IS 20))) ? (radius2 - tool_radius): (radius2 + tool_radius); if (fabs(arc_radius - radius2) > tolerance) ERROR_MACRO(_interpreter_linetext, name, "Radius to end of arc differs from radius to start of arc"); /* This catches an arc too small for the tool, also */ if (move IS G_2) *turn SET_TO -1; else if (move IS G_3) *turn SET_TO 1; else BUG_MACRO(name, "Code is not G2 or G3 in arc_data_comp"); return RS274NGC_OK; }

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 )

Definition at line 1298 of file rs274ngc.cc. { static char name[] SET_TO "arc_data_comp_r"; double abs_radius; /* absolute value of big_radius */ double radius2; /* distance from center to current point */ double distance; /* length of line L from current to end */ double mid_length; /* length from current point to point P */ double offset; /* length of line from P to center */ double alpha; /* direction of line from current to end */ double theta; /* direction of line from P to center */ double mid_x; /* x-value of point P */ double mid_y; /* y-value of point P */ if ((end_x IS current_x) AND (end_y IS current_y)) ERROR_MACRO(_interpreter_linetext, name, "Current point same as end point of arc"); abs_radius SET_TO fabs(big_radius); if ((abs_radius < tool_radius) AND (((side IS LEFT ) AND (move IS G_3)) OR ((side IS RIGHT) AND (move IS G_2)))) ERROR_MACRO(_interpreter_linetext, name, "Tool radius not less than arc radius with cutter radius comp"); distance SET_TO hypot((end_x - current_x), (end_y - current_y)); alpha SET_TO atan2 ((end_y - current_y), (end_x - current_x)); theta SET_TO (((move IS G_3) AND (big_radius > 0)) OR ((move IS G_2) AND (big_radius < 0))) ? (alpha + PI2) : (alpha - PI2); radius2 SET_TO (((side IS LEFT ) AND (move IS G_3)) OR ((side IS RIGHT) AND (move IS G_2))) ? (abs_radius - tool_radius) : (abs_radius + tool_radius); if (distance > (radius2 + abs_radius)) ERROR_MACRO(_interpreter_linetext, name, "Radius too small to reach end point"); mid_length SET_TO (((radius2 * radius2) + (distance * distance) - (abs_radius * abs_radius)) / (2.0 * distance)); mid_x SET_TO (current_x + (mid_length * cos(alpha))); mid_y SET_TO (current_y + (mid_length * sin(alpha))); offset SET_TO sqrt((radius2 * radius2) - (mid_length * mid_length)); *center_x SET_TO mid_x + (offset * cos(theta)); *center_y SET_TO mid_y + (offset * sin(theta)); *turn SET_TO (move IS G_2) ? -1 : 1; return RS274NGC_OK; }

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 )

Definition at line 1380 of file rs274ngc.cc. { static char name[] SET_TO "arc_data_ijk"; double radius; /* radius to current point */ double radius2; /* radius to end point */ *center_x SET_TO (current_x + i_number); *center_y SET_TO (current_y + j_number); radius SET_TO hypot((*center_x - current_x), (*center_y - current_y)); radius2 SET_TO hypot((*center_x - end_x), (*center_y - end_y)); if (fabs(radius - radius2) > tolerance) ERROR_MACRO(_interpreter_linetext, name, "Radius to end of arc differs from radius to start of arc"); if (move IS G_2) *turn SET_TO -1; else if (move IS G_3) *turn SET_TO 1; else BUG_MACRO(name, "Code is not G2 or G3 in arc_data_ijk"); return RS274NGC_OK; }

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 )

Definition at line 1447 of file rs274ngc.cc. { static char name[] SET_TO "arc_data_r"; double abs_radius; /* absolute value of given radius */ double half_length; double turn2; /* absolute value of half of turn */ double offset; /* distance from M to center */ double theta; /* angle of line from M to center */ double mid_x; /* first coordinate of M */ double mid_y; /* second coordinate of M */ if ((end_x IS current_x) AND (end_y IS current_y)) ERROR_MACRO(_interpreter_linetext, name, "Current point same as end point of arc"); abs_radius SET_TO fabs(radius); mid_x SET_TO (end_x + current_x)/2.0; mid_y SET_TO (end_y + current_y)/2.0; half_length SET_TO hypot((mid_x - end_x), (mid_y - end_y)); if ((half_length/abs_radius) > (1+TINY)) ERROR_MACRO(_interpreter_linetext, name, "Arc radius too small to reach end point"); else if ((half_length/abs_radius) > (1-TINY)) half_length SET_TO abs_radius; /* allow a small error for semicircle */ /* check needed before calling asin */ if (((move IS G_2) AND (radius > 0)) OR ((move IS G_3) AND (radius < 0))) theta SET_TO atan2((end_y - current_y), (end_x - current_x)) - PI2; else theta SET_TO atan2((end_y - current_y), (end_x - current_x)) + PI2; turn2 SET_TO asin (half_length/abs_radius); offset SET_TO abs_radius * cos(turn2); *center_x SET_TO mid_x + (offset * cos(theta)); *center_y SET_TO mid_y + (offset * sin(theta)); *turn SET_TO (move IS G_2) ? -1 : 1; return RS274NGC_OK; }

int check_g_codes (  block_pointer    block, setup_pointer    settings )

Definition at line 5541 of file rs274ngc.cc. { static char name[] SET_TO "check_g_codes"; ON_OFF axis_flag; int explicit_motion; int mode0; int p_int; axis_flag SET_TO ((block->x_flag) OR (block->y_flag) OR (block->z_flag)) ? ON : OFF; explicit_motion SET_TO block->g_modes[1]; mode0 SET_TO block->g_modes[0]; if(block->g_count > MAX_GEES) ERROR_MACRO(_interpreter_linetext, name, "Too many G codes on line"); if (mode0 IS -1) { if (block->g_modes[4] IS -1) { if ((block->motion_to_be IS G_80) AND (axis_flag IS ON)) ERROR_MACRO(_interpreter_linetext, name, "Cannot use axis commands with G80"); } else if (block->g_modes[4] IS G_4) { if (((block->motion_to_be IS -1) OR (block->motion_to_be IS G_80)) AND (axis_flag IS ON)) ERROR_MACRO(_interpreter_linetext, name, "Cannot use axis commands with G4"); if(block->p_number IS -1.0) ERROR_MACRO(_interpreter_linetext, name, "Dwell time missing with G4"); } else if (block->g_modes[4] IS G_53) { if ((block->motion_to_be ISNT G_0) AND (block->motion_to_be ISNT G_1)) ERROR_MACRO(_interpreter_linetext, name, "Must use G0 or G1 with G53"); if((block->g_modes[3] IS G_91) OR ((block->g_modes[3] ISNT G_90) AND (settings->distance_mode IS MODE_INCREMENTAL))) ERROR_MACRO(_interpreter_linetext, name, "Cannot use G53 in incremental distance mode"); } else BUG_MACRO(name, "Bad setting of g_mode in check_g_codes"); } else if (block->g_modes[4] ISNT -1) ERROR_MACRO(_interpreter_linetext, name, "Cannot use two G codes from group 0"); else if (mode0 IS G_10) { p_int SET_TO (int)(block->p_number + 0.0001); if ((explicit_motion ISNT -1) AND (explicit_motion ISNT G_80)) ERROR_MACRO(_interpreter_linetext, name, "Cannot use a G code for motion with G10"); if (block->l_number ISNT 2) ERROR_MACRO(_interpreter_linetext, name, "Line with G10 does not have L2"); if (((block->p_number + 0.0001) - p_int) > 0.0002) ERROR_MACRO(_interpreter_linetext, name, "P value not an integer with G10 L2"); if ((p_int < 1) OR (p_int > 9)) ERROR_MACRO(_interpreter_linetext, name, "P value out of range with G10 L2"); } else if (mode0 IS G_92) { if ((explicit_motion ISNT -1) AND (explicit_motion ISNT G_80)) ERROR_MACRO(_interpreter_linetext, name, "Cannot use a G motion with G92"); if (axis_flag IS OFF) ERROR_MACRO(_interpreter_linetext, name, "All axes missing with G92"); } else if (mode0 IS G_92_2) {} else BUG_MACRO(name, "Bad setting of g_mode in check_g_codes"); return RS274NGC_OK; }

int check_items (  block_pointer    block, setup_pointer    settings )

Definition at line 6742 of file rs274ngc.cc. { static char name[] SET_TO "check_items"; if (check_g_codes(block, settings) ISNT RS274NGC_OK) ERROR_MACRO_PASS(name); if (check_m_codes(block, settings) ISNT RS274NGC_OK) ERROR_MACRO_PASS(name); if (check_other_codes(block, settings) ISNT RS274NGC_OK) ERROR_MACRO_PASS(name); if ((block->m_modes[4] ISNT -1) AND (block->g_modes[1] IS G_38_2)) ERROR_MACRO(_interpreter_linetext, name, "Cannot put an M code for stopping with G38.2"); return RS274NGC_OK; }

int check_m_codes (  block_pointer    block, setup_pointer    settings )

Definition at line 5637 of file rs274ngc.cc. { static char name[] SET_TO "check_m_codes"; if(block->m_count > MAX_EMS) ERROR_MACRO(_interpreter_linetext, name, "Too many M codes on line"); return RS274NGC_OK; }

int check_other_codes (  block_pointer    block, setup_pointer    settings )

Definition at line 5678 of file rs274ngc.cc. { static char name[] SET_TO "check_other_codes"; int motion; motion SET_TO block->motion_to_be; if (block->d_number ISNT -1) { if ((block->g_modes[7] ISNT G_41) AND (block->g_modes[7] ISNT G_42)) ERROR_MACRO(_interpreter_linetext, name, "D word on line with no cutter comp on (G41 or G42) command"); } if (block->h_number ISNT -1) { if (block->g_modes[8] ISNT G_43) ERROR_MACRO(_interpreter_linetext, name, "H word on line with no tool length comp (G43) command"); } if (block->i_flag IS ON) /* could still be useless if yz_plane arc */ { if (((motion ISNT G_2) AND (motion ISNT G_3)) AND (motion ISNT G_87)) ERROR_MACRO(_interpreter_linetext, name, "I word on line with no G code (G2, G3, G87) that uses it"); } if (block->j_flag IS ON) /* could still be useless if xz_plane arc */ { if (((motion ISNT G_2) AND (motion ISNT G_3)) AND (motion ISNT G_87)) ERROR_MACRO(_interpreter_linetext, name, "J word on line with no G code (G2, G3, G87) that uses it"); } if (block->k_flag IS ON) /* could still be useless if xy_plane arc */ { if (((motion ISNT G_2) AND (motion ISNT G_3)) AND (motion ISNT G_87)) ERROR_MACRO(_interpreter_linetext, name, "K word on line with no G code (G2, G3, G87) that uses it"); } if (block->l_number ISNT -1) { if (((motion < G_81) OR (motion > G_89)) AND (block->g_modes[0] ISNT G_10)) ERROR_MACRO(_interpreter_linetext, name, "L word on line with no canned cycle or G10 to use it"); } if (block->p_number ISNT -1.0) { if (((block->g_modes[0] ISNT G_10) AND (block->g_modes[4] ISNT G_4)) AND (((motion ISNT G_82) AND (motion ISNT G_86)) AND ((motion ISNT G_88) AND (motion ISNT G_89)))) ERROR_MACRO(_interpreter_linetext, name, "P word on line with no G code (G4 G10 G82 G86 G88 G89) that uses it"); } if (block->q_number ISNT -1.0) { if (motion ISNT G_83) ERROR_MACRO(_interpreter_linetext, name, "Q word on line with no G83 cycle that uses it"); } if (block->r_flag IS ON) { if (((motion ISNT G_2) AND (motion ISNT G_3)) AND ((motion < G_81) OR (motion > G_89))) ERROR_MACRO(_interpreter_linetext, name, "R word on line with no G code (arc or cycle) that uses it"); } return RS274NGC_OK; }

int close_and_downcase (  char *    line )

Definition at line 6800 of file rs274ngc.cc. : one line of NC code */ { static char name[] SET_TO "close_and_downcase"; int m; int n; int comment; char item; comment SET_TO 0; for (n SET_TO 0, m SET_TO 0; (item SET_TO line[m]) ISNT (char) NULL; m++) { if (comment) { line[n++] SET_TO item; if (item IS ')') { comment SET_TO 0; } else if (item IS '(') ERROR_MACRO(_interpreter_linetext, name, "Nested comment found"); } else if ((item IS ' ') OR (item IS '\t') OR (item IS '\r')); /* don't copy blank or tab or CR */ else if (item IS '\n') /* don't copy newline */ { /* but check null follows */ if (line[m+1] ISNT 0) ERROR_MACRO(_interpreter_linetext, name, "Null missing after newline"); } else if ((64 < item) AND (item < 91)) /* downcase upper case letters */ { line[n++] SET_TO (32 + item); } else if (item IS '(') /* comment is starting */ { comment SET_TO 1; line[n++] SET_TO item; } else { line[n++] SET_TO item; /* copy anything else */ } } if (m IS (INTERP_TEXT_SIZE - 1)) /* line was too long */ ERROR_MACRO(_interpreter_linetext, name, "Command too long"); else if (comment) ERROR_MACRO(_interpreter_linetext, name, "Unclosed comment found"); line[n] SET_TO 0; return RS274NGC_OK; }

int convert_arc (  int    move, block_pointer    block, setup_pointer    settings )

Definition at line 3508 of file rs274ngc.cc. { static char name[] SET_TO "convert_arc"; int status; DISTANCE_MODE mode; int first; int ijk_flag; double end_x; double end_y; double end_z; mode SET_TO settings->distance_mode; ijk_flag SET_TO ((block->i_flag OR block->j_flag) OR block->k_flag) ? ON : OFF; first SET_TO (settings->program_x IS UNKNOWN); if ((block->r_flag ISNT ON) AND (ijk_flag ISNT ON)) ERROR_MACRO(_interpreter_linetext, name, "R, I, J, and K words all missing for arc"); else if ((block->r_flag IS ON) AND (ijk_flag IS ON)) ERROR_MACRO(_interpreter_linetext, name, "Mixed radius-ijk format for arc"); else if (settings->feed_rate IS 0.0) ERROR_MACRO(_interpreter_linetext, name, "Cannot make arc with zero feed rate"); else if (ijk_flag) { if (settings->plane IS CANON_PLANE_XY) { if (block->k_flag) ERROR_MACRO(_interpreter_linetext, name, "K word given for arc in XY-plane"); else if (block->i_flag IS OFF) /* i or j flag on to get here */ block->i_number SET_TO 0.0; else if (block->j_flag IS OFF) block->j_number SET_TO 0.0; } else if (settings->plane IS CANON_PLANE_YZ) { if (block->i_flag) ERROR_MACRO(_interpreter_linetext, name, "I word given for arc in YZ-plane"); else if (block->j_flag IS OFF) /* j or k flag on to get here */ block->j_number SET_TO 0.0; else if (block->k_flag IS OFF) block->k_number SET_TO 0.0; } else if (settings->plane IS CANON_PLANE_XZ) { if (block->j_flag) ERROR_MACRO(_interpreter_linetext, name, "J word given for arc in XZ-plane"); else if (block->i_flag IS OFF) /* i or k flag on to get here */ block->i_number SET_TO 0.0; else if (block->k_flag IS OFF) block->k_number SET_TO 0.0; } else BUG_MACRO(name, "Plane is not XY, YZ, or XZ in convert_arc"); } else; /* r format arc; no other checks needed specific to this format */ if (settings->plane IS CANON_PLANE_XY) /* checks for both formats */ { if ((block->x_flag IS OFF) AND (block->y_flag IS OFF)) ERROR_MACRO(_interpreter_linetext, name, "X and Y words missing for arc in XY-plane"); } else if (settings->plane IS CANON_PLANE_YZ) { if ((block->y_flag IS OFF) AND (block->z_flag IS OFF)) ERROR_MACRO(_interpreter_linetext, name, "Y and Z words missing for arc in YZ-plane"); } else if (settings->plane IS CANON_PLANE_XZ) { if ((block->x_flag IS OFF) AND (block->z_flag IS OFF)) ERROR_MACRO(_interpreter_linetext, name, "X and Z words missing for arc in XZ-plane"); } utility_find_ends(block, settings, &end_x, &end_y, &end_z); settings->motion_mode SET_TO move; if (settings->plane IS CANON_PLANE_XY) { if (settings->cutter_radius_compensation IS OFF) status SET_TO convert_arc_xy(move, block, settings, end_x, end_y, end_z); else if (settings->feed_mode IS INVERSE_TIME) ERROR_MACRO(_interpreter_linetext, name, "Cannot use inverse time feed with cutter radius comp"); else if (first) status SET_TO convert_arc_comp1 (move, block, settings, end_x, end_y, end_z); else status SET_TO convert_arc_comp2 (move, block, settings, end_x, end_y, end_z); } else if (settings->plane IS CANON_PLANE_XZ) status SET_TO convert_arc_zx (move, block, settings, end_z, end_x, end_y); else if (settings->plane IS CANON_PLANE_YZ) status SET_TO convert_arc_yz (move, block, settings, end_y, end_z, end_x); else BUG_MACRO(name, "Plane is not XY, YZ, or XZ in convert_arc"); if (status ISNT RS274NGC_OK) ERROR_MACRO_PASS(name); else return RS274NGC_OK; }

int convert_arc_comp1 (  int    move, block_pointer    block, setup_pointer    settings, double    end_x, double    end_y, double    end_z )

Definition at line 2198 of file rs274ngc.cc. { static char name[] SET_TO "convert_arc_comp1"; double center_x; double center_y; int turn; /* 1 for counterclockwise, -1 for clockwise */ double gamma; /* direction of perpendicular to arc at end */ double tolerance; double tool_radius; int side; int status; side SET_TO settings->cutter_radius_compensation; tool_radius SET_TO (settings->tool_table[settings->tool_table_index].diameter)/2.0; if (tool_radius <= 0.0) ERROR_MACRO(_interpreter_linetext, name, "Bad tool radius value with cutter radius comp"); tolerance SET_TO (settings->length_units IS CANON_UNITS_INCHES) ? TOLERANCE_INCH : TOLERANCE_MM; if (block->r_flag) { status SET_TO arc_data_comp_r(move, side, tool_radius, settings->current_x, settings->current_y, end_x, end_y, block->r_number, &center_x, &center_y, &turn); } else { status SET_TO arc_data_comp_ijk(move, side, tool_radius, settings->current_x, settings->current_y, end_x, end_y, block->i_number, block->j_number, &center_x, &center_y, &turn, tolerance); } if (status IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); gamma SET_TO (((side IS LEFT) AND (move IS G_3)) OR ((side IS RIGHT) AND (move IS G_2))) ? atan2 ((center_y - end_y), (center_x - end_x)) : atan2 ((end_y - center_y), (end_x - center_x)); settings->program_x SET_TO end_x; settings->program_y SET_TO end_y; end_x SET_TO (end_x + (tool_radius * cos(gamma))); end_y SET_TO (end_y + (tool_radius * sin(gamma))); ARC_FEED(end_x, end_y, center_x, center_y, turn, end_z); settings->current_x SET_TO end_x; settings->current_y SET_TO end_y; settings->current_z SET_TO end_z; return RS274NGC_OK; }

int convert_arc_comp2 (  int    move, block_pointer    block, setup_pointer    settings, double    end_x, double    end_y, double    end_z )

Definition at line 2292 of file rs274ngc.cc. { static char name[] SET_TO "convert_arc_comp2"; double center_x; /* center of arc */ double center_y; double start_x; double start_y; int turn; /* number of full or partial circles CCW */ double theta; /* direction of tangent to last cut */ double delta; /* direction of radius from start of arc to center of arc */ double alpha; /* direction of tangent to start of arc */ double beta; /* angle between two tangents above */ double gamma; /* direction of perpendicular to arc at end */ double arc_radius; double tool_radius; /* small angle in radians for testing corners */ double small SET_TO TOLERANCE_CONCAVE_CORNER; int side; int status; double tolerance; /* find basic arc data: center_x, center_y, and turn */ start_x SET_TO settings->program_x; start_y SET_TO settings->program_y; tolerance SET_TO (settings->length_units IS CANON_UNITS_INCHES) ? TOLERANCE_INCH : TOLERANCE_MM; if (block->r_flag) { status SET_TO arc_data_r(move, start_x, start_y, end_x, end_y, block->r_number, &center_x, &center_y, &turn); } else { status SET_TO arc_data_ijk(move, start_x, start_y, end_x, end_y, block->i_number, block->j_number, &center_x, &center_y, &turn, tolerance); } if (status IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); /* compute other data */ side SET_TO settings->cutter_radius_compensation; tool_radius SET_TO (settings->tool_table[settings->tool_table_index].diameter)/2.0; if (tool_radius <= 0.0) ERROR_MACRO(_interpreter_linetext, name, "Bad tool radius value with cutter radius comp"); arc_radius SET_TO hypot((center_x - end_x), (center_y - end_y)); theta SET_TO atan2(settings->current_y - start_y, settings->current_x - start_x); theta SET_TO (side IS LEFT) ? (theta - PI2) : (theta + PI2); delta SET_TO atan2(center_y - start_y, center_x - start_x); alpha SET_TO (move IS G_3) ? (delta - PI2) : (delta + PI2); beta SET_TO (side IS LEFT) ? (theta - alpha) : (alpha - theta); beta SET_TO (beta > (1.5 * PI)) ? (beta - TWO_PI) : (beta < -PI2) ? (beta + TWO_PI) : beta; if (((side IS LEFT) AND (move IS G_3)) OR ((side IS RIGHT) AND (move IS G_2))) { gamma SET_TO atan2 ((center_y - end_y), (center_x - end_x)); if (arc_radius <= tool_radius) ERROR_MACRO(_interpreter_linetext, name, "Tool radius not less than arc radius with cutter radius comp"); } else { gamma SET_TO atan2 ((end_y - center_y), (end_x - center_x)); delta SET_TO (delta + PI); } settings->program_x SET_TO end_x; settings->program_y SET_TO end_y; /* check if extra arc needed and insert if so */ if ((beta < -small) OR (beta > (PI + small))) ERROR_MACRO(_interpreter_linetext, name, "Concave corner with cutter radius comp"); else if (beta > small) /* TWO ARCS NEEDED */ ARC_FEED((start_x + (tool_radius * cos(delta))), (start_y + (tool_radius * sin(delta))), start_x, start_y, (side IS LEFT) ? -1 : 1, settings->current_z); end_x SET_TO (end_x + (tool_radius * cos(gamma))); /* end_x reset actual */ end_y SET_TO (end_y + (tool_radius * sin(gamma))); /* end_y reset actual */ /* insert main arc */ ARC_FEED(end_x, end_y, center_x, center_y, turn, end_z); settings->current_x SET_TO end_x; settings->current_y SET_TO end_y; settings->current_z SET_TO end_z; return RS274NGC_OK; }

int convert_arc_xy (  int    move, block_pointer    block, setup_pointer    settings, double    end_x, double    end_y, double    end_z )

Definition at line 2418 of file rs274ngc.cc. { static char name[] SET_TO "convert_arc_xy"; double center_x; double center_y; double length; double rate; int turn; int status; double tolerance; tolerance SET_TO (settings->length_units IS CANON_UNITS_INCHES) ? TOLERANCE_INCH : TOLERANCE_MM; if (block->r_flag) { status SET_TO arc_data_r(move, settings->current_x, settings->current_y, end_x, end_y, block->r_number, &center_x, &center_y, &turn); } else { status SET_TO arc_data_ijk(move, settings->current_x, settings->current_y, end_x, end_y, block->i_number, block->j_number, &center_x, &center_y, &turn, tolerance); } if (status IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); if (settings->feed_mode IS INVERSE_TIME) { length SET_TO utility_find_arc_length (settings->current_x, settings->current_y, settings->current_z, center_x, center_y, turn, end_x, end_y, end_z); rate SET_TO MAX(0.1, (length * block->f_number)); SET_FEED_RATE (rate); settings->feed_rate SET_TO rate; } ARC_FEED(end_x, end_y, center_x, center_y, turn, end_z); settings->current_x SET_TO end_x; settings->current_y SET_TO end_y; settings->current_z SET_TO end_z; return RS274NGC_OK; }

int convert_arc_yz (  int    move, block_pointer    block, setup_pointer    settings, double    end_y, double    end_z, double    end_x )

Definition at line 2492 of file rs274ngc.cc. { static char name[] SET_TO "convert_arc_yz"; double center_y; double center_z; double length; double rate; int turn; int status; double tolerance; tolerance SET_TO (settings->length_units IS CANON_UNITS_INCHES) ? TOLERANCE_INCH : TOLERANCE_MM; if (block->r_flag) { status SET_TO arc_data_r(move, settings->current_y, settings->current_z, end_y, end_z, block->r_number, &center_y, &center_z, &turn); } else { status SET_TO arc_data_ijk(move, settings->current_y, settings->current_z, end_y, end_z, block->j_number, block->k_number, &center_y, &center_z, &turn, tolerance); } if (status IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); if (settings->feed_mode IS INVERSE_TIME) { length SET_TO utility_find_arc_length (settings->current_y, settings->current_z, settings->current_x, center_y, center_z, turn, end_y, end_z, end_x); rate SET_TO MAX(0.1, (length * block->f_number)); SET_FEED_RATE (rate); settings->feed_rate SET_TO rate; } ARC_FEED(end_y, end_z, center_y, center_z, turn, end_x); settings->current_y SET_TO end_y; settings->current_z SET_TO end_z; settings->current_x SET_TO end_x; return RS274NGC_OK; }

int convert_arc_zx (  int    move, block_pointer    block, setup_pointer    settings, double    end_z, double    end_x, double    end_y )

Definition at line 2567 of file rs274ngc.cc. { static char name[] SET_TO "convert_arc_zx"; double center_z; double center_x; double length; double rate; int turn; int status; double tolerance; tolerance SET_TO (settings->length_units IS CANON_UNITS_INCHES) ? TOLERANCE_INCH : TOLERANCE_MM; if (block->r_flag) { status SET_TO arc_data_r(move, settings->current_z, settings->current_x, end_z, end_x, block->r_number, &center_z, &center_x, &turn); } else { status SET_TO arc_data_ijk(move, settings->current_z, settings->current_x, end_z, end_x, block->k_number, block->i_number, &center_z, &center_x, &turn, tolerance); } if (status IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); if (settings->feed_mode IS INVERSE_TIME) { length SET_TO utility_find_arc_length (settings->current_z, settings->current_x, settings->current_y, center_z, center_x, turn, end_z, end_x, end_y); rate SET_TO MAX(0.1, (length * block->f_number)); SET_FEED_RATE (rate); settings->feed_rate SET_TO rate; } ARC_FEED(end_z, end_x, center_z, center_x, turn, end_y); settings->current_z SET_TO end_z; settings->current_x SET_TO end_x; settings->current_y SET_TO end_y; return RS274NGC_OK; }

int convert_axis_offsets (  int    g_code, block_pointer    block, setup_pointer    settings )

Definition at line 3663 of file rs274ngc.cc. { static char name[] SET_TO "convert_axis_offsets"; if (settings->cutter_radius_compensation ISNT OFF) /* not "IS ON" */ ERROR_MACRO(_interpreter_linetext, name, "Cannot change axis offsets with cutter radius comp"); else if (g_code IS G_92) { if (block->x_flag IS ON) { settings->axis_offset_x SET_TO (settings->current_x + settings->axis_offset_x - block->x_number); settings->current_x SET_TO block->x_number; } if (block->y_flag IS ON) { settings->axis_offset_y SET_TO (settings->current_y + settings->axis_offset_y - block->y_number); settings->current_y SET_TO block->y_number; } if (block->z_flag IS ON) { settings->axis_offset_z SET_TO (settings->current_z + settings->axis_offset_z - block->z_number); settings->current_z SET_TO block->z_number; } SET_ORIGIN_OFFSETS(settings->origin_offset_x + settings->axis_offset_x, settings->origin_offset_y + settings->axis_offset_y, settings->origin_offset_z + settings->axis_offset_z); settings->parameters[5211] SET_TO settings->axis_offset_x; settings->parameters[5212] SET_TO settings->axis_offset_y; settings->parameters[5213] SET_TO settings->axis_offset_z; } else if (g_code IS G_92_2) { settings->current_x SET_TO settings->current_x + settings->axis_offset_x; settings->current_y SET_TO settings->current_y + settings->axis_offset_y; settings->current_z SET_TO settings->current_z + settings->axis_offset_z; SET_ORIGIN_OFFSETS(settings->origin_offset_x, settings->origin_offset_y, settings->origin_offset_z); settings->axis_offset_x SET_TO 0.0; settings->axis_offset_y SET_TO 0.0; settings->axis_offset_z SET_TO 0.0; settings->parameters[5211] SET_TO 0.0; settings->parameters[5212] SET_TO 0.0; settings->parameters[5213] SET_TO 0.0; } else BUG_MACRO(name, "Code is not G92 or G92.2 in convert_axis_offsets"); return RS274NGC_OK; }

int convert_comment (  char *    comment )

Definition at line 6873 of file rs274ngc.cc. { int m; int item; for (m SET_TO 0; ((item SET_TO comment[m]) IS ' ') OR (item IS '\t') ; m++); if ((item ISNT 'M') AND (item ISNT 'm')) { COMMENT(comment); return RS274NGC_OK; } for (m++; ((item SET_TO comment[m]) IS ' ') OR (item IS '\t') ; m++); if ((item ISNT 'S') AND (item ISNT 's')) { COMMENT(comment); return RS274NGC_OK; } for (m++; ((item SET_TO comment[m]) IS ' ') OR (item IS '\t') ; m++); if ((item ISNT 'G') AND (item ISNT 'g')) { COMMENT(comment); return RS274NGC_OK; } for (m++; ((item SET_TO comment[m]) IS ' ') OR (item IS '\t') ; m++); if (item ISNT ',') { COMMENT(comment); return RS274NGC_OK; } MESSAGE(comment + m + 1); return RS274NGC_OK; }

int convert_control_mode (  int    g_code, block_pointer    block, setup_pointer    settings )

Definition at line 5785 of file rs274ngc.cc. { static char name[] SET_TO "convert_control_mode"; if (g_code IS G_61) { SET_MOTION_CONTROL_MODE(CANON_EXACT_PATH); settings->control_mode SET_TO CANON_EXACT_PATH; } else if (g_code IS G_64) { SET_MOTION_CONTROL_MODE(CANON_CONTINUOUS); settings->control_mode SET_TO CANON_CONTINUOUS; } else BUG_MACRO(name, "Code is not G61 or G64 in convert_control_mode"); return RS274NGC_OK; }

int convert_coordinate_system (  int    g_code, block_pointer    block, setup_pointer    settings )

Definition at line 5877 of file rs274ngc.cc. { static char name[] SET_TO "convert_coordinate_system"; int origin; double x; double y; double z; double * parameters; parameters SET_TO settings->parameters; switch(g_code) { case 540: origin SET_TO 1; break; case 550: origin SET_TO 2; break; case 560: origin SET_TO 3; break; case 570: origin SET_TO 4; break; case 580: origin SET_TO 5; break; case 590: origin SET_TO 6; break; case 591: origin SET_TO 7; break; case 592: origin SET_TO 8; break; case 593: origin SET_TO 9; break; default: BUG_MACRO(name, "Code is not G54 to G59.3 in convert_coordinate_system"); } if (origin IS settings->origin_ngc) /* already using this origin */ { #ifdef DEBUG_EMC COMMENT("interpreter: continuing to use same coordinate system"); #endif return RS274NGC_OK; } /* axis offsets could be included in the following calculcations but do not need to be because they would not change the result. */ settings->current_x SET_TO (settings->current_x + settings->origin_offset_x); settings->current_y SET_TO (settings->current_y + settings->origin_offset_y); settings->current_z SET_TO (settings->current_z + settings->origin_offset_z); x SET_TO parameters[5201 + (origin * 20)]; y SET_TO parameters[5202 + (origin * 20)]; z SET_TO parameters[5203 + (origin * 20)]; settings->origin_offset_x SET_TO x; settings->origin_offset_y SET_TO y; settings->origin_offset_z SET_TO z; settings->current_x SET_TO (settings->current_x - x); settings->current_y SET_TO (settings->current_y - y); settings->current_z SET_TO (settings->current_z - z); settings->origin_ngc SET_TO origin; SET_ORIGIN_OFFSETS(x + settings->axis_offset_x, y + settings->axis_offset_y, z + settings->axis_offset_z); return RS274NGC_OK; }

int convert_cutter_compensation (  int    g_code, block_pointer    block, setup_pointer    settings )

Definition at line 5983 of file rs274ngc.cc. { static char name[] SET_TO "convert_cutter_compensation"; if (g_code IS G_40) { if (convert_cutter_compensation_off(settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } else if (g_code IS G_41) { if (convert_cutter_compensation_on(LEFT, block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } else if (g_code IS G_42) { if (convert_cutter_compensation_on(RIGHT, block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } else BUG_MACRO(name, "Code is not G40, G41, or G42 in convert_cutter_compensation"); return RS274NGC_OK; }

int convert_cutter_compensation_off (  setup_pointer    settings )

Definition at line 3745 of file rs274ngc.cc. { #ifdef DEBUG_EMC COMMENT("interpreter: cutter radius compensation off"); #endif settings->cutter_radius_compensation SET_TO OFF; settings->program_x SET_TO UNKNOWN; return RS274NGC_OK; }

int convert_cutter_compensation_on (  int    side, block_pointer    block, setup_pointer    settings )

Definition at line 3785 of file rs274ngc.cc. { static char name[] SET_TO "convert_cutter_compensation_on"; if (settings->plane ISNT CANON_PLANE_XY) ERROR_MACRO(_interpreter_linetext, name, "Cannot turn cutter radius comp on out of XY-plane"); if (block->d_number IS -1) ERROR_MACRO(_interpreter_linetext, name, "D word missing with cutter radius comp on"); if (settings->cutter_radius_compensation ISNT OFF) ERROR_MACRO(_interpreter_linetext, name, "Cannot turn cutter radius comp on when already on"); #ifdef DEBUG_EMC if (side IS RIGHT) COMMENT("interpreter: cutter radius compensation on right"); else COMMENT("interpreter: cutter radius compensation on left"); #endif /* radius is (settings->tool_table[block->d_number].diameter)/2.0) */ settings->tool_table_index SET_TO block->d_number; settings->cutter_radius_compensation SET_TO side; return RS274NGC_OK; }

int convert_cycle (  int    motion, block_pointer    block, setup_pointer    settings )

Definition at line 3910 of file rs274ngc.cc. { static char name[] SET_TO "convert_cycle"; double x_increment; double y_increment; double i; double j; double k; double x; double y; double clear_z; double old_z; double z; double r; int repeat; CANON_MOTION_MODE save_mode; if (settings->motion_mode ISNT motion) { if (block->r_flag IS OFF) ERROR_MACRO(_interpreter_linetext, name, "R clearance plane unspecified in canned cycle"); if (block->z_flag IS OFF) ERROR_MACRO(_interpreter_linetext, name, "Z value unspecified in canned cycle"); } block->r_number SET_TO block->r_flag IS ON ? block->r_number : settings->cycle_r; block->z_number SET_TO block->z_flag IS ON ? block->z_number : settings->cycle_z; old_z SET_TO settings->current_z; if (settings->distance_mode IS MODE_ABSOLUTE) { x_increment SET_TO 0.0; y_increment SET_TO 0.0; r SET_TO block->r_number; z SET_TO block->z_number; x SET_TO block->x_flag IS ON ? block->x_number : settings->current_x; y SET_TO block->y_flag IS ON ? block->y_number : settings->current_y; } else if (settings->distance_mode IS MODE_INCREMENTAL) { x_increment SET_TO block->x_number; y_increment SET_TO block->y_number; r SET_TO (block->r_number + old_z); z SET_TO (r + block->z_number); /* [NCMS, page 98] */ x SET_TO settings->current_x; y SET_TO settings->current_y; } else BUG_MACRO(name, "Distance mode is neither absolute nor incremental in convert_cycle"); if (r < z) ERROR_MACRO(_interpreter_linetext, name, "R value less than Z value in canned cycle"); if (block->l_number IS -1) block->l_number SET_TO 1; else if (block->l_number IS 0) ERROR_MACRO(_interpreter_linetext, name, "Cannot do zero repeats of cycle"); if (old_z < r) { STRAIGHT_TRAVERSE(settings->current_x, settings->current_y, r); old_z SET_TO r; } clear_z SET_TO (settings->retract_mode IS R_PLANE) ? r : old_z; save_mode = GET_MOTION_CONTROL_MODE(); if (save_mode ISNT CANON_EXACT_PATH) SET_MOTION_CONTROL_MODE(CANON_EXACT_PATH); switch(motion) { case G_81: CYCLE_MACRO(convert_cycle_g81(x, y, clear_z, z)) break; case G_82: if ((settings->motion_mode ISNT G_82) AND (block->p_number IS -1.0)) ERROR_MACRO(_interpreter_linetext, name, "P word (dwell time) missing with G82"); block->p_number SET_TO block->p_number IS -1.0 ? settings->cycle_p : block->p_number; CYCLE_MACRO(convert_cycle_g82 (x, y, clear_z, z, block->p_number)) settings->cycle_p SET_TO block->p_number; break; case G_83: if ((settings->motion_mode ISNT G_83) AND (block->q_number IS -1.0)) ERROR_MACRO(_interpreter_linetext, name, "Q word (depth increment) missing with G83"); block->q_number SET_TO block->q_number IS -1.0 ? settings->cycle_q : block->q_number; CYCLE_MACRO(convert_cycle_g83 (x, y, r, clear_z, z, block->q_number)) settings->cycle_q SET_TO block->q_number; break; case G_84: CYCLE_MACRO(convert_cycle_g84 (x, y, clear_z, z, settings->spindle_turning, settings->speed_feed_mode)) break; case G_85: CYCLE_MACRO(convert_cycle_g85 (x, y, clear_z, z)) break; case G_86: if ((settings->motion_mode ISNT G_86) AND (block->p_number IS -1.0)) ERROR_MACRO(_interpreter_linetext, name, "P word (dwell time) missing with G86"); block->p_number SET_TO block->p_number IS -1.0 ? settings->cycle_p : block->p_number; CYCLE_MACRO(convert_cycle_g86 (x, y, clear_z, z, block->p_number, settings->spindle_turning)) settings->cycle_p SET_TO block->p_number; break; case G_87: if (settings->motion_mode ISNT G_87) { if (block->i_flag IS OFF) ERROR_MACRO(_interpreter_linetext, name, "I word missing with G87"); if (block->j_flag IS OFF) ERROR_MACRO(_interpreter_linetext, name, "J word missing with G87"); if (block->k_flag IS OFF) ERROR_MACRO(_interpreter_linetext, name, "K word missing with G87"); } i SET_TO block->i_flag IS ON ? block->i_number : settings->cycle_i; j SET_TO block->j_flag IS ON ? block->j_number : settings->cycle_j; k SET_TO block->k_flag IS ON ? block->k_number : settings->cycle_k; settings->cycle_i SET_TO i; settings->cycle_j SET_TO j; settings->cycle_k SET_TO k; if (settings->distance_mode IS MODE_INCREMENTAL) { k SET_TO (z + k); /* k always absolute in function call below */ } CYCLE_MACRO(convert_cycle_g87 (x, (x + i), y, (y + j), r, clear_z, k, z, settings->spindle_turning)) break; case G_88: if ((settings->motion_mode ISNT G_88) AND (block->p_number IS -1.0)) ERROR_MACRO(_interpreter_linetext, name, "P word (dwell time) missing with G88"); block->p_number SET_TO block->p_number IS -1.0 ? settings->cycle_p : block->p_number; CYCLE_MACRO(convert_cycle_g88 (x, y, z, block->p_number, settings->spindle_turning)) settings->cycle_p SET_TO block->p_number; break; case G_89: if ((settings->motion_mode ISNT G_89) AND (block->p_number IS -1.0)) ERROR_MACRO(_interpreter_linetext, name, "P word (dwell time) missing with G89"); block->p_number SET_TO block->p_number IS -1.0 ? settings->cycle_p : block->p_number; CYCLE_MACRO(convert_cycle_g89 (x, y, clear_z, z, block->p_number)) settings->cycle_p SET_TO block->p_number; break; default: BUG_MACRO(name, "Convert_cycle should not have been called"); } settings->current_x SET_TO x; settings->current_y SET_TO y; settings->current_z SET_TO clear_z; settings->cycle_l SET_TO block->l_number; settings->cycle_r SET_TO block->r_number; settings->cycle_z SET_TO block->z_number; settings->motion_mode SET_TO motion; if (save_mode ISNT CANON_EXACT_PATH) SET_MOTION_CONTROL_MODE(save_mode); return RS274NGC_OK; }

int convert_cycle_g81 (  double    x, double    y, double    clear_z, double    bottom_z )

Definition at line 2643 of file rs274ngc.cc. { static char name[] SET_TO "convert_cycle_g81"; STRAIGHT_FEED(x, y, bottom_z); STRAIGHT_TRAVERSE(x, y, clear_z); return RS274NGC_OK; }

int convert_cycle_g82 (  double    x, double    y, double    clear_z, double    bottom_z, double    dwell )

Definition at line 2677 of file rs274ngc.cc. { static char name[] SET_TO "convert_cycle_g82"; STRAIGHT_FEED(x, y, bottom_z); DWELL(dwell); STRAIGHT_TRAVERSE(x, y, clear_z); return RS274NGC_OK; }

int convert_cycle_g83 (  double    x, double    y, double    r, double    clear_z, double    bottom_z, double    delta )

Definition at line 2723 of file rs274ngc.cc. { static char name[] SET_TO "convert_cycle_g83"; double current_depth; double rapid_delta; rapid_delta SET_TO G83_RAPID_DELTA; if (_interpreter_settings.length_units IS CANON_UNITS_MM) rapid_delta *= 25.4; for (current_depth SET_TO (r - delta); current_depth > bottom_z; current_depth SET_TO (current_depth - delta)) { STRAIGHT_FEED(x, y, current_depth); DWELL(0.25); STRAIGHT_TRAVERSE(x, y, clear_z); STRAIGHT_TRAVERSE(x, y, current_depth + rapid_delta); } STRAIGHT_FEED(x, y, bottom_z); DWELL(0.25); STRAIGHT_TRAVERSE(x, y, clear_z); return RS274NGC_OK; }

int convert_cycle_g84 (  double    x, double    y, double    clear_z, double    bottom_z, CANON_DIRECTION    direction, CANON_SPEED_FEED_MODE    mode )

Definition at line 2784 of file rs274ngc.cc. { static char name[] SET_TO "convert_cycle_g84"; if (direction ISNT CANON_CLOCKWISE) ERROR_MACRO(_interpreter_linetext, name, "Spindle not turning clockwise in G84 canned cycle"); START_SPEED_FEED_SYNCH(); STRAIGHT_FEED(x, y, bottom_z); STOP_SPINDLE_TURNING(); START_SPINDLE_COUNTERCLOCKWISE(); STRAIGHT_FEED(x, y, clear_z); if (mode ISNT CANON_SYNCHED) STOP_SPEED_FEED_SYNCH(); STOP_SPINDLE_TURNING(); START_SPINDLE_CLOCKWISE(); return RS274NGC_OK; }

int convert_cycle_g85 (  double    x, double    y, double    clear_z, double    bottom_z )

Definition at line 2828 of file rs274ngc.cc. { static char name[] SET_TO "convert_cycle_g85"; STRAIGHT_FEED(x, y, bottom_z); STRAIGHT_FEED(x, y, clear_z); return RS274NGC_OK; }

int convert_cycle_g86 (  double    x, double    y, double    clear_z, double    bottom_z, double    dwell, CANON_DIRECTION    direction )

Definition at line 2867 of file rs274ngc.cc. { static char name[] SET_TO "convert_cycle_g86"; if ((direction ISNT CANON_CLOCKWISE) AND (direction ISNT CANON_COUNTERCLOCKWISE)) ERROR_MACRO(_interpreter_linetext, name, "Spindle not turning in G86 canned cycle"); STRAIGHT_FEED(x, y, bottom_z); DWELL(dwell); STOP_SPINDLE_TURNING(); STRAIGHT_TRAVERSE(x, y, clear_z); if (direction IS CANON_CLOCKWISE) START_SPINDLE_CLOCKWISE(); else START_SPINDLE_COUNTERCLOCKWISE(); return RS274NGC_OK; }

int convert_cycle_g87 (  double    x, double    offset_x, double    y, double    offset_y, double    r, double    clear_z, double    middle_z, double    bottom_z, CANON_DIRECTION    direction )

Definition at line 2942 of file rs274ngc.cc. { static char name[] SET_TO "convert_cycle_g87"; if ((direction ISNT CANON_CLOCKWISE) AND (direction ISNT CANON_COUNTERCLOCKWISE)) ERROR_MACRO(_interpreter_linetext, name, "Spindle not turning in G87 canned cycle"); STRAIGHT_TRAVERSE(offset_x, offset_y, r); STOP_SPINDLE_TURNING(); ORIENT_SPINDLE(0.0, direction); STRAIGHT_TRAVERSE(offset_x, offset_y, bottom_z); STRAIGHT_TRAVERSE(x, y, bottom_z); if (direction IS CANON_CLOCKWISE) START_SPINDLE_CLOCKWISE(); else START_SPINDLE_COUNTERCLOCKWISE(); STRAIGHT_FEED(x, y, middle_z); STRAIGHT_FEED(x, y, bottom_z); STOP_SPINDLE_TURNING(); ORIENT_SPINDLE(0.0, direction); STRAIGHT_TRAVERSE(offset_x, offset_y, bottom_z); STRAIGHT_TRAVERSE(offset_x, offset_y, clear_z); STRAIGHT_TRAVERSE(x, y, clear_z); if (direction IS CANON_CLOCKWISE) START_SPINDLE_CLOCKWISE(); else START_SPINDLE_COUNTERCLOCKWISE(); return RS274NGC_OK; }

int convert_cycle_g88 (  double    x, double    y, double    bottom_z, double    dwell, CANON_DIRECTION    direction )

Definition at line 3008 of file rs274ngc.cc. { static char name[] SET_TO "convert_cycle_g88"; if ((direction ISNT CANON_CLOCKWISE) AND (direction ISNT CANON_COUNTERCLOCKWISE)) ERROR_MACRO(_interpreter_linetext, name, "Spindle not turning in G88 canned cycle"); STRAIGHT_FEED(x, y, bottom_z); DWELL(dwell); STOP_SPINDLE_TURNING(); PROGRAM_STOP(); /* operator retracts the spindle here */ if (direction IS CANON_CLOCKWISE) START_SPINDLE_CLOCKWISE(); else START_SPINDLE_COUNTERCLOCKWISE(); return RS274NGC_OK; }

int convert_cycle_g89 (  double    x, double    y, double    clear_z, double    bottom_z, double    dwell )

Definition at line 3051 of file rs274ngc.cc. { static char name[] SET_TO "convert_cycle_g89"; STRAIGHT_FEED(x, y, bottom_z); DWELL(dwell); STRAIGHT_FEED(x, y, clear_z); return RS274NGC_OK; }

int convert_distance_mode (  int    g_code, block_pointer    block, setup_pointer    settings )

Definition at line 6032 of file rs274ngc.cc. { static char name[] SET_TO "convert_distance_mode"; if (g_code IS G_90) { if (settings->distance_mode ISNT MODE_ABSOLUTE) { #ifdef DEBUG_EMC COMMENT("interpreter: distance mode changed to absolute"); #endif settings->distance_mode SET_TO MODE_ABSOLUTE; } } else if (g_code IS G_91) { if (settings->distance_mode ISNT MODE_INCREMENTAL) { #ifdef DEBUG_EMC COMMENT("interpreter: distance mode changed to incremental"); #endif settings->distance_mode SET_TO MODE_INCREMENTAL; } } else BUG_MACRO(name, "Code is not G90 or G91 in convert_distance_mode"); return RS274NGC_OK; }

int convert_dwell (  double    time )

Definition at line 6076 of file rs274ngc.cc. { DWELL(time); return RS274NGC_OK; }

int convert_feed_mode (  int    g_code, block_pointer    block, setup_pointer    settings )

Definition at line 6928 of file rs274ngc.cc. { static char name[] SET_TO "convert_feed_mode"; if (g_code IS G_93) { #ifdef DEBUG_EMC COMMENT("interpreter: feed mode set to inverse time"); #endif settings->feed_mode SET_TO INVERSE_TIME; } else if (g_code IS G_94) { #ifdef DEBUG_EMC COMMENT("interpreter: feed mode set to units per minute"); #endif settings->feed_mode SET_TO UNITS_PER_MINUTE; } else BUG_MACRO(name, "Code is not G93 or G94 in convert_feed_mode"); return RS274NGC_OK; }

int convert_feed_rate (  block_pointer    block, setup_pointer    settings )

Definition at line 6968 of file rs274ngc.cc. { SET_FEED_RATE(block->f_number); settings->feed_rate SET_TO block->f_number; return RS274NGC_OK; }

int convert_g (  block_pointer    block, setup_pointer    settings )

Definition at line 7039 of file rs274ngc.cc. { static char name[] SET_TO "convert_g"; if (block->g_modes[4] IS G_4) { if (convert_dwell(block->p_number) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } if (block->g_modes[2] ISNT -1) { if (convert_set_plane(block->g_modes[2], block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } if (block->g_modes[6] ISNT -1) { if (convert_length_units(block->g_modes[6], settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } if (block->g_modes[7] ISNT -1) { if (convert_cutter_compensation(block->g_modes[7], block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } if (block->g_modes[8] ISNT -1) { if (convert_tool_length_offset(block->g_modes[8], block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } if (block->g_modes[12] ISNT -1) { if (convert_coordinate_system (block->g_modes[12], block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } if (block->g_modes[13] ISNT -1) { if (convert_control_mode (block->g_modes[13], block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } if (block->g_modes[3] ISNT -1) { if (convert_distance_mode(block->g_modes[3], block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } if (block->g_modes[10] ISNT -1) { if (convert_retract_mode(block->g_modes[10], block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } if (block->g_modes[0] ISNT -1) { if (convert_modal_0(block->g_modes[0], block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } if (block->motion_to_be ISNT -1) { if (convert_motion(block->motion_to_be, block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } return RS274NGC_OK; }

int convert_length_units (  int    g_code, setup_pointer    settings )

Definition at line 6124 of file rs274ngc.cc. { static char name[] SET_TO "convert_length_units"; if (settings->cutter_radius_compensation ISNT OFF) ERROR_MACRO(_interpreter_linetext, name, "Cannot change units with cutter radius comp"); else if (g_code IS G_20) { USE_LENGTH_UNITS(CANON_UNITS_INCHES); if (settings->length_units ISNT CANON_UNITS_INCHES) { settings->length_units SET_TO CANON_UNITS_INCHES; settings->current_x SET_TO (settings->current_x * INCH_PER_MM); settings->current_y SET_TO (settings->current_y * INCH_PER_MM); settings->current_z SET_TO (settings->current_z * INCH_PER_MM); settings->axis_offset_x SET_TO (settings->axis_offset_x * INCH_PER_MM); settings->axis_offset_y SET_TO (settings->axis_offset_y * INCH_PER_MM); settings->axis_offset_z SET_TO (settings->axis_offset_z * INCH_PER_MM); settings->origin_offset_x SET_TO (settings->origin_offset_x * INCH_PER_MM); settings->origin_offset_y SET_TO (settings->origin_offset_y * INCH_PER_MM); settings->origin_offset_z SET_TO (settings->origin_offset_z * INCH_PER_MM); } } else if (g_code IS G_21) { USE_LENGTH_UNITS(CANON_UNITS_MM); if (settings->length_units ISNT CANON_UNITS_MM) { settings->length_units SET_TO CANON_UNITS_MM; settings->current_x SET_TO (settings->current_x * MM_PER_INCH); settings->current_y SET_TO (settings->current_y * MM_PER_INCH); settings->current_z SET_TO (settings->current_z * MM_PER_INCH); settings->axis_offset_x SET_TO (settings->axis_offset_x * MM_PER_INCH); settings->axis_offset_y SET_TO (settings->axis_offset_y * MM_PER_INCH); settings->axis_offset_z SET_TO (settings->axis_offset_z * MM_PER_INCH); settings->origin_offset_x SET_TO (settings->origin_offset_x * MM_PER_INCH); settings->origin_offset_y SET_TO (settings->origin_offset_y * MM_PER_INCH); settings->origin_offset_z SET_TO (settings->origin_offset_z * MM_PER_INCH); } } else BUG_MACRO(name, "Code is not G20 or G21 in convert_length_units"); return RS274NGC_OK; }

int convert_m (  block_pointer    block, setup_pointer    settings )

Definition at line 7149 of file rs274ngc.cc. { static char name[] SET_TO "convert_m"; if (block->m_modes[6] ISNT -1) if (convert_tool_change(block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); if (block->m_modes[7] IS 3) { START_SPINDLE_CLOCKWISE(); settings->spindle_turning SET_TO CANON_CLOCKWISE; } else if (block->m_modes[7] IS 4) { START_SPINDLE_COUNTERCLOCKWISE(); settings->spindle_turning SET_TO CANON_COUNTERCLOCKWISE; } else if (block->m_modes[7] IS 5) { STOP_SPINDLE_TURNING(); settings->spindle_turning SET_TO CANON_STOPPED; } if (block->m_modes[8] IS 7) { MIST_ON(); settings->mist SET_TO ON; } else if (block->m_modes[8] IS 8) { FLOOD_ON(); settings->flood SET_TO ON; } else if (block->m_modes[8] IS 9) { MIST_OFF(); settings->mist SET_TO OFF; FLOOD_OFF(); settings->flood SET_TO OFF; } if (block->m_modes[9] IS 48) { ENABLE_FEED_OVERRIDE(); ENABLE_SPEED_OVERRIDE(); settings->feed_override SET_TO ON; settings->speed_override SET_TO ON; } else if (block->m_modes[9] IS 49) { DISABLE_FEED_OVERRIDE(); DISABLE_SPEED_OVERRIDE(); settings->feed_override SET_TO OFF; settings->speed_override SET_TO OFF; } return RS274NGC_OK; }

int convert_modal_0 (  int    code, block_pointer    block, setup_pointer    settings )

Definition at line 6201 of file rs274ngc.cc. { static char name[] SET_TO "convert_modal_0"; if (code IS G_10) { if (convert_setup(block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } else if ((code IS G_92) OR (code IS G_92_2)) { if (convert_axis_offsets(code, block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } else BUG_MACRO(name, "Code is not G10, G92, or G92.2 in convert_modal_0"); return RS274NGC_OK; }

int convert_motion (  int    motion, block_pointer    block, setup_pointer    settings )

Definition at line 6252 of file rs274ngc.cc. { static char name[] SET_TO "convert_motion"; if ((motion IS G_0) OR (motion IS G_1)) { if (convert_straight (motion, block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } else if ((motion IS G_3) OR (motion IS G_2)) { if ((settings->feed_mode IS INVERSE_TIME) AND (block->f_number IS -1.0)) ERROR_MACRO(_interpreter_linetext, name, "F word missing with inverse time arc move"); if (convert_arc (motion, block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } else if (motion IS G_38_2) { if (settings->feed_mode IS INVERSE_TIME) ERROR_MACRO(_interpreter_linetext, name, "Cannot probe in inverse time feed mode"); if (settings->cutter_radius_compensation ISNT OFF) /* NOT "IS ON"! */ ERROR_MACRO(_interpreter_linetext, name, "Cannot probe with cutter radius compensation on"); if (settings->feed_rate IS 0.0) ERROR_MACRO(_interpreter_linetext, name, "Cannot probe with zero feed rate"); if (convert_probe (block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } else if (motion IS G_80) { if((block->x_flag) OR (block->y_flag) OR (block->z_flag)) ERROR_MACRO(_interpreter_linetext, name, "Coordinate setting given with G80"); else { #ifdef DEBUG_EMC COMMENT("interpreter: motion mode set to none"); #endif settings->motion_mode SET_TO G_80; } } else if ((motion > G_80) AND (motion < G_90)) { if (convert_cycle(motion, block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } else BUG_MACRO(name, "Code is not G0 to G3 or G80 to G89 in convert_motion"); return RS274NGC_OK; }

int convert_probe (  block_pointer    block, setup_pointer    settings )

Definition at line 4111 of file rs274ngc.cc. { static char name[] SET_TO "convert_probe"; double end_x; double end_y; double end_z; if (((block->x_flag IS OFF) AND (block->y_flag IS OFF)) AND (block->z_flag IS OFF)) ERROR_MACRO(_interpreter_linetext, name, "X, Y, and Z words all missing with G38.2"); utility_find_ends(block, settings, &end_x, &end_y, &end_z); TURN_PROBE_ON(); STRAIGHT_PROBE (end_x, end_y, end_z); TURN_PROBE_OFF(); settings->motion_mode SET_TO G_38_2; settings->probe_flag SET_TO ON; #ifdef STAND_ALONE_INTERP settings->current_x SET_TO ((0.9 * end_x) + (0.1 * settings->current_x)); settings->current_y SET_TO ((0.9 * end_y) + (0.1 * settings->current_y)); settings->current_z SET_TO ((0.9 * end_z) + (0.1 * settings->current_z)); #endif return RS274NGC_OK; }

int convert_retract_mode (  int    g_code, block_pointer    block, setup_pointer    settings )

Definition at line 6327 of file rs274ngc.cc. { static char name[] SET_TO "convert_retract_mode"; if (g_code IS G_98) { #ifdef DEBUG_EMC COMMENT("interpreter: retract mode set to old_z"); #endif settings->retract_mode SET_TO OLD_Z; } else if (g_code IS G_99) { #ifdef DEBUG_EMC COMMENT("interpreter: retract mode set to r_plane"); #endif settings->retract_mode SET_TO R_PLANE; } else BUG_MACRO(name, "Code is not G98 or G99 in convert_retract_mode"); return RS274NGC_OK; }

int convert_set_plane (  int    g_code, block_pointer    block, setup_pointer    settings )

Definition at line 6369 of file rs274ngc.cc. { static char name[] SET_TO "convert_set_plane"; if (g_code IS G_17) { SELECT_PLANE(CANON_PLANE_XY); settings->plane SET_TO CANON_PLANE_XY; } else if (g_code IS G_18) { if (settings->cutter_radius_compensation ISNT OFF) ERROR_MACRO(_interpreter_linetext, name, "Cannot use XZ plane with cutter radius comp"); SELECT_PLANE(CANON_PLANE_XZ); settings->plane SET_TO CANON_PLANE_XZ; } else if (g_code IS G_19) { if (settings->cutter_radius_compensation ISNT OFF) ERROR_MACRO(_interpreter_linetext, name, "Cannot use YZ plane with cutter radius comp"); SELECT_PLANE(CANON_PLANE_YZ); settings->plane SET_TO CANON_PLANE_YZ; } else BUG_MACRO(name, "Code is not G17, G18, or G19 in convert_set_plane"); return RS274NGC_OK; }

int convert_setup (  block_pointer    block, setup_pointer    settings )

Definition at line 4163 of file rs274ngc.cc. { static char name[] SET_TO "convert_setup"; double x; double y; double z; double * parameters; int p_int; parameters SET_TO settings->parameters; p_int SET_TO (int)(block->p_number + 0.0001); /* p_number is a double */ if (block->x_flag IS ON) { x SET_TO block->x_number; parameters[5201 + (p_int * 20)] SET_TO x; } else x SET_TO parameters[5201 + (p_int * 20)]; if (block->y_flag IS ON) { y SET_TO block->y_number; parameters[5202 + (p_int * 20)] SET_TO y; } else y SET_TO parameters[5202 + (p_int * 20)]; if (block->z_flag IS ON) { z SET_TO block->z_number; parameters[5203 + (p_int * 20)] SET_TO z; } else z SET_TO parameters[5203 + (p_int * 20)]; /* axis offsets could be included in the following calculations but do not need to be because the results do not change */ if (p_int IS settings->origin_ngc) /* system is currently used */ { settings->current_x SET_TO (settings->current_x + settings->origin_offset_x); settings->current_y SET_TO (settings->current_y + settings->origin_offset_y); settings->current_z SET_TO (settings->current_z + settings->origin_offset_z); settings->origin_offset_x SET_TO x; settings->origin_offset_y SET_TO y; settings->origin_offset_z SET_TO z; SET_ORIGIN_OFFSETS(x + settings->axis_offset_x, y + settings->axis_offset_y, z + settings->axis_offset_z); settings->current_x SET_TO (settings->current_x - x); settings->current_y SET_TO (settings->current_y - y); settings->current_z SET_TO (settings->current_z - z); } #ifdef DEBUG_EMC else COMMENT("interpreter: setting coordinate system origin"); #endif return RS274NGC_OK; }

int convert_speed (  block_pointer    block, setup_pointer    settings )

Definition at line 7224 of file rs274ngc.cc. { SET_SPINDLE_SPEED(block->s_number); settings->speed SET_TO block->s_number; return RS274NGC_OK; }

int convert_stop (  block_pointer    block, setup_pointer    settings )

Definition at line 7297 of file rs274ngc.cc. { static char name[] SET_TO "convert_stop"; if (block->m_modes[4] IS 0) { PROGRAM_STOP(); } else if (block->m_modes[4] IS 60) { PALLET_SHUTTLE(); PROGRAM_STOP(); } else if (block->m_modes[4] IS 1) { OPTIONAL_PROGRAM_STOP(); } else if ((block->m_modes[4] IS 2) OR (block->m_modes[4] IS 30)) { /* reset stuff here */ /*1*/ settings->current_x SET_TO settings->current_x + settings->origin_offset_x; settings->current_y SET_TO settings->current_y + settings->origin_offset_y; settings->current_z SET_TO settings->current_z + settings->origin_offset_z; settings->origin_offset_x SET_TO settings->parameters[5221]; settings->origin_offset_y SET_TO settings->parameters[5222]; settings->origin_offset_z SET_TO settings->parameters[5223]; settings->current_x SET_TO settings->current_x - settings->origin_offset_x; settings->current_y SET_TO settings->current_y - settings->origin_offset_y; settings->current_z SET_TO settings->current_z - settings->origin_offset_z; SET_ORIGIN_OFFSETS(settings->origin_offset_x + settings->axis_offset_x, settings->origin_offset_y + settings->axis_offset_y, settings->origin_offset_z + settings->axis_offset_z); /*2*/ if (settings->plane ISNT CANON_PLANE_XY) { SELECT_PLANE(CANON_PLANE_XY); settings->plane SET_TO CANON_PLANE_XY; } /*3*/ settings->distance_mode SET_TO MODE_ABSOLUTE; /*4*/ settings->feed_mode SET_TO UNITS_PER_MINUTE; /*5*/ if (settings->feed_override ISNT ON) { ENABLE_FEED_OVERRIDE(); settings->feed_override SET_TO ON; } if (settings->speed_override ISNT ON) { ENABLE_SPEED_OVERRIDE(); settings->speed_override SET_TO ON; } /*6*/ settings->cutter_radius_compensation SET_TO OFF; settings->program_x SET_TO UNKNOWN; /*7*/ STOP_SPINDLE_TURNING(); settings->spindle_turning SET_TO CANON_STOPPED; /*8*/ settings->motion_mode SET_TO G_1; /*9*/ if (settings->mist IS ON) { MIST_OFF(); settings->mist SET_TO OFF; } if (settings->flood IS ON) { FLOOD_OFF(); settings->flood SET_TO OFF; } if (block->m_modes[4] IS 30) PALLET_SHUTTLE(); PROGRAM_END(); return RS274NGC_EXIT; } else BUG_MACRO(name, "Code is not M0, M1, M2, M30 or M60 in convert_stop"); return RS274NGC_OK; }

int convert_straight (  int    move, block_pointer    block, setup_pointer    settings )

Definition at line 4264 of file rs274ngc.cc. { static char name[] SET_TO "convert_straight"; double end_x = 0.0; double end_y = 0.0; double end_z = 0.0; double length; double rate; if (((block->x_flag IS OFF) AND (block->y_flag IS OFF)) AND (block->z_flag IS OFF)) ERROR_MACRO(_interpreter_linetext, name, "X, Y, and Z words all missing with G0 or G1"); settings->motion_mode SET_TO move; utility_find_ends(block, settings, &end_x, &end_y, &end_z); if (move IS G_0) { if (settings->cutter_radius_compensation ISNT OFF) ERROR_MACRO(_interpreter_linetext, name, "Cannot use G0 with cutter radius comp"); STRAIGHT_TRAVERSE(end_x, end_y, end_z); settings->current_x SET_TO end_x; settings->current_y SET_TO end_y; } else if (move IS G_1) { if (settings->cutter_radius_compensation ISNT OFF) /* NOT "IS ON"! */ { if (settings->feed_mode IS INVERSE_TIME) ERROR_MACRO(_interpreter_linetext, name, "Cannot use inverse time feed with cutter radius comp"); else if (block->g_modes[4] IS G_53) ERROR_MACRO(_interpreter_linetext, name, "Cannot use G53 with cutter radius comp"); else if (settings->feed_rate IS 0.0) ERROR_MACRO(_interpreter_linetext, name, "Cannot do G1 with zero feed rate"); else if (settings->program_x IS UNKNOWN) { if (convert_straight_comp1(settings, end_x, end_y, end_z) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } else { if (convert_straight_comp2(settings, end_x, end_y, end_z) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } } else { if (settings->feed_mode IS INVERSE_TIME) { if (block->f_number IS -1.0) ERROR_MACRO(_interpreter_linetext, name, "F word missing with inverse time G1 move"); else { length SET_TO utility_find_straight_length (end_x, end_y, end_z, settings->current_x, settings->current_y, settings->current_z); rate SET_TO MAX(0.1, (length * block->f_number)); SET_FEED_RATE (rate); settings->feed_rate SET_TO rate; } } else if (settings->feed_rate IS 0.0) ERROR_MACRO(_interpreter_linetext, name, "Cannot do G1 with zero feed rate"); STRAIGHT_FEED(end_x, end_y, end_z); settings->current_x SET_TO end_x; settings->current_y SET_TO end_y; } } else BUG_MACRO(name, "Code is not G0 or G1 in convert_straight"); settings->current_z SET_TO end_z; return RS274NGC_OK; }

int convert_straight_comp1 (  setup_pointer    settings, double    px, double    py, double    end_z )

Definition at line 3099 of file rs274ngc.cc. { static char name[] SET_TO "convert_straight_comp1"; double radius; double cx, cy; double distance; double theta; double alpha; int side; side SET_TO settings->cutter_radius_compensation; cx SET_TO settings->current_x; cy SET_TO settings->current_y; radius SET_TO (settings->tool_table[settings->tool_table_index].diameter)/2.0; if (radius <= 0.0) ERROR_MACRO(_interpreter_linetext, name, "Bad tool radius value with cutter radius comp"); distance SET_TO hypot((px - cx), (py -cy)); if ((side ISNT LEFT) AND (side ISNT RIGHT)) BUG_MACRO(name, "Side fails to be right or left in convert_straight_comp1"); else if (distance <= radius) ERROR_MACRO(_interpreter_linetext, name, "Cutter gouging with cutter radius comp"); theta SET_TO acos(radius/distance); alpha SET_TO (side IS LEFT) ? (atan2((cy - py), (cx - px)) - theta) : (atan2((cy - py), (cx - px)) + theta); cx SET_TO (px + (radius * cos(alpha))); /* reset to end location */ cy SET_TO (py + (radius * sin(alpha))); STRAIGHT_FEED (cx, cy, end_z); settings->current_x SET_TO cx; settings->current_y SET_TO cy; settings->program_x SET_TO px; settings->program_y SET_TO py; return RS274NGC_OK; }

int convert_straight_comp2 (  setup_pointer    settings, double    program_end_x, double    program_end_y, double    end_z )

Definition at line 3193 of file rs274ngc.cc. { static char name[] SET_TO "convert_straight_comp2"; double radius; double cx, cy; /* actual end point */ double dx, dy; /* end of added arc, if needed */ double start_x, start_y; /* programmed beginning point */ double theta; double alpha; double beta; double gamma; /* small angle in radians for testing corners */ double small SET_TO TOLERANCE_CONCAVE_CORNER; int side; side SET_TO settings->cutter_radius_compensation; start_x SET_TO settings->program_x; start_y SET_TO settings->program_y; if ((start_x IS program_end_x) AND (start_y IS program_end_y)) { STRAIGHT_FEED(settings->current_x, settings->current_y, end_z); return RS274NGC_OK; } radius SET_TO (settings->tool_table[settings->tool_table_index].diameter)/2.0; if (radius <= 0.0) ERROR_MACRO(_interpreter_linetext, name, "Bad tool radius value with cutter radius comp"); theta SET_TO atan2(settings->current_y - start_y, settings->current_x - start_x); alpha SET_TO atan2(program_end_y - start_y, program_end_x - start_x); if (side IS LEFT) { if (theta < alpha) theta SET_TO (theta + TWO_PI); beta SET_TO ((theta - alpha) - PI2); gamma SET_TO PI2; } else if (side IS RIGHT) { if (alpha < theta) alpha SET_TO (alpha + TWO_PI); beta SET_TO ((alpha - theta) - PI2); gamma SET_TO -PI2; } else BUG_MACRO(name, "Side fails to be right or left in convert_straight_comp2"); cx SET_TO (program_end_x + (radius * cos(alpha + gamma))); cy SET_TO (program_end_y + (radius * sin(alpha + gamma))); dx SET_TO (start_x + (radius * cos(alpha + gamma))); dy SET_TO (start_y + (radius * sin(alpha + gamma))); if ((beta < -small) OR (beta > (PI + small))) ERROR_MACRO(_interpreter_linetext, name, "Cannot have concave corner with cutter radius comp"); else if (beta > small) /* ARC NEEDED */ { ARC_FEED(dx, dy, start_x, start_y, (side IS LEFT) ? -1 : 1, end_z); STRAIGHT_FEED (cx, cy, end_z); } else STRAIGHT_FEED (cx, cy, end_z); settings->current_x SET_TO cx; settings->current_y SET_TO cy; settings->program_x SET_TO program_end_x; settings->program_y SET_TO program_end_y; return RS274NGC_OK; }

int convert_tool_change (  block_pointer    block, setup_pointer    settings )

Definition at line 6458 of file rs274ngc.cc. { static char name[] SET_TO "convert_tool_change"; CHANGE_TOOL(settings->selected_tool_slot); settings->current_slot SET_TO settings->selected_tool_slot; settings->spindle_turning SET_TO CANON_STOPPED; return RS274NGC_OK; }

int convert_tool_length_offset (  int    g_code, block_pointer    block, setup_pointer    settings )

Definition at line 6503 of file rs274ngc.cc. { static char name[] SET_TO "convert_tool_length_offset"; int index; double offset; if (g_code IS G_49) { USE_TOOL_LENGTH_OFFSET(0.0); settings->current_z SET_TO (settings->current_z + settings->tool_length_offset); settings->tool_length_offset SET_TO 0.0; settings->length_offset_index SET_TO 0; } else if (g_code IS G_43) { index SET_TO block->h_number; if (index IS -1) ERROR_MACRO(_interpreter_linetext, name, "Offset index missing"); else if (index > GET_EXTERNAL_TOOL_MAX()) ERROR_MACRO(_interpreter_linetext, name, "Tool index out of bounds"); else { offset SET_TO settings->tool_table[index].length; USE_TOOL_LENGTH_OFFSET(offset); settings->current_z SET_TO (settings->current_z + settings->tool_length_offset - offset); settings->tool_length_offset SET_TO offset; settings->length_offset_index SET_TO index; } } else BUG_MACRO(name, "Code is not G43 or G49 in convert_tool_length_offset"); return RS274NGC_OK; }

int convert_tool_select (  block_pointer    block, setup_pointer    settings )

Definition at line 7406 of file rs274ngc.cc. { static char name[] SET_TO "convert_tool_select"; if (block->t_number > GET_EXTERNAL_TOOL_MAX()) ERROR_MACRO(_interpreter_linetext, name, "Selected tool slot number too large"); SELECT_TOOL(block->t_number); settings->selected_tool_slot SET_TO block->t_number; return RS274NGC_OK; }

int execute_binary1 (  double *    left, int    operation, double *    right )

Definition at line 607 of file rs274ngc.cc. { static char name[] SET_TO "execute_binary1"; switch (operation) { case DIVIDED_BY: if (*right IS 0.0) ERROR_MACRO(_interpreter_linetext, name, "Attempt to divide by zero"); else { *left SET_TO (*left / *right); return RS274NGC_OK; } case MODULO: /* always calculates a positive answer */ *left SET_TO fmod(*left, *right); if (*left < 0.0) { *left SET_TO (*left + fabs(*right)); } return RS274NGC_OK; case POWER: if ((*left < 0.0) AND (floor(*right) ISNT *right)) ERROR_MACRO(_interpreter_linetext, name, "Cannot raise negative number to non-integer power"); *left SET_TO pow(*left, *right); return RS274NGC_OK; case TIMES: *left SET_TO (*left * *right); return RS274NGC_OK; default: BUG_MACRO(name, "Unknown operation in execute_binary1"); } }

int execute_binary2 (  double *    left, int    operation, double *    right )

Definition at line 666 of file rs274ngc.cc. { static char name[] SET_TO "execute_binary2"; switch (operation) { case AND2: *left SET_TO ((*left IS 0.0) OR (*right IS 0.0)) ? 0.0 : 1.0; return RS274NGC_OK; case EXCLUSIVE_OR: *left SET_TO (((*left IS 0.0) AND (*right ISNT 0.0)) OR ((*left ISNT 0.0) AND (*right IS 0.0))) ? 1.0 : 0.0; return RS274NGC_OK; case MINUS: *left SET_TO (*left - *right); return RS274NGC_OK; case NON_EXCLUSIVE_OR: *left SET_TO ((*left ISNT 0.0) OR (*right ISNT 0.0)) ? 1.0 : 0.0; return RS274NGC_OK; case PLUS: *left SET_TO (*left + *right); return RS274NGC_OK; default: BUG_MACRO(name, "Unknown operation in execute_binary2"); } }

int execute_block (  block_pointer    block, setup_pointer    settings, int    line_number )

Definition at line 7743 of file rs274ngc.cc. { static char name[] SET_TO "execute_block"; if (block->comment[0] ISNT 0) { if (convert_comment(block->comment) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } if (block->g_modes[5] ISNT -1) { if (convert_feed_mode(block->g_modes[5], block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } if (block->f_number > -1.0) { if (settings->feed_mode IS INVERSE_TIME); /* handle elsewhere */ else if (convert_feed_rate(block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } if (block->s_number > -1.0) { if (convert_speed(block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } if (block->t_number ISNT -1) { if (convert_tool_select(block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } if (convert_m(block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); if (convert_g(block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); if (block->m_modes[4] ISNT -1) /* converts m0, m1, m2, m30, or m60 */ { if (convert_stop(block, settings) IS RS274NGC_EXIT) return RS274NGC_EXIT; } if (settings->probe_flag IS ON) return RS274NGC_EXECUTE_FINISH; else return RS274NGC_OK; }

int execute_unary (  double *    double_ptr, int    operation )

Definition at line 720 of file rs274ngc.cc. { static char name[] SET_TO "execute_unary"; switch (operation) { case ABS: if (*double_ptr < 0.0) *double_ptr SET_TO (-1.0 * *double_ptr); return RS274NGC_OK; case ACOS: if ((*double_ptr < -1.0) OR (*double_ptr > 1.0)) ERROR_MACRO(_interpreter_linetext, name, "Argument to acos out of range"); else { *double_ptr SET_TO acos(*double_ptr); *double_ptr SET_TO ((*double_ptr * 180.0)/ PI); return RS274NGC_OK; } case ASIN: if ((*double_ptr < -1.0) OR (*double_ptr > 1.0)) ERROR_MACRO(_interpreter_linetext, name, "Argument to asin out of range"); else { *double_ptr SET_TO asin(*double_ptr); *double_ptr SET_TO ((*double_ptr * 180.0)/ PI); return RS274NGC_OK; } case COS: *double_ptr SET_TO cos((*double_ptr * PI)/180.0); return RS274NGC_OK; case EXP: *double_ptr SET_TO exp(*double_ptr); return RS274NGC_OK; case FIX: *double_ptr SET_TO floor(*double_ptr); return RS274NGC_OK; case FUP: *double_ptr SET_TO ceil(*double_ptr); return RS274NGC_OK; case LN: if (*double_ptr <= 0.0) ERROR_MACRO(_interpreter_linetext, name, "Zero or negative argument to ln"); else { *double_ptr SET_TO log(*double_ptr); return RS274NGC_OK; } case ROUND: *double_ptr SET_TO (double) ((int) (*double_ptr + ((*double_ptr < 0.0) ? -0.5 : 0.5))); return RS274NGC_OK; case SIN: *double_ptr SET_TO sin((*double_ptr * PI)/180.0); return RS274NGC_OK; case SQRT: if (*double_ptr < 0.0) ERROR_MACRO(_interpreter_linetext, name, "Negative argument to sqrt"); else { *double_ptr SET_TO sqrt(*double_ptr); return RS274NGC_OK; } case TAN: *double_ptr SET_TO tan((*double_ptr * PI)/180.0); return RS274NGC_OK; default: BUG_MACRO(name, "Unknown operation in execute_unary"); } }

int init_block (  block_pointer    block )

Definition at line 7458 of file rs274ngc.cc. { int n; block->comment[0] SET_TO 0; block->d_number SET_TO -1; block->f_number SET_TO -1.0; block->g_count SET_TO 0; for (n SET_TO 0; n < 14; n++) { block->g_modes[n] SET_TO -1; } block->h_number SET_TO -1; block->i_flag SET_TO OFF; block->j_flag SET_TO OFF; block->k_flag SET_TO OFF; block->l_number SET_TO -1; block->line_number SET_TO -1; block->motion_to_be SET_TO -1; block->m_count SET_TO 0; for (n SET_TO 0; n < 10; n++) { block->m_modes[n] SET_TO -1; } block->p_number SET_TO -1.0; block->q_number SET_TO -1.0; block->r_flag SET_TO OFF; block->s_number SET_TO -1.0; block->t_number SET_TO -1; block->x_flag SET_TO OFF; block->y_flag SET_TO OFF; block->z_flag SET_TO OFF; return RS274NGC_OK; }

int read_atan (  char *    line, int *    counter, double *    double_ptr, double *    parameters )

Definition at line 826 of file rs274ngc.cc. : line of RS274/NGC code being processed */ int * counter, /* pointer to a counter for position on line */ double * double_ptr, /* pointer to double to be read */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_atan"; double argument2; if (line [*counter] ISNT '/') ERROR_MACRO(_interpreter_linetext, name, "Slash missing"); *counter SET_TO (*counter + 1); if(line[*counter] ISNT '[') ERROR_MACRO(_interpreter_linetext, name, "Left bracket missing after slash with atan operator"); if (read_real_expression (line, counter, &argument2, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); *double_ptr SET_TO atan2(*double_ptr, argument2); /* value in radians */ *double_ptr SET_TO ((*double_ptr * 180.0)/PI); /* convert to degrees */ return RS274NGC_OK; }

int read_comment (  char *    line, int *    counter, block_pointer    block, double *    parameters )

Definition at line 4379 of file rs274ngc.cc. : line of RS274 code being processed */ int * counter, /* pointer to a counter for position on the line */ block_pointer block, /* pointer to a block being filled from the line */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_comment"; int n; if (line[*counter] ISNT '(') BUG_MACRO(name, "Read_comment should not have been called"); (*counter)++; for (n SET_TO 0; line[*counter] ISNT ')' ; (*counter)++, n++) { block->comment[n] SET_TO line[*counter]; } block->comment[n] SET_TO 0; (*counter)++; return RS274NGC_OK; }

int read_d (  char *    line, int *    counter, block_pointer    block, double *    parameters )

Definition at line 4429 of file rs274ngc.cc. : line of RS274 code being processed */ int * counter, /* pointer to a counter for position on the line */ block_pointer block, /* pointer to a block being filled from the line */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_d"; int value; if (line[*counter] ISNT 'd') BUG_MACRO(name, "Read_d should not have been called"); *counter SET_TO (*counter + 1); if (block->d_number > -1) ERROR_MACRO(_interpreter_linetext, name, "Multiple D words on one line"); else if (read_integer_value(line, counter, &value, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); else if (value < 0) ERROR_MACRO(_interpreter_linetext, name, "Negative D code used"); else { block->d_number SET_TO value; return RS274NGC_OK; } }

int read_f (  char *    line, int *    counter, block_pointer    block, double *    parameters )

Definition at line 4487 of file rs274ngc.cc. : line of RS274 code being processed */ int * counter, /* pointer to a counter for position on the line */ block_pointer block, /* pointer to a block being filled from the line */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_f"; double value; if (line[*counter] ISNT 'f') BUG_MACRO(name, "Read_f should not have been called"); *counter SET_TO (*counter + 1); if (block->f_number > -1.0) ERROR_MACRO(_interpreter_linetext, name, "Multiple F words on one line"); else if (read_real_value(line, counter, &value, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); else if (value < 0.0) ERROR_MACRO(_interpreter_linetext, name, "Negative F word found"); else { block->f_number SET_TO value; return RS274NGC_OK; } }

int read_g (  char *    line, int *    counter, block_pointer    block, double *    parameters )

Definition at line 4563 of file rs274ngc.cc. : line of RS274/NGC code being processed */ int * counter, /* pointer to a counter for position on the line */ block_pointer block, /* pointer to a block being filled from the line */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_g"; double value_read; int value; int mode; if (line[*counter] ISNT 'g') BUG_MACRO(name, "Read_g should not have been called"); *counter SET_TO (*counter + 1); if (read_real_value(line, counter, &value_read, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); value_read SET_TO (10.0 * value_read); value SET_TO (int)floor(value_read); if ((value_read - value) > 0.999) value SET_TO (int)ceil(value_read); else if ((value_read - value) > 0.001) ERROR_MACRO(_interpreter_linetext, name,"G code out of range"); if (value > 999) ERROR_MACRO(_interpreter_linetext, name, "G code out of range"); else if (value < 0) ERROR_MACRO(_interpreter_linetext, name, "Negative G code used"); mode SET_TO gees[value]; if (mode IS -1) ERROR_MACRO(_interpreter_linetext, name, "Unknown G code used"); else if (block->g_modes[mode] ISNT -1) ERROR_MACRO(_interpreter_linetext, name, "Two G codes used from same modal group"); else { block->g_modes[mode] SET_TO value; block->g_count++; return RS274NGC_OK; } }

int read_i (  char *    line, int *    counter, block_pointer    block, double *    parameters )

Definition at line 4639 of file rs274ngc.cc. : line of RS274 code being processed */ int * counter, /* pointer to a counter for position on the line */ block_pointer block, /* pointer to a block being filled from the line */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_i"; double value; if (line[*counter] ISNT 'i') BUG_MACRO(name, "Read_i should not have been called"); *counter SET_TO (*counter + 1); if (block->i_flag ISNT OFF) ERROR_MACRO(_interpreter_linetext, name, "Multiple I words on one line"); else if (read_real_value(line, counter, &value, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); else { block->i_flag SET_TO ON; block->i_number SET_TO value; return RS274NGC_OK; } }

int read_integer_unsigned (  char *    line, int *    counter, int *    integer_ptr )

Definition at line 3291 of file rs274ngc.cc. : line of RS274 code being processed */ int * counter, /* pointer to a counter for position on the line */ int * integer_ptr) /* pointer to the value being read */ { static char name[] SET_TO "read_integer_unsigned"; int n; char c; for (n SET_TO *counter; ; n++) { c SET_TO line[n]; if ((c < 48) OR (c > 57)) break; } if (n IS *counter) ERROR_MACRO(_interpreter_linetext, name, "Bad format unsigned integer"); if (sscanf(line + *counter, "%d", integer_ptr) IS 0) BUG_MACRO(name, "Sscanf failure in read_integer_unsigned"); else { *counter SET_TO n; return RS274NGC_OK; } }

int read_integer_value (  char *    line, int *    counter, int *    integer_ptr, double *    parameters )

Definition at line 884 of file rs274ngc.cc. : line of RS274/NGC code being processed */ int * counter, /* pointer to a counter for position on the line */ int * integer_ptr, /* pointer to the value being read */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_integer_value"; double float_value; if (read_real_value(line, counter, &float_value, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); *integer_ptr SET_TO (int)floor(float_value); if ((float_value - *integer_ptr) > 0.9999) { *integer_ptr SET_TO (int)ceil(float_value); } else if ((float_value - *integer_ptr) > 0.0001) ERROR_MACRO(_interpreter_linetext, name, "Non-integer value for integer"); return RS274NGC_OK; }

int read_items (  block_pointer    block, char *    line, double *    parameters )

Definition at line 7511 of file rs274ngc.cc. : line of RS274/NGC code being processed */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_items"; int counter; int length; length SET_TO strlen(line); counter SET_TO 0; if (line[counter] IS '/') counter++; if (line[counter] IS 'n') { if (read_line_number(line, &counter, block) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } for ( ; counter < length; ) { if (read_one_item (line, &counter, block, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); } return RS274NGC_OK; }

int read_j (  char *    line, int *    counter, block_pointer    block, double *    parameters )

Definition at line 4697 of file rs274ngc.cc. : line of RS274 code being processed */ int * counter, /* pointer to a counter for position on the line */ block_pointer block, /* pointer to a block being filled from the line */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_j"; double value; if (line[*counter] ISNT 'j') BUG_MACRO(name, "Read_j should not have been called"); *counter SET_TO (*counter + 1); if (block->j_flag ISNT OFF) ERROR_MACRO(_interpreter_linetext, name, "Multiple J words on one line"); else if (read_real_value(line, counter, &value, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); else { block->j_flag SET_TO ON; block->j_number SET_TO value; return RS274NGC_OK; } }

int read_k (  char *    line, int *    counter, block_pointer    block, double *    parameters )

Definition at line 4755 of file rs274ngc.cc. : line of RS274 code being processed */ int * counter, /* pointer to a counter for position on the line */ block_pointer block, /* pointer to a block being filled from the line */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_k"; double value; if (line[*counter] ISNT 'k') BUG_MACRO(name, "Read_k should not have been called"); *counter SET_TO (*counter + 1); if (block->k_flag ISNT OFF) ERROR_MACRO(_interpreter_linetext, name, "Multiple K words on one line"); else if (read_real_value(line, counter, &value, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); else { block->k_flag SET_TO ON; block->k_number SET_TO value; return RS274NGC_OK; } }

int read_l (  char *    line, int *    counter, block_pointer    block, double *    parameters )

Definition at line 4811 of file rs274ngc.cc. : line of RS274/NGC code being processed */ int * counter, /* pointer to a counter for position on the line */ block_pointer block, /* pointer to a block being filled from the line */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_l"; int value; if (line[*counter] ISNT 'l') BUG_MACRO(name, "Read_l should not have been called"); *counter SET_TO (*counter + 1); if (block->l_number > -1) ERROR_MACRO(_interpreter_linetext, name, "Multiple L words on one line"); else if (read_integer_value(line, counter, &value, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); else if (value < 0) ERROR_MACRO(_interpreter_linetext, name, "Negative L word used"); else { block->l_number SET_TO value; return RS274NGC_OK; } }

int read_line (  char *    line, block_pointer    block, setup_pointer    settings )

Definition at line 7810 of file rs274ngc.cc. Referenced by rs274ngc_read(). { static char name[] SET_TO "read_line"; if (init_block (block) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); if (read_items(block, line, settings->parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); if (utility_enhance_block(block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); if (check_items (block, settings) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); return RS274NGC_OK; }

int read_line_number (  char *    line, int *    counter, block_pointer    block )

Definition at line 6569 of file rs274ngc.cc. : line of RS274 code being processed */ int * counter, /* pointer to a counter for position on the line */ block_pointer block) /* pointer to a block being filled from the line */ { static char name[] SET_TO "read_line_number"; int value; if (line[*counter] ISNT 'n') BUG_MACRO(name, "Read_line_number should not have been called"); *counter SET_TO (*counter + 1); if (read_integer_unsigned(line, counter, &value) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); else if (value > 99999) ERROR_MACRO(_interpreter_linetext, name, "Line number greater than 99999"); else { block->line_number SET_TO value; return RS274NGC_OK; } }

int read_m (  char *    line, int *    counter, block_pointer    block, double *    parameters )

Definition at line 4871 of file rs274ngc.cc. : line of RS274 code being processed */ int * counter, /* pointer to a counter for position on the line */ block_pointer block, /* pointer to a block being filled from the line */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_m"; int value; int mode; if (line[*counter] ISNT 'm') BUG_MACRO(name, "Read_m should not have been called"); *counter SET_TO (*counter + 1); if (read_integer_value(line, counter, &value, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); else if (value < 0) ERROR_MACRO(_interpreter_linetext, name, "Negative M code used"); else if (value > 99) ERROR_MACRO(_interpreter_linetext, name, "M code greater than 99"); mode SET_TO ems[value]; if (mode IS -1) ERROR_MACRO(_interpreter_linetext, name, "Unknown M code used"); else if (block->m_modes[mode] ISNT -1) ERROR_MACRO(_interpreter_linetext, name, "Two M codes used from same modal group"); else { block->m_modes[mode] SET_TO value; block->m_count++; return RS274NGC_OK; } }

int read_one_item (  char *    line, int *    counter, block_pointer    block, double *    parameters )

Definition at line 6634 of file rs274ngc.cc. : line of RS274/NGC code being processed */ int * counter, /* pointer to a counter for position on the line */ block_pointer block, /* pointer to a block being filled from the line */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_one_item"; _function_pointer function_pointer; switch (line[*counter]) { case 'd': function_pointer SET_TO read_d; break; case 'f': function_pointer SET_TO read_f; break; case 'g': function_pointer SET_TO read_g; break; case 'h': function_pointer SET_TO read_tool_length_offset; break; case 'i': function_pointer SET_TO read_i; break; case 'j': function_pointer SET_TO read_j; break; case 'k': function_pointer SET_TO read_k; break; case 'l': function_pointer SET_TO read_l; break; case 'm': function_pointer SET_TO read_m; break; case 'p': function_pointer SET_TO read_p; break; case 'q': function_pointer SET_TO read_q; break; case 'r': function_pointer SET_TO read_r; break; case 's': function_pointer SET_TO read_spindle_speed; break; case 't': function_pointer SET_TO read_tool; break; case 'x': function_pointer SET_TO read_x; break; case 'y': function_pointer SET_TO read_y; break; case 'z': function_pointer SET_TO read_z; break; case '(': function_pointer SET_TO read_comment; break; case '#': function_pointer SET_TO read_parameter_setting; break; default: ERROR_MACRO(_interpreter_linetext, name, "Bad character used"); } if (function_pointer (line, counter, block, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); return RS274NGC_OK; }

int read_operation (  char *    line, int *    counter, int *    operation )

Definition at line 922 of file rs274ngc.cc. : line of RS274/NGC code being processed */ int * counter, /* pointer to a counter for position on the line */ int * operation) /* pointer to operation to be read */ { static char name[] SET_TO "read_operation"; char c; c SET_TO line[*counter]; *counter SET_TO (*counter + 1); switch(c) { case '+': *operation SET_TO PLUS; return RS274NGC_OK; case '-': *operation SET_TO MINUS; return RS274NGC_OK; case '/': *operation SET_TO DIVIDED_BY; return RS274NGC_OK; case '*': if(strncmp((line + *counter), "*", 1) IS 0) { *operation SET_TO POWER; *counter SET_TO (*counter + 1); return RS274NGC_OK; } else { *operation SET_TO TIMES; return RS274NGC_OK; } case ']': *operation SET_TO RIGHT_BRACKET; return RS274NGC_OK; case 'a': if(strncmp((line + *counter), "nd", 2) IS 0) { *operation SET_TO AND2; *counter SET_TO (*counter + 2); return RS274NGC_OK; } else ERROR_MACRO(_interpreter_linetext, name, "Unknown operation name starting with A"); case 'm': if(strncmp((line + *counter), "od", 2) IS 0) { *operation SET_TO MODULO; *counter SET_TO (*counter + 2); return RS274NGC_OK; } else ERROR_MACRO(_interpreter_linetext, name, "Unknown operation name starting with M"); case 'o': if(strncmp((line + *counter), "r", 1) IS 0) { *operation SET_TO NON_EXCLUSIVE_OR; *counter SET_TO (*counter + 1); return RS274NGC_OK; } else ERROR_MACRO(_interpreter_linetext, name, "Unknown operation name starting with O"); case 'x': if(strncmp((line + *counter), "or", 2) IS 0) { *operation SET_TO EXCLUSIVE_OR; *counter SET_TO (*counter + 2); return RS274NGC_OK; } else ERROR_MACRO(_interpreter_linetext, name, "Unknown operation name starting with X"); case 0: ERROR_MACRO(_interpreter_linetext, name, "Unclosed expression"); default: ERROR_MACRO(_interpreter_linetext, name, "Unknown operation"); } }

int read_operation_unary (  char *    line, int *    counter, int *    operation )

Definition at line 1023 of file rs274ngc.cc. : line of RS274/NGC code being processed */ int * counter, /* pointer to a counter for position on the line */ int * operation) /* pointer to operation to be read */ { static char name[] SET_TO "read_operation_unary"; char c; c SET_TO line[*counter]; *counter SET_TO (*counter + 1); switch (c) { case 'a': if(strncmp((line + *counter), "bs", 2) IS 0) { *operation SET_TO ABS; *counter SET_TO (*counter + 2); return RS274NGC_OK; } else if(strncmp((line + *counter), "cos", 3) IS 0) { *operation SET_TO ACOS; *counter SET_TO (*counter + 3); return RS274NGC_OK; } else if(strncmp((line + *counter), "sin", 3) IS 0) { *operation SET_TO ASIN; *counter SET_TO (*counter + 3); return RS274NGC_OK; } else if(strncmp((line + *counter), "tan", 3) IS 0) { *operation SET_TO ATAN; *counter SET_TO (*counter + 3); return RS274NGC_OK; } else ERROR_MACRO(_interpreter_linetext, name, "Unknown word starting with A"); case 'c': if(strncmp((line + *counter), "os", 2) IS 0) { *operation SET_TO COS; *counter SET_TO (*counter + 2); return RS274NGC_OK; } else ERROR_MACRO(_interpreter_linetext, name, "Unknown word starting with C"); case 'e': if(strncmp((line + *counter), "xp", 2) IS 0) { *operation SET_TO EXP; *counter SET_TO (*counter + 2); return RS274NGC_OK; } else ERROR_MACRO(_interpreter_linetext, name, "Unknown word starting with E"); case 'f': if(strncmp((line + *counter), "ix", 2) IS 0) { *operation SET_TO FIX; *counter SET_TO (*counter + 2); return RS274NGC_OK; } else if(strncmp((line + *counter), "up", 2) IS 0) { *operation SET_TO FUP; *counter SET_TO (*counter + 2); return RS274NGC_OK; } else ERROR_MACRO(_interpreter_linetext, name, "Unknown word starting with F"); case 'l': if(strncmp((line + *counter), "n", 1) IS 0) { *operation SET_TO LN; *counter SET_TO (*counter + 1); return RS274NGC_OK; } else ERROR_MACRO(_interpreter_linetext, name, "Unknown word starting with L"); case 'r': if(strncmp((line + *counter), "ound", 4) IS 0) { *operation SET_TO ROUND; *counter SET_TO (*counter + 4); return RS274NGC_OK; } else ERROR_MACRO(_interpreter_linetext, name, "Unknown word starting with R"); case 's': if(strncmp((line + *counter), "in", 2) IS 0) { *operation SET_TO SIN; *counter SET_TO (*counter + 2); return RS274NGC_OK; } else if(strncmp((line + *counter), "qrt", 3) IS 0) { *operation SET_TO SQRT; *counter SET_TO (*counter + 3); return RS274NGC_OK; } else ERROR_MACRO(_interpreter_linetext, name, "Unknown word starting with S"); case 't': if(strncmp((line + *counter), "an", 2) IS 0) { *operation SET_TO TAN; *counter SET_TO (*counter + 2); return RS274NGC_OK; } else ERROR_MACRO(_interpreter_linetext, name, "Unknown word starting with T"); default: ERROR_MACRO(_interpreter_linetext, name, "Unknown word where unary operation could be"); } }

int read_p (  char *    line, int *    counter, block_pointer    block, double *    parameters )

Definition at line 4938 of file rs274ngc.cc. : line of RS274/NGC code being processed */ int * counter, /* pointer to a counter for position on the line */ block_pointer block, /* pointer to a block being filled from the line */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_p"; double value; if (line[*counter] ISNT 'p') BUG_MACRO(name, "Read_p should not have been called"); *counter SET_TO (*counter + 1); if (block->p_number > -1.0) ERROR_MACRO(_interpreter_linetext, name, "Multiple P words on one line"); else if (read_real_value(line, counter, &value, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); else if (value < 0.0) ERROR_MACRO(_interpreter_linetext, name, "Negative P value used"); else { block->p_number SET_TO value; return RS274NGC_OK; } }

int read_parameter (  char *    line, int *    counter, double *    double_ptr, double *    parameters )

Definition at line 1523 of file rs274ngc.cc. : line of RS274/NGC code being processed */ int * counter, /* pointer to a counter for position on the line */ double * double_ptr, /* pointer to double to be read */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_parameter"; int index; if (line[*counter] ISNT '#') BUG_MACRO(name, "Read_parameter should not have been called"); *counter SET_TO (*counter + 1); if (read_integer_value(line, counter, &index, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); else if ((index < 1) OR (index >= RS274NGC_MAX_PARAMETERS)) ERROR_MACRO(_interpreter_linetext, name, "Parameter number out of range"); else { *double_ptr SET_TO parameters[index]; return RS274NGC_OK; } }

int read_parameter_setting (  char *    line, int *    counter, block_pointer    block, double *    parameters )

Definition at line 5015 of file rs274ngc.cc. : line of RS274/NGC code being processed */ int * counter, /* pointer to a counter for position on the line */ block_pointer block, /* pointer to a block being filled from the line */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_parameter_setting"; int index; double value; if (line[*counter] ISNT '#') BUG_MACRO(name, "Read_parameter_setting should not have been called"); *counter SET_TO (*counter + 1); if (read_integer_value(line, counter, &index, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); else if ((index < 1) OR (index >= RS274NGC_MAX_PARAMETERS)) ERROR_MACRO(_interpreter_linetext, name, "Parameter number out of range"); else if (line[*counter] ISNT '=') ERROR_MACRO(_interpreter_linetext, name, "Equal sign missing in parameter setting"); *counter SET_TO (*counter + 1); if (read_real_value(line, counter, &value, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); else { parameters[index] SET_TO value; return RS274NGC_OK; } }

int read_q (  char *    line, int *    counter, block_pointer    block, double *    parameters )

Definition at line 5072 of file rs274ngc.cc. : line of RS274/NGC code being processed */ int * counter, /* pointer to a counter for position on the line */ block_pointer block, /* pointer to a block being filled from the line */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_q"; double value; if (line[*counter] ISNT 'q') BUG_MACRO(name, "Read_q should not have been called"); *counter SET_TO (*counter + 1); if (block->q_number > -1.0) ERROR_MACRO(_interpreter_linetext, name, "Multiple Q words on one line"); else if (read_real_value(line, counter, &value, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); else if (value < 0.0) ERROR_MACRO(_interpreter_linetext, name, "Negative Q value used"); else { block->q_number SET_TO value; return RS274NGC_OK; } }

int read_r (  char *    line, int *    counter, block_pointer    block, double *    parameters )

Definition at line 5130 of file rs274ngc.cc. : line of RS274 code being processed */ int * counter, /* pointer to a counter for position on the line */ block_pointer block, /* pointer to a block being filled from the line */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_r"; double value; if (line[*counter] ISNT 'r') BUG_MACRO(name, "Read_r should not have been called"); *counter SET_TO (*counter + 1); if (block->r_flag ISNT OFF) ERROR_MACRO(_interpreter_linetext, name, "Multiple R words on one line"); else if (read_real_value(line, counter, &value, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); else { block->r_flag SET_TO ON; block->r_number SET_TO value; return RS274NGC_OK; } }

int read_real_expression (  char *    line, int *    counter, double *    value, double *    parameters )

Definition at line 1853 of file rs274ngc.cc. : line of RS274/NGC code being processed */ int * counter, /* pointer to a counter for position on the line */ double * hold2, /* pointer to double to be read */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_real_expression"; double value; double hold1; int waiting_operation; /* always a bop2 */ int last_operation; int next_operation; if (line[*counter] ISNT '[') BUG_MACRO(name, "Read_real_expression should not have been called"); *counter SET_TO (*counter + 1); waiting_operation SET_TO PLUS; *hold2 SET_TO 0.0; last_operation SET_TO PLUS; for (;;) { if (read_real_value(line, counter, &value, parameters) ISNT RS274NGC_OK) ERROR_MACRO_PASS(name); if (read_operation(line, counter, &next_operation) ISNT RS274NGC_OK) ERROR_MACRO_PASS(name); if (next_operation IS RIGHT_BRACKET) { if (last_operation < AND2) { if (execute_binary1(&hold1,last_operation, &value) ISNT RS274NGC_OK) ERROR_MACRO_PASS(name); if (execute_binary2(hold2, waiting_operation, &hold1) ISNT RS274NGC_OK) ERROR_MACRO_PASS(name); } else if (execute_binary2(hold2, waiting_operation, &value) ISNT RS274NGC_OK) ERROR_MACRO_PASS(name); else {} return RS274NGC_OK; } else if (next_operation < AND2) /* next operation is a bop1 */ { if (last_operation >= AND2) { hold1 SET_TO value; } else if (execute_binary1(&hold1, last_operation, &value) ISNT RS274NGC_OK) ERROR_MACRO_PASS(name); } else /* next operation is a bop2 */ { if (last_operation < AND2) { if (execute_binary1(&hold1, last_operation, &value) ISNT RS274NGC_OK) ERROR_MACRO_PASS(name); if (execute_binary2(hold2, waiting_operation, &hold1) ISNT RS274NGC_OK) ERROR_MACRO_PASS(name); } else { if (execute_binary2(hold2, waiting_operation, &value) ISNT RS274NGC_OK) ERROR_MACRO_PASS(name); } waiting_operation SET_TO next_operation; } last_operation SET_TO next_operation; } }

int read_real_number (  char *    line, int *    counter, double *    double_ptr )

Definition at line 1965 of file rs274ngc.cc. : line of RS274/NGC code being processed */ int * counter, /* pointer to a counter for position on the line */ double * double_ptr) /* pointer to double to be read */ { static char name[] SET_TO "read_real_number"; int n; char c; int flag_point; /* set to ON if decimal point found */ int flag_digit; /* set to ON if digit found */ n SET_TO *counter; flag_point SET_TO OFF; flag_digit SET_TO OFF; /* check first character */ c SET_TO line[n]; if (c IS '+') { *counter SET_TO (*counter + 1); /* skip plus sign */ n++; } else if (c IS '-') { n++; } else if ((c ISNT '.') AND ((c < 48) OR (c > 57))) ERROR_MACRO(_interpreter_linetext, name, "Bad number format"); /* check out rest of characters (must be digit or decimal point) */ for (; (c SET_TO line[n]) ISNT (char) NULL; n++) { if (( 47 < c) AND ( c < 58)) { flag_digit SET_TO ON; } else if (c IS '.') { if (flag_point IS OFF) { flag_point SET_TO ON; } else break; } else break; } if (flag_digit IS OFF) ERROR_MACRO(_interpreter_linetext, name, "No digits found where real number should be"); line[n] SET_TO (char) NULL; /* temporary string termination for sscanf */ if (sscanf(line + *counter, "%lf", double_ptr) IS 0) { line[n] SET_TO c; BUG_MACRO(name, "Sscanf failure in read_real_number"); } else { line[n] SET_TO c; *counter SET_TO n; return RS274NGC_OK; } }

int read_real_value (  char *    line, int *    counter, double *    double_ptr, double *    parameters )

Definition at line 3357 of file rs274ngc.cc. : line of RS274/NGC code being processed */ int * counter, /* pointer to a counter for position on the line */ double * double_ptr, /* pointer to double to be read */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_real_value"; char c; c SET_TO line[*counter]; if (c IS 0) ERROR_MACRO(_interpreter_linetext, name, "No characters found in reading real value"); else if (c IS '[') return read_real_expression (line, counter, double_ptr, parameters); else if (c IS '#') return read_parameter(line, counter, double_ptr, parameters); else if ((c >= 'a') AND (c <= 'z')) return read_unary(line, counter, double_ptr, parameters); else return read_real_number(line, counter, double_ptr); }

int read_spindle_speed (  char *    line, int *    counter, block_pointer    block, double *    parameters )

Definition at line 5186 of file rs274ngc.cc. : line of RS274 code being processed */ int * counter, /* pointer to a counter for position on the line */ block_pointer block, /* pointer to a block being filled from the line */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_spindle_speed"; double speed; if (line[*counter] ISNT 's') BUG_MACRO(name, "Read_spindle_speed should not have been called"); *counter SET_TO (*counter + 1); if (block->s_number > -1.0) ERROR_MACRO(_interpreter_linetext, name, "Multiple S word spindle speed settings on one line"); else if (read_real_value(line, counter, &speed, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); else if (speed < 0.0) ERROR_MACRO(_interpreter_linetext, name, "Negative spindle speed found"); else { block->s_number SET_TO speed; return RS274NGC_OK; } }

int read_text (  const char *    command, FILE *    inport, char *    raw_line, char *    line, int *    length, ON_OFF    block_delete )

Definition at line 7879 of file rs274ngc.cc. { static char name[] SET_TO "read_text"; char * returned_value; int len; if (command IS NULL) { returned_value SET_TO fgets(raw_line, INTERP_TEXT_SIZE, inport); // knock off CR, LF len = strlen(raw_line) - 1; // set len to index of last char while (len >= 0) { if (isspace(raw_line[len])) { raw_line[len] = 0; len--; } else { break; } } if (returned_value IS NULL) return RS274NGC_ENDFILE; else strcpy(line, raw_line); } else { strcpy(raw_line, command); strcpy(line, command); } if (close_and_downcase(line) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); if (((line[0] IS '/') AND ((block_delete IS ON) OR (line[1] IS 0))) OR (line[0] IS 0)) *length SET_TO 0; else *length SET_TO strlen(line); return RS274NGC_OK; }

int read_tool (  char *    line, int *    counter, block_pointer    block, double *    parameters )

Definition at line 5239 of file rs274ngc.cc. : line of RS274/NGC code being processed */ int * counter, /* pointer to a counter for position on the line */ block_pointer block, /* pointer to a block being filled from the line */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_tool"; int value; if (line[*counter] ISNT 't') BUG_MACRO(name, "Read_tool should not have been called"); *counter SET_TO (*counter + 1); if (block->t_number > -1) ERROR_MACRO(_interpreter_linetext, name, "Multiple T words (tool ids) on one line"); if (read_integer_value(line, counter, &value, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); else if (value < 0) ERROR_MACRO(_interpreter_linetext, name, "Negative tool id used"); else { block->t_number SET_TO value; return RS274NGC_OK; } }

int read_tool_length_offset (  char *    line, int *    counter, block_pointer    block, double *    parameters )

Definition at line 5292 of file rs274ngc.cc. : line of RS274/NGC code being processed */ int * counter, /* pointer to a counter for position on the line */ block_pointer block, /* pointer to a block being filled from the line */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_tool_length_offset"; int value; if (line[*counter] ISNT 'h') BUG_MACRO(name, "Read_tool_length_offset should not have been called"); *counter SET_TO (*counter + 1); if (block->h_number > -1) ERROR_MACRO(_interpreter_linetext, name, "Multiple tool length offsets on one line"); if (read_integer_value(line, counter, &value, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); else if (value < 0) ERROR_MACRO(_interpreter_linetext, name, "Negative tool length offset used"); else { block->h_number SET_TO value; return RS274NGC_OK; } }

int read_unary (  char *    line, int *    counter, double *    double_ptr, double *    parameters )

Definition at line 2057 of file rs274ngc.cc. : line of RS274/NGC code being processed */ int * counter, /* pointer to a counter for position on the line */ double * double_ptr, /* pointer to double to be read */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_unary"; int operation; if (read_operation_unary (line, counter, &operation) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); if (line[*counter] ISNT '[') ERROR_MACRO(_interpreter_linetext, name, "Left bracket missing after unary operation name"); if (read_real_expression (line, counter, double_ptr, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); if (operation IS ATAN) return read_atan(line, counter, double_ptr, parameters); else return execute_unary (double_ptr, operation); }

int read_x (  char *    line, int *    counter, block_pointer    block, double *    parameters )

Definition at line 5349 of file rs274ngc.cc. : line of RS274 code being processed */ int * counter, /* pointer to a counter for position on the line */ block_pointer block, /* pointer to a block being filled from the line */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_x"; double value; if (line[*counter] ISNT 'x') BUG_MACRO(name, "Read_x should not have been called"); *counter SET_TO (*counter + 1); if (block->x_flag ISNT OFF) ERROR_MACRO(_interpreter_linetext, name, "Multiple X words on one line"); else if (read_real_value(line, counter, &value, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); else { block->x_flag SET_TO ON; block->x_number SET_TO value; return RS274NGC_OK; } }

int read_y (  char *    line, int *    counter, block_pointer    block, double *    parameters )

Definition at line 5407 of file rs274ngc.cc. : line of RS274 code being processed */ int * counter, /* pointer to a counter for position on the line */ block_pointer block, /* pointer to a block being filled from the line */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_y"; double value; if (line[*counter] ISNT 'y') BUG_MACRO(name, "Read_y should not have been called"); *counter SET_TO (*counter + 1); if (block->y_flag ISNT OFF) ERROR_MACRO(_interpreter_linetext, name, "Multiple Y words on one line"); else if (read_real_value(line, counter, &value, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); else { block->y_flag SET_TO ON; block->y_number SET_TO value; return RS274NGC_OK; } }

int read_z (  char *    line, int *    counter, block_pointer    block, double *    parameters )

Definition at line 5465 of file rs274ngc.cc. : line of RS274 code being processed */ int * counter, /* pointer to a counter for position on the line */ block_pointer block, /* pointer to a block being filled from the line */ double * parameters) /* array of system parameters */ { static char name[] SET_TO "read_z"; double value; if (line[*counter] ISNT 'z') BUG_MACRO(name, "Read_z should not have been called"); *counter SET_TO (*counter + 1); if (block->z_flag ISNT OFF) ERROR_MACRO(_interpreter_linetext, name, "Multiple Z words on one line"); else if (read_real_value(line, counter, &value, parameters) IS RS274NGC_ERROR) ERROR_MACRO_PASS(name); else { block->z_flag SET_TO ON; block->z_number SET_TO value; return RS274NGC_OK; } }

int rs274ngc_active_g_codes (  int *    codes )

Definition at line 8832 of file rs274ngc.cc. { int t; for (t = 0; t < RS274NGC_ACTIVE_G_CODES; t++) { codes[t] = _interpreter_active_g_codes[t]; } return RS274NGC_OK; }

int rs274ngc_active_m_codes (  int *    codes )

Definition at line 8856 of file rs274ngc.cc. { int t; for (t = 0; t < RS274NGC_ACTIVE_M_CODES; t++) { codes[t] = _interpreter_active_m_codes[t]; } return RS274NGC_OK; }

int rs274ngc_active_settings (  double *    settings )

Definition at line 8880 of file rs274ngc.cc. { int t; for (t = 0; t < RS274NGC_ACTIVE_SETTINGS; t++) { settings[t] = _interpreter_active_settings[t]; } return RS274NGC_OK; }

int rs274ngc_close (    )

Definition at line 8096 of file rs274ngc.cc. Referenced by emcTaskPlanClose(), and main(). { if (_interpreter_fp ISNT NULL) { fclose(_interpreter_fp); _interpreter_fp SET_TO NULL; } _interpreter_filename[0] SET_TO 0; rs274ngc_reset(); return RS274NGC_OK; }

const char* rs274ngc_command (    )

Definition at line 8029 of file rs274ngc.cc. Referenced by emcTaskPlanCommand(). { return _interpreter_linetext; }

int rs274ngc_execute (  const char *    command = 0 )

Definition at line 8150 of file rs274ngc.cc. : line of NC code to execute (may be null) */ { static char name[] SET_TO "rs274ngc_execute"; if (_interpreter_settings.probe_flag IS ON) { if (IS_EXTERNAL_QUEUE_EMPTY() IS 0) { /* rs274ngc_reset(); */ ERR_MACRO(_interpreter_linetext, name, "Queue is not empty after probing"); } set_probe_data(&_interpreter_settings); _interpreter_settings.probe_flag SET_TO OFF; } if (command ISNT NULL) { if(strlen(command) > (INTERP_TEXT_SIZE -1)) ERR_MACRO(_interpreter_linetext, name, "Command too long"); else if (read_text (command, NULL, _interpreter_linetext, _interpreter_blocktext, &_interpreter_length, _interpreter_settings.block_delete) ISNT RS274NGC_OK) ERR_MACRO_PASS(name); else if (_interpreter_length IS 0) /* blank or block-deleted command */ return RS274NGC_OK; else if (read_line(_interpreter_blocktext, &_interpreter_block, &_interpreter_settings) IS RS274NGC_ERROR) ERR_MACRO_PASS(name); _textline++; } if (_interpreter_length IS 0) /* blank or block deleted line from file */ { write_g_codes((block *) NULL, &_interpreter_settings, _textline, &_interpreter_active_g_codes[0]); write_m_codes((block *) NULL, &_interpreter_settings, _textline, &_interpreter_active_m_codes[0]); write_settings((block *) NULL, &_interpreter_settings, _textline, &_interpreter_active_settings[0]); return RS274NGC_OK; } _interpreter_status SET_TO execute_block (&_interpreter_block, &_interpreter_settings, _textline); // write most recent G codes write_g_codes(&_interpreter_block, &_interpreter_settings, _textline, &_interpreter_active_g_codes[0]); write_m_codes(&_interpreter_block, &_interpreter_settings, _textline, &_interpreter_active_m_codes[0]); write_settings(&_interpreter_block, &_interpreter_settings, _textline, &_interpreter_active_settings[0]); if (_interpreter_status IS RS274NGC_EXIT) /* program over */ { if (_interpreter_fp ISNT NULL) { fclose(_interpreter_fp); _interpreter_fp SET_TO NULL; _textline SET_TO 0; _interpreter_linetext[0] SET_TO 0; } return RS274NGC_EXIT; } else if (_interpreter_status IS RS274NGC_ERROR) ERR_MACRO_PASS(name); else if (_interpreter_status IS RS274NGC_EXECUTE_FINISH) return RS274NGC_EXECUTE_FINISH; else /* satisfactory execution of a line */ return RS274NGC_OK; }

int rs274ngc_exit (    )

Definition at line 8240 of file rs274ngc.cc. Referenced by emcTaskPlanExit(), and main(). { rs274ngc_save_parameters(RS274NGC_PARAMETER_FILE, _interpreter_settings.parameters); rs274ngc_reset(); return RS274NGC_OK; }

const char* rs274ngc_file (    )

Definition at line 8049 of file rs274ngc.cc. { return _interpreter_filename; }

int rs274ngc_ini_load (  const char *    filename )

load settings from INI file. Definition at line 8791 of file rs274ngc.cc. { INIFILE inifile; const char *inistring; // open it if (-1 == inifile.open(filename)) { return -1; } if (NULL != (inistring = inifile.find("PARAMETER_FILE", "RS274NGC"))) { // found it strcpy(RS274NGC_PARAMETER_FILE, inistring); } else { // not found, leave RS274NGC_PARAMETER_FILE alone } // close it inifile.close(); return RS274NGC_OK; }

int rs274ngc_init (    )

calling interface Definition at line 8332 of file rs274ngc.cc. Referenced by emcTaskPlanInit(), and main(). { CANON_VECTOR axis_offset; CANON_VECTOR origin_point; int k; rs274ngc_reset(); INIT_CANON(); _interpreter_settings.length_units SET_TO CANON_UNITS_INCHES; USE_LENGTH_UNITS(_interpreter_settings.length_units); for (k SET_TO 5161; k < 5387; k++) { _interpreter_settings.parameters[k] SET_TO 0.0; } rs274ngc_restore_parameters( #ifdef STAND_ALONE_INTERP DEFAULT_RS274NGC_PARAMETER_FILE, #else RS274NGC_PARAMETER_FILE, #endif _interpreter_settings.parameters); // Get axis offsets from parameters axis_offset.x SET_TO _interpreter_settings.parameters[5211]; axis_offset.y SET_TO _interpreter_settings.parameters[5212]; axis_offset.z SET_TO _interpreter_settings.parameters[5213]; // Get origin from parameters for G54 default coordinate system origin_point.x SET_TO _interpreter_settings.parameters[5221]; origin_point.y SET_TO _interpreter_settings.parameters[5222]; origin_point.z SET_TO _interpreter_settings.parameters[5223]; // Set the origin offsets SET_ORIGIN_OFFSETS(origin_point.x + axis_offset.x, origin_point.y + axis_offset.y, origin_point.z + axis_offset.z); SET_FEED_REFERENCE(CANON_XYZ); _textline SET_TO 0; _interpreter_settings.axis_offset_x SET_TO 0.0; _interpreter_settings.axis_offset_y SET_TO 0.0; _interpreter_settings.axis_offset_z SET_TO 0.0; _interpreter_settings.block_delete SET_TO OFF; /*_interpreter_settings.control_mode set in rs274ngc_synch */ /*_interpreter_settings.current_slot set in rs274ngc_synch */ _interpreter_settings.current_x SET_TO 0.0; /* reset by rs274ngc_synch */ _interpreter_settings.current_y SET_TO 0.0; /* reset by rs274ngc_synch */ _interpreter_settings.current_z SET_TO 0.0; /* reset by rs274ngc_synch */ _interpreter_settings.cutter_radius_compensation SET_TO OFF; /* cycle values do not need initialization */ _interpreter_settings.distance_mode SET_TO MODE_ABSOLUTE; _interpreter_settings.feed_mode SET_TO UNITS_PER_MINUTE; _interpreter_settings.feed_override SET_TO ON; /*_interpreter_settings.feed_rate set in rs274ngc_synch */ /*_interpreter_settings.flood set in rs274ngc_synch */ _interpreter_settings.length_offset_index SET_TO 1; /*_interpreter_settings.length_units set above */ /*_interpreter_settings.mist set in rs274ngc_synch */ _interpreter_settings.motion_mode SET_TO G_1; _interpreter_settings.origin_ngc SET_TO 1; _interpreter_settings.axis_offset_x SET_TO axis_offset.x; _interpreter_settings.axis_offset_y SET_TO axis_offset.y; _interpreter_settings.axis_offset_z SET_TO axis_offset.z; _interpreter_settings.origin_offset_x SET_TO origin_point.x; _interpreter_settings.origin_offset_y SET_TO origin_point.y; _interpreter_settings.origin_offset_z SET_TO origin_point.z; /*_interpreter_settings.parameters set above */ _interpreter_settings.plane SET_TO CANON_PLANE_XY; SELECT_PLANE(_interpreter_settings.plane); _interpreter_settings.probe_flag SET_TO OFF; _interpreter_settings.program_x SET_TO UNKNOWN; /* for cutter comp */ _interpreter_settings.program_y SET_TO UNKNOWN; /* for cutter comp */ _interpreter_settings.retract_mode SET_TO R_PLANE; /*_interpreter_settings.selected_tool_slot set in rs274ngc_synch */ /*_interpreter_settings.speed set in rs274ngc_synch */ _interpreter_settings.speed_feed_mode SET_TO CANON_INDEPENDENT; _interpreter_settings.speed_override SET_TO ON; _interpreter_settings.tool_length_offset SET_TO 0.0; /*_interpreter_settings.tool_table set in rs274ngc_synch */ _interpreter_settings.tool_table_index SET_TO 1; /*_interpreter_settings.traverse_rate set in rs274ngc_synch */ write_g_codes((block_pointer)NULL, &_interpreter_settings, _textline, &_interpreter_active_g_codes[0]); write_m_codes((block_pointer)NULL, &_interpreter_settings, _textline, &_interpreter_active_m_codes[0]); write_settings((block_pointer)NULL, &_interpreter_settings, _textline, &_interpreter_active_settings[0]); // Synch rest of settings to external world rs274ngc_synch(); return RS274NGC_OK; }

int rs274ngc_line (    )

Definition at line 8075 of file rs274ngc.cc. Referenced by emcTaskPlanLine(). { return _textline; }

int rs274ngc_load_tool_table (    )

Definition at line 8599 of file rs274ngc.cc. Referenced by rs274ngc_synch(). { int t; for (t SET_TO 0; t <= CANON_TOOL_MAX; t++) { _interpreter_settings.tool_table[t] SET_TO GET_EXTERNAL_TOOL_TABLE(t); } return 0; }

int rs274ngc_open (  const char *    filename )

Definition at line 8457 of file rs274ngc.cc. : the name of the input NC-program file */ { static char name[] SET_TO "rs274ngc_open"; _interpreter_fp SET_TO fopen(filename, "r"); if (_interpreter_fp IS NULL) ERR_MACRO(_interpreter_linetext, name, "Unable to open file"); _textline SET_TO 0; strcpy(_interpreter_filename, filename); return RS274NGC_OK; }

int rs274ngc_read (    )

Definition at line 8518 of file rs274ngc.cc. Referenced by emcTaskPlanRead(), interpret_from_file(), interpret_from_keyboard(), and rs274ngc_execute(). { static char name[] SET_TO "rs274ngc_read"; int status; if (_interpreter_settings.probe_flag IS ON) { if (IS_EXTERNAL_QUEUE_EMPTY() IS 0) { /* rs274ngc_reset(); */ ERR_MACRO(_interpreter_linetext, name, "Queue is not empty after probing"); } set_probe_data(&_interpreter_settings); _interpreter_settings.probe_flag SET_TO OFF; } if (_interpreter_fp IS NULL) { if (_interpreter_status IS RS274NGC_EXIT) { /* set in call to rs274ngc_execute */ /* rs274ngc_reset(); */ return RS274NGC_EXIT; } else { /* rs274ngc_reset(); */ ERR_MACRO_PASS(name); } } /* read the line */ _textline++; status SET_TO read_text (NULL, _interpreter_fp, _interpreter_linetext, _interpreter_blocktext, &_interpreter_length, _interpreter_settings.block_delete); if ((status IS RS274NGC_ENDFILE) AND (_interpreter_block.m_modes[4] IS 1)) return RS274NGC_ENDFILE; /* m1 appeared on the preceding line */ else if (status IS RS274NGC_ENDFILE) { fclose(_interpreter_fp); _interpreter_fp SET_TO NULL; /* rs274ngc_reset(); */ ERR_MACRO(_interpreter_linetext, name, "File ended with no stopping command given"); } else if (status IS RS274NGC_ERROR) { /* rs274ngc_reset(); */ ERR_MACRO_PASS(name); } if (_interpreter_length IS 0) return RS274NGC_OK; /* parse the block */ else if (read_line(_interpreter_blocktext, &_interpreter_block, &_interpreter_settings) IS RS274NGC_ERROR) { /* rs274ngc_reset(); */ ERR_MACRO_PASS(name); } else return RS274NGC_OK; }

int rs274ngc_reset (    )

Definition at line 8001 of file rs274ngc.cc. Referenced by rs274ngc_close(), rs274ngc_exit(), and rs274ngc_init(). { _textline SET_TO 0; _interpreter_filename[0] SET_TO 0; _interpreter_linetext[0] SET_TO 0; _interpreter_blocktext[0] SET_TO 0; _interpreter_fp SET_TO NULL; _interpreter_status SET_TO 0; _interpreter_length SET_TO 0; return 0; }

int rs274ngc_restore_parameters (  const char *    filename, double    parameters[] )

restore interpreter variables from file. Definition at line 8633 of file rs274ngc.cc. { static char name[] SET_TO "rs274ngc_restore_parameters"; FILE *infp = NULL; char line[256]; int variable; double value; // open original for reading if (NULL == (infp = fopen(filename, "r"))) { ERR_MACRO(_interpreter_linetext, name, "Cannot open file"); return -1; } while (!feof(infp)) { if (NULL == fgets(line, 256, infp)) { break; } // try for a variable-value match if (2 == sscanf(line, "%d %lf", &variable, &value)) { // write it into variable array if (variable <= 0 || variable >= RS274NGC_MAX_PARAMETERS) { ERR_MACRO(_interpreter_linetext, name, "Parameter number out of range"); } else { parameters[variable] = value; } } } fclose(infp); return 0; }

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

save interpreter variables to file. Definition at line 8697 of file rs274ngc.cc. { static char name[] SET_TO "rs274ngc_save_parameters"; FILE *infp = NULL; FILE *outfp = NULL; char line[256]; int variable; double value; // rename as .bak strcpy(line, filename); strcat(line, RS274NGC_PARAMETER_FILE_BACKUP_SUFFIX); if (0 != rename(filename, line)) { ERR_MACRO(_interpreter_linetext, name, "Cannot create backup file"); return -1; } // open backup for reading if (NULL == (infp = fopen(line, "r"))) { ERR_MACRO(_interpreter_linetext, name, "Cannot open backup file"); return -1; } // open original for writing if (NULL == (outfp = fopen(filename, "w"))) { ERR_MACRO(_interpreter_linetext, name, "Cannot open variable file"); return -1; } while (!feof(infp)) { if (NULL == fgets(line, 256, infp)) { break; } // try for a variable-value match if (2 == sscanf(line, "%d %f", &variable, &value)) { // overwrite with internal variable if (variable <= 0 || variable >= RS274NGC_MAX_PARAMETERS) { ERR_MACRO(_interpreter_linetext, name, "Parameter number out of range"); } else { sprintf(line, "%d\t%f\n", variable, parameters[variable]); } } // write it out fputs(line, outfp); } fclose(infp); fclose(outfp); return 0; }

int rs274ngc_synch (    )

Definition at line 8267 of file rs274ngc.cc. Referenced by emcTaskPlanExecute(), emcTaskPlanSynch(), and rs274ngc_init(). { CANON_POSITION current_point; _interpreter_settings.current_slot SET_TO GET_EXTERNAL_TOOL(); rs274ngc_load_tool_table(); _interpreter_settings.control_mode SET_TO GET_MOTION_CONTROL_MODE(); current_point SET_TO GET_EXTERNAL_POSITION(); _interpreter_settings.current_x SET_TO current_point.x; _interpreter_settings.current_y SET_TO current_point.y; _interpreter_settings.current_z SET_TO current_point.z; _interpreter_settings.feed_rate SET_TO GET_EXTERNAL_FEED_RATE(); _interpreter_settings.flood SET_TO (GET_EXTERNAL_FLOOD() ISNT 0) ? ON : OFF; _interpreter_settings.mist SET_TO (GET_EXTERNAL_MIST() ISNT 0) ? ON : OFF; _interpreter_settings.selected_tool_slot SET_TO GET_EXTERNAL_POCKET(); _interpreter_settings.speed SET_TO GET_EXTERNAL_SPEED(); _interpreter_settings.spindle_turning SET_TO GET_EXTERNAL_SPINDLE(); _interpreter_settings.traverse_rate SET_TO GET_EXTERNAL_TRAVERSE_RATE(); return RS274NGC_OK; }

int set_probe_data (  setup_pointer    settings )

Definition at line 7946 of file rs274ngc.cc. { static char name[] SET_TO "set_probe_data"; CANON_POSITION position; CANON_POSITION probe_position; position SET_TO GET_EXTERNAL_POSITION(); settings->current_x SET_TO position.x; settings->current_y SET_TO position.y; settings->current_z SET_TO position.z; probe_position SET_TO GET_EXTERNAL_PROBE_POSITION(); settings->parameters[5061] SET_TO probe_position.x; settings->parameters[5062] SET_TO probe_position.y; settings->parameters[5063] SET_TO probe_position.z; settings->parameters[5067] SET_TO GET_EXTERNAL_PROBE_VALUE(); return RS274NGC_OK; }

int utility_enhance_block (  block_pointer    block, setup_pointer    settings )

Definition at line 7557 of file rs274ngc.cc. { static char name[] SET_TO "utility_enhance_block"; if (block->g_modes[1] ISNT -1) block->motion_to_be SET_TO block->g_modes[1]; else if ((((block->x_flag IS ON) OR (block->y_flag IS ON)) OR (block->z_flag IS ON)) AND (block->g_modes[0] IS -1)) block->motion_to_be SET_TO settings->motion_mode; return RS274NGC_OK; }

int utility_error_number (  char *    message, char *    error_array[], int    index )

Definition at line 574 of file rs274ngc.cc. : the message text */ char * error_array[], /* array of error messages */ int index) /* index to start at */ { for (;error_array[index][0] ISNT 0; index++) { if (strcmp(message, error_array[index]) IS 0) return index; } return 0; }

double utility_find_arc_length (  double    x1, double    y1, double    z1, double    center_x, double    center_y, int    turn, double    x2, double    y2, double    z2 )

Definition at line 2111 of file rs274ngc.cc. { double radius; double theta; /* amount of turn of arc */ if (turn IS 0) return 0.0; radius SET_TO hypot((center_x - x1), (center_y - y1)); theta SET_TO utility_find_turn(x1, y1, center_x, center_y, turn, x2, y2); if (z2 IS z1) return (radius * fabs(theta)); else return hypot((radius * theta), (z2 - z1)); }

int utility_find_ends (  block_pointer    block, setup_pointer    settings, double *    px, double *    py, double *    pz )

Definition at line 3396 of file rs274ngc.cc. { int mode; int middle; int comp; mode SET_TO settings->distance_mode; middle SET_TO (settings->program_x ISNT UNKNOWN); comp SET_TO (settings->cutter_radius_compensation ISNT OFF); if (block->g_modes[4] IS G_53) /* mode is absolute in this case */ { #ifdef DEBUG_EMC COMMENT("interpreter: offsets temporarily suspended"); #endif *px SET_TO (block->x_flag IS ON) ? (block->x_number - (settings->origin_offset_x + settings->axis_offset_x)) : settings->current_x; *py SET_TO (block->y_flag IS ON) ? (block->y_number - (settings->origin_offset_y + settings->axis_offset_y)) : settings->current_y; *pz SET_TO (block->z_flag IS ON) ? (block->z_number - (settings->tool_length_offset + settings->origin_offset_z + settings->axis_offset_z)) : settings->current_z; } else if (mode IS MODE_ABSOLUTE) { *px SET_TO (block->x_flag IS ON) ? block->x_number : (comp AND middle) ? settings->program_x : settings->current_x ; *py SET_TO (block->y_flag IS ON) ? block->y_number : (comp AND middle) ? settings->program_y : settings->current_y ; *pz SET_TO (block->z_flag IS ON) ? block->z_number : settings->current_z ; } else { *px SET_TO (block->x_flag IS ON) ? ((comp AND middle) ? (block->x_number + settings->program_x) : (block->x_number + settings->current_x)) : ((comp AND middle) ? settings->program_x : settings->current_x); *py SET_TO (block->y_flag IS ON) ? ((comp AND middle) ? (block->y_number + settings->program_y) : (block->y_number + settings->current_y)) : ((comp AND middle) ? settings->program_y : settings->current_y); *pz SET_TO (block->z_flag IS ON) ? (settings->current_z + block->z_number) : settings->current_z; } return RS274NGC_OK; }

double utility_find_straight_length (  double    x2, double    y2, double    z2, double    x1, double    y1, double    z1 )

Definition at line 2158 of file rs274ngc.cc. { return sqrt(pow((x2 - x1),2) + pow((y2 - y1),2) + pow((z2 - z1),2)); }

double utility_find_turn (  double    x1, double    y1, double    center_x, double    center_y, int    turn, double    x2, double    y2 )

Definition at line 1160 of file rs274ngc.cc. { double alpha; double beta; double theta; /* amount of turn of arc CCW - negative if CW */ if (turn IS 0) return 0.0; alpha SET_TO atan2((y1 - center_y), (x1 - center_x)); beta SET_TO atan2((y2 - center_y), (x2 - center_x)); if (turn > 0) { if (beta <= alpha) beta SET_TO (beta + TWO_PI); theta SET_TO ((beta - alpha) + ((turn - 1) * TWO_PI)); } else /* turn < 0 */ { if (alpha <= beta) alpha SET_TO (alpha + TWO_PI); theta SET_TO ((beta - alpha) + ((turn + 1) * TWO_PI)); } return (theta); }

int write_g_codes (  block_pointer    block, setup_pointer    settings, int    line_number, int *    gez )

Definition at line 7596 of file rs274ngc.cc. { gez[0] SET_TO line_number; /* 0 line number */ gez[1] SET_TO settings->motion_mode; /* 1 motion mode */ gez[2] SET_TO (block IS NULL) ? -1 : (block->g_modes[0] ISNT -1) ? block->g_modes[0] : /* 2 g10,g92 */ block->g_modes[4] ; /* 2 g4, g53 */ gez[3] SET_TO (settings->plane IS CANON_PLANE_XY) ? G_17 : /* 3 active plane */ (settings->plane IS CANON_PLANE_XZ) ? G_18 : G_19; gez[4] SET_TO /* 4 cut radius comp */ (settings->cutter_radius_compensation IS RIGHT) ? G_42 : (settings->cutter_radius_compensation IS LEFT) ? G_41 : G_40; gez[5] SET_TO /* 5 length units */ (settings->length_units IS CANON_UNITS_INCHES) ? G_20 : G_21; gez[6] SET_TO /* 6 distance mode */ (settings->distance_mode IS MODE_ABSOLUTE) ? G_90 : G_91; gez[7] SET_TO /* 7 feed mode */ (settings->feed_mode IS INVERSE_TIME) ? G_93 : G_94; gez[8] SET_TO /* 8 coord system */ (settings->origin_ngc < 7) ? (530 + (10 * settings->origin_ngc)) : (584 + settings->origin_ngc); gez[9] SET_TO /* 9 tool len offset */ (settings->tool_length_offset IS 0.0) ? G_49 : G_43; gez[10] SET_TO /* 10 retract mode */ (settings->retract_mode IS OLD_Z) ? G_98 : G_99; gez[11] SET_TO /* 11 control mode */ (settings->control_mode IS CANON_CONTINUOUS) ? G_64 : G_61; return RS274NGC_OK; }

int write_m_codes (  block_pointer    block, setup_pointer    settings, int    line_number, int *    ems )

Definition at line 7651 of file rs274ngc.cc. { ems[0] SET_TO line_number; /* 0 line number */ ems[1] SET_TO (block IS NULL) ? -1 : block->m_modes[4]; /* 1 stopping */ ems[2] SET_TO (settings->spindle_turning IS CANON_STOPPED) ? 5 : /* 2 spindle */ (settings->spindle_turning IS CANON_CLOCKWISE) ? 3 : 4; ems[3] SET_TO /* 3 tool change */ (block IS NULL) ? -1 : block->m_modes[6]; ems[4] SET_TO /* 4 mist */ (settings->mist IS ON) ? 7 : (settings->flood IS ON) ? -1 : 9; ems[5] SET_TO /* 5 flood */ (settings->flood IS ON) ? 8 : -1; ems[6] SET_TO /* 6 overrides */ (settings->feed_override IS ON) ? 48 : 49; /* both overrides*/ return RS274NGC_OK; }

int write_settings (  block_pointer    block, setup_pointer    settings, int    line_number, double *    vals )

Definition at line 7690 of file rs274ngc.cc. { vals[0] SET_TO line_number; /* 0 line number */ vals[1] SET_TO settings->feed_rate; /* 1 feed rate */ vals[2] SET_TO settings->speed; /* 2 spindle speed */ return RS274NGC_OK; }

---

Variable Documentation

FILE* _interpreter_fp SET_TO NULL [static]

Definition at line 533 of file rs274ngc.cc.

char RS274NGC_PARAMETER_FILE[INTERP_TEXT_SIZE]

Initial value: DEFAULT_RS274NGC_PARAMETER_FILE Definition at line 544 of file rs274ngc.cc.

int _interpreter_length SET_TO [static]

Definition at line 538 of file rs274ngc.cc.

int _interpreter_active_g_codes[RS274NGC_ACTIVE_G_CODES] [static]

Definition at line 539 of file rs274ngc.cc.

int _interpreter_active_m_codes[RS274NGC_ACTIVE_M_CODES] [static]

Definition at line 540 of file rs274ngc.cc.

double _interpreter_active_settings[RS274NGC_ACTIVE_SETTINGS] [static]

Definition at line 541 of file rs274ngc.cc.

char _interpreter_blocktext[INTERP_TEXT_SIZE] [static]

Definition at line 531 of file rs274ngc.cc.

char _interpreter_filename[INTERP_TEXT_SIZE] [static]

Definition at line 529 of file rs274ngc.cc.

char _interpreter_linetext[INTERP_TEXT_SIZE] [static]

Definition at line 530 of file rs274ngc.cc.

setup _interpreter_settings

Definition at line 111 of file rs274ngc.cc.

char ident[] = "$Id: rs274ngc.cc,v 1.4 2000/10/27 20:34:44 terrylr Exp $" [static]

Definition at line 99 of file rs274ngc.cc.

---