|
|
|
|
@ -134,12 +134,11 @@ float destination[XYZE]; // = { 0 }
|
|
|
|
|
// no other feedrate is specified. Overridden for special moves.
|
|
|
|
|
// Set by the last G0 through G5 command's "F" parameter.
|
|
|
|
|
// Functions that override this for custom moves *must always* restore it!
|
|
|
|
|
float feedrate_mm_s = MMM_TO_MMS(1500.0f);
|
|
|
|
|
|
|
|
|
|
feedRate_t feedrate_mm_s = MMM_TO_MMS(1500);
|
|
|
|
|
int16_t feedrate_percentage = 100;
|
|
|
|
|
|
|
|
|
|
// Homing feedrate is const progmem - compare to constexpr in the header
|
|
|
|
|
const float homing_feedrate_mm_s[XYZ] PROGMEM = {
|
|
|
|
|
const feedRate_t homing_feedrate_mm_s[XYZ] PROGMEM = {
|
|
|
|
|
#if ENABLED(DELTA)
|
|
|
|
|
MMM_TO_MMS(HOMING_FEEDRATE_Z), MMM_TO_MMS(HOMING_FEEDRATE_Z),
|
|
|
|
|
#else
|
|
|
|
|
@ -285,29 +284,21 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) {
|
|
|
|
|
* Move the planner to the current position from wherever it last moved
|
|
|
|
|
* (or from wherever it has been told it is located).
|
|
|
|
|
*/
|
|
|
|
|
void line_to_current_position(const float &fr_mm_s/*=feedrate_mm_s*/) {
|
|
|
|
|
planner.buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], fr_mm_s, active_extruder);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Move the planner to the position stored in the destination array, which is
|
|
|
|
|
* used by G0/G1/G2/G3/G5 and many other functions to set a destination.
|
|
|
|
|
*/
|
|
|
|
|
void buffer_line_to_destination(const float fr_mm_s) {
|
|
|
|
|
planner.buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], fr_mm_s, active_extruder);
|
|
|
|
|
void line_to_current_position(const feedRate_t &fr_mm_s/*=feedrate_mm_s*/) {
|
|
|
|
|
planner.buffer_line(current_position, fr_mm_s, active_extruder);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#if IS_KINEMATIC
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Calculate delta, start a line, and set current_position to destination
|
|
|
|
|
* Buffer a fast move without interpolation. Set current_position to destination
|
|
|
|
|
*/
|
|
|
|
|
void prepare_uninterpolated_move_to_destination(const float &fr_mm_s/*=0.0*/) {
|
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("prepare_uninterpolated_move_to_destination", destination);
|
|
|
|
|
void prepare_fast_move_to_destination(const feedRate_t &scaled_fr_mm_s/*=MMS_SCALED(feedrate_mm_s)*/) {
|
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("prepare_fast_move_to_destination", destination);
|
|
|
|
|
|
|
|
|
|
#if UBL_SEGMENTED
|
|
|
|
|
// ubl segmented line will do z-only moves in single segment
|
|
|
|
|
ubl.prepare_segmented_line_to(destination, MMS_SCALED(fr_mm_s ? fr_mm_s : feedrate_mm_s));
|
|
|
|
|
// UBL segmented line will do Z-only moves in single segment
|
|
|
|
|
ubl.line_to_destination_segmented(scaled_fr_mm_s);
|
|
|
|
|
#else
|
|
|
|
|
if ( current_position[X_AXIS] == destination[X_AXIS]
|
|
|
|
|
&& current_position[Y_AXIS] == destination[Y_AXIS]
|
|
|
|
|
@ -315,7 +306,7 @@ void buffer_line_to_destination(const float fr_mm_s) {
|
|
|
|
|
&& current_position[E_AXIS] == destination[E_AXIS]
|
|
|
|
|
) return;
|
|
|
|
|
|
|
|
|
|
planner.buffer_line(destination, MMS_SCALED(fr_mm_s ? fr_mm_s : feedrate_mm_s), active_extruder);
|
|
|
|
|
planner.buffer_line(destination, scaled_fr_mm_s, active_extruder);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
set_current_from_destination();
|
|
|
|
|
@ -323,14 +314,40 @@ void buffer_line_to_destination(const float fr_mm_s) {
|
|
|
|
|
|
|
|
|
|
#endif // IS_KINEMATIC
|
|
|
|
|
|
|
|
|
|
void _internal_move_to_destination(const feedRate_t &fr_mm_s/*=0.0f*/
|
|
|
|
|
#if IS_KINEMATIC
|
|
|
|
|
, const bool is_fast/*=false*/
|
|
|
|
|
#endif
|
|
|
|
|
) {
|
|
|
|
|
const feedRate_t old_feedrate = feedrate_mm_s;
|
|
|
|
|
if (fr_mm_s) feedrate_mm_s = fr_mm_s;
|
|
|
|
|
|
|
|
|
|
const uint16_t old_pct = feedrate_percentage;
|
|
|
|
|
feedrate_percentage = 100;
|
|
|
|
|
|
|
|
|
|
const float old_fac = planner.e_factor[active_extruder];
|
|
|
|
|
planner.e_factor[active_extruder] = 1.0f;
|
|
|
|
|
|
|
|
|
|
#if IS_KINEMATIC
|
|
|
|
|
if (is_fast)
|
|
|
|
|
prepare_fast_move_to_destination();
|
|
|
|
|
else
|
|
|
|
|
#endif
|
|
|
|
|
prepare_move_to_destination();
|
|
|
|
|
|
|
|
|
|
feedrate_mm_s = old_feedrate;
|
|
|
|
|
feedrate_percentage = old_pct;
|
|
|
|
|
planner.e_factor[active_extruder] = old_fac;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Plan a move to (X, Y, Z) and set the current_position
|
|
|
|
|
*/
|
|
|
|
|
void do_blocking_move_to(const float rx, const float ry, const float rz, const float &fr_mm_s/*=0.0*/) {
|
|
|
|
|
void do_blocking_move_to(const float rx, const float ry, const float rz, const feedRate_t &fr_mm_s/*=0.0*/) {
|
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_XYZ(">>> do_blocking_move_to", rx, ry, rz);
|
|
|
|
|
|
|
|
|
|
const float z_feedrate = fr_mm_s ? fr_mm_s : homing_feedrate(Z_AXIS),
|
|
|
|
|
xy_feedrate = fr_mm_s ? fr_mm_s : XY_PROBE_FEEDRATE_MM_S;
|
|
|
|
|
const feedRate_t z_feedrate = fr_mm_s ? fr_mm_s : homing_feedrate(Z_AXIS),
|
|
|
|
|
xy_feedrate = fr_mm_s ? fr_mm_s : feedRate_t(XY_PROBE_FEEDRATE_MM_S);
|
|
|
|
|
|
|
|
|
|
#if ENABLED(DELTA)
|
|
|
|
|
|
|
|
|
|
@ -344,33 +361,33 @@ void do_blocking_move_to(const float rx, const float ry, const float rz, const f
|
|
|
|
|
|
|
|
|
|
// when in the danger zone
|
|
|
|
|
if (current_position[Z_AXIS] > delta_clip_start_height) {
|
|
|
|
|
if (rz > delta_clip_start_height) { // staying in the danger zone
|
|
|
|
|
destination[X_AXIS] = rx; // move directly (uninterpolated)
|
|
|
|
|
if (rz > delta_clip_start_height) { // staying in the danger zone
|
|
|
|
|
destination[X_AXIS] = rx; // move directly (uninterpolated)
|
|
|
|
|
destination[Y_AXIS] = ry;
|
|
|
|
|
destination[Z_AXIS] = rz;
|
|
|
|
|
prepare_uninterpolated_move_to_destination(); // set_current_from_destination()
|
|
|
|
|
prepare_internal_fast_move_to_destination(); // set_current_from_destination()
|
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("danger zone move", current_position);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
destination[Z_AXIS] = delta_clip_start_height;
|
|
|
|
|
prepare_uninterpolated_move_to_destination(); // set_current_from_destination()
|
|
|
|
|
prepare_internal_fast_move_to_destination(); // set_current_from_destination()
|
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("zone border move", current_position);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (rz > current_position[Z_AXIS]) { // raising?
|
|
|
|
|
if (rz > current_position[Z_AXIS]) { // raising?
|
|
|
|
|
destination[Z_AXIS] = rz;
|
|
|
|
|
prepare_uninterpolated_move_to_destination(z_feedrate); // set_current_from_destination()
|
|
|
|
|
prepare_internal_fast_move_to_destination(z_feedrate); // set_current_from_destination()
|
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("z raise move", current_position);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
destination[X_AXIS] = rx;
|
|
|
|
|
destination[Y_AXIS] = ry;
|
|
|
|
|
prepare_move_to_destination(); // set_current_from_destination()
|
|
|
|
|
prepare_internal_move_to_destination(); // set_current_from_destination()
|
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("xy move", current_position);
|
|
|
|
|
|
|
|
|
|
if (rz < current_position[Z_AXIS]) { // lowering?
|
|
|
|
|
if (rz < current_position[Z_AXIS]) { // lowering?
|
|
|
|
|
destination[Z_AXIS] = rz;
|
|
|
|
|
prepare_uninterpolated_move_to_destination(z_feedrate); // set_current_from_destination()
|
|
|
|
|
prepare_fast_move_to_destination(z_feedrate); // set_current_from_destination()
|
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("z lower move", current_position);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@ -383,17 +400,17 @@ void do_blocking_move_to(const float rx, const float ry, const float rz, const f
|
|
|
|
|
// If Z needs to raise, do it before moving XY
|
|
|
|
|
if (destination[Z_AXIS] < rz) {
|
|
|
|
|
destination[Z_AXIS] = rz;
|
|
|
|
|
prepare_uninterpolated_move_to_destination(z_feedrate);
|
|
|
|
|
prepare_internal_fast_move_to_destination(z_feedrate);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
destination[X_AXIS] = rx;
|
|
|
|
|
destination[Y_AXIS] = ry;
|
|
|
|
|
prepare_uninterpolated_move_to_destination(xy_feedrate);
|
|
|
|
|
prepare_internal_fast_move_to_destination(xy_feedrate);
|
|
|
|
|
|
|
|
|
|
// If Z needs to lower, do it after moving XY
|
|
|
|
|
if (destination[Z_AXIS] > rz) {
|
|
|
|
|
destination[Z_AXIS] = rz;
|
|
|
|
|
prepare_uninterpolated_move_to_destination(z_feedrate);
|
|
|
|
|
prepare_internal_fast_move_to_destination(z_feedrate);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
@ -420,16 +437,16 @@ void do_blocking_move_to(const float rx, const float ry, const float rz, const f
|
|
|
|
|
|
|
|
|
|
planner.synchronize();
|
|
|
|
|
}
|
|
|
|
|
void do_blocking_move_to_x(const float &rx, const float &fr_mm_s/*=0.0*/) {
|
|
|
|
|
void do_blocking_move_to_x(const float &rx, const feedRate_t &fr_mm_s/*=0.0*/) {
|
|
|
|
|
do_blocking_move_to(rx, current_position[Y_AXIS], current_position[Z_AXIS], fr_mm_s);
|
|
|
|
|
}
|
|
|
|
|
void do_blocking_move_to_y(const float &ry, const float &fr_mm_s/*=0.0*/) {
|
|
|
|
|
void do_blocking_move_to_y(const float &ry, const feedRate_t &fr_mm_s/*=0.0*/) {
|
|
|
|
|
do_blocking_move_to(current_position[X_AXIS], ry, current_position[Z_AXIS], fr_mm_s);
|
|
|
|
|
}
|
|
|
|
|
void do_blocking_move_to_z(const float &rz, const float &fr_mm_s/*=0.0*/) {
|
|
|
|
|
void do_blocking_move_to_z(const float &rz, const feedRate_t &fr_mm_s/*=0.0*/) {
|
|
|
|
|
do_blocking_move_to(current_position[X_AXIS], current_position[Y_AXIS], rz, fr_mm_s);
|
|
|
|
|
}
|
|
|
|
|
void do_blocking_move_to_xy(const float &rx, const float &ry, const float &fr_mm_s/*=0.0*/) {
|
|
|
|
|
void do_blocking_move_to_xy(const float &rx, const float &ry, const feedRate_t &fr_mm_s/*=0.0*/) {
|
|
|
|
|
do_blocking_move_to(rx, ry, current_position[Z_AXIS], fr_mm_s);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@ -629,31 +646,31 @@ void restore_feedrate_and_scaling() {
|
|
|
|
|
* small incremental moves for DELTA or SCARA.
|
|
|
|
|
*
|
|
|
|
|
* For Unified Bed Leveling (Delta or Segmented Cartesian)
|
|
|
|
|
* the ubl.prepare_segmented_line_to method replaces this.
|
|
|
|
|
* the ubl.line_to_destination_segmented method replaces this.
|
|
|
|
|
*
|
|
|
|
|
* For Auto Bed Leveling (Bilinear) with SEGMENT_LEVELED_MOVES
|
|
|
|
|
* this is replaced by segmented_line_to_destination below.
|
|
|
|
|
*/
|
|
|
|
|
inline bool prepare_kinematic_move_to(const float (&rtarget)[XYZE]) {
|
|
|
|
|
inline bool line_to_destination_kinematic() {
|
|
|
|
|
|
|
|
|
|
// Get the top feedrate of the move in the XY plane
|
|
|
|
|
const float _feedrate_mm_s = MMS_SCALED(feedrate_mm_s);
|
|
|
|
|
const float scaled_fr_mm_s = MMS_SCALED(feedrate_mm_s);
|
|
|
|
|
|
|
|
|
|
const float xdiff = rtarget[X_AXIS] - current_position[X_AXIS],
|
|
|
|
|
ydiff = rtarget[Y_AXIS] - current_position[Y_AXIS];
|
|
|
|
|
const float xdiff = destination[X_AXIS] - current_position[X_AXIS],
|
|
|
|
|
ydiff = destination[Y_AXIS] - current_position[Y_AXIS];
|
|
|
|
|
|
|
|
|
|
// If the move is only in Z/E don't split up the move
|
|
|
|
|
if (!xdiff && !ydiff) {
|
|
|
|
|
planner.buffer_line(rtarget, _feedrate_mm_s, active_extruder);
|
|
|
|
|
planner.buffer_line(destination, scaled_fr_mm_s, active_extruder);
|
|
|
|
|
return false; // caller will update current_position
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Fail if attempting move outside printable radius
|
|
|
|
|
if (!position_is_reachable(rtarget[X_AXIS], rtarget[Y_AXIS])) return true;
|
|
|
|
|
if (!position_is_reachable(destination[X_AXIS], destination[Y_AXIS])) return true;
|
|
|
|
|
|
|
|
|
|
// Remaining cartesian distances
|
|
|
|
|
const float zdiff = rtarget[Z_AXIS] - current_position[Z_AXIS],
|
|
|
|
|
ediff = rtarget[E_AXIS] - current_position[E_AXIS];
|
|
|
|
|
const float zdiff = destination[Z_AXIS] - current_position[Z_AXIS],
|
|
|
|
|
ediff = destination[E_AXIS] - current_position[E_AXIS];
|
|
|
|
|
|
|
|
|
|
// Get the linear distance in XYZ
|
|
|
|
|
float cartesian_mm = SQRT(sq(xdiff) + sq(ydiff) + sq(zdiff));
|
|
|
|
|
@ -665,7 +682,7 @@ void restore_feedrate_and_scaling() {
|
|
|
|
|
if (UNEAR_ZERO(cartesian_mm)) return true;
|
|
|
|
|
|
|
|
|
|
// Minimum number of seconds to move the given distance
|
|
|
|
|
const float seconds = cartesian_mm / _feedrate_mm_s;
|
|
|
|
|
const float seconds = cartesian_mm / scaled_fr_mm_s;
|
|
|
|
|
|
|
|
|
|
// The number of segments-per-second times the duration
|
|
|
|
|
// gives the number of segments
|
|
|
|
|
@ -690,7 +707,7 @@ void restore_feedrate_and_scaling() {
|
|
|
|
|
cartesian_segment_mm = cartesian_mm * inv_segments;
|
|
|
|
|
|
|
|
|
|
#if ENABLED(SCARA_FEEDRATE_SCALING)
|
|
|
|
|
const float inv_duration = _feedrate_mm_s / cartesian_segment_mm;
|
|
|
|
|
const float inv_duration = scaled_fr_mm_s / cartesian_segment_mm;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
@ -717,7 +734,7 @@ void restore_feedrate_and_scaling() {
|
|
|
|
|
|
|
|
|
|
LOOP_XYZE(i) raw[i] += segment_distance[i];
|
|
|
|
|
|
|
|
|
|
if (!planner.buffer_line(raw, _feedrate_mm_s, active_extruder, cartesian_segment_mm
|
|
|
|
|
if (!planner.buffer_line(raw, scaled_fr_mm_s, active_extruder, cartesian_segment_mm
|
|
|
|
|
#if ENABLED(SCARA_FEEDRATE_SCALING)
|
|
|
|
|
, inv_duration
|
|
|
|
|
#endif
|
|
|
|
|
@ -726,7 +743,7 @@ void restore_feedrate_and_scaling() {
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Ensure last segment arrives at target location.
|
|
|
|
|
planner.buffer_line(rtarget, _feedrate_mm_s, active_extruder, cartesian_segment_mm
|
|
|
|
|
planner.buffer_line(destination, scaled_fr_mm_s, active_extruder, cartesian_segment_mm
|
|
|
|
|
#if ENABLED(SCARA_FEEDRATE_SCALING)
|
|
|
|
|
, inv_duration
|
|
|
|
|
#endif
|
|
|
|
|
@ -746,7 +763,7 @@ void restore_feedrate_and_scaling() {
|
|
|
|
|
* small incremental moves. This allows the planner to
|
|
|
|
|
* apply more detailed bed leveling to the full move.
|
|
|
|
|
*/
|
|
|
|
|
inline void segmented_line_to_destination(const float &fr_mm_s, const float segment_size=LEVELED_SEGMENT_LENGTH) {
|
|
|
|
|
inline void segmented_line_to_destination(const feedRate_t &fr_mm_s, const float segment_size=LEVELED_SEGMENT_LENGTH) {
|
|
|
|
|
|
|
|
|
|
const float xdiff = destination[X_AXIS] - current_position[X_AXIS],
|
|
|
|
|
ydiff = destination[Y_AXIS] - current_position[Y_AXIS];
|
|
|
|
|
@ -784,7 +801,7 @@ void restore_feedrate_and_scaling() {
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#if ENABLED(SCARA_FEEDRATE_SCALING)
|
|
|
|
|
const float inv_duration = _feedrate_mm_s / cartesian_segment_mm;
|
|
|
|
|
const float inv_duration = scaled_fr_mm_s / cartesian_segment_mm;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
// SERIAL_ECHOPAIR("mm=", cartesian_mm);
|
|
|
|
|
@ -832,13 +849,14 @@ void restore_feedrate_and_scaling() {
|
|
|
|
|
* Returns true if current_position[] was set to destination[]
|
|
|
|
|
*/
|
|
|
|
|
inline bool prepare_move_to_destination_cartesian() {
|
|
|
|
|
const float scaled_fr_mm_s = MMS_SCALED(feedrate_mm_s);
|
|
|
|
|
#if HAS_MESH
|
|
|
|
|
if (planner.leveling_active && planner.leveling_active_at_z(destination[Z_AXIS])) {
|
|
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
|
|
|
|
ubl.line_to_destination_cartesian(MMS_SCALED(feedrate_mm_s), active_extruder); // UBL's motion routine needs to know about
|
|
|
|
|
return true; // all moves, including Z-only moves.
|
|
|
|
|
ubl.line_to_destination_cartesian(scaled_fr_mm_s, active_extruder); // UBL's motion routine needs to know about
|
|
|
|
|
return true; // all moves, including Z-only moves.
|
|
|
|
|
#elif ENABLED(SEGMENT_LEVELED_MOVES)
|
|
|
|
|
segmented_line_to_destination(MMS_SCALED(feedrate_mm_s));
|
|
|
|
|
segmented_line_to_destination(scaled_fr_mm_s);
|
|
|
|
|
return false; // caller will update current_position
|
|
|
|
|
#else
|
|
|
|
|
/**
|
|
|
|
|
@ -847,9 +865,9 @@ void restore_feedrate_and_scaling() {
|
|
|
|
|
*/
|
|
|
|
|
if (current_position[X_AXIS] != destination[X_AXIS] || current_position[Y_AXIS] != destination[Y_AXIS]) {
|
|
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
|
|
|
|
mbl.line_to_destination(MMS_SCALED(feedrate_mm_s));
|
|
|
|
|
mbl.line_to_destination(scaled_fr_mm_s);
|
|
|
|
|
#elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
|
|
|
|
bilinear_line_to_destination(MMS_SCALED(feedrate_mm_s));
|
|
|
|
|
bilinear_line_to_destination(scaled_fr_mm_s);
|
|
|
|
|
#endif
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
@ -857,7 +875,7 @@ void restore_feedrate_and_scaling() {
|
|
|
|
|
}
|
|
|
|
|
#endif // HAS_MESH
|
|
|
|
|
|
|
|
|
|
buffer_line_to_destination(MMS_SCALED(feedrate_mm_s));
|
|
|
|
|
planner.buffer_line(destination, scaled_fr_mm_s, active_extruder);
|
|
|
|
|
return false; // caller will update current_position
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@ -971,6 +989,8 @@ void restore_feedrate_and_scaling() {
|
|
|
|
|
*
|
|
|
|
|
* Make sure current_position[E] and destination[E] are good
|
|
|
|
|
* before calling or cold/lengthy extrusion may get missed.
|
|
|
|
|
*
|
|
|
|
|
* Before exit, current_position is set to destination.
|
|
|
|
|
*/
|
|
|
|
|
void prepare_move_to_destination() {
|
|
|
|
|
apply_motion_limits(destination);
|
|
|
|
|
@ -1014,14 +1034,13 @@ void prepare_move_to_destination() {
|
|
|
|
|
|
|
|
|
|
if (
|
|
|
|
|
#if UBL_SEGMENTED
|
|
|
|
|
//ubl.prepare_segmented_line_to(destination, MMS_SCALED(feedrate_mm_s)) // This doesn't seem to work correctly on UBL.
|
|
|
|
|
#if IS_KINEMATIC // Use Kinematic / Cartesian cases as a workaround for now.
|
|
|
|
|
ubl.prepare_segmented_line_to(destination, MMS_SCALED(feedrate_mm_s))
|
|
|
|
|
#if IS_KINEMATIC // UBL using Kinematic / Cartesian cases as a workaround for now.
|
|
|
|
|
ubl.line_to_destination_segmented(MMS_SCALED(feedrate_mm_s))
|
|
|
|
|
#else
|
|
|
|
|
prepare_move_to_destination_cartesian()
|
|
|
|
|
#endif
|
|
|
|
|
#elif IS_KINEMATIC
|
|
|
|
|
prepare_kinematic_move_to(destination)
|
|
|
|
|
line_to_destination_kinematic()
|
|
|
|
|
#else
|
|
|
|
|
prepare_move_to_destination_cartesian()
|
|
|
|
|
#endif
|
|
|
|
|
@ -1065,7 +1084,7 @@ bool axis_unhomed_error(uint8_t axis_bits/*=0x07*/) {
|
|
|
|
|
/**
|
|
|
|
|
* Homing bump feedrate (mm/s)
|
|
|
|
|
*/
|
|
|
|
|
float get_homing_bump_feedrate(const AxisEnum axis) {
|
|
|
|
|
feedRate_t get_homing_bump_feedrate(const AxisEnum axis) {
|
|
|
|
|
#if HOMING_Z_WITH_PROBE
|
|
|
|
|
if (axis == Z_AXIS) return MMM_TO_MMS(Z_PROBE_SPEED_SLOW);
|
|
|
|
|
#endif
|
|
|
|
|
@ -1075,7 +1094,7 @@ float get_homing_bump_feedrate(const AxisEnum axis) {
|
|
|
|
|
hbd = 10;
|
|
|
|
|
SERIAL_ECHO_MSG("Warning: Homing Bump Divisor < 1");
|
|
|
|
|
}
|
|
|
|
|
return homing_feedrate(axis) / hbd;
|
|
|
|
|
return homing_feedrate(axis) / float(hbd);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#if ENABLED(SENSORLESS_HOMING)
|
|
|
|
|
@ -1221,7 +1240,7 @@ float get_homing_bump_feedrate(const AxisEnum axis) {
|
|
|
|
|
/**
|
|
|
|
|
* Home an individual linear axis
|
|
|
|
|
*/
|
|
|
|
|
void do_homing_move(const AxisEnum axis, const float distance, const float fr_mm_s=0.0) {
|
|
|
|
|
void do_homing_move(const AxisEnum axis, const float distance, const feedRate_t fr_mm_s=0.0) {
|
|
|
|
|
|
|
|
|
|
if (DEBUGGING(LEVELING)) {
|
|
|
|
|
DEBUG_ECHOPAIR(">>> do_homing_move(", axis_codes[axis], ", ", distance, ", ");
|
|
|
|
|
@ -1266,12 +1285,13 @@ void do_homing_move(const AxisEnum axis, const float distance, const float fr_mm
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const feedRate_t real_fr_mm_s = fr_mm_s ? fr_mm_s : homing_feedrate(axis);
|
|
|
|
|
#if IS_SCARA
|
|
|
|
|
// Tell the planner the axis is at 0
|
|
|
|
|
current_position[axis] = 0;
|
|
|
|
|
sync_plan_position();
|
|
|
|
|
current_position[axis] = distance;
|
|
|
|
|
planner.buffer_line(current_position, fr_mm_s ? fr_mm_s : homing_feedrate(axis), active_extruder);
|
|
|
|
|
line_to_current_position(real_fr_mm_s);
|
|
|
|
|
#else
|
|
|
|
|
float target[ABCE] = { planner.get_axis_position_mm(A_AXIS), planner.get_axis_position_mm(B_AXIS), planner.get_axis_position_mm(C_AXIS), planner.get_axis_position_mm(E_AXIS) };
|
|
|
|
|
target[axis] = 0;
|
|
|
|
|
@ -1287,7 +1307,7 @@ void do_homing_move(const AxisEnum axis, const float distance, const float fr_mm
|
|
|
|
|
#if IS_KINEMATIC && ENABLED(JUNCTION_DEVIATION)
|
|
|
|
|
, delta_mm_cart
|
|
|
|
|
#endif
|
|
|
|
|
, fr_mm_s ? fr_mm_s : homing_feedrate(axis), active_extruder
|
|
|
|
|
, real_fr_mm_s, active_extruder
|
|
|
|
|
);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
@ -1507,7 +1527,7 @@ void homeaxis(const AxisEnum axis) {
|
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("Move Away:");
|
|
|
|
|
do_homing_move(axis, -bump
|
|
|
|
|
#if HOMING_Z_WITH_PROBE
|
|
|
|
|
, axis == Z_AXIS ? MMM_TO_MMS(Z_PROBE_SPEED_FAST) : 0.0
|
|
|
|
|
, MMM_TO_MMS(axis == Z_AXIS ? Z_PROBE_SPEED_FAST : 0)
|
|
|
|
|
#endif
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
|
Scott Lahteine
5 years ago
committed by