From 4b612f590c730a1e8b757da717dbba45debb45e7 Mon Sep 17 00:00:00 2001 From: Scott Lahteine Date: Thu, 30 Nov 2017 16:40:42 -0600 Subject: [PATCH] Split first move to planner for better chaining --- Marlin/src/module/planner.cpp | 158 ++++++++++++++++++++++------------ Marlin/src/module/planner.h | 13 ++- 2 files changed, 113 insertions(+), 58 deletions(-) diff --git a/Marlin/src/module/planner.cpp b/Marlin/src/module/planner.cpp index 44065e82fa..e4f7e62f72 100644 --- a/Marlin/src/module/planner.cpp +++ b/Marlin/src/module/planner.cpp @@ -580,6 +580,7 @@ void Planner::calculate_volumetric_multipliers() { #if PLANNER_LEVELING /** * rx, ry, rz - Cartesian positions in mm + * Leveled XYZ on completion */ void Planner::apply_leveling(float &rx, float &ry, float &rz) { @@ -622,7 +623,7 @@ void Planner::calculate_volumetric_multipliers() { #endif rz += ( - #if ENABLED(AUTO_BED_LEVELING_UBL) + #if ENABLED(AUTO_BED_LEVELING_UBL) // UBL_DELTA ubl.get_z_correction(rx, ry) * fade_scaling_factor #elif ENABLED(MESH_BED_LEVELING) mbl.get_z(rx, ry @@ -698,69 +699,35 @@ void Planner::calculate_volumetric_multipliers() { #endif // PLANNER_LEVELING /** - * Planner::_buffer_line + * Planner::_buffer_steps * - * Add a new linear movement to the buffer in axis units. + * Add a new linear movement to the buffer (in terms of steps). * - * Leveling and kinematics should be applied ahead of calling this. - * - * a,b,c,e - target positions in mm and/or degrees - * fr_mm_s - (target) speed of the move - * extruder - target extruder + * target - target position in steps units + * fr_mm_s - (target) speed of the move + * extruder - target extruder */ -void Planner::_buffer_line(const float &a, const float &b, const float &c, const float &e, float fr_mm_s, const uint8_t extruder) { - - // The target position of the tool in absolute steps - // Calculate target position in absolute steps - //this should be done after the wait, because otherwise a M92 code within the gcode disrupts this calculation somehow - const long target[XYZE] = { - LROUND(a * axis_steps_per_mm[X_AXIS]), - LROUND(b * axis_steps_per_mm[Y_AXIS]), - LROUND(c * axis_steps_per_mm[Z_AXIS]), - LROUND(e * axis_steps_per_mm[E_AXIS_N]) - }; - - // When changing extruders recalculate steps corresponding to the E position - #if ENABLED(DISTINCT_E_FACTORS) - if (last_extruder != extruder && axis_steps_per_mm[E_AXIS_N] != axis_steps_per_mm[E_AXIS + last_extruder]) { - position[E_AXIS] = LROUND(position[E_AXIS] * axis_steps_per_mm[E_AXIS_N] * steps_to_mm[E_AXIS + last_extruder]); - last_extruder = extruder; - } - #endif +void Planner::_buffer_steps(const int32_t (&target)[XYZE], float fr_mm_s, const uint8_t extruder) { const int32_t da = target[X_AXIS] - position[X_AXIS], db = target[Y_AXIS] - position[Y_AXIS], dc = target[Z_AXIS] - position[Z_AXIS]; - /* - SERIAL_ECHOPAIR(" Planner FR:", fr_mm_s); - SERIAL_CHAR(' '); - #if IS_KINEMATIC - SERIAL_ECHOPAIR("A:", a); - SERIAL_ECHOPAIR(" (", da); - SERIAL_ECHOPAIR(") B:", b); - #else - SERIAL_ECHOPAIR("X:", a); - SERIAL_ECHOPAIR(" (", da); - SERIAL_ECHOPAIR(") Y:", b); - #endif - SERIAL_ECHOPAIR(" (", db); - #if ENABLED(DELTA) - SERIAL_ECHOPAIR(") C:", c); - #else - SERIAL_ECHOPAIR(") Z:", c); - #endif - SERIAL_ECHOPAIR(" (", dc); - SERIAL_CHAR(')'); - SERIAL_EOL(); - //*/ - - // DRYRUN ignores all temperature constraints and assures that the extruder is instantly satisfied - if (DEBUGGING(DRYRUN)) - position[E_AXIS] = target[E_AXIS]; - int32_t de = target[E_AXIS] - position[E_AXIS]; + /* <-- add a slash to enable + SERIAL_ECHOPAIR(" _buffer_steps FR:", fr_mm_s); + SERIAL_ECHOPAIR(" A:", target[A_AXIS]); + SERIAL_ECHOPAIR(" (", da); + SERIAL_ECHOPAIR(" steps) B:", target[B_AXIS]); + SERIAL_ECHOPAIR(" (", db); + SERIAL_ECHOPAIR(" steps) C:", target[C_AXIS]); + SERIAL_ECHOPAIR(" (", dc); + SERIAL_ECHOPAIR(" steps) E:", target[E_AXIS]); + SERIAL_ECHOPAIR(" (", de); + SERIAL_ECHOLNPGM(" steps)"); + //*/ + #if ENABLED(PREVENT_COLD_EXTRUSION) || ENABLED(PREVENT_LENGTHY_EXTRUDE) if (de) { #if ENABLED(PREVENT_COLD_EXTRUSION) @@ -1067,6 +1034,7 @@ void Planner::_buffer_line(const float &a, const float &b, const float &c, const // Segment time im micro seconds uint32_t segment_time_us = LROUND(1000000.0 / inverse_secs); #endif + #if ENABLED(SLOWDOWN) if (WITHIN(moves_queued, 2, (BLOCK_BUFFER_SIZE) / 2 - 1)) { if (segment_time_us < min_segment_time_us) { @@ -1314,12 +1282,12 @@ void Planner::_buffer_line(const float &a, const float &b, const float &c, const // Pick the smaller of the nominal speeds. Higher speed shall not be achieved at the junction during coasting. vmax_junction = min(block->nominal_speed, previous_nominal_speed); - const float smaller_speed_factor = vmax_junction / previous_nominal_speed; - // Factor to multiply the previous / current nominal velocities to get componentwise limited velocities. float v_factor = 1; limited = 0; + // Now limit the jerk in all axes. + const float smaller_speed_factor = vmax_junction / previous_nominal_speed; LOOP_XYZE(axis) { // Limit an axis. We have to differentiate: coasting, reversal of an axis, full stop. float v_exit = previous_speed[axis] * smaller_speed_factor, @@ -1414,13 +1382,89 @@ void Planner::_buffer_line(const float &a, const float &b, const float &c, const block_buffer_head = next_buffer_head; // Update the position (only when a move was queued) + static_assert(COUNT(target) > 1, "array as function parameter should be declared as reference and with count"); COPY(position, target); recalculate(); +} // _buffer_steps() + +/** + * Planner::_buffer_line + * + * Add a new linear movement to the buffer in axis units. + * + * Leveling and kinematics should be applied ahead of calling this. + * + * a,b,c,e - target positions in mm and/or degrees + * fr_mm_s - (target) speed of the move + * extruder - target extruder + */ +void Planner::_buffer_line(const float &a, const float &b, const float &c, const float &e, const float &fr_mm_s, const uint8_t extruder) { + // When changing extruders recalculate steps corresponding to the E position + #if ENABLED(DISTINCT_E_FACTORS) + if (last_extruder != extruder && axis_steps_per_mm[E_AXIS_N] != axis_steps_per_mm[E_AXIS + last_extruder]) { + position[E_AXIS] = LROUND(position[E_AXIS] * axis_steps_per_mm[E_AXIS_N] * steps_to_mm[E_AXIS + last_extruder]); + last_extruder = extruder; + } + #endif + + // The target position of the tool in absolute steps + // Calculate target position in absolute steps + const int32_t target[XYZE] = { + LROUND(a * axis_steps_per_mm[X_AXIS]), + LROUND(b * axis_steps_per_mm[Y_AXIS]), + LROUND(c * axis_steps_per_mm[Z_AXIS]), + LROUND(e * axis_steps_per_mm[E_AXIS_N]) + }; + + /* <-- add a slash to enable + SERIAL_ECHOPAIR(" _buffer_line FR:", fr_mm_s); + #if IS_KINEMATIC + SERIAL_ECHOPAIR(" A:", a); + SERIAL_ECHOPAIR(" (", position[A_AXIS]); + SERIAL_ECHOPAIR("->", target[A_AXIS]); + SERIAL_ECHOPAIR(") B:", b); + #else + SERIAL_ECHOPAIR(" X:", a); + SERIAL_ECHOPAIR(" (", position[X_AXIS]); + SERIAL_ECHOPAIR("->", target[X_AXIS]); + SERIAL_ECHOPAIR(") Y:", b); + #endif + SERIAL_ECHOPAIR(" (", position[Y_AXIS]); + SERIAL_ECHOPAIR("->", target[Y_AXIS]); + #if ENABLED(DELTA) + SERIAL_ECHOPAIR(") C:", c); + #else + SERIAL_ECHOPAIR(") Z:", c); + #endif + SERIAL_ECHOPAIR(" (", position[Z_AXIS]); + SERIAL_ECHOPAIR("->", target[Z_AXIS]); + SERIAL_ECHOPAIR(") E:", e); + SERIAL_ECHOPAIR(" (", position[E_AXIS]); + SERIAL_ECHOPAIR("->", target[E_AXIS]); + SERIAL_ECHOLNPGM(")"); + //*/ + + // DRYRUN ignores all temperature constraints and assures that the extruder is instantly satisfied + if (DEBUGGING(DRYRUN)) + position[E_AXIS] = target[E_AXIS]; + + // Always split the first move into one longer and one shorter move + if (!blocks_queued()) { + #define _BETWEEN(A) (position[A##_AXIS] + target[A##_AXIS]) >> 1 + const int32_t between[XYZE] = { _BETWEEN(X), _BETWEEN(Y), _BETWEEN(Z), _BETWEEN(E) }; + DISABLE_STEPPER_DRIVER_INTERRUPT(); + _buffer_steps(between, fr_mm_s, extruder); + _buffer_steps(target, fr_mm_s, extruder); + ENABLE_STEPPER_DRIVER_INTERRUPT(); + } + else + _buffer_steps(target, fr_mm_s, extruder); + stepper.wake_up(); -} // buffer_line() +} // _buffer_line() /** * Directly set the planner XYZ position (and stepper positions) diff --git a/Marlin/src/module/planner.h b/Marlin/src/module/planner.h index 84818bc5f9..37259f3783 100644 --- a/Marlin/src/module/planner.h +++ b/Marlin/src/module/planner.h @@ -352,6 +352,17 @@ class Planner { #endif + /** + * Planner::_buffer_steps + * + * Add a new linear movement to the buffer (in terms of steps). + * + * target - target position in steps units + * fr_mm_s - (target) speed of the move + * extruder - target extruder + */ + static void _buffer_steps(const int32_t (&target)[XYZE], float fr_mm_s, const uint8_t extruder); + /** * Planner::_buffer_line * @@ -363,7 +374,7 @@ class Planner { * fr_mm_s - (target) speed of the move * extruder - target extruder */ - static void _buffer_line(const float &a, const float &b, const float &c, const float &e, float fr_mm_s, const uint8_t extruder); + static void _buffer_line(const float &a, const float &b, const float &c, const float &e, const float &fr_mm_s, const uint8_t extruder); static void _set_position_mm(const float &a, const float &b, const float &c, const float &e);