From e2443997666f6ce86693bec0329be0974ed9a5f1 Mon Sep 17 00:00:00 2001 From: Scott Lahteine Date: Mon, 20 Mar 2017 01:42:41 -0500 Subject: [PATCH] Additional cleanup of UBL code --- Marlin/Conditionals_post.h | 2 +- Marlin/Configuration.h | 80 +- Marlin/G26_Mesh_Validation_Tool.cpp | 330 ++--- Marlin/Marlin_main.cpp | 58 +- Marlin/SanityCheck.h | 60 +- Marlin/UBL.h | 68 +- Marlin/UBL_Bed_Leveling.cpp | 123 +- Marlin/UBL_G29.cpp | 1158 ++++++++--------- Marlin/UBL_line_to_destination.cpp | 581 ++++----- Marlin/cardreader.cpp | 2 +- Marlin/configuration_store.cpp | 48 +- .../Cartesio/Configuration.h | 79 +- .../Felix/Configuration.h | 79 +- .../Felix/DUAL/Configuration.h | 79 +- .../Hephestos/Configuration.h | 79 +- .../Hephestos_2/Configuration.h | 79 +- .../K8200/Configuration.h | 79 +- .../K8400/Configuration.h | 79 +- .../K8400/Dual-head/Configuration.h | 79 +- .../RepRapWorld/Megatronics/Configuration.h | 79 +- .../RigidBot/Configuration.h | 79 +- .../SCARA/Configuration.h | 79 +- .../TAZ4/Configuration.h | 79 +- .../WITBOX/Configuration.h | 79 +- .../adafruit/ST7565/Configuration.h | 79 +- .../delta/flsun_kossel_mini/Configuration.h | 79 +- .../delta/generic/Configuration.h | 79 +- .../delta/kossel_mini/Configuration.h | 79 +- .../delta/kossel_pro/Configuration.h | 79 +- .../delta/kossel_xl/Configuration.h | 79 +- .../makibox/Configuration.h | 79 +- .../tvrrug/Round2/Configuration.h | 79 +- Marlin/servo.cpp | 4 +- Marlin/ultralcd.cpp | 91 +- Marlin/ultralcd.h | 7 + 35 files changed, 2201 insertions(+), 2070 deletions(-) diff --git a/Marlin/Conditionals_post.h b/Marlin/Conditionals_post.h index 6594840808..83f8059ea2 100644 --- a/Marlin/Conditionals_post.h +++ b/Marlin/Conditionals_post.h @@ -669,7 +669,7 @@ #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 PLANNER_LEVELING (HAS_ABL || ENABLED(MESH_BED_LEVELING)) + #define PLANNER_LEVELING ((HAS_ABL && DISABLED(AUTO_BED_LEVELING_UBL)) || ENABLED(MESH_BED_LEVELING)) #define HAS_PROBING_PROCEDURE (HAS_ABL || ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST)) #if HAS_PROBING_PROCEDURE diff --git a/Marlin/Configuration.h b/Marlin/Configuration.h index 465b8df8fe..96b1ededc2 100644 --- a/Marlin/Configuration.h +++ b/Marlin/Configuration.h @@ -747,42 +747,48 @@ // @section bedlevel /** - * Select one form of Auto Bed Leveling below. + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. * - * If you're also using the Probe for Z Homing, it's - * highly recommended to enable Z_SAFE_HOMING also! + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! * - * - 3POINT + * - AUTO_BED_LEVELING_3POINT * Probe 3 arbitrary points on the bed (that aren't collinear) * You specify the XY coordinates of all 3 points. * The result is a single tilted plane. Best for a flat bed. * - * - LINEAR + * - AUTO_BED_LEVELING_LINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a single tilted plane. Best for a flat bed. * - * - BILINEAR + * - AUTO_BED_LEVELING_BILINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. * - * - UBL Unified Bed Leveling - * A comprehensive bed leveling system that combines features and benefits from previous - * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use - * Mesh Generation, Mesh Validation and Mesh Editing system. - * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with - * that said, it was primarily designed to handle poor quality Delta Printers. If you feel - * adventurous and have a Delta, please post an issue if something doesn't work correctly. - * Initially, you will need to reduce your declared bed size so you have a rectangular area to - * test on. + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. Currently, UBL is only checked out + * for Cartesian Printers. That said, it was primarily designed to correct + * poor quality Delta Printers. If you feel adventurous and have a Delta, + * please post an issue if something doesn't work correctly. Initially, + * you will need to set a reduced bed size so you have a rectangular area + * to test on. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR -//#define MESH_BED_LEVELING //#define AUTO_BED_LEVELING_UBL - +//#define MESH_BED_LEVELING /** * Enable detailed logging of G28, G29, M48, etc. @@ -841,25 +847,6 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#elif ENABLED(MESH_BED_LEVELING) - - //=========================================================================== - //=================================== Mesh ================================== - //=========================================================================== - - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif - #elif ENABLED(AUTO_BED_LEVELING_UBL) //=========================================================================== @@ -876,7 +863,26 @@ #define UBL_PROBE_PT_3_X 180 #define UBL_PROBE_PT_3_Y 20 -#endif // BED_LEVELING +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/G26_Mesh_Validation_Tool.cpp b/Marlin/G26_Mesh_Validation_Tool.cpp index fe92a74c79..d7dd605820 100644 --- a/Marlin/G26_Mesh_Validation_Tool.cpp +++ b/Marlin/G26_Mesh_Validation_Tool.cpp @@ -32,7 +32,7 @@ #define PRIME_LENGTH 10.0 // So, we put these number in an easy to find and change place. #define BED_TEMP 60.0 #define HOTEND_TEMP 205.0 -#define OOOOZE_AMOUNT 0.3 +#define OOZE_AMOUNT 0.3 #include "Marlin.h" #include "Configuration.h" @@ -111,7 +111,7 @@ * Y # Y coordinate Specify the starting location of the drawing activity. */ - extern int UBL_has_control_of_LCD_Panel; + extern bool ubl_has_control_of_lcd_panel; extern float feedrate; //extern bool relative_mode; extern Planner planner; @@ -141,12 +141,12 @@ bool prime_nozzle(); void chirp_at_user(); - static uint16_t circle_flags[16], horizontal_mesh_line_flags[16], vertical_mesh_line_flags[16], Continue_with_closest = 0; - float G26_E_AXIS_feedrate = 0.020, - Random_Deviation = 0.0, - Layer_Height = LAYER_HEIGHT; + static uint16_t circle_flags[16], horizontal_mesh_line_flags[16], vertical_mesh_line_flags[16], continue_with_closest = 0; + float g26_e_axis_feedrate = 0.020, + random_deviation = 0.0, + layer_height = LAYER_HEIGHT; - bool G26_retracted = false; // We keep track of the state of the nozzle to know if it + bool g26_retracted = false; // We keep track of the state of the nozzle to know if it // is currently retracted or not. This allows us to be // less careful because mis-matched retractions and un-retractions // won't leave us in a bad state. @@ -157,24 +157,24 @@ float valid_trig_angle(float); mesh_index_pair find_closest_circle_to_print(float, float); void debug_current_and_destination(char *title); - void UBL_line_to_destination(const float&, const float&, const float&, const float&, const float&, uint8_t); + void ubl_line_to_destination(const float&, const float&, const float&, const float&, const float&, uint8_t); //uint16_t x_splits = 0xFFFF, uint16_t y_splits = 0xFFFF); /* needed for the old mesh_buffer_line() routine */ - static float E_Pos_Delta, - Extrusion_Multiplier = EXTRUSION_MULTIPLIER, - Retraction_Multiplier = RETRACTION_MULTIPLIER, - Nozzle = NOZZLE, - Filament = FILAMENT, - Prime_Length = PRIME_LENGTH, - X_Pos, Y_Pos, + static float extrusion_multiplier = EXTRUSION_MULTIPLIER, + retraction_multiplier = RETRACTION_MULTIPLIER, + nozzle = NOZZLE, + filament_diameter = FILAMENT, + prime_length = PRIME_LENGTH, + x_pos, y_pos, bed_temp = BED_TEMP, hotend_temp = HOTEND_TEMP, - Ooooze_Amount = OOOOZE_AMOUNT; + ooze_amount = OOZE_AMOUNT; - int8_t Prime_Flag = 0; + int8_t prime_flag = 0; - bool Keep_Heaters_On = false, - G26_Debug_flag = false; + bool keep_heaters_on = false; + + bool g26_debug_flag = false; /** * These support functions allow the use of large bit arrays of flags that take very @@ -217,17 +217,17 @@ current_position[E_AXIS] = 0.0; sync_plan_position_e(); - if (Prime_Flag && prime_nozzle()) // if prime_nozzle() returns an error, we just bail out. + if (prime_flag && prime_nozzle()) // if prime_nozzle() returns an error, we just bail out. goto LEAVE; /** - * Bed is preheated + * Bed is preheated * - * Nozzle is at temperature + * Nozzle is at temperature * - * Filament is primed! + * Filament is primed! * - * It's "Show Time" !!! + * It's "Show Time" !!! */ // Clear all of the flags we need @@ -239,17 +239,19 @@ // Move nozzle to the specified height for the first layer // set_destination_to_current(); - destination[Z_AXIS] = Layer_Height; + destination[Z_AXIS] = layer_height; move_to(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], 0.0); - move_to(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], Ooooze_Amount); + move_to(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], ooze_amount); - UBL_has_control_of_LCD_Panel = 1; // Take control of the LCD Panel! - debug_current_and_destination((char *)"Starting G26 Mesh Validation Pattern."); + ubl_has_control_of_lcd_panel++; // Take control of the LCD Panel! + debug_current_and_destination((char*)"Starting G26 Mesh Validation Pattern."); + + wait_for_user = true; do { - if (G29_lcd_clicked()) { // Check if the user wants to stop the Mesh Validation + + if (!wait_for_user) { // Check if the user wants to stop the Mesh Validation strcpy(lcd_status_message, "Mesh Validation Stopped."); // We can't do lcd_setstatus() without having it continue; - while (G29_lcd_clicked()) idle(); // Debounce the switch click #if ENABLED(ULTRA_LCD) lcd_setstatus("Mesh Validation Stopped.", true); lcd_quick_feedback(); @@ -257,14 +259,14 @@ goto LEAVE; } - if (Continue_with_closest) + if (continue_with_closest) location = find_closest_circle_to_print(current_position[X_AXIS], current_position[Y_AXIS]); else - location = find_closest_circle_to_print(X_Pos, Y_Pos); // Find the closest Mesh Intersection to where we are now. + location = find_closest_circle_to_print(x_pos, y_pos); // Find the closest Mesh Intersection to where we are now. if (location.x_index >= 0 && location.y_index >= 0) { - circle_x = blm.map_x_index_to_bed_location(location.x_index); - circle_y = blm.map_y_index_to_bed_location(location.y_index); + circle_x = ubl.map_x_index_to_bed_location(location.x_index); + circle_y = ubl.map_y_index_to_bed_location(location.y_index); // Let's do a couple of quick sanity checks. We can pull this code out later if we never see it catch a problem #ifdef DELTA @@ -282,7 +284,7 @@ xi = location.x_index; // Just to shrink the next few lines and make them easier to understand yi = location.y_index; - if (G26_Debug_flag) { + if (g26_debug_flag) { SERIAL_ECHOPGM(" Doing circle at: (xi="); SERIAL_ECHO(xi); SERIAL_ECHOPGM(", yi="); @@ -322,14 +324,13 @@ * the CPU load and make the arc drawing faster and more smooth */ float sin_table[360 / 30 + 1], cos_table[360 / 30 + 1]; - int tmp_div_30; for (i = 0; i <= 360 / 30; i++) { cos_table[i] = SIZE_OF_INTERSECTION_CIRCLES * cos(RADIANS(valid_trig_angle(i * 30.0))); sin_table[i] = SIZE_OF_INTERSECTION_CIRCLES * sin(RADIANS(valid_trig_angle(i * 30.0))); } for (tmp = start_angle; tmp < end_angle - 0.1; tmp += 30.0) { - tmp_div_30 = tmp / 30.0; + int tmp_div_30 = tmp / 30.0; if (tmp_div_30 < 0) tmp_div_30 += 360 / 30; x = circle_x + cos_table[tmp_div_30]; // for speed, these are now a lookup table entry @@ -348,18 +349,18 @@ ye = constrain(ye, Y_MIN_POS + 1, Y_MAX_POS - 1); #endif - if (G26_Debug_flag) { + if (g26_debug_flag) { char ccc, *cptr, seg_msg[50], seg_num[10]; strcpy(seg_msg, " segment: "); strcpy(seg_num, " \n"); - cptr = (char *) "01234567890ABCDEF????????"; + cptr = (char*) "01234567890ABCDEF????????"; ccc = cptr[tmp_div_30]; seg_num[1] = ccc; strcat(seg_msg, seg_num); debug_current_and_destination(seg_msg); } - print_line_from_here_to_there(x, y, Layer_Height, xe, ye, Layer_Height); + print_line_from_here_to_there(x, y, layer_height, xe, ye, layer_height); } lcd_init_counter++; if (lcd_init_counter > 10) { @@ -367,35 +368,37 @@ lcd_init(); // Some people's LCD Displays are locking up. This might help them } - debug_current_and_destination((char *)"Looking for lines to connect."); + debug_current_and_destination((char*)"Looking for lines to connect."); look_for_lines_to_connect(); - debug_current_and_destination((char *)"Done with line connect."); + debug_current_and_destination((char*)"Done with line connect."); } - debug_current_and_destination((char *)"Done with current circle."); + debug_current_and_destination((char*)"Done with current circle."); } - while (location.x_index >= 0 && location.y_index >= 0) ; + while (location.x_index >= 0 && location.y_index >= 0); LEAVE: + wait_for_user = false; + retract_filament(); destination[Z_AXIS] = Z_CLEARANCE_BETWEEN_PROBES; // Raise the nozzle - debug_current_and_destination((char *)"ready to do Z-Raise."); + debug_current_and_destination((char*)"ready to do Z-Raise."); move_to( destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], 0); // Raise the nozzle - debug_current_and_destination((char *)"done doing Z-Raise."); + debug_current_and_destination((char*)"done doing Z-Raise."); - destination[X_AXIS] = X_Pos; // Move back to the starting position - destination[Y_AXIS] = Y_Pos; + destination[X_AXIS] = x_pos; // Move back to the starting position + destination[Y_AXIS] = y_pos; destination[Z_AXIS] = Z_CLEARANCE_BETWEEN_PROBES; // Keep the nozzle where it is move_to(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], 0); // Move back to the starting position - debug_current_and_destination((char *)"done doing X/Y move."); + debug_current_and_destination((char*)"done doing X/Y move."); - UBL_has_control_of_LCD_Panel = 0; // Give back control of the LCD Panel! + ubl_has_control_of_lcd_panel = false; // Give back control of the LCD Panel! - if (!Keep_Heaters_On) { + if (!keep_heaters_on) { #if HAS_TEMP_BED thermalManager.setTargetBed(0.0); #endif @@ -419,23 +422,23 @@ for (uint8_t i = 0; i < UBL_MESH_NUM_X_POINTS; i++) { for (uint8_t j = 0; j < UBL_MESH_NUM_Y_POINTS; j++) { - if (!is_bit_set(circle_flags, i, j)) { - mx = blm.map_x_index_to_bed_location(i); // We found a circle that needs to be printed - my = blm.map_y_index_to_bed_location(j); + if (!is_bit_set(circle_flags, i, j)) { + mx = ubl.map_x_index_to_bed_location(i); // We found a circle that needs to be printed + my = ubl.map_y_index_to_bed_location(j); dx = X - mx; // Get the distance to this intersection dy = Y - my; f = HYPOT(dx, dy); - dx = X_Pos - mx; // It is possible that we are being called with the values - dy = Y_Pos - my; // to let us find the closest circle to the start position. + dx = x_pos - mx; // It is possible that we are being called with the values + dy = y_pos - my; // to let us find the closest circle to the start position. f += HYPOT(dx, dy) / 15.0; // But if this is not the case, // we are going to add in a small // weighting to the distance calculation to help it choose // a better place to continue. - if (Random_Deviation > 1.0) - f += random(0.0, Random_Deviation); // Add in the specified amount of Random Noise to our search + if (random_deviation > 1.0) + f += random(0.0, random_deviation); // Add in the specified amount of Random Noise to our search if (f < closest) { closest = f; // We found a closer location that is still @@ -457,7 +460,7 @@ for (uint8_t j = 0; j < UBL_MESH_NUM_Y_POINTS; j++) { if (i < UBL_MESH_NUM_X_POINTS) { // We can't connect to anything to the right than UBL_MESH_NUM_X_POINTS. - // This is already a half circle because we are at the edge of the bed. + // This is already a half circle because we are at the edge of the bed. if (is_bit_set(circle_flags, i, j) && is_bit_set(circle_flags, i + 1, j)) { // check if we can do a line to the left if (!is_bit_set(horizontal_mesh_line_flags, i, j)) { @@ -466,11 +469,11 @@ // We found two circles that need a horizontal line to connect them // Print it! // - sx = blm.map_x_index_to_bed_location(i); + sx = ubl.map_x_index_to_bed_location(i); sx = sx + SIZE_OF_INTERSECTION_CIRCLES - SIZE_OF_CROSS_HAIRS; // get the right edge of the circle - sy = blm.map_y_index_to_bed_location(j); + sy = ubl.map_y_index_to_bed_location(j); - ex = blm.map_x_index_to_bed_location(i + 1); + ex = ubl.map_x_index_to_bed_location(i + 1); ex = ex - SIZE_OF_INTERSECTION_CIRCLES + SIZE_OF_CROSS_HAIRS; // get the left edge of the circle ey = sy; @@ -479,7 +482,7 @@ ex = constrain(ex, X_MIN_POS + 1, X_MAX_POS - 1); ey = constrain(ey, Y_MIN_POS + 1, Y_MAX_POS - 1); - if (G26_Debug_flag) { + if (g26_debug_flag) { SERIAL_ECHOPGM(" Connecting with horizontal line (sx="); SERIAL_ECHO(sx); SERIAL_ECHOPGM(", sy="); @@ -489,16 +492,16 @@ SERIAL_ECHOPGM(", ey="); SERIAL_ECHO(ey); SERIAL_ECHOLNPGM(")"); - debug_current_and_destination((char *)"Connecting horizontal line."); + debug_current_and_destination((char*)"Connecting horizontal line."); } - print_line_from_here_to_there(sx, sy, Layer_Height, ex, ey, Layer_Height); + print_line_from_here_to_there(sx, sy, layer_height, ex, ey, layer_height); bit_set(horizontal_mesh_line_flags, i, j); // Mark it as done so we don't do it again } } if (j < UBL_MESH_NUM_Y_POINTS) { // We can't connect to anything further back than UBL_MESH_NUM_Y_POINTS. - // This is already a half circle because we are at the edge of the bed. + // This is already a half circle because we are at the edge of the bed. if (is_bit_set(circle_flags, i, j) && is_bit_set(circle_flags, i, j + 1)) { // check if we can do a line straight down if (!is_bit_set( vertical_mesh_line_flags, i, j)) { @@ -506,12 +509,12 @@ // We found two circles that need a vertical line to connect them // Print it! // - sx = blm.map_x_index_to_bed_location(i); - sy = blm.map_y_index_to_bed_location(j); + sx = ubl.map_x_index_to_bed_location(i); + sy = ubl.map_y_index_to_bed_location(j); sy = sy + SIZE_OF_INTERSECTION_CIRCLES - SIZE_OF_CROSS_HAIRS; // get the top edge of the circle ex = sx; - ey = blm.map_y_index_to_bed_location(j + 1); + ey = ubl.map_y_index_to_bed_location(j + 1); ey = ey - SIZE_OF_INTERSECTION_CIRCLES + SIZE_OF_CROSS_HAIRS; // get the bottom edge of the circle sx = constrain(sx, X_MIN_POS + 1, X_MAX_POS - 1); // This keeps us from bumping the endstops @@ -519,7 +522,7 @@ ex = constrain(ex, X_MIN_POS + 1, X_MAX_POS - 1); ey = constrain(ey, Y_MIN_POS + 1, Y_MAX_POS - 1); - if (G26_Debug_flag) { + if (g26_debug_flag) { SERIAL_ECHOPGM(" Connecting with vertical line (sx="); SERIAL_ECHO(sx); SERIAL_ECHOPGM(", sy="); @@ -529,9 +532,9 @@ SERIAL_ECHOPGM(", ey="); SERIAL_ECHO(ey); SERIAL_ECHOLNPGM(")"); - debug_current_and_destination((char *)"Connecting vertical line."); + debug_current_and_destination((char*)"Connecting vertical line."); } - print_line_from_here_to_there(sx, sy, Layer_Height, ex, ey, Layer_Height); + print_line_from_here_to_there(sx, sy, layer_height, ex, ey, layer_height); bit_set( vertical_mesh_line_flags, i, j); // Mark it as done so we don't do it again } } @@ -545,8 +548,8 @@ float dx, dy, de, xy_dist, fpmm; // if the title message starts with a '!' it is so important, we are going to - // ignore the status of the G26_Debug_Flag - if (*title != '!' && !G26_Debug_flag) return; + // ignore the status of the g26_debug_flag + if (*title != '!' && !g26_debug_flag) return; dx = current_position[X_AXIS] - destination[X_AXIS]; dy = current_position[Y_AXIS] - destination[Y_AXIS]; @@ -563,43 +566,43 @@ else { SERIAL_ECHOPGM(" fpmm="); fpmm = de / xy_dist; - SERIAL_PROTOCOL_F(fpmm, 6); + SERIAL_ECHO_F(fpmm, 6); } SERIAL_ECHOPGM(" current=( "); - SERIAL_PROTOCOL_F(current_position[X_AXIS], 6); + SERIAL_ECHO_F(current_position[X_AXIS], 6); SERIAL_ECHOPGM(", "); - SERIAL_PROTOCOL_F(current_position[Y_AXIS], 6); + SERIAL_ECHO_F(current_position[Y_AXIS], 6); SERIAL_ECHOPGM(", "); - SERIAL_PROTOCOL_F(current_position[Z_AXIS], 6); + SERIAL_ECHO_F(current_position[Z_AXIS], 6); SERIAL_ECHOPGM(", "); - SERIAL_PROTOCOL_F(current_position[E_AXIS], 6); + SERIAL_ECHO_F(current_position[E_AXIS], 6); SERIAL_ECHOPGM(" ) destination=( "); if (current_position[X_AXIS] == destination[X_AXIS]) SERIAL_ECHOPGM("-------------"); else - SERIAL_PROTOCOL_F(destination[X_AXIS], 6); + SERIAL_ECHO_F(destination[X_AXIS], 6); SERIAL_ECHOPGM(", "); if (current_position[Y_AXIS] == destination[Y_AXIS]) SERIAL_ECHOPGM("-------------"); else - SERIAL_PROTOCOL_F(destination[Y_AXIS], 6); + SERIAL_ECHO_F(destination[Y_AXIS], 6); SERIAL_ECHOPGM(", "); if (current_position[Z_AXIS] == destination[Z_AXIS]) SERIAL_ECHOPGM("-------------"); else - SERIAL_PROTOCOL_F(destination[Z_AXIS], 6); + SERIAL_ECHO_F(destination[Z_AXIS], 6); SERIAL_ECHOPGM(", "); if (current_position[E_AXIS] == destination[E_AXIS]) SERIAL_ECHOPGM("-------------"); else - SERIAL_PROTOCOL_F(destination[E_AXIS], 6); + SERIAL_ECHO_F(destination[E_AXIS], 6); SERIAL_ECHOPGM(" ) "); SERIAL_ECHO(title); @@ -617,16 +620,16 @@ float feed_value; static float last_z = -999.99; - bool has_XY_component = (x != current_position[X_AXIS] || y != current_position[Y_AXIS]); // Check if X or Y is involved in the movement. + bool has_xy_component = (x != current_position[X_AXIS] || y != current_position[Y_AXIS]); // Check if X or Y is involved in the movement. - if (G26_Debug_flag) { - SERIAL_ECHOPAIR("in move_to() has_XY_component:", (int)has_XY_component); + if (g26_debug_flag) { + SERIAL_ECHOPAIR("in move_to() has_xy_component:", (int)has_xy_component); SERIAL_EOL; } if (z != last_z) { - if (G26_Debug_flag) { + if (g26_debug_flag) { SERIAL_ECHOPAIR("in move_to() changing Z to ", (int)z); SERIAL_EOL; } @@ -638,20 +641,20 @@ destination[Z_AXIS] = z; // We know the last_z==z or we wouldn't be in this block of code. destination[E_AXIS] = current_position[E_AXIS]; - UBL_line_to_destination(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feed_value, 0); + ubl_line_to_destination(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feed_value, 0); stepper.synchronize(); set_destination_to_current(); - if (G26_Debug_flag) - debug_current_and_destination((char *)" in move_to() done with Z move"); + if (g26_debug_flag) + debug_current_and_destination((char*)" in move_to() done with Z move"); } // Check if X or Y is involved in the movement. // Yes: a 'normal' movement. No: a retract() or un_retract() - feed_value = has_XY_component ? PLANNER_XY_FEEDRATE() / 10.0 : planner.max_feedrate_mm_s[E_AXIS] / 1.5; + feed_value = has_xy_component ? PLANNER_XY_FEEDRATE() / 10.0 : planner.max_feedrate_mm_s[E_AXIS] / 1.5; - if (G26_Debug_flag) { + if (g26_debug_flag) { SERIAL_ECHOPAIR("in move_to() feed_value for XY:", feed_value); SERIAL_EOL; } @@ -660,32 +663,32 @@ destination[Y_AXIS] = y; destination[E_AXIS] += e_delta; - if (G26_Debug_flag) - debug_current_and_destination((char *)" in move_to() doing last move"); + if (g26_debug_flag) + debug_current_and_destination((char*)" in move_to() doing last move"); - UBL_line_to_destination(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feed_value, 0); + ubl_line_to_destination(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feed_value, 0); - if (G26_Debug_flag) - debug_current_and_destination((char *)" in move_to() after last move"); + if (g26_debug_flag) + debug_current_and_destination((char*)" in move_to() after last move"); stepper.synchronize(); set_destination_to_current(); } void retract_filament() { - if (!G26_retracted) { // Only retract if we are not already retracted! - G26_retracted = true; - if (G26_Debug_flag) SERIAL_ECHOLNPGM(" Decided to do retract."); - move_to(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], -1.0 * Retraction_Multiplier); - if (G26_Debug_flag) SERIAL_ECHOLNPGM(" Retraction done."); + if (!g26_retracted) { // Only retract if we are not already retracted! + g26_retracted = true; + if (g26_debug_flag) SERIAL_ECHOLNPGM(" Decided to do retract."); + move_to(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], -1.0 * retraction_multiplier); + if (g26_debug_flag) SERIAL_ECHOLNPGM(" Retraction done."); } } void un_retract_filament() { - if (G26_retracted) { // Only un-retract if we are retracted. - move_to(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], 1.2 * Retraction_Multiplier); - G26_retracted = false; - if (G26_Debug_flag) SERIAL_ECHOLNPGM(" unretract done."); + if (g26_retracted) { // Only un-retract if we are retracted. + move_to(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], 1.2 * retraction_multiplier); + g26_retracted = false; + if (g26_debug_flag) SERIAL_ECHOLNPGM(" unretract done."); } } @@ -724,7 +727,7 @@ // On very small lines we don't do the optimization because it just isn't worth it. // if (dist_end < dist_start && (SIZE_OF_INTERSECTION_CIRCLES) < abs(Line_Length)) { - if (G26_Debug_flag) + if (g26_debug_flag) SERIAL_ECHOLNPGM(" Reversing start and end of print_line_from_here_to_there()"); print_line_from_here_to_there(ex, ey, ez, sx, sy, sz); return; @@ -734,19 +737,19 @@ if (dist_start > 2.0) { retract_filament(); - if (G26_Debug_flag) + if (g26_debug_flag) SERIAL_ECHOLNPGM(" filament retracted."); } move_to(sx, sy, sz, 0.0); // Get to the starting point with no extrusion - E_Pos_Delta = Line_Length * G26_E_AXIS_feedrate * Extrusion_Multiplier; + float e_pos_delta = Line_Length * g26_e_axis_feedrate * extrusion_multiplier; un_retract_filament(); - if (G26_Debug_flag) { + if (g26_debug_flag) { SERIAL_ECHOLNPGM(" doing printing move."); - debug_current_and_destination((char *)"doing final move_to() inside print_line_from_here_to_there()"); + debug_current_and_destination((char*)"doing final move_to() inside print_line_from_here_to_there()"); } - move_to(ex, ey, ez, E_Pos_Delta); // Get to the ending point with an appropriate amount of extrusion + move_to(ex, ey, ez, e_pos_delta); // Get to the ending point with an appropriate amount of extrusion } /** @@ -756,17 +759,17 @@ */ bool parse_G26_parameters() { - Extrusion_Multiplier = EXTRUSION_MULTIPLIER; - Retraction_Multiplier = RETRACTION_MULTIPLIER; - Nozzle = NOZZLE; - Filament = FILAMENT; - Layer_Height = LAYER_HEIGHT; - Prime_Length = PRIME_LENGTH; + extrusion_multiplier = EXTRUSION_MULTIPLIER; + retraction_multiplier = RETRACTION_MULTIPLIER; + nozzle = NOZZLE; + filament_diameter = FILAMENT; + layer_height = LAYER_HEIGHT; + prime_length = PRIME_LENGTH; bed_temp = BED_TEMP; hotend_temp = HOTEND_TEMP; - Ooooze_Amount = OOOOZE_AMOUNT; - Prime_Flag = 0; - Keep_Heaters_On = false; + ooze_amount = OOZE_AMOUNT; + prime_flag = 0; + keep_heaters_on = false; if (code_seen('B')) { bed_temp = code_value_float(); @@ -776,11 +779,11 @@ } } - if (code_seen('C')) Continue_with_closest++; + if (code_seen('C')) continue_with_closest++; if (code_seen('L')) { - Layer_Height = code_value_float(); - if (Layer_Height<0.0 || Layer_Height>2.0) { + layer_height = code_value_float(); + if (layer_height < 0.0 || layer_height > 2.0) { SERIAL_PROTOCOLLNPGM("?Specified layer height not plausible."); return UBL_ERR; } @@ -788,8 +791,8 @@ if (code_seen('Q')) { if (code_has_value()) { - Retraction_Multiplier = code_value_float(); - if (Retraction_Multiplier<.05 || Retraction_Multiplier>15.0) { + retraction_multiplier = code_value_float(); + if (retraction_multiplier < 0.05 || retraction_multiplier > 15.0) { SERIAL_PROTOCOLLNPGM("?Specified Retraction Multiplier not plausible."); return UBL_ERR; } @@ -801,25 +804,25 @@ } if (code_seen('N')) { - Nozzle = code_value_float(); - if (Nozzle < 0.1 || Nozzle > 1.0) { + nozzle = code_value_float(); + if (nozzle < 0.1 || nozzle > 1.0) { SERIAL_PROTOCOLLNPGM("?Specified nozzle size not plausible."); return UBL_ERR; } } - if (code_seen('K')) Keep_Heaters_On++; + if (code_seen('K')) keep_heaters_on++; if (code_seen('O') && code_has_value()) - Ooooze_Amount = code_value_float(); + ooze_amount = code_value_float(); if (code_seen('P')) { if (!code_has_value()) - Prime_Flag = -1; + prime_flag = -1; else { - Prime_Flag++; - Prime_Length = code_value_float(); - if (Prime_Length < 0.0 || Prime_Length > 25.0) { + prime_flag++; + prime_length = code_value_float(); + if (prime_length < 0.0 || prime_length > 25.0) { SERIAL_PROTOCOLLNPGM("?Specified prime length not plausible."); return UBL_ERR; } @@ -827,16 +830,17 @@ } if (code_seen('F')) { - Filament = code_value_float(); - if (Filament < 1.0 || Filament > 4.0) { + filament_diameter = code_value_float(); + if (filament_diameter < 1.0 || filament_diameter > 4.0) { SERIAL_PROTOCOLLNPGM("?Specified filament size not plausible."); return UBL_ERR; } } - Extrusion_Multiplier *= sq(1.75) / sq(Filament); // If we aren't using 1.75mm filament, we need to - // scale up or down the length needed to get the - // same volume of filament - Extrusion_Multiplier *= Filament * sq(Nozzle) / sq(0.3); // Scale up by nozzle size + extrusion_multiplier *= sq(1.75) / sq(filament_diameter); // If we aren't using 1.75mm filament, we need to + // scale up or down the length needed to get the + // same volume of filament + + extrusion_multiplier *= filament_diameter * sq(nozzle) / sq(0.3); // Scale up by nozzle size if (code_seen('H')) { hotend_temp = code_value_float(); @@ -848,15 +852,15 @@ if (code_seen('R')) { randomSeed(millis()); - Random_Deviation = code_has_value() ? code_value_float() : 50.0; + random_deviation = code_has_value() ? code_value_float() : 50.0; } - X_Pos = current_position[X_AXIS]; - Y_Pos = current_position[Y_AXIS]; + x_pos = current_position[X_AXIS]; + y_pos = current_position[Y_AXIS]; if (code_seen('X')) { - X_Pos = code_value_float(); - if (X_Pos < X_MIN_POS || X_Pos > X_MAX_POS) { + x_pos = code_value_float(); + if (x_pos < X_MIN_POS || x_pos > X_MAX_POS) { SERIAL_PROTOCOLLNPGM("?Specified X coordinate not plausible."); return UBL_ERR; } @@ -864,8 +868,8 @@ else if (code_seen('Y')) { - Y_Pos = code_value_float(); - if (Y_Pos < Y_MIN_POS || Y_Pos > Y_MAX_POS) { + y_pos = code_value_float(); + if (y_pos < Y_MIN_POS || y_pos > Y_MAX_POS) { SERIAL_PROTOCOLLNPGM("?Specified Y coordinate not plausible."); return UBL_ERR; } @@ -877,7 +881,7 @@ * alter the system's status. We wait until we know everything is correct before altering the state * of the system. */ - blm.state.active = !code_seen('D'); + ubl.state.active = !code_seen('D'); return UBL_OK; } @@ -893,17 +897,18 @@ lcd_setstatus("G26 Heating Bed.", true); lcd_quick_feedback(); #endif - UBL_has_control_of_LCD_Panel++; + ubl_has_control_of_lcd_panel++; thermalManager.setTargetBed(bed_temp); + wait_for_user = true; while (abs(thermalManager.degBed() - bed_temp) > 3) { - if (G29_lcd_clicked()) { + if (!wait_for_user) { strcpy(lcd_status_message, "Leaving G26"); // We can't do lcd_setstatus() without having it continue; - while (G29_lcd_clicked()) idle(); // Debounce the switch lcd_setstatus("Leaving G26", true); // Now we do it right. return UBL_ERR; } idle(); } + wait_for_user = false; #if ENABLED(ULTRA_LCD) } lcd_setstatus("G26 Heating Nozzle.", true); @@ -913,15 +918,16 @@ // Start heating the nozzle and wait for it to reach temperature. thermalManager.setTargetHotend(hotend_temp, 0); + wait_for_user = true; while (abs(thermalManager.degHotend(0) - hotend_temp) > 3) { - if (G29_lcd_clicked()) { + if (!wait_for_user) { strcpy(lcd_status_message, "Leaving G26"); // We can't do lcd_setstatus() without having it continue; - while (G29_lcd_clicked()) idle(); // Debounce the switch lcd_setstatus("Leaving G26", true); // Now we do it right. return UBL_ERR; } idle(); } + wait_for_user = false; #if ENABLED(ULTRA_LCD) lcd_setstatus("", true); @@ -936,8 +942,8 @@ bool prime_nozzle() { float Total_Prime = 0.0; - if (Prime_Flag == -1) { // The user wants to control how much filament gets purged - lcd_setstatus("User Controled Prime", true); + if (prime_flag == -1) { // The user wants to control how much filament gets purged + lcd_setstatus("User-Controlled Prime", true); chirp_at_user(); set_destination_to_current(); @@ -946,15 +952,15 @@ // retracted(). We are here because we want to prime the nozzle. // So let's just unretract just to be sure. - UBL_has_control_of_LCD_Panel++; - while (!G29_lcd_clicked()) { + wait_for_user = true; + while (wait_for_user) { chirp_at_user(); destination[E_AXIS] += 0.25; #ifdef PREVENT_LENGTHY_EXTRUDE Total_Prime += 0.25; if (Total_Prime >= EXTRUDE_MAXLENGTH) return UBL_ERR; #endif - UBL_line_to_destination( + ubl_line_to_destination( destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], //planner.max_feedrate_mm_s[E_AXIS] / 15.0, 0, 0xFFFF, 0xFFFF); planner.max_feedrate_mm_s[E_AXIS] / 15.0, 0 @@ -971,10 +977,8 @@ strcpy(lcd_status_message, "Done Priming"); // We can't do lcd_setstatus() without having it continue; // So... We cheat to get a message up. - while (G29_lcd_clicked()) idle(); // Debounce the switch - #if ENABLED(ULTRA_LCD) - UBL_has_control_of_LCD_Panel = 0; + ubl_has_control_of_lcd_panel = false; lcd_setstatus("Done Priming", true); // Now we do it right. lcd_quick_feedback(); #endif @@ -985,8 +989,8 @@ lcd_quick_feedback(); #endif set_destination_to_current(); - destination[E_AXIS] += Prime_Length; - UBL_line_to_destination( + destination[E_AXIS] += prime_length; + ubl_line_to_destination( destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], //planner.max_feedrate_mm_s[E_AXIS] / 15.0, 0, 0xFFFF, 0xFFFF); planner.max_feedrate_mm_s[E_AXIS] / 15.0, 0 diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp index 7537f2033f..dfa1a5dbcc 100755 --- a/Marlin/Marlin_main.cpp +++ b/Marlin/Marlin_main.cpp @@ -301,7 +301,7 @@ #endif #if ENABLED(AUTO_BED_LEVELING_UBL) - bed_leveling blm; + unified_bed_leveling ubl; #endif bool Running = true; @@ -2309,9 +2309,9 @@ static void clean_up_after_endstop_or_probe_move() { planner.unapply_leveling(current_position); } #elif ENABLED(AUTO_BED_LEVELING_UBL) - if (blm.state.EEPROM_storage_slot == 0) { - blm.state.active = enable; - blm.store_state(); + if (ubl.state.eeprom_storage_slot == 0) { + ubl.state.active = enable; + ubl.store_state(); } #endif } @@ -2486,7 +2486,7 @@ static void clean_up_after_endstop_or_probe_move() { SERIAL_PROTOCOLCHAR(' '); float offset = fn(x, y); if (offset != UNPROBED) { - if (offset >= 0) SERIAL_CHAR('+'); + if (offset >= 0) SERIAL_PROTOCOLCHAR('+'); SERIAL_PROTOCOL_F(offset, precision); } else @@ -3258,7 +3258,9 @@ inline void gcode_G4() { #endif SERIAL_ECHOPGM("Probe: "); - #if ENABLED(FIX_MOUNTED_PROBE) + #if ENABLED(PROBE_MANUALLY) + SERIAL_ECHOLNPGM("PROBE_MANUALLY"); + #elif ENABLED(FIX_MOUNTED_PROBE) SERIAL_ECHOLNPGM("FIX_MOUNTED_PROBE"); #elif ENABLED(BLTOUCH) SERIAL_ECHOLNPGM("BLTOUCH"); @@ -3314,7 +3316,7 @@ inline void gcode_G4() { #endif if (planner.abl_enabled) { SERIAL_ECHOLNPGM(" (enabled)"); - #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_3POINT) || ENABLED(AUTO_BED_LEVELING_UBL) + #if ABL_PLANAR float diff[XYZ] = { stepper.get_axis_position_mm(X_AXIS) - current_position[X_AXIS], stepper.get_axis_position_mm(Y_AXIS) - current_position[Y_AXIS], @@ -3329,12 +3331,19 @@ inline void gcode_G4() { SERIAL_ECHOPGM(" Z"); if (diff[Z_AXIS] > 0) SERIAL_CHAR('+'); SERIAL_ECHO(diff[Z_AXIS]); + #elif ENABLED(AUTO_BED_LEVELING_UBL) + SERIAL_ECHOPAIR("UBL Adjustment Z", stepper.get_axis_position_mm(Z_AXIS) - current_position[Z_AXIS]); #elif ENABLED(AUTO_BED_LEVELING_BILINEAR) SERIAL_ECHOPAIR("ABL Adjustment Z", bilinear_z_offset(current_position)); #endif } + else + SERIAL_ECHOLNPGM(" (disabled)"); + SERIAL_EOL; + #elif ENABLED(MESH_BED_LEVELING) + SERIAL_ECHOPGM("Mesh Bed Leveling"); if (mbl.active()) { float lz = current_position[Z_AXIS]; @@ -3342,9 +3351,12 @@ inline void gcode_G4() { SERIAL_ECHOLNPGM(" (enabled)"); SERIAL_ECHOPAIR("MBL Adjustment Z", lz); } - SERIAL_EOL; - #endif + else + SERIAL_ECHOPGM(" (disabled)"); + SERIAL_EOL; + + #endif // MESH_BED_LEVELING } #endif // DEBUG_LEVELING_FEATURE @@ -5354,7 +5366,7 @@ inline void gcode_M104() { SERIAL_PROTOCOL_F(thermalManager.degTargetHotend(target_extruder), 1); #if ENABLED(SHOW_TEMP_ADC_VALUES) SERIAL_PROTOCOLPAIR(" (", thermalManager.current_temperature_raw[target_extruder] / OVERSAMPLENR); - SERIAL_CHAR(')'); + SERIAL_PROTOCOLCHAR(')'); #endif #endif #if HAS_TEMP_BED @@ -5364,7 +5376,7 @@ inline void gcode_M104() { SERIAL_PROTOCOL_F(thermalManager.degTargetBed(), 1); #if ENABLED(SHOW_TEMP_ADC_VALUES) SERIAL_PROTOCOLPAIR(" (", thermalManager.current_temperature_bed_raw / OVERSAMPLENR); - SERIAL_CHAR(')'); + SERIAL_PROTOCOLCHAR(')'); #endif #endif #if HOTENDS > 1 @@ -5376,7 +5388,7 @@ inline void gcode_M104() { SERIAL_PROTOCOL_F(thermalManager.degTargetHotend(e), 1); #if ENABLED(SHOW_TEMP_ADC_VALUES) SERIAL_PROTOCOLPAIR(" (", thermalManager.current_temperature_raw[e] / OVERSAMPLENR); - SERIAL_CHAR(')'); + SERIAL_PROTOCOLCHAR(')'); #endif } #endif @@ -7132,7 +7144,7 @@ void quickstop_stepper() { * * S[bool] Turns leveling on or off * Z[height] Sets the Z fade height (0 or none to disable) - * V[bool] Verbose - Print the levelng grid + * V[bool] Verbose - Print the leveling grid */ inline void gcode_M420() { bool to_enable = false; @@ -7150,7 +7162,7 @@ void quickstop_stepper() { #if ENABLED(MESH_BED_LEVELING) mbl.active() #elif ENABLED(AUTO_BED_LEVELING_UBL) - blm.state.active + ubl.state.active #else planner.abl_enabled #endif @@ -7176,7 +7188,7 @@ void quickstop_stepper() { #endif } #elif ENABLED(AUTO_BED_LEVELING_UBL) - blm.display_map(0); // Right now, we only support one type of map + ubl.display_map(0); // Right now, we only support one type of map #elif ENABLED(MESH_BED_LEVELING) if (mbl.has_mesh()) { SERIAL_ECHOLNPGM("Mesh Bed Level data:"); @@ -8013,7 +8025,7 @@ inline void gcode_M999() { inline void invalid_extruder_error(const uint8_t &e) { SERIAL_ECHO_START; SERIAL_CHAR('T'); - SERIAL_PROTOCOL_F(e, DEC); + SERIAL_ECHO_F(e, DEC); SERIAL_ECHOLN(MSG_INVALID_EXTRUDER); } @@ -8616,13 +8628,13 @@ void process_next_command() { #endif // Z_MIN_PROBE_REPEATABILITY_TEST #if ENABLED(AUTO_BED_LEVELING_UBL) - case 49: // M49: Turn on or off G26_Debug_flag for verbose output - if (G26_Debug_flag) { + case 49: // M49: Turn on or off g26_debug_flag for verbose output + if (g26_debug_flag) { SERIAL_PROTOCOLPGM("UBL Debug Flag turned off.\n"); - G26_Debug_flag = 0; } + g26_debug_flag = 0; } else { SERIAL_PROTOCOLPGM("UBL Debug Flag turned on.\n"); - G26_Debug_flag++; } + g26_debug_flag++; } break; #endif // Z_MIN_PROBE_REPEATABILITY_TEST @@ -9757,11 +9769,11 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { } else #elif ENABLED(AUTO_BED_LEVELING_UBL) - if (blm.state.active) { + if (ubl.state.active) { -// UBL_line_to_destination(MMS_SCALED(feedrate_mm_s)); +// ubl_line_to_destination(MMS_SCALED(feedrate_mm_s)); - UBL_line_to_destination(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], + ubl_line_to_destination(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], // (feedrate*(1.0/60.0))*(feedrate_percentage*(1.0/100.0) ), active_extruder); MMS_SCALED(feedrate_mm_s), active_extruder); diff --git a/Marlin/SanityCheck.h b/Marlin/SanityCheck.h index 23666d8f75..21c1d8626b 100644 --- a/Marlin/SanityCheck.h +++ b/Marlin/SanityCheck.h @@ -576,17 +576,15 @@ static_assert(1 >= 0 #endif /** - * Check if Probe_Offset * Grid Points is greater than Probing Range + * Check auto bed leveling sub-options, especially probe points */ #if ABL_GRID #ifndef DELTA_PROBEABLE_RADIUS - // Be sure points are in the right order #if LEFT_PROBE_BED_POSITION > RIGHT_PROBE_BED_POSITION #error "LEFT_PROBE_BED_POSITION must be less than RIGHT_PROBE_BED_POSITION." #elif FRONT_PROBE_BED_POSITION > BACK_PROBE_BED_POSITION #error "FRONT_PROBE_BED_POSITION must be less than BACK_PROBE_BED_POSITION." #endif - // Make sure probing points are reachable #if LEFT_PROBE_BED_POSITION < MIN_PROBE_X #error "The given LEFT_PROBE_BED_POSITION can't be reached by the Z probe." #elif RIGHT_PROBE_BED_POSITION > MAX_PROBE_X @@ -597,29 +595,39 @@ static_assert(1 >= 0 #error "The given BACK_PROBE_BED_POSITION can't be reached by the Z probe." #endif #endif - #else // !ABL_GRID - #if ENABLED(AUTO_BED_LEVELING_UBL) - #ifndef EEPROM_SETTINGS - #error "AUTO_BED_LEVELING_UBL requires EEPROM_SETTINGS. Please update your configuration." - #endif - #else // !UBL - // Check the triangulation points - #if ABL_PROBE_PT_1_X < MIN_PROBE_X || ABL_PROBE_PT_1_X > MAX_PROBE_X - #error "The given ABL_PROBE_PT_1_X can't be reached by the Z probe." - #elif ABL_PROBE_PT_2_X < MIN_PROBE_X || ABL_PROBE_PT_2_X > MAX_PROBE_X - #error "The given ABL_PROBE_PT_2_X can't be reached by the Z probe." - #elif ABL_PROBE_PT_3_X < MIN_PROBE_X || ABL_PROBE_PT_3_X > MAX_PROBE_X - #error "The given ABL_PROBE_PT_3_X can't be reached by the Z probe." - #elif ABL_PROBE_PT_1_Y < MIN_PROBE_Y || ABL_PROBE_PT_1_Y > MAX_PROBE_Y - #error "The given ABL_PROBE_PT_1_Y can't be reached by the Z probe." - #elif ABL_PROBE_PT_2_Y < MIN_PROBE_Y || ABL_PROBE_PT_2_Y > MAX_PROBE_Y - #error "The given ABL_PROBE_PT_2_Y can't be reached by the Z probe." - #elif ABL_PROBE_PT_3_Y < MIN_PROBE_Y || ABL_PROBE_PT_3_Y > MAX_PROBE_Y - #error "The given ABL_PROBE_PT_3_Y can't be reached by the Z probe." - #endif - #endif // !AUTO_BED_LEVEING_UBL - - #endif // !ABL_GRID + #elif ENABLED(AUTO_BED_LEVELING_UBL) + #if DISABLED(EEPROM_SETTINGS) + #error "AUTO_BED_LEVELING_UBL requires EEPROM_SETTINGS. Please update your configuration." + #elif UBL_MESH_NUM_X_POINTS < 3 || UBL_MESH_NUM_X_POINTS > 15 || UBL_MESH_NUM_Y_POINTS < 3 || UBL_MESH_NUM_Y_POINTS > 15 + #error "UBL_MESH_NUM_[XY]_POINTS must be a whole number between 3 and 15." + #elif UBL_PROBE_PT_1_X < MIN_PROBE_X || UBL_PROBE_PT_1_X > MAX_PROBE_X + #error "The given UBL_PROBE_PT_1_X can't be reached by the Z probe." + #elif UBL_PROBE_PT_2_X < MIN_PROBE_X || UBL_PROBE_PT_2_X > MAX_PROBE_X + #error "The given UBL_PROBE_PT_2_X can't be reached by the Z probe." + #elif UBL_PROBE_PT_3_X < MIN_PROBE_X || UBL_PROBE_PT_3_X > MAX_PROBE_X + #error "The given UBL_PROBE_PT_3_X can't be reached by the Z probe." + #elif UBL_PROBE_PT_1_Y < MIN_PROBE_Y || UBL_PROBE_PT_1_Y > MAX_PROBE_Y + #error "The given UBL_PROBE_PT_1_Y can't be reached by the Z probe." + #elif UBL_PROBE_PT_2_Y < MIN_PROBE_Y || UBL_PROBE_PT_2_Y > MAX_PROBE_Y + #error "The given UBL_PROBE_PT_2_Y can't be reached by the Z probe." + #elif UBL_PROBE_PT_3_Y < MIN_PROBE_Y || UBL_PROBE_PT_3_Y > MAX_PROBE_Y + #error "The given UBL_PROBE_PT_3_Y can't be reached by the Z probe." + #endif + #else // AUTO_BED_LEVELING_3POINT + #if ABL_PROBE_PT_1_X < MIN_PROBE_X || ABL_PROBE_PT_1_X > MAX_PROBE_X + #error "The given ABL_PROBE_PT_1_X can't be reached by the Z probe." + #elif ABL_PROBE_PT_2_X < MIN_PROBE_X || ABL_PROBE_PT_2_X > MAX_PROBE_X + #error "The given ABL_PROBE_PT_2_X can't be reached by the Z probe." + #elif ABL_PROBE_PT_3_X < MIN_PROBE_X || ABL_PROBE_PT_3_X > MAX_PROBE_X + #error "The given ABL_PROBE_PT_3_X can't be reached by the Z probe." + #elif ABL_PROBE_PT_1_Y < MIN_PROBE_Y || ABL_PROBE_PT_1_Y > MAX_PROBE_Y + #error "The given ABL_PROBE_PT_1_Y can't be reached by the Z probe." + #elif ABL_PROBE_PT_2_Y < MIN_PROBE_Y || ABL_PROBE_PT_2_Y > MAX_PROBE_Y + #error "The given ABL_PROBE_PT_2_Y can't be reached by the Z probe." + #elif ABL_PROBE_PT_3_Y < MIN_PROBE_Y || ABL_PROBE_PT_3_Y > MAX_PROBE_Y + #error "The given ABL_PROBE_PT_3_Y can't be reached by the Z probe." + #endif + #endif // AUTO_BED_LEVELING_3POINT #endif // HAS_ABL diff --git a/Marlin/UBL.h b/Marlin/UBL.h index 2c26276288..9aa34f3c79 100644 --- a/Marlin/UBL.h +++ b/Marlin/UBL.h @@ -37,27 +37,27 @@ // from the search location } mesh_index_pair; - struct vector { double dx, dy, dz; }; + typedef struct { double dx, dy, dz; } vector; - enum Mesh_Point_Type { INVALID, REAL, SET_IN_BITMAP }; + enum MeshPointType { INVALID, REAL, SET_IN_BITMAP }; bool axis_unhomed_error(bool, bool, bool); void dump(char *str, float f); - bool G29_lcd_clicked(); + bool ubl_lcd_clicked(); void probe_entire_mesh(float, float, bool, bool); - void UBL_line_to_destination(const float&, const float&, const float&, const float&, const float&, uint8_t); + void ubl_line_to_destination(const float&, const float&, const float&, const float&, const float&, uint8_t); void manually_probe_remaining_mesh(float, float, float, float, bool); - struct vector tilt_mesh_based_on_3pts(float, float, float); + vector tilt_mesh_based_on_3pts(float, float, float); void new_set_bed_level_equation_3pts(float, float, float); float measure_business_card_thickness(float); - mesh_index_pair find_closest_mesh_point_of_type(Mesh_Point_Type, float, float, bool, unsigned int[16]); - void Find_Mean_Mesh_Height(); - void Shift_Mesh_Height(); - bool G29_Parameter_Parsing(); - void G29_What_Command(); - void G29_EEPROM_Dump(); - void G29_Kompare_Current_Mesh_to_Stored_Mesh(); - void fine_tune_mesh(float, float, float, bool); + mesh_index_pair find_closest_mesh_point_of_type(MeshPointType, float, float, bool, unsigned int[16]); + void find_mean_mesh_height(); + void shift_mesh_height(); + bool g29_parameter_parsing(); + void g29_what_command(); + void g29_eeprom_dump(); + void g29_compare_current_mesh_to_stored_mesh(); + void fine_tune_mesh(float, float, bool); void bit_clear(uint16_t bits[16], uint8_t x, uint8_t y); void bit_set(uint16_t bits[16], uint8_t x, uint8_t y); bool is_bit_set(uint16_t bits[16], uint8_t x, uint8_t y); @@ -68,8 +68,8 @@ void gcode_G29(); extern char conv[9]; - void save_UBL_active_state_and_disable(); - void restore_UBL_active_state_and_leave(); + void save_ubl_active_state_and_disable(); + void restore_ubl_active_state_and_leave(); /////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -83,19 +83,19 @@ #define MESH_X_DIST ((float(UBL_MESH_MAX_X) - float(UBL_MESH_MIN_X)) / (float(UBL_MESH_NUM_X_POINTS) - 1.0)) #define MESH_Y_DIST ((float(UBL_MESH_MAX_Y) - float(UBL_MESH_MIN_Y)) / (float(UBL_MESH_NUM_Y_POINTS) - 1.0)) - extern bool G26_Debug_flag; + extern bool g26_debug_flag; extern float last_specified_z; extern float fade_scaling_factor_for_current_height; extern float z_values[UBL_MESH_NUM_X_POINTS][UBL_MESH_NUM_Y_POINTS]; - extern float mesh_index_to_X_location[UBL_MESH_NUM_X_POINTS + 1]; // +1 just because of paranoia that we might end up on the - extern float mesh_index_to_Y_location[UBL_MESH_NUM_Y_POINTS + 1]; // the last Mesh Line and that is the start of a whole new cell + extern float mesh_index_to_x_location[UBL_MESH_NUM_X_POINTS + 1]; // +1 just because of paranoia that we might end up on the + extern float mesh_index_to_y_location[UBL_MESH_NUM_Y_POINTS + 1]; // the last Mesh Line and that is the start of a whole new cell - class bed_leveling { + class unified_bed_leveling { public: struct ubl_state { bool active = false; float z_offset = 0.0; - int EEPROM_storage_slot = -1, + int eeprom_storage_slot = -1, n_x = UBL_MESH_NUM_X_POINTS, n_y = UBL_MESH_NUM_Y_POINTS; float mesh_x_min = UBL_MESH_MIN_X, @@ -104,8 +104,8 @@ mesh_y_max = UBL_MESH_MAX_Y, mesh_x_dist = MESH_X_DIST, mesh_y_dist = MESH_Y_DIST, - G29_Correction_Fade_Height = 10.0, - G29_Fade_Height_Multiplier = 1.0 / 10.0; // It is cheaper to do a floating point multiply than a floating + g29_correction_fade_height = 10.0, + g29_fade_height_multiplier = 1.0 / 10.0; // It is cheaper to do a floating point multiply than a floating // point divide. So, we keep this number in both forms. The first // is for the user. The second one is the one that is actually used // again and again and again during the correction calculations. @@ -119,8 +119,8 @@ // the padding[] to keep the size the same! } state, pre_initialized; - bed_leveling(); - // ~bed_leveling(); // No destructor because this object never goes away! + unified_bed_leveling(); + // ~unified_bed_leveling(); // No destructor because this object never goes away! void display_map(int); @@ -203,7 +203,7 @@ return NAN; } - const float a0ma1diva2ma1 = (x0 - mesh_index_to_X_location[x1_i]) * (1.0 / (MESH_X_DIST)), + const float a0ma1diva2ma1 = (x0 - mesh_index_to_x_location[x1_i]) * (1.0 / (MESH_X_DIST)), z1 = z_values[x1_i][yi], z2 = z_values[x1_i + 1][yi], dz = (z2 - z1); @@ -224,7 +224,7 @@ return NAN; } - const float a0ma1diva2ma1 = (y0 - mesh_index_to_Y_location[y1_i]) * (1.0 / (MESH_Y_DIST)), + const float a0ma1diva2ma1 = (y0 - mesh_index_to_y_location[y1_i]) * (1.0 / (MESH_Y_DIST)), z1 = z_values[xi][y1_i], z2 = z_values[xi][y1_i + 1], dz = (z2 - z1); @@ -271,20 +271,20 @@ SERIAL_ECHOPAIR(" raw get_z_correction(", x0); SERIAL_ECHOPAIR(",", y0); SERIAL_ECHOPGM(")="); - SERIAL_PROTOCOL_F(z0, 6); + SERIAL_ECHO_F(z0, 6); } #endif #if ENABLED(DEBUG_LEVELING_FEATURE) if (DEBUGGING(MESH_ADJUST)) { SERIAL_ECHOPGM(" >>>---> "); - SERIAL_PROTOCOL_F(z0, 6); + SERIAL_ECHO_F(z0, 6); SERIAL_EOL; } #endif if (isnan(z0)) { // if part of the Mesh is undefined, it will show up as NAN - z0 = 0.0; // in blm.z_values[][] and propagate through the + z0 = 0.0; // in ubl.z_values[][] and propagate through the // calculations. If our correction is NAN, we throw it out // because part of the Mesh is undefined and we don't have the // information we need to complete the height correction. @@ -311,21 +311,21 @@ * If it must do a calcuation, it will return a scaling factor of 0.0 if the UBL System is not active * or if the current Z Height is past the specified 'Fade Height' */ - FORCE_INLINE float fade_scaling_factor_for_Z(float current_z) { + FORCE_INLINE float fade_scaling_factor_for_z(float current_z) { if (last_specified_z == current_z) return fade_scaling_factor_for_current_height; last_specified_z = current_z; fade_scaling_factor_for_current_height = - state.active && current_z < state.G29_Correction_Fade_Height - ? 1.0 - (current_z * state.G29_Fade_Height_Multiplier) + state.active && current_z < state.g29_correction_fade_height + ? 1.0 - (current_z * state.g29_fade_height_multiplier) : 0.0; return fade_scaling_factor_for_current_height; } }; - extern bed_leveling blm; - extern int Unified_Bed_Leveling_EEPROM_start; + extern unified_bed_leveling ubl; + extern int ubl_eeprom_start; #endif // AUTO_BED_LEVELING_UBL #endif // UNIFIED_BED_LEVELING_H \ No newline at end of file diff --git a/Marlin/UBL_Bed_Leveling.cpp b/Marlin/UBL_Bed_Leveling.cpp index feff74e976..1494c9b03d 100644 --- a/Marlin/UBL_Bed_Leveling.cpp +++ b/Marlin/UBL_Bed_Leveling.cpp @@ -28,52 +28,59 @@ #include "hex_print_routines.h" /** - * These variables used to be declared inside the bed_leveling class. We are going to still declare - * them within the .cpp file for bed leveling. But there is only one instance of the bed leveling - * object and we can get rid of a level of inderection by not making them 'member data'. So, in the - * interest of speed, we do it this way. When we move to a 32-Bit processor, they can be moved - * back inside the bed leveling class. + * These variables used to be declared inside the unified_bed_leveling class. We are going to + * still declare them within the .cpp file for bed leveling. But there is only one instance of + * the bed leveling object and we can get rid of a level of inderection by not making them + * 'member data'. So, in the interest of speed, we do it this way. On a 32-bit CPU they can be + * moved back inside the bed leveling class. */ float last_specified_z, fade_scaling_factor_for_current_height, z_values[UBL_MESH_NUM_X_POINTS][UBL_MESH_NUM_Y_POINTS], - mesh_index_to_X_location[UBL_MESH_NUM_X_POINTS + 1], // +1 just because of paranoia that we might end up on the - mesh_index_to_Y_location[UBL_MESH_NUM_Y_POINTS + 1]; // the last Mesh Line and that is the start of a whole new cell + mesh_index_to_x_location[UBL_MESH_NUM_X_POINTS + 1], // +1 just because of paranoia that we might end up on the + mesh_index_to_y_location[UBL_MESH_NUM_Y_POINTS + 1]; // the last Mesh Line and that is the start of a whole new cell - bed_leveling::bed_leveling() { + unified_bed_leveling::unified_bed_leveling() { for (uint8_t i = 0; i <= UBL_MESH_NUM_X_POINTS; i++) // We go one past what we expect to ever need for safety - mesh_index_to_X_location[i] = double(UBL_MESH_MIN_X) + double(MESH_X_DIST) * double(i); + mesh_index_to_x_location[i] = double(UBL_MESH_MIN_X) + double(MESH_X_DIST) * double(i); for (uint8_t i = 0; i <= UBL_MESH_NUM_Y_POINTS; i++) // We go one past what we expect to ever need for safety - mesh_index_to_Y_location[i] = double(UBL_MESH_MIN_Y) + double(MESH_Y_DIST) * double(i); + mesh_index_to_y_location[i] = double(UBL_MESH_MIN_Y) + double(MESH_Y_DIST) * double(i); reset(); } - void bed_leveling::store_state() { - int k = E2END - sizeof(blm.state); - eeprom_write_block((void *)&blm.state, (void *)k, sizeof(blm.state)); + void unified_bed_leveling::store_state() { + int k = E2END - sizeof(ubl.state); + eeprom_write_block((void *)&ubl.state, (void *)k, sizeof(ubl.state)); } - void bed_leveling::load_state() { - int k = E2END - sizeof(blm.state); - eeprom_read_block((void *)&blm.state, (void *)k, sizeof(blm.state)); + void unified_bed_leveling::load_state() { + int k = E2END - sizeof(ubl.state); + eeprom_read_block((void *)&ubl.state, (void *)k, sizeof(ubl.state)); if (sanity_check()) SERIAL_PROTOCOLLNPGM("?In load_state() sanity_check() failed.\n"); - // These lines can go away in a few weeks. They are just - // to make sure people updating thier firmware won't be using - if (blm.state.G29_Fade_Height_Multiplier != 1.0 / blm.state.G29_Correction_Fade_Height) { // an incomplete Bed_Leveling.state structure. For speed - blm.state.G29_Fade_Height_Multiplier = 1.0 / blm.state.G29_Correction_Fade_Height; // we now multiply by the inverse of the Fade Height instead of - store_state(); // dividing by it. Soon... all of the old structures will be - } // updated, but until then, we try to ease the transition - // for our Beta testers. + /** + * These lines can go away in a few weeks. They are just + * to make sure people updating thier firmware won't be using + * an incomplete Bed_Leveling.state structure. For speed + * we now multiply by the inverse of the Fade Height instead of + * dividing by it. Soon... all of the old structures will be + * updated, but until then, we try to ease the transition + * for our Beta testers. + */ + if (ubl.state.g29_fade_height_multiplier != 1.0 / ubl.state.g29_correction_fade_height) { + ubl.state.g29_fade_height_multiplier = 1.0 / ubl.state.g29_correction_fade_height; + store_state(); + } + } - void bed_leveling::load_mesh(int m) { - int k = E2END - sizeof(blm.state), - j = (k - Unified_Bed_Leveling_EEPROM_start) / sizeof(z_values); + void unified_bed_leveling::load_mesh(int m) { + int k = E2END - sizeof(ubl.state), + j = (k - ubl_eeprom_start) / sizeof(z_values); if (m == -1) { SERIAL_PROTOCOLLNPGM("?No mesh saved in EEPROM. Zeroing mesh in memory.\n"); @@ -81,7 +88,7 @@ return; } - if (m < 0 || m >= j || Unified_Bed_Leveling_EEPROM_start <= 0) { + if (m < 0 || m >= j || ubl_eeprom_start <= 0) { SERIAL_PROTOCOLLNPGM("?EEPROM storage not available to load mesh.\n"); return; } @@ -96,11 +103,11 @@ SERIAL_EOL; } - void bed_leveling:: store_mesh(int m) { + void unified_bed_leveling:: store_mesh(int m) { int k = E2END - sizeof(state), - j = (k - Unified_Bed_Leveling_EEPROM_start) / sizeof(z_values); + j = (k - ubl_eeprom_start) / sizeof(z_values); - if (m < 0 || m >= j || Unified_Bed_Leveling_EEPROM_start <= 0) { + if (m < 0 || m >= j || ubl_eeprom_start <= 0) { SERIAL_PROTOCOLLNPGM("?EEPROM storage not available to load mesh.\n"); SERIAL_PROTOCOL(m); SERIAL_PROTOCOLLNPGM(" mesh slots available.\n"); @@ -122,18 +129,18 @@ SERIAL_EOL; } - void bed_leveling::reset() { + void unified_bed_leveling::reset() { state.active = false; state.z_offset = 0; - state.EEPROM_storage_slot = -1; + state.eeprom_storage_slot = -1; ZERO(z_values); - last_specified_z = -999.9; // We can't pre-initialize these values in the declaration - fade_scaling_factor_for_current_height = 0.0; // due to C++11 constraints + last_specified_z = -999.9; + fade_scaling_factor_for_current_height = 0.0; } - void bed_leveling::invalidate() { + void unified_bed_leveling::invalidate() { prt_hex_word((unsigned int)this); SERIAL_EOL; @@ -144,7 +151,7 @@ z_values[x][y] = NAN; } - void bed_leveling::display_map(int map_type) { + void unified_bed_leveling::display_map(int map_type) { float f, current_xi, current_yi; int8_t i, j; UNUSED(map_type); @@ -155,8 +162,8 @@ SERIAL_ECHOPAIR(", ", UBL_MESH_NUM_Y_POINTS - 1); SERIAL_ECHOPGM(") "); - current_xi = blm.get_cell_index_x(current_position[X_AXIS] + (MESH_X_DIST) / 2.0); - current_yi = blm.get_cell_index_y(current_position[Y_AXIS] + (MESH_Y_DIST) / 2.0); + current_xi = ubl.get_cell_index_x(current_position[X_AXIS] + (MESH_X_DIST) / 2.0); + current_yi = ubl.get_cell_index_y(current_position[Y_AXIS] + (MESH_Y_DIST) / 2.0); for (i = 0; i < UBL_MESH_NUM_X_POINTS - 1; i++) SERIAL_ECHOPGM(" "); @@ -166,16 +173,18 @@ SERIAL_ECHOLNPGM(")"); // if (map_type || 1) { - SERIAL_ECHOPAIR("(", UBL_MESH_MIN_X); - SERIAL_ECHOPAIR(",", UBL_MESH_MAX_Y); - SERIAL_CHAR(')'); - for (i = 0; i < UBL_MESH_NUM_X_POINTS - 1; i++) - SERIAL_ECHOPGM(" "); + SERIAL_ECHOPAIR("(", UBL_MESH_MIN_X); + SERIAL_ECHOPAIR(",", UBL_MESH_MAX_Y); + SERIAL_CHAR(')'); + + for (i = 0; i < UBL_MESH_NUM_X_POINTS - 1; i++) + SERIAL_ECHOPGM(" "); + + SERIAL_ECHOPAIR("(", UBL_MESH_MAX_X); + SERIAL_ECHOPAIR(",", UBL_MESH_MAX_Y); + SERIAL_ECHOLNPGM(")"); - SERIAL_ECHOPAIR("(", UBL_MESH_MAX_X); - SERIAL_ECHOPAIR(",", UBL_MESH_MAX_Y); - SERIAL_ECHOLNPGM(")"); // } for (j = UBL_MESH_NUM_Y_POINTS - 1; j >= 0; j--) { @@ -235,51 +244,51 @@ SERIAL_EOL; } - bool bed_leveling::sanity_check() { + bool unified_bed_leveling::sanity_check() { uint8_t error_flag = 0; - if (state.n_x != UBL_MESH_NUM_X_POINTS) { + if (state.n_x != UBL_MESH_NUM_X_POINTS) { SERIAL_PROTOCOLLNPGM("?UBL_MESH_NUM_X_POINTS set wrong\n"); error_flag++; } - if (state.n_y != UBL_MESH_NUM_Y_POINTS) { + if (state.n_y != UBL_MESH_NUM_Y_POINTS) { SERIAL_PROTOCOLLNPGM("?UBL_MESH_NUM_Y_POINTS set wrong\n"); error_flag++; } - if (state.mesh_x_min != UBL_MESH_MIN_X) { + if (state.mesh_x_min != UBL_MESH_MIN_X) { SERIAL_PROTOCOLLNPGM("?UBL_MESH_MIN_X set wrong\n"); error_flag++; } - if (state.mesh_y_min != UBL_MESH_MIN_Y) { + if (state.mesh_y_min != UBL_MESH_MIN_Y) { SERIAL_PROTOCOLLNPGM("?UBL_MESH_MIN_Y set wrong\n"); error_flag++; } - if (state.mesh_x_max != UBL_MESH_MAX_X) { + if (state.mesh_x_max != UBL_MESH_MAX_X) { SERIAL_PROTOCOLLNPGM("?UBL_MESH_MAX_X set wrong\n"); error_flag++; } - if (state.mesh_y_max != UBL_MESH_MAX_Y) { + if (state.mesh_y_max != UBL_MESH_MAX_Y) { SERIAL_PROTOCOLLNPGM("?UBL_MESH_MAX_Y set wrong\n"); error_flag++; } - if (state.mesh_x_dist != MESH_X_DIST) { + if (state.mesh_x_dist != MESH_X_DIST) { SERIAL_PROTOCOLLNPGM("?MESH_X_DIST set wrong\n"); error_flag++; } - if (state.mesh_y_dist != MESH_Y_DIST) { + if (state.mesh_y_dist != MESH_Y_DIST) { SERIAL_PROTOCOLLNPGM("?MESH_Y_DIST set wrong\n"); error_flag++; } - int k = E2END - sizeof(blm.state), - j = (k - Unified_Bed_Leveling_EEPROM_start) / sizeof(z_values); + const int k = E2END - sizeof(ubl.state), + j = (k - ubl_eeprom_start) / sizeof(z_values); if (j < 1) { SERIAL_PROTOCOLLNPGM("?No EEPROM storage available for a mesh of this size.\n"); diff --git a/Marlin/UBL_G29.cpp b/Marlin/UBL_G29.cpp index 93f2c8f198..6bf0ec4f42 100644 --- a/Marlin/UBL_G29.cpp +++ b/Marlin/UBL_G29.cpp @@ -37,10 +37,6 @@ void lcd_return_to_status(); bool lcd_clicked(); void lcd_implementation_clear(); - void lcd_mesh_edit_setup(float inital); - float lcd_mesh_edit(); - void lcd_z_offset_edit_setup(float); - float lcd_z_offset_edit(); extern float meshedit_done; extern long babysteps_done; @@ -65,268 +61,250 @@ extern void lcd_quick_feedback(); /** - * G29: Unified Bed Leveling by Roxy - */ - - // Transform required to compensate for bed level - //extern matrix_3x3 plan_bed_level_matrix; - - /** - * Get the position applying the bed level matrix - */ - - //vector_3 plan_get_position(); - - // static void set_bed_level_equation_lsq(double* plane_equation_coefficients); - // static void set_bed_level_equation_3pts(float z_at_pt_1, float z_at_pt_2, float z_at_pt_3); - - /** - * G29: Mesh Based Compensation System + * G29: Unified Bed Leveling by Roxy * * Parameters understood by this leveling system: * - * A Activate Activate the Unified Bed Leveling system. + * A Activate Activate the Unified Bed Leveling system. * - * B # Business Use the 'Business Card' mode of the Manual Probe subsystem. This is invoked as - * G29 P2 B The mode of G29 P2 allows you to use a bussiness card or recipe card - * as a shim that the nozzle will pinch as it is lowered. The idea is that you - * can easily feel the nozzle getting to the same height by the amount of resistance - * the business card exhibits to movement. You should try to achieve the same amount - * of resistance on each probed point to facilitate accurate and repeatable measurements. - * You should be very careful not to drive the nozzle into the bussiness card with a - * lot of force as it is very possible to cause damage to your printer if your are - * careless. If you use the B option with G29 P2 B you can leave the number parameter off - * on its first use to enable measurement of the business card thickness. Subsequent usage - * of the B parameter can have the number previously measured supplied to the command. - * Incidently, you are much better off using something like a Spark Gap feeler gauge than - * something that compresses like a Business Card. + * B # Business Use the 'Business Card' mode of the Manual Probe subsystem. This is invoked as + * G29 P2 B The mode of G29 P2 allows you to use a bussiness card or recipe card + * as a shim that the nozzle will pinch as it is lowered. The idea is that you + * can easily feel the nozzle getting to the same height by the amount of resistance + * the business card exhibits to movement. You should try to achieve the same amount + * of resistance on each probed point to facilitate accurate and repeatable measurements. + * You should be very careful not to drive the nozzle into the bussiness card with a + * lot of force as it is very possible to cause damage to your printer if your are + * careless. If you use the B option with G29 P2 B you can leave the number parameter off + * on its first use to enable measurement of the business card thickness. Subsequent usage + * of the B parameter can have the number previously measured supplied to the command. + * Incidently, you are much better off using something like a Spark Gap feeler gauge than + * something that compresses like a Business Card. * - * C Continue Continue, Constant, Current Location. This is not a primary command. C is used to - * further refine the behaviour of several other commands. Issuing a G29 P1 C will - * continue the generation of a partially constructed Mesh without invalidating what has - * been done. Issuing a G29 P2 C will tell the Manual Probe subsystem to use the current - * location in its search for the closest unmeasured Mesh Point. When used with a G29 Z C - * it indicates to use the current location instead of defaulting to the center of the print bed. + * C Continue Continue, Constant, Current Location. This is not a primary command. C is used to + * further refine the behaviour of several other commands. Issuing a G29 P1 C will + * continue the generation of a partially constructed Mesh without invalidating what has + * been done. Issuing a G29 P2 C will tell the Manual Probe subsystem to use the current + * location in its search for the closest unmeasured Mesh Point. When used with a G29 Z C + * it indicates to use the current location instead of defaulting to the center of the print bed. * - * D Disable Disable the Unified Bed Leveling system. + * D Disable Disable the Unified Bed Leveling system. * * E Stow_probe Stow the probe after each sampled point. * - * F # Fade * Fade the amount of Mesh Based Compensation over a specified height. At the specified height, - * no correction is applied and natural printer kenimatics take over. If no number is specified - * for the command, 10mm is assummed to be reasonable. + * F # Fade * Fade the amount of Mesh Based Compensation over a specified height. At the + * specified height, no correction is applied and natural printer kenimatics take over. If no + * number is specified for the command, 10mm is assumed to be reasonable. * * G # Grid * Perform a Grid Based Leveling of the current Mesh using a grid with n points on * a side. * - * H # Height Specify the Height to raise the nozzle after each manual probe of the bed. The - * default is 5mm. + * H # Height Specify the Height to raise the nozzle after each manual probe of the bed. The + * default is 5mm. * - * I # Invalidate Invalidate specified number of Mesh Points. The nozzle location is used unless - * the X and Y parameter are used. If no number is specified, only the closest Mesh - * point to the location is invalidated. The M parameter is available as well to produce - * a map after the operation. This command is useful to invalidate a portion of the - * Mesh so it can be adjusted using other tools in the Unified Bed Leveling System. When - * attempting to invalidate an isolated bad point in the mesh, the M option will indicate - * where the nozzle is positioned in the Mesh with (#). You can move the nozzle around on - * the bed and use this feature to select the center of the area (or cell) you want to - * invalidate. + * I # Invalidate Invalidate specified number of Mesh Points. The nozzle location is used unless + * the X and Y parameter are used. If no number is specified, only the closest Mesh + * point to the location is invalidated. The M parameter is available as well to produce + * a map after the operation. This command is useful to invalidate a portion of the + * Mesh so it can be adjusted using other tools in the Unified Bed Leveling System. When + * attempting to invalidate an isolated bad point in the mesh, the M option will indicate + * where the nozzle is positioned in the Mesh with (#). You can move the nozzle around on + * the bed and use this feature to select the center of the area (or cell) you want to + * invalidate. * - * K # Kompare Kompare current Mesh with stored Mesh # replacing current Mesh with the result. This - * command litterly performs a difference between two Mesh. + * K # Kompare Kompare current Mesh with stored Mesh # replacing current Mesh with the result. This + * command literally performs a diff between two Meshes. * * L Load * Load Mesh from the previously activated location in the EEPROM. * - * L # Load * Load Mesh from the specified location in the EEPROM. Set this location as activated - * for subsequent Load and Store operations. + * L # Load * Load Mesh from the specified location in the EEPROM. Set this location as activated + * for subsequent Load and Store operations. * * O Map * Display the Mesh Map Topology. - * The parameter can be specified alone (ie. G29 O) or in combination with many of the - * other commands. The Mesh Map option works with all of the Phase - * commands (ie. G29 P4 R 5 X 50 Y100 C -.1 O) + * The parameter can be specified alone (ie. G29 O) or in combination with many of the + * other commands. The Mesh Map option works with all of the Phase + * commands (ie. G29 P4 R 5 X 50 Y100 C -.1 O) * - * N No Home G29 normally insists that a G28 has been performed. You can over rule this with an - * N option. In general, you should not do this. This can only be done safely with - * commands that do not move the nozzle. + * N No Home G29 normally insists that a G28 has been performed. You can over rule this with an + * N option. In general, you should not do this. This can only be done safely with + * commands that do not move the nozzle. * - * The P or Phase commands are used for the bulk of the work to setup a Mesh. In general, your Mesh will + * The P or Phase commands are used for the bulk of the work to setup a Mesh. In general, your Mesh will * start off being initialized with a G29 P0 or a G29 P1. Further refinement of the Mesh happens with * each additional Phase that processes it. * - * P0 Phase 0 Zero Mesh Data and turn off the Mesh Compensation System. This reverts the - * 3D Printer to the same state it was in before the Unified Bed Leveling Compensation - * was turned on. Setting the entire Mesh to Zero is a special case that allows - * a subsequent G or T leveling operation for backward compatability. + * P0 Phase 0 Zero Mesh Data and turn off the Mesh Compensation System. This reverts the + * 3D Printer to the same state it was in before the Unified Bed Leveling Compensation + * was turned on. Setting the entire Mesh to Zero is a special case that allows + * a subsequent G or T leveling operation for backward compatability. * - * P1 Phase 1 Invalidate entire Mesh and continue with automatic generation of the Mesh data using - * the Z-Probe. Depending upon the values of DELTA_PROBEABLE_RADIUS and - * DELTA_PRINTABLE_RADIUS some area of the bed will not have Mesh Data automatically - * generated. This will be handled in Phase 2. If the Phase 1 command is given the - * C (Continue) parameter it does not invalidate the Mesh prior to automatically - * probing needed locations. This allows you to invalidate portions of the Mesh but still - * use the automatic probing capabilities of the Unified Bed Leveling System. An X and Y - * parameter can be given to prioritize where the command should be trying to measure points. - * If the X and Y parameters are not specified the current probe position is used. Phase 1 - * allows you to specify the M (Map) parameter so you can watch the generation of the Mesh. - * Phase 1 also watches for the LCD Panel's Encoder Switch being held in a depressed state. - * It will suspend generation of the Mesh if it sees the user request that. (This check is - * only done between probe points. You will need to press and hold the switch until the - * Phase 1 command can detect it.) + * P1 Phase 1 Invalidate entire Mesh and continue with automatic generation of the Mesh data using + * the Z-Probe. Depending upon the values of DELTA_PROBEABLE_RADIUS and + * DELTA_PRINTABLE_RADIUS some area of the bed will not have Mesh Data automatically + * generated. This will be handled in Phase 2. If the Phase 1 command is given the + * C (Continue) parameter it does not invalidate the Mesh prior to automatically + * probing needed locations. This allows you to invalidate portions of the Mesh but still + * use the automatic probing capabilities of the Unified Bed Leveling System. An X and Y + * parameter can be given to prioritize where the command should be trying to measure points. + * If the X and Y parameters are not specified the current probe position is used. Phase 1 + * allows you to specify the M (Map) parameter so you can watch the generation of the Mesh. + * Phase 1 also watches for the LCD Panel's Encoder Switch being held in a depressed state. + * It will suspend generation of the Mesh if it sees the user request that. (This check is + * only done between probe points. You will need to press and hold the switch until the + * Phase 1 command can detect it.) * - * P2 Phase 2 Probe areas of the Mesh that can not be automatically handled. Phase 2 respects an H - * parameter to control the height between Mesh points. The default height for movement - * between Mesh points is 5mm. A smaller number can be used to make this part of the - * calibration less time consuming. You will be running the nozzle down until it just barely - * touches the glass. You should have the nozzle clean with no plastic obstructing your view. - * Use caution and move slowly. It is possible to damage your printer if you are careless. - * Note that this command will use the configuration #define SIZE_OF_LITTLE_RAISE if the - * nozzle is moving a distance of less than BIG_RAISE_NOT_NEEDED. + * P2 Phase 2 Probe areas of the Mesh that can not be automatically handled. Phase 2 respects an H + * parameter to control the height between Mesh points. The default height for movement + * between Mesh points is 5mm. A smaller number can be used to make this part of the + * calibration less time consuming. You will be running the nozzle down until it just barely + * touches the glass. You should have the nozzle clean with no plastic obstructing your view. + * Use caution and move slowly. It is possible to damage your printer if you are careless. + * Note that this command will use the configuration #define SIZE_OF_LITTLE_RAISE if the + * nozzle is moving a distance of less than BIG_RAISE_NOT_NEEDED. * - * The H parameter can be set negative if your Mesh dips in a large area. You can press - * and hold the LCD Panel's encoder wheel to terminate the current Phase 2 command. You - * can then re-issue the G29 P 2 command with an H parameter that is more suitable for the - * area you are manually probing. Note that the command tries to start you in a corner - * of the bed where movement will be predictable. You can force the location to be used in - * the distance calculations by using the X and Y parameters. You may find it is helpful to - * print out a Mesh Map (G29 O ) to understand where the mesh is invalidated and where - * the nozzle will need to move in order to complete the command. The C parameter is - * available on the Phase 2 command also and indicates the search for points to measure should - * be done based on the current location of the nozzle. + * The H parameter can be set negative if your Mesh dips in a large area. You can press + * and hold the LCD Panel's encoder wheel to terminate the current Phase 2 command. You + * can then re-issue the G29 P 2 command with an H parameter that is more suitable for the + * area you are manually probing. Note that the command tries to start you in a corner + * of the bed where movement will be predictable. You can force the location to be used in + * the distance calculations by using the X and Y parameters. You may find it is helpful to + * print out a Mesh Map (G29 O ) to understand where the mesh is invalidated and where + * the nozzle will need to move in order to complete the command. The C parameter is + * available on the Phase 2 command also and indicates the search for points to measure should + * be done based on the current location of the nozzle. * - * A B parameter is also available for this command and described up above. It places the - * manual probe subsystem into Business Card mode where the thickness of a business care is - * measured and then used to accurately set the nozzle height in all manual probing for the - * duration of the command. (S for Shim mode would be a better parameter name, but S is needed - * for Save or Store of the Mesh to EEPROM) A Business card can be used, but you will have - * better results if you use a flexible Shim that does not compress very much. That makes it - * easier for you to get the nozzle to press with similar amounts of force against the shim so you - * can get accurate measurements. As you are starting to touch the nozzle against the shim try - * to get it to grasp the shim with the same force as when you measured the thickness of the - * shim at the start of the command. + * A B parameter is also available for this command and described up above. It places the + * manual probe subsystem into Business Card mode where the thickness of a business care is + * measured and then used to accurately set the nozzle height in all manual probing for the + * duration of the command. (S for Shim mode would be a better parameter name, but S is needed + * for Save or Store of the Mesh to EEPROM) A Business card can be used, but you will have + * better results if you use a flexible Shim that does not compress very much. That makes it + * easier for you to get the nozzle to press with similar amounts of force against the shim so you + * can get accurate measurements. As you are starting to touch the nozzle against the shim try + * to get it to grasp the shim with the same force as when you measured the thickness of the + * shim at the start of the command. * - * Phase 2 allows the O (Map) parameter to be specified. This helps the user see the progression - * of the Mesh being built. + * Phase 2 allows the O (Map) parameter to be specified. This helps the user see the progression + * of the Mesh being built. * - * P3 Phase 3 Fill the unpopulated regions of the Mesh with a fixed value. The C parameter is used to - * specify the Constant value to fill all invalid areas of the Mesh. If no C parameter is - * specified, a value of 0.0 is assumed. The R parameter can be given to specify the number - * of points to set. If the R parameter is specified the current nozzle position is used to - * find the closest points to alter unless the X and Y parameter are used to specify the fill - * location. + * P3 Phase 3 Fill the unpopulated regions of the Mesh with a fixed value. The C parameter is + * used to specify the 'constant' value to fill all invalid areas of the Mesh. If no C parameter + * is specified, a value of 0.0 is assumed. The R parameter can be given to specify the number + * of points to set. If the R parameter is specified the current nozzle position is used to + * find the closest points to alter unless the X and Y parameter are used to specify the fill + * location. * - * P4 Phase 4 Fine tune the Mesh. The Delta Mesh Compensation System assume the existance of - * an LCD Panel. It is possible to fine tune the mesh without the use of an LCD Panel. - * (More work and details on doing this later!) - * The System will search for the closest Mesh Point to the nozzle. It will move the - * nozzle to this location. The user can use the LCD Panel to carefully adjust the nozzle - * so it is just barely touching the bed. When the user clicks the control, the System - * will lock in that height for that point in the Mesh Compensation System. + * P4 Phase 4 Fine tune the Mesh. The Delta Mesh Compensation System assume the existance of + * an LCD Panel. It is possible to fine tune the mesh without the use of an LCD Panel. + * (More work and details on doing this later!) + * The System will search for the closest Mesh Point to the nozzle. It will move the + * nozzle to this location. The user can use the LCD Panel to carefully adjust the nozzle + * so it is just barely touching the bed. When the user clicks the control, the System + * will lock in that height for that point in the Mesh Compensation System. * - * Phase 4 has several additional parameters that the user may find helpful. Phase 4 - * can be started at a specific location by specifying an X and Y parameter. Phase 4 - * can be requested to continue the adjustment of Mesh Points by using the R(epeat) - * parameter. If the Repetition count is not specified, it is assumed the user wishes - * to adjust the entire matrix. The nozzle is moved to the Mesh Point being edited. - * The command can be terminated early (or after the area of interest has been edited) by - * pressing and holding the encoder wheel until the system recognizes the exit request. - * Phase 4's general form is G29 P4 [R # of points] [X position] [Y position] + * Phase 4 has several additional parameters that the user may find helpful. Phase 4 + * can be started at a specific location by specifying an X and Y parameter. Phase 4 + * can be requested to continue the adjustment of Mesh Points by using the R(epeat) + * parameter. If the Repetition count is not specified, it is assumed the user wishes + * to adjust the entire matrix. The nozzle is moved to the Mesh Point being edited. + * The command can be terminated early (or after the area of interest has been edited) by + * pressing and holding the encoder wheel until the system recognizes the exit request. + * Phase 4's general form is G29 P4 [R # of points] [X position] [Y position] * - * Phase 4 is intended to be used with the G26 Mesh Validation Command. Using the - * information left on the printer's bed from the G26 command it is very straight forward - * and easy to fine tune the Mesh. One concept that is important to remember and that - * will make using the Phase 4 command easy to use is this: You are editing the Mesh Points. - * If you have too little clearance and not much plastic was extruded in an area, you want to - * LOWER the Mesh Point at the location. If you did not get good adheasion, you want to - * RAISE the Mesh Point at that location. + * Phase 4 is intended to be used with the G26 Mesh Validation Command. Using the + * information left on the printer's bed from the G26 command it is very straight forward + * and easy to fine tune the Mesh. One concept that is important to remember and that + * will make using the Phase 4 command easy to use is this: You are editing the Mesh Points. + * If you have too little clearance and not much plastic was extruded in an area, you want to + * LOWER the Mesh Point at the location. If you did not get good adheasion, you want to + * RAISE the Mesh Point at that location. * * - * P5 Phase 5 Find Mean Mesh Height and Standard Deviation. Typically, it is easier to use and - * work with the Mesh if it is Mean Adjusted. You can specify a C parameter to - * Correct the Mesh to a 0.00 Mean Height. Adding a C parameter will automatically - * execute a G29 P6 C . + * P5 Phase 5 Find Mean Mesh Height and Standard Deviation. Typically, it is easier to use and + * work with the Mesh if it is Mean Adjusted. You can specify a C parameter to + * Correct the Mesh to a 0.00 Mean Height. Adding a C parameter will automatically + * execute a G29 P6 C . * - * P6 Phase 6 Shift Mesh height. The entire Mesh's height is adjusted by the height specified - * with the C parameter. Being able to adjust the height of a Mesh is useful tool. It - * can be used to compensate for poorly calibrated Z-Probes and other errors. Ideally, - * you should have the Mesh adjusted for a Mean Height of 0.00 and the Z-Probe measuring - * 0.000 at the Z Home location. + * P6 Phase 6 Shift Mesh height. The entire Mesh's height is adjusted by the height specified + * with the C parameter. Being able to adjust the height of a Mesh is useful tool. It + * can be used to compensate for poorly calibrated Z-Probes and other errors. Ideally, + * you should have the Mesh adjusted for a Mean Height of 0.00 and the Z-Probe measuring + * 0.000 at the Z Home location. * - * Q Test * Load specified Test Pattern to assist in checking correct operation of system. This - * command is not anticipated to be of much value to the typical user. It is intended - * for developers to help them verify correct operation of the Unified Bed Leveling System. + * Q Test * Load specified Test Pattern to assist in checking correct operation of system. This + * command is not anticipated to be of much value to the typical user. It is intended + * for developers to help them verify correct operation of the Unified Bed Leveling System. * - * S Store Store the current Mesh in the Activated area of the EEPROM. It will also store the - * current state of the Unified Bed Leveling system in the EEPROM. + * S Store Store the current Mesh in the Activated area of the EEPROM. It will also store the + * current state of the Unified Bed Leveling system in the EEPROM. * - * S # Store Store the current Mesh at the specified location in EEPROM. Activate this location - * for subsequent Load and Store operations. It will also store the current state of - * the Unified Bed Leveling system in the EEPROM. + * S # Store Store the current Mesh at the specified location in EEPROM. Activate this location + * for subsequent Load and Store operations. It will also store the current state of + * the Unified Bed Leveling system in the EEPROM. * - * S -1 Store Store the current Mesh as a print out that is suitable to be feed back into - * the system at a later date. The text generated can be saved and later sent by PronterFace or - * Repetier Host to reconstruct the current mesh on another machine. + * S -1 Store Store the current Mesh as a print out that is suitable to be feed back into + * the system at a later date. The text generated can be saved and later sent by PronterFace or + * Repetier Host to reconstruct the current mesh on another machine. * - * T 3-Point Perform a 3 Point Bed Leveling on the current Mesh + * T 3-Point Perform a 3 Point Bed Leveling on the current Mesh * - * W What? Display valuable data the Unified Bed Leveling System knows. + * W What? Display valuable data the Unified Bed Leveling System knows. * - * X # * * Specify X Location for this line of commands + * X # * * X Location for this line of commands * - * Y # * * Specify Y Location for this line of commands + * Y # * * Y Location for this line of commands * - * Z Zero * Probes to set the Z Height of the nozzle. The entire Mesh can be raised or lowered - * by just doing a G29 Z + * Z Zero * Probes to set the Z Height of the nozzle. The entire Mesh can be raised or lowered + * by just doing a G29 Z * * Z # Zero * The entire Mesh can be raised or lowered to conform with the specified difference. - * zprobe_zoffset is added to the calculation. + * zprobe_zoffset is added to the calculation. * * * Release Notes: - * You MUST do a M502 & M500 pair of commands to initialize the storage. Failure to do this - * will cause all kinds of problems. Enabling EEPROM Storage is highly recommended. With - * EEPROM Storage of the mesh, you are limited to 3-Point and Grid Leveling. (G29 P0 T and - * G29 P0 G respectively.) + * You MUST do M502, M500 to initialize the storage. Failure to do this will cause all + * kinds of problems. Enabling EEPROM Storage is highly recommended. With EEPROM Storage + * of the mesh, you are limited to 3-Point and Grid Leveling. (G29 P0 T and G29 P0 G + * respectively.) * - * Z-Probe Sleds are not currently fully supported. There were too many complications caused - * by them to support them in the Unified Bed Leveling code. Support for them will be handled - * better in the upcoming Z-Probe Object that will happen during the Code Clean Up phase. (That + * Z-Probe Sleds are not currently fully supported. There were too many complications caused + * by them to support them in the Unified Bed Leveling code. Support for them will be handled + * better in the upcoming Z-Probe Object that will happen during the Code Clean Up phase. (That * is what they really are: A special case of the Z-Probe.) When a Z-Probe Object appears, it * should slip in under the Unified Bed Leveling code without major trauma. * * When you do a G28 and then a G29 P1 to automatically build your first mesh, you are going to notice * the Unified Bed Leveling probes points further and further away from the starting location. (The * starting location defaults to the center of the bed.) The original Grid and Mesh leveling used - * a Zig Zag pattern. The new pattern is better, especially for people with Delta printers. This - * allows you to get the center area of the Mesh populated (and edited) quicker. This allows you to - * perform a small print and check out your settings quicker. You do not need to populate the - * entire mesh to use it. (You don't want to spend a lot of time generating a mesh only to realize - * you don't have the resolution or zprobe_zoffset set correctly. The Mesh generation + * a Zig Zag pattern. The new pattern is better, especially for people with Delta printers. This + * allows you to get the center area of the Mesh populated (and edited) quicker. This allows you to + * perform a small print and check out your settings quicker. You do not need to populate the + * entire mesh to use it. (You don't want to spend a lot of time generating a mesh only to realize + * you don't have the resolution or zprobe_zoffset set correctly. The Mesh generation * gathers points closest to where the nozzle is located unless you specify an (X,Y) coordinate pair. * - * The Unified Bed Leveling uses a lot of EEPROM storage to hold its data. And it takes some effort - * to get this Mesh data correct for a user's printer. We do not want this data destroyed as - * new versions of Marlin add or subtract to the items stored in EEPROM. So, for the benefit of + * The Unified Bed Leveling uses a lot of EEPROM storage to hold its data. And it takes some effort + * to get this Mesh data correct for a user's printer. We do not want this data destroyed as + * new versions of Marlin add or subtract to the items stored in EEPROM. So, for the benefit of * the users, we store the Mesh data at the end of the EEPROM and do not keep it contiguous with the - * other data stored in the EEPROM. (For sure the developers are going to complain about this, but + * other data stored in the EEPROM. (For sure the developers are going to complain about this, but * this is going to be helpful to the users!) * - * The foundation of this Bed Leveling System is built on Epatel's Mesh Bed Leveling code. A big - * 'Thanks!' to him and the creators of 3-Point and Grid Based leveling. Combining thier contributions + * The foundation of this Bed Leveling System is built on Epatel's Mesh Bed Leveling code. A big + * 'Thanks!' to him and the creators of 3-Point and Grid Based leveling. Combining thier contributions * we now have the functionality and features of all three systems combined. */ - int Unified_Bed_Leveling_EEPROM_start = -1; - int UBL_has_control_of_LCD_Panel = 0; - volatile int G29_encoderDiff = 0; // This is volatile because it is getting changed at interrupt time. + int ubl_eeprom_start = -1; + bool ubl_has_control_of_lcd_panel = false; + volatile uint8_t ubl_encoderDiff = 0; // Volatile because it's changed by Temperature ISR button update - // We keep the simple parameter flags and values as 'static' because we break out the - // parameter parsing into a support routine. - - static int G29_Verbose_Level = 0, Test_Value = 0, - Phase_Value = -1, Repetition_Cnt = 1; - static bool Repeat_Flag = UBL_OK, C_Flag = false, X_Flag = UBL_OK, Y_Flag = UBL_OK, Statistics_Flag = UBL_OK, Business_Card_Mode = false; - static float X_Pos = 0.0, Y_Pos = 0.0, Height_Value = 5.0, measured_z, card_thickness = 0.0, Constant = 0.0; - static int Storage_Slot = 0, Test_Pattern = 0; + // The simple parameter flags and values are 'static' so parameter parsing can be in a support routine. + static int g29_verbose_level = 0, test_value = 0, + phase_value = -1, repetition_cnt = 1; + static bool repeat_flag = UBL_OK, c_flag = false, x_flag = UBL_OK, y_flag = UBL_OK, statistics_flag = UBL_OK, business_card_mode = false; + static float x_pos = 0.0, y_pos = 0.0, height_value = 5.0, measured_z, card_thickness = 0.0, constant = 0.0; + static int storage_slot = 0, test_pattern = 0; #if ENABLED(ULTRA_LCD) void lcd_setstatus(const char* message, bool persist); @@ -334,19 +312,18 @@ void gcode_G29() { mesh_index_pair location; - int i, j, k; + int j, k; float Z1, Z2, Z3; - G29_Verbose_Level = 0; // These may change, but let's get some reasonable values into them. - Repeat_Flag = UBL_OK; - Repetition_Cnt = 1; - C_Flag = false; + g29_verbose_level = 0; // These may change, but let's get some reasonable values into them. + repeat_flag = UBL_OK; + repetition_cnt = 1; + c_flag = false; - SERIAL_PROTOCOLPGM("Unified_Bed_Leveling_EEPROM_start="); - SERIAL_PROTOCOLLN(Unified_Bed_Leveling_EEPROM_start); + SERIAL_PROTOCOLLNPAIR("ubl_eeprom_start=", ubl_eeprom_start); - if (Unified_Bed_Leveling_EEPROM_start < 0) { - SERIAL_PROTOCOLLNPGM("?You need to enable your EEPROM and initialize it "); + if (ubl_eeprom_start < 0) { + SERIAL_PROTOCOLLNPGM("?You need to enable your EEPROM and initialize it"); SERIAL_PROTOCOLLNPGM("with M502, M500, M501 in that order.\n"); return; } @@ -354,14 +331,14 @@ if (!code_seen('N') && axis_unhomed_error(true, true, true)) // Don't allow auto-leveling without homing first gcode_G28(); - if (G29_Parameter_Parsing()) return; // abort if parsing the simple parameters causes a problem, + if (g29_parameter_parsing()) return; // abort if parsing the simple parameters causes a problem, // Invalidate Mesh Points. This command is a little bit asymetrical because // it directly specifies the repetition count and does not use the 'R' parameter. if (code_seen('I')) { - Repetition_Cnt = code_has_value() ? code_value_int() : 1; - while (Repetition_Cnt--) { - location = find_closest_mesh_point_of_type(REAL, X_Pos, Y_Pos, 0, NULL); // The '0' says we want to use the nozzle's position + repetition_cnt = code_has_value() ? code_value_int() : 1; + while (repetition_cnt--) { + location = find_closest_mesh_point_of_type(REAL, x_pos, y_pos, 0, NULL); // The '0' says we want to use the nozzle's position if (location.x_index < 0) { SERIAL_PROTOCOLLNPGM("Entire Mesh invalidated.\n"); break; // No more invalid Mesh Points to populate @@ -373,38 +350,38 @@ if (code_seen('Q')) { - if (code_has_value()) Test_Pattern = code_value_int(); + if (code_has_value()) test_pattern = code_value_int(); - if (Test_Pattern < 0 || Test_Pattern > 4) { - SERIAL_PROTOCOLLNPGM("Invalid Test_Pattern value. (0-4)\n"); + if (test_pattern < 0 || test_pattern > 4) { + SERIAL_PROTOCOLLNPGM("Invalid test_pattern value. (0-4)\n"); return; } - SERIAL_PROTOCOLLNPGM("Loading Test_Pattern values.\n"); - switch (Test_Pattern) { + SERIAL_PROTOCOLLNPGM("Loading test_pattern values.\n"); + switch (test_pattern) { case 0: - for (i = 0; i < UBL_MESH_NUM_X_POINTS; i++) { // Create a bowl shape. This is - for (j = 0; j < UBL_MESH_NUM_Y_POINTS; j++) { // similar to what a user would see with - Z1 = 0.5 * (UBL_MESH_NUM_X_POINTS) - i; // a poorly calibrated Delta. - Z2 = 0.5 * (UBL_MESH_NUM_Y_POINTS) - j; - z_values[i][j] += 2.0 * HYPOT(Z1, Z2); + for (uint8_t x = 0; x < UBL_MESH_NUM_X_POINTS; x++) { // Create a bowl shape. This is + for (uint8_t y = 0; y < UBL_MESH_NUM_Y_POINTS; y++) { // similar to what a user would see with + Z1 = 0.5 * (UBL_MESH_NUM_X_POINTS) - x; // a poorly calibrated Delta. + Z2 = 0.5 * (UBL_MESH_NUM_Y_POINTS) - y; + z_values[x][y] += 2.0 * HYPOT(Z1, Z2); } } break; case 1: - for (i = 0; i < UBL_MESH_NUM_X_POINTS; i++) { // Create a diagonal line several Mesh - z_values[i][i] += 9.999; // cells thick that is raised - if (i < UBL_MESH_NUM_Y_POINTS - 1) - z_values[i][i + 1] += 9.999; // We want the altered line several mesh points thick - if (i > 0) - z_values[i][i - 1] += 9.999; // We want the altered line several mesh points thick + for (uint8_t x = 0; x < UBL_MESH_NUM_X_POINTS; x++) { // Create a diagonal line several Mesh + z_values[x][x] += 9.999; // cells thick that is raised + if (x < UBL_MESH_NUM_Y_POINTS - 1) + z_values[x][x + 1] += 9.999; // We want the altered line several mesh points thick + if (x > 0) + z_values[x][x - 1] += 9.999; // We want the altered line several mesh points thick } break; case 2: // Allow the user to specify the height because 10mm is // a little bit extreme in some cases. - for (i = (UBL_MESH_NUM_X_POINTS) / 3.0; i < 2 * ((UBL_MESH_NUM_X_POINTS) / 3.0); i++) // Create a rectangular raised area in - for (j = (UBL_MESH_NUM_Y_POINTS) / 3.0; j < 2 * ((UBL_MESH_NUM_Y_POINTS) / 3.0); j++) // the center of the bed - z_values[i][j] += code_seen('C') ? Constant : 9.99; + for (uint8_t x = (UBL_MESH_NUM_X_POINTS) / 3; x < 2 * (UBL_MESH_NUM_X_POINTS) / 3; x++) // Create a rectangular raised area in + for (uint8_t y = (UBL_MESH_NUM_Y_POINTS) / 3; y < 2 * (UBL_MESH_NUM_Y_POINTS) / 3; y++) // the center of the bed + z_values[x][y] += code_seen('C') ? constant : 9.99; break; case 3: break; @@ -412,34 +389,34 @@ } if (code_seen('P')) { - Phase_Value = code_value_int(); - if (Phase_Value < 0 || Phase_Value > 7) { + phase_value = code_value_int(); + if (phase_value < 0 || phase_value > 7) { SERIAL_PROTOCOLLNPGM("Invalid Phase value. (0-4)\n"); return; } - switch (Phase_Value) { + switch (phase_value) { // // Zero Mesh Data // case 0: - blm.reset(); + ubl.reset(); SERIAL_PROTOCOLLNPGM("Mesh zeroed.\n"); break; // // Invalidate Entire Mesh and Automatically Probe Mesh in areas that can be reached by the probe // case 1: - if (!code_seen('C') ) { - blm.invalidate(); + if (!code_seen('C') ) { + ubl.invalidate(); SERIAL_PROTOCOLLNPGM("Mesh invalidated. Probing mesh.\n"); } - if (G29_Verbose_Level > 1) { + if (g29_verbose_level > 1) { SERIAL_ECHOPGM("Probing Mesh Points Closest to ("); - SERIAL_ECHO(X_Pos); - SERIAL_ECHOPAIR(",", Y_Pos); + SERIAL_ECHO(x_pos); + SERIAL_ECHOPAIR(",", y_pos); SERIAL_PROTOCOLLNPGM(")\n"); } - probe_entire_mesh( X_Pos+X_PROBE_OFFSET_FROM_EXTRUDER, Y_Pos+Y_PROBE_OFFSET_FROM_EXTRUDER, + probe_entire_mesh( x_pos+X_PROBE_OFFSET_FROM_EXTRUDER, y_pos+Y_PROBE_OFFSET_FROM_EXTRUDER, code_seen('O') || code_seen('M'), code_seen('E')); break; // @@ -448,90 +425,90 @@ case 2: SERIAL_PROTOCOLLNPGM("Manually probing unreachable mesh locations.\n"); do_blocking_move_to_z(Z_CLEARANCE_BETWEEN_PROBES); - if (!X_Flag && !Y_Flag) { // use a good default location for the path - X_Pos = X_MIN_POS; - Y_Pos = Y_MIN_POS; + if (!x_flag && !y_flag) { // use a good default location for the path + x_pos = X_MIN_POS; + y_pos = Y_MIN_POS; if (X_PROBE_OFFSET_FROM_EXTRUDER > 0) // The flipped > and < operators on these two comparisons is - X_Pos = X_MAX_POS; // intentional. It should cause the probed points to follow a + x_pos = X_MAX_POS; // intentional. It should cause the probed points to follow a if (Y_PROBE_OFFSET_FROM_EXTRUDER < 0) // nice path on Cartesian printers. It may make sense to - Y_Pos = Y_MAX_POS; // have Delta printers default to the center of the bed. + y_pos = Y_MAX_POS; // have Delta printers default to the center of the bed. - } // For now, until that is decided, it can be forced with the X - // and Y parameters. + } // For now, until that is decided, it can be forced with the X + // and Y parameters. if (code_seen('C')) { - X_Pos = current_position[X_AXIS]; - Y_Pos = current_position[Y_AXIS]; + x_pos = current_position[X_AXIS]; + y_pos = current_position[Y_AXIS]; } - Height_Value = code_seen('H') && code_has_value() ? code_value_float() : Z_CLEARANCE_BETWEEN_PROBES; + height_value = code_seen('H') && code_has_value() ? code_value_float() : Z_CLEARANCE_BETWEEN_PROBES; - if ((Business_Card_Mode = code_seen('B'))) { - card_thickness = code_has_value() ? code_value_float() : measure_business_card_thickness(Height_Value); + if ((business_card_mode = code_seen('B'))) { + card_thickness = code_has_value() ? code_value_float() : measure_business_card_thickness(height_value); - if (fabs(card_thickness) > 1.5) { + if (fabs(card_thickness) > 1.5) { SERIAL_PROTOCOLLNPGM("?Error in Business Card measurment.\n"); return; } } - manually_probe_remaining_mesh( X_Pos, Y_Pos, Height_Value, card_thickness, code_seen('O') || code_seen('M')); + manually_probe_remaining_mesh(x_pos, y_pos, height_value, card_thickness, code_seen('O') || code_seen('M')); break; // // Populate invalid Mesh areas with a constant // case 3: - Height_Value = 0.0; // Assume 0.0 until proven otherwise - if (code_seen('C')) Height_Value = Constant; + height_value = 0.0; // Assume 0.0 until proven otherwise + if (code_seen('C')) height_value = constant; // If no repetition is specified, do the whole Mesh - if (!Repeat_Flag) Repetition_Cnt = 9999; - while (Repetition_Cnt--) { - location = find_closest_mesh_point_of_type( INVALID, X_Pos, Y_Pos, 0, NULL); // The '0' says we want to use the nozzle's position + if (!repeat_flag) repetition_cnt = 9999; + while (repetition_cnt--) { + location = find_closest_mesh_point_of_type(INVALID, x_pos, y_pos, 0, NULL); // The '0' says we want to use the nozzle's position if (location.x_index < 0) break; // No more invalid Mesh Points to populate - z_values[location.x_index][location.y_index] = Height_Value; + z_values[location.x_index][location.y_index] = height_value; } break; // // Fine Tune (Or Edit) the Mesh // case 4: - fine_tune_mesh(X_Pos, Y_Pos, Height_Value, code_seen('O') || code_seen('M')); + fine_tune_mesh(x_pos, y_pos, code_seen('O') || code_seen('M')); break; case 5: - Find_Mean_Mesh_Height(); + find_mean_mesh_height(); break; case 6: - Shift_Mesh_Height(); + shift_mesh_height(); break; case 10: - UBL_has_control_of_LCD_Panel++; // Debug code... Pay no attention to this stuff - SERIAL_ECHO_START; // it can be removed soon. - SERIAL_ECHOPGM("Checking G29 has control of LCD Panel:\n"); - while(!G29_lcd_clicked()) { + // Debug code... Pay no attention to this stuff + // it can be removed soon. + SERIAL_ECHO_START; + SERIAL_ECHOLNPGM("Checking G29 has control of LCD Panel:"); + wait_for_user = true; + while (wait_for_user) { idle(); delay(250); - SERIAL_PROTOCOL(G29_encoderDiff); - G29_encoderDiff = 0; + SERIAL_ECHO((int)ubl_encoderDiff); + ubl_encoderDiff = 0; SERIAL_EOL; } - while (G29_lcd_clicked()) idle(); - UBL_has_control_of_LCD_Panel = 0;; - SERIAL_ECHOPGM("G29 giving back control of LCD Panel.\n"); + SERIAL_ECHOLNPGM("G29 giving back control of LCD Panel."); break; } } if (code_seen('T')) { - Z1 = probe_pt(ubl_3_point_1_X, ubl_3_point_1_Y, false /*Stow Flag*/, G29_Verbose_Level) + zprobe_zoffset; - Z2 = probe_pt(ubl_3_point_2_X, ubl_3_point_2_Y, false /*Stow Flag*/, G29_Verbose_Level) + zprobe_zoffset; - Z3 = probe_pt(ubl_3_point_3_X, ubl_3_point_3_Y, true /*Stow Flag*/, G29_Verbose_Level) + zprobe_zoffset; + Z1 = probe_pt(ubl_3_point_1_X, ubl_3_point_1_Y, false /*Stow Flag*/, g29_verbose_level) + zprobe_zoffset; + Z2 = probe_pt(ubl_3_point_2_X, ubl_3_point_2_Y, false /*Stow Flag*/, g29_verbose_level) + zprobe_zoffset; + Z3 = probe_pt(ubl_3_point_3_X, ubl_3_point_3_Y, true /*Stow Flag*/, g29_verbose_level) + zprobe_zoffset; // We need to adjust Z1, Z2, Z3 by the Mesh Height at these points. Just because they are non-zero doesn't mean // the Mesh is tilted! (We need to compensate each probe point by what the Mesh says that location's height is) - Z1 -= blm.get_z_correction(ubl_3_point_1_X, ubl_3_point_1_Y); - Z2 -= blm.get_z_correction(ubl_3_point_2_X, ubl_3_point_2_Y); - Z3 -= blm.get_z_correction(ubl_3_point_3_X, ubl_3_point_3_Y); + Z1 -= ubl.get_z_correction(ubl_3_point_1_X, ubl_3_point_1_Y); + Z2 -= ubl.get_z_correction(ubl_3_point_2_X, ubl_3_point_2_Y); + Z3 -= ubl.get_z_correction(ubl_3_point_3_X, ubl_3_point_3_Y); do_blocking_move_to_xy((X_MAX_POS - (X_MIN_POS)) / 2.0, (Y_MAX_POS - (Y_MIN_POS)) / 2.0); tilt_mesh_based_on_3pts(Z1, Z2, Z3); @@ -541,13 +518,13 @@ // Much of the 'What?' command can be eliminated. But until we are fully debugged, it is // good to have the extra information. Soon... we prune this to just a few items // - if (code_seen('W')) G29_What_Command(); + if (code_seen('W')) g29_what_command(); // // When we are fully debugged, the EEPROM dump command will get deleted also. But // right now, it is good to have the extra information. Soon... we prune this. // - if (code_seen('J')) G29_EEPROM_Dump(); // EEPROM Dump + if (code_seen('J')) g29_eeprom_dump(); // EEPROM Dump // // When we are fully debugged, this may go away. But there are some valid @@ -555,26 +532,26 @@ // if (code_seen('K')) // Kompare Current Mesh Data to Specified Stored Mesh - G29_Kompare_Current_Mesh_to_Stored_Mesh(); + g29_compare_current_mesh_to_stored_mesh(); // // Load a Mesh from the EEPROM // if (code_seen('L')) { // Load Current Mesh Data - Storage_Slot = code_has_value() ? code_value_int() : blm.state.EEPROM_storage_slot; + storage_slot = code_has_value() ? code_value_int() : ubl.state.eeprom_storage_slot; - k = E2END - sizeof(blm.state); - j = (k - Unified_Bed_Leveling_EEPROM_start) / sizeof(z_values); + k = E2END - sizeof(ubl.state); + j = (k - ubl_eeprom_start) / sizeof(z_values); - if (Storage_Slot < 0 || Storage_Slot >= j || Unified_Bed_Leveling_EEPROM_start <= 0) { + if (storage_slot < 0 || storage_slot >= j || ubl_eeprom_start <= 0) { SERIAL_PROTOCOLLNPGM("?EEPROM storage not available for use.\n"); return; } - blm.load_mesh(Storage_Slot); - blm.state.EEPROM_storage_slot = Storage_Slot; - if (Storage_Slot != blm.state.EEPROM_storage_slot) - blm.store_state(); + ubl.load_mesh(storage_slot); + ubl.state.eeprom_storage_slot = storage_slot; + if (storage_slot != ubl.state.eeprom_storage_slot) + ubl.store_state(); SERIAL_PROTOCOLLNPGM("Done.\n"); } @@ -583,53 +560,48 @@ // if (code_seen('S')) { // Store (or Save) Current Mesh Data - Storage_Slot = code_has_value() ? code_value_int() : blm.state.EEPROM_storage_slot; + storage_slot = code_has_value() ? code_value_int() : ubl.state.eeprom_storage_slot; - if (Storage_Slot == -1) { // Special case, we are going to 'Export' the mesh to the - SERIAL_ECHOPGM("G29 I 999\n"); // host in a form it can be reconstructed on a different machine - for (i = 0; i < UBL_MESH_NUM_X_POINTS; i++) { - for (j = 0; j < UBL_MESH_NUM_Y_POINTS; j++) { - if (!isnan(z_values[i][j])) { - SERIAL_ECHOPAIR("M421 I ", i); - SERIAL_ECHOPAIR(" J ", j); + if (storage_slot == -1) { // Special case, we are going to 'Export' the mesh to the + SERIAL_ECHOLNPGM("G29 I 999"); // host in a form it can be reconstructed on a different machine + for (uint8_t x = 0; x < UBL_MESH_NUM_X_POINTS; x++) + for (uint8_t y = 0; y < UBL_MESH_NUM_Y_POINTS; y++) + if (!isnan(z_values[x][y])) { + SERIAL_ECHOPAIR("M421 I ", x); + SERIAL_ECHOPAIR(" J ", y); SERIAL_ECHOPGM(" Z "); - SERIAL_PROTOCOL_F(z_values[i][j], 6); + SERIAL_ECHO_F(z_values[x][y], 6); SERIAL_EOL; } - } - } return; } - int k = E2END - sizeof(blm.state), - j = (k - Unified_Bed_Leveling_EEPROM_start) / sizeof(z_values); + int k = E2END - sizeof(ubl.state), + j = (k - ubl_eeprom_start) / sizeof(z_values); - if (Storage_Slot < 0 || Storage_Slot >= j || Unified_Bed_Leveling_EEPROM_start <= 0) { + if (storage_slot < 0 || storage_slot >= j || ubl_eeprom_start <= 0) { SERIAL_PROTOCOLLNPGM("?EEPROM storage not available for use.\n"); SERIAL_PROTOCOLLNPAIR("?Use 0 to ", j - 1); goto LEAVE; } - blm.store_mesh(Storage_Slot); - blm.state.EEPROM_storage_slot = Storage_Slot; + ubl.store_mesh(storage_slot); + ubl.state.eeprom_storage_slot = storage_slot; // - // if (Storage_Slot != blm.state.EEPROM_storage_slot) - blm.store_state(); // Always save an updated copy of the UBL State info + // if (storage_slot != ubl.state.eeprom_storage_slot) + ubl.store_state(); // Always save an updated copy of the UBL State info SERIAL_PROTOCOLLNPGM("Done.\n"); } - if (code_seen('O') || code_seen('M')) { - i = code_has_value() ? code_value_int() : 0; - blm.display_map(i); - } + if (code_seen('O') || code_seen('M')) + ubl.display_map(code_has_value() ? code_value_int() : 0); if (code_seen('Z')) { - if (code_has_value()) { - blm.state.z_offset = code_value_float(); // do the simple case. Just lock in the specified value - } + if (code_has_value()) + ubl.state.z_offset = code_value_float(); // do the simple case. Just lock in the specified value else { - save_UBL_active_state_and_disable(); - //measured_z = probe_pt(X_Pos + X_PROBE_OFFSET_FROM_EXTRUDER, Y_Pos+Y_PROBE_OFFSET_FROM_EXTRUDER, ProbeDeployAndStow, G29_Verbose_Level); + save_ubl_active_state_and_disable(); + //measured_z = probe_pt(x_pos + X_PROBE_OFFSET_FROM_EXTRUDER, y_pos + Y_PROBE_OFFSET_FROM_EXTRUDER, ProbeDeployAndStow, g29_verbose_level); measured_z = 1.5; do_blocking_move_to_z(measured_z); // Get close to the bed, but leave some space so we don't damage anything @@ -637,149 +609,154 @@ // it won't be that painful to spin the Encoder Wheel for 1.5mm lcd_implementation_clear(); lcd_z_offset_edit_setup(measured_z); + wait_for_user = true; do { measured_z = lcd_z_offset_edit(); idle(); do_blocking_move_to_z(measured_z); - } while (!G29_lcd_clicked()); + } while (wait_for_user); - UBL_has_control_of_LCD_Panel = 1; // There is a race condition for the Encoder Wheel getting clicked. - // It could get detected in lcd_mesh_edit (actually _lcd_mesh_fine_tune( ) + ubl_has_control_of_lcd_panel++; // There is a race condition for the Encoder Wheel getting clicked. + // It could get detected in lcd_mesh_edit (actually _lcd_mesh_fine_tune) // or here. So, until we are done looking for a long Encoder Wheel Press, // we need to take control of the panel - millis_t nxt = millis() + 1500UL; + lcd_return_to_status(); - while (G29_lcd_clicked()) { // debounce and watch for abort + + const millis_t nxt = millis() + 1500UL; + while (ubl_lcd_clicked()) { // debounce and watch for abort idle(); if (ELAPSED(millis(), nxt)) { SERIAL_PROTOCOLLNPGM("\nZ-Offset Adjustment Stopped."); do_blocking_move_to_z(Z_CLEARANCE_DEPLOY_PROBE); lcd_setstatus("Z-Offset Stopped", true); - - while (G29_lcd_clicked()) idle(); - - UBL_has_control_of_LCD_Panel = 0; - restore_UBL_active_state_and_leave(); + ubl_has_control_of_lcd_panel = false; + restore_ubl_active_state_and_leave(); goto LEAVE; } } - UBL_has_control_of_LCD_Panel = 0; + ubl_has_control_of_lcd_panel = false; delay(20); // We don't want any switch noise. - blm.state.z_offset = measured_z; + ubl.state.z_offset = measured_z; lcd_implementation_clear(); - restore_UBL_active_state_and_leave(); + restore_ubl_active_state_and_leave(); } } LEAVE: + #if ENABLED(ULTRA_LCD) lcd_setstatus(" ", true); lcd_quick_feedback(); #endif - UBL_has_control_of_LCD_Panel = 0; + + ubl_has_control_of_lcd_panel = false; } - void Find_Mean_Mesh_Height() { - int i, j, n; + void find_mean_mesh_height() { + uint8_t x, y; + int n; float sum, sum_of_diff_squared, sigma, difference, mean; sum = sum_of_diff_squared = 0.0; n = 0; - for (i = 0; i < UBL_MESH_NUM_X_POINTS; i++) { - for (j = 0; j < UBL_MESH_NUM_Y_POINTS; j++) { - if (!isnan(z_values[i][j])) { - sum += z_values[i][j]; + for (x = 0; x < UBL_MESH_NUM_X_POINTS; x++) + for (y = 0; y < UBL_MESH_NUM_Y_POINTS; y++) + if (!isnan(z_values[x][y])) { + sum += z_values[x][y]; n++; } - } - } + mean = sum / n; + // // Now do the sumation of the squares of difference from mean // - for (i = 0; i < UBL_MESH_NUM_X_POINTS; i++) { - for (j = 0; j < UBL_MESH_NUM_Y_POINTS; j++) { - if (!isnan(z_values[i][j])) { - difference = (z_values[i][j] - mean); + for (x = 0; x < UBL_MESH_NUM_X_POINTS; x++) + for (y = 0; y < UBL_MESH_NUM_Y_POINTS; y++) + if (!isnan(z_values[x][y])) { + difference = (z_values[x][y] - mean); sum_of_diff_squared += difference * difference; } - } - } + SERIAL_ECHOLNPAIR("# of samples: ", n); SERIAL_ECHOPGM("Mean Mesh Height: "); - SERIAL_PROTOCOL_F(mean, 6); + SERIAL_ECHO_F(mean, 6); SERIAL_EOL; - sigma = sqrt( sum_of_diff_squared / (n + 1)); + sigma = sqrt(sum_of_diff_squared / (n + 1)); SERIAL_ECHOPGM("Standard Deviation: "); - SERIAL_PROTOCOL_F(sigma, 6); + SERIAL_ECHO_F(sigma, 6); SERIAL_EOL; - if (C_Flag) - for (i = 0; i < UBL_MESH_NUM_X_POINTS; i++) - for (j = 0; j < UBL_MESH_NUM_Y_POINTS; j++) - if (!isnan(z_values[i][j])) - z_values[i][j] -= mean + Constant; + if (c_flag) + for (x = 0; x < UBL_MESH_NUM_X_POINTS; x++) + for (y = 0; y < UBL_MESH_NUM_Y_POINTS; y++) + if (!isnan(z_values[x][y])) + z_values[x][y] -= mean + constant; } - void Shift_Mesh_Height( ) { - for (uint8_t i = 0; i < UBL_MESH_NUM_X_POINTS; i++) - for (uint8_t j = 0; j < UBL_MESH_NUM_Y_POINTS; j++) - if (!isnan(z_values[i][j])) - z_values[i][j] += Constant; + void shift_mesh_height( ) { + for (uint8_t x = 0; x < UBL_MESH_NUM_X_POINTS; x++) + for (uint8_t y = 0; y < UBL_MESH_NUM_Y_POINTS; y++) + if (!isnan(z_values[x][y])) + z_values[x][y] += constant; } - // probe_entire_mesh(X_Pos, Y_Pos) probes all invalidated locations of the mesh that can be reached - // by the probe. It attempts to fill in locations closest to the nozzle's start location first. - - void probe_entire_mesh(float X_Pos, float Y_Pos, bool do_UBL_MESH_Map, bool stow_probe) { + /** + * Probe all invalidated locations of the mesh that can be reached by the probe. + * This attempts to fill in locations closest to the nozzle's start location first. + */ + void probe_entire_mesh(float x_pos, float y_pos, bool do_ubl_mesh_map, bool stow_probe) { mesh_index_pair location; float xProbe, yProbe, measured_z; - UBL_has_control_of_LCD_Panel++; - save_UBL_active_state_and_disable(); // we don't do bed level correction because we want the raw data when we probe + ubl_has_control_of_lcd_panel++; + save_ubl_active_state_and_disable(); // we don't do bed level correction because we want the raw data when we probe DEPLOY_PROBE(); + wait_for_user = true; do { - if (G29_lcd_clicked()) { + if (!wait_for_user) { SERIAL_PROTOCOLLNPGM("\nMesh only partially populated."); lcd_quick_feedback(); - while (G29_lcd_clicked()) idle(); - UBL_has_control_of_LCD_Panel = 0; + ubl_has_control_of_lcd_panel = false; STOW_PROBE(); - restore_UBL_active_state_and_leave(); + restore_ubl_active_state_and_leave(); return; } - location = find_closest_mesh_point_of_type( INVALID, X_Pos, Y_Pos, 1, NULL); // the '1' says we want the location to be relative to the probe - if (location.x_index>=0 && location.y_index>=0) { - xProbe = blm.map_x_index_to_bed_location(location.x_index); - yProbe = blm.map_y_index_to_bed_location(location.y_index); + location = find_closest_mesh_point_of_type(INVALID, x_pos, y_pos, 1, NULL); // the '1' says we want the location to be relative to the probe + if (location.x_index >= 0 && location.y_index >= 0) { + xProbe = ubl.map_x_index_to_bed_location(location.x_index); + yProbe = ubl.map_y_index_to_bed_location(location.y_index); if (xProbe < MIN_PROBE_X || xProbe > MAX_PROBE_X || yProbe < MIN_PROBE_Y || yProbe > MAX_PROBE_Y) { SERIAL_PROTOCOLLNPGM("?Error: Attempt to probe off the bed."); - UBL_has_control_of_LCD_Panel = 0; + ubl_has_control_of_lcd_panel = false; goto LEAVE; } - measured_z = probe_pt(xProbe, yProbe, stow_probe, G29_Verbose_Level); + measured_z = probe_pt(xProbe, yProbe, stow_probe, g29_verbose_level); z_values[location.x_index][location.y_index] = measured_z + Z_PROBE_OFFSET_FROM_EXTRUDER; } - if (do_UBL_MESH_Map) blm.display_map(1); + if (do_ubl_mesh_map) ubl.display_map(1); } while (location.x_index >= 0 && location.y_index >= 0); LEAVE: + + wait_for_user = false; STOW_PROBE(); - restore_UBL_active_state_and_leave(); + restore_ubl_active_state_and_leave(); - X_Pos = constrain( X_Pos-X_PROBE_OFFSET_FROM_EXTRUDER, X_MIN_POS, X_MAX_POS); - Y_Pos = constrain( Y_Pos-Y_PROBE_OFFSET_FROM_EXTRUDER, Y_MIN_POS, Y_MAX_POS); + x_pos = constrain(x_pos - (X_PROBE_OFFSET_FROM_EXTRUDER), X_MIN_POS, X_MAX_POS); + y_pos = constrain(y_pos - (Y_PROBE_OFFSET_FROM_EXTRUDER), Y_MIN_POS, Y_MAX_POS); - do_blocking_move_to_xy(X_Pos, Y_Pos); + do_blocking_move_to_xy(x_pos, y_pos); } - struct vector tilt_mesh_based_on_3pts(float pt1, float pt2, float pt3) { - struct vector v1, v2, normal; + vector tilt_mesh_based_on_3pts(float pt1, float pt2, float pt3) { + vector v1, v2, normal; float c, d, t; int i, j; @@ -799,11 +776,16 @@ // printf("[%f,%f,%f] ", normal.dx, normal.dy, normal.dz); - normal.dx /= normal.dz; // This code does two things. This vector is normal to the tilted plane. - normal.dy /= normal.dz; // However, we don't know its direction. We need it to point up. So if - normal.dz /= normal.dz; // Z is negative, we need to invert the sign of all components of the vector - // We also need Z to be unity because we are going to be treating this triangle - // as the sin() and cos() of the bed's tilt + /** + * This code does two things. This vector is normal to the tilted plane. + * However, we don't know its direction. We need it to point up. So if + * Z is negative, we need to invert the sign of all components of the vector + * We also need Z to be unity because we are going to be treating this triangle + * as the sin() and cos() of the bed's tilt + */ + normal.dx /= normal.dz; + normal.dy /= normal.dz; + normal.dz /= normal.dz; // // All of 3 of these points should give us the same d constant @@ -812,25 +794,25 @@ d = t + normal.dz * pt1; c = d - t; SERIAL_ECHOPGM("d from 1st point: "); - SERIAL_PROTOCOL_F(d, 6); + SERIAL_ECHO_F(d, 6); SERIAL_ECHOPGM(" c: "); - SERIAL_PROTOCOL_F(c, 6); + SERIAL_ECHO_F(c, 6); SERIAL_EOL; t = normal.dx * ubl_3_point_2_X + normal.dy * ubl_3_point_2_Y; d = t + normal.dz * pt2; c = d - t; SERIAL_ECHOPGM("d from 2nd point: "); - SERIAL_PROTOCOL_F(d, 6); + SERIAL_ECHO_F(d, 6); SERIAL_ECHOPGM(" c: "); - SERIAL_PROTOCOL_F(c, 6); + SERIAL_ECHO_F(c, 6); SERIAL_EOL; t = normal.dx * ubl_3_point_3_X + normal.dy * ubl_3_point_3_Y; d = t + normal.dz * pt3; c = d - t; SERIAL_ECHOPGM("d from 3rd point: "); - SERIAL_PROTOCOL_F(d, 6); + SERIAL_ECHO_F(d, 6); SERIAL_ECHOPGM(" c: "); - SERIAL_PROTOCOL_F(c, 6); + SERIAL_ECHO_F(c, 6); SERIAL_EOL; for (i = 0; i < UBL_MESH_NUM_X_POINTS; i++) { @@ -843,77 +825,68 @@ } float use_encoder_wheel_to_measure_point() { - UBL_has_control_of_LCD_Panel++; - while (!G29_lcd_clicked()) { // we need the loop to move the nozzle based on the encoder wheel here! + wait_for_user = true; + while (wait_for_user) { // we need the loop to move the nozzle based on the encoder wheel here! idle(); - if (G29_encoderDiff != 0) { - float new_z; - // We define a new variable so we can know ahead of time where we are trying to go. - // The reason is we want G29_encoderDiff cleared so an interrupt can update it even before the move - // is complete. (So the dial feels responsive to user) - new_z = current_position[Z_AXIS] + 0.01 * float(G29_encoderDiff); - G29_encoderDiff = 0; - do_blocking_move_to_z(new_z); + if (ubl_encoderDiff) { + do_blocking_move_to_z(current_position[Z_AXIS] + 0.01 * float(ubl_encoderDiff)); + ubl_encoderDiff = 0; } } - while (G29_lcd_clicked()) idle(); // debounce and wait - UBL_has_control_of_LCD_Panel--; return current_position[Z_AXIS]; } - float measure_business_card_thickness(float Height_Value) { - float Z1, Z2; + float measure_business_card_thickness(float height_value) { - UBL_has_control_of_LCD_Panel++; - save_UBL_active_state_and_disable(); // we don't do bed level correction because we want the raw data when we probe + ubl_has_control_of_lcd_panel++; + save_ubl_active_state_and_disable(); // we don't do bed level correction because we want the raw data when we probe SERIAL_PROTOCOLLNPGM("Place Shim Under Nozzle and Perform Measurement."); - do_blocking_move_to_z(Height_Value); + do_blocking_move_to_z(height_value); do_blocking_move_to_xy((float(X_MAX_POS) - float(X_MIN_POS)) / 2.0, (float(Y_MAX_POS) - float(Y_MIN_POS)) / 2.0); //, min( planner.max_feedrate_mm_s[X_AXIS], planner.max_feedrate_mm_s[Y_AXIS])/2.0); - Z1 = use_encoder_wheel_to_measure_point(); + const float Z1 = use_encoder_wheel_to_measure_point(); do_blocking_move_to_z(current_position[Z_AXIS] + SIZE_OF_LITTLE_RAISE); - UBL_has_control_of_LCD_Panel = 0; + ubl_has_control_of_lcd_panel = false; SERIAL_PROTOCOLLNPGM("Remove Shim and Measure Bed Height."); - Z2 = use_encoder_wheel_to_measure_point(); + const float Z2 = use_encoder_wheel_to_measure_point(); do_blocking_move_to_z(current_position[Z_AXIS] + SIZE_OF_LITTLE_RAISE); - if (G29_Verbose_Level > 1) { - SERIAL_ECHOPGM("Business Card is: "); + if (g29_verbose_level > 1) { + SERIAL_PROTOCOLPGM("Business Card is: "); SERIAL_PROTOCOL_F(abs(Z1 - Z2), 6); SERIAL_PROTOCOLLNPGM("mm thick."); } - restore_UBL_active_state_and_leave(); + restore_ubl_active_state_and_leave(); return abs(Z1 - Z2); } - void manually_probe_remaining_mesh(float X_Pos, float Y_Pos, float z_clearance, float card_thickness, bool do_UBL_MESH_Map) { + void manually_probe_remaining_mesh(float x_pos, float y_pos, float z_clearance, float card_thickness, bool do_ubl_mesh_map) { mesh_index_pair location; float last_x, last_y, dx, dy, xProbe, yProbe; - unsigned long cnt; - UBL_has_control_of_LCD_Panel++; + ubl_has_control_of_lcd_panel++; last_x = last_y = -9999.99; - save_UBL_active_state_and_disable(); // we don't do bed level correction because we want the raw data when we probe + save_ubl_active_state_and_disable(); // we don't do bed level correction because we want the raw data when we probe do_blocking_move_to_z(z_clearance); - do_blocking_move_to_xy(X_Pos, Y_Pos); + do_blocking_move_to_xy(x_pos, y_pos); do { - if (do_UBL_MESH_Map) blm.display_map(1); + if (do_ubl_mesh_map) ubl.display_map(1); - location = find_closest_mesh_point_of_type(INVALID, X_Pos, Y_Pos, 0, NULL); // The '0' says we want to use the nozzle's position + location = find_closest_mesh_point_of_type(INVALID, x_pos, y_pos, 0, NULL); // The '0' says we want to use the nozzle's position // It doesn't matter if the probe can not reach the // NAN location. This is a manual probe. if (location.x_index < 0 && location.y_index < 0) continue; - xProbe = blm.map_x_index_to_bed_location(location.x_index); - yProbe = blm.map_y_index_to_bed_location(location.y_index); - if (xProbe < (X_MIN_POS) || xProbe > (X_MAX_POS) || yProbe < (Y_MIN_POS) || yProbe > (Y_MAX_POS)) { + xProbe = ubl.map_x_index_to_bed_location(location.x_index); + yProbe = ubl.map_y_index_to_bed_location(location.y_index); + if (xProbe < (X_MIN_POS) || xProbe > (X_MAX_POS) || yProbe < (Y_MIN_POS) || yProbe > (Y_MAX_POS)) { SERIAL_PROTOCOLLNPGM("?Error: Attempt to probe off the bed."); - UBL_has_control_of_LCD_Panel = 0; + ubl_has_control_of_lcd_panel = false; goto LEAVE; } @@ -929,124 +902,120 @@ last_y = yProbe; do_blocking_move_to_xy(xProbe, yProbe); - while (!G29_lcd_clicked()) { // we need the loop to move the nozzle based on the encoder wheel here! + wait_for_user = true; + while (wait_for_user) { // we need the loop to move the nozzle based on the encoder wheel here! idle(); - if (G29_encoderDiff) { - float new_z; - // We define a new variable so we can know ahead of time where we are trying to go. - // The reason is we want G29_encoderDiff cleared so an interrupt can update it even before the move - // is complete. (So the dial feels responsive to user) - new_z = current_position[Z_AXIS] + float(G29_encoderDiff) / 100.0; - G29_encoderDiff = 0; - do_blocking_move_to_z(new_z); + if (ubl_encoderDiff) { + do_blocking_move_to_z(current_position[Z_AXIS] + float(ubl_encoderDiff) / 100.0); + ubl_encoderDiff = 0; } } - cnt = millis(); - while (G29_lcd_clicked()) { // debounce and watch for abort + const millis_t nxt = millis() + 1500L; + while (ubl_lcd_clicked()) { // debounce and watch for abort idle(); - if (millis() - cnt > 1500L) { + if (ELAPSED(millis(), nxt)) { SERIAL_PROTOCOLLNPGM("\nMesh only partially populated."); do_blocking_move_to_z(Z_CLEARANCE_DEPLOY_PROBE); lcd_quick_feedback(); - while (G29_lcd_clicked()) idle(); - UBL_has_control_of_LCD_Panel = 0; - restore_UBL_active_state_and_leave(); + while (ubl_lcd_clicked()) idle(); + ubl_has_control_of_lcd_panel = false; + restore_ubl_active_state_and_leave(); return; } } z_values[location.x_index][location.y_index] = current_position[Z_AXIS] - card_thickness; - if (G29_Verbose_Level > 2) { + if (g29_verbose_level > 2) { SERIAL_PROTOCOL("Mesh Point Measured at: "); SERIAL_PROTOCOL_F(z_values[location.x_index][location.y_index], 6); SERIAL_EOL; } } while (location.x_index >= 0 && location.y_index >= 0); - if (do_UBL_MESH_Map) blm.display_map(1); + if (do_ubl_mesh_map) ubl.display_map(1); LEAVE: - restore_UBL_active_state_and_leave(); + restore_ubl_active_state_and_leave(); do_blocking_move_to_z(Z_CLEARANCE_DEPLOY_PROBE); - do_blocking_move_to_xy(X_Pos, Y_Pos); + do_blocking_move_to_xy(x_pos, y_pos); } - bool G29_Parameter_Parsing() { + bool g29_parameter_parsing() { #if ENABLED(ULTRA_LCD) lcd_setstatus("Doing G29 UBL !", true); lcd_quick_feedback(); #endif - X_Pos = current_position[X_AXIS]; - Y_Pos = current_position[Y_AXIS]; - X_Flag = Y_Flag = Repeat_Flag = UBL_OK; - Constant = 0.0; - Repetition_Cnt = 1; + x_pos = current_position[X_AXIS]; + y_pos = current_position[Y_AXIS]; + x_flag = y_flag = repeat_flag = false; + constant = 0.0; + repetition_cnt = 1; - if ((X_Flag = code_seen('X'))) { - X_Pos = code_value_float(); - if (X_Pos < X_MIN_POS || X_Pos > X_MAX_POS) { + if ((x_flag = code_seen('X'))) { + x_pos = code_value_float(); + if (x_pos < X_MIN_POS || x_pos > X_MAX_POS) { SERIAL_PROTOCOLLNPGM("Invalid X location specified.\n"); return UBL_ERR; } } - if ((Y_Flag = code_seen('Y'))) { - Y_Pos = code_value_float(); - if (Y_Pos < Y_MIN_POS || Y_Pos > Y_MAX_POS) { + if ((y_flag = code_seen('Y'))) { + y_pos = code_value_float(); + if (y_pos < Y_MIN_POS || y_pos > Y_MAX_POS) { SERIAL_PROTOCOLLNPGM("Invalid Y location specified.\n"); return UBL_ERR; } } - if (X_Flag != Y_Flag) { + if (x_flag != y_flag) { SERIAL_PROTOCOLLNPGM("Both X & Y locations must be specified.\n"); return UBL_ERR; } - G29_Verbose_Level = 0; + g29_verbose_level = 0; if (code_seen('V')) { - G29_Verbose_Level = code_value_int(); - if (G29_Verbose_Level < 0 || G29_Verbose_Level > 4) { + g29_verbose_level = code_value_int(); + if (g29_verbose_level < 0 || g29_verbose_level > 4) { SERIAL_PROTOCOLLNPGM("Invalid Verbose Level specified. (0-4)\n"); return UBL_ERR; } } if (code_seen('A')) { // Activate the Unified Bed Leveling System - blm.state.active = 1; + ubl.state.active = 1; SERIAL_PROTOCOLLNPGM("Unified Bed Leveling System activated.\n"); - blm.store_state(); + ubl.store_state(); } - if ((C_Flag = code_seen('C')) && code_has_value()) - Constant = code_value_float(); + if ((c_flag = code_seen('C')) && code_has_value()) + constant = code_value_float(); if (code_seen('D')) { // Disable the Unified Bed Leveling System - blm.state.active = 0; + ubl.state.active = 0; SERIAL_PROTOCOLLNPGM("Unified Bed Leveling System de-activated.\n"); - blm.store_state(); + ubl.store_state(); } if (code_seen('F')) { - blm.state.G29_Correction_Fade_Height = 10.00; + ubl.state.g29_correction_fade_height = 10.00; if (code_has_value()) { - blm.state.G29_Correction_Fade_Height = code_value_float(); - blm.state.G29_Fade_Height_Multiplier = 1.0 / blm.state.G29_Correction_Fade_Height; + ubl.state.g29_correction_fade_height = code_value_float(); + ubl.state.g29_fade_height_multiplier = 1.0 / ubl.state.g29_correction_fade_height; } - if (blm.state.G29_Correction_Fade_Height<0.0 || blm.state.G29_Correction_Fade_Height>100.0) { - SERIAL_PROTOCOLLNPGM("?Bed Level Correction Fade Height Not Plausable.\n"); - blm.state.G29_Correction_Fade_Height = 10.00; - blm.state.G29_Fade_Height_Multiplier = 1.0 / blm.state.G29_Correction_Fade_Height; + if (ubl.state.g29_correction_fade_height < 0.0 || ubl.state.g29_correction_fade_height > 100.0) { + SERIAL_PROTOCOLLNPGM("?Bed Level Correction Fade Height Not Plausible.\n"); + ubl.state.g29_correction_fade_height = 10.00; + ubl.state.g29_fade_height_multiplier = 1.0 / ubl.state.g29_correction_fade_height; return UBL_ERR; } } - if ((Repeat_Flag = code_seen('R'))) { - Repetition_Cnt = code_has_value() ? code_value_int() : 9999; - if (Repetition_Cnt < 1) { + if ((repeat_flag = code_seen('R'))) { + repetition_cnt = code_has_value() ? code_value_int() : 9999; + if (repetition_cnt < 1) { SERIAL_PROTOCOLLNPGM("Invalid Repetition count.\n"); return UBL_ERR; } @@ -1064,7 +1033,7 @@ SERIAL_PROTOCOL(str); SERIAL_PROTOCOL_F(f, 8); SERIAL_PROTOCOL(" "); - ptr = (char *)&f; + ptr = (char*)&f; for (uint8_t i = 0; i < 4; i++) { SERIAL_PROTOCOL(" "); prt_hex_byte(*ptr++); @@ -1081,95 +1050,98 @@ SERIAL_EOL; } - static int UBL_state_at_invokation = 0, - UBL_state_recursion_chk = 0; + static int ubl_state_at_invocation = 0, + ubl_state_recursion_chk = 0; - void save_UBL_active_state_and_disable() { - UBL_state_recursion_chk++; - if (UBL_state_recursion_chk != 1) { - SERIAL_ECHOLNPGM("save_UBL_active_state_and_disabled() called multiple times in a row."); + void save_ubl_active_state_and_disable() { + ubl_state_recursion_chk++; + if (ubl_state_recursion_chk != 1) { + SERIAL_ECHOLNPGM("save_ubl_active_state_and_disabled() called multiple times in a row."); lcd_setstatus("save_UBL_active() error", true); lcd_quick_feedback(); return; } - UBL_state_at_invokation = blm.state.active; - blm.state.active = 0; + ubl_state_at_invocation = ubl.state.active; + ubl.state.active = 0; return; } - void restore_UBL_active_state_and_leave() { - if (--UBL_state_recursion_chk) { - SERIAL_ECHOLNPGM("restore_UBL_active_state_and_leave() called too many times."); + void restore_ubl_active_state_and_leave() { + if (--ubl_state_recursion_chk) { + SERIAL_ECHOLNPGM("restore_ubl_active_state_and_leave() called too many times."); lcd_setstatus("restore_UBL_active() error", true); lcd_quick_feedback(); return; } - blm.state.active = UBL_state_at_invokation; + ubl.state.active = ubl_state_at_invocation; + } + + void g29_print_line(bool longer=false) { + SERIAL_PROTOCOLPGM(" -------------------------------------"); + if (longer) SERIAL_PROTOCOLPGM("-------------------"); + SERIAL_PROTOCOLLNPGM(" <----<<<"); } /** * Much of the 'What?' command can be eliminated. But until we are fully debugged, it is * good to have the extra information. Soon... we prune this to just a few items */ - void G29_What_Command() { - int k, i; - k = E2END - Unified_Bed_Leveling_EEPROM_start; - Statistics_Flag++; + void g29_what_command() { + int k = E2END - ubl_eeprom_start; + statistics_flag++; - SERIAL_PROTOCOLPGM("Version #4: 10/30/2016 branch \n"); + SERIAL_PROTOCOLLNPGM("Version #4: 10/30/2016 branch"); SERIAL_PROTOCOLPGM("Unified Bed Leveling System "); - if (blm.state.active) + if (ubl.state.active) SERIAL_PROTOCOLPGM("Active."); else SERIAL_PROTOCOLPGM("Inactive."); - SERIAL_PROTOCOLLNPGM(" ------------------------------------- <----<<<"); // These arrows are just to help me + g29_print_line(); // These are just to help me find this info buried in the clutter - if (blm.state.EEPROM_storage_slot == 0xFFFF) { + if (ubl.state.eeprom_storage_slot == 0xFFFF) { SERIAL_PROTOCOLPGM("No Mesh Loaded."); - SERIAL_PROTOCOLLNPGM(" ------------------------------------- <----<<<"); // These arrows are just to help me - // find this info buried in the clutter + g29_print_line(); // These are just to help me find this info buried in the clutter } else { SERIAL_PROTOCOLPGM("Mesh: "); - prt_hex_word(blm.state.EEPROM_storage_slot); + prt_hex_word(ubl.state.eeprom_storage_slot); SERIAL_PROTOCOLPGM(" Loaded. "); - SERIAL_PROTOCOLLNPGM(" -------------------------------------------------------- <----<<<"); // These arrows are just to help me - // find this info buried in the clutter + g29_print_line(true); // These are just to help me find this info buried in the clutter } - SERIAL_ECHOPAIR("\nG29_Correction_Fade_Height : ", blm.state.G29_Correction_Fade_Height ); - SERIAL_PROTOCOLPGM(" ------------------------------------- <----<<< \n"); // These arrows are just to help me - // find this info buried in the clutter + SERIAL_PROTOCOLPAIR("\ng29_correction_fade_height : ", ubl.state.g29_correction_fade_height ); + g29_print_line(); // These are just to help me find this info buried in the clutter + idle(); - SERIAL_ECHOPGM("z_offset: "); - SERIAL_PROTOCOL_F(blm.state.z_offset, 6); - SERIAL_PROTOCOLLNPGM(" ------------------------------------------------------------ <----<<<"); + SERIAL_PROTOCOLPGM("z_offset: "); + SERIAL_PROTOCOL_F(ubl.state.z_offset, 6); + g29_print_line(true); // These are just to help me find this info buried in the clutter SERIAL_PROTOCOLPGM("X-Axis Mesh Points at: "); - for (i = 0; i < UBL_MESH_NUM_X_POINTS; i++) { - SERIAL_PROTOCOL_F( blm.map_x_index_to_bed_location(i), 1); + for (uint8_t i = 0; i < UBL_MESH_NUM_X_POINTS; i++) { + SERIAL_PROTOCOL_F( ubl.map_x_index_to_bed_location(i), 1); SERIAL_PROTOCOLPGM(" "); } SERIAL_EOL; SERIAL_PROTOCOLPGM("Y-Axis Mesh Points at: "); - for (i = 0; i < UBL_MESH_NUM_Y_POINTS; i++) { - SERIAL_PROTOCOL_F( blm.map_y_index_to_bed_location(i), 1); + for (uint8_t i = 0; i < UBL_MESH_NUM_Y_POINTS; i++) { + SERIAL_PROTOCOL_F( ubl.map_y_index_to_bed_location(i), 1); SERIAL_PROTOCOLPGM(" "); } SERIAL_EOL; #if HAS_KILL - SERIAL_ECHOPAIR("Kill pin on :", KILL_PIN); - SERIAL_ECHOLNPAIR(" state:", READ(KILL_PIN)); + SERIAL_PROTOCOLPAIR("Kill pin on :", KILL_PIN); + SERIAL_PROTOCOLLNPAIR(" state:", READ(KILL_PIN)); #endif - SERIAL_ECHOLNPAIR("UBL_state_at_invokation :", UBL_state_at_invokation); - SERIAL_ECHOLNPAIR("UBL_state_recursion_chk :", UBL_state_recursion_chk); + SERIAL_PROTOCOLLNPAIR("ubl_state_at_invocation :", ubl_state_at_invocation); + SERIAL_PROTOCOLLNPAIR("ubl_state_recursion_chk :", ubl_state_recursion_chk); SERIAL_EOL; SERIAL_PROTOCOLPGM("Free EEPROM space starts at: 0x"); - prt_hex_word(Unified_Bed_Leveling_EEPROM_start); + prt_hex_word(ubl_eeprom_start); SERIAL_EOL; idle(); @@ -1178,7 +1150,7 @@ SERIAL_EOL; idle(); - SERIAL_PROTOCOLLNPAIR("sizeof(blm) : ", (int)sizeof(blm)); + SERIAL_PROTOCOLLNPAIR("sizeof(ubl) : ", (int)sizeof(ubl)); SERIAL_EOL; SERIAL_PROTOCOLLNPAIR("z_value[][] size: ", (int)sizeof(z_values)); SERIAL_EOL; @@ -1190,45 +1162,45 @@ SERIAL_PROTOCOLPGM("EEPROM can hold 0x"); prt_hex_word(k / sizeof(z_values)); - SERIAL_PROTOCOLPGM(" meshes. \n"); + SERIAL_PROTOCOLLNPGM(" meshes."); SERIAL_PROTOCOLPGM("sizeof(stat) :"); - prt_hex_word(sizeof(blm.state)); + prt_hex_word(sizeof(ubl.state)); SERIAL_EOL; idle(); - SERIAL_ECHOPAIR("\nUBL_MESH_NUM_X_POINTS ", UBL_MESH_NUM_X_POINTS); - SERIAL_ECHOPAIR("\nUBL_MESH_NUM_Y_POINTS ", UBL_MESH_NUM_Y_POINTS); - SERIAL_ECHOPAIR("\nUBL_MESH_MIN_X ", UBL_MESH_MIN_X); - SERIAL_ECHOPAIR("\nUBL_MESH_MIN_Y ", UBL_MESH_MIN_Y); - SERIAL_ECHOPAIR("\nUBL_MESH_MAX_X ", UBL_MESH_MAX_X); - SERIAL_ECHOPAIR("\nUBL_MESH_MAX_Y ", UBL_MESH_MAX_Y); - SERIAL_ECHOPGM("\nMESH_X_DIST "); + SERIAL_PROTOCOLPAIR("\nUBL_MESH_NUM_X_POINTS ", UBL_MESH_NUM_X_POINTS); + SERIAL_PROTOCOLPAIR("\nUBL_MESH_NUM_Y_POINTS ", UBL_MESH_NUM_Y_POINTS); + SERIAL_PROTOCOLPAIR("\nUBL_MESH_MIN_X ", UBL_MESH_MIN_X); + SERIAL_PROTOCOLPAIR("\nUBL_MESH_MIN_Y ", UBL_MESH_MIN_Y); + SERIAL_PROTOCOLPAIR("\nUBL_MESH_MAX_X ", UBL_MESH_MAX_X); + SERIAL_PROTOCOLPAIR("\nUBL_MESH_MAX_Y ", UBL_MESH_MAX_Y); + SERIAL_PROTOCOLPGM("\nMESH_X_DIST "); SERIAL_PROTOCOL_F(MESH_X_DIST, 6); - SERIAL_ECHOPGM("\nMESH_Y_DIST "); + SERIAL_PROTOCOLPGM("\nMESH_Y_DIST "); SERIAL_PROTOCOL_F(MESH_Y_DIST, 6); SERIAL_EOL; idle(); - SERIAL_ECHOPAIR("\nsizeof(block_t): ", (int)sizeof(block_t)); - SERIAL_ECHOPAIR("\nsizeof(planner.block_buffer): ", (int)sizeof(planner.block_buffer)); - SERIAL_ECHOPAIR("\nsizeof(char): ", (int)sizeof(char)); - SERIAL_ECHOPAIR(" sizeof(unsigned char): ", (int)sizeof(unsigned char)); - SERIAL_ECHOPAIR("\nsizeof(int): ", (int)sizeof(int)); - SERIAL_ECHOPAIR(" sizeof(unsigned int): ", (int)sizeof(unsigned int)); - SERIAL_ECHOPAIR("\nsizeof(long): ", (int)sizeof(long)); - SERIAL_ECHOPAIR(" sizeof(unsigned long int): ", (int)sizeof(unsigned long int)); - SERIAL_ECHOPAIR("\nsizeof(float): ", (int)sizeof(float)); - SERIAL_ECHOPAIR(" sizeof(double): ", (int)sizeof(double)); - SERIAL_ECHOPAIR("\nsizeof(void *): ", (int)sizeof(void *)); + SERIAL_PROTOCOLPAIR("\nsizeof(block_t): ", (int)sizeof(block_t)); + SERIAL_PROTOCOLPAIR("\nsizeof(planner.block_buffer): ", (int)sizeof(planner.block_buffer)); + SERIAL_PROTOCOLPAIR("\nsizeof(char): ", (int)sizeof(char)); + SERIAL_PROTOCOLPAIR(" sizeof(unsigned char): ", (int)sizeof(unsigned char)); + SERIAL_PROTOCOLPAIR("\nsizeof(int): ", (int)sizeof(int)); + SERIAL_PROTOCOLPAIR(" sizeof(unsigned int): ", (int)sizeof(unsigned int)); + SERIAL_PROTOCOLPAIR("\nsizeof(long): ", (int)sizeof(long)); + SERIAL_PROTOCOLPAIR(" sizeof(unsigned long int): ", (int)sizeof(unsigned long int)); + SERIAL_PROTOCOLPAIR("\nsizeof(float): ", (int)sizeof(float)); + SERIAL_PROTOCOLPAIR(" sizeof(double): ", (int)sizeof(double)); + SERIAL_PROTOCOLPAIR("\nsizeof(void *): ", (int)sizeof(void *)); struct pf { void *p_f(); } ptr_func; - SERIAL_ECHOPAIR(" sizeof(struct pf): ", (int)sizeof(pf)); - SERIAL_ECHOPAIR(" sizeof(void *()): ", (int)sizeof(ptr_func)); + SERIAL_PROTOCOLPAIR(" sizeof(struct pf): ", (int)sizeof(pf)); + SERIAL_PROTOCOLPAIR(" sizeof(void *()): ", (int)sizeof(ptr_func)); SERIAL_EOL; idle(); - if (!blm.sanity_check()) + if (!ubl.sanity_check()) SERIAL_PROTOCOLLNPGM("Unified Bed Leveling sanity checks passed."); } @@ -1236,17 +1208,17 @@ * When we are fully debugged, the EEPROM dump command will get deleted also. But * right now, it is good to have the extra information. Soon... we prune this. */ - void G29_EEPROM_Dump() { + void g29_eeprom_dump() { unsigned char cccc; - int i, j, kkkk; + uint16_t kkkk; SERIAL_ECHO_START; - SERIAL_ECHOPGM("EEPROM Dump:\n"); - for (i = 0; i < E2END + 1; i += 16) { + SERIAL_ECHOLNPGM("EEPROM Dump:"); + for (uint16_t i = 0; i < E2END + 1; i += 16) { if (i & 0x3 == 0) idle(); prt_hex_word(i); SERIAL_ECHOPGM(": "); - for (j = 0; j < 16; j++) { + for (uint16_t j = 0; j < 16; j++) { kkkk = i + j; eeprom_read_block(&cccc, (void *)kkkk, 1); prt_hex_byte(cccc); @@ -1262,41 +1234,40 @@ * When we are fully debugged, this may go away. But there are some valid * use cases for the users. So we can wait and see what to do with it. */ - void G29_Kompare_Current_Mesh_to_Stored_Mesh() { + void g29_compare_current_mesh_to_stored_mesh() { float tmp_z_values[UBL_MESH_NUM_X_POINTS][UBL_MESH_NUM_Y_POINTS]; - int i, j, k; if (!code_has_value()) { SERIAL_PROTOCOLLNPGM("?Mesh # required.\n"); return; } - Storage_Slot = code_value_int(); + storage_slot = code_value_int(); - k = E2END - sizeof(blm.state); - j = (k - Unified_Bed_Leveling_EEPROM_start) / sizeof(tmp_z_values); + uint16_t k = E2END - sizeof(ubl.state), + j = (k - ubl_eeprom_start) / sizeof(tmp_z_values); - if (Storage_Slot < 0 || Storage_Slot > j || Unified_Bed_Leveling_EEPROM_start <= 0) { + if (storage_slot < 0 || storage_slot > j || ubl_eeprom_start <= 0) { SERIAL_PROTOCOLLNPGM("?EEPROM storage not available for use.\n"); return; } - j = k - (Storage_Slot + 1) * sizeof(tmp_z_values); + j = k - (storage_slot + 1) * sizeof(tmp_z_values); eeprom_read_block((void *)&tmp_z_values, (void *)j, sizeof(tmp_z_values)); - SERIAL_ECHOPAIR("Subtracting Mesh ", Storage_Slot); + SERIAL_ECHOPAIR("Subtracting Mesh ", storage_slot); SERIAL_PROTOCOLPGM(" loaded from EEPROM address "); // Soon, we can remove the extra clutter of printing prt_hex_word(j); // the address in the EEPROM where the Mesh is stored. SERIAL_EOL; - for (i = 0; i < UBL_MESH_NUM_X_POINTS; i++) - for (j = 0; j < UBL_MESH_NUM_Y_POINTS; j++) - z_values[i][j] = z_values[i][j] - tmp_z_values[i][j]; + for (uint8_t x = 0; x < UBL_MESH_NUM_X_POINTS; x++) + for (uint8_t y = 0; y < UBL_MESH_NUM_Y_POINTS; y++) + z_values[x][y] = z_values[x][y] - tmp_z_values[x][y]; } - mesh_index_pair find_closest_mesh_point_of_type(Mesh_Point_Type type, float X, float Y, bool probe_as_reference, unsigned int bits[16]) { + mesh_index_pair find_closest_mesh_point_of_type(MeshPointType type, float X, float Y, bool probe_as_reference, unsigned int bits[16]) { int i, j; - float f, px, py, mx, my, dx, dy, closest = 99999.99; - float current_x, current_y, distance; + float f, px, py, mx, my, dx, dy, closest = 99999.99, + current_x, current_y, distance; mesh_index_pair return_val; return_val.x_index = return_val.y_index = -1; @@ -1321,8 +1292,8 @@ // We only get here if we found a Mesh Point of the specified type - mx = blm.map_x_index_to_bed_location(i); // Check if we can probe this mesh location - my = blm.map_y_index_to_bed_location(j); + mx = ubl.map_x_index_to_bed_location(i); // Check if we can probe this mesh location + my = ubl.map_y_index_to_bed_location(j); // If we are using the probe as the reference there are some locations we can't get to. // We prune these out of the list and ignore them until the next Phase where we do the @@ -1352,13 +1323,13 @@ return return_val; } - void fine_tune_mesh(float X_Pos, float Y_Pos, float Height_Value, bool do_UBL_MESH_Map) { + void fine_tune_mesh(float x_pos, float y_pos, bool do_ubl_mesh_map) { mesh_index_pair location; - float xProbe, yProbe, new_z; + float xProbe, yProbe; uint16_t i, not_done[16]; - long round_off; + int32_t round_off; - save_UBL_active_state_and_disable(); + save_ubl_active_state_and_disable(); memset(not_done, 0xFF, sizeof(not_done)); #if ENABLED(ULTRA_LCD) @@ -1366,11 +1337,11 @@ #endif do_blocking_move_to_z(Z_CLEARANCE_DEPLOY_PROBE); - do_blocking_move_to_xy(X_Pos, Y_Pos); + do_blocking_move_to_xy(x_pos, y_pos); do { - if (do_UBL_MESH_Map) blm.display_map(1); + if (do_ubl_mesh_map) ubl.display_map(1); - location = find_closest_mesh_point_of_type( SET_IN_BITMAP, X_Pos, Y_Pos, 0, not_done); // The '0' says we want to use the nozzle's position + location = find_closest_mesh_point_of_type( SET_IN_BITMAP, x_pos, y_pos, 0, not_done); // The '0' says we want to use the nozzle's position // It doesn't matter if the probe can not reach this // location. This is a manual edit of the Mesh Point. if (location.x_index < 0 && location.y_index < 0) continue; // abort if we can't find any more points. @@ -1378,21 +1349,21 @@ bit_clear(not_done, location.x_index, location.y_index); // Mark this location as 'adjusted' so we will find a // different location the next time through the loop - xProbe = blm.map_x_index_to_bed_location(location.x_index); - yProbe = blm.map_y_index_to_bed_location(location.y_index); + xProbe = ubl.map_x_index_to_bed_location(location.x_index); + yProbe = ubl.map_y_index_to_bed_location(location.y_index); if (xProbe < X_MIN_POS || xProbe > X_MAX_POS || yProbe < Y_MIN_POS || yProbe > Y_MAX_POS) { // In theory, we don't need this check. SERIAL_PROTOCOLLNPGM("?Error: Attempt to edit off the bed."); // This really can't happen, but for now, - UBL_has_control_of_LCD_Panel = 0; // Let's do the check. + ubl_has_control_of_lcd_panel = false; // Let's do the check. goto FINE_TUNE_EXIT; } do_blocking_move_to_z(Z_CLEARANCE_DEPLOY_PROBE); // Move the nozzle to where we are going to edit do_blocking_move_to_xy(xProbe, yProbe); - new_z = z_values[location.x_index][location.y_index] + 0.001; + float new_z = z_values[location.x_index][location.y_index] + 0.001; round_off = (int32_t)(new_z * 1000.0 + 2.5); // we chop off the last digits just to be clean. We are rounding to the round_off -= (round_off % 5L); // closest 0 or 5 at the 3rd decimal place. - new_z = ((float)(round_off)) / 1000.0; + new_z = float(round_off) / 1000.0; //SERIAL_ECHOPGM("Mesh Point Currently At: "); //SERIAL_PROTOCOL_F(new_z, 6); @@ -1400,18 +1371,21 @@ lcd_implementation_clear(); lcd_mesh_edit_setup(new_z); - UBL_has_control_of_LCD_Panel++; + + wait_for_user = true; do { new_z = lcd_mesh_edit(); idle(); - } while (!G29_lcd_clicked()); + } while (wait_for_user); - UBL_has_control_of_LCD_Panel = 1; // There is a race condition for the Encoder Wheel getting clicked. - // It could get detected in lcd_mesh_edit (actually _lcd_mesh_fine_tune( ) - // or here. - millis_t nxt = millis() + 1500UL; lcd_return_to_status(); - while (G29_lcd_clicked()) { // debounce and watch for abort + + ubl_has_control_of_lcd_panel++; // There is a race condition for the Encoder Wheel getting clicked. + // It could get detected in lcd_mesh_edit (actually _lcd_mesh_fine_tune) + // or here. + + const millis_t nxt = millis() + 1500UL; + while (ubl_lcd_clicked()) { // debounce and watch for abort idle(); if (ELAPSED(millis(), nxt)) { lcd_return_to_status(); @@ -1419,30 +1393,30 @@ do_blocking_move_to_z(Z_CLEARANCE_DEPLOY_PROBE); lcd_setstatus("Mesh Editing Stopped", true); - while (G29_lcd_clicked()) idle(); + while (ubl_lcd_clicked()) idle(); - UBL_has_control_of_LCD_Panel = 0; + ubl_has_control_of_lcd_panel = false; goto FINE_TUNE_EXIT; } } - //UBL_has_control_of_LCD_Panel = 0; + delay(20); // We don't want any switch noise. z_values[location.x_index][location.y_index] = new_z; lcd_implementation_clear(); - } while (location.x_index >= 0 && location.y_index >= 0 && --Repetition_Cnt); + } while (location.x_index >= 0 && location.y_index >= 0 && --repetition_cnt); FINE_TUNE_EXIT: - if (do_UBL_MESH_Map) blm.display_map(1); - restore_UBL_active_state_and_leave(); + ubl_has_control_of_lcd_panel = false; + + if (do_ubl_mesh_map) ubl.display_map(1); + restore_ubl_active_state_and_leave(); do_blocking_move_to_z(Z_CLEARANCE_DEPLOY_PROBE); - do_blocking_move_to_xy(X_Pos, Y_Pos); - - UBL_has_control_of_LCD_Panel = 0; + do_blocking_move_to_xy(x_pos, y_pos); #if ENABLED(ULTRA_LCD) lcd_setstatus("Done Editing Mesh", true); diff --git a/Marlin/UBL_line_to_destination.cpp b/Marlin/UBL_line_to_destination.cpp index bb3956dc38..2b3b1988f9 100644 --- a/Marlin/UBL_line_to_destination.cpp +++ b/Marlin/UBL_line_to_destination.cpp @@ -19,116 +19,118 @@ * along with this program. If not, see . * */ -#include "Marlin.h" +#include "MarlinConfig.h" #if ENABLED(AUTO_BED_LEVELING_UBL) + #include "Marlin.h" #include "UBL.h" #include "planner.h" #include #include extern void set_current_to_destination(); - extern bool G26_Debug_flag; - void debug_current_and_destination(char *title); + extern void debug_current_and_destination(char *title); - void wait_for_button_press(); + void ubl_line_to_destination(const float &x_end, const float &y_end, const float &z_end, const float &e_end, const float &feed_rate, uint8_t extruder) { - void UBL_line_to_destination(const float &x_end, const float &y_end, const float &z_end, const float &e_end, const float &feed_rate, uint8_t extruder) { + int cell_start_xi, cell_start_yi, cell_dest_xi, cell_dest_yi, + current_xi, current_yi, + dxi, dyi, xi_cnt, yi_cnt; + float x_start, y_start, + x, y, z1, z2, z0 /*, z_optimized */, + next_mesh_line_x, next_mesh_line_y, a0ma1diva2ma1, + on_axis_distance, e_normalized_dist, e_position, e_start, z_normalized_dist, z_position, z_start, + dx, dy, adx, ady, m, c; - int cell_start_xi, cell_start_yi, cell_dest_xi, cell_dest_yi; - int left_flag, down_flag; - int current_xi, current_yi; - int dxi, dyi, xi_cnt, yi_cnt; - bool use_X_dist, inf_normalized_flag, inf_m_flag; - float x_start, y_start; - float x, y, z1, z2, z0 /*, z_optimized */; - float next_mesh_line_x, next_mesh_line_y, a0ma1diva2ma1; - float on_axis_distance, e_normalized_dist, e_position, e_start, z_normalized_dist, z_position, z_start; - float dx, dy, adx, ady, m, c; - - // - // Much of the nozzle movement will be within the same cell. So we will do as little computation - // as possible to determine if this is the case. If this move is within the same cell, we will - // just do the required Z-Height correction, call the Planner's buffer_line() routine, and leave - // + /** + * Much of the nozzle movement will be within the same cell. So we will do as little computation + * as possible to determine if this is the case. If this move is within the same cell, we will + * just do the required Z-Height correction, call the Planner's buffer_line() routine, and leave + */ x_start = current_position[X_AXIS]; y_start = current_position[Y_AXIS]; z_start = current_position[Z_AXIS]; e_start = current_position[E_AXIS]; - cell_start_xi = blm.get_cell_index_x(x_start); - cell_start_yi = blm.get_cell_index_y(y_start); - cell_dest_xi = blm.get_cell_index_x(x_end); - cell_dest_yi = blm.get_cell_index_y(y_end); + cell_start_xi = ubl.get_cell_index_x(x_start); + cell_start_yi = ubl.get_cell_index_y(y_start); + cell_dest_xi = ubl.get_cell_index_x(x_end); + cell_dest_yi = ubl.get_cell_index_y(y_end); - if (G26_Debug_flag!=0) { - SERIAL_ECHOPGM(" UBL_line_to_destination(xe="); + if (g26_debug_flag) { + SERIAL_ECHOPGM(" ubl_line_to_destination(xe="); SERIAL_ECHO(x_end); - SERIAL_ECHOPGM(",ye="); + SERIAL_ECHOPGM(", ye="); SERIAL_ECHO(y_end); - SERIAL_ECHOPGM(",ze="); + SERIAL_ECHOPGM(", ze="); SERIAL_ECHO(z_end); - SERIAL_ECHOPGM(",ee="); + SERIAL_ECHOPGM(", ee="); SERIAL_ECHO(e_end); SERIAL_ECHOPGM(")\n"); - debug_current_and_destination( (char *) "Start of UBL_line_to_destination()"); + debug_current_and_destination((char*)"Start of ubl_line_to_destination()"); } - if ((cell_start_xi == cell_dest_xi) && (cell_start_yi == cell_dest_yi)) { // if the whole move is within the same cell, - // we don't need to break up the move - // - // If we are moving off the print bed, we are going to allow the move at this level. - // But we detect it and isolate it. For now, we just pass along the request. - // + if (cell_start_xi == cell_dest_xi && cell_start_yi == cell_dest_yi) { // if the whole move is within the same cell, + /** + * we don't need to break up the move + * + * If we are moving off the print bed, we are going to allow the move at this level. + * But we detect it and isolate it. For now, we just pass along the request. + */ - if (cell_dest_xi<0 || cell_dest_yi<0 || cell_dest_xi >= UBL_MESH_NUM_X_POINTS || cell_dest_yi >= UBL_MESH_NUM_Y_POINTS) { + if (cell_dest_xi < 0 || cell_dest_yi < 0 || cell_dest_xi >= UBL_MESH_NUM_X_POINTS || cell_dest_yi >= UBL_MESH_NUM_Y_POINTS) { - // Note: There is no Z Correction in this case. We are off the grid and don't know what + // Note: There is no Z Correction in this case. We are off the grid and don't know what // a reasonable correction would be. - planner.buffer_line(x_end, y_end, z_end + blm.state.z_offset, e_end, feed_rate, extruder); + planner.buffer_line(x_end, y_end, z_end + ubl.state.z_offset, e_end, feed_rate, extruder); set_current_to_destination(); - if (G26_Debug_flag!=0) { - debug_current_and_destination( (char *) "out of bounds in UBL_line_to_destination()"); - } + + if (g26_debug_flag) + debug_current_and_destination((char*)"out of bounds in ubl_line_to_destination()"); + return; } - // we can optimize some floating point operations here. We could call float get_z_correction(float x0, float y0) to - // generate the correction for us. But we can lighten the load on the CPU by doing a modified version of the function. - // We are going to only calculate the amount we are from the first mesh line towards the second mesh line once. - // We will use this fraction in both of the original two Z Height calculations for the bi-linear interpolation. And, - // instead of doing a generic divide of the distance, we know the distance is MESH_X_DIST so we can use the preprocessor - // to create a 1-over number for us. That will allow us to do a floating point multiply instead of a floating point divide. - FINAL_MOVE: - a0ma1diva2ma1 = (x_end - mesh_index_to_X_location[cell_dest_xi]) * (float) (1.0 / MESH_X_DIST); - z1 = z_values[cell_dest_xi][cell_dest_yi] + - (z_values[cell_dest_xi + 1][cell_dest_yi] - z_values[cell_dest_xi][cell_dest_yi]) * a0ma1diva2ma1; + /** + * Optimize some floating point operations here. We could call float get_z_correction(float x0, float y0) to + * generate the correction for us. But we can lighten the load on the CPU by doing a modified version of the function. + * We are going to only calculate the amount we are from the first mesh line towards the second mesh line once. + * We will use this fraction in both of the original two Z Height calculations for the bi-linear interpolation. And, + * instead of doing a generic divide of the distance, we know the distance is MESH_X_DIST so we can use the preprocessor + * to create a 1-over number for us. That will allow us to do a floating point multiply instead of a floating point divide. + */ - z2 = z_values[cell_dest_xi][cell_dest_yi+1] + - (z_values[cell_dest_xi+1][cell_dest_yi+1] - z_values[cell_dest_xi][cell_dest_yi+1]) * a0ma1diva2ma1; + a0ma1diva2ma1 = (x_end - mesh_index_to_x_location[cell_dest_xi]) * 0.1 * (MESH_X_DIST); - // we are done with the fractional X distance into the cell. Now with the two Z-Heights we have calculated, we + z1 = z_values[cell_dest_xi ][cell_dest_yi ] + a0ma1diva2ma1 * + (z_values[cell_dest_xi + 1][cell_dest_yi ] - z_values[cell_dest_xi][cell_dest_yi ]); + + z2 = z_values[cell_dest_xi ][cell_dest_yi + 1] + a0ma1diva2ma1 * + (z_values[cell_dest_xi + 1][cell_dest_yi + 1] - z_values[cell_dest_xi][cell_dest_yi + 1]); + + // we are done with the fractional X distance into the cell. Now with the two Z-Heights we have calculated, we // are going to apply the Y-Distance into the cell to interpolate the final Z correction. - a0ma1diva2ma1 = (y_end - mesh_index_to_Y_location[cell_dest_yi]) * (float) (1.0 / MESH_Y_DIST); + a0ma1diva2ma1 = (y_end - mesh_index_to_y_location[cell_dest_yi]) * 0.1 * (MESH_Y_DIST); z0 = z1 + (z2 - z1) * a0ma1diva2ma1; - // debug code to use non-optimized get_z_correction() and to do a sanity check - // that the correct value is being passed to planner.buffer_line() - // + /** + * Debug code to use non-optimized get_z_correction() and to do a sanity check + * that the correct value is being passed to planner.buffer_line() + */ /* z_optimized = z0; - z0 = blm.get_z_correction( x_end, y_end); - if ( fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized) ) { - debug_current_and_destination( (char *) "FINAL_MOVE: z_correction()"); - if ( isnan(z0) ) SERIAL_ECHO(" z0==NAN "); - if ( isnan(z_optimized) ) SERIAL_ECHO(" z_optimized==NAN "); + z0 = ubl.get_z_correction( x_end, y_end); + if (fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized)) { + debug_current_and_destination((char*)"FINAL_MOVE: z_correction()"); + if (isnan(z0)) SERIAL_ECHO(" z0==NAN "); + if (isnan(z_optimized)) SERIAL_ECHO(" z_optimized==NAN "); SERIAL_ECHOPAIR(" x_end=", x_end); SERIAL_ECHOPAIR(" y_end=", y_end); SERIAL_ECHOPAIR(" z0=", z0); @@ -136,48 +138,50 @@ SERIAL_ECHOPAIR(" err=",fabs(z_optimized - z0)); SERIAL_EOL; } - */ - z0 = z0 * blm.fade_scaling_factor_for_Z( z_end ); + //*/ + z0 = z0 * ubl.fade_scaling_factor_for_z(z_end); - if (isnan(z0)) { // if part of the Mesh is undefined, it will show up as NAN - z0 = 0.0; // in z_values[][] and propagate through the - // calculations. If our correction is NAN, we throw it out - // because part of the Mesh is undefined and we don't have the - // information we need to complete the height correction. - } + /** + * If part of the Mesh is undefined, it will show up as NAN + * in z_values[][] and propagate through the + * calculations. If our correction is NAN, we throw it out + * because part of the Mesh is undefined and we don't have the + * information we need to complete the height correction. + */ + if (isnan(z0)) z0 = 0.0; + + planner.buffer_line(x_end, y_end, z_end + z0 + ubl.state.z_offset, e_end, feed_rate, extruder); + + if (g26_debug_flag) + debug_current_and_destination((char*)"FINAL_MOVE in ubl_line_to_destination()"); - planner.buffer_line(x_end, y_end, z_end + z0 + blm.state.z_offset, e_end, feed_rate, extruder); - if (G26_Debug_flag!=0) { - debug_current_and_destination( (char *) "FINAL_MOVE in UBL_line_to_destination()"); - } set_current_to_destination(); return; } - // - // If we get here, we are processing a move that crosses at least one Mesh Line. We will check - // for the simple case of just crossing X or just crossing Y Mesh Lines after we get all the details - // of the move figured out. We can process the easy case of just crossing an X or Y Mesh Line with less - // computation and in fact most lines are of this nature. We will check for that in the following - // blocks of code: - - left_flag = 0; - down_flag = 0; - inf_m_flag = false; - inf_normalized_flag = false; + /** + * If we get here, we are processing a move that crosses at least one Mesh Line. We will check + * for the simple case of just crossing X or just crossing Y Mesh Lines after we get all the details + * of the move figured out. We can process the easy case of just crossing an X or Y Mesh Line with less + * computation and in fact most lines are of this nature. We will check for that in the following + * blocks of code: + */ dx = x_end - x_start; dy = y_end - y_start; - if (dx<0.0) { // figure out which way we need to move to get to the next cell + const int left_flag = dx < 0.0 ? 1 : 0, + down_flag = dy < 0.0 ? 1 : 0; + + if (left_flag) { // figure out which way we need to move to get to the next cell dxi = -1; - adx = -dx; // absolute value of dx. We already need to check if dx and dy are negative. + adx = -dx; // absolute value of dx. We already need to check if dx and dy are negative. } - else { // We may as well generate the appropriate values for adx and ady right now + else { // We may as well generate the appropriate values for adx and ady right now dxi = 1; // to save setting up the abs() function call and actually doing the call. adx = dx; } - if (dy<0.0) { + if (dy < 0.0) { dyi = -1; ady = -dy; // absolute value of dy } @@ -186,75 +190,68 @@ ady = dy; } - if (dx<0.0) left_flag = 1; - if (dy<0.0) down_flag = 1; if (cell_start_xi == cell_dest_xi) dxi = 0; if (cell_start_yi == cell_dest_yi) dyi = 0; - // - // Compute the scaling factor for the extruder for each partial move. - // We need to watch out for zero length moves because it will cause us to - // have an infinate scaling factor. We are stuck doing a floating point - // divide to get our scaling factor, but after that, we just multiply by this - // number. We also pick our scaling factor based on whether the X or Y - // component is larger. We use the biggest of the two to preserve precision. - // - if ( adx > ady ) { - use_X_dist = true; - on_axis_distance = x_end-x_start; - } - else { - use_X_dist = false; - on_axis_distance = y_end-y_start; - } + /** + * Compute the scaling factor for the extruder for each partial move. + * We need to watch out for zero length moves because it will cause us to + * have an infinate scaling factor. We are stuck doing a floating point + * divide to get our scaling factor, but after that, we just multiply by this + * number. We also pick our scaling factor based on whether the X or Y + * component is larger. We use the biggest of the two to preserve precision. + */ + + const bool use_x_dist = adx > ady; + + on_axis_distance = use_x_dist ? x_end - x_start : y_end - y_start; + e_position = e_end - e_start; e_normalized_dist = e_position / on_axis_distance; z_position = z_end - z_start; z_normalized_dist = z_position / on_axis_distance; - if (e_normalized_dist==INFINITY || e_normalized_dist==-INFINITY) { - inf_normalized_flag = true; - } + const bool inf_normalized_flag = e_normalized_dist == INFINITY || e_normalized_dist == -INFINITY; + current_xi = cell_start_xi; current_yi = cell_start_yi; m = dy / dx; - c = y_start - m*x_start; - if (m == INFINITY || m == -INFINITY) { - inf_m_flag = true; - } - // - // This block handles vertical lines. These are lines that stay within the same - // X Cell column. They do not need to be perfectly vertical. They just can - // not cross into another X Cell column. - // + c = y_start - m * x_start; + const bool inf_m_flag = (m == INFINITY || m == -INFINITY); + + /** + * This block handles vertical lines. These are lines that stay within the same + * X Cell column. They do not need to be perfectly vertical. They just can + * not cross into another X Cell column. + */ if (dxi == 0) { // Check for a vertical line current_yi += down_flag; // Line is heading down, we just want to go to the bottom while (current_yi != cell_dest_yi + down_flag) { current_yi += dyi; - next_mesh_line_y = mesh_index_to_Y_location[current_yi]; - if (inf_m_flag) { - x = x_start; // if the slope of the line is infinite, we won't do the calculations - } - // we know the next X is the same so we can recover and continue! - else { - x = (next_mesh_line_y - c) / m; // Calculate X at the next Y mesh line - } + next_mesh_line_y = mesh_index_to_y_location[current_yi]; - z0 = blm.get_z_correction_along_horizontal_mesh_line_at_specific_X(x, current_xi, current_yi); + /** + * inf_m_flag? the slope of the line is infinite, we won't do the calculations + * else, we know the next X is the same so we can recover and continue! + * Calculate X at the next Y mesh line + */ + x = inf_m_flag ? x_start : (next_mesh_line_y - c) / m; - // - // debug code to use non-optimized get_z_correction() and to do a sanity check - // that the correct value is being passed to planner.buffer_line() - // + z0 = ubl.get_z_correction_along_horizontal_mesh_line_at_specific_X(x, current_xi, current_yi); + + /** + * Debug code to use non-optimized get_z_correction() and to do a sanity check + * that the correct value is being passed to planner.buffer_line() + */ /* z_optimized = z0; - z0 = blm.get_z_correction( x, next_mesh_line_y); - if ( fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized) ) { - debug_current_and_destination( (char *) "VERTICAL z_correction()"); - if ( isnan(z0) ) SERIAL_ECHO(" z0==NAN "); - if ( isnan(z_optimized) ) SERIAL_ECHO(" z_optimized==NAN "); + z0 = ubl.get_z_correction( x, next_mesh_line_y); + if (fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized)) { + debug_current_and_destination((char*)"VERTICAL z_correction()"); + if (isnan(z0)) SERIAL_ECHO(" z0==NAN "); + if (isnan(z_optimized)) SERIAL_ECHO(" z_optimized==NAN "); SERIAL_ECHOPAIR(" x=", x); SERIAL_ECHOPAIR(" next_mesh_line_y=", next_mesh_line_y); SERIAL_ECHOPAIR(" z0=", z0); @@ -262,25 +259,30 @@ SERIAL_ECHOPAIR(" err=",fabs(z_optimized-z0)); SERIAL_ECHO("\n"); } - */ + //*/ - z0 = z0 * blm.fade_scaling_factor_for_Z( z_end ); + z0 = z0 * ubl.fade_scaling_factor_for_z(z_end); - if (isnan(z0)) { // if part of the Mesh is undefined, it will show up as NAN - z0 = 0.0; // in z_values[][] and propagate through the - // calculations. If our correction is NAN, we throw it out - // because part of the Mesh is undefined and we don't have the - // information we need to complete the height correction. - } - y = mesh_index_to_Y_location[current_yi]; + /** + * If part of the Mesh is undefined, it will show up as NAN + * in z_values[][] and propagate through the + * calculations. If our correction is NAN, we throw it out + * because part of the Mesh is undefined and we don't have the + * information we need to complete the height correction. + */ + if (isnan(z0)) z0 = 0.0; - // Without this check, it is possible for the algorythm to generate a zero length move in the case - // where the line is heading down and it is starting right on a Mesh Line boundary. For how often that - // happens, it might be best to remove the check and always 'schedule' the move because - // the planner.buffer_line() routine will filter it if that happens. - if ( y!=y_start) { - if ( inf_normalized_flag == false ) { - on_axis_distance = y - y_start; // we don't need to check if the extruder position + y = mesh_index_to_y_location[current_yi]; + + /** + * Without this check, it is possible for the algorithm to generate a zero length move in the case + * where the line is heading down and it is starting right on a Mesh Line boundary. For how often that + * happens, it might be best to remove the check and always 'schedule' the move because + * the planner.buffer_line() routine will filter it if that happens. + */ + if (y != y_start) { + if (!inf_normalized_flag) { + on_axis_distance = y - y_start; // we don't need to check if the extruder position e_position = e_start + on_axis_distance * e_normalized_dist; // is based on X or Y because this is a vertical move z_position = z_start + on_axis_distance * z_normalized_dist; } @@ -289,49 +291,52 @@ z_position = z_start; } - planner.buffer_line(x, y, z_position + z0 + blm.state.z_offset, e_position, feed_rate, extruder); + planner.buffer_line(x, y, z_position + z0 + ubl.state.z_offset, e_position, feed_rate, extruder); } //else printf("FIRST MOVE PRUNED "); } + + if (g26_debug_flag) + debug_current_and_destination((char*)"vertical move done in ubl_line_to_destination()"); + // - // Check if we are at the final destination. Usually, we won't be, but if it is on a Y Mesh Line, we are done. + // Check if we are at the final destination. Usually, we won't be, but if it is on a Y Mesh Line, we are done. // - if (G26_Debug_flag!=0) { - debug_current_and_destination( (char *) "vertical move done in UBL_line_to_destination()"); - } - if (current_position[X_AXIS] != x_end || current_position[Y_AXIS] != y_end) { + if (current_position[X_AXIS] != x_end || current_position[Y_AXIS] != y_end) goto FINAL_MOVE; - } + set_current_to_destination(); return; } - // - // This block handles horizontal lines. These are lines that stay within the same - // Y Cell row. They do not need to be perfectly horizontal. They just can - // not cross into another Y Cell row. - // + /** + * + * This block handles horizontal lines. These are lines that stay within the same + * Y Cell row. They do not need to be perfectly horizontal. They just can + * not cross into another Y Cell row. + * + */ - if (dyi == 0) { // Check for a horiziontal line + if (dyi == 0) { // Check for a horizontal line current_xi += left_flag; // Line is heading left, we just want to go to the left - // edge of this cell for the first move. + // edge of this cell for the first move. while (current_xi != cell_dest_xi + left_flag) { current_xi += dxi; - next_mesh_line_x = mesh_index_to_X_location[current_xi]; + next_mesh_line_x = mesh_index_to_x_location[current_xi]; y = m * next_mesh_line_x + c; // Calculate X at the next Y mesh line - z0 = blm.get_z_correction_along_vertical_mesh_line_at_specific_Y(y, current_xi, current_yi); + z0 = ubl.get_z_correction_along_vertical_mesh_line_at_specific_Y(y, current_xi, current_yi); - // - // debug code to use non-optimized get_z_correction() and to do a sanity check - // that the correct value is being passed to planner.buffer_line() - // + /** + * Debug code to use non-optimized get_z_correction() and to do a sanity check + * that the correct value is being passed to planner.buffer_line() + */ /* z_optimized = z0; - z0 = blm.get_z_correction( next_mesh_line_x, y); - if ( fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized) ) { - debug_current_and_destination( (char *) "HORIZONTAL z_correction()"); - if ( isnan(z0) ) SERIAL_ECHO(" z0==NAN "); - if ( isnan(z_optimized) ) SERIAL_ECHO(" z_optimized==NAN "); + z0 = ubl.get_z_correction( next_mesh_line_x, y); + if (fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized)) { + debug_current_and_destination((char*)"HORIZONTAL z_correction()"); + if (isnan(z0)) SERIAL_ECHO(" z0==NAN "); + if (isnan(z_optimized)) SERIAL_ECHO(" z_optimized==NAN "); SERIAL_ECHOPAIR(" next_mesh_line_x=", next_mesh_line_x); SERIAL_ECHOPAIR(" y=", y); SERIAL_ECHOPAIR(" z0=", z0); @@ -339,25 +344,30 @@ SERIAL_ECHOPAIR(" err=",fabs(z_optimized-z0)); SERIAL_ECHO("\n"); } - */ + //*/ - z0 = z0 * blm.fade_scaling_factor_for_Z( z_end ); + z0 = z0 * ubl.fade_scaling_factor_for_z(z_end); - if (isnan(z0)) { // if part of the Mesh is undefined, it will show up as NAN - z0 = 0.0; // in z_values[][] and propagate through the - // calculations. If our correction is NAN, we throw it out - // because part of the Mesh is undefined and we don't have the - // information we need to complete the height correction. - } - x = mesh_index_to_X_location[current_xi]; + /** + * If part of the Mesh is undefined, it will show up as NAN + * in z_values[][] and propagate through the + * calculations. If our correction is NAN, we throw it out + * because part of the Mesh is undefined and we don't have the + * information we need to complete the height correction. + */ + if (isnan(z0)) z0 = 0.0; - // Without this check, it is possible for the algorythm to generate a zero length move in the case - // where the line is heading left and it is starting right on a Mesh Line boundary. For how often - // that happens, it might be best to remove the check and always 'schedule' the move because - // the planner.buffer_line() routine will filter it if that happens. - if ( x!=x_start) { - if ( inf_normalized_flag == false ) { - on_axis_distance = x - x_start; // we don't need to check if the extruder position + x = mesh_index_to_x_location[current_xi]; + + /** + * Without this check, it is possible for the algorithm to generate a zero length move in the case + * where the line is heading left and it is starting right on a Mesh Line boundary. For how often + * that happens, it might be best to remove the check and always 'schedule' the move because + * the planner.buffer_line() routine will filter it if that happens. + */ + if (x != x_start) { + if (!inf_normalized_flag) { + on_axis_distance = x - x_start; // we don't need to check if the extruder position e_position = e_start + on_axis_distance * e_normalized_dist; // is based on X or Y because this is a horizontal move z_position = z_start + on_axis_distance * z_normalized_dist; } @@ -366,74 +376,63 @@ z_position = z_start; } - planner.buffer_line(x, y, z_position + z0 + blm.state.z_offset, e_position, feed_rate, extruder); + planner.buffer_line(x, y, z_position + z0 + ubl.state.z_offset, e_position, feed_rate, extruder); } //else printf("FIRST MOVE PRUNED "); } - if (G26_Debug_flag!=0) { - debug_current_and_destination( (char *) "horizontal move done in UBL_line_to_destination()"); - } - if (current_position[X_AXIS] != x_end || current_position[Y_AXIS] != y_end) { + + if (g26_debug_flag) + debug_current_and_destination((char*)"horizontal move done in ubl_line_to_destination()"); + + if (current_position[X_AXIS] != x_end || current_position[Y_AXIS] != y_end) goto FINAL_MOVE; - } + set_current_to_destination(); return; } - // - // - // - // - // This block handles the generic case of a line crossing both X and Y - // Mesh lines. - // - // - // - // + /** + * + * This block handles the generic case of a line crossing both X and Y Mesh lines. + * + */ xi_cnt = cell_start_xi - cell_dest_xi; - if ( xi_cnt < 0 ) { - xi_cnt = -xi_cnt; - } + if (xi_cnt < 0) xi_cnt = -xi_cnt; yi_cnt = cell_start_yi - cell_dest_yi; - if ( yi_cnt < 0 ) { - yi_cnt = -yi_cnt; - } + if (yi_cnt < 0) yi_cnt = -yi_cnt; current_xi += left_flag; current_yi += down_flag; - while ( xi_cnt>0 || yi_cnt>0 ) { + while (xi_cnt > 0 || yi_cnt > 0) { - next_mesh_line_x = mesh_index_to_X_location[current_xi + dxi]; - next_mesh_line_y = mesh_index_to_Y_location[current_yi + dyi]; + next_mesh_line_x = mesh_index_to_x_location[current_xi + dxi]; + next_mesh_line_y = mesh_index_to_y_location[current_yi + dyi]; y = m * next_mesh_line_x + c; // Calculate Y at the next X mesh line - x = (next_mesh_line_y-c) / m; // Calculate X at the next Y mesh line (we don't have to worry + x = (next_mesh_line_y - c) / m; // Calculate X at the next Y mesh line (we don't have to worry // about m being equal to 0.0 If this was the case, we would have // detected this as a vertical line move up above and we wouldn't // be down here doing a generic type of move. - if ((left_flag && (x>next_mesh_line_x)) || (!left_flag && (x next_mesh_line_x)) { // Check if we hit the Y line first // // Yes! Crossing a Y Mesh Line next // - z0 = blm.get_z_correction_along_horizontal_mesh_line_at_specific_X(x, current_xi-left_flag, current_yi+dyi); - - // - // debug code to use non-optimized get_z_correction() and to do a sanity check - // that the correct value is being passed to planner.buffer_line() - // + z0 = ubl.get_z_correction_along_horizontal_mesh_line_at_specific_X(x, current_xi - left_flag, current_yi + dyi); + /** + * Debug code to use non-optimized get_z_correction() and to do a sanity check + * that the correct value is being passed to planner.buffer_line() + */ /* - z_optimized = z0; - - z0 = blm.get_z_correction( x, next_mesh_line_y); - if ( fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized) ) { - debug_current_and_destination( (char *) "General_1: z_correction()"); - if ( isnan(z0) ) SERIAL_ECHO(" z0==NAN "); - if ( isnan(z_optimized) ) SERIAL_ECHO(" z_optimized==NAN "); { + z0 = ubl.get_z_correction( x, next_mesh_line_y); + if (fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized)) { + debug_current_and_destination((char*)"General_1: z_correction()"); + if (isnan(z0)) SERIAL_ECHO(" z0==NAN "); + if (isnan(z_optimized)) SERIAL_ECHO(" z_optimized==NAN "); { SERIAL_ECHOPAIR(" x=", x); } SERIAL_ECHOPAIR(" next_mesh_line_y=", next_mesh_line_y); @@ -442,23 +441,21 @@ SERIAL_ECHOPAIR(" err=",fabs(z_optimized-z0)); SERIAL_ECHO("\n"); } - */ + //*/ - z0 = z0 * blm.fade_scaling_factor_for_Z( z_end ); - if (isnan(z0)) { // if part of the Mesh is undefined, it will show up as NAN - z0 = 0.0; // in z_values[][] and propagate through the - // calculations. If our correction is NAN, we throw it out - // because part of the Mesh is undefined and we don't have the - // information we need to complete the height correction. - } + z0 *= ubl.fade_scaling_factor_for_z(z_end); - if ( inf_normalized_flag == false ) { - if ( use_X_dist ) { - on_axis_distance = x - x_start; - } - else { - on_axis_distance = next_mesh_line_y - y_start; - } + /** + * If part of the Mesh is undefined, it will show up as NAN + * in z_values[][] and propagate through the + * calculations. If our correction is NAN, we throw it out + * because part of the Mesh is undefined and we don't have the + * information we need to complete the height correction. + */ + if (isnan(z0)) z0 = 0.0; + + if (!inf_normalized_flag) { + on_axis_distance = use_x_dist ? x - x_start : next_mesh_line_y - y_start; e_position = e_start + on_axis_distance * e_normalized_dist; z_position = z_start + on_axis_distance * z_normalized_dist; } @@ -466,7 +463,7 @@ e_position = e_start; z_position = z_start; } - planner.buffer_line(x, next_mesh_line_y, z_position + z0 + blm.state.z_offset, e_position, feed_rate, extruder); + planner.buffer_line(x, next_mesh_line_y, z_position + z0 + ubl.state.z_offset, e_position, feed_rate, extruder); current_yi += dyi; yi_cnt--; } @@ -474,20 +471,19 @@ // // Yes! Crossing a X Mesh Line next // - z0 = blm.get_z_correction_along_vertical_mesh_line_at_specific_Y(y, current_xi+dxi, current_yi-down_flag); + z0 = ubl.get_z_correction_along_vertical_mesh_line_at_specific_Y(y, current_xi + dxi, current_yi - down_flag); - - // - // debug code to use non-optimized get_z_correction() and to do a sanity check - // that the correct value is being passed to planner.buffer_line() - // + /** + * Debug code to use non-optimized get_z_correction() and to do a sanity check + * that the correct value is being passed to planner.buffer_line() + */ /* z_optimized = z0; - z0 = blm.get_z_correction( next_mesh_line_x, y); - if ( fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized) ) { - debug_current_and_destination( (char *) "General_2: z_correction()"); - if ( isnan(z0) ) SERIAL_ECHO(" z0==NAN "); - if ( isnan(z_optimized) ) SERIAL_ECHO(" z_optimized==NAN "); + z0 = ubl.get_z_correction( next_mesh_line_x, y); + if (fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized)) { + debug_current_and_destination((char*)"General_2: z_correction()"); + if (isnan(z0)) SERIAL_ECHO(" z0==NAN "); + if (isnan(z_optimized)) SERIAL_ECHO(" z_optimized==NAN "); SERIAL_ECHOPAIR(" next_mesh_line_x=", next_mesh_line_x); SERIAL_ECHOPAIR(" y=", y); SERIAL_ECHOPAIR(" z0=", z0); @@ -495,23 +491,21 @@ SERIAL_ECHOPAIR(" err=",fabs(z_optimized-z0)); SERIAL_ECHO("\n"); } - */ + //*/ - z0 = z0 * blm.fade_scaling_factor_for_Z( z_end ); + z0 = z0 * ubl.fade_scaling_factor_for_z(z_end); - if (isnan(z0)) { // if part of the Mesh is undefined, it will show up as NAN - z0 = 0.0; // in z_values[][] and propagate through the - // calculations. If our correction is NAN, we throw it out - // because part of the Mesh is undefined and we don't have the - // information we need to complete the height correction. - } - if ( inf_normalized_flag == false ) { - if ( use_X_dist ) { - on_axis_distance = next_mesh_line_x - x_start; - } - else { - on_axis_distance = y - y_start; - } + /** + * If part of the Mesh is undefined, it will show up as NAN + * in z_values[][] and propagate through the + * calculations. If our correction is NAN, we throw it out + * because part of the Mesh is undefined and we don't have the + * information we need to complete the height correction. + */ + if (isnan(z0)) z0 = 0.0; + + if (!inf_normalized_flag) { + on_axis_distance = use_x_dist ? next_mesh_line_x - x_start : y - y_start; e_position = e_start + on_axis_distance * e_normalized_dist; z_position = z_start + on_axis_distance * z_normalized_dist; } @@ -520,34 +514,19 @@ z_position = z_start; } - planner.buffer_line(next_mesh_line_x, y, z_position + z0 + blm.state.z_offset, e_position, feed_rate, extruder); + planner.buffer_line(next_mesh_line_x, y, z_position + z0 + ubl.state.z_offset, e_position, feed_rate, extruder); current_xi += dxi; xi_cnt--; } } - if (G26_Debug_flag) { - debug_current_and_destination( (char *) "generic move done in UBL_line_to_destination()"); - } - if (current_position[0] != x_end || current_position[1] != y_end) { + + if (g26_debug_flag) + debug_current_and_destination((char*)"generic move done in ubl_line_to_destination()"); + + if (current_position[0] != x_end || current_position[1] != y_end) goto FINAL_MOVE; - } + set_current_to_destination(); - return; - } - - void wait_for_button_press() { - // if ( !been_to_2_6 ) - //return; // bob - I think this should be commented out - - SET_INPUT_PULLUP(66); // Roxy's Left Switch is on pin 66. Right Switch is on pin 65 - SET_OUTPUT(64); - while (READ(66) & 0x01) idle(); - - delay(50); - while (!(READ(66) & 0x01)) idle(); - delay(50); } #endif - - diff --git a/Marlin/cardreader.cpp b/Marlin/cardreader.cpp index aefc2dee45..08d8671011 100644 --- a/Marlin/cardreader.cpp +++ b/Marlin/cardreader.cpp @@ -152,7 +152,7 @@ void CardReader::lsDive(const char *prepend, SdFile parent, const char * const m } // while readDir } -void CardReader::ls() { +void CardReader::ls() { lsAction = LS_SerialPrint; root.rewind(); lsDive("", root); diff --git a/Marlin/configuration_store.cpp b/Marlin/configuration_store.cpp index 09e89940c1..80c9976488 100644 --- a/Marlin/configuration_store.cpp +++ b/Marlin/configuration_store.cpp @@ -250,7 +250,7 @@ void Config_Postprocess() { /** * M500 - Store Configuration */ - bool Config_StoreSettings() { + bool Config_StoreSettings() { float dummy = 0.0f; char ver[4] = "000"; @@ -540,9 +540,9 @@ void Config_Postprocess() { } #if ENABLED(AUTO_BED_LEVELING_UBL) - blm.store_state(); - if (blm.state.EEPROM_storage_slot >= 0) - blm.store_mesh(blm.state.EEPROM_storage_slot); + ubl.store_state(); + if (ubl.state.eeprom_storage_slot >= 0) + ubl.store_mesh(ubl.state.eeprom_storage_slot); #endif return !eeprom_write_error; @@ -846,39 +846,39 @@ void Config_Postprocess() { } #if ENABLED(AUTO_BED_LEVELING_UBL) - Unified_Bed_Leveling_EEPROM_start = (eeprom_index + 32) & 0xFFF8; // Pad the end of configuration data so it + ubl_eeprom_start = (eeprom_index + 32) & 0xFFF8; // Pad the end of configuration data so it // can float up or down a little bit without // disrupting the Unified Bed Leveling data - blm.load_state(); + ubl.load_state(); SERIAL_ECHOPGM(" UBL "); - if (!blm.state.active) SERIAL_ECHO("not "); + if (!ubl.state.active) SERIAL_ECHO("not "); SERIAL_ECHOLNPGM("active!"); - if (!blm.sanity_check()) { + if (!ubl.sanity_check()) { int tmp_mesh; // We want to preserve whether the UBL System is Active bool tmp_active; // If it is, we want to preserve the Mesh that is being used. - tmp_mesh = blm.state.EEPROM_storage_slot; - tmp_active = blm.state.active; + tmp_mesh = ubl.state.eeprom_storage_slot; + tmp_active = ubl.state.active; SERIAL_ECHOLNPGM("\nInitializing Bed Leveling State to current firmware settings.\n"); - blm.state = blm.pre_initialized; // Initialize with the pre_initialized data structure - blm.state.EEPROM_storage_slot = tmp_mesh; // But then restore some data we don't want mangled - blm.state.active = tmp_active; + ubl.state = ubl.pre_initialized; // Initialize with the pre_initialized data structure + ubl.state.eeprom_storage_slot = tmp_mesh; // But then restore some data we don't want mangled + ubl.state.active = tmp_active; } else { SERIAL_PROTOCOLPGM("?Unable to enable Unified Bed Leveling.\n"); - blm.state = blm.pre_initialized; - blm.reset(); - blm.store_state(); + ubl.state = ubl.pre_initialized; + ubl.reset(); + ubl.store_state(); } - if (blm.state.EEPROM_storage_slot >= 0) { - blm.load_mesh(blm.state.EEPROM_storage_slot); - SERIAL_ECHOPAIR("Mesh ", blm.state.EEPROM_storage_slot); + if (ubl.state.eeprom_storage_slot >= 0) { + ubl.load_mesh(ubl.state.eeprom_storage_slot); + SERIAL_ECHOPAIR("Mesh ", ubl.state.eeprom_storage_slot); SERIAL_ECHOLNPGM(" loaded from storage."); } else { - blm.reset(); + ubl.reset(); SERIAL_ECHOPGM("UBL System reset() \n"); } #endif @@ -1183,19 +1183,19 @@ void Config_ResetDefault() { CONFIG_ECHO_START; SERIAL_ECHOPGM("System is: "); - if (blm.state.active) + if (ubl.state.active) SERIAL_ECHOLNPGM("Active\n"); else SERIAL_ECHOLNPGM("Deactive\n"); - SERIAL_ECHOPAIR("Active Mesh Slot: ", blm.state.EEPROM_storage_slot); + SERIAL_ECHOPAIR("Active Mesh Slot: ", ubl.state.eeprom_storage_slot); SERIAL_EOL; SERIAL_ECHOPGM("z_offset: "); - SERIAL_ECHO_F(blm.state.z_offset, 6); + SERIAL_ECHO_F(ubl.state.z_offset, 6); SERIAL_EOL; - SERIAL_ECHOPAIR("EEPROM can hold ", (int)((E2END - sizeof(blm.state) - Unified_Bed_Leveling_EEPROM_start) / sizeof(z_values))); + SERIAL_ECHOPAIR("EEPROM can hold ", (int)((E2END - sizeof(ubl.state) - ubl_eeprom_start) / sizeof(z_values))); SERIAL_ECHOLNPGM(" meshes. \n"); SERIAL_ECHOPAIR("\nUBL_MESH_NUM_X_POINTS ", UBL_MESH_NUM_X_POINTS); diff --git a/Marlin/example_configurations/Cartesio/Configuration.h b/Marlin/example_configurations/Cartesio/Configuration.h index 8b944a81a3..1ea5401bcf 100644 --- a/Marlin/example_configurations/Cartesio/Configuration.h +++ b/Marlin/example_configurations/Cartesio/Configuration.h @@ -748,41 +748,48 @@ // @section bedlevel /** - * Select one form of Auto Bed Leveling below. + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. * - * If you're also using the Probe for Z Homing, it's - * highly recommended to enable Z_SAFE_HOMING also! + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! * - * - 3POINT + * - AUTO_BED_LEVELING_3POINT * Probe 3 arbitrary points on the bed (that aren't collinear) * You specify the XY coordinates of all 3 points. * The result is a single tilted plane. Best for a flat bed. * - * - LINEAR + * - AUTO_BED_LEVELING_LINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a single tilted plane. Best for a flat bed. * - * - BILINEAR + * - AUTO_BED_LEVELING_BILINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. * - * - UBL Unified Bed Leveling - * A comprehensive bed leveling system that combines features and benefits from previous - * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use - * Mesh Generation, Mesh Validation and Mesh Editing system. - * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with - * that said, it was primarily designed to handle poor quality Delta Printers. If you feel - * adventurous and have a Delta, please post an issue if something doesn't work correctly. - * Initially, you will need to reduce your declared bed size so you have a rectangular area to - * test on. + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. Currently, UBL is only checked out + * for Cartesian Printers. That said, it was primarily designed to correct + * poor quality Delta Printers. If you feel adventurous and have a Delta, + * please post an issue if something doesn't work correctly. Initially, + * you will need to set a reduced bed size so you have a rectangular area + * to test on. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR -//#define MESH_BED_LEVELING //#define AUTO_BED_LEVELING_UBL +//#define MESH_BED_LEVELING /** * Enable detailed logging of G28, G29, M48, etc. @@ -841,25 +848,6 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#elif ENABLED(MESH_BED_LEVELING) - - //=========================================================================== - //=================================== Mesh ================================== - //=========================================================================== - - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif - #elif ENABLED(AUTO_BED_LEVELING_UBL) //=========================================================================== @@ -876,7 +864,26 @@ #define UBL_PROBE_PT_3_X 180 #define UBL_PROBE_PT_3_Y 20 -#endif // BED_LEVELING +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/Felix/Configuration.h b/Marlin/example_configurations/Felix/Configuration.h index 1f10b07720..069b8e1262 100644 --- a/Marlin/example_configurations/Felix/Configuration.h +++ b/Marlin/example_configurations/Felix/Configuration.h @@ -731,41 +731,48 @@ // @section bedlevel /** - * Select one form of Auto Bed Leveling below. + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. * - * If you're also using the Probe for Z Homing, it's - * highly recommended to enable Z_SAFE_HOMING also! + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! * - * - 3POINT + * - AUTO_BED_LEVELING_3POINT * Probe 3 arbitrary points on the bed (that aren't collinear) * You specify the XY coordinates of all 3 points. * The result is a single tilted plane. Best for a flat bed. * - * - LINEAR + * - AUTO_BED_LEVELING_LINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a single tilted plane. Best for a flat bed. * - * - BILINEAR + * - AUTO_BED_LEVELING_BILINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. * - * - UBL Unified Bed Leveling - * A comprehensive bed leveling system that combines features and benefits from previous - * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use - * Mesh Generation, Mesh Validation and Mesh Editing system. - * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with - * that said, it was primarily designed to handle poor quality Delta Printers. If you feel - * adventurous and have a Delta, please post an issue if something doesn't work correctly. - * Initially, you will need to reduce your declared bed size so you have a rectangular area to - * test on. + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. Currently, UBL is only checked out + * for Cartesian Printers. That said, it was primarily designed to correct + * poor quality Delta Printers. If you feel adventurous and have a Delta, + * please post an issue if something doesn't work correctly. Initially, + * you will need to set a reduced bed size so you have a rectangular area + * to test on. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR -//#define MESH_BED_LEVELING //#define AUTO_BED_LEVELING_UBL +//#define MESH_BED_LEVELING /** * Enable detailed logging of G28, G29, M48, etc. @@ -824,25 +831,6 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#elif ENABLED(MESH_BED_LEVELING) - - //=========================================================================== - //=================================== Mesh ================================== - //=========================================================================== - - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif - #elif ENABLED(AUTO_BED_LEVELING_UBL) //=========================================================================== @@ -859,7 +847,26 @@ #define UBL_PROBE_PT_3_X 180 #define UBL_PROBE_PT_3_Y 20 -#endif // BED_LEVELING +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/Felix/DUAL/Configuration.h b/Marlin/example_configurations/Felix/DUAL/Configuration.h index c987fdf72b..33fac4c535 100644 --- a/Marlin/example_configurations/Felix/DUAL/Configuration.h +++ b/Marlin/example_configurations/Felix/DUAL/Configuration.h @@ -731,41 +731,48 @@ // @section bedlevel /** - * Select one form of Auto Bed Leveling below. + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. * - * If you're also using the Probe for Z Homing, it's - * highly recommended to enable Z_SAFE_HOMING also! + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! * - * - 3POINT + * - AUTO_BED_LEVELING_3POINT * Probe 3 arbitrary points on the bed (that aren't collinear) * You specify the XY coordinates of all 3 points. * The result is a single tilted plane. Best for a flat bed. * - * - LINEAR + * - AUTO_BED_LEVELING_LINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a single tilted plane. Best for a flat bed. * - * - BILINEAR + * - AUTO_BED_LEVELING_BILINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. * - * - UBL Unified Bed Leveling - * A comprehensive bed leveling system that combines features and benefits from previous - * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use - * Mesh Generation, Mesh Validation and Mesh Editing system. - * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with - * that said, it was primarily designed to handle poor quality Delta Printers. If you feel - * adventurous and have a Delta, please post an issue if something doesn't work correctly. - * Initially, you will need to reduce your declared bed size so you have a rectangular area to - * test on. + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. Currently, UBL is only checked out + * for Cartesian Printers. That said, it was primarily designed to correct + * poor quality Delta Printers. If you feel adventurous and have a Delta, + * please post an issue if something doesn't work correctly. Initially, + * you will need to set a reduced bed size so you have a rectangular area + * to test on. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR -//#define MESH_BED_LEVELING //#define AUTO_BED_LEVELING_UBL +//#define MESH_BED_LEVELING /** * Enable detailed logging of G28, G29, M48, etc. @@ -824,25 +831,6 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#elif ENABLED(MESH_BED_LEVELING) - - //=========================================================================== - //=================================== Mesh ================================== - //=========================================================================== - - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif - #elif ENABLED(AUTO_BED_LEVELING_UBL) //=========================================================================== @@ -859,7 +847,26 @@ #define UBL_PROBE_PT_3_X 180 #define UBL_PROBE_PT_3_Y 20 -#endif // BED_LEVELING +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/Hephestos/Configuration.h b/Marlin/example_configurations/Hephestos/Configuration.h index 57a8d3b24e..4ec31392b9 100644 --- a/Marlin/example_configurations/Hephestos/Configuration.h +++ b/Marlin/example_configurations/Hephestos/Configuration.h @@ -740,41 +740,48 @@ // @section bedlevel /** - * Select one form of Auto Bed Leveling below. + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. * - * If you're also using the Probe for Z Homing, it's - * highly recommended to enable Z_SAFE_HOMING also! + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! * - * - 3POINT + * - AUTO_BED_LEVELING_3POINT * Probe 3 arbitrary points on the bed (that aren't collinear) * You specify the XY coordinates of all 3 points. * The result is a single tilted plane. Best for a flat bed. * - * - LINEAR + * - AUTO_BED_LEVELING_LINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a single tilted plane. Best for a flat bed. * - * - BILINEAR + * - AUTO_BED_LEVELING_BILINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. * - * - UBL Unified Bed Leveling - * A comprehensive bed leveling system that combines features and benefits from previous - * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use - * Mesh Generation, Mesh Validation and Mesh Editing system. - * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with - * that said, it was primarily designed to handle poor quality Delta Printers. If you feel - * adventurous and have a Delta, please post an issue if something doesn't work correctly. - * Initially, you will need to reduce your declared bed size so you have a rectangular area to - * test on. + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. Currently, UBL is only checked out + * for Cartesian Printers. That said, it was primarily designed to correct + * poor quality Delta Printers. If you feel adventurous and have a Delta, + * please post an issue if something doesn't work correctly. Initially, + * you will need to set a reduced bed size so you have a rectangular area + * to test on. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR -//#define MESH_BED_LEVELING //#define AUTO_BED_LEVELING_UBL +//#define MESH_BED_LEVELING /** * Enable detailed logging of G28, G29, M48, etc. @@ -833,25 +840,6 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#elif ENABLED(MESH_BED_LEVELING) - - //=========================================================================== - //=================================== Mesh ================================== - //=========================================================================== - - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif - #elif ENABLED(AUTO_BED_LEVELING_UBL) //=========================================================================== @@ -868,7 +856,26 @@ #define UBL_PROBE_PT_3_X 180 #define UBL_PROBE_PT_3_Y 20 -#endif // BED_LEVELING +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/Hephestos_2/Configuration.h b/Marlin/example_configurations/Hephestos_2/Configuration.h index c704710e02..d67307d870 100644 --- a/Marlin/example_configurations/Hephestos_2/Configuration.h +++ b/Marlin/example_configurations/Hephestos_2/Configuration.h @@ -742,41 +742,48 @@ // @section bedlevel /** - * Select one form of Auto Bed Leveling below. + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. * - * If you're also using the Probe for Z Homing, it's - * highly recommended to enable Z_SAFE_HOMING also! + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! * - * - 3POINT + * - AUTO_BED_LEVELING_3POINT * Probe 3 arbitrary points on the bed (that aren't collinear) * You specify the XY coordinates of all 3 points. * The result is a single tilted plane. Best for a flat bed. * - * - LINEAR + * - AUTO_BED_LEVELING_LINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a single tilted plane. Best for a flat bed. * - * - BILINEAR + * - AUTO_BED_LEVELING_BILINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. * - * - UBL Unified Bed Leveling - * A comprehensive bed leveling system that combines features and benefits from previous - * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use - * Mesh Generation, Mesh Validation and Mesh Editing system. - * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with - * that said, it was primarily designed to handle poor quality Delta Printers. If you feel - * adventurous and have a Delta, please post an issue if something doesn't work correctly. - * Initially, you will need to reduce your declared bed size so you have a rectangular area to - * test on. + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. Currently, UBL is only checked out + * for Cartesian Printers. That said, it was primarily designed to correct + * poor quality Delta Printers. If you feel adventurous and have a Delta, + * please post an issue if something doesn't work correctly. Initially, + * you will need to set a reduced bed size so you have a rectangular area + * to test on. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR -//#define MESH_BED_LEVELING //#define AUTO_BED_LEVELING_UBL +//#define MESH_BED_LEVELING /** * Enable detailed logging of G28, G29, M48, etc. @@ -835,25 +842,6 @@ #define ABL_PROBE_PT_3_X ((X_MIN_POS + X_MAX_POS) / 2) #define ABL_PROBE_PT_3_Y Y_MAX_POS - (Y_PROBE_OFFSET_FROM_EXTRUDER) -#elif ENABLED(MESH_BED_LEVELING) - - //=========================================================================== - //=================================== Mesh ================================== - //=========================================================================== - - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif - #elif ENABLED(AUTO_BED_LEVELING_UBL) //=========================================================================== @@ -870,7 +858,26 @@ #define UBL_PROBE_PT_3_X 180 #define UBL_PROBE_PT_3_Y 20 -#endif // BED_LEVELING +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/K8200/Configuration.h b/Marlin/example_configurations/K8200/Configuration.h index 16a1a09dd3..c340f26aaa 100644 --- a/Marlin/example_configurations/K8200/Configuration.h +++ b/Marlin/example_configurations/K8200/Configuration.h @@ -777,41 +777,48 @@ // @section bedlevel /** - * Select one form of Auto Bed Leveling below. + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. * - * If you're also using the Probe for Z Homing, it's - * highly recommended to enable Z_SAFE_HOMING also! + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! * - * - 3POINT + * - AUTO_BED_LEVELING_3POINT * Probe 3 arbitrary points on the bed (that aren't collinear) * You specify the XY coordinates of all 3 points. * The result is a single tilted plane. Best for a flat bed. * - * - LINEAR + * - AUTO_BED_LEVELING_LINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a single tilted plane. Best for a flat bed. * - * - BILINEAR + * - AUTO_BED_LEVELING_BILINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. * - * - UBL Unified Bed Leveling - * A comprehensive bed leveling system that combines features and benefits from previous - * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use - * Mesh Generation, Mesh Validation and Mesh Editing system. - * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with - * that said, it was primarily designed to handle poor quality Delta Printers. If you feel - * adventurous and have a Delta, please post an issue if something doesn't work correctly. - * Initially, you will need to reduce your declared bed size so you have a rectangular area to - * test on. + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. Currently, UBL is only checked out + * for Cartesian Printers. That said, it was primarily designed to correct + * poor quality Delta Printers. If you feel adventurous and have a Delta, + * please post an issue if something doesn't work correctly. Initially, + * you will need to set a reduced bed size so you have a rectangular area + * to test on. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR -//#define MESH_BED_LEVELING //#define AUTO_BED_LEVELING_UBL +//#define MESH_BED_LEVELING /** * Enable detailed logging of G28, G29, M48, etc. @@ -870,25 +877,6 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#elif ENABLED(MESH_BED_LEVELING) - - //=========================================================================== - //=================================== Mesh ================================== - //=========================================================================== - - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif - #elif ENABLED(AUTO_BED_LEVELING_UBL) //=========================================================================== @@ -905,7 +893,26 @@ #define UBL_PROBE_PT_3_X 180 #define UBL_PROBE_PT_3_Y 20 -#endif // BED_LEVELING +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/K8400/Configuration.h b/Marlin/example_configurations/K8400/Configuration.h index fa74835ea3..d84cbff9a7 100644 --- a/Marlin/example_configurations/K8400/Configuration.h +++ b/Marlin/example_configurations/K8400/Configuration.h @@ -748,41 +748,48 @@ // @section bedlevel /** - * Select one form of Auto Bed Leveling below. + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. * - * If you're also using the Probe for Z Homing, it's - * highly recommended to enable Z_SAFE_HOMING also! + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! * - * - 3POINT + * - AUTO_BED_LEVELING_3POINT * Probe 3 arbitrary points on the bed (that aren't collinear) * You specify the XY coordinates of all 3 points. * The result is a single tilted plane. Best for a flat bed. * - * - LINEAR + * - AUTO_BED_LEVELING_LINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a single tilted plane. Best for a flat bed. * - * - BILINEAR + * - AUTO_BED_LEVELING_BILINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. * - * - UBL Unified Bed Leveling - * A comprehensive bed leveling system that combines features and benefits from previous - * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use - * Mesh Generation, Mesh Validation and Mesh Editing system. - * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with - * that said, it was primarily designed to handle poor quality Delta Printers. If you feel - * adventurous and have a Delta, please post an issue if something doesn't work correctly. - * Initially, you will need to reduce your declared bed size so you have a rectangular area to - * test on. + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. Currently, UBL is only checked out + * for Cartesian Printers. That said, it was primarily designed to correct + * poor quality Delta Printers. If you feel adventurous and have a Delta, + * please post an issue if something doesn't work correctly. Initially, + * you will need to set a reduced bed size so you have a rectangular area + * to test on. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR -//#define MESH_BED_LEVELING //#define AUTO_BED_LEVELING_UBL +//#define MESH_BED_LEVELING /** * Enable detailed logging of G28, G29, M48, etc. @@ -841,25 +848,6 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#elif ENABLED(MESH_BED_LEVELING) - - //=========================================================================== - //=================================== Mesh ================================== - //=========================================================================== - - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif - #elif ENABLED(AUTO_BED_LEVELING_UBL) //=========================================================================== @@ -876,7 +864,26 @@ #define UBL_PROBE_PT_3_X 180 #define UBL_PROBE_PT_3_Y 20 -#endif // BED_LEVELING +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/K8400/Dual-head/Configuration.h b/Marlin/example_configurations/K8400/Dual-head/Configuration.h index 570f3ad2a3..768d4b6959 100644 --- a/Marlin/example_configurations/K8400/Dual-head/Configuration.h +++ b/Marlin/example_configurations/K8400/Dual-head/Configuration.h @@ -748,41 +748,48 @@ // @section bedlevel /** - * Select one form of Auto Bed Leveling below. + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. * - * If you're also using the Probe for Z Homing, it's - * highly recommended to enable Z_SAFE_HOMING also! + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! * - * - 3POINT + * - AUTO_BED_LEVELING_3POINT * Probe 3 arbitrary points on the bed (that aren't collinear) * You specify the XY coordinates of all 3 points. * The result is a single tilted plane. Best for a flat bed. * - * - LINEAR + * - AUTO_BED_LEVELING_LINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a single tilted plane. Best for a flat bed. * - * - BILINEAR + * - AUTO_BED_LEVELING_BILINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. * - * - UBL Unified Bed Leveling - * A comprehensive bed leveling system that combines features and benefits from previous - * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use - * Mesh Generation, Mesh Validation and Mesh Editing system. - * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with - * that said, it was primarily designed to handle poor quality Delta Printers. If you feel - * adventurous and have a Delta, please post an issue if something doesn't work correctly. - * Initially, you will need to reduce your declared bed size so you have a rectangular area to - * test on. + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. Currently, UBL is only checked out + * for Cartesian Printers. That said, it was primarily designed to correct + * poor quality Delta Printers. If you feel adventurous and have a Delta, + * please post an issue if something doesn't work correctly. Initially, + * you will need to set a reduced bed size so you have a rectangular area + * to test on. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR -//#define MESH_BED_LEVELING //#define AUTO_BED_LEVELING_UBL +//#define MESH_BED_LEVELING /** * Enable detailed logging of G28, G29, M48, etc. @@ -841,25 +848,6 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#elif ENABLED(MESH_BED_LEVELING) - - //=========================================================================== - //=================================== Mesh ================================== - //=========================================================================== - - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif - #elif ENABLED(AUTO_BED_LEVELING_UBL) //=========================================================================== @@ -876,7 +864,26 @@ #define UBL_PROBE_PT_3_X 180 #define UBL_PROBE_PT_3_Y 20 -#endif // BED_LEVELING +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/RepRapWorld/Megatronics/Configuration.h b/Marlin/example_configurations/RepRapWorld/Megatronics/Configuration.h index 9d462ebd43..525e9923fb 100644 --- a/Marlin/example_configurations/RepRapWorld/Megatronics/Configuration.h +++ b/Marlin/example_configurations/RepRapWorld/Megatronics/Configuration.h @@ -748,41 +748,48 @@ // @section bedlevel /** - * Select one form of Auto Bed Leveling below. + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. * - * If you're also using the Probe for Z Homing, it's - * highly recommended to enable Z_SAFE_HOMING also! + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! * - * - 3POINT + * - AUTO_BED_LEVELING_3POINT * Probe 3 arbitrary points on the bed (that aren't collinear) * You specify the XY coordinates of all 3 points. * The result is a single tilted plane. Best for a flat bed. * - * - LINEAR + * - AUTO_BED_LEVELING_LINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a single tilted plane. Best for a flat bed. * - * - BILINEAR + * - AUTO_BED_LEVELING_BILINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. * - * - UBL Unified Bed Leveling - * A comprehensive bed leveling system that combines features and benefits from previous - * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use - * Mesh Generation, Mesh Validation and Mesh Editing system. - * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with - * that said, it was primarily designed to handle poor quality Delta Printers. If you feel - * adventurous and have a Delta, please post an issue if something doesn't work correctly. - * Initially, you will need to reduce your declared bed size so you have a rectangular area to - * test on. + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. Currently, UBL is only checked out + * for Cartesian Printers. That said, it was primarily designed to correct + * poor quality Delta Printers. If you feel adventurous and have a Delta, + * please post an issue if something doesn't work correctly. Initially, + * you will need to set a reduced bed size so you have a rectangular area + * to test on. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR -//#define MESH_BED_LEVELING //#define AUTO_BED_LEVELING_UBL +//#define MESH_BED_LEVELING /** * Enable detailed logging of G28, G29, M48, etc. @@ -841,25 +848,6 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#elif ENABLED(MESH_BED_LEVELING) - - //=========================================================================== - //=================================== Mesh ================================== - //=========================================================================== - - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif - #elif ENABLED(AUTO_BED_LEVELING_UBL) //=========================================================================== @@ -876,7 +864,26 @@ #define UBL_PROBE_PT_3_X 180 #define UBL_PROBE_PT_3_Y 20 -#endif // BED_LEVELING +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/RigidBot/Configuration.h b/Marlin/example_configurations/RigidBot/Configuration.h index 6eb5318a94..d8a0e33fbd 100644 --- a/Marlin/example_configurations/RigidBot/Configuration.h +++ b/Marlin/example_configurations/RigidBot/Configuration.h @@ -747,41 +747,48 @@ // @section bedlevel /** - * Select one form of Auto Bed Leveling below. + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. * - * If you're also using the Probe for Z Homing, it's - * highly recommended to enable Z_SAFE_HOMING also! + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! * - * - 3POINT + * - AUTO_BED_LEVELING_3POINT * Probe 3 arbitrary points on the bed (that aren't collinear) * You specify the XY coordinates of all 3 points. * The result is a single tilted plane. Best for a flat bed. * - * - LINEAR + * - AUTO_BED_LEVELING_LINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a single tilted plane. Best for a flat bed. * - * - BILINEAR + * - AUTO_BED_LEVELING_BILINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. * - * - UBL Unified Bed Leveling - * A comprehensive bed leveling system that combines features and benefits from previous - * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use - * Mesh Generation, Mesh Validation and Mesh Editing system. - * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with - * that said, it was primarily designed to handle poor quality Delta Printers. If you feel - * adventurous and have a Delta, please post an issue if something doesn't work correctly. - * Initially, you will need to reduce your declared bed size so you have a rectangular area to - * test on. + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. Currently, UBL is only checked out + * for Cartesian Printers. That said, it was primarily designed to correct + * poor quality Delta Printers. If you feel adventurous and have a Delta, + * please post an issue if something doesn't work correctly. Initially, + * you will need to set a reduced bed size so you have a rectangular area + * to test on. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR -//#define MESH_BED_LEVELING //#define AUTO_BED_LEVELING_UBL +//#define MESH_BED_LEVELING /** * Enable detailed logging of G28, G29, M48, etc. @@ -840,25 +847,6 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#elif ENABLED(MESH_BED_LEVELING) - - //=========================================================================== - //=================================== Mesh ================================== - //=========================================================================== - - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif - #elif ENABLED(AUTO_BED_LEVELING_UBL) //=========================================================================== @@ -875,7 +863,26 @@ #define UBL_PROBE_PT_3_X 180 #define UBL_PROBE_PT_3_Y 20 -#endif // BED_LEVELING +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/SCARA/Configuration.h b/Marlin/example_configurations/SCARA/Configuration.h index 1b76ccef05..691484f747 100644 --- a/Marlin/example_configurations/SCARA/Configuration.h +++ b/Marlin/example_configurations/SCARA/Configuration.h @@ -763,41 +763,48 @@ // @section bedlevel /** - * Select one form of Auto Bed Leveling below. + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. * - * If you're also using the Probe for Z Homing, it's - * highly recommended to enable Z_SAFE_HOMING also! + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! * - * - 3POINT + * - AUTO_BED_LEVELING_3POINT * Probe 3 arbitrary points on the bed (that aren't collinear) * You specify the XY coordinates of all 3 points. * The result is a single tilted plane. Best for a flat bed. * - * - LINEAR + * - AUTO_BED_LEVELING_LINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a single tilted plane. Best for a flat bed. * - * - BILINEAR + * - AUTO_BED_LEVELING_BILINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. * - * - UBL Unified Bed Leveling - * A comprehensive bed leveling system that combines features and benefits from previous - * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use - * Mesh Generation, Mesh Validation and Mesh Editing system. - * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with - * that said, it was primarily designed to handle poor quality Delta Printers. If you feel - * adventurous and have a Delta, please post an issue if something doesn't work correctly. - * Initially, you will need to reduce your declared bed size so you have a rectangular area to - * test on. + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. Currently, UBL is only checked out + * for Cartesian Printers. That said, it was primarily designed to correct + * poor quality Delta Printers. If you feel adventurous and have a Delta, + * please post an issue if something doesn't work correctly. Initially, + * you will need to set a reduced bed size so you have a rectangular area + * to test on. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR -//#define MESH_BED_LEVELING //#define AUTO_BED_LEVELING_UBL +//#define MESH_BED_LEVELING /** * Enable detailed logging of G28, G29, M48, etc. @@ -856,25 +863,6 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#elif ENABLED(MESH_BED_LEVELING) - - //=========================================================================== - //=================================== Mesh ================================== - //=========================================================================== - - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif - #elif ENABLED(AUTO_BED_LEVELING_UBL) //=========================================================================== @@ -891,7 +879,26 @@ #define UBL_PROBE_PT_3_X 180 #define UBL_PROBE_PT_3_Y 20 -#endif // BED_LEVELING +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/TAZ4/Configuration.h b/Marlin/example_configurations/TAZ4/Configuration.h index ffda09ba07..1c6e99d9fc 100644 --- a/Marlin/example_configurations/TAZ4/Configuration.h +++ b/Marlin/example_configurations/TAZ4/Configuration.h @@ -769,41 +769,48 @@ // @section bedlevel /** - * Select one form of Auto Bed Leveling below. + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. * - * If you're also using the Probe for Z Homing, it's - * highly recommended to enable Z_SAFE_HOMING also! + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! * - * - 3POINT + * - AUTO_BED_LEVELING_3POINT * Probe 3 arbitrary points on the bed (that aren't collinear) * You specify the XY coordinates of all 3 points. * The result is a single tilted plane. Best for a flat bed. * - * - LINEAR + * - AUTO_BED_LEVELING_LINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a single tilted plane. Best for a flat bed. * - * - BILINEAR + * - AUTO_BED_LEVELING_BILINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. * - * - UBL Unified Bed Leveling - * A comprehensive bed leveling system that combines features and benefits from previous - * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use - * Mesh Generation, Mesh Validation and Mesh Editing system. - * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with - * that said, it was primarily designed to handle poor quality Delta Printers. If you feel - * adventurous and have a Delta, please post an issue if something doesn't work correctly. - * Initially, you will need to reduce your declared bed size so you have a rectangular area to - * test on. + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. Currently, UBL is only checked out + * for Cartesian Printers. That said, it was primarily designed to correct + * poor quality Delta Printers. If you feel adventurous and have a Delta, + * please post an issue if something doesn't work correctly. Initially, + * you will need to set a reduced bed size so you have a rectangular area + * to test on. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR -//#define MESH_BED_LEVELING //#define AUTO_BED_LEVELING_UBL +//#define MESH_BED_LEVELING /** * Enable detailed logging of G28, G29, M48, etc. @@ -862,25 +869,6 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#elif ENABLED(MESH_BED_LEVELING) - - //=========================================================================== - //=================================== Mesh ================================== - //=========================================================================== - - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif - #elif ENABLED(AUTO_BED_LEVELING_UBL) //=========================================================================== @@ -897,7 +885,26 @@ #define UBL_PROBE_PT_3_X 180 #define UBL_PROBE_PT_3_Y 20 -#endif // BED_LEVELING +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/WITBOX/Configuration.h b/Marlin/example_configurations/WITBOX/Configuration.h index 998b692e99..be87a33dfa 100644 --- a/Marlin/example_configurations/WITBOX/Configuration.h +++ b/Marlin/example_configurations/WITBOX/Configuration.h @@ -740,41 +740,48 @@ // @section bedlevel /** - * Select one form of Auto Bed Leveling below. + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. * - * If you're also using the Probe for Z Homing, it's - * highly recommended to enable Z_SAFE_HOMING also! + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! * - * - 3POINT + * - AUTO_BED_LEVELING_3POINT * Probe 3 arbitrary points on the bed (that aren't collinear) * You specify the XY coordinates of all 3 points. * The result is a single tilted plane. Best for a flat bed. * - * - LINEAR + * - AUTO_BED_LEVELING_LINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a single tilted plane. Best for a flat bed. * - * - BILINEAR + * - AUTO_BED_LEVELING_BILINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. * - * - UBL Unified Bed Leveling - * A comprehensive bed leveling system that combines features and benefits from previous - * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use - * Mesh Generation, Mesh Validation and Mesh Editing system. - * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with - * that said, it was primarily designed to handle poor quality Delta Printers. If you feel - * adventurous and have a Delta, please post an issue if something doesn't work correctly. - * Initially, you will need to reduce your declared bed size so you have a rectangular area to - * test on. + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. Currently, UBL is only checked out + * for Cartesian Printers. That said, it was primarily designed to correct + * poor quality Delta Printers. If you feel adventurous and have a Delta, + * please post an issue if something doesn't work correctly. Initially, + * you will need to set a reduced bed size so you have a rectangular area + * to test on. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR -//#define MESH_BED_LEVELING //#define AUTO_BED_LEVELING_UBL +//#define MESH_BED_LEVELING /** * Enable detailed logging of G28, G29, M48, etc. @@ -833,25 +840,6 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#elif ENABLED(MESH_BED_LEVELING) - - //=========================================================================== - //=================================== Mesh ================================== - //=========================================================================== - - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif - #elif ENABLED(AUTO_BED_LEVELING_UBL) //=========================================================================== @@ -868,7 +856,26 @@ #define UBL_PROBE_PT_3_X 180 #define UBL_PROBE_PT_3_Y 20 -#endif // BED_LEVELING +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/adafruit/ST7565/Configuration.h b/Marlin/example_configurations/adafruit/ST7565/Configuration.h index bc22703f7e..f0538cf7c3 100644 --- a/Marlin/example_configurations/adafruit/ST7565/Configuration.h +++ b/Marlin/example_configurations/adafruit/ST7565/Configuration.h @@ -748,41 +748,48 @@ // @section bedlevel /** - * Select one form of Auto Bed Leveling below. + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. * - * If you're also using the Probe for Z Homing, it's - * highly recommended to enable Z_SAFE_HOMING also! + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! * - * - 3POINT + * - AUTO_BED_LEVELING_3POINT * Probe 3 arbitrary points on the bed (that aren't collinear) * You specify the XY coordinates of all 3 points. * The result is a single tilted plane. Best for a flat bed. * - * - LINEAR + * - AUTO_BED_LEVELING_LINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a single tilted plane. Best for a flat bed. * - * - BILINEAR + * - AUTO_BED_LEVELING_BILINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. * - * - UBL Unified Bed Leveling - * A comprehensive bed leveling system that combines features and benefits from previous - * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use - * Mesh Generation, Mesh Validation and Mesh Editing system. - * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with - * that said, it was primarily designed to handle poor quality Delta Printers. If you feel - * adventurous and have a Delta, please post an issue if something doesn't work correctly. - * Initially, you will need to reduce your declared bed size so you have a rectangular area to - * test on. + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. Currently, UBL is only checked out + * for Cartesian Printers. That said, it was primarily designed to correct + * poor quality Delta Printers. If you feel adventurous and have a Delta, + * please post an issue if something doesn't work correctly. Initially, + * you will need to set a reduced bed size so you have a rectangular area + * to test on. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR -//#define MESH_BED_LEVELING //#define AUTO_BED_LEVELING_UBL +//#define MESH_BED_LEVELING /** * Enable detailed logging of G28, G29, M48, etc. @@ -841,25 +848,6 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#elif ENABLED(MESH_BED_LEVELING) - - //=========================================================================== - //=================================== Mesh ================================== - //=========================================================================== - - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif - #elif ENABLED(AUTO_BED_LEVELING_UBL) //=========================================================================== @@ -876,7 +864,26 @@ #define UBL_PROBE_PT_3_X 180 #define UBL_PROBE_PT_3_Y 20 -#endif // BED_LEVELING +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/delta/flsun_kossel_mini/Configuration.h b/Marlin/example_configurations/delta/flsun_kossel_mini/Configuration.h index 5f0a8ee0a8..eae632fef8 100644 --- a/Marlin/example_configurations/delta/flsun_kossel_mini/Configuration.h +++ b/Marlin/example_configurations/delta/flsun_kossel_mini/Configuration.h @@ -853,41 +853,48 @@ // @section bedlevel /** - * Select one form of Auto Bed Leveling below. + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. * - * If you're also using the Probe for Z Homing, it's - * highly recommended to enable Z_SAFE_HOMING also! + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! * - * - 3POINT + * - AUTO_BED_LEVELING_3POINT * Probe 3 arbitrary points on the bed (that aren't collinear) * You specify the XY coordinates of all 3 points. * The result is a single tilted plane. Best for a flat bed. * - * - LINEAR + * - AUTO_BED_LEVELING_LINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a single tilted plane. Best for a flat bed. * - * - BILINEAR + * - AUTO_BED_LEVELING_BILINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. * - * - UBL Unified Bed Leveling - * A comprehensive bed leveling system that combines features and benefits from previous - * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use - * Mesh Generation, Mesh Validation and Mesh Editing system. - * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with - * that said, it was primarily designed to handle poor quality Delta Printers. If you feel - * adventurous and have a Delta, please post an issue if something doesn't work correctly. - * Initially, you will need to reduce your declared bed size so you have a rectangular area to - * test on. + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. Currently, UBL is only checked out + * for Cartesian Printers. That said, it was primarily designed to correct + * poor quality Delta Printers. If you feel adventurous and have a Delta, + * please post an issue if something doesn't work correctly. Initially, + * you will need to set a reduced bed size so you have a rectangular area + * to test on. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. */ //#define AUTO_BED_LEVELING_3POINT // Only AUTO_BED_LEVELING_BILINEAR is supported for DELTA bed leveling. //#define AUTO_BED_LEVELING_LINEAR // Only AUTO_BED_LEVELING_BILINEAR is supported for DELTA bed leveling. #define AUTO_BED_LEVELING_BILINEAR // Only AUTO_BED_LEVELING_BILINEAR is supported for DELTA bed leveling. -//#define MESH_BED_LEVELING //#define AUTO_BED_LEVELING_UBL +//#define MESH_BED_LEVELING /** * Enable detailed logging of G28, G29, M48, etc. @@ -946,25 +953,6 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#elif ENABLED(MESH_BED_LEVELING) - - //=========================================================================== - //=================================== Mesh ================================== - //=========================================================================== - - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif - #elif ENABLED(AUTO_BED_LEVELING_UBL) //=========================================================================== @@ -981,7 +969,26 @@ #define UBL_PROBE_PT_3_X 180 #define UBL_PROBE_PT_3_Y 20 -#endif // BED_LEVELING +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/delta/generic/Configuration.h b/Marlin/example_configurations/delta/generic/Configuration.h index a1fe690f2a..a08cdde5e2 100644 --- a/Marlin/example_configurations/delta/generic/Configuration.h +++ b/Marlin/example_configurations/delta/generic/Configuration.h @@ -838,41 +838,48 @@ // @section bedlevel /** - * Select one form of Auto Bed Leveling below. + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. * - * If you're also using the Probe for Z Homing, it's - * highly recommended to enable Z_SAFE_HOMING also! + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! * - * - 3POINT + * - AUTO_BED_LEVELING_3POINT * Probe 3 arbitrary points on the bed (that aren't collinear) * You specify the XY coordinates of all 3 points. * The result is a single tilted plane. Best for a flat bed. * - * - LINEAR + * - AUTO_BED_LEVELING_LINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a single tilted plane. Best for a flat bed. * - * - BILINEAR + * - AUTO_BED_LEVELING_BILINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. * - * - UBL Unified Bed Leveling - * A comprehensive bed leveling system that combines features and benefits from previous - * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use - * Mesh Generation, Mesh Validation and Mesh Editing system. - * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with - * that said, it was primarily designed to handle poor quality Delta Printers. If you feel - * adventurous and have a Delta, please post an issue if something doesn't work correctly. - * Initially, you will need to reduce your declared bed size so you have a rectangular area to - * test on. + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. Currently, UBL is only checked out + * for Cartesian Printers. That said, it was primarily designed to correct + * poor quality Delta Printers. If you feel adventurous and have a Delta, + * please post an issue if something doesn't work correctly. Initially, + * you will need to set a reduced bed size so you have a rectangular area + * to test on. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR -//#define MESH_BED_LEVELING //#define AUTO_BED_LEVELING_UBL +//#define MESH_BED_LEVELING /** * Enable detailed logging of G28, G29, M48, etc. @@ -932,25 +939,6 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#elif ENABLED(MESH_BED_LEVELING) - - //=========================================================================== - //=================================== Mesh ================================== - //=========================================================================== - - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif - #elif ENABLED(AUTO_BED_LEVELING_UBL) //=========================================================================== @@ -967,7 +955,26 @@ #define UBL_PROBE_PT_3_X 180 #define UBL_PROBE_PT_3_Y 20 -#endif // BED_LEVELING +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/delta/kossel_mini/Configuration.h b/Marlin/example_configurations/delta/kossel_mini/Configuration.h index 690a0ac714..084331a75d 100644 --- a/Marlin/example_configurations/delta/kossel_mini/Configuration.h +++ b/Marlin/example_configurations/delta/kossel_mini/Configuration.h @@ -841,41 +841,48 @@ // @section bedlevel /** - * Select one form of Auto Bed Leveling below. + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. * - * If you're also using the Probe for Z Homing, it's - * highly recommended to enable Z_SAFE_HOMING also! + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! * - * - 3POINT + * - AUTO_BED_LEVELING_3POINT * Probe 3 arbitrary points on the bed (that aren't collinear) * You specify the XY coordinates of all 3 points. * The result is a single tilted plane. Best for a flat bed. * - * - LINEAR + * - AUTO_BED_LEVELING_LINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a single tilted plane. Best for a flat bed. * - * - BILINEAR + * - AUTO_BED_LEVELING_BILINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. * - * - UBL Unified Bed Leveling - * A comprehensive bed leveling system that combines features and benefits from previous - * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use - * Mesh Generation, Mesh Validation and Mesh Editing system. - * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with - * that said, it was primarily designed to handle poor quality Delta Printers. If you feel - * adventurous and have a Delta, please post an issue if something doesn't work correctly. - * Initially, you will need to reduce your declared bed size so you have a rectangular area to - * test on. + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. Currently, UBL is only checked out + * for Cartesian Printers. That said, it was primarily designed to correct + * poor quality Delta Printers. If you feel adventurous and have a Delta, + * please post an issue if something doesn't work correctly. Initially, + * you will need to set a reduced bed size so you have a rectangular area + * to test on. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR -//#define MESH_BED_LEVELING //#define AUTO_BED_LEVELING_UBL +//#define MESH_BED_LEVELING /** * Enable detailed logging of G28, G29, M48, etc. @@ -936,25 +943,6 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#elif ENABLED(MESH_BED_LEVELING) - - //=========================================================================== - //=================================== Mesh ================================== - //=========================================================================== - - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif - #elif ENABLED(AUTO_BED_LEVELING_UBL) //=========================================================================== @@ -971,7 +959,26 @@ #define UBL_PROBE_PT_3_X 180 #define UBL_PROBE_PT_3_Y 20 -#endif // BED_LEVELING +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/delta/kossel_pro/Configuration.h b/Marlin/example_configurations/delta/kossel_pro/Configuration.h index af36b4def9..44b3d8279d 100644 --- a/Marlin/example_configurations/delta/kossel_pro/Configuration.h +++ b/Marlin/example_configurations/delta/kossel_pro/Configuration.h @@ -840,41 +840,48 @@ // @section bedlevel /** - * Select one form of Auto Bed Leveling below. + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. * - * If you're also using the Probe for Z Homing, it's - * highly recommended to enable Z_SAFE_HOMING also! + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! * - * - 3POINT + * - AUTO_BED_LEVELING_3POINT * Probe 3 arbitrary points on the bed (that aren't collinear) * You specify the XY coordinates of all 3 points. * The result is a single tilted plane. Best for a flat bed. * - * - LINEAR + * - AUTO_BED_LEVELING_LINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a single tilted plane. Best for a flat bed. * - * - BILINEAR + * - AUTO_BED_LEVELING_BILINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. * - * - UBL Unified Bed Leveling - * A comprehensive bed leveling system that combines features and benefits from previous - * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use - * Mesh Generation, Mesh Validation and Mesh Editing system. - * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with - * that said, it was primarily designed to handle poor quality Delta Printers. If you feel - * adventurous and have a Delta, please post an issue if something doesn't work correctly. - * Initially, you will need to reduce your declared bed size so you have a rectangular area to - * test on. + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. Currently, UBL is only checked out + * for Cartesian Printers. That said, it was primarily designed to correct + * poor quality Delta Printers. If you feel adventurous and have a Delta, + * please post an issue if something doesn't work correctly. Initially, + * you will need to set a reduced bed size so you have a rectangular area + * to test on. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR -//#define MESH_BED_LEVELING //#define AUTO_BED_LEVELING_UBL +//#define MESH_BED_LEVELING /** * Enable detailed logging of G28, G29, M48, etc. @@ -935,25 +942,6 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#elif ENABLED(MESH_BED_LEVELING) - - //=========================================================================== - //=================================== Mesh ================================== - //=========================================================================== - - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif - #elif ENABLED(AUTO_BED_LEVELING_UBL) //=========================================================================== @@ -970,7 +958,26 @@ #define UBL_PROBE_PT_3_X 180 #define UBL_PROBE_PT_3_Y 20 -#endif // BED_LEVELING +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/delta/kossel_xl/Configuration.h b/Marlin/example_configurations/delta/kossel_xl/Configuration.h index 0e3410227e..d0e1b870a8 100644 --- a/Marlin/example_configurations/delta/kossel_xl/Configuration.h +++ b/Marlin/example_configurations/delta/kossel_xl/Configuration.h @@ -851,41 +851,48 @@ // @section bedlevel /** - * Select one form of Auto Bed Leveling below. + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. * - * If you're also using the Probe for Z Homing, it's - * highly recommended to enable Z_SAFE_HOMING also! + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! * - * - 3POINT + * - AUTO_BED_LEVELING_3POINT * Probe 3 arbitrary points on the bed (that aren't collinear) * You specify the XY coordinates of all 3 points. * The result is a single tilted plane. Best for a flat bed. * - * - LINEAR + * - AUTO_BED_LEVELING_LINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a single tilted plane. Best for a flat bed. * - * - BILINEAR + * - AUTO_BED_LEVELING_BILINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. * - * - UBL Unified Bed Leveling - * A comprehensive bed leveling system that combines features and benefits from previous - * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use - * Mesh Generation, Mesh Validation and Mesh Editing system. - * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with - * that said, it was primarily designed to handle poor quality Delta Printers. If you feel - * adventurous and have a Delta, please post an issue if something doesn't work correctly. - * Initially, you will need to reduce your declared bed size so you have a rectangular area to - * test on. + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. Currently, UBL is only checked out + * for Cartesian Printers. That said, it was primarily designed to correct + * poor quality Delta Printers. If you feel adventurous and have a Delta, + * please post an issue if something doesn't work correctly. Initially, + * you will need to set a reduced bed size so you have a rectangular area + * to test on. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR -//#define MESH_BED_LEVELING //#define AUTO_BED_LEVELING_UBL +//#define MESH_BED_LEVELING /** * Enable detailed logging of G28, G29, M48, etc. @@ -945,25 +952,6 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#elif ENABLED(MESH_BED_LEVELING) - - //=========================================================================== - //=================================== Mesh ================================== - //=========================================================================== - - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif - #elif ENABLED(AUTO_BED_LEVELING_UBL) //=========================================================================== @@ -980,7 +968,26 @@ #define UBL_PROBE_PT_3_X 180 #define UBL_PROBE_PT_3_Y 20 -#endif // BED_LEVELING +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/makibox/Configuration.h b/Marlin/example_configurations/makibox/Configuration.h index 0d5b87ff88..2e17c6998a 100644 --- a/Marlin/example_configurations/makibox/Configuration.h +++ b/Marlin/example_configurations/makibox/Configuration.h @@ -751,41 +751,48 @@ // @section bedlevel /** - * Select one form of Auto Bed Leveling below. + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. * - * If you're also using the Probe for Z Homing, it's - * highly recommended to enable Z_SAFE_HOMING also! + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! * - * - 3POINT + * - AUTO_BED_LEVELING_3POINT * Probe 3 arbitrary points on the bed (that aren't collinear) * You specify the XY coordinates of all 3 points. * The result is a single tilted plane. Best for a flat bed. * - * - LINEAR + * - AUTO_BED_LEVELING_LINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a single tilted plane. Best for a flat bed. * - * - BILINEAR + * - AUTO_BED_LEVELING_BILINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. * - * - UBL Unified Bed Leveling - * A comprehensive bed leveling system that combines features and benefits from previous - * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use - * Mesh Generation, Mesh Validation and Mesh Editing system. - * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with - * that said, it was primarily designed to handle poor quality Delta Printers. If you feel - * adventurous and have a Delta, please post an issue if something doesn't work correctly. - * Initially, you will need to reduce your declared bed size so you have a rectangular area to - * test on. + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. Currently, UBL is only checked out + * for Cartesian Printers. That said, it was primarily designed to correct + * poor quality Delta Printers. If you feel adventurous and have a Delta, + * please post an issue if something doesn't work correctly. Initially, + * you will need to set a reduced bed size so you have a rectangular area + * to test on. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR -//#define MESH_BED_LEVELING //#define AUTO_BED_LEVELING_UBL +//#define MESH_BED_LEVELING /** * Enable detailed logging of G28, G29, M48, etc. @@ -844,25 +851,6 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#elif ENABLED(MESH_BED_LEVELING) - - //=========================================================================== - //=================================== Mesh ================================== - //=========================================================================== - - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif - #elif ENABLED(AUTO_BED_LEVELING_UBL) //=========================================================================== @@ -879,7 +867,26 @@ #define UBL_PROBE_PT_3_X 180 #define UBL_PROBE_PT_3_Y 20 -#endif // BED_LEVELING +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/example_configurations/tvrrug/Round2/Configuration.h b/Marlin/example_configurations/tvrrug/Round2/Configuration.h index ec0b87f80a..e732ce4355 100644 --- a/Marlin/example_configurations/tvrrug/Round2/Configuration.h +++ b/Marlin/example_configurations/tvrrug/Round2/Configuration.h @@ -744,41 +744,48 @@ // @section bedlevel /** - * Select one form of Auto Bed Leveling below. + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. * - * If you're also using the Probe for Z Homing, it's - * highly recommended to enable Z_SAFE_HOMING also! + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! * - * - 3POINT + * - AUTO_BED_LEVELING_3POINT * Probe 3 arbitrary points on the bed (that aren't collinear) * You specify the XY coordinates of all 3 points. * The result is a single tilted plane. Best for a flat bed. * - * - LINEAR + * - AUTO_BED_LEVELING_LINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a single tilted plane. Best for a flat bed. * - * - BILINEAR + * - AUTO_BED_LEVELING_BILINEAR * Probe several points in a grid. * You specify the rectangle and the density of sample points. * The result is a mesh, best for large or uneven beds. * - * - UBL Unified Bed Leveling - * A comprehensive bed leveling system that combines features and benefits from previous - * bed leveling system. The UBL Bed Leveling System also includes an integrated and easy to use - * Mesh Generation, Mesh Validation and Mesh Editing system. - * - Currently, the UBL Bed Leveling System is only checked out for Cartesian Printers. But with - * that said, it was primarily designed to handle poor quality Delta Printers. If you feel - * adventurous and have a Delta, please post an issue if something doesn't work correctly. - * Initially, you will need to reduce your declared bed size so you have a rectangular area to - * test on. + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. Currently, UBL is only checked out + * for Cartesian Printers. That said, it was primarily designed to correct + * poor quality Delta Printers. If you feel adventurous and have a Delta, + * please post an issue if something doesn't work correctly. Initially, + * you will need to set a reduced bed size so you have a rectangular area + * to test on. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. */ //#define AUTO_BED_LEVELING_3POINT //#define AUTO_BED_LEVELING_LINEAR //#define AUTO_BED_LEVELING_BILINEAR -//#define MESH_BED_LEVELING //#define AUTO_BED_LEVELING_UBL +//#define MESH_BED_LEVELING /** * Enable detailed logging of G28, G29, M48, etc. @@ -837,25 +844,6 @@ #define ABL_PROBE_PT_3_X 170 #define ABL_PROBE_PT_3_Y 20 -#elif ENABLED(MESH_BED_LEVELING) - - //=========================================================================== - //=================================== Mesh ================================== - //=========================================================================== - - #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment - #define MESH_INSET 10 // Mesh inset margin on print area - #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. - #define MESH_NUM_Y_POINTS 3 - - //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS - - //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. - - #if ENABLED(MANUAL_BED_LEVELING) - #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. - #endif - #elif ENABLED(AUTO_BED_LEVELING_UBL) //=========================================================================== @@ -872,7 +860,26 @@ #define UBL_PROBE_PT_3_X 180 #define UBL_PROBE_PT_3_Y 20 -#endif // BED_LEVELING +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Mesh inset margin on print area + #define MESH_NUM_X_POINTS 3 // Don't use more than 7 points per axis, implementation limited. + #define MESH_NUM_Y_POINTS 3 + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + + //#define MANUAL_BED_LEVELING // Add display menu option for bed leveling. + #define MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment + + #if ENABLED(MANUAL_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #endif + +#endif // BED_LEVELING /** * Commands to execute at the end of G29 probing. diff --git a/Marlin/servo.cpp b/Marlin/servo.cpp index 34f6dbde87..5be9441e44 100644 --- a/Marlin/servo.cpp +++ b/Marlin/servo.cpp @@ -126,7 +126,7 @@ static inline void handle_interrupts(timer16_Sequence_t timer, volatile uint16_t SIGNAL (TIMER5_COMPA_vect) { handle_interrupts(_timer5, &TCNT5, &OCR5A); } #endif -#else //!WIRING +#else // WIRING // Interrupt handlers for Wiring #if ENABLED(_useTimer1) @@ -136,7 +136,7 @@ static inline void handle_interrupts(timer16_Sequence_t timer, volatile uint16_t void Timer3Service() { handle_interrupts(_timer3, &TCNT3, &OCR3A); } #endif -#endif //!WIRING +#endif // WIRING static void initISR(timer16_Sequence_t timer) { diff --git a/Marlin/ultralcd.cpp b/Marlin/ultralcd.cpp index 39ab47e325..7a8905987d 100755 --- a/Marlin/ultralcd.cpp +++ b/Marlin/ultralcd.cpp @@ -124,8 +124,8 @@ uint16_t max_display_update_time = 0; int32_t lastEncoderMovementMillis; #if ENABLED(AUTO_BED_LEVELING_UBL) - extern int UBL_has_control_of_LCD_Panel; - extern int G29_encoderDiff; + extern bool ubl_has_control_of_lcd_panel; + extern uint8_t ubl_encoderDiff; #endif #if HAS_POWER_SWITCH @@ -854,88 +854,72 @@ void kill_screen(const char* lcd_msg) { #if ENABLED(AUTO_BED_LEVELING_UBL) - float Mesh_Edit_Value, Mesh_Edit_Accumulator; // We round Mesh_Edit_Value to 2.5 decimal places. So we keep a + float mesh_edit_value, mesh_edit_accumulator; // We round mesh_edit_value to 2.5 decimal places. So we keep a // seperate value that doesn't lose precision. - static int loop_cnt=0, last_seen_bits, UBL_encoderPosition=0; + static int ubl_encoderPosition = 0; - static void _lcd_mesh_fine_tune( const char* msg) { - static unsigned long last_click=0; - int last_digit, movement; - long int rounded; + static void _lcd_mesh_fine_tune(const char* msg) { + static millis_t next_click = 0; + int16_t last_digit, movement; + int32_t rounded; defer_return_to_status = true; + if (ubl_encoderDiff) { + // If moving the Encoder wheel very slowly, move by just 1 position + ubl_encoderPosition = ELAPSED(millis(), next_click) + ? ubl_encoderDiff > 0 ? 1 : -1 + : ubl_encoderDiff * 2; - if (G29_encoderDiff) { // If moving the Encoder wheel very slowly, we just go - if ( (millis() - last_click) > 200L) { // up or down by 1 position - if ( G29_encoderDiff > 0 ) - UBL_encoderPosition = 1; - else { - UBL_encoderPosition = -1; - } - } else - UBL_encoderPosition = G29_encoderDiff * 2; + ubl_encoderDiff = 0; + next_click = millis() + 200L; - G29_encoderDiff = 0; - last_click = millis(); + mesh_edit_accumulator += float((int32_t)ubl_encoderPosition) * .005 / 2.0; + mesh_edit_value = mesh_edit_accumulator; + encoderPosition = 0; + lcdDrawUpdate = LCDVIEW_REDRAW_NOW; - Mesh_Edit_Accumulator += ( (float) (UBL_encoderPosition)) * .005 / 2.0 ; - Mesh_Edit_Value = Mesh_Edit_Accumulator; - encoderPosition = 0; - lcdDrawUpdate = LCDVIEW_REDRAW_NOW; - - rounded = (long int) (Mesh_Edit_Value * 1000.0); + rounded = (int32_t)(mesh_edit_value * 1000.0); last_digit = rounded % 5L; //10L; - rounded = rounded - last_digit; + rounded -= last_digit; last_digit = rounded % 5L; //10L; - Mesh_Edit_Value = ((float) rounded) / 1000.0; + mesh_edit_value = float(rounded) / 1000.0; } - if (lcdDrawUpdate) { - lcd_implementation_drawedit(msg, ftostr43sign( (float) Mesh_Edit_Value )); - } + if (lcdDrawUpdate) + lcd_implementation_drawedit(msg, ftostr43sign(mesh_edit_value)); } void _lcd_mesh_edit() { - _lcd_mesh_fine_tune( PSTR("Mesh Editor: ")); + _lcd_mesh_fine_tune(PSTR("Mesh Editor: ")); defer_return_to_status = true; } float lcd_mesh_edit() { lcd_goto_screen(_lcd_mesh_edit); - _lcd_mesh_fine_tune( PSTR("Mesh Editor: ")); - defer_return_to_status = true; - return Mesh_Edit_Value; + return mesh_edit_value; } - - void lcd_mesh_edit_setup(float inital) { - Mesh_Edit_Value = inital; - Mesh_Edit_Accumulator = inital; + void lcd_mesh_edit_setup(float initial) { + mesh_edit_value = mesh_edit_accumulator = initial; lcd_goto_screen(_lcd_mesh_edit); - defer_return_to_status = true; - return ; } void _lcd_z_offset_edit() { - _lcd_mesh_fine_tune( PSTR("Z-Offset: ")); + _lcd_mesh_fine_tune(PSTR("Z-Offset: ")); + defer_return_to_status = true; } float lcd_z_offset_edit() { lcd_goto_screen(_lcd_z_offset_edit); - defer_return_to_status = true; - return Mesh_Edit_Value; + return mesh_edit_value; } - void lcd_z_offset_edit_setup(float inital) { - Mesh_Edit_Value = inital; - Mesh_Edit_Accumulator = inital; + void lcd_z_offset_edit_setup(float initial) { + mesh_edit_value = mesh_edit_accumulator = initial; lcd_goto_screen(_lcd_z_offset_edit); - defer_return_to_status = true; - return ; } - #endif // AUTO_BED_LEVELING_UBL @@ -3232,7 +3216,7 @@ void lcd_update() { lcd_buttons_update(); #if ENABLED(AUTO_BED_LEVELING_UBL) - const bool UBL_CONDITION = !UBL_has_control_of_LCD_Panel; + const bool UBL_CONDITION = !ubl_has_control_of_lcd_panel; #else constexpr bool UBL_CONDITION = true; #endif @@ -3648,8 +3632,8 @@ void lcd_reset_alert_level() { lcd_status_message_level = 0; } case encrot3: ENCODER_SPIN(encrot2, encrot0); break; } #if ENABLED(AUTO_BED_LEVELING_UBL) - if (UBL_has_control_of_LCD_Panel) { - G29_encoderDiff = encoderDiff; // Make the encoder's rotation available to G29's Mesh Editor + if (ubl_has_control_of_lcd_panel) { + ubl_encoderDiff = encoderDiff; // Make the encoder's rotation available to G29's Mesh Editor encoderDiff = 0; // We are going to lie to the LCD Panel and claim the encoder // wheel has not turned. } @@ -3665,6 +3649,7 @@ void lcd_reset_alert_level() { lcd_status_message_level = 0; } #endif #if ENABLED(AUTO_BED_LEVELING_UBL) + void chirp_at_user() { #if ENABLED(LCD_USE_I2C_BUZZER) lcd.buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ); @@ -3673,7 +3658,7 @@ void lcd_reset_alert_level() { lcd_status_message_level = 0; } #endif } - bool G29_lcd_clicked() { return LCD_CLICKED; } + bool ubl_lcd_clicked() { return LCD_CLICKED; } #endif diff --git a/Marlin/ultralcd.h b/Marlin/ultralcd.h index 6b7179902b..4a69591501 100644 --- a/Marlin/ultralcd.h +++ b/Marlin/ultralcd.h @@ -164,4 +164,11 @@ #endif // ULTRA_LCD +#if ENABLED(AUTO_BED_LEVELING_UBL) + void lcd_mesh_edit_setup(float initial); + float lcd_mesh_edit(); + void lcd_z_offset_edit_setup(float); + float lcd_z_offset_edit(); +#endif + #endif // ULTRALCD_H