CMS/Marlin
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use planner.leveling_active for all leveling systems

Browse Source
This commit is contained in:
Scott Lahteine 2017-10-13 17:21:25 -05:00
parent 32c607ffe2
commit 3e3911fb81
21 changed files with 143 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Marlin/src/core/utility.cpp
View File

@ -333,7 +333,7 @@ void safe_delay(millis_t ms) {
#elif ENABLED(AUTO_BED_LEVELING_UBL)
SERIAL_ECHOPGM("UBL");
#endif
if (LEVELING_IS_ACTIVE()) {
if (planner.leveling_active) {
SERIAL_ECHOLNPGM(" (enabled)");
#if ABL_PLANAR
const float diff[XYZ] = {
@ -364,7 +364,7 @@ void safe_delay(millis_t ms) {
#elif ENABLED(MESH_BED_LEVELING)
SERIAL_ECHOPGM("Mesh Bed Leveling");
if (LEVELING_IS_ACTIVE()) {
if (planner.leveling_active) {
float lz = current_position[Z_AXIS];
planner.apply_leveling(current_position[X_AXIS], current_position[Y_AXIS], lz);
SERIAL_ECHOLNPGM(" (enabled)");

24
Marlin/src/feature/bedlevel/bedlevel.cpp
View File

@ -44,7 +44,7 @@
bool leveling_is_valid() {
return
#if ENABLED(MESH_BED_LEVELING)
mbl.has_mesh()
mbl.has_mesh
#elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
!!bilinear_grid_spacing[X_AXIS]
#elif ENABLED(AUTO_BED_LEVELING_UBL)
@ -70,7 +70,7 @@ void set_bed_leveling_enabled(const bool enable/*=true*/) {
constexpr bool can_change = true;
#endif
if (can_change && enable != LEVELING_IS_ACTIVE()) {
if (can_change && enable != planner.leveling_active) {
#if ENABLED(MESH_BED_LEVELING)
@ -78,23 +78,23 @@ void set_bed_leveling_enabled(const bool enable/*=true*/) {
planner.apply_leveling(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS]);
const bool enabling = enable && leveling_is_valid();
mbl.set_active(enabling);
planner.leveling_active = enabling;
if (enabling) planner.unapply_leveling(current_position);
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#if PLANNER_LEVELING
if (ubl.state.active) { // leveling from on to off
if (planner.leveling_active) { // leveling from on to off
// change unleveled current_position to physical current_position without moving steppers.
planner.apply_leveling(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS]);
ubl.state.active = false; // disable only AFTER calling apply_leveling
planner.leveling_active = false; // disable only AFTER calling apply_leveling
}
else { // leveling from off to on
ubl.state.active = true; // enable BEFORE calling unapply_leveling, otherwise ignored
planner.leveling_active = true; // enable BEFORE calling unapply_leveling, otherwise ignored
// change physical current_position to unleveled current_position without moving steppers.
planner.unapply_leveling(current_position);
}
#else
ubl.state.active = enable; // just flip the bit, current_position will be wrong until next move.
planner.leveling_active = enable; // just flip the bit, current_position will be wrong until next move.
#endif
#else // OLDSCHOOL_ABL
@ -106,7 +106,7 @@ void set_bed_leveling_enabled(const bool enable/*=true*/) {
#endif
// Enable or disable leveling compensation in the planner
planner.abl_enabled = enable;
planner.leveling_active = enable;
if (!enable)
// When disabling just get the current position from the steppers.
@ -131,15 +131,13 @@ void set_bed_leveling_enabled(const bool enable/*=true*/) {
void set_z_fade_height(const float zfh) {
const bool level_active = LEVELING_IS_ACTIVE();
const bool level_active = planner.leveling_active;
#if ENABLED(AUTO_BED_LEVELING_UBL)
if (level_active) set_bed_leveling_enabled(false); // turn off before changing fade height for proper apply/unapply leveling to maintain current_position
#endif
planner.z_fade_height = zfh;
planner.inverse_z_fade_height = RECIPROCAL(zfh);
planner.force_fade_recalc();
planner.set_z_fade_height(zfh);
if (level_active) {
#if ENABLED(AUTO_BED_LEVELING_UBL)
@ -166,7 +164,7 @@ void reset_bed_level() {
#if ENABLED(MESH_BED_LEVELING)
if (leveling_is_valid()) {
mbl.reset();
mbl.set_has_mesh(false);
mbl.has_mesh = false;
}
#else
#if ENABLED(DEBUG_LEVELING_FEATURE)

10
Marlin/src/feature/bedlevel/bedlevel.h
View File

@ -43,16 +43,6 @@ bool leveling_is_valid();
void set_bed_leveling_enabled(const bool enable=true);
void reset_bed_level();
#if ENABLED(MESH_BED_LEVELING)
#define LEVELING_IS_ACTIVE() (mbl.active())
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define LEVELING_IS_ACTIVE() (ubl.state.active)
#elif HAS_ABL
#define LEVELING_IS_ACTIVE() (planner.abl_enabled)
#else
#define LEVELING_IS_ACTIVE() (false)
#endif
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
void set_z_fade_height(const float zfh);
#endif

4
Marlin/src/feature/bedlevel/mbl/mesh_bed_leveling.cpp
View File

@ -31,7 +31,7 @@
mesh_bed_leveling mbl;
uint8_t mesh_bed_leveling::status;
bool mesh_bed_leveling::has_mesh;
float mesh_bed_leveling::z_offset,
mesh_bed_leveling::z_values[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y],
@ -47,7 +47,7 @@
}
void mesh_bed_leveling::reset() {
status = MBL_STATUS_NONE;
has_mesh = false;
z_offset = 0;
ZERO(z_values);
}

13
Marlin/src/feature/bedlevel/mbl/mesh_bed_leveling.h
View File

@ -34,18 +34,12 @@ enum MeshLevelingState {
MeshReset
};
enum MBLStatus {
MBL_STATUS_NONE = 0,
MBL_STATUS_HAS_MESH_BIT = 0,
MBL_STATUS_ACTIVE_BIT = 1
};
#define MESH_X_DIST ((MESH_MAX_X - (MESH_MIN_X)) / (GRID_MAX_POINTS_X - 1))
#define MESH_Y_DIST ((MESH_MAX_Y - (MESH_MIN_Y)) / (GRID_MAX_POINTS_Y - 1))
class mesh_bed_leveling {
public:
static uint8_t status; // Has Mesh and Is Active bits
static bool has_mesh;
static float z_offset,
z_values[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y],
index_to_xpos[GRID_MAX_POINTS_X],
@ -57,11 +51,6 @@ public:
static void set_z(const int8_t px, const int8_t py, const float &z) { z_values[px][py] = z; }
static bool active() { return TEST(status, MBL_STATUS_ACTIVE_BIT); }
static void set_active(const bool onOff) { onOff ? SBI(status, MBL_STATUS_ACTIVE_BIT) : CBI(status, MBL_STATUS_ACTIVE_BIT); }
static bool has_mesh() { return TEST(status, MBL_STATUS_HAS_MESH_BIT); }
static void set_has_mesh(const bool onOff) { onOff ? SBI(status, MBL_STATUS_HAS_MESH_BIT) : CBI(status, MBL_STATUS_HAS_MESH_BIT); }
static inline void zigzag(const int8_t index, int8_t &px, int8_t &py) {
px = index % (GRID_MAX_POINTS_X);
py = index / (GRID_MAX_POINTS_X);

4
Marlin/src/feature/bedlevel/ubl/ubl.cpp
View File

@ -51,7 +51,7 @@
void unified_bed_leveling::report_state() {
echo_name();
SERIAL_PROTOCOLPGM(" System v" UBL_VERSION " ");
if (!state.active) SERIAL_PROTOCOLPGM("in");
if (!planner.leveling_active) SERIAL_PROTOCOLPGM("in");
SERIAL_PROTOCOLLNPGM("active.");
safe_delay(50);
}
@ -93,7 +93,7 @@
set_bed_leveling_enabled(false);
state.storage_slot = -1;
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
planner.z_fade_height = 10.0;
planner.set_z_fade_height(10.0);
#endif
ZERO(z_values);
last_specified_z = -999.9;

2
Marlin/src/feature/bedlevel/ubl/ubl_G29.cpp
View File

@ -1170,7 +1170,7 @@
return;
}
ubl_state_at_invocation = state.active;
ubl_state_at_invocation = planner.leveling_active;
set_bed_leveling_enabled(false);
}

32
Marlin/src/feature/bedlevel/ubl/ubl_motion.cpp
View File

@ -257,9 +257,8 @@
*/
const float x = inf_m_flag ? start[X_AXIS] : (next_mesh_line_y - c) / m;
float z0 = z_correction_for_x_on_horizontal_mesh_line(x, current_xi, current_yi);
z0 *= planner.fade_scaling_factor_for_z(end[Z_AXIS]);
float z0 = z_correction_for_x_on_horizontal_mesh_line(x, current_xi, current_yi)
* planner.fade_scaling_factor_for_z(end[Z_AXIS]);
/**
* If part of the Mesh is undefined, it will show up as NAN
@ -322,9 +321,8 @@
const float next_mesh_line_x = LOGICAL_X_POSITION(mesh_index_to_xpos(current_xi)),
y = m * next_mesh_line_x + c; // Calculate Y at the next X mesh line
float z0 = z_correction_for_y_on_vertical_mesh_line(y, current_xi, current_yi);
z0 *= planner.fade_scaling_factor_for_z(end[Z_AXIS]);
float z0 = z_correction_for_y_on_vertical_mesh_line(y, current_xi, current_yi)
* planner.fade_scaling_factor_for_z(end[Z_AXIS]);
/**
* If part of the Mesh is undefined, it will show up as NAN
@ -395,9 +393,8 @@
if (left_flag == (x > next_mesh_line_x)) { // Check if we hit the Y line first
// Yes! Crossing a Y Mesh Line next
float z0 = z_correction_for_x_on_horizontal_mesh_line(x, current_xi - left_flag, current_yi + dyi);
z0 *= planner.fade_scaling_factor_for_z(end[Z_AXIS]);
float z0 = z_correction_for_x_on_horizontal_mesh_line(x, current_xi - left_flag, current_yi + dyi)
* planner.fade_scaling_factor_for_z(end[Z_AXIS]);
/**
* If part of the Mesh is undefined, it will show up as NAN
@ -423,9 +420,8 @@
}
else {
// Yes! Crossing a X Mesh Line next
float z0 = z_correction_for_y_on_vertical_mesh_line(y, current_xi + dxi, current_yi - down_flag);
z0 *= planner.fade_scaling_factor_for_z(end[Z_AXIS]);
float z0 = z_correction_for_y_on_vertical_mesh_line(y, current_xi + dxi, current_yi - down_flag)
* planner.fade_scaling_factor_for_z(end[Z_AXIS]);
/**
* If part of the Mesh is undefined, it will show up as NAN
@ -580,17 +576,9 @@
seg_rz = RAW_Z_POSITION(current_position[Z_AXIS]),
seg_le = current_position[E_AXIS];
const bool above_fade_height = (
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
planner.z_fade_height != 0 && planner.z_fade_height < RAW_Z_POSITION(ltarget[Z_AXIS])
#else
false
#endif
);
// Only compute leveling per segment if ubl active and target below z_fade_height.
if (!state.active || above_fade_height) { // no mesh leveling
if (!planner.leveling_active || !planner.leveling_active_at_z(ltarget[Z_AXIS])) { // no mesh leveling
do {
@ -648,7 +636,7 @@
z_x0y1 = z_values[cell_xi ][cell_yi+1], // z at lower right corner
z_x1y1 = z_values[cell_xi+1][cell_yi+1]; // z at upper right corner
if (isnan(z_x0y0)) z_x0y0 = 0; // ideally activating state.active (G29 A)
if (isnan(z_x0y0)) z_x0y0 = 0; // ideally activating planner.leveling_active (G29 A)
if (isnan(z_x1y0)) z_x1y0 = 0; // should refuse if any invalid mesh points
if (isnan(z_x0y1)) z_x0y1 = 0; // in order to avoid isnan tests per cell,
if (isnan(z_x1y1)) z_x1y1 = 0; // thus guessing zero for undefined points

5
Marlin/src/gcode/bedlevel/M420.cpp
View File

@ -105,14 +105,13 @@ void GcodeSuite::M420() {
}
const bool to_enable = parser.boolval('S');
if (parser.seen('S'))
set_bed_leveling_enabled(to_enable);
if (parser.seen('S')) set_bed_leveling_enabled(to_enable);
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
if (parser.seen('Z')) set_z_fade_height(parser.value_linear_units());
#endif
const bool new_status = LEVELING_IS_ACTIVE();
const bool new_status = planner.leveling_active;
if (to_enable && !new_status) {
SERIAL_ERROR_START();

24
Marlin/src/gcode/bedlevel/abl/G29.cpp
View File

@ -247,7 +247,7 @@ void GcodeSuite::G29() {
abl_probe_index = -1;
#endif
abl_should_enable = LEVELING_IS_ACTIVE();
abl_should_enable = planner.leveling_active;
#if ENABLED(AUTO_BED_LEVELING_BILINEAR)
@ -388,7 +388,7 @@ void GcodeSuite::G29() {
stepper.synchronize();
// Disable auto bed leveling during G29
planner.abl_enabled = false;
planner.leveling_active = false;
if (!dryrun) {
// Re-orient the current position without leveling
@ -402,7 +402,7 @@ void GcodeSuite::G29() {
#if HAS_BED_PROBE
// Deploy the probe. Probe will raise if needed.
if (DEPLOY_PROBE()) {
planner.abl_enabled = abl_should_enable;
planner.leveling_active = abl_should_enable;
return;
}
#endif
@ -421,7 +421,7 @@ void GcodeSuite::G29() {
) {
if (dryrun) {
// Before reset bed level, re-enable to correct the position
planner.abl_enabled = abl_should_enable;
planner.leveling_active = abl_should_enable;
}
// Reset grid to 0.0 or "not probed". (Also disables ABL)
reset_bed_level();
@ -466,7 +466,7 @@ void GcodeSuite::G29() {
#if HAS_SOFTWARE_ENDSTOPS
soft_endstops_enabled = enable_soft_endstops;
#endif
planner.abl_enabled = abl_should_enable;
planner.leveling_active = abl_should_enable;
g29_in_progress = false;
#if ENABLED(LCD_BED_LEVELING)
lcd_wait_for_move = false;
@ -669,7 +669,7 @@ void GcodeSuite::G29() {
measured_z = faux ? 0.001 * random(-100, 101) : probe_pt(xProbe, yProbe, stow_probe_after_each, verbose_level);
if (isnan(measured_z)) {
planner.abl_enabled = abl_should_enable;
planner.leveling_active = abl_should_enable;
break;
}
@ -705,7 +705,7 @@ void GcodeSuite::G29() {
yProbe = LOGICAL_Y_POSITION(points[i].y);
measured_z = faux ? 0.001 * random(-100, 101) : probe_pt(xProbe, yProbe, stow_probe_after_each, verbose_level);
if (isnan(measured_z)) {
planner.abl_enabled = abl_should_enable;
planner.leveling_active = abl_should_enable;
break;
}
points[i].z = measured_z;
@ -728,7 +728,7 @@ void GcodeSuite::G29() {
// Raise to _Z_CLEARANCE_DEPLOY_PROBE. Stow the probe.
if (STOW_PROBE()) {
planner.abl_enabled = abl_should_enable;
planner.leveling_active = abl_should_enable;
measured_z = NAN;
}
}
@ -896,9 +896,9 @@ void GcodeSuite::G29() {
float converted[XYZ];
COPY(converted, current_position);
planner.abl_enabled = true;
planner.leveling_active = true;
planner.unapply_leveling(converted); // use conversion machinery
planner.abl_enabled = false;
planner.leveling_active = false;
// Use the last measured distance to the bed, if possible
if ( NEAR(current_position[X_AXIS], xProbe - (X_PROBE_OFFSET_FROM_EXTRUDER))
@ -950,7 +950,7 @@ void GcodeSuite::G29() {
#endif
// Auto Bed Leveling is complete! Enable if possible.
planner.abl_enabled = dryrun ? abl_should_enable : true;
planner.leveling_active = dryrun ? abl_should_enable : true;
} // !isnan(measured_z)
// Restore state after probing
@ -964,7 +964,7 @@ void GcodeSuite::G29() {
KEEPALIVE_STATE(IN_HANDLER);
if (LEVELING_IS_ACTIVE())
if (planner.leveling_active)
SYNC_PLAN_POSITION_KINEMATIC();
}

4
Marlin/src/gcode/bedlevel/mbl/G29.cpp
View File

@ -42,7 +42,7 @@
void echo_not_entered() { SERIAL_PROTOCOLLNPGM(" not entered."); }
void mesh_probing_done() {
mbl.set_has_mesh(true);
mbl.has_mesh = true;
gcode.home_all_axes();
set_bed_leveling_enabled(true);
#if ENABLED(MESH_G28_REST_ORIGIN)
@ -92,7 +92,7 @@ void GcodeSuite::G29() {
switch (state) {
case MeshReport:
if (leveling_is_valid()) {
SERIAL_PROTOCOLLNPAIR("State: ", LEVELING_IS_ACTIVE() ? MSG_ON : MSG_OFF);
SERIAL_PROTOCOLLNPAIR("State: ", planner.leveling_active ? MSG_ON : MSG_OFF);
mbl_mesh_report();
}
else

2
Marlin/src/gcode/calibrate/G28.cpp
View File

@ -157,7 +157,7 @@ void GcodeSuite::G28(const bool always_home_all) {
// Disable the leveling matrix before homing
#if HAS_LEVELING
#if ENABLED(AUTO_BED_LEVELING_UBL)
const bool ubl_state_at_entry = LEVELING_IS_ACTIVE();
const bool ubl_state_at_entry = planner.leveling_active;
#endif
set_bed_leveling_enabled(false);
#endif

2
Marlin/src/gcode/calibrate/M48.cpp
View File

@ -119,7 +119,7 @@ void GcodeSuite::M48() {
// Disable bed level correction in M48 because we want the raw data when we probe
#if HAS_LEVELING
const bool was_enabled = LEVELING_IS_ACTIVE();
const bool was_enabled = planner.leveling_active;
set_bed_leveling_enabled(false);
#endif

8
Marlin/src/lcd/ultralcd.cpp
View File

@ -1086,7 +1086,7 @@ void kill_screen(const char* lcd_msg) {
const float new_zoffset = zprobe_zoffset + planner.steps_to_mm[Z_AXIS] * babystep_increment;
if (WITHIN(new_zoffset, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX)) {
if (LEVELING_IS_ACTIVE())
if (planner.leveling_active)
thermalManager.babystep_axis(Z_AXIS, babystep_increment);
zprobe_zoffset = new_zoffset;
@ -1788,7 +1788,7 @@ void kill_screen(const char* lcd_msg) {
_lcd_after_probing();
mbl.set_has_mesh(true);
mbl.has_mesh = true;
mesh_probing_done();
#endif
@ -1934,12 +1934,12 @@ void kill_screen(const char* lcd_msg) {
if (!(axis_known_position[X_AXIS] && axis_known_position[Y_AXIS] && axis_known_position[Z_AXIS]))
MENU_ITEM(gcode, MSG_AUTO_HOME, PSTR("G28"));
else if (leveling_is_valid()) {
_level_state = LEVELING_IS_ACTIVE();
_level_state = planner.leveling_active;
MENU_ITEM_EDIT_CALLBACK(bool, MSG_BED_LEVELING, &_level_state, _lcd_toggle_bed_leveling);
}
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
set_z_fade_height(planner.z_fade_height);
//set_z_fade_height(planner.z_fade_height);
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float62, MSG_Z_FADE_HEIGHT, &planner.z_fade_height, 0.0, 100.0, _lcd_set_z_fade_height);
#endif

2
Marlin/src/lcd/ultralcd_impl_HD44780.h
View File

@ -795,7 +795,7 @@ static void lcd_implementation_status_screen() {
lcd.print(ftostr52sp(FIXFLOAT(current_position[Z_AXIS])));
#if HAS_LEVELING
lcd.write(LEVELING_IS_ACTIVE() || blink ? '_' : ' ');
lcd.write(planner.leveling_active || blink ? '_' : ' ');
#endif
#endif // LCD_HEIGHT > 2

30
Marlin/src/module/configuration_store.cpp
View File

@ -68,7 +68,7 @@
* 219 z_fade_height (float)
*
* MESH_BED_LEVELING: 43 bytes
* 223 M420 S from mbl.status (bool)
* 223 M420 S planner.leveling_active (bool)
* 224 mbl.z_offset (float)
* 228 GRID_MAX_POINTS_X (uint8_t)
* 229 GRID_MAX_POINTS_Y (uint8_t)
@ -88,7 +88,7 @@
* 316 z_values[][] (float x9, up to float x256) +988
*
* AUTO_BED_LEVELING_UBL: 2 bytes
* 324 G29 A ubl.state.active (bool)
* 324 G29 A planner.leveling_active (bool)
* 325 G29 S ubl.state.storage_slot (int8_t)
*
* DELTA: 48 bytes
@ -202,6 +202,10 @@ MarlinSettings settings;
#include "../feature/fwretract.h"
#endif
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
float new_z_fade_height;
#endif
/**
* Post-process after Retrieve or Reset
*/
@ -231,7 +235,7 @@ void MarlinSettings::postprocess() {
#endif
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
set_z_fade_height(planner.z_fade_height);
set_z_fade_height(new_z_fade_height);
#endif
#if HAS_BED_PROBE
@ -329,7 +333,7 @@ void MarlinSettings::postprocess() {
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
const float zfh = planner.z_fade_height;
#else
const float zfh = 10.0;
const float zfh = 0.0;
#endif
EEPROM_WRITE(zfh);
@ -343,7 +347,7 @@ void MarlinSettings::postprocess() {
sizeof(mbl.z_values) == GRID_MAX_POINTS * sizeof(mbl.z_values[0][0]),
"MBL Z array is the wrong size."
);
const bool leveling_is_on = TEST(mbl.status, MBL_STATUS_HAS_MESH_BIT);
const bool leveling_is_on = mbl.has_mesh;
const uint8_t mesh_num_x = GRID_MAX_POINTS_X, mesh_num_y = GRID_MAX_POINTS_Y;
EEPROM_WRITE(leveling_is_on);
EEPROM_WRITE(mbl.z_offset);
@ -406,7 +410,7 @@ void MarlinSettings::postprocess() {
#endif // AUTO_BED_LEVELING_BILINEAR
#if ENABLED(AUTO_BED_LEVELING_UBL)
EEPROM_WRITE(ubl.state.active);
EEPROM_WRITE(planner.leveling_active);
EEPROM_WRITE(ubl.state.storage_slot);
#else
const bool ubl_active = false;
@ -720,7 +724,7 @@ void MarlinSettings::postprocess() {
//
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
EEPROM_READ(planner.z_fade_height);
EEPROM_READ(new_z_fade_height);
#else
EEPROM_READ(dummy);
#endif
@ -737,7 +741,7 @@ void MarlinSettings::postprocess() {
EEPROM_READ(mesh_num_y);
#if ENABLED(MESH_BED_LEVELING)
mbl.status = leveling_is_on ? _BV(MBL_STATUS_HAS_MESH_BIT) : 0;
mbl.has_mesh = leveling_is_on;
mbl.z_offset = dummy;
if (mesh_num_x == GRID_MAX_POINTS_X && mesh_num_y == GRID_MAX_POINTS_Y) {
// EEPROM data fits the current mesh
@ -793,7 +797,7 @@ void MarlinSettings::postprocess() {
}
#if ENABLED(AUTO_BED_LEVELING_UBL)
EEPROM_READ(ubl.state.active);
EEPROM_READ(planner.leveling_active);
EEPROM_READ(ubl.state.storage_slot);
#else
uint8_t dummyui8;
@ -1156,7 +1160,7 @@ void MarlinSettings::reset() {
planner.max_jerk[E_AXIS] = DEFAULT_EJERK;
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
planner.z_fade_height = 0.0;
new_z_fade_height = 0.0;
#endif
#if HAS_HOME_OFFSET
@ -1556,9 +1560,9 @@ void MarlinSettings::reset() {
SERIAL_ECHOLNPGM(":");
}
CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" M420 S", LEVELING_IS_ACTIVE() ? 1 : 0);
SERIAL_ECHOPAIR(" M420 S", planner.leveling_active ? 1 : 0);
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
SERIAL_ECHOPAIR(" Z", planner.z_fade_height);
SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.z_fade_height));
#endif
SERIAL_EOL();
@ -1578,7 +1582,7 @@ void MarlinSettings::reset() {
SERIAL_ECHOLNPGM("Auto Bed Leveling:");
}
CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" M420 S", LEVELING_IS_ACTIVE() ? 1 : 0);
SERIAL_ECHOPAIR(" M420 S", planner.leveling_active ? 1 : 0);
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.z_fade_height));
#endif

53
Marlin/src/module/motion.cpp
View File

@ -490,14 +490,14 @@ float soft_endstop_min[XYZ] = { X_MIN_BED, Y_MIN_BED, Z_MIN_POS },
#if ENABLED(AUTO_BED_LEVELING_BILINEAR)
#if ENABLED(DELTA)
#define ADJUST_DELTA(V) \
if (LEVELING_IS_ACTIVE()) { \
if (planner.leveling_active) { \
const float zadj = bilinear_z_offset(V); \
delta[A_AXIS] += zadj; \
delta[B_AXIS] += zadj; \
delta[C_AXIS] += zadj; \
}
#else
#define ADJUST_DELTA(V) if (LEVELING_IS_ACTIVE()) { delta[Z_AXIS] += bilinear_z_offset(V); }
#define ADJUST_DELTA(V) if (planner.leveling_active) { delta[Z_AXIS] += bilinear_z_offset(V); }
#endif
#else
#define ADJUST_DELTA(V) NOOP
@ -630,41 +630,30 @@ float soft_endstop_min[XYZ] = { X_MIN_BED, Y_MIN_BED, Z_MIN_POS },
/**
* Prepare a linear move in a Cartesian setup.
* If Mesh Bed Leveling is enabled, perform a mesh move.
* Bed Leveling will be applied to the move if enabled.
*
* Returns true if the caller didn't update current_position.
* Returns true if current_position[] was set to destination[]
*/
inline bool prepare_move_to_destination_cartesian() {
#if ENABLED(AUTO_BED_LEVELING_UBL)
if (current_position[X_AXIS] != destination[X_AXIS] || current_position[Y_AXIS] != destination[Y_AXIS]) {
const float fr_scaled = MMS_SCALED(feedrate_mm_s);
if (ubl.state.active) { // direct use of ubl.state.active for speed
ubl.line_to_destination_cartesian(fr_scaled, active_extruder);
return true;
}
else
line_to_destination(fr_scaled);
#else
// Do not use feedrate_percentage for E or Z only moves
if (current_position[X_AXIS] == destination[X_AXIS] && current_position[Y_AXIS] == destination[Y_AXIS])
line_to_destination();
else {
const float fr_scaled = MMS_SCALED(feedrate_mm_s);
#if ENABLED(MESH_BED_LEVELING)
if (mbl.active()) { // direct used of mbl.active() for speed
#if HAS_MESH
if (planner.leveling_active) {
#if ENABLED(AUTO_BED_LEVELING_UBL)
ubl.line_to_destination_cartesian(fr_scaled, active_extruder);
#elif ENABLED(MESH_BED_LEVELING)
mesh_line_to_destination(fr_scaled);
return true;
}
else
#elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
if (planner.abl_enabled) { // direct use of abl_enabled for speed
#elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
bilinear_line_to_destination(fr_scaled);
return true;
}
else
#endif
line_to_destination(fr_scaled);
}
#endif
#endif
return true;
}
#endif // HAS_MESH
line_to_destination(fr_scaled);
}
else
line_to_destination();
return false;
}
@ -699,6 +688,8 @@ float soft_endstop_min[XYZ] = { X_MIN_BED, Y_MIN_BED, Z_MIN_POS },
/**
* Prepare a linear move in a dual X axis setup
*
* Return true if current_position[] was set to destination[]
*/
inline bool prepare_move_to_destination_dualx() {
if (active_extruder_parked) {

73
Marlin/src/module/planner.cpp
View File

@ -122,8 +122,8 @@ float Planner::min_feedrate_mm_s,
Planner::max_jerk[XYZE], // The largest speed change requiring no acceleration
Planner::min_travel_feedrate_mm_s;
#if OLDSCHOOL_ABL
bool Planner::abl_enabled = false; // Flag that auto bed leveling is enabled
#if HAS_LEVELING
bool Planner::leveling_active = false; // Flag that auto bed leveling is enabled
#if ABL_PLANAR
matrix_3x3 Planner::bed_level_matrix; // Transform to compensate for bed level
#endif
@ -556,7 +556,7 @@ void Planner::calculate_volumetric_multipliers() {
*/
void Planner::apply_leveling(float &lx, float &ly, float &lz) {
if (!LEVELING_IS_ACTIVE()) return;
if (!planner.leveling_active) return;
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
const float fade_scaling_factor = fade_scaling_factor_for_z(lz);
@ -601,48 +601,41 @@ void Planner::calculate_volumetric_multipliers() {
void Planner::unapply_leveling(float logical[XYZ]) {
#if ENABLED(AUTO_BED_LEVELING_UBL)
if (ubl.state.active) {
const float z_physical = RAW_Z_POSITION(logical[Z_AXIS]),
z_correct = ubl.get_z_correction(logical[X_AXIS], logical[Y_AXIS]),
z_virtual = z_physical - z_correct;
float z_logical = LOGICAL_Z_POSITION(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_logical >= planner.z_fade_height)
z_logical = LOGICAL_Z_POSITION(z_physical);
else
z_logical /= 1.0 - z_correct * planner.inverse_z_fade_height;
}
#endif // ENABLE_LEVELING_FADE_HEIGHT
logical[Z_AXIS] = z_logical;
}
return; // don't fall thru to other ENABLE_LEVELING_FADE_HEIGHT logic
#endif
if (!LEVELING_IS_ACTIVE()) return;
if (!planner.leveling_active) return;
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
if (z_fade_height && RAW_Z_POSITION(logical[Z_AXIS]) >= z_fade_height) return;
#endif
#if ENABLED(MESH_BED_LEVELING)
#if ENABLED(AUTO_BED_LEVELING_UBL)
const float z_physical = RAW_Z_POSITION(logical[Z_AXIS]),
z_correct = ubl.get_z_correction(logical[X_AXIS], logical[Y_AXIS]),
z_virtual = z_physical - z_correct;
float z_logical = LOGICAL_Z_POSITION(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_logical >= planner.z_fade_height)
z_logical = LOGICAL_Z_POSITION(z_physical);
else
z_logical /= 1.0 - z_correct * planner.inverse_z_fade_height;
}
#endif // ENABLE_LEVELING_FADE_HEIGHT
logical[Z_AXIS] = z_logical;
#elif ENABLED(MESH_BED_LEVELING)
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
const float c = mbl.get_z(RAW_X_POSITION(logical[X_AXIS]), RAW_Y_POSITION(logical[Y_AXIS]), 1.0);

23
Marlin/src/module/planner.h
View File

@ -164,15 +164,14 @@ class Planner {
max_jerk[XYZE], // The largest speed change requiring no acceleration
min_travel_feedrate_mm_s;
#if OLDSCHOOL_ABL
static bool abl_enabled; // Flag that bed leveling is enabled
#if HAS_LEVELING
static bool leveling_active; // Flag that bed leveling is enabled
#if ABL_PLANAR
static matrix_3x3 bed_level_matrix; // Transform to compensate for bed level
#endif
#endif
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
static float z_fade_height, inverse_z_fade_height;
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
static float z_fade_height, inverse_z_fade_height;
#endif
#endif
#if ENABLED(LIN_ADVANCE)
@ -292,6 +291,16 @@ class Planner {
FORCE_INLINE static void force_fade_recalc() { last_raw_lz = -999.999; }
FORCE_INLINE static void set_z_fade_height(const float &zfh) {
z_fade_height = zfh > 0 ? zfh : 0;
inverse_z_fade_height = RECIPROCAL(z_fade_height);
force_fade_recalc();
}
FORCE_INLINE static bool leveling_active_at_z(const float &lz) {
return !z_fade_height || RAW_Z_POSITION(lz) < z_fade_height;
}
#else
FORCE_INLINE static float fade_scaling_factor_for_z(const float &lz) {
@ -299,6 +308,8 @@ class Planner {
return 1.0;
}
FORCE_INLINE static bool leveling_active_at_z(const float &lz) { return true; }
#endif
#if PLANNER_LEVELING

2
Marlin/src/module/probe.cpp
View File

@ -679,7 +679,7 @@ void refresh_zprobe_zoffset(const bool no_babystep/*=false*/) {
#endif
#if ENABLED(BABYSTEP_ZPROBE_OFFSET)
if (!no_babystep && LEVELING_IS_ACTIVE())
if (!no_babystep && planner.leveling_active)
thermalManager.babystep_axis(Z_AXIS, -LROUND(diff * planner.axis_steps_per_mm[Z_AXIS]));
#else
UNUSED(no_babystep);

2
Marlin/src/module/tool_change.cpp
View File

@ -464,7 +464,7 @@ void tool_change(const uint8_t tmp_extruder, const float fr_mm_s/*=0.0*/, bool n
#if ENABLED(MESH_BED_LEVELING)
if (LEVELING_IS_ACTIVE()) {
if (planner.leveling_active) {
#if ENABLED(DEBUG_LEVELING_FEATURE)
if (DEBUGGING(LEVELING)) SERIAL_ECHOPAIR("Z before MBL: ", current_position[Z_AXIS]);
#endif