|
|
|
@ -1592,9 +1592,6 @@ inline void set_destination_to_current() { memcpy(destination, current_position, |
|
|
|
// - Reset the command timeout
|
|
|
|
// - Enable the endstops (for endstop moves)
|
|
|
|
//
|
|
|
|
// clean_up_after_endstop_move() restores
|
|
|
|
// feedrates, sets endstops back to global state.
|
|
|
|
//
|
|
|
|
static void setup_for_endstop_or_probe_move() { |
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE) |
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("setup_for_endstop_or_probe_move", current_position); |
|
|
|
@ -1619,12 +1616,6 @@ static void clean_up_after_endstop_or_probe_move() { |
|
|
|
} |
|
|
|
|
|
|
|
#if HAS_BED_PROBE |
|
|
|
|
|
|
|
static void clean_up_after_endstop_move() { |
|
|
|
clean_up_after_endstop_or_probe_move(); |
|
|
|
endstops.not_homing(); |
|
|
|
} |
|
|
|
|
|
|
|
#if ENABLED(DELTA) |
|
|
|
/**
|
|
|
|
* Calculate delta, start a line, and set current_position to destination |
|
|
|
@ -1666,18 +1657,25 @@ static void clean_up_after_endstop_or_probe_move() { |
|
|
|
|
|
|
|
#else |
|
|
|
|
|
|
|
feedrate = homing_feedrate[Z_AXIS]; |
|
|
|
|
|
|
|
current_position[Z_AXIS] = z; |
|
|
|
line_to_current_position(); |
|
|
|
stepper.synchronize(); |
|
|
|
// If Z needs to raise, do it before moving XY
|
|
|
|
if (current_position[Z_AXIS] < z) { |
|
|
|
feedrate = homing_feedrate[Z_AXIS]; |
|
|
|
current_position[Z_AXIS] = z; |
|
|
|
line_to_current_position(); |
|
|
|
} |
|
|
|
|
|
|
|
feedrate = XY_PROBE_FEEDRATE; |
|
|
|
|
|
|
|
current_position[X_AXIS] = x; |
|
|
|
current_position[Y_AXIS] = y; |
|
|
|
line_to_current_position(); |
|
|
|
|
|
|
|
// If Z needs to lower, do it after moving XY
|
|
|
|
if (current_position[Z_AXIS] > z) { |
|
|
|
feedrate = homing_feedrate[Z_AXIS]; |
|
|
|
current_position[Z_AXIS] = z; |
|
|
|
line_to_current_position(); |
|
|
|
} |
|
|
|
|
|
|
|
#endif |
|
|
|
|
|
|
|
stepper.synchronize(); |
|
|
|
@ -1722,11 +1720,6 @@ static void clean_up_after_endstop_or_probe_move() { |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
inline void raise_z_after_probing() { |
|
|
|
#if Z_RAISE_AFTER_PROBING > 0 |
|
|
|
do_probe_raise(Z_RAISE_AFTER_PROBING); |
|
|
|
#endif |
|
|
|
} |
|
|
|
#endif //HAS_BED_PROBE
|
|
|
|
|
|
|
|
#if ENABLED(Z_PROBE_SLED) || ENABLED(Z_SAFE_HOMING) || HAS_PROBING_PROCEDURE |
|
|
|
@ -1774,7 +1767,9 @@ static void clean_up_after_endstop_or_probe_move() { |
|
|
|
float oldXpos = current_position[X_AXIS]; // save x position
|
|
|
|
float old_feedrate = feedrate; |
|
|
|
if (dock) { |
|
|
|
raise_z_after_probing(); // raise Z
|
|
|
|
#if Z_RAISE_AFTER_PROBING > 0 |
|
|
|
do_probe_raise(Z_RAISE_AFTER_PROBING); |
|
|
|
#endif |
|
|
|
// Dock sled a bit closer to ensure proper capturing
|
|
|
|
feedrate = XY_PROBE_FEEDRATE; |
|
|
|
do_blocking_move_to_x(X_MAX_POS + SLED_DOCKING_OFFSET + offset - 1); |
|
|
|
@ -1804,15 +1799,17 @@ static void clean_up_after_endstop_or_probe_move() { |
|
|
|
|
|
|
|
if (endstops.z_probe_enabled) return; |
|
|
|
|
|
|
|
// Make room for probe
|
|
|
|
#if Z_RAISE_BEFORE_PROBING > 0 |
|
|
|
do_probe_raise(Z_RAISE_BEFORE_PROBING); |
|
|
|
#endif |
|
|
|
|
|
|
|
#if ENABLED(Z_PROBE_SLED) |
|
|
|
|
|
|
|
dock_sled(false); |
|
|
|
|
|
|
|
#elif HAS_Z_SERVO_ENDSTOP |
|
|
|
|
|
|
|
// Make room for Z Servo
|
|
|
|
do_probe_raise(Z_RAISE_BEFORE_PROBING); |
|
|
|
|
|
|
|
// Engage Z Servo endstop if enabled
|
|
|
|
DEPLOY_Z_SERVO(); |
|
|
|
|
|
|
|
@ -1906,15 +1903,17 @@ static void clean_up_after_endstop_or_probe_move() { |
|
|
|
|
|
|
|
if (!endstops.z_probe_enabled) return; |
|
|
|
|
|
|
|
// Make more room for the servo
|
|
|
|
#if Z_RAISE_AFTER_PROBING > 0 |
|
|
|
do_probe_raise(Z_RAISE_AFTER_PROBING); |
|
|
|
#endif |
|
|
|
|
|
|
|
#if ENABLED(Z_PROBE_SLED) |
|
|
|
|
|
|
|
dock_sled(true); |
|
|
|
|
|
|
|
#elif HAS_Z_SERVO_ENDSTOP |
|
|
|
|
|
|
|
// Make room for the servo
|
|
|
|
do_probe_raise(Z_RAISE_AFTER_PROBING); |
|
|
|
|
|
|
|
// Change the Z servo angle
|
|
|
|
STOW_Z_SERVO(); |
|
|
|
|
|
|
|
@ -2080,27 +2079,24 @@ static void clean_up_after_endstop_or_probe_move() { |
|
|
|
return current_position[Z_AXIS]; |
|
|
|
} |
|
|
|
|
|
|
|
#endif // HAS_BED_PROBE
|
|
|
|
|
|
|
|
#if HAS_PROBING_PROCEDURE |
|
|
|
|
|
|
|
inline void do_blocking_move_to_xy(float x, float y) { |
|
|
|
do_blocking_move_to(x, y, current_position[Z_AXIS]); |
|
|
|
} |
|
|
|
|
|
|
|
enum ProbeAction { |
|
|
|
ProbeStay = 0, |
|
|
|
ProbeDeploy = _BV(0), |
|
|
|
ProbeStow = _BV(1), |
|
|
|
ProbeDeployAndStow = (ProbeDeploy | ProbeStow) |
|
|
|
}; |
|
|
|
|
|
|
|
// Probe bed height at position (x,y), returns the measured z value
|
|
|
|
static float probe_pt(float x, float y, float z_raise, ProbeAction probe_action = ProbeDeployAndStow, int verbose_level = 1) { |
|
|
|
//
|
|
|
|
// - Move to the given XY
|
|
|
|
// - Deploy the probe, if not already deployed
|
|
|
|
// - Probe the bed, get the Z position
|
|
|
|
// - Depending on the 'stow' flag
|
|
|
|
// - Stow the probe, or
|
|
|
|
// - Raise to the BETWEEN height
|
|
|
|
// - Return the probed Z position
|
|
|
|
//
|
|
|
|
static float probe_pt(float x, float y, bool stow = true, int verbose_level = 1) { |
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE) |
|
|
|
if (DEBUGGING(LEVELING)) { |
|
|
|
SERIAL_ECHOLNPGM("probe_pt >>>"); |
|
|
|
SERIAL_ECHOPAIR("> ProbeAction:", probe_action); |
|
|
|
SERIAL_ECHOPAIR("> stow:", stow); |
|
|
|
SERIAL_EOL; |
|
|
|
DEBUG_POS("", current_position); |
|
|
|
} |
|
|
|
@ -2111,39 +2107,37 @@ static void clean_up_after_endstop_or_probe_move() { |
|
|
|
// Raise by z_raise, then move the Z probe to the given XY
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE) |
|
|
|
if (DEBUGGING(LEVELING)) { |
|
|
|
SERIAL_ECHOPAIR("Z Raise by z_raise ", z_raise); |
|
|
|
SERIAL_EOL; |
|
|
|
} |
|
|
|
#endif |
|
|
|
do_probe_raise(z_raise); // this also updates current_position
|
|
|
|
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE) |
|
|
|
if (DEBUGGING(LEVELING)) { |
|
|
|
SERIAL_ECHOPAIR("> do_blocking_move_to_xy ", x - (X_PROBE_OFFSET_FROM_EXTRUDER)); |
|
|
|
SERIAL_ECHOPAIR("> do_blocking_move_to ", x - (X_PROBE_OFFSET_FROM_EXTRUDER)); |
|
|
|
SERIAL_ECHOPAIR(", ", y - (Y_PROBE_OFFSET_FROM_EXTRUDER)); |
|
|
|
SERIAL_ECHOPAIR(", ", max(current_position[Z_AXIS], Z_RAISE_BETWEEN_PROBINGS)); |
|
|
|
SERIAL_EOL; |
|
|
|
} |
|
|
|
#endif |
|
|
|
|
|
|
|
// this also updates current_position
|
|
|
|
feedrate = XY_PROBE_FEEDRATE; |
|
|
|
do_blocking_move_to_xy(x - (X_PROBE_OFFSET_FROM_EXTRUDER), y - (Y_PROBE_OFFSET_FROM_EXTRUDER)); |
|
|
|
|
|
|
|
if (probe_action & ProbeDeploy) { |
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE) |
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("> ProbeDeploy"); |
|
|
|
#endif |
|
|
|
deploy_z_probe(); |
|
|
|
} |
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE) |
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("> deploy_z_probe"); |
|
|
|
#endif |
|
|
|
deploy_z_probe(); |
|
|
|
|
|
|
|
float measured_z = run_z_probe(); |
|
|
|
|
|
|
|
if (probe_action & ProbeStow) { |
|
|
|
if (stow) { |
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE) |
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("> ProbeStow (stow_z_probe will do Z Raise)"); |
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("> stow_z_probe"); |
|
|
|
#endif |
|
|
|
stow_z_probe(); |
|
|
|
} |
|
|
|
#if Z_RAISE_BETWEEN_PROBINGS > 0 |
|
|
|
else { |
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE) |
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("> do_probe_raise"); |
|
|
|
#endif |
|
|
|
do_probe_raise(Z_RAISE_BETWEEN_PROBINGS); |
|
|
|
} |
|
|
|
#endif |
|
|
|
|
|
|
|
if (verbose_level > 2) { |
|
|
|
SERIAL_PROTOCOLPGM("Bed X: "); |
|
|
|
@ -2164,7 +2158,7 @@ static void clean_up_after_endstop_or_probe_move() { |
|
|
|
return measured_z; |
|
|
|
} |
|
|
|
|
|
|
|
#endif // AUTO_BED_LEVELING_FEATURE || Z_MIN_PROBE_REPEATABILITY_TEST
|
|
|
|
#endif // HAS_BED_PROBE
|
|
|
|
|
|
|
|
#if ENABLED(AUTO_BED_LEVELING_FEATURE) |
|
|
|
|
|
|
|
@ -3383,8 +3377,10 @@ inline void gcode_G28() { |
|
|
|
|
|
|
|
bool dryrun = code_seen('D'); |
|
|
|
|
|
|
|
#if DISABLED(Z_PROBE_SLED) && DISABLED(Z_PROBE_ALLEN_KEY) |
|
|
|
bool deploy_probe_for_each_reading = code_seen('E'); |
|
|
|
#if ENABLED(Z_PROBE_SLED) || ENABLED(Z_PROBE_ALLEN_KEY) |
|
|
|
const bool stow_probe_after_each = false; |
|
|
|
#else |
|
|
|
bool stow_probe_after_each = code_seen('E'); |
|
|
|
#endif |
|
|
|
|
|
|
|
#if ENABLED(AUTO_BED_LEVELING_GRID) |
|
|
|
@ -3541,42 +3537,13 @@ inline void gcode_G28() { |
|
|
|
for (int xCount = xStart; xCount != xStop; xCount += xInc) { |
|
|
|
double xProbe = left_probe_bed_position + xGridSpacing * xCount; |
|
|
|
|
|
|
|
// raise extruder
|
|
|
|
float measured_z, |
|
|
|
z_raise = probePointCounter ? Z_RAISE_BETWEEN_PROBINGS : Z_RAISE_BEFORE_PROBING; |
|
|
|
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE) |
|
|
|
if (DEBUGGING(LEVELING)) { |
|
|
|
SERIAL_ECHOPGM("z_raise = ("); |
|
|
|
if (probePointCounter) |
|
|
|
SERIAL_ECHOPGM("between) "); |
|
|
|
else |
|
|
|
SERIAL_ECHOPGM("before) "); |
|
|
|
SERIAL_ECHOLN(z_raise); |
|
|
|
} |
|
|
|
#endif |
|
|
|
|
|
|
|
#if ENABLED(DELTA) |
|
|
|
// Avoid probing the corners (outside the round or hexagon print surface) on a delta printer.
|
|
|
|
float distance_from_center = sqrt(xProbe * xProbe + yProbe * yProbe); |
|
|
|
if (distance_from_center > DELTA_PROBEABLE_RADIUS) continue; |
|
|
|
#endif //DELTA
|
|
|
|
|
|
|
|
#if ENABLED(Z_PROBE_SLED) || ENABLED(Z_PROBE_ALLEN_KEY) |
|
|
|
const ProbeAction act = ProbeStay; |
|
|
|
#else |
|
|
|
ProbeAction act; |
|
|
|
if (deploy_probe_for_each_reading) // G29 E - Stow between probes
|
|
|
|
act = ProbeDeployAndStow; |
|
|
|
else if (yCount == 0 && xCount == xStart) |
|
|
|
act = ProbeDeploy; |
|
|
|
else if (yCount == auto_bed_leveling_grid_points - 1 && xCount == xStop - xInc) |
|
|
|
act = ProbeStow; |
|
|
|
else |
|
|
|
act = ProbeStay; |
|
|
|
#endif |
|
|
|
|
|
|
|
measured_z = probe_pt(xProbe, yProbe, z_raise, act, verbose_level); |
|
|
|
float measured_z = probe_pt(xProbe, yProbe, stow_probe_after_each, verbose_level); |
|
|
|
|
|
|
|
#if DISABLED(DELTA) |
|
|
|
mean += measured_z; |
|
|
|
@ -3597,10 +3564,39 @@ inline void gcode_G28() { |
|
|
|
} //xProbe
|
|
|
|
} //yProbe
|
|
|
|
|
|
|
|
#else // !AUTO_BED_LEVELING_GRID
|
|
|
|
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE) |
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("> probing complete", current_position); |
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("> 3-point Leveling"); |
|
|
|
#endif |
|
|
|
|
|
|
|
// Probe at 3 arbitrary points
|
|
|
|
float z_at_pt_1 = probe_pt( ABL_PROBE_PT_1_X + home_offset[X_AXIS], |
|
|
|
ABL_PROBE_PT_1_Y + home_offset[Y_AXIS], |
|
|
|
stow_probe_after_each, verbose_level), |
|
|
|
z_at_pt_2 = probe_pt( ABL_PROBE_PT_2_X + home_offset[X_AXIS], |
|
|
|
ABL_PROBE_PT_2_Y + home_offset[Y_AXIS], |
|
|
|
stow_probe_after_each, verbose_level), |
|
|
|
z_at_pt_3 = probe_pt( ABL_PROBE_PT_3_X + home_offset[X_AXIS], |
|
|
|
ABL_PROBE_PT_3_Y + home_offset[Y_AXIS], |
|
|
|
stow_probe_after_each, verbose_level); |
|
|
|
|
|
|
|
if (!dryrun) set_bed_level_equation_3pts(z_at_pt_1, z_at_pt_2, z_at_pt_3); |
|
|
|
|
|
|
|
#endif // !AUTO_BED_LEVELING_GRID
|
|
|
|
|
|
|
|
// Raise to Z_RAISE_AFTER_PROBING. Stow the probe.
|
|
|
|
stow_z_probe(); |
|
|
|
|
|
|
|
// Restore state after probing
|
|
|
|
clean_up_after_endstop_or_probe_move(); |
|
|
|
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE) |
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("> probing complete", current_position); |
|
|
|
#endif |
|
|
|
|
|
|
|
// Calculate leveling, print reports, correct the position
|
|
|
|
#if ENABLED(AUTO_BED_LEVELING_GRID) |
|
|
|
#if ENABLED(DELTA) |
|
|
|
|
|
|
|
if (!dryrun) extrapolate_unprobed_bed_level(); |
|
|
|
@ -3696,41 +3692,7 @@ inline void gcode_G28() { |
|
|
|
} |
|
|
|
} //do_topography_map
|
|
|
|
#endif //!DELTA
|
|
|
|
|
|
|
|
#else // !AUTO_BED_LEVELING_GRID
|
|
|
|
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE) |
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("> 3-point Leveling"); |
|
|
|
#endif |
|
|
|
|
|
|
|
#if ENABLED(Z_PROBE_SLED) || ENABLED(Z_PROBE_ALLEN_KEY) |
|
|
|
const ProbeAction p1 = ProbeStay, p2 = ProbeStay, p3 = ProbeStay; |
|
|
|
#else |
|
|
|
// Actions for each probe
|
|
|
|
ProbeAction p1, p2, p3; |
|
|
|
if (deploy_probe_for_each_reading) |
|
|
|
p1 = p2 = p3 = ProbeDeployAndStow; |
|
|
|
else |
|
|
|
p1 = ProbeDeploy, p2 = ProbeStay, p3 = ProbeStow; |
|
|
|
#endif |
|
|
|
|
|
|
|
// Probe at 3 arbitrary points
|
|
|
|
float z_at_pt_1 = probe_pt( ABL_PROBE_PT_1_X + home_offset[X_AXIS], |
|
|
|
ABL_PROBE_PT_1_Y + home_offset[Y_AXIS], |
|
|
|
Z_RAISE_BEFORE_PROBING, |
|
|
|
p1, verbose_level), |
|
|
|
z_at_pt_2 = probe_pt( ABL_PROBE_PT_2_X + home_offset[X_AXIS], |
|
|
|
ABL_PROBE_PT_2_Y + home_offset[Y_AXIS], |
|
|
|
Z_RAISE_BETWEEN_PROBINGS, |
|
|
|
p2, verbose_level), |
|
|
|
z_at_pt_3 = probe_pt( ABL_PROBE_PT_3_X + home_offset[X_AXIS], |
|
|
|
ABL_PROBE_PT_3_Y + home_offset[Y_AXIS], |
|
|
|
Z_RAISE_BETWEEN_PROBINGS, |
|
|
|
p3, verbose_level); |
|
|
|
|
|
|
|
if (!dryrun) set_bed_level_equation_3pts(z_at_pt_1, z_at_pt_2, z_at_pt_3); |
|
|
|
|
|
|
|
#endif // !AUTO_BED_LEVELING_GRID
|
|
|
|
#endif // AUTO_BED_LEVELING_GRID
|
|
|
|
|
|
|
|
#if DISABLED(DELTA) |
|
|
|
if (verbose_level > 0) |
|
|
|
@ -3745,13 +3707,12 @@ inline void gcode_G28() { |
|
|
|
float x_tmp = current_position[X_AXIS] + X_PROBE_OFFSET_FROM_EXTRUDER, |
|
|
|
y_tmp = current_position[Y_AXIS] + Y_PROBE_OFFSET_FROM_EXTRUDER, |
|
|
|
z_tmp = current_position[Z_AXIS], |
|
|
|
real_z = stepper.get_axis_position_mm(Z_AXIS); //get the real Z (since planner.adjusted_position is now correcting the plane)
|
|
|
|
stepper_z = stepper.get_axis_position_mm(Z_AXIS); //get the real Z (since planner.adjusted_position is now correcting the plane)
|
|
|
|
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE) |
|
|
|
if (DEBUGGING(LEVELING)) { |
|
|
|
SERIAL_ECHOPAIR("> BEFORE apply_rotation_xyz > z_tmp = ", z_tmp); |
|
|
|
SERIAL_EOL; |
|
|
|
SERIAL_ECHOPAIR("> BEFORE apply_rotation_xyz > real_z = ", real_z); |
|
|
|
SERIAL_ECHOPAIR("> BEFORE apply_rotation_xyz > stepper_z = ", stepper_z); |
|
|
|
SERIAL_ECHOPAIR(" ... z_tmp = ", z_tmp); |
|
|
|
SERIAL_EOL; |
|
|
|
} |
|
|
|
#endif |
|
|
|
@ -3759,28 +3720,6 @@ inline void gcode_G28() { |
|
|
|
// Apply the correction sending the Z probe offset
|
|
|
|
apply_rotation_xyz(planner.bed_level_matrix, x_tmp, y_tmp, z_tmp); |
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the current Z position and send it to the planner. |
|
|
|
* |
|
|
|
* >> (z_tmp - real_z) : The rotated current Z minus the uncorrected Z |
|
|
|
* (most recent planner.set_position_mm/sync_plan_position) |
|
|
|
* |
|
|
|
* >> zprobe_zoffset : Z distance from nozzle to Z probe |
|
|
|
* (set by default, M851, EEPROM, or Menu) |
|
|
|
* |
|
|
|
* >> Z_RAISE_AFTER_PROBING : The distance the Z probe will have lifted |
|
|
|
* after the last probe |
|
|
|
* |
|
|
|
* >> Should home_offset[Z_AXIS] be included? |
|
|
|
* |
|
|
|
* |
|
|
|
* Discussion: home_offset[Z_AXIS] was applied in G28 to set the |
|
|
|
* starting Z. If Z is not tweaked in G29 -and- the Z probe in G29 is |
|
|
|
* not actually "homing" Z... then perhaps it should not be included |
|
|
|
* here. The purpose of home_offset[] is to adjust for inaccurate |
|
|
|
* endstops, not for reasonably accurate probes. If it were added |
|
|
|
* here, it could be seen as a compensating factor for the Z probe. |
|
|
|
*/ |
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE) |
|
|
|
if (DEBUGGING(LEVELING)) { |
|
|
|
SERIAL_ECHOPAIR("> AFTER apply_rotation_xyz > z_tmp = ", z_tmp); |
|
|
|
@ -3788,30 +3727,16 @@ inline void gcode_G28() { |
|
|
|
} |
|
|
|
#endif |
|
|
|
|
|
|
|
current_position[Z_AXIS] = -zprobe_zoffset + (z_tmp - real_z) |
|
|
|
#if HAS_Z_SERVO_ENDSTOP || ENABLED(Z_PROBE_ALLEN_KEY) || ENABLED(Z_PROBE_SLED) |
|
|
|
+ Z_RAISE_AFTER_PROBING |
|
|
|
#endif |
|
|
|
; |
|
|
|
// current_position[Z_AXIS] += home_offset[Z_AXIS]; // The Z probe determines Z=0, not "Z home"
|
|
|
|
// Adjust the current Z and send it to the planner.
|
|
|
|
current_position[Z_AXIS] += z_tmp - stepper_z; |
|
|
|
SYNC_PLAN_POSITION_KINEMATIC(); |
|
|
|
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE) |
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("> corrected Z in G29", current_position); |
|
|
|
#endif |
|
|
|
} |
|
|
|
|
|
|
|
#endif // !DELTA
|
|
|
|
|
|
|
|
// Final raise of Z axis after probing.
|
|
|
|
raise_z_after_probing(); |
|
|
|
|
|
|
|
// Stow the probe. Servo will raise if needed.
|
|
|
|
stow_z_probe(); |
|
|
|
|
|
|
|
// Restore state after probing
|
|
|
|
clean_up_after_endstop_or_probe_move(); |
|
|
|
|
|
|
|
#ifdef Z_PROBE_END_SCRIPT |
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE) |
|
|
|
if (DEBUGGING(LEVELING)) { |
|
|
|
@ -3824,9 +3749,7 @@ inline void gcode_G28() { |
|
|
|
#endif |
|
|
|
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE) |
|
|
|
if (DEBUGGING(LEVELING)) { |
|
|
|
SERIAL_ECHOLNPGM("<<< gcode_G29"); |
|
|
|
} |
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("<<< gcode_G29"); |
|
|
|
#endif |
|
|
|
|
|
|
|
bed_leveling_in_progress = false; |
|
|
|
@ -3847,12 +3770,10 @@ inline void gcode_G28() { |
|
|
|
|
|
|
|
setup_for_endstop_or_probe_move(); |
|
|
|
|
|
|
|
deploy_z_probe(); |
|
|
|
|
|
|
|
stepper.synchronize(); |
|
|
|
|
|
|
|
// TODO: clear the leveling matrix or the planner will be set incorrectly
|
|
|
|
float measured_z = run_z_probe(); // clears the ABL non-delta matrix only
|
|
|
|
float measured_z = probe_pt(current_position[X_AXIS] + X_PROBE_OFFSET_FROM_EXTRUDER, |
|
|
|
current_position[Y_AXIS] + Y_PROBE_OFFSET_FROM_EXTRUDER, |
|
|
|
true, 1); |
|
|
|
|
|
|
|
SERIAL_PROTOCOLPGM("Bed X: "); |
|
|
|
SERIAL_PROTOCOL(current_position[X_AXIS] + X_PROBE_OFFSET_FROM_EXTRUDER + 0.0001); |
|
|
|
@ -3862,13 +3783,25 @@ inline void gcode_G28() { |
|
|
|
SERIAL_PROTOCOL(measured_z + 0.0001); |
|
|
|
SERIAL_EOL; |
|
|
|
|
|
|
|
stow_z_probe(); |
|
|
|
|
|
|
|
clean_up_after_endstop_or_probe_move(); |
|
|
|
|
|
|
|
report_current_position(); |
|
|
|
} |
|
|
|
|
|
|
|
#if ENABLED(Z_PROBE_SLED) |
|
|
|
|
|
|
|
/**
|
|
|
|
* G31: Deploy the Z probe |
|
|
|
*/ |
|
|
|
inline void gcode_G31() { deploy_z_probe(); } |
|
|
|
|
|
|
|
/**
|
|
|
|
* G32: Stow the Z probe |
|
|
|
*/ |
|
|
|
inline void gcode_G32() { stow_z_probe(); } |
|
|
|
|
|
|
|
#endif // Z_PROBE_SLED
|
|
|
|
|
|
|
|
#endif // HAS_BED_PROBE
|
|
|
|
|
|
|
|
/**
|
|
|
|
@ -4210,9 +4143,9 @@ inline void gcode_M42() { |
|
|
|
Y_current = current_position[Y_AXIS]; |
|
|
|
|
|
|
|
#if ENABLED(Z_PROBE_SLED) || ENABLED(Z_PROBE_ALLEN_KEY) |
|
|
|
const bool deploy_probe_for_each_reading = false; |
|
|
|
const bool stow_probe_after_each = false; |
|
|
|
#else |
|
|
|
bool deploy_probe_for_each_reading = code_seen('E'); |
|
|
|
bool stow_probe_after_each = code_seen('E'); |
|
|
|
#endif |
|
|
|
|
|
|
|
float X_probe_location = code_seen('X') ? code_value_axis_units(X_AXIS) : X_current + X_PROBE_OFFSET_FROM_EXTRUDER; |
|
|
|
@ -4265,24 +4198,8 @@ inline void gcode_M42() { |
|
|
|
|
|
|
|
setup_for_endstop_or_probe_move(); |
|
|
|
|
|
|
|
do_probe_raise(Z_RAISE_BEFORE_PROBING); |
|
|
|
|
|
|
|
feedrate = XY_PROBE_FEEDRATE; |
|
|
|
do_blocking_move_to_xy(X_probe_location - (X_PROBE_OFFSET_FROM_EXTRUDER), Y_probe_location - (Y_PROBE_OFFSET_FROM_EXTRUDER)); |
|
|
|
|
|
|
|
/**
|
|
|
|
* OK, do the initial probe to get us close to the bed. |
|
|
|
* Then retrace the right amount and use that in subsequent probes |
|
|
|
*/ |
|
|
|
|
|
|
|
// Height before each probe (except the first)
|
|
|
|
float z_between = deploy_probe_for_each_reading ? Z_RAISE_BEFORE_PROBING : Z_RAISE_BETWEEN_PROBINGS; |
|
|
|
|
|
|
|
// Deploy the probe and probe the first point
|
|
|
|
probe_pt(X_probe_location, Y_probe_location, |
|
|
|
Z_RAISE_BEFORE_PROBING, |
|
|
|
deploy_probe_for_each_reading ? ProbeDeployAndStow : ProbeDeploy, |
|
|
|
verbose_level); |
|
|
|
// Move to the first point, deploy, and probe
|
|
|
|
probe_pt(X_probe_location, Y_probe_location, stow_probe_after_each, verbose_level); |
|
|
|
|
|
|
|
randomSeed(millis()); |
|
|
|
|
|
|
|
@ -4302,12 +4219,9 @@ inline void gcode_M42() { |
|
|
|
if (verbose_level > 3) { |
|
|
|
SERIAL_ECHOPAIR("Starting radius: ", radius); |
|
|
|
SERIAL_ECHOPAIR(" angle: ", angle); |
|
|
|
delay(100); |
|
|
|
if (dir > 0) |
|
|
|
SERIAL_ECHO(" Direction: Counter Clockwise \n"); |
|
|
|
else |
|
|
|
SERIAL_ECHO(" Direction: Clockwise \n"); |
|
|
|
delay(100); |
|
|
|
SERIAL_ECHO(" Direction: "); |
|
|
|
if (dir > 0) SERIAL_ECHO("Counter "); |
|
|
|
SERIAL_ECHOLN("Clockwise"); |
|
|
|
} |
|
|
|
|
|
|
|
for (uint8_t l = 0; l < n_legs - 1; l++) { |
|
|
|
@ -4346,7 +4260,6 @@ inline void gcode_M42() { |
|
|
|
SERIAL_ECHOPAIR("Pulling point towards center:", X_current); |
|
|
|
SERIAL_ECHOPAIR(", ", Y_current); |
|
|
|
SERIAL_EOL; |
|
|
|
delay(50); |
|
|
|
} |
|
|
|
} |
|
|
|
#endif |
|
|
|
@ -4356,22 +4269,13 @@ inline void gcode_M42() { |
|
|
|
SERIAL_ECHOPAIR("y: ", Y_current); |
|
|
|
SERIAL_ECHOPAIR(" z: ", current_position[Z_AXIS]); |
|
|
|
SERIAL_EOL; |
|
|
|
delay(55); |
|
|
|
} |
|
|
|
do_blocking_move_to_xy(X_current, Y_current); |
|
|
|
} // n_legs loop
|
|
|
|
} // n_legs
|
|
|
|
|
|
|
|
// The last probe will differ
|
|
|
|
bool last_probe = (n == n_samples - 1); |
|
|
|
|
|
|
|
// Probe a single point
|
|
|
|
sample_set[n] = probe_pt( |
|
|
|
X_probe_location, Y_probe_location, |
|
|
|
z_between, |
|
|
|
deploy_probe_for_each_reading ? ProbeDeployAndStow : last_probe ? ProbeStow : ProbeStay, |
|
|
|
verbose_level |
|
|
|
); |
|
|
|
sample_set[n] = probe_pt(X_probe_location, Y_probe_location, stow_probe_after_each, verbose_level); |
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the current mean for the data points we have so far |
|
|
|
@ -4397,7 +4301,6 @@ inline void gcode_M42() { |
|
|
|
SERIAL_PROTOCOL((int)n_samples); |
|
|
|
SERIAL_PROTOCOLPGM(" z: "); |
|
|
|
SERIAL_PROTOCOL_F(current_position[Z_AXIS], 6); |
|
|
|
delay(50); |
|
|
|
if (verbose_level > 2) { |
|
|
|
SERIAL_PROTOCOLPGM(" mean: "); |
|
|
|
SERIAL_PROTOCOL_F(mean, 6); |
|
|
|
@ -4408,17 +4311,10 @@ inline void gcode_M42() { |
|
|
|
SERIAL_EOL; |
|
|
|
} |
|
|
|
|
|
|
|
// Raise before the next loop for the legs,
|
|
|
|
// or do the final raise after the last probe
|
|
|
|
if (last_probe) |
|
|
|
do_probe_raise(Z_RAISE_AFTER_PROBING); |
|
|
|
else if (n_legs) { |
|
|
|
do_probe_raise(z_between); |
|
|
|
if (!last_probe) delay(500); |
|
|
|
} |
|
|
|
|
|
|
|
} // End of probe loop
|
|
|
|
|
|
|
|
stow_z_probe(); |
|
|
|
|
|
|
|
if (verbose_level > 0) { |
|
|
|
SERIAL_PROTOCOLPGM("Mean: "); |
|
|
|
SERIAL_PROTOCOL_F(mean, 6); |
|
|
|
@ -5967,16 +5863,12 @@ inline void gcode_M400() { stepper.synchronize(); } |
|
|
|
/**
|
|
|
|
* M401: Engage Z Servo endstop if available |
|
|
|
*/ |
|
|
|
inline void gcode_M401() { |
|
|
|
deploy_z_probe(); |
|
|
|
} |
|
|
|
inline void gcode_M401() { deploy_z_probe(); } |
|
|
|
|
|
|
|
/**
|
|
|
|
* M402: Retract Z Servo endstop if enabled |
|
|
|
*/ |
|
|
|
inline void gcode_M402() { |
|
|
|
stow_z_probe(); |
|
|
|
} |
|
|
|
inline void gcode_M402() { stow_z_probe(); } |
|
|
|
|
|
|
|
#endif // HAS_BED_PROBE
|
|
|
|
|
|
|
|
@ -6858,10 +6750,11 @@ void process_next_command() { |
|
|
|
#if ENABLED(Z_PROBE_SLED) |
|
|
|
|
|
|
|
case 31: // G31: dock the sled
|
|
|
|
stow_z_probe(); |
|
|
|
gcode_G31(); |
|
|
|
break; |
|
|
|
|
|
|
|
case 32: // G32: undock the sled
|
|
|
|
deploy_z_probe(); |
|
|
|
gcode_G32(); |
|
|
|
break; |
|
|
|
|
|
|
|
#endif // Z_PROBE_SLED
|
|
|
|
|
Scott Lahteine
8 years ago
GitHub