Merge pull request #8613 from thinkyhead/bf1_planner_parity
[1.1.x] Fix some planner bugs
This commit is contained in:
commit
ab43113f73
@ -8714,12 +8714,8 @@ inline void gcode_M200() {
|
|||||||
// setting any extruder filament size disables volumetric on the assumption that
|
// setting any extruder filament size disables volumetric on the assumption that
|
||||||
// slicers either generate in extruder values as cubic mm or as as filament feeds
|
// slicers either generate in extruder values as cubic mm or as as filament feeds
|
||||||
// for all extruders
|
// for all extruders
|
||||||
if ( (parser.volumetric_enabled = (parser.value_linear_units() != 0.0)) ) {
|
if ( (parser.volumetric_enabled = (parser.value_linear_units() != 0.0)) )
|
||||||
planner.filament_size[target_extruder] = parser.value_linear_units();
|
planner.set_filament_size(target_extruder, parser.value_linear_units());
|
||||||
// make sure all extruders have some sane value for the filament size
|
|
||||||
for (uint8_t i = 0; i < COUNT(planner.filament_size); i++)
|
|
||||||
if (!planner.filament_size[i]) planner.filament_size[i] = DEFAULT_NOMINAL_FILAMENT_DIA;
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
planner.calculate_volumetric_multipliers();
|
planner.calculate_volumetric_multipliers();
|
||||||
}
|
}
|
||||||
|
@ -153,8 +153,7 @@ float Planner::previous_speed[NUM_AXIS],
|
|||||||
|
|
||||||
#if ENABLED(LIN_ADVANCE)
|
#if ENABLED(LIN_ADVANCE)
|
||||||
float Planner::extruder_advance_k, // Initialized by settings.load()
|
float Planner::extruder_advance_k, // Initialized by settings.load()
|
||||||
Planner::advance_ed_ratio, // Initialized by settings.load()
|
Planner::advance_ed_ratio; // Initialized by settings.load()
|
||||||
Planner::position_float[NUM_AXIS] = { 0 };
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#if ENABLED(ULTRA_LCD)
|
#if ENABLED(ULTRA_LCD)
|
||||||
@ -170,9 +169,6 @@ Planner::Planner() { init(); }
|
|||||||
void Planner::init() {
|
void Planner::init() {
|
||||||
block_buffer_head = block_buffer_tail = 0;
|
block_buffer_head = block_buffer_tail = 0;
|
||||||
ZERO(position);
|
ZERO(position);
|
||||||
#if ENABLED(LIN_ADVANCE)
|
|
||||||
ZERO(position_float);
|
|
||||||
#endif
|
|
||||||
ZERO(previous_speed);
|
ZERO(previous_speed);
|
||||||
previous_nominal_speed = 0.0;
|
previous_nominal_speed = 0.0;
|
||||||
#if ABL_PLANAR
|
#if ABL_PLANAR
|
||||||
@ -554,34 +550,13 @@ void Planner::calculate_volumetric_multipliers() {
|
|||||||
|
|
||||||
#if PLANNER_LEVELING
|
#if PLANNER_LEVELING
|
||||||
/**
|
/**
|
||||||
* rx, ry, rz - cartesian position in mm
|
* rx, ry, rz - Cartesian positions in mm
|
||||||
*/
|
*/
|
||||||
void Planner::apply_leveling(float &rx, float &ry, float &rz) {
|
void Planner::apply_leveling(float &rx, float &ry, float &rz) {
|
||||||
|
|
||||||
if (!leveling_active) return;
|
if (!leveling_active) return;
|
||||||
|
|
||||||
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
#if ABL_PLANAR
|
||||||
const float fade_scaling_factor = fade_scaling_factor_for_z(rz);
|
|
||||||
if (!fade_scaling_factor) return;
|
|
||||||
#else
|
|
||||||
constexpr float fade_scaling_factor = 1.0;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
|
||||||
|
|
||||||
rz += ubl.get_z_correction(rx, ry) * fade_scaling_factor;
|
|
||||||
|
|
||||||
#elif ENABLED(MESH_BED_LEVELING)
|
|
||||||
|
|
||||||
rz += mbl.get_z(rx, ry
|
|
||||||
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
|
||||||
, fade_scaling_factor
|
|
||||||
#endif
|
|
||||||
);
|
|
||||||
|
|
||||||
#elif ABL_PLANAR
|
|
||||||
|
|
||||||
UNUSED(fade_scaling_factor);
|
|
||||||
|
|
||||||
float dx = rx - (X_TILT_FULCRUM),
|
float dx = rx - (X_TILT_FULCRUM),
|
||||||
dy = ry - (Y_TILT_FULCRUM);
|
dy = ry - (Y_TILT_FULCRUM);
|
||||||
@ -591,68 +566,43 @@ void Planner::calculate_volumetric_multipliers() {
|
|||||||
rx = dx + X_TILT_FULCRUM;
|
rx = dx + X_TILT_FULCRUM;
|
||||||
ry = dy + Y_TILT_FULCRUM;
|
ry = dy + Y_TILT_FULCRUM;
|
||||||
|
|
||||||
#elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
#else
|
||||||
|
|
||||||
float tmp[XYZ] = { rx, ry, 0 };
|
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
||||||
rz += bilinear_z_offset(tmp) * fade_scaling_factor;
|
const float fade_scaling_factor = fade_scaling_factor_for_z(rz);
|
||||||
|
if (!fade_scaling_factor) return;
|
||||||
|
#elif HAS_MESH
|
||||||
|
constexpr float fade_scaling_factor = 1.0;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
||||||
|
const float raw[XYZ] = { rx, ry, 0 };
|
||||||
|
#endif
|
||||||
|
|
||||||
|
rz += (
|
||||||
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
||||||
|
ubl.get_z_correction(rx, ry) * fade_scaling_factor
|
||||||
|
#elif ENABLED(MESH_BED_LEVELING)
|
||||||
|
mbl.get_z(rx, ry
|
||||||
|
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
||||||
|
, fade_scaling_factor
|
||||||
|
#endif
|
||||||
|
)
|
||||||
|
#elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
||||||
|
bilinear_z_offset(raw) * fade_scaling_factor
|
||||||
|
#else
|
||||||
|
0
|
||||||
|
#endif
|
||||||
|
);
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
void Planner::unapply_leveling(float raw[XYZ]) {
|
void Planner::unapply_leveling(float raw[XYZ]) {
|
||||||
|
|
||||||
#if HAS_LEVELING
|
if (!leveling_active) return;
|
||||||
if (!leveling_active) return;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
#if ABL_PLANAR
|
||||||
if (!leveling_active_at_z(raw[Z_AXIS])) return;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
|
||||||
|
|
||||||
const float z_physical = raw[Z_AXIS],
|
|
||||||
z_correct = ubl.get_z_correction(raw[X_AXIS], raw[Y_AXIS]),
|
|
||||||
z_virtual = z_physical - z_correct;
|
|
||||||
float z_raw = z_virtual;
|
|
||||||
|
|
||||||
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
|
||||||
|
|
||||||
// for P=physical_z, L=logical_z, M=mesh_z, H=fade_height,
|
|
||||||
// Given P=L+M(1-L/H) (faded mesh correction formula for L<H)
|
|
||||||
// then L=P-M(1-L/H)
|
|
||||||
// so L=P-M+ML/H
|
|
||||||
// so L-ML/H=P-M
|
|
||||||
// so L(1-M/H)=P-M
|
|
||||||
// so L=(P-M)/(1-M/H) for L<H
|
|
||||||
|
|
||||||
if (planner.z_fade_height) {
|
|
||||||
if (z_raw >= planner.z_fade_height)
|
|
||||||
z_raw = z_physical;
|
|
||||||
else
|
|
||||||
z_raw /= 1.0 - z_correct * planner.inverse_z_fade_height;
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif // ENABLE_LEVELING_FADE_HEIGHT
|
|
||||||
|
|
||||||
raw[Z_AXIS] = z_raw;
|
|
||||||
|
|
||||||
return; // don't fall thru to other ENABLE_LEVELING_FADE_HEIGHT logic
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if ENABLED(MESH_BED_LEVELING)
|
|
||||||
|
|
||||||
if (leveling_active) {
|
|
||||||
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
|
||||||
const float c = mbl.get_z(raw[X_AXIS], raw[Y_AXIS], 1.0);
|
|
||||||
raw[Z_AXIS] = (z_fade_height * (raw[Z_AXIS]) - c) / (z_fade_height - c);
|
|
||||||
#else
|
|
||||||
raw[Z_AXIS] -= mbl.get_z(raw[X_AXIS], raw[Y_AXIS]);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
#elif ABL_PLANAR
|
|
||||||
|
|
||||||
matrix_3x3 inverse = matrix_3x3::transpose(bed_level_matrix);
|
matrix_3x3 inverse = matrix_3x3::transpose(bed_level_matrix);
|
||||||
|
|
||||||
@ -664,15 +614,31 @@ void Planner::calculate_volumetric_multipliers() {
|
|||||||
raw[X_AXIS] = dx + X_TILT_FULCRUM;
|
raw[X_AXIS] = dx + X_TILT_FULCRUM;
|
||||||
raw[Y_AXIS] = dy + Y_TILT_FULCRUM;
|
raw[Y_AXIS] = dy + Y_TILT_FULCRUM;
|
||||||
|
|
||||||
#elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
#else
|
||||||
|
|
||||||
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
||||||
const float c = bilinear_z_offset(raw);
|
const float fade_scaling_factor = fade_scaling_factor_for_z(raw[Z_AXIS]);
|
||||||
raw[Z_AXIS] = (z_fade_height * (raw[Z_AXIS]) - c) / (z_fade_height - c);
|
if (!fade_scaling_factor) return;
|
||||||
#else
|
#elif HAS_MESH
|
||||||
raw[Z_AXIS] -= bilinear_z_offset(raw);
|
constexpr float fade_scaling_factor = 1.0;
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
raw[Z_AXIS] -= (
|
||||||
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
||||||
|
ubl.get_z_correction(raw[X_AXIS], raw[Y_AXIS]) * fade_scaling_factor
|
||||||
|
#elif ENABLED(MESH_BED_LEVELING)
|
||||||
|
mbl.get_z(raw[X_AXIS], raw[Y_AXIS]
|
||||||
|
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
||||||
|
, fade_scaling_factor
|
||||||
|
#endif
|
||||||
|
)
|
||||||
|
#elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
||||||
|
bilinear_z_offset(raw) * fade_scaling_factor
|
||||||
|
#else
|
||||||
|
0
|
||||||
|
#endif
|
||||||
|
);
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -709,10 +675,6 @@ void Planner::_buffer_line(const float &a, const float &b, const float &c, const
|
|||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#if ENABLED(LIN_ADVANCE)
|
|
||||||
const float mm_D_float = SQRT(sq(a - position_float[X_AXIS]) + sq(b - position_float[Y_AXIS]));
|
|
||||||
#endif
|
|
||||||
|
|
||||||
const long da = target[X_AXIS] - position[X_AXIS],
|
const long 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];
|
||||||
@ -741,29 +703,17 @@ void Planner::_buffer_line(const float &a, const float &b, const float &c, const
|
|||||||
//*/
|
//*/
|
||||||
|
|
||||||
// DRYRUN ignores all temperature constraints and assures that the extruder is instantly satisfied
|
// DRYRUN ignores all temperature constraints and assures that the extruder is instantly satisfied
|
||||||
if (DEBUGGING(DRYRUN)) {
|
if (DEBUGGING(DRYRUN))
|
||||||
position[E_AXIS] = target[E_AXIS];
|
position[E_AXIS] = target[E_AXIS];
|
||||||
#if ENABLED(LIN_ADVANCE)
|
|
||||||
position_float[E_AXIS] = e;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
long de = target[E_AXIS] - position[E_AXIS];
|
long de = target[E_AXIS] - position[E_AXIS];
|
||||||
|
|
||||||
#if ENABLED(LIN_ADVANCE)
|
|
||||||
float de_float = e - position_float[E_AXIS]; // Should this include e_factor?
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#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)
|
||||||
if (thermalManager.tooColdToExtrude(extruder)) {
|
if (thermalManager.tooColdToExtrude(extruder)) {
|
||||||
position[E_AXIS] = target[E_AXIS]; // Behave as if the move really took place, but ignore E part
|
position[E_AXIS] = target[E_AXIS]; // Behave as if the move really took place, but ignore E part
|
||||||
de = 0; // no difference
|
de = 0; // no difference
|
||||||
#if ENABLED(LIN_ADVANCE)
|
|
||||||
position_float[E_AXIS] = e;
|
|
||||||
de_float = 0;
|
|
||||||
#endif
|
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM(MSG_ERR_COLD_EXTRUDE_STOP);
|
SERIAL_ECHOLNPGM(MSG_ERR_COLD_EXTRUDE_STOP);
|
||||||
}
|
}
|
||||||
@ -772,10 +722,6 @@ void Planner::_buffer_line(const float &a, const float &b, const float &c, const
|
|||||||
if (labs(de * e_factor[extruder]) > (int32_t)axis_steps_per_mm[E_AXIS_N] * (EXTRUDE_MAXLENGTH)) { // It's not important to get max. extrusion length in a precision < 1mm, so save some cycles and cast to int
|
if (labs(de * e_factor[extruder]) > (int32_t)axis_steps_per_mm[E_AXIS_N] * (EXTRUDE_MAXLENGTH)) { // It's not important to get max. extrusion length in a precision < 1mm, so save some cycles and cast to int
|
||||||
position[E_AXIS] = target[E_AXIS]; // Behave as if the move really took place, but ignore E part
|
position[E_AXIS] = target[E_AXIS]; // Behave as if the move really took place, but ignore E part
|
||||||
de = 0; // no difference
|
de = 0; // no difference
|
||||||
#if ENABLED(LIN_ADVANCE)
|
|
||||||
position_float[E_AXIS] = e;
|
|
||||||
de_float = 0;
|
|
||||||
#endif
|
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM(MSG_ERR_LONG_EXTRUDE_STOP);
|
SERIAL_ECHOLNPGM(MSG_ERR_LONG_EXTRUDE_STOP);
|
||||||
}
|
}
|
||||||
@ -783,6 +729,10 @@ void Planner::_buffer_line(const float &a, const float &b, const float &c, const
|
|||||||
}
|
}
|
||||||
#endif // PREVENT_COLD_EXTRUSION || PREVENT_LENGTHY_EXTRUDE
|
#endif // PREVENT_COLD_EXTRUSION || PREVENT_LENGTHY_EXTRUDE
|
||||||
|
|
||||||
|
#if ENABLED(LIN_ADVANCE)
|
||||||
|
float de_float = de * steps_to_mm[E_AXIS_N];
|
||||||
|
#endif
|
||||||
|
|
||||||
// Compute direction bit-mask for this block
|
// Compute direction bit-mask for this block
|
||||||
uint8_t dm = 0;
|
uint8_t dm = 0;
|
||||||
#if CORE_IS_XY
|
#if CORE_IS_XY
|
||||||
@ -1380,30 +1330,28 @@ void Planner::_buffer_line(const float &a, const float &b, const float &c, const
|
|||||||
|
|
||||||
#if ENABLED(LIN_ADVANCE)
|
#if ENABLED(LIN_ADVANCE)
|
||||||
|
|
||||||
//
|
/**
|
||||||
// Use LIN_ADVANCE for blocks if all these are true:
|
*
|
||||||
//
|
* Use LIN_ADVANCE for blocks if all these are true:
|
||||||
// esteps : We have E steps todo (a printing move)
|
*
|
||||||
//
|
* esteps && (block->steps[X_AXIS] || block->steps[Y_AXIS]) : This is a print move
|
||||||
// block->steps[X_AXIS] || block->steps[Y_AXIS] : We have a movement in XY direction (i.e., not retract / prime).
|
*
|
||||||
//
|
* extruder_advance_k : There is an advance factor set.
|
||||||
// extruder_advance_k : There is an advance factor set.
|
*
|
||||||
//
|
* esteps != block->step_event_count : A problem occurs if the move before a retract is too small.
|
||||||
// block->steps[E_AXIS] != block->step_event_count : A problem occurs if the move before a retract is too small.
|
* In that case, the retract and move will be executed together.
|
||||||
// In that case, the retract and move will be executed together.
|
* This leads to too many advance steps due to a huge e_acceleration.
|
||||||
// This leads to too many advance steps due to a huge e_acceleration.
|
* The math is good, but we must avoid retract moves with advance!
|
||||||
// The math is good, but we must avoid retract moves with advance!
|
* de > 0 : Extruder is running forward (e.g., for "Wipe while retracting" (Slic3r) or "Combing" (Cura) moves)
|
||||||
// de_float > 0.0 : Extruder is running forward (e.g., for "Wipe while retracting" (Slic3r) or "Combing" (Cura) moves)
|
*/
|
||||||
//
|
block->use_advance_lead = esteps && (block->steps[X_AXIS] || block->steps[Y_AXIS])
|
||||||
block->use_advance_lead = esteps
|
|
||||||
&& (block->steps[X_AXIS] || block->steps[Y_AXIS])
|
|
||||||
&& extruder_advance_k
|
&& extruder_advance_k
|
||||||
&& (uint32_t)esteps != block->step_event_count
|
&& (uint32_t)esteps != block->step_event_count
|
||||||
&& de_float > 0.0;
|
&& de > 0;
|
||||||
if (block->use_advance_lead)
|
if (block->use_advance_lead)
|
||||||
block->abs_adv_steps_multiplier8 = LROUND(
|
block->abs_adv_steps_multiplier8 = LROUND(
|
||||||
extruder_advance_k
|
extruder_advance_k
|
||||||
* (UNEAR_ZERO(advance_ed_ratio) ? de_float / mm_D_float : advance_ed_ratio) // Use the fixed ratio, if set
|
* (UNEAR_ZERO(advance_ed_ratio) ? de * steps_to_mm[E_AXIS_N] / HYPOT(da * steps_to_mm[X_AXIS], db * steps_to_mm[Y_AXIS]) : advance_ed_ratio) // Use the fixed ratio, if set
|
||||||
* (block->nominal_speed / (float)block->nominal_rate)
|
* (block->nominal_speed / (float)block->nominal_rate)
|
||||||
* axis_steps_per_mm[E_AXIS_N] * 256.0
|
* axis_steps_per_mm[E_AXIS_N] * 256.0
|
||||||
);
|
);
|
||||||
@ -1417,12 +1365,6 @@ void Planner::_buffer_line(const float &a, const float &b, const float &c, const
|
|||||||
|
|
||||||
// Update the position (only when a move was queued)
|
// Update the position (only when a move was queued)
|
||||||
COPY(position, target);
|
COPY(position, target);
|
||||||
#if ENABLED(LIN_ADVANCE)
|
|
||||||
position_float[X_AXIS] = a;
|
|
||||||
position_float[Y_AXIS] = b;
|
|
||||||
position_float[Z_AXIS] = c;
|
|
||||||
position_float[E_AXIS] = e;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
recalculate();
|
recalculate();
|
||||||
|
|
||||||
@ -1448,12 +1390,6 @@ void Planner::_set_position_mm(const float &a, const float &b, const float &c, c
|
|||||||
nb = position[Y_AXIS] = LROUND(b * axis_steps_per_mm[Y_AXIS]),
|
nb = position[Y_AXIS] = LROUND(b * axis_steps_per_mm[Y_AXIS]),
|
||||||
nc = position[Z_AXIS] = LROUND(c * axis_steps_per_mm[Z_AXIS]),
|
nc = position[Z_AXIS] = LROUND(c * axis_steps_per_mm[Z_AXIS]),
|
||||||
ne = position[E_AXIS] = LROUND(e * axis_steps_per_mm[_EINDEX]);
|
ne = position[E_AXIS] = LROUND(e * axis_steps_per_mm[_EINDEX]);
|
||||||
#if ENABLED(LIN_ADVANCE)
|
|
||||||
position_float[X_AXIS] = a;
|
|
||||||
position_float[Y_AXIS] = b;
|
|
||||||
position_float[Z_AXIS] = c;
|
|
||||||
position_float[E_AXIS] = e;
|
|
||||||
#endif
|
|
||||||
stepper.set_position(na, nb, nc, ne);
|
stepper.set_position(na, nb, nc, ne);
|
||||||
previous_nominal_speed = 0.0; // Resets planner junction speeds. Assumes start from rest.
|
previous_nominal_speed = 0.0; // Resets planner junction speeds. Assumes start from rest.
|
||||||
ZERO(previous_speed);
|
ZERO(previous_speed);
|
||||||
@ -1478,16 +1414,8 @@ void Planner::set_position_mm_kinematic(const float position[NUM_AXIS]) {
|
|||||||
* Sync from the stepper positions. (e.g., after an interrupted move)
|
* Sync from the stepper positions. (e.g., after an interrupted move)
|
||||||
*/
|
*/
|
||||||
void Planner::sync_from_steppers() {
|
void Planner::sync_from_steppers() {
|
||||||
LOOP_XYZE(i) {
|
LOOP_XYZE(i)
|
||||||
position[i] = stepper.position((AxisEnum)i);
|
position[i] = stepper.position((AxisEnum)i);
|
||||||
#if ENABLED(LIN_ADVANCE)
|
|
||||||
position_float[i] = position[i] * steps_to_mm[i
|
|
||||||
#if ENABLED(DISTINCT_E_FACTORS)
|
|
||||||
+ (i == E_AXIS ? active_extruder : 0)
|
|
||||||
#endif
|
|
||||||
];
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
@ -1501,9 +1429,6 @@ void Planner::set_position_mm(const AxisEnum axis, const float &v) {
|
|||||||
const uint8_t axis_index = axis;
|
const uint8_t axis_index = axis;
|
||||||
#endif
|
#endif
|
||||||
position[axis] = LROUND(v * axis_steps_per_mm[axis_index]);
|
position[axis] = LROUND(v * axis_steps_per_mm[axis_index]);
|
||||||
#if ENABLED(LIN_ADVANCE)
|
|
||||||
position_float[axis] = v;
|
|
||||||
#endif
|
|
||||||
stepper.set_position(axis, v);
|
stepper.set_position(axis, v);
|
||||||
previous_speed[axis] = 0.0;
|
previous_speed[axis] = 0.0;
|
||||||
}
|
}
|
||||||
|
@ -219,10 +219,6 @@ class Planner {
|
|||||||
static uint32_t axis_segment_time_us[2][3];
|
static uint32_t axis_segment_time_us[2][3];
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#if ENABLED(LIN_ADVANCE)
|
|
||||||
static float position_float[NUM_AXIS];
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if ENABLED(ULTRA_LCD)
|
#if ENABLED(ULTRA_LCD)
|
||||||
volatile static uint32_t block_buffer_runtime_us; //Theoretical block buffer runtime in µs
|
volatile static uint32_t block_buffer_runtime_us; //Theoretical block buffer runtime in µs
|
||||||
#endif
|
#endif
|
||||||
@ -251,8 +247,6 @@ class Planner {
|
|||||||
// Manage fans, paste pressure, etc.
|
// Manage fans, paste pressure, etc.
|
||||||
static void check_axes_activity();
|
static void check_axes_activity();
|
||||||
|
|
||||||
static void calculate_volumetric_multipliers();
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Number of moves currently in the planner
|
* Number of moves currently in the planner
|
||||||
*/
|
*/
|
||||||
@ -260,6 +254,16 @@ class Planner {
|
|||||||
|
|
||||||
static bool is_full() { return (block_buffer_tail == BLOCK_MOD(block_buffer_head + 1)); }
|
static bool is_full() { return (block_buffer_tail == BLOCK_MOD(block_buffer_head + 1)); }
|
||||||
|
|
||||||
|
// Update multipliers based on new diameter measurements
|
||||||
|
static void calculate_volumetric_multipliers();
|
||||||
|
|
||||||
|
FORCE_INLINE static void set_filament_size(const uint8_t e, const float &v) {
|
||||||
|
filament_size[e] = v;
|
||||||
|
// make sure all extruders have some sane value for the filament size
|
||||||
|
for (uint8_t i = 0; i < COUNT(filament_size); i++)
|
||||||
|
if (!filament_size[i]) filament_size[i] = DEFAULT_NOMINAL_FILAMENT_DIA;
|
||||||
|
}
|
||||||
|
|
||||||
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
Loading…
Reference in New Issue
Block a user