|
|
|
@ -56,6 +56,8 @@ |
|
|
|
* G12 - Clean tool |
|
|
|
* G20 - Set input units to inches |
|
|
|
* G21 - Set input units to millimeters |
|
|
|
* G26 - Mesh Validation Pattern (Requires UBL_G26_MESH_EDITING) |
|
|
|
* G27 - Park Nozzle (Requires NOZZLE_PARK_FEATURE) |
|
|
|
* G28 - Home one or more axes |
|
|
|
* G29 - Detailed Z probe, probes the bed at 3 or more points. Will fail if you haven't homed yet. |
|
|
|
* G30 - Single Z probe, probes bed at X Y location (defaults to current XY location) |
|
|
|
@ -97,14 +99,15 @@ |
|
|
|
* M76 - Pause the print job timer. |
|
|
|
* M77 - Stop the print job timer. |
|
|
|
* M78 - Show statistical information about the print jobs. (Requires PRINTCOUNTER) |
|
|
|
* M80 - Turn on Power Supply. (Requires POWER_SUPPLY) |
|
|
|
* M81 - Turn off Power Supply. (Requires POWER_SUPPLY) |
|
|
|
* M80 - Turn on Power Supply. (Requires POWER_SUPPLY > 0) |
|
|
|
* M81 - Turn off Power Supply. (Requires POWER_SUPPLY > 0) |
|
|
|
* M82 - Set E codes absolute (default). |
|
|
|
* M83 - Set E codes relative while in Absolute (G90) mode. |
|
|
|
* M84 - Disable steppers until next move, or use S<seconds> to specify an idle |
|
|
|
* duration after which steppers should turn off. S0 disables the timeout. |
|
|
|
* M85 - Set inactivity shutdown timer with parameter S<seconds>. To disable set zero (default) |
|
|
|
* M92 - Set planner.axis_steps_per_mm for one or more axes. |
|
|
|
* M100 - Watch Free Memory (for debugging) (Requires M100_FREE_MEMORY_WATCHER) |
|
|
|
* M104 - Set extruder target temp. |
|
|
|
* M105 - Report current temperatures. |
|
|
|
* M106 - Fan on. |
|
|
|
@ -210,7 +213,6 @@ |
|
|
|
* M364 - SCARA calibration: Move to cal-position PSIC (90 deg to Theta calibration position) |
|
|
|
* |
|
|
|
* ************ Custom codes - This can change to suit future G-code regulations |
|
|
|
* M100 - Watch Free Memory (For Debugging). (Requires M100_FREE_MEMORY_WATCHER) |
|
|
|
* M928 - Start SD logging: "M928 filename.gco". Stop with M29. (Requires SDSUPPORT) |
|
|
|
* M999 - Restart after being stopped by error |
|
|
|
* |
|
|
|
@ -2425,9 +2427,12 @@ static void clean_up_after_endstop_or_probe_move() { |
|
|
|
|
|
|
|
#elif ENABLED(AUTO_BED_LEVELING_UBL) |
|
|
|
|
|
|
|
#if ENABLED(UBL_DELTA) |
|
|
|
if (( ubl.state.active ) && ( ! enable )) { // leveling from on to off
|
|
|
|
planner.unapply_leveling(current_position); |
|
|
|
#if PLANNER_LEVELING |
|
|
|
if (ubl.state.active != enable) { |
|
|
|
if (!enable) // leveling from on to off
|
|
|
|
planner.apply_leveling(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS]); |
|
|
|
else |
|
|
|
planner.unapply_leveling(current_position); |
|
|
|
} |
|
|
|
#endif |
|
|
|
|
|
|
|
@ -3729,7 +3734,7 @@ inline void gcode_G28() { |
|
|
|
// Disable the leveling matrix before homing
|
|
|
|
#if HAS_LEVELING |
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL) |
|
|
|
const bool bed_leveling_state_at_entry = ubl.state.active; |
|
|
|
const bool ubl_state_at_entry = ubl.state.active; |
|
|
|
#endif |
|
|
|
set_bed_leveling_enabled(false); |
|
|
|
#endif |
|
|
|
@ -3872,8 +3877,9 @@ inline void gcode_G28() { |
|
|
|
// move to a height where we can use the full xy-area
|
|
|
|
do_blocking_move_to_z(delta_clip_start_height); |
|
|
|
#endif |
|
|
|
|
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL) |
|
|
|
set_bed_leveling_enabled(bed_leveling_state_at_entry); |
|
|
|
set_bed_leveling_enabled(ubl_state_at_entry); |
|
|
|
#endif |
|
|
|
|
|
|
|
clean_up_after_endstop_or_probe_move(); |
|
|
|
@ -4028,7 +4034,7 @@ void home_all_axes() { gcode_G28(); } |
|
|
|
#endif |
|
|
|
} |
|
|
|
// If there's another point to sample, move there with optional lift.
|
|
|
|
if (mbl_probe_index < (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y)) { |
|
|
|
if (mbl_probe_index < GRID_MAX_POINTS) { |
|
|
|
mbl.zigzag(mbl_probe_index, px, py); |
|
|
|
_manual_goto_xy(mbl.index_to_xpos[px], mbl.index_to_ypos[py]); |
|
|
|
|
|
|
|
@ -4247,8 +4253,6 @@ void home_all_axes() { gcode_G28(); } |
|
|
|
ABL_VAR int left_probe_bed_position, right_probe_bed_position, front_probe_bed_position, back_probe_bed_position; |
|
|
|
ABL_VAR float xGridSpacing, yGridSpacing; |
|
|
|
|
|
|
|
#define ABL_GRID_MAX (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y) |
|
|
|
|
|
|
|
#if ABL_PLANAR |
|
|
|
ABL_VAR uint8_t abl_grid_points_x = GRID_MAX_POINTS_X, |
|
|
|
abl_grid_points_y = GRID_MAX_POINTS_Y; |
|
|
|
@ -4262,7 +4266,7 @@ void home_all_axes() { gcode_G28(); } |
|
|
|
#if ABL_PLANAR |
|
|
|
ABL_VAR int abl2; |
|
|
|
#else // 3-point
|
|
|
|
int constexpr abl2 = ABL_GRID_MAX; |
|
|
|
int constexpr abl2 = GRID_MAX_POINTS; |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
|
|
|
|
@ -4274,8 +4278,8 @@ void home_all_axes() { gcode_G28(); } |
|
|
|
|
|
|
|
ABL_VAR int indexIntoAB[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y]; |
|
|
|
|
|
|
|
ABL_VAR float eqnAMatrix[ABL_GRID_MAX * 3], // "A" matrix of the linear system of equations
|
|
|
|
eqnBVector[ABL_GRID_MAX], // "B" vector of Z points
|
|
|
|
ABL_VAR float eqnAMatrix[GRID_MAX_POINTS * 3], // "A" matrix of the linear system of equations
|
|
|
|
eqnBVector[GRID_MAX_POINTS], // "B" vector of Z points
|
|
|
|
mean; |
|
|
|
#endif |
|
|
|
|
|
|
|
@ -7619,7 +7623,6 @@ inline void gcode_M205() { |
|
|
|
if (code_seen('H')) { |
|
|
|
home_offset[Z_AXIS] = code_value_linear_units() - DELTA_HEIGHT; |
|
|
|
current_position[Z_AXIS] += code_value_linear_units() - DELTA_HEIGHT - home_offset[Z_AXIS]; |
|
|
|
home_offset[Z_AXIS] = code_value_linear_units() - DELTA_HEIGHT; |
|
|
|
update_software_endstops(Z_AXIS); |
|
|
|
} |
|
|
|
if (code_seen('L')) delta_diagonal_rod = code_value_linear_units(); |
|
|
|
@ -8413,17 +8416,15 @@ void quickstop_stepper() { |
|
|
|
* Use either 'M421 X<linear> Y<linear> Z<linear>' or 'M421 I<xindex> J<yindex> Z<linear>' |
|
|
|
*/ |
|
|
|
inline void gcode_M421() { |
|
|
|
int8_t px = 0, py = 0; |
|
|
|
float z = 0; |
|
|
|
bool hasX, hasY, hasZ, hasI, hasJ; |
|
|
|
if ((hasX = code_seen('X'))) px = mbl.probe_index_x(code_value_linear_units()); |
|
|
|
if ((hasY = code_seen('Y'))) py = mbl.probe_index_y(code_value_linear_units()); |
|
|
|
if ((hasI = code_seen('I'))) px = code_value_linear_units(); |
|
|
|
if ((hasJ = code_seen('J'))) py = code_value_linear_units(); |
|
|
|
if ((hasZ = code_seen('Z'))) z = code_value_linear_units(); |
|
|
|
|
|
|
|
if (hasX && hasY && hasZ) { |
|
|
|
const bool hasX = code_seen('X'), hasI = !hasX && code_seen('I'); |
|
|
|
const int8_t px = hasX || hasI ? mbl.probe_index_x(code_value_linear_units()) : 0; |
|
|
|
const bool hasY = code_seen('Y'), hasJ = !hasY && code_seen('J'); |
|
|
|
const int8_t py = hasY || hasJ ? mbl.probe_index_y(code_value_linear_units()) : 0; |
|
|
|
const bool hasZ = code_seen('Z'); |
|
|
|
const float z = hasZ ? code_value_linear_units() : 0; |
|
|
|
|
|
|
|
if (hasX && hasY && hasZ) { |
|
|
|
if (px >= 0 && py >= 0) |
|
|
|
mbl.set_z(px, py, z); |
|
|
|
else { |
|
|
|
@ -8450,18 +8451,18 @@ void quickstop_stepper() { |
|
|
|
/**
|
|
|
|
* M421: Set a single Mesh Bed Leveling Z coordinate |
|
|
|
* |
|
|
|
* Usage: |
|
|
|
* M421 I<xindex> J<yindex> Z<linear> |
|
|
|
* or |
|
|
|
* M421 I<xindex> J<yindex> Q<offset> |
|
|
|
*/ |
|
|
|
inline void gcode_M421() { |
|
|
|
int8_t px = 0, py = 0; |
|
|
|
float z = 0; |
|
|
|
bool hasI, hasJ, hasZ, hasQ; |
|
|
|
if ((hasI = code_seen('I'))) px = code_value_int(); |
|
|
|
if ((hasJ = code_seen('J'))) py = code_value_int(); |
|
|
|
if ((hasZ = code_seen('Z'))) z = code_value_linear_units(); |
|
|
|
if ((hasQ = code_seen('Q'))) z = code_value_linear_units(); |
|
|
|
|
|
|
|
const bool hasI = code_seen('I'); |
|
|
|
const int8_t px = hasI ? code_value_int() : 0; |
|
|
|
const bool hasJ = code_seen('J'); |
|
|
|
const int8_t py = hasJ ? code_value_int() : 0; |
|
|
|
const bool hasZ = code_seen('Z'), hasQ = !hasZ && code_seen('Q'); |
|
|
|
const float z = hasZ || hasQ ? code_value_linear_units() : 0; |
|
|
|
|
|
|
|
if (!hasI || !hasJ || (hasQ && hasZ) || (!hasQ && !hasZ)) { |
|
|
|
SERIAL_ERROR_START; |
|
|
|
@ -8494,35 +8495,33 @@ void quickstop_stepper() { |
|
|
|
/**
|
|
|
|
* M421: Set a single Mesh Bed Leveling Z coordinate |
|
|
|
* |
|
|
|
* Usage: |
|
|
|
* M421 I<xindex> J<yindex> Z<linear> |
|
|
|
* or |
|
|
|
* M421 I<xindex> J<yindex> Q<offset> |
|
|
|
* M421 C Z<linear> |
|
|
|
* M421 C Q<offset> |
|
|
|
*/ |
|
|
|
|
|
|
|
//todo: change multiple points simultaneously?
|
|
|
|
|
|
|
|
inline void gcode_M421() { |
|
|
|
int8_t px = 0, py = 0; |
|
|
|
float z = 0; |
|
|
|
bool hasI, hasJ, hasZ, hasQ, hasC; |
|
|
|
if ((hasI = code_seen('I'))) px = code_value_int(); |
|
|
|
if ((hasJ = code_seen('J'))) py = code_value_int(); |
|
|
|
if ((hasZ = code_seen('Z'))) z = code_value_linear_units(); |
|
|
|
if ((hasQ = code_seen('Q'))) z = code_value_linear_units(); |
|
|
|
hasC = code_seen('C'); |
|
|
|
|
|
|
|
if ( (!(hasI && hasJ) && !hasC) || (hasQ && hasZ) || (!hasQ && !hasZ)) { |
|
|
|
|
|
|
|
// Get the closest position for 'C', if needed
|
|
|
|
const mesh_index_pair location = find_closest_mesh_point_of_type(REAL, current_position[X_AXIS], current_position[Y_AXIS], USE_NOZZLE_AS_REFERENCE, NULL, false); |
|
|
|
|
|
|
|
const bool hasC = code_seen('C'), hasI = code_seen('I'); |
|
|
|
const int8_t px = hasC ? location.x_index : hasI ? code_value_int() : 0; |
|
|
|
|
|
|
|
const bool hasJ = code_seen('J'); |
|
|
|
const int8_t py = hasC ? location.y_index : hasJ ? code_value_int() : 0; |
|
|
|
|
|
|
|
const bool hasZ = code_seen('Z'), hasQ = !hasZ && code_seen('Q'); |
|
|
|
const float z = hasZ || hasQ ? code_value_linear_units() : 0; |
|
|
|
|
|
|
|
if ( ((hasI && hasJ) == hasC) || (hasQ && hasZ) || (!hasQ && !hasZ)) { |
|
|
|
SERIAL_ERROR_START; |
|
|
|
SERIAL_ERRORLNPGM(MSG_ERR_M421_PARAMETERS); |
|
|
|
return; |
|
|
|
} |
|
|
|
|
|
|
|
if (hasC) { // get closest position
|
|
|
|
const mesh_index_pair location = find_closest_mesh_point_of_type(REAL, current_position[X_AXIS], current_position[Y_AXIS], USE_NOZZLE_AS_REFERENCE, NULL, false); |
|
|
|
px = location.x_index; |
|
|
|
py = location.y_index; |
|
|
|
} |
|
|
|
|
|
|
|
if (WITHIN(px, 0, GRID_MAX_POINTS_X - 1) && WITHIN(py, 0, GRID_MAX_POINTS_Y - 1)) { |
|
|
|
if (hasZ) // doing an absolute mesh value
|
|
|
|
ubl.z_values[px][py] = z; |
|
|
|
@ -8534,7 +8533,8 @@ void quickstop_stepper() { |
|
|
|
SERIAL_ERRORLNPGM(MSG_ERR_MESH_XY); |
|
|
|
} |
|
|
|
} |
|
|
|
#endif |
|
|
|
|
|
|
|
#endif // AUTO_BED_LEVELING_UBL
|
|
|
|
|
|
|
|
#if HAS_M206_COMMAND |
|
|
|
|
|
|
|
@ -11106,7 +11106,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { |
|
|
|
|
|
|
|
#endif // AUTO_BED_LEVELING_BILINEAR
|
|
|
|
|
|
|
|
#if IS_KINEMATIC && DISABLED(UBL_DELTA) |
|
|
|
#if IS_KINEMATIC && !UBL_DELTA |
|
|
|
|
|
|
|
/**
|
|
|
|
* Prepare a linear move in a DELTA or SCARA setup. |
|
|
|
@ -11117,7 +11117,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { |
|
|
|
inline bool prepare_kinematic_move_to(float ltarget[XYZE]) { |
|
|
|
|
|
|
|
// Get the top feedrate of the move in the XY plane
|
|
|
|
float _feedrate_mm_s = MMS_SCALED(feedrate_mm_s); |
|
|
|
const float _feedrate_mm_s = MMS_SCALED(feedrate_mm_s); |
|
|
|
|
|
|
|
// If the move is only in Z/E don't split up the move
|
|
|
|
if (ltarget[X_AXIS] == current_position[X_AXIS] && ltarget[Y_AXIS] == current_position[Y_AXIS]) { |
|
|
|
@ -11126,7 +11126,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { |
|
|
|
} |
|
|
|
|
|
|
|
// Fail if attempting move outside printable radius
|
|
|
|
if ( ! position_is_reachable_xy( ltarget[X_AXIS], ltarget[Y_AXIS] )) return true; |
|
|
|
if (!position_is_reachable_xy(ltarget[X_AXIS], ltarget[Y_AXIS])) return true; |
|
|
|
|
|
|
|
// Get the cartesian distances moved in XYZE
|
|
|
|
float difference[XYZE]; |
|
|
|
@ -11142,7 +11142,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { |
|
|
|
if (UNEAR_ZERO(cartesian_mm)) return true; |
|
|
|
|
|
|
|
// Minimum number of seconds to move the given distance
|
|
|
|
float seconds = cartesian_mm / _feedrate_mm_s; |
|
|
|
const float seconds = cartesian_mm / _feedrate_mm_s; |
|
|
|
|
|
|
|
// The number of segments-per-second times the duration
|
|
|
|
// gives the number of segments
|
|
|
|
@ -11227,7 +11227,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { |
|
|
|
return false; |
|
|
|
} |
|
|
|
|
|
|
|
#else // !IS_KINEMATIC
|
|
|
|
#else // !IS_KINEMATIC || UBL_DELTA
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Prepare a linear move in a Cartesian setup. |
|
|
|
@ -11265,7 +11265,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { |
|
|
|
return false; |
|
|
|
} |
|
|
|
|
|
|
|
#endif // !IS_KINEMATIC
|
|
|
|
#endif // !IS_KINEMATIC || UBL_DELTA
|
|
|
|
|
|
|
|
#if ENABLED(DUAL_X_CARRIAGE) |
|
|
|
|
|
|
|
@ -11377,21 +11377,21 @@ void prepare_move_to_destination() { |
|
|
|
|
|
|
|
#endif |
|
|
|
|
|
|
|
#if IS_KINEMATIC |
|
|
|
#if ENABLED(UBL_DELTA) |
|
|
|
if (ubl_prepare_linear_move_to(destination,feedrate_mm_s)) return; |
|
|
|
#else |
|
|
|
if (prepare_kinematic_move_to(destination)) return; |
|
|
|
#endif |
|
|
|
#else |
|
|
|
#if ENABLED(DUAL_X_CARRIAGE) |
|
|
|
if (prepare_move_to_destination_dualx()) return; |
|
|
|
#elif ENABLED(UBL_DELTA) // will work for CARTESIAN too (smaller segments follow mesh more closely)
|
|
|
|
if (ubl_prepare_linear_move_to(destination,feedrate_mm_s)) return; |
|
|
|
if ( |
|
|
|
#if IS_KINEMATIC |
|
|
|
#if UBL_DELTA |
|
|
|
ubl_prepare_linear_move_to(destination, feedrate_mm_s) |
|
|
|
#else |
|
|
|
prepare_kinematic_move_to(destination) |
|
|
|
#endif |
|
|
|
#elif ENABLED(DUAL_X_CARRIAGE) |
|
|
|
prepare_move_to_destination_dualx() |
|
|
|
#elif UBL_DELTA // will work for CARTESIAN too (smaller segments follow mesh more closely)
|
|
|
|
ubl_prepare_linear_move_to(destination, feedrate_mm_s) |
|
|
|
#else |
|
|
|
if (prepare_move_to_destination_cartesian()) return; |
|
|
|
prepare_move_to_destination_cartesian() |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
) return; |
|
|
|
|
|
|
|
set_current_to_destination(); |
|
|
|
} |
|
|
|
@ -11432,7 +11432,7 @@ void prepare_move_to_destination() { |
|
|
|
if (angular_travel == 0 && current_position[X_AXIS] == logical[X_AXIS] && current_position[Y_AXIS] == logical[Y_AXIS]) |
|
|
|
angular_travel += RADIANS(360); |
|
|
|
|
|
|
|
float mm_of_travel = HYPOT(angular_travel * radius, fabs(linear_travel)); |
|
|
|
const float mm_of_travel = HYPOT(angular_travel * radius, fabs(linear_travel)); |
|
|
|
if (mm_of_travel < 0.001) return; |
|
|
|
|
|
|
|
uint16_t segments = floor(mm_of_travel / (MM_PER_ARC_SEGMENT)); |
|
|
|
|
Scott Lahteine
8 years ago
GitHub