diff --git a/Marlin/Conditionals_post.h b/Marlin/Conditionals_post.h index 2a1f4e0b8e..b303b65aab 100644 --- a/Marlin/Conditionals_post.h +++ b/Marlin/Conditionals_post.h @@ -731,15 +731,12 @@ * Set granular options based on the specific type of leveling */ - #if ENABLED(AUTO_BED_LEVELING_UBL) && ENABLED(DELTA) - #define UBL_DELTA - #endif - + #define UBL_DELTA (ENABLED(AUTO_BED_LEVELING_UBL) && ENABLED(DELTA)) #define ABL_PLANAR (ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_3POINT)) #define ABL_GRID (ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)) #define HAS_ABL (ABL_PLANAR || ABL_GRID || ENABLED(AUTO_BED_LEVELING_UBL)) #define HAS_LEVELING (HAS_ABL || ENABLED(MESH_BED_LEVELING)) - #define PLANNER_LEVELING (ABL_PLANAR || ABL_GRID || ENABLED(MESH_BED_LEVELING) || ENABLED(UBL_DELTA)) + #define PLANNER_LEVELING (ABL_PLANAR || ABL_GRID || ENABLED(MESH_BED_LEVELING) || UBL_DELTA) #define HAS_PROBING_PROCEDURE (HAS_ABL || ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST)) #if HAS_PROBING_PROCEDURE #define PROBE_BED_WIDTH abs(RIGHT_PROBE_BED_POSITION - (LEFT_PROBE_BED_POSITION)) @@ -823,8 +820,7 @@ /** * DELTA_SEGMENT_MIN_LENGTH for UBL_DELTA */ - - #if ENABLED(UBL_DELTA) + #if UBL_DELTA #ifndef DELTA_SEGMENT_MIN_LENGTH #if IS_SCARA #define DELTA_SEGMENT_MIN_LENGTH 0.25 // SCARA minimum segment size is 0.25mm @@ -836,4 +832,7 @@ #endif #endif + // Shorthand + #define GRID_MAX_POINTS ((GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y)) + #endif // CONDITIONALS_POST_H diff --git a/Marlin/G26_Mesh_Validation_Tool.cpp b/Marlin/G26_Mesh_Validation_Tool.cpp index 6b862358d0..e4fa01dd3c 100644 --- a/Marlin/G26_Mesh_Validation_Tool.cpp +++ b/Marlin/G26_Mesh_Validation_Tool.cpp @@ -100,7 +100,7 @@ * 'n' can be used instead if your host program does not appreciate you using 'N'. * * O # Ooooze How much your nozzle will Ooooze filament while getting in position to print. This - * is over kill, but using this parameter will let you get the very first 'cicle' perfect + * is over kill, but using this parameter will let you get the very first 'circle' perfect * so you have a trophy to peel off of the bed and hang up to show how perfectly you have your * Mesh calibrated. If not specified, a filament length of .3mm is assumed. * @@ -152,7 +152,7 @@ bool turn_on_heaters(); bool prime_nozzle(); - static uint16_t circle_flags[16], horizontal_mesh_line_flags[16], vertical_mesh_line_flags[16], continue_with_closest = 0; + static uint16_t circle_flags[16], horizontal_mesh_line_flags[16], vertical_mesh_line_flags[16]; float g26_e_axis_feedrate = 0.020, random_deviation = 0.0, layer_height = LAYER_HEIGHT; @@ -176,7 +176,7 @@ static int8_t prime_flag = 0; - static bool keep_heaters_on = false; + static bool continue_with_closest, keep_heaters_on; static int16_t g26_repeats; @@ -278,8 +278,7 @@ // If this mesh location is outside the printable_radius, skip it. - if ( ! position_is_reachable_raw_xy( circle_x, circle_y )) - continue; + if (!position_is_reachable_raw_xy(circle_x, circle_y)) continue; xi = location.x_index; // Just to shrink the next few lines and make them easier to understand yi = location.y_index; @@ -329,9 +328,7 @@ ye = circle_y + sin_table[tmp_div_30 + 1]; #if IS_KINEMATIC // Check to make sure this segment is entirely on the bed, skip if not. - if (( ! position_is_reachable_raw_xy( x , y )) || - ( ! position_is_reachable_raw_xy( xe, ye ))) - continue; + if (!position_is_reachable_raw_xy(x, y) || !position_is_reachable_raw_xy(xe, ye)) continue; #else // not, we need to skip x = constrain(x, X_MIN_POS + 1, X_MAX_POS - 1); // This keeps us from bumping the endstops y = constrain(y, Y_MIN_POS + 1, Y_MAX_POS - 1); @@ -361,7 +358,7 @@ //debug_current_and_destination(PSTR("Done with current circle.")); - } while (location.x_index >= 0 && location.y_index >= 0 && g26_repeats--); + } while (--g26_repeats && location.x_index >= 0 && location.y_index >= 0); LEAVE: lcd_reset_alert_level(); @@ -459,8 +456,7 @@ sy = ey = constrain(pgm_read_float(&ubl.mesh_index_to_ypos[j]), Y_MIN_POS + 1, Y_MAX_POS - 1); ex = constrain(ex, X_MIN_POS + 1, X_MAX_POS - 1); - if (( position_is_reachable_raw_xy( sx, sy )) && - ( position_is_reachable_raw_xy( ex, ey ))) { + if (position_is_reachable_raw_xy(sx, sy) && position_is_reachable_raw_xy(ex, ey)) { if (ubl.g26_debug_flag) { SERIAL_ECHOPAIR(" Connecting with horizontal line (sx=", sx); @@ -494,8 +490,7 @@ sy = constrain(sy, Y_MIN_POS + 1, Y_MAX_POS - 1); ey = constrain(ey, Y_MIN_POS + 1, Y_MAX_POS - 1); - if (( position_is_reachable_raw_xy( sx, sy )) && - ( position_is_reachable_raw_xy( ex, ey ))) { + if (position_is_reachable_raw_xy(sx, sy) && position_is_reachable_raw_xy(ex, ey)) { if (ubl.g26_debug_flag) { SERIAL_ECHOPAIR(" Connecting with vertical line (sx=", sx); @@ -623,8 +618,8 @@ //if (ubl.g26_debug_flag) SERIAL_ECHOLNPGM(" Z bumping by 0.500 to minimize scraping."); //todo: parameterize the bump height with a define - move_to(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS]+0.500, 0.0); // Z bump to minimize scraping - move_to(sx, sy, sz+0.500, 0.0); // Get to the starting point with no extrusion while bumped + move_to(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS] + 0.500, 0.0); // Z bump to minimize scraping + move_to(sx, sy, sz + 0.500, 0.0); // Get to the starting point with no extrusion while bumped } move_to(sx, sy, sz, 0.0); // Get to the starting point with no extrusion / un-Z bump @@ -655,9 +650,11 @@ prime_length = PRIME_LENGTH; bed_temp = BED_TEMP; hotend_temp = HOTEND_TEMP; - ooze_amount = OOZE_AMOUNT; prime_flag = 0; - keep_heaters_on = false; + + ooze_amount = code_seen('O') && code_has_value() ? code_value_linear_units() : OOZE_AMOUNT; + keep_heaters_on = code_seen('K') && code_value_bool(); + continue_with_closest = code_seen('C') && code_value_bool(); if (code_seen('B')) { bed_temp = code_value_temp_abs(); @@ -667,8 +664,6 @@ } } - if (code_seen('C')) continue_with_closest++; - if (code_seen('L')) { layer_height = code_value_linear_units(); if (!WITHIN(layer_height, 0.0, 2.0)) { @@ -691,7 +686,7 @@ } } - if (code_seen('N') || code_seen('n')) { + if (code_seen('N') || code_seen('n')) { // Warning! Use of 'N' / lowercase flouts established standards. nozzle = code_value_float(); if (!WITHIN(nozzle, 0.1, 1.0)) { SERIAL_PROTOCOLLNPGM("?Specified nozzle size not plausible."); @@ -699,11 +694,6 @@ } } - if (code_seen('K')) keep_heaters_on++; - - if (code_seen('O') && code_has_value()) - ooze_amount = code_value_linear_units(); - if (code_seen('P')) { if (!code_has_value()) prime_flag = -1; @@ -738,35 +728,21 @@ } } - if (code_seen('M')) { + if (code_seen('M')) { // Warning! Use of 'M' flouts established standards. randomSeed(millis()); + // This setting will persist for the next G26 random_deviation = code_has_value() ? code_value_float() : 50.0; } - if (code_seen('R')) { - g26_repeats = code_has_value() ? code_value_int() : 999; - - if (g26_repeats <= 0) { - SERIAL_PROTOCOLLNPGM("?(R)epeat value not plausible; must be greater than 0."); - return UBL_ERR; - } - - g26_repeats--; + g26_repeats = code_seen('R') ? (code_has_value() ? code_value_int() : 999) : 1; + if (g26_repeats < 1) { + SERIAL_PROTOCOLLNPGM("?(R)epeat value not plausible; must be at least 1."); + return UBL_ERR; } - - x_pos = current_position[X_AXIS]; - y_pos = current_position[Y_AXIS]; - - if (code_seen('X')) { - x_pos = code_value_float(); - } - - if (code_seen('Y')) { - y_pos = code_value_float(); - } - - if ( ! position_is_reachable_xy( x_pos, y_pos )) { + x_pos = code_seen('X') ? code_value_linear_units() : current_position[X_AXIS]; + y_pos = code_seen('Y') ? code_value_linear_units() : current_position[Y_AXIS]; + if (!position_is_reachable_xy(x_pos, y_pos)) { SERIAL_PROTOCOLLNPGM("?Specified X,Y coordinate out of bounds."); return UBL_ERR; } diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp index 983ae939e1..5c8d70ff1c 100644 --- a/Marlin/Marlin_main.cpp +++ b/Marlin/Marlin_main.cpp @@ -56,6 +56,8 @@ * G12 - Clean tool * G20 - Set input units to inches * G21 - Set input units to millimeters + * G26 - Mesh Validation Pattern (Requires UBL_G26_MESH_EDITING) + * G27 - Park Nozzle (Requires NOZZLE_PARK_FEATURE) * G28 - Home one or more axes * G29 - Detailed Z probe, probes the bed at 3 or more points. Will fail if you haven't homed yet. * G30 - Single Z probe, probes bed at X Y location (defaults to current XY location) @@ -97,14 +99,15 @@ * M76 - Pause the print job timer. * M77 - Stop the print job timer. * M78 - Show statistical information about the print jobs. (Requires PRINTCOUNTER) - * M80 - Turn on Power Supply. (Requires POWER_SUPPLY) - * M81 - Turn off Power Supply. (Requires POWER_SUPPLY) + * M80 - Turn on Power Supply. (Requires POWER_SUPPLY > 0) + * M81 - Turn off Power Supply. (Requires POWER_SUPPLY > 0) * M82 - Set E codes absolute (default). * M83 - Set E codes relative while in Absolute (G90) mode. * M84 - Disable steppers until next move, or use S to specify an idle * duration after which steppers should turn off. S0 disables the timeout. * M85 - Set inactivity shutdown timer with parameter S. To disable set zero (default) * M92 - Set planner.axis_steps_per_mm for one or more axes. + * M100 - Watch Free Memory (for debugging) (Requires M100_FREE_MEMORY_WATCHER) * M104 - Set extruder target temp. * M105 - Report current temperatures. * M106 - Fan on. @@ -210,7 +213,6 @@ * M364 - SCARA calibration: Move to cal-position PSIC (90 deg to Theta calibration position) * * ************ Custom codes - This can change to suit future G-code regulations - * M100 - Watch Free Memory (For Debugging). (Requires M100_FREE_MEMORY_WATCHER) * M928 - Start SD logging: "M928 filename.gco". Stop with M29. (Requires SDSUPPORT) * M999 - Restart after being stopped by error * @@ -2425,9 +2427,12 @@ static void clean_up_after_endstop_or_probe_move() { #elif ENABLED(AUTO_BED_LEVELING_UBL) - #if ENABLED(UBL_DELTA) - if (( ubl.state.active ) && ( ! enable )) { // leveling from on to off - planner.unapply_leveling(current_position); + #if PLANNER_LEVELING + if (ubl.state.active != enable) { + if (!enable) // leveling from on to off + planner.apply_leveling(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS]); + else + planner.unapply_leveling(current_position); } #endif @@ -3729,7 +3734,7 @@ inline void gcode_G28() { // Disable the leveling matrix before homing #if HAS_LEVELING #if ENABLED(AUTO_BED_LEVELING_UBL) - const bool bed_leveling_state_at_entry = ubl.state.active; + const bool ubl_state_at_entry = ubl.state.active; #endif set_bed_leveling_enabled(false); #endif @@ -3872,8 +3877,9 @@ inline void gcode_G28() { // move to a height where we can use the full xy-area do_blocking_move_to_z(delta_clip_start_height); #endif + #if ENABLED(AUTO_BED_LEVELING_UBL) - set_bed_leveling_enabled(bed_leveling_state_at_entry); + set_bed_leveling_enabled(ubl_state_at_entry); #endif clean_up_after_endstop_or_probe_move(); @@ -4028,7 +4034,7 @@ void home_all_axes() { gcode_G28(); } #endif } // If there's another point to sample, move there with optional lift. - if (mbl_probe_index < (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y)) { + if (mbl_probe_index < GRID_MAX_POINTS) { mbl.zigzag(mbl_probe_index, px, py); _manual_goto_xy(mbl.index_to_xpos[px], mbl.index_to_ypos[py]); @@ -4247,8 +4253,6 @@ void home_all_axes() { gcode_G28(); } ABL_VAR int left_probe_bed_position, right_probe_bed_position, front_probe_bed_position, back_probe_bed_position; ABL_VAR float xGridSpacing, yGridSpacing; - #define ABL_GRID_MAX (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y) - #if ABL_PLANAR ABL_VAR uint8_t abl_grid_points_x = GRID_MAX_POINTS_X, abl_grid_points_y = GRID_MAX_POINTS_Y; @@ -4262,7 +4266,7 @@ void home_all_axes() { gcode_G28(); } #if ABL_PLANAR ABL_VAR int abl2; #else // 3-point - int constexpr abl2 = ABL_GRID_MAX; + int constexpr abl2 = GRID_MAX_POINTS; #endif #endif @@ -4274,8 +4278,8 @@ void home_all_axes() { gcode_G28(); } ABL_VAR int indexIntoAB[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y]; - ABL_VAR float eqnAMatrix[ABL_GRID_MAX * 3], // "A" matrix of the linear system of equations - eqnBVector[ABL_GRID_MAX], // "B" vector of Z points + ABL_VAR float eqnAMatrix[GRID_MAX_POINTS * 3], // "A" matrix of the linear system of equations + eqnBVector[GRID_MAX_POINTS], // "B" vector of Z points mean; #endif @@ -7619,7 +7623,6 @@ inline void gcode_M205() { if (code_seen('H')) { home_offset[Z_AXIS] = code_value_linear_units() - DELTA_HEIGHT; current_position[Z_AXIS] += code_value_linear_units() - DELTA_HEIGHT - home_offset[Z_AXIS]; - home_offset[Z_AXIS] = code_value_linear_units() - DELTA_HEIGHT; update_software_endstops(Z_AXIS); } if (code_seen('L')) delta_diagonal_rod = code_value_linear_units(); @@ -8413,17 +8416,15 @@ void quickstop_stepper() { * Use either 'M421 X Y Z' or 'M421 I J Z' */ inline void gcode_M421() { - int8_t px = 0, py = 0; - float z = 0; - bool hasX, hasY, hasZ, hasI, hasJ; - if ((hasX = code_seen('X'))) px = mbl.probe_index_x(code_value_linear_units()); - if ((hasY = code_seen('Y'))) py = mbl.probe_index_y(code_value_linear_units()); - if ((hasI = code_seen('I'))) px = code_value_linear_units(); - if ((hasJ = code_seen('J'))) py = code_value_linear_units(); - if ((hasZ = code_seen('Z'))) z = code_value_linear_units(); + + const bool hasX = code_seen('X'), hasI = !hasX && code_seen('I'); + const int8_t px = hasX || hasI ? mbl.probe_index_x(code_value_linear_units()) : 0; + const bool hasY = code_seen('Y'), hasJ = !hasY && code_seen('J'); + const int8_t py = hasY || hasJ ? mbl.probe_index_y(code_value_linear_units()) : 0; + const bool hasZ = code_seen('Z'); + const float z = hasZ ? code_value_linear_units() : 0; if (hasX && hasY && hasZ) { - if (px >= 0 && py >= 0) mbl.set_z(px, py, z); else { @@ -8450,18 +8451,18 @@ void quickstop_stepper() { /** * M421: Set a single Mesh Bed Leveling Z coordinate * + * Usage: * M421 I J Z - * or * M421 I J Q */ inline void gcode_M421() { - int8_t px = 0, py = 0; - float z = 0; - bool hasI, hasJ, hasZ, hasQ; - if ((hasI = code_seen('I'))) px = code_value_int(); - if ((hasJ = code_seen('J'))) py = code_value_int(); - if ((hasZ = code_seen('Z'))) z = code_value_linear_units(); - if ((hasQ = code_seen('Q'))) z = code_value_linear_units(); + + const bool hasI = code_seen('I'); + const int8_t px = hasI ? code_value_int() : 0; + const bool hasJ = code_seen('J'); + const int8_t py = hasJ ? code_value_int() : 0; + const bool hasZ = code_seen('Z'), hasQ = !hasZ && code_seen('Q'); + const float z = hasZ || hasQ ? code_value_linear_units() : 0; if (!hasI || !hasJ || (hasQ && hasZ) || (!hasQ && !hasZ)) { SERIAL_ERROR_START; @@ -8494,35 +8495,33 @@ void quickstop_stepper() { /** * M421: Set a single Mesh Bed Leveling Z coordinate * + * Usage: * M421 I J Z - * or * M421 I J Q + * M421 C Z + * M421 C Q */ - //todo: change multiple points simultaneously? - inline void gcode_M421() { - int8_t px = 0, py = 0; - float z = 0; - bool hasI, hasJ, hasZ, hasQ, hasC; - if ((hasI = code_seen('I'))) px = code_value_int(); - if ((hasJ = code_seen('J'))) py = code_value_int(); - if ((hasZ = code_seen('Z'))) z = code_value_linear_units(); - if ((hasQ = code_seen('Q'))) z = code_value_linear_units(); - hasC = code_seen('C'); - if ( (!(hasI && hasJ) && !hasC) || (hasQ && hasZ) || (!hasQ && !hasZ)) { + // Get the closest position for 'C', if needed + const mesh_index_pair location = find_closest_mesh_point_of_type(REAL, current_position[X_AXIS], current_position[Y_AXIS], USE_NOZZLE_AS_REFERENCE, NULL, false); + + const bool hasC = code_seen('C'), hasI = code_seen('I'); + const int8_t px = hasC ? location.x_index : hasI ? code_value_int() : 0; + + const bool hasJ = code_seen('J'); + const int8_t py = hasC ? location.y_index : hasJ ? code_value_int() : 0; + + const bool hasZ = code_seen('Z'), hasQ = !hasZ && code_seen('Q'); + const float z = hasZ || hasQ ? code_value_linear_units() : 0; + + if ( ((hasI && hasJ) == hasC) || (hasQ && hasZ) || (!hasQ && !hasZ)) { SERIAL_ERROR_START; SERIAL_ERRORLNPGM(MSG_ERR_M421_PARAMETERS); return; } - if (hasC) { // get closest position - const mesh_index_pair location = find_closest_mesh_point_of_type(REAL, current_position[X_AXIS], current_position[Y_AXIS], USE_NOZZLE_AS_REFERENCE, NULL, false); - px = location.x_index; - py = location.y_index; - } - if (WITHIN(px, 0, GRID_MAX_POINTS_X - 1) && WITHIN(py, 0, GRID_MAX_POINTS_Y - 1)) { if (hasZ) // doing an absolute mesh value ubl.z_values[px][py] = z; @@ -8534,7 +8533,8 @@ void quickstop_stepper() { SERIAL_ERRORLNPGM(MSG_ERR_MESH_XY); } } -#endif + +#endif // AUTO_BED_LEVELING_UBL #if HAS_M206_COMMAND @@ -11106,7 +11106,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { #endif // AUTO_BED_LEVELING_BILINEAR -#if IS_KINEMATIC && DISABLED(UBL_DELTA) +#if IS_KINEMATIC && !UBL_DELTA /** * Prepare a linear move in a DELTA or SCARA setup. @@ -11117,7 +11117,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { inline bool prepare_kinematic_move_to(float ltarget[XYZE]) { // Get the top feedrate of the move in the XY plane - float _feedrate_mm_s = MMS_SCALED(feedrate_mm_s); + const float _feedrate_mm_s = MMS_SCALED(feedrate_mm_s); // If the move is only in Z/E don't split up the move if (ltarget[X_AXIS] == current_position[X_AXIS] && ltarget[Y_AXIS] == current_position[Y_AXIS]) { @@ -11126,7 +11126,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { } // Fail if attempting move outside printable radius - if ( ! position_is_reachable_xy( ltarget[X_AXIS], ltarget[Y_AXIS] )) return true; + if (!position_is_reachable_xy(ltarget[X_AXIS], ltarget[Y_AXIS])) return true; // Get the cartesian distances moved in XYZE float difference[XYZE]; @@ -11142,7 +11142,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { if (UNEAR_ZERO(cartesian_mm)) return true; // Minimum number of seconds to move the given distance - float seconds = cartesian_mm / _feedrate_mm_s; + const float seconds = cartesian_mm / _feedrate_mm_s; // The number of segments-per-second times the duration // gives the number of segments @@ -11227,7 +11227,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { return false; } -#else // !IS_KINEMATIC +#else // !IS_KINEMATIC || UBL_DELTA /** * Prepare a linear move in a Cartesian setup. @@ -11265,7 +11265,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { return false; } -#endif // !IS_KINEMATIC +#endif // !IS_KINEMATIC || UBL_DELTA #if ENABLED(DUAL_X_CARRIAGE) @@ -11377,21 +11377,21 @@ void prepare_move_to_destination() { #endif - #if IS_KINEMATIC - #if ENABLED(UBL_DELTA) - if (ubl_prepare_linear_move_to(destination,feedrate_mm_s)) return; + if ( + #if IS_KINEMATIC + #if UBL_DELTA + ubl_prepare_linear_move_to(destination, feedrate_mm_s) + #else + prepare_kinematic_move_to(destination) + #endif + #elif ENABLED(DUAL_X_CARRIAGE) + prepare_move_to_destination_dualx() + #elif UBL_DELTA // will work for CARTESIAN too (smaller segments follow mesh more closely) + ubl_prepare_linear_move_to(destination, feedrate_mm_s) #else - if (prepare_kinematic_move_to(destination)) return; + prepare_move_to_destination_cartesian() #endif - #else - #if ENABLED(DUAL_X_CARRIAGE) - if (prepare_move_to_destination_dualx()) return; - #elif ENABLED(UBL_DELTA) // will work for CARTESIAN too (smaller segments follow mesh more closely) - if (ubl_prepare_linear_move_to(destination,feedrate_mm_s)) return; - #else - if (prepare_move_to_destination_cartesian()) return; - #endif - #endif + ) return; set_current_to_destination(); } @@ -11432,7 +11432,7 @@ void prepare_move_to_destination() { if (angular_travel == 0 && current_position[X_AXIS] == logical[X_AXIS] && current_position[Y_AXIS] == logical[Y_AXIS]) angular_travel += RADIANS(360); - float mm_of_travel = HYPOT(angular_travel * radius, fabs(linear_travel)); + const float mm_of_travel = HYPOT(angular_travel * radius, fabs(linear_travel)); if (mm_of_travel < 0.001) return; uint16_t segments = floor(mm_of_travel / (MM_PER_ARC_SEGMENT)); diff --git a/Marlin/SanityCheck.h b/Marlin/SanityCheck.h index 006bf68293..3aa307298a 100644 --- a/Marlin/SanityCheck.h +++ b/Marlin/SanityCheck.h @@ -248,11 +248,9 @@ #if ENABLED(DELTA) #if DISABLED(USE_XMAX_PLUG) && DISABLED(USE_YMAX_PLUG) && DISABLED(USE_ZMAX_PLUG) #error "You probably want to use Max Endstops for DELTA!" - #endif - #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT) && DISABLED(UBL_DELTA) - #error "ENABLE_LEVELING_FADE_HEIGHT for DELTA requires UBL_DELTA and AUTO_BED_LEVELING_UBL." - #endif - #if ABL_GRID + #elif ENABLED(ENABLE_LEVELING_FADE_HEIGHT) && DISABLED(AUTO_BED_LEVELING_BILINEAR) && !UBL_DELTA + #error "ENABLE_LEVELING_FADE_HEIGHT on DELTA requires AUTO_BED_LEVELING_BILINEAR or AUTO_BED_LEVELING_UBL." + #elif ABL_GRID #if (GRID_MAX_POINTS_X & 1) == 0 || (GRID_MAX_POINTS_Y & 1) == 0 #error "DELTA requires GRID_MAX_POINTS_X and GRID_MAX_POINTS_Y to be odd numbers." #elif GRID_MAX_POINTS_X < 3 @@ -431,20 +429,11 @@ static_assert(1 >= 0 * Unified Bed Leveling */ #if ENABLED(AUTO_BED_LEVELING_UBL) - #if IS_KINEMATIC - #if ENABLED(DELTA) - #if DISABLED(UBL_DELTA) - #error "AUTO_BED_LEVELING_UBL requires UBL_DELTA for DELTA printers." - #endif - #else // SCARA - #error "AUTO_BED_LEVELING_UBL not supported for SCARA printers." - #endif - #endif - #if DISABLED(NEWPANEL) + #if IS_SCARA + #error "AUTO_BED_LEVELING_UBL does not yet support SCARA printers." + #elif DISABLED(NEWPANEL) #error "AUTO_BED_LEVELING_UBL requires an LCD controller." #endif -#elif ENABLED(UBL_DELTA) - #error "UBL_DELTA requires AUTO_BED_LEVELING_UBL." #endif /** @@ -603,10 +592,8 @@ static_assert(1 >= 0 /** * Delta and SCARA have limited bed leveling options */ - #if IS_KINEMATIC - #if DISABLED(AUTO_BED_LEVELING_BILINEAR) && DISABLED(UBL_DELTA) - #error "Only AUTO_BED_LEVELING_BILINEAR or AUTO_BED_LEVELING_UBL with UBL_DELTA support DELTA and SCARA bed leveling." - #endif + #if IS_SCARA && DISABLED(AUTO_BED_LEVELING_BILINEAR) + #error "Only AUTO_BED_LEVELING_BILINEAR currently supports SCARA bed leveling." #endif /** diff --git a/Marlin/configuration_store.cpp b/Marlin/configuration_store.cpp index fe815af2cb..201c03558f 100644 --- a/Marlin/configuration_store.cpp +++ b/Marlin/configuration_store.cpp @@ -342,7 +342,7 @@ void MarlinSettings::postprocess() { #if ENABLED(MESH_BED_LEVELING) // Compile time test that sizeof(mbl.z_values) is as expected static_assert( - sizeof(mbl.z_values) == (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y) * sizeof(mbl.z_values[0][0]), + 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); @@ -386,7 +386,7 @@ void MarlinSettings::postprocess() { #if ENABLED(AUTO_BED_LEVELING_BILINEAR) // Compile time test that sizeof(z_values) is as expected static_assert( - sizeof(z_values) == (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y) * sizeof(z_values[0][0]), + sizeof(z_values) == GRID_MAX_POINTS * sizeof(z_values[0][0]), "Bilinear Z array is the wrong size." ); const uint8_t grid_max_x = GRID_MAX_POINTS_X, grid_max_y = GRID_MAX_POINTS_Y; diff --git a/Marlin/planner.cpp b/Marlin/planner.cpp index 8c641fc269..21a98a304f 100644 --- a/Marlin/planner.cpp +++ b/Marlin/planner.cpp @@ -534,12 +534,12 @@ void Planner::check_axes_activity() { */ void Planner::apply_leveling(float &lx, float &ly, float &lz) { - #if ENABLED(AUTO_BED_LEVELING_UBL) && ENABLED(UBL_DELTA) // probably should also be enabled for UBL without UBL_DELTA + #if ENABLED(AUTO_BED_LEVELING_UBL) && UBL_DELTA // probably should also be enabled for UBL without UBL_DELTA if (!ubl.state.active) return; #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT) // if z_fade_height enabled (nonzero) and raw_z above it, no leveling required if ((planner.z_fade_height) && (planner.z_fade_height <= RAW_Z_POSITION(lz))) return; - lz += ubl.state.z_offset + ( ubl.get_z_correction(lx,ly) * ubl.fade_scaling_factor_for_z(lz)); + lz += ubl.state.z_offset + ubl.get_z_correction(lx,ly) * ubl.fade_scaling_factor_for_z(lz); #else // no fade lz += ubl.state.z_offset + ubl.get_z_correction(lx,ly); #endif // FADE @@ -598,13 +598,13 @@ void Planner::check_axes_activity() { void Planner::unapply_leveling(float logical[XYZ]) { - #if ENABLED(AUTO_BED_LEVELING_UBL) && ENABLED(UBL_DELTA) + #if ENABLED(AUTO_BED_LEVELING_UBL) && UBL_DELTA - if ( ubl.state.active ) { + if (ubl.state.active) { - float z_leveled = RAW_Z_POSITION(logical[Z_AXIS]); - float z_ublmesh = ubl.get_z_correction(logical[X_AXIS],logical[Y_AXIS]); - float z_unlevel = z_leveled - ubl.state.z_offset - z_ublmesh; + const float z_leveled = RAW_Z_POSITION(logical[Z_AXIS]), + z_ublmesh = ubl.get_z_correction(logical[X_AXIS], logical[Y_AXIS]); + float z_unlevel = z_leveled - ubl.state.z_offset - z_ublmesh; #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT) @@ -616,9 +616,9 @@ void Planner::check_axes_activity() { // so U(1-M/H)==L-O-M // so U==(L-O-M)/(1-M/H) for U