zaubentrucker/muele-marlin
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

Merge pull request #8611 from thinkyhead/bf2_planner_split_first

Browse source 
[2.0.x] Split first planner move for better chaining
This commit is contained in:
Scott Lahteine 2017-12-03 01:50:46 -06:00 committed by GitHub
parent aa7efb96bf 3a97de52ef
commit 824980e70e
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2 changed files with 103 additions and 55 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

143
Marlin/src/module/planner.cpp
View file

@ -698,69 +698,35 @@ void Planner::calculate_volumetric_multipliers() {
#endif // PLANNER_LEVELING #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. * target - target position in steps units
*
* a,b,c,e - target positions in mm and/or degrees
* fr_mm_s - (target) speed of the move * fr_mm_s - (target) speed of the move
* extruder - target extruder * 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) { void Planner::_buffer_steps(const int32_t target[XYZE], 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
const int32_t da = target[X_AXIS] - position[X_AXIS], const int32_t da = target[X_AXIS] - position[X_AXIS],
db = target[Y_AXIS] - position[Y_AXIS], db = target[Y_AXIS] - position[Y_AXIS],
dc = target[Z_AXIS] - position[Z_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]; 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_ECHOLNPGM(" steps) C:", target[C_AXIS]);
SERIAL_ECHOPAIR(" (", dc);
SERIAL_ECHOLNPGM(" steps) E:", target[E_AXIS]);
SERIAL_ECHOPAIR(" (", de);
SERIAL_ECHOLNPGM(" steps)");
//*/
#if ENABLED(PREVENT_COLD_EXTRUSION) || ENABLED(PREVENT_LENGTHY_EXTRUDE) #if ENABLED(PREVENT_COLD_EXTRUSION) || ENABLED(PREVENT_LENGTHY_EXTRUDE)
if (de) { if (de) {
#if ENABLED(PREVENT_COLD_EXTRUSION) #if ENABLED(PREVENT_COLD_EXTRUSION)
@ -1067,6 +1033,7 @@ void Planner::_buffer_line(const float &a, const float &b, const float &c, const
// Segment time im micro seconds // Segment time im micro seconds
uint32_t segment_time_us = LROUND(1000000.0 / inverse_secs); uint32_t segment_time_us = LROUND(1000000.0 / inverse_secs);
#endif #endif
#if ENABLED(SLOWDOWN) #if ENABLED(SLOWDOWN)
if (WITHIN(moves_queued, 2, (BLOCK_BUFFER_SIZE) / 2 - 1)) { if (WITHIN(moves_queued, 2, (BLOCK_BUFFER_SIZE) / 2 - 1)) {
if (segment_time_us < min_segment_time_us) { if (segment_time_us < min_segment_time_us) {
@ -1305,7 +1272,7 @@ void Planner::_buffer_line(const float &a, const float &b, const float &c, const
} }
} }
if (moves_queued > 1 && !UNEAR_ZERO(previous_nominal_speed)) { if (moves_queued && !UNEAR_ZERO(previous_nominal_speed)) {
// Estimate a maximum velocity allowed at a joint of two successive segments. // Estimate a maximum velocity allowed at a joint of two successive segments.
// If this maximum velocity allowed is lower than the minimum of the entry / exit safe velocities, // If this maximum velocity allowed is lower than the minimum of the entry / exit safe velocities,
// then the machine is not coasting anymore and the safe entry / exit velocities shall be used. // then the machine is not coasting anymore and the safe entry / exit velocities shall be used.
@ -1417,9 +1384,79 @@ void Planner::_buffer_line(const float &a, const float &b, const float &c, const
recalculate(); 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(" (", target[A_AXIS]);
SERIAL_ECHOPAIR(" steps) B:", b);
#else
SERIAL_ECHOPAIR(" X:", a);
SERIAL_ECHOPAIR(" (", target[X_AXIS]);
SERIAL_ECHOPAIR(" steps) Y:", b);
#endif
SERIAL_ECHOPAIR(" (", target[Y_AXIS]);
#if ENABLED(DELTA)
SERIAL_ECHOPAIR(" steps) C:", c);
#else
SERIAL_ECHOPAIR(" steps) Z:", c);
#endif
SERIAL_ECHOPAIR(" (", target[Z_AXIS]);
SERIAL_ECHOPAIR(" steps) E:", e);
SERIAL_ECHOPAIR(" (", target[E_AXIS]);
SERIAL_ECHOLNPGM(" steps)");
//*/
// 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 in two so it can chain
if (!blocks_queued()) {
DISABLE_STEPPER_DRIVER_INTERRUPT();
#define _BETWEEN(A) (position[A##_AXIS] + target[A##_AXIS]) >> 1
const int32_t between[XYZE] = { _BETWEEN(X), _BETWEEN(Y), _BETWEEN(Z), _BETWEEN(E) };
_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(); stepper.wake_up();
} // buffer_line() } // _buffer_line()
/** /**
* Directly set the planner XYZ position (and stepper positions) * Directly set the planner XYZ position (and stepper positions)

15
Marlin/src/module/planner.h
View file

@ -144,7 +144,7 @@ class Planner {
static uint8_t last_extruder; // Respond to extruder change static uint8_t last_extruder; // Respond to extruder change
#endif #endif
static int16_t flow_percentage[EXTRUDERS]; // Extrusion factor for each extruder static int16_t flow_percentage[EXTRUDERS]; // Extrusion factor for each extruder
static float e_factor[EXTRUDERS], // The flow percentage and volumetric multiplier combine to scale E movement static float e_factor[EXTRUDERS], // The flow percentage and volumetric multiplier combine to scale E movement
filament_size[EXTRUDERS], // diameter of filament (in millimeters), typically around 1.75 or 2.85, 0 disables the volumetric calculations for the extruder filament_size[EXTRUDERS], // diameter of filament (in millimeters), typically around 1.75 or 2.85, 0 disables the volumetric calculations for the extruder
@ -352,6 +352,17 @@ class Planner {
#endif #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 * Planner::_buffer_line
* *
@ -363,7 +374,7 @@ class Planner {
* fr_mm_s - (target) speed of the move * fr_mm_s - (target) speed of the move
* extruder - target extruder * 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); static void _set_position_mm(const float &a, const float &b, const float &c, const float &e);