/* gcode.c - rs274/ngc parser. Part of Grbl Copyright (c) 2011-2014 Sungeun K. Jeon Copyright (c) 2009-2011 Simen Svale Skogsrud Grbl is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. Grbl is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Grbl. If not, see . */ #include "system.h" #include "settings.h" #include "protocol.h" #include "gcode.h" #include "motion_control.h" #include "spindle_control.h" #include "coolant_control.h" #include "probe.h" #include "report.h" // NOTE: Max line number is defined by the g-code standard to be 99999. It seems to be an // arbitrary value, and some GUIs may require more. So we increased it based on a max safe // value when converting a float (7.2 digit precision)s to an integer. #define MAX_LINE_NUMBER 9999999 #define AXIS_COMMAND_NONE 0 #define AXIS_COMMAND_NON_MODAL 1 #define AXIS_COMMAND_MOTION_MODE 2 #define AXIS_COMMAND_TOOL_LENGTH_OFFSET 3 // *Undefined but required // Declare gc extern struct parser_state_t gc_state; parser_block_t gc_block; #define FAIL(status) return(status); void gc_init() { memset(&gc_state, 0, sizeof(gc_state)); // Load default G54 coordinate system. if (!(settings_read_coord_data(gc_state.modal.coord_select,gc_state.coord_system))) { report_status_message(STATUS_SETTING_READ_FAIL); } } // Sets g-code parser position in mm. Input in steps. Called by the system abort and hard // limit pull-off routines. void gc_sync_position() { uint8_t i; for (i=0; i 255, variable type must be changed to uint16_t. while (line[char_counter] != 0) { // Loop until no more g-code words in line. // Import the next g-code word, expecting a letter followed by a value. Otherwise, error out. letter = line[char_counter]; if((letter < 'A') || (letter > 'Z')) { FAIL(STATUS_EXPECTED_COMMAND_LETTER); } // [Expected word letter] char_counter++; if (!read_float(line, &char_counter, &value)) { FAIL(STATUS_BAD_NUMBER_FORMAT); } // [Expected word value] // Convert values to smaller uint8 significand and mantissa values for parsing this word. // NOTE: Mantissa is multiplied by 100 to catch non-integer command values. This is more // accurate than the NIST gcode requirement of x10 when used for commands, but not quite // accurate enough for value words that require integers to within 0.0001. This should be // a good enough comprimise and catch most all non-integer errors. To make it compliant, // we would simply need to change the mantissa to int16, but this add compiled flash space. // Maybe update this later. int_value = trunc(value); mantissa = trunc(100*(value - int_value)); // Compute mantissa for Gxx.x commands // Check if the g-code word is supported or errors due to modal group violations or has // been repeated in the g-code block. If ok, update the command or record its value. switch(letter) { /* 'G' and 'M' Command Words: Parse commands and check for modal group violations. NOTE: Modal group numbers are defined in Table 4 of NIST RS274-NGC v3, pg.20 */ case 'G': // Determine 'G' command and its modal group switch(int_value) { case 10: case 28: case 30: case 92: // Check for G10/28/30/92 being called with G0/1/2/3/38 on same block. // * G43.1 is also an axis command but is not explicitly defined this way. if (mantissa == 0) { // Ignore G28.1, G30.1, and G92.1 if (axis_command) { FAIL(STATUS_GCODE_AXIS_COMMAND_CONFLICT); } // [Axis word/command conflict] axis_command = AXIS_COMMAND_NON_MODAL; } // No break. Continues to next line. case 4: case 53: word_bit = MODAL_GROUP_G0; switch(int_value) { case 4: gc_block.non_modal_command = NON_MODAL_DWELL; break; // G4 case 10: gc_block.non_modal_command = NON_MODAL_SET_COORDINATE_DATA; break; // G10 case 28: switch(mantissa) { case 0: gc_block.non_modal_command = NON_MODAL_GO_HOME_0; break; // G28 case 10: gc_block.non_modal_command = NON_MODAL_SET_HOME_0; break; // G28.1 default: FAIL(STATUS_GCODE_UNSUPPORTED_COMMAND); // [Unsupported G28.x command] } mantissa = 0; // Set to zero to indicate valid non-integer G command. break; case 30: switch(mantissa) { case 0: gc_block.non_modal_command = NON_MODAL_GO_HOME_1; break; // G30 case 10: gc_block.non_modal_command = NON_MODAL_SET_HOME_1; break; // G30.1 default: FAIL(STATUS_GCODE_UNSUPPORTED_COMMAND); // [Unsupported G30.x command] } mantissa = 0; // Set to zero to indicate valid non-integer G command. break; case 53: gc_block.non_modal_command = NON_MODAL_ABSOLUTE_OVERRIDE; break; // G53 case 92: switch(mantissa) { case 0: gc_block.non_modal_command = NON_MODAL_SET_COORDINATE_OFFSET; break; // G92 case 10: gc_block.non_modal_command = NON_MODAL_RESET_COORDINATE_OFFSET; break; // G92.1 default: FAIL(STATUS_GCODE_UNSUPPORTED_COMMAND); // [Unsupported G92.x command] } mantissa = 0; // Set to zero to indicate valid non-integer G command. break; } break; case 0: case 1: case 2: case 3: case 38: // Check for G0/1/2/3/38 being called with G10/28/30/92 on same block. // * G43.1 is also an axis command but is not explicitly defined this way. if (axis_command) { FAIL(STATUS_GCODE_AXIS_COMMAND_CONFLICT); } // [Axis word/command conflict] axis_command = AXIS_COMMAND_MOTION_MODE; // No break. Continues to next line. case 80: word_bit = MODAL_GROUP_G1; switch(int_value) { case 0: gc_block.modal.motion = MOTION_MODE_SEEK; break; // G0 case 1: gc_block.modal.motion = MOTION_MODE_LINEAR; break; // G1 case 2: gc_block.modal.motion = MOTION_MODE_CW_ARC; break; // G2 case 3: gc_block.modal.motion = MOTION_MODE_CCW_ARC; break; // G3 case 38: switch(mantissa) { case 20: gc_block.modal.motion = MOTION_MODE_PROBE; break; // G38.2 // NOTE: If G38.3+ are enabled, change mantissa variable type to uint16_t. // case 30: gc_block.modal.motion = MOTION_MODE_PROBE_NO_ERROR; break; // G38.3 Not supported. // case 40: // Not supported. // case 50: // Not supported. default: FAIL(STATUS_GCODE_UNSUPPORTED_COMMAND); // [Unsupported G38.x command] } mantissa = 0; // Set to zero to indicate valid non-integer G command. break; case 80: gc_block.modal.motion = MOTION_MODE_NONE; break; // G80 } break; case 17: case 18: case 19: word_bit = MODAL_GROUP_G2; switch(int_value) { case 17: gc_block.modal.plane_select = PLANE_SELECT_XY; break; case 18: gc_block.modal.plane_select = PLANE_SELECT_ZX; break; case 19: gc_block.modal.plane_select = PLANE_SELECT_YZ; break; } break; case 90: case 91: word_bit = MODAL_GROUP_G3; if (int_value == 90) { gc_block.modal.distance = DISTANCE_MODE_ABSOLUTE; } // G90 else { gc_block.modal.distance = DISTANCE_MODE_INCREMENTAL; } // G91 break; case 93: case 94: word_bit = MODAL_GROUP_G5; if (int_value == 93) { gc_block.modal.feed_rate = FEED_RATE_MODE_INVERSE_TIME; } // G93 else { gc_block.modal.feed_rate = FEED_RATE_MODE_UNITS_PER_MIN; } // G94 break; case 20: case 21: word_bit = MODAL_GROUP_G6; if (int_value == 20) { gc_block.modal.units = UNITS_MODE_INCHES; } // G20 else { gc_block.modal.units = UNITS_MODE_MM; } // G21 break; case 43: case 49: word_bit = MODAL_GROUP_G8; if (int_value == 49) { gc_block.modal.tool_length = TOOL_LENGTH_OFFSET_CANCEL; // Else command is G43. Only G43.1 is supported. G43 is NOT. } else if (mantissa == 1) { // * G43.1 is requires an axis word to operate and cannot exist with other axis // commands in the same line. However, it's not explicitly defined this way. if (axis_command) { FAIL(STATUS_GCODE_AXIS_COMMAND_CONFLICT); } // [Axis word/command conflict] } axis_command = AXIS_COMMAND_TOOL_LENGTH_OFFSET; gc_block.modal.tool_length = TOOL_LENGTH_OFFSET_ENABLE_DYNAMIC; } else { FAIL(STATUS_GCODE_UNSUPPORTED_COMMAND); } // [Unsupported G43.x command] case 54: case 55: case 56: case 57: case 58: case 59: // NOTE: G59.x are not supported. (But their int_values would be 60, 61, and 62.) word_bit = MODAL_GROUP_G12; gc_block.modal.coord_select = int_value-54; // Shift to array indexing. break; default: FAIL(STATUS_GCODE_UNSUPPORTED_COMMAND); // [Unsupported G command] } if (mantissa > 0) { FAIL(STATUS_GCODE_COMMAND_VALUE_NOT_INTEGER); } // [Unsupported or invalid Gxx.x command] // Check for more than one command per modal group violations in the current block // NOTE: Variable 'word_bit' is always assigned, if the command is valid. if ( bit_istrue(command_words,bit(word_bit)) ) { FAIL(STATUS_GCODE_MODAL_GROUP_VIOLATION); } bit_true(command_words,bit(word_bit)); break; case 'M': // Determine 'M' command and its modal group if (mantissa > 0) { FAIL(STATUS_GCODE_COMMAND_VALUE_NOT_INTEGER); } // [No Mxx.x commands] switch(int_value) { case 0: case 1: case 2: case 30: word_bit = MODAL_GROUP_M4; switch(int_value) { case 0: gc_block.modal.program_flow = PROGRAM_FLOW_PAUSED; break; // Program pause case 1: break; // Optional stop not supported. Ignore. case 2: case 30: gc_block.modal.program_flow = PROGRAM_FLOW_COMPLETED; break; // Program end and reset } break; case 3: case 4: case 5: word_bit = MODAL_GROUP_M7; switch(int_value) { case 3: gc_block.modal.spindle = SPINDLE_ENABLE_CW; break; case 4: gc_block.modal.spindle = SPINDLE_ENABLE_CCW; break; case 5: gc_block.modal.spindle = SPINDLE_DISABLE; break; } break; #ifdef ENABLE_M7 case 7: #endif case 8: case 9: word_bit = MODAL_GROUP_M8; switch(int_value) { #ifdef ENABLE_M7 case 7: gc_block.modal.coolant = COOLANT_MIST_ENABLE; break; #endif case 8: gc_block.modal.coolant = COOLANT_FLOOD_ENABLE; break; case 9: gc_block.modal.coolant = COOLANT_DISABLE; break; } break; default: FAIL(STATUS_GCODE_UNSUPPORTED_COMMAND); // [Unsupported M command] } // Check for more than one command per modal group violations in the current block // NOTE: Variable 'word_bit' is always assigned, if the command is valid. if ( bit_istrue(command_words,bit(word_bit)) ) { FAIL(STATUS_GCODE_MODAL_GROUP_VIOLATION); } bit_true(command_words,bit(word_bit)); break; // NOTE: All remaining letters assign values. default: /* Non-Command Words: This initial parsing phase only checks for repeats of the remaining legal g-code words and stores their value. Error-checking is performed later since some words (I,J,K,L,P,R) have multiple connotations and/or depend on the issued commands. */ switch(letter){ // case 'A': // Not supported // case 'B': // Not supported // case 'C': // Not supported // case 'D': // Not supported case 'F': word_bit = WORD_F; gc_block.values.f = value; break; // case 'H': // Not supported case 'I': word_bit = WORD_I; gc_block.values.ijk[X_AXIS] = value; ijk_words |= (1< MAX_LINE_NUMBER) { FAIL(STATUS_GCODE_INVALID_LINE_NUMBER); } // [Exceeds max line number] } // bit_false(value_words,bit(WORD_N)); // NOTE: Single-meaning value word. Set at end of error-checking. // Track for unused words at the end of error-checking. // NOTE: Single-meaning value words are removed all at once at the end of error-checking, because // they are always used when present. This was done to save a few bytes of flash. For clarity, the // single-meaning value words may be removed as they are used. Also, axis words are treated in the // same way. If there is an explicit/implicit axis command, XYZ words are always used and are // are removed at the end of error-checking. // [1. Comments ]: MSG's NOT SUPPORTED. Comment handling performed by protocol. // [2. Set feed rate mode ]: G93 F word missing with G1,G2/3 active, implicitly or explicitly. Feed rate // is not defined after switching to G94 from G93. if (gc_block.modal.feed_rate == FEED_RATE_MODE_INVERSE_TIME) { // = G93 // NOTE: G38 can also operate in inverse time, but is undefined as an error. Missing F word check added here. if (axis_command == AXIS_COMMAND_MOTION_MODE) { if ((gc_block.modal.motion != MOTION_MODE_NONE) || (gc_block.modal.motion != MOTION_MODE_SEEK)) { if (bit_isfalse(value_words,bit(WORD_F))) { FAIL(STATUS_GCODE_UNDEFINED_FEED_RATE); } // [F word missing] } } // NOTE: It seems redundant to check for an F word to be passed after switching from G94 to G93. We would // accomplish the exact same thing if the feed rate value is always reset to zero and undefined after each // inverse time block, since the commands that use this value already perform undefined checks. This would // also allow other commands, following this switch, to execute and not error out needlessly. This code is // combined with the above feed rate mode and the below set feed rate error-checking. // [3. Set feed rate ]: F is negative (done.) // - In inverse time mode: Always implicitly zero the feed rate value before and after block completion. // NOTE: If in G93 mode or switched into it from G94, just keep F value as initialized zero or passed F word // value in the block. If no F word is passed with a motion command that requires a feed rate, this will error // out in the motion modes error-checking. However, if no F word is passed with NO motion command that requires // a feed rate, we simply move on and the state feed rate value gets updated to zero and remains undefined. } else { // = G94 // - In units per mm mode: If F word passed, ensure value is in mm/min, otherwise push last state value. if (gc_state.modal.feed_rate == FEED_RATE_MODE_UNITS_PER_MIN) { // Last state is also G94 if (bit_istrue(value_words,bit(WORD_F))) { if (gc_block.modal.units == UNITS_MODE_INCHES) { gc_block.values.f *= MM_PER_INCH; } } else { gc_block.values.f = gc_state.feed_rate; // Push last state feed rate } } // Else, switching to G94 from G93, so don't push last state feed rate. Its undefined or the passed F word value. } // bit_false(value_words,bit(WORD_F)); // NOTE: Single-meaning value word. Set at end of error-checking. // [4. Set spindle speed ]: S is negative (done.) if (bit_isfalse(value_words,bit(WORD_S))) { gc_block.values.s = gc_state.spindle_speed; } // bit_false(value_words,bit(WORD_S)); // NOTE: Single-meaning value word. Set at end of error-checking. // [5. Select tool ]: NOT SUPPORTED. Only tracks value. T is negative (done.) Not an integer. Greater than max tool value. // bit_false(value_words,bit(WORD_T)); // NOTE: Single-meaning value word. Set at end of error-checking. // [6. Change tool ]: N/A // [7. Spindle control ]: N/A // [8. Coolant control ]: N/A // [9. Enable/disable feed rate or spindle overrides ]: NOT SUPPORTED. // [10. Dwell ]: P value missing. P is negative (done.) NOTE: See below. if (gc_block.non_modal_command == NON_MODAL_DWELL) { if (bit_isfalse(value_words,bit(WORD_P))) { FAIL(STATUS_GCODE_VALUE_WORD_MISSING); } // [P word missing] bit_false(value_words,bit(WORD_P)); } // [11. Set active plane ]: N/A switch (gc_block.modal.plane_select) { case PLANE_SELECT_XY: axis_0 = X_AXIS; axis_1 = Y_AXIS; axis_linear = Z_AXIS; break; case PLANE_SELECT_ZX: axis_0 = Z_AXIS; axis_1 = X_AXIS; axis_linear = Y_AXIS; break; default: // case PLANE_SELECT_YZ: axis_0 = Y_AXIS; axis_1 = Z_AXIS; axis_linear = X_AXIS; } // [12. Set length units ]: N/A // Pre-convert XYZ coordinate values to millimeters, if applicable. uint8_t idx; if (gc_block.modal.units == UNITS_MODE_INCHES) { for (idx=0; idx N_COORDINATE_SYSTEM) { FAIL(STATUS_GCODE_UNSUPPORTED_COORD_SYS); } // [Greater than N sys] if (gc_state.modal.coord_select != gc_block.modal.coord_select) { if (!(settings_read_coord_data(gc_block.modal.coord_select,coordinate_data))) { FAIL(STATUS_SETTING_READ_FAIL); } } } // [16. Set path control mode ]: NOT SUPPORTED. // [17. Set distance mode ]: N/A. G90.1 and G91.1 NOT SUPPORTED. // [18. Set retract mode ]: NOT SUPPORTED. // [19. Remaining non-modal actions ]: Check go to predefined position, set G10, or set axis offsets. // NOTE: We need to separate the non-modal commands that are axis word-using (G10/G28/G30/G92), as these // commands all treat axis words differently. G10 as absolute offsets or computes current position as // the axis value, G92 similarly to G10 L20, and G28/30 as an intermediate target position that observes // all the current coordinate system and G92 offsets. switch (gc_block.non_modal_command) { case NON_MODAL_SET_COORDINATE_DATA: // [G10 Errors]: L missing and is not 2 or 20. P word missing. (Negative P value done.) // [G10 L2 Errors]: R word NOT SUPPORTED. P value not 0 to nCoordSys(max 9). Axis words missing. // [G10 L20 Errors]: P must be 0 to nCoordSys(max 9). Axis words missing. if (!axis_words) { FAIL(STATUS_GCODE_NO_AXIS_WORDS) }; // [No axis words] if (bit_isfalse(value_words,((1< N_COORDINATE_SYSTEM) { FAIL(STATUS_GCODE_UNSUPPORTED_COORD_SYS); } // [Greater than N sys] if (gc_block.values.l != 20) { if (gc_block.values.l == 2) { if (bit_istrue(value_words,bit(WORD_R))) { FAIL(STATUS_GCODE_UNSUPPORTED_COMMAND); } // [G10 L2 R not supported] } else { FAIL(STATUS_GCODE_UNSUPPORTED_COMMAND); } // [Unsupported L] } bit_false(value_words,(bit(WORD_L)|bit(WORD_P))); // Load EEPROM coordinate data and pre-calculate the new coordinate data. if (int_value > 0) { int_value--; } // Adjust P1-P6 index to EEPROM coordinate data indexing. else { int_value = gc_block.modal.coord_select; } // Index P0 as the active coordinate system if (!settings_read_coord_data(int_value,parameter_data)) { FAIL(STATUS_SETTING_READ_FAIL); } // [EEPROM read fail] for (idx=0; idx C -----------------+--------------- T <- [x,y] | <------ d/2 ---->| C - Current position T - Target position O - center of circle that pass through both C and T d - distance from C to T r - designated radius h - distance from center of CT to O Expanding the equations: d -> sqrt(x^2 + y^2) h -> sqrt(4 * r^2 - x^2 - y^2)/2 i -> (x - (y * sqrt(4 * r^2 - x^2 - y^2)) / sqrt(x^2 + y^2)) / 2 j -> (y + (x * sqrt(4 * r^2 - x^2 - y^2)) / sqrt(x^2 + y^2)) / 2 Which can be written: i -> (x - (y * sqrt(4 * r^2 - x^2 - y^2))/sqrt(x^2 + y^2))/2 j -> (y + (x * sqrt(4 * r^2 - x^2 - y^2))/sqrt(x^2 + y^2))/2 Which we for size and speed reasons optimize to: h_x2_div_d = sqrt(4 * r^2 - x^2 - y^2)/sqrt(x^2 + y^2) i = (x - (y * h_x2_div_d))/2 j = (y + (x * h_x2_div_d))/2 */ // First, use h_x2_div_d to compute 4*h^2 to check if it is negative or r is smaller // than d. If so, the sqrt of a negative number is complex and error out. float h_x2_div_d = 4.0 * gc_block.values.r*gc_block.values.r - x*x - y*y; if (h_x2_div_d < 0) { FAIL(STATUS_GCODE_ARC_RADIUS_ERROR); } // [Arc radius error] // Finish computing h_x2_div_d. h_x2_div_d = -sqrt(h_x2_div_d)/hypot_f(x,y); // == -(h * 2 / d) // Invert the sign of h_x2_div_d if the circle is counter clockwise (see sketch below) if (gc_block.modal.motion == MOTION_MODE_CCW_ARC) { h_x2_div_d = -h_x2_div_d; } /* The counter clockwise circle lies to the left of the target direction. When offset is positive, the left hand circle will be generated - when it is negative the right hand circle is generated. T <-- Target position ^ Clockwise circles with this center | Clockwise circles with this center will have will have > 180 deg of angular travel | < 180 deg of angular travel, which is a good thing! \ | / center of arc when h_x2_div_d is positive -> x <----- | -----> x <- center of arc when h_x2_div_d is negative | | C <-- Current position */ // Negative R is g-code-alese for "I want a circle with more than 180 degrees of travel" (go figure!), // even though it is advised against ever generating such circles in a single line of g-code. By // inverting the sign of h_x2_div_d the center of the circles is placed on the opposite side of the line of // travel and thus we get the unadvisably long arcs as prescribed. if (gc_block.values.r < 0) { h_x2_div_d = -h_x2_div_d; gc_block.values.r = -gc_block.values.r; // Finished with r. Set to positive for mc_arc } // Complete the operation by calculating the actual center of the arc gc_block.values.ijk[axis_0] = 0.5*(x-(y*h_x2_div_d)); gc_block.values.ijk[axis_1] = 0.5*(y+(x*h_x2_div_d)); } else { // Arc Center Format Offset Mode if (!(ijk_words & (bit(axis_0)|bit(axis_1)))) { FAIL(STATUS_GCODE_NO_OFFSETS_IN_PLANE); } // [No offsets in plane] bit_false(value_words,(bit(WORD_I)|bit(WORD_J)|bit(WORD_K))); // Convert IJK values to proper units. if (gc_block.modal.units == UNITS_MODE_INCHES) { for (idx=0; idx 0.005) { if (delta_r > 0.5) { FAIL(STATUS_GCODE_INVALID_TARGET); } // [Arc definition error] > 0.5mm if (delta_r > (0.001*gc_block.values.r)) { FAIL(STATUS_GCODE_INVALID_TARGET); } // [Arc definition error] > 0.005mm AND 0.1% radius } } break; case MOTION_MODE_PROBE: // [G38 Errors]: Target is same current. No axis words. Cutter compensation is enabled. Feed rate // is undefined. Probe is triggered. if (!axis_words) { FAIL(STATUS_GCODE_NO_AXIS_WORDS); } // [No axis words] if (gc_check_same_position(gc_state.position, gc_block.values.xyz)) { FAIL(STATUS_GCODE_INVALID_TARGET); } // [Invalid target] if (probe_get_state()) { FAIL(STATUS_GCODE_PROBE_TRIGGERED); } // [Probe triggered] break; } } } // [21. Program flow ]: No error check required. // [0. Non-specific error-checks]: Complete unused value words check, i.e. IJK used when in arc // radius mode, or axis words that aren't used in the block. bit_false(value_words,(bit(WORD_N)|bit(WORD_F)|bit(WORD_S)|bit(WORD_T))); // Remove single-meaning value words. if (axis_command) { bit_false(value_words,(bit(WORD_X)|bit(WORD_Y)|bit(WORD_Z))); } // Remove axis words. if (value_words) { FAIL(STATUS_GCODE_UNUSED_WORDS); } // [Unused words] /* ------------------------------------------------------------------------------------- STEP 4: EXECUTE!! Assumes that all error-checking has been completed and no failure modes exist. We just need to update the state and execute the block according to the order-of-execution. */ // [1. Comments feedback ]: NOT SUPPORTED // [2. Set feed rate mode ]: gc_state.modal.feed_rate = gc_block.modal.feed_rate; // [3. Set feed rate ]: gc_state.feed_rate = gc_block.values.f; // Always copy this value. See feed rate error-checking. // [4. Set spindle speed ]: if (gc_state.spindle_speed != gc_block.values.s) { gc_state.spindle_speed = gc_block.values.s; // Update running spindle only if not in check mode and not already enabled. if (gc_state.modal.spindle != SPINDLE_DISABLE) { spindle_run(gc_state.modal.spindle, gc_state.spindle_speed); } } // [5. Select tool ]: NOT SUPPORTED // [6. Change tool ]: NOT SUPPORTED // [7. Spindle control ]: if (gc_state.modal.spindle != gc_block.modal.spindle) { gc_state.modal.spindle = gc_block.modal.spindle; // Update spindle control and apply spindle speed when enabling it in this block. spindle_run(gc_state.modal.spindle, gc_state.spindle_speed); } // [8. Coolant control ]: if (gc_state.modal.coolant != gc_block.modal.coolant) { gc_state.modal.coolant = gc_block.modal.coolant; coolant_run(gc_state.modal.coolant); } // [9. Enable/disable feed rate or spindle overrides ]: NOT SUPPORTED // [10. Dwell ]: if (gc_block.non_modal_command == NON_MODAL_DWELL) { mc_dwell(gc_block.values.p); } // [11. Set active plane ]: gc_state.modal.plane_select = gc_block.modal.plane_select; // [12. Set length units ]: gc_state.modal.units = gc_block.modal.units; // [13. Cutter radius compensation ]: NOT SUPPORTED // [14. Cutter length compensation ]: NOT SUPPORTED // [15. Coordinate system selection ]: if (gc_state.modal.coord_select != gc_block.modal.coord_select) { gc_state.modal.coord_select = gc_block.modal.coord_select; memcpy(gc_state.coord_system,coordinate_data,sizeof(coordinate_data)); } // [16. Set path control mode ]: NOT SUPPORTED // [17. Set distance mode ]: gc_state.modal.distance = gc_block.modal.distance; // [18. Set retract mode ]: NOT SUPPORTED // [19. Go to predefined position, Set G10, or Set axis offsets ]: switch(gc_block.non_modal_command) { case NON_MODAL_SET_COORDINATE_DATA: // TODO: See if I can clean up this int_value. int_value = trunc(gc_block.values.p); // Convert p value to int. if (int_value > 0) { int_value--; } // Adjust P1-P6 index to EEPROM coordinate data indexing. else { int_value = gc_state.modal.coord_select; } // Index P0 as the active coordinate system settings_write_coord_data(int_value,parameter_data); // Update system coordinate system if currently active. if (gc_state.modal.coord_select == int_value) { memcpy(gc_state.coord_system,parameter_data,sizeof(parameter_data)); } break; case NON_MODAL_GO_HOME_0: case NON_MODAL_GO_HOME_1: // Move to intermediate position before going home. Obeys current coordinate system and offsets // and absolute and incremental modes. if (axis_command) { #ifdef USE_LINE_NUMBERS mc_line(gc_block.values.xyz, -1.0, false, gc_block.values.n); #else mc_line(gc_block.values.xyz, -1.0, false); #endif } #ifdef USE_LINE_NUMBERS mc_line(parameter_data, -1.0, false, gc_block.values.n); #else mc_line(parameter_data, -1.0, false); #endif memcpy(gc_state.position, parameter_data, sizeof(parameter_data)); break; case NON_MODAL_SET_HOME_0: settings_write_coord_data(SETTING_INDEX_G28,gc_state.position); break; case NON_MODAL_SET_HOME_1: settings_write_coord_data(SETTING_INDEX_G30,gc_state.position); break; case NON_MODAL_SET_COORDINATE_OFFSET: memcpy(gc_state.coord_offset,gc_block.values.xyz,sizeof(gc_block.values.xyz)); break; case NON_MODAL_RESET_COORDINATE_OFFSET: clear_vector(gc_state.coord_offset); // Disable G92 offsets by zeroing offset vector. break; } // [20. Motion modes ]: // NOTE: Commands G10,G28,G30,G92 lock out and prevent axis words from use in motion modes. // Enter motion modes only if there are axis words or a motion mode command word in the block. gc_state.modal.motion = gc_block.modal.motion; if (gc_state.modal.motion != MOTION_MODE_NONE) { if (axis_command == AXIS_COMMAND_MOTION_MODE) { switch (gc_state.modal.motion) { case MOTION_MODE_SEEK: #ifdef USE_LINE_NUMBERS mc_line(gc_block.values.xyz, -1.0, false, gc_block.values.n); #else mc_line(gc_block.values.xyz, -1.0, false); #endif break; case MOTION_MODE_LINEAR: #ifdef USE_LINE_NUMBERS mc_line(gc_block.values.xyz, gc_state.feed_rate, gc_state.modal.feed_rate, gc_block.values.n); #else mc_line(gc_block.values.xyz, gc_state.feed_rate, gc_state.modal.feed_rate); #endif break; case MOTION_MODE_CW_ARC: case MOTION_MODE_CCW_ARC: #ifdef USE_LINE_NUMBERS mc_arc(gc_state.position, gc_block.values.xyz, gc_block.values.ijk, gc_block.values.r, gc_state.feed_rate, gc_state.modal.feed_rate, axis_0, axis_1, axis_linear, gc_block.values.n); #else mc_arc(gc_state.position, gc_block.values.xyz, gc_block.values.ijk, gc_block.values.r, gc_state.feed_rate, gc_state.modal.feed_rate, axis_0, axis_1, axis_linear); #endif break; case MOTION_MODE_PROBE: #ifdef USE_LINE_NUMBERS mc_probe_cycle(gc_block.values.xyz, gc_state.feed_rate, gc_state.modal.feed_rate, gc_block.values.n); #else mc_probe_cycle(gc_block.values.xyz, gc_state.feed_rate, gc_state.modal.feed_rate); #endif } // As far as the parser is concerned, the position is now == target. In reality the // motion control system might still be processing the action and the real tool position // in any intermediate location. memcpy(gc_state.position, gc_block.values.xyz, sizeof(gc_block.values.xyz)); // gc.position[] = target[]; } } // [21. Program flow ]: // M0,M1,M2,M30: Perform non-running program flow actions. During a program pause, the buffer may // refill and can only be resumed by the cycle start run-time command. gc_state.modal.program_flow = gc_block.modal.program_flow; if (gc_state.modal.program_flow) { protocol_buffer_synchronize(); // Finish all remaining buffered motions. Program paused when complete. sys.auto_start = false; // Disable auto cycle start. Forces pause until cycle start issued. // If complete, reset to reload defaults (G92.2,G54,G17,G90,G94,M48,G40,M5,M9). Otherwise, // re-enable program flow after pause complete, where cycle start will resume the program. if (gc_state.modal.program_flow == PROGRAM_FLOW_COMPLETED) { mc_reset(); } else { gc_state.modal.program_flow = PROGRAM_FLOW_RUNNING; } } // TBD: % to denote start of program. Sets auto cycle start? return(STATUS_OK); } /* Not supported: - Canned cycles - Tool radius compensation - A,B,C-axes - Evaluation of expressions - Variables - Override control (TBD) - Tool changes - Switches (*) Indicates optional parameter, enabled through config.h and re-compile group 0 = {G92.2, G92.3} (Non modal: Cancel and re-enable G92 offsets) group 1 = {G81 - G89} (Motion modes: Canned cycles) group 4 = {M1} (Optional stop, ignored) group 6 = {M6} (Tool change) group 8 = {*M7} enable mist coolant group 9 = {M48, M49} enable/disable feed and speed override switches group 13 = {G61, G61.1, G64} path control mode */