Additional cleanup of UBL code

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

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,13 +847,28 @@
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+  //===========================================================================
+  //========================= Unified Bed Leveling ============================
+  //===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_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
@@ -855,28 +876,13 @@
   //#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
 
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-
-  //===========================================================================
-  //========================= Unified Bed Leveling ============================
-  //===========================================================================
-
-  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
-  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
-  #define UBL_MESH_NUM_Y_POINTS 10
-  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
-  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
-  #define UBL_PROBE_PT_2_X 39
-  #define UBL_PROBE_PT_2_Y 20
-  #define UBL_PROBE_PT_3_X 180
-  #define UBL_PROBE_PT_3_Y 20
-
-#endif  // BED_LEVELING
+#endif // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

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++; // Take control of the LCD Panel!
+    debug_current_and_destination((char*)"Starting G26 Mesh Validation Pattern.");
 
-    UBL_has_control_of_LCD_Panel = 1; // 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

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);
       }
+      else
+        SERIAL_ECHOPGM(" (disabled)");
+
       SERIAL_EOL;
-    #endif
 
+    #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);
 

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
 

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

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");

Marlin/UBL_line_to_destination.cpp

@@ -19,116 +19,118 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  */
-#include "Marlin.h"
+#include "MarlinConfig.h"
 
 #if ENABLED(AUTO_BED_LEVELING_UBL)
 
+  #include "Marlin.h"
   #include "UBL.h"
   #include "planner.h"
   #include <avr/io.h>
   #include <math.h>
 
   extern void set_current_to_destination();
-  extern bool G26_Debug_flag;
-  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) {
-
-    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
-    //
+  extern void debug_current_and_destination(char *title);
+
+  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;
+
+    /**
+     * 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.
+       */
+
+      a0ma1diva2ma1 = (x_end - mesh_index_to_x_location[cell_dest_xi]) * 0.1 * (MESH_X_DIST);
+
+      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] +
-      (z_values[cell_dest_xi+1][cell_dest_yi+1] - z_values[cell_dest_xi][cell_dest_yi+1]) * a0ma1diva2ma1;
+      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
+      // 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 );
-
-      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 = z0 * ubl.fade_scaling_factor_for_z(z_end);
+
+      /**
+       * 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 );
-
-        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];
-
-        // 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
+        //*/
+
+        z0 = z0 * ubl.fade_scaling_factor_for_z(z_end);
+
+        /**
+         * 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;     
+
+        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 );
-
-        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];
-
-        // 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
+        //*/
+
+        z0 = z0 * ubl.fade_scaling_factor_for_z(z_end);
+
+        /**
+         * 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;
+
+        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
+      if (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.
-        }
+        //*/
 
-        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;
-          }
+        z0 *= ubl.fade_scaling_factor_for_z(z_end);
+
+        /**
+         * 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)  {
-      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
+    if (g26_debug_flag)
+      debug_current_and_destination((char*)"generic move done in ubl_line_to_destination()");
 
-    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();
+    if (current_position[0] != x_end || current_position[1] != y_end)
+      goto FINAL_MOVE;
 
-    delay(50);
-    while (!(READ(66) & 0x01)) idle();
-    delay(50);
+    set_current_to_destination();
   }
 
 #endif
-
-

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);

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);

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,13 +848,28 @@
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+  //===========================================================================
+  //========================= Unified Bed Leveling ============================
+  //===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_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
@@ -855,28 +877,13 @@
   //#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
 
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-
-  //===========================================================================
-  //========================= Unified Bed Leveling ============================
-  //===========================================================================
-
-  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
-  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
-  #define UBL_MESH_NUM_Y_POINTS 10
-  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
-  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
-  #define UBL_PROBE_PT_2_X 39
-  #define UBL_PROBE_PT_2_Y 20
-  #define UBL_PROBE_PT_3_X 180
-  #define UBL_PROBE_PT_3_Y 20
-
-#endif  // BED_LEVELING
+#endif // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

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,13 +831,28 @@
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+  //===========================================================================
+  //========================= Unified Bed Leveling ============================
+  //===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_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
@@ -838,28 +860,13 @@
   //#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
 
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-
-  //===========================================================================
-  //========================= Unified Bed Leveling ============================
-  //===========================================================================
-
-  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
-  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
-  #define UBL_MESH_NUM_Y_POINTS 10
-  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
-  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
-  #define UBL_PROBE_PT_2_X 39
-  #define UBL_PROBE_PT_2_Y 20
-  #define UBL_PROBE_PT_3_X 180
-  #define UBL_PROBE_PT_3_Y 20
-
-#endif  // BED_LEVELING
+#endif // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

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,13 +831,28 @@
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+  //===========================================================================
+  //========================= Unified Bed Leveling ============================
+  //===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_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
@@ -838,28 +860,13 @@
   //#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
 
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-
-  //===========================================================================
-  //========================= Unified Bed Leveling ============================
-  //===========================================================================
-
-  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
-  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
-  #define UBL_MESH_NUM_Y_POINTS 10
-  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
-  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
-  #define UBL_PROBE_PT_2_X 39
-  #define UBL_PROBE_PT_2_Y 20
-  #define UBL_PROBE_PT_3_X 180
-  #define UBL_PROBE_PT_3_Y 20
-
-#endif  // BED_LEVELING
+#endif // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

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,13 +840,28 @@
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+  //===========================================================================
+  //========================= Unified Bed Leveling ============================
+  //===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_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
@@ -847,28 +869,13 @@
   //#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
 
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-
-  //===========================================================================
-  //========================= Unified Bed Leveling ============================
-  //===========================================================================
-
-  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
-  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
-  #define UBL_MESH_NUM_Y_POINTS 10
-  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
-  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
-  #define UBL_PROBE_PT_2_X 39
-  #define UBL_PROBE_PT_2_Y 20
-  #define UBL_PROBE_PT_3_X 180
-  #define UBL_PROBE_PT_3_Y 20
-
-#endif  // BED_LEVELING
+#endif // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

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,13 +842,28 @@
   #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(AUTO_BED_LEVELING_UBL)
+
+  //===========================================================================
+  //========================= Unified Bed Leveling ============================
+  //===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_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
@@ -849,28 +871,13 @@
   //#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
 
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-
-  //===========================================================================
-  //========================= Unified Bed Leveling ============================
-  //===========================================================================
-
-  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
-  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
-  #define UBL_MESH_NUM_Y_POINTS 10
-  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
-  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
-  #define UBL_PROBE_PT_2_X 39
-  #define UBL_PROBE_PT_2_Y 20
-  #define UBL_PROBE_PT_3_X 180
-  #define UBL_PROBE_PT_3_Y 20
-
-#endif  // BED_LEVELING
+#endif // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

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,13 +877,28 @@
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+  //===========================================================================
+  //========================= Unified Bed Leveling ============================
+  //===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_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
@@ -884,28 +906,13 @@
   //#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
 
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-
-  //===========================================================================
-  //========================= Unified Bed Leveling ============================
-  //===========================================================================
-
-  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
-  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
-  #define UBL_MESH_NUM_Y_POINTS 10
-  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
-  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
-  #define UBL_PROBE_PT_2_X 39
-  #define UBL_PROBE_PT_2_Y 20
-  #define UBL_PROBE_PT_3_X 180
-  #define UBL_PROBE_PT_3_Y 20
-
-#endif  // BED_LEVELING
+#endif // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

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,13 +848,28 @@
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+  //===========================================================================
+  //========================= Unified Bed Leveling ============================
+  //===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_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
@@ -855,28 +877,13 @@
   //#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
 
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-
-  //===========================================================================
-  //========================= Unified Bed Leveling ============================
-  //===========================================================================
-
-  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
-  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
-  #define UBL_MESH_NUM_Y_POINTS 10
-  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
-  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
-  #define UBL_PROBE_PT_2_X 39
-  #define UBL_PROBE_PT_2_Y 20
-  #define UBL_PROBE_PT_3_X 180
-  #define UBL_PROBE_PT_3_Y 20
-
-#endif  // BED_LEVELING
+#endif // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

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,13 +848,28 @@
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+  //===========================================================================
+  //========================= Unified Bed Leveling ============================
+  //===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_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
@@ -855,28 +877,13 @@
   //#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
 
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-
-  //===========================================================================
-  //========================= Unified Bed Leveling ============================
-  //===========================================================================
-
-  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
-  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
-  #define UBL_MESH_NUM_Y_POINTS 10
-  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
-  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
-  #define UBL_PROBE_PT_2_X 39
-  #define UBL_PROBE_PT_2_Y 20
-  #define UBL_PROBE_PT_3_X 180
-  #define UBL_PROBE_PT_3_Y 20
-
-#endif  // BED_LEVELING
+#endif // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

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,13 +848,28 @@
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+  //===========================================================================
+  //========================= Unified Bed Leveling ============================
+  //===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_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
@@ -855,28 +877,13 @@
   //#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
 
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-
-  //===========================================================================
-  //========================= Unified Bed Leveling ============================
-  //===========================================================================
-
-  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
-  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
-  #define UBL_MESH_NUM_Y_POINTS 10
-  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
-  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
-  #define UBL_PROBE_PT_2_X 39
-  #define UBL_PROBE_PT_2_Y 20
-  #define UBL_PROBE_PT_3_X 180
-  #define UBL_PROBE_PT_3_Y 20
-
-#endif  // BED_LEVELING
+#endif // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

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,13 +847,28 @@
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+  //===========================================================================
+  //========================= Unified Bed Leveling ============================
+  //===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_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
@@ -854,28 +876,13 @@
   //#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
 
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-
-  //===========================================================================
-  //========================= Unified Bed Leveling ============================
-  //===========================================================================
-
-  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
-  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
-  #define UBL_MESH_NUM_Y_POINTS 10
-  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
-  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
-  #define UBL_PROBE_PT_2_X 39
-  #define UBL_PROBE_PT_2_Y 20
-  #define UBL_PROBE_PT_3_X 180
-  #define UBL_PROBE_PT_3_Y 20
-
-#endif  // BED_LEVELING
+#endif // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

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,13 +863,28 @@
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+  //===========================================================================
+  //========================= Unified Bed Leveling ============================
+  //===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_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
@@ -870,28 +892,13 @@
   //#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
 
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-
-  //===========================================================================
-  //========================= Unified Bed Leveling ============================
-  //===========================================================================
-
-  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
-  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
-  #define UBL_MESH_NUM_Y_POINTS 10
-  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
-  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
-  #define UBL_PROBE_PT_2_X 39
-  #define UBL_PROBE_PT_2_Y 20
-  #define UBL_PROBE_PT_3_X 180
-  #define UBL_PROBE_PT_3_Y 20
-
-#endif  // BED_LEVELING
+#endif // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

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,13 +869,28 @@
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+  //===========================================================================
+  //========================= Unified Bed Leveling ============================
+  //===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_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
@@ -876,28 +898,13 @@
   //#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
 
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-
-  //===========================================================================
-  //========================= Unified Bed Leveling ============================
-  //===========================================================================
-
-  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
-  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
-  #define UBL_MESH_NUM_Y_POINTS 10
-  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
-  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
-  #define UBL_PROBE_PT_2_X 39
-  #define UBL_PROBE_PT_2_Y 20
-  #define UBL_PROBE_PT_3_X 180
-  #define UBL_PROBE_PT_3_Y 20
-
-#endif  // BED_LEVELING
+#endif // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

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,13 +840,28 @@
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+  //===========================================================================
+  //========================= Unified Bed Leveling ============================
+  //===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_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
@@ -847,28 +869,13 @@
   //#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
 
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-
-  //===========================================================================
-  //========================= Unified Bed Leveling ============================
-  //===========================================================================
-
-  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
-  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
-  #define UBL_MESH_NUM_Y_POINTS 10
-  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
-  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
-  #define UBL_PROBE_PT_2_X 39
-  #define UBL_PROBE_PT_2_Y 20
-  #define UBL_PROBE_PT_3_X 180
-  #define UBL_PROBE_PT_3_Y 20
-
-#endif  // BED_LEVELING
+#endif // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

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,13 +848,28 @@
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+  //===========================================================================
+  //========================= Unified Bed Leveling ============================
+  //===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_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
@@ -855,28 +877,13 @@
   //#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
 
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-
-  //===========================================================================
-  //========================= Unified Bed Leveling ============================
-  //===========================================================================
-
-  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
-  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
-  #define UBL_MESH_NUM_Y_POINTS 10
-  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
-  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
-  #define UBL_PROBE_PT_2_X 39
-  #define UBL_PROBE_PT_2_Y 20
-  #define UBL_PROBE_PT_3_X 180
-  #define UBL_PROBE_PT_3_Y 20
-
-#endif  // BED_LEVELING
+#endif // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

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,13 +953,28 @@
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+  //===========================================================================
+  //========================= Unified Bed Leveling ============================
+  //===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_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
@@ -960,28 +982,13 @@
   //#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
 
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-
-  //===========================================================================
-  //========================= Unified Bed Leveling ============================
-  //===========================================================================
-
-  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
-  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
-  #define UBL_MESH_NUM_Y_POINTS 10
-  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
-  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
-  #define UBL_PROBE_PT_2_X 39
-  #define UBL_PROBE_PT_2_Y 20
-  #define UBL_PROBE_PT_3_X 180
-  #define UBL_PROBE_PT_3_Y 20
-
-#endif  // BED_LEVELING
+#endif // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

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,13 +939,28 @@
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+  //===========================================================================
+  //========================= Unified Bed Leveling ============================
+  //===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_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
@@ -946,28 +968,13 @@
   //#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
 
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-
-  //===========================================================================
-  //========================= Unified Bed Leveling ============================
-  //===========================================================================
-
-  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
-  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
-  #define UBL_MESH_NUM_Y_POINTS 10
-  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
-  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
-  #define UBL_PROBE_PT_2_X 39
-  #define UBL_PROBE_PT_2_Y 20
-  #define UBL_PROBE_PT_3_X 180
-  #define UBL_PROBE_PT_3_Y 20
-
-#endif  // BED_LEVELING
+#endif // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

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,13 +943,28 @@
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+  //===========================================================================
+  //========================= Unified Bed Leveling ============================
+  //===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_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
@@ -950,28 +972,13 @@
   //#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
 
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-
-  //===========================================================================
-  //========================= Unified Bed Leveling ============================
-  //===========================================================================
-
-  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
-  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
-  #define UBL_MESH_NUM_Y_POINTS 10
-  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
-  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
-  #define UBL_PROBE_PT_2_X 39
-  #define UBL_PROBE_PT_2_Y 20
-  #define UBL_PROBE_PT_3_X 180
-  #define UBL_PROBE_PT_3_Y 20
-
-#endif  // BED_LEVELING
+#endif // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

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,13 +942,28 @@
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+  //===========================================================================
+  //========================= Unified Bed Leveling ============================
+  //===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_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
@@ -949,28 +971,13 @@
   //#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
 
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-
-  //===========================================================================
-  //========================= Unified Bed Leveling ============================
-  //===========================================================================
-
-  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
-  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
-  #define UBL_MESH_NUM_Y_POINTS 10
-  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
-  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
-  #define UBL_PROBE_PT_2_X 39
-  #define UBL_PROBE_PT_2_Y 20
-  #define UBL_PROBE_PT_3_X 180
-  #define UBL_PROBE_PT_3_Y 20
-
-#endif  // BED_LEVELING
+#endif // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

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,13 +952,28 @@
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+  //===========================================================================
+  //========================= Unified Bed Leveling ============================
+  //===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_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
@@ -959,28 +981,13 @@
   //#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
 
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-
-  //===========================================================================
-  //========================= Unified Bed Leveling ============================
-  //===========================================================================
-
-  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
-  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
-  #define UBL_MESH_NUM_Y_POINTS 10
-  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
-  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
-  #define UBL_PROBE_PT_2_X 39
-  #define UBL_PROBE_PT_2_Y 20
-  #define UBL_PROBE_PT_3_X 180
-  #define UBL_PROBE_PT_3_Y 20
-
-#endif  // BED_LEVELING
+#endif // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

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,13 +851,28 @@
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+  //===========================================================================
+  //========================= Unified Bed Leveling ============================
+  //===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_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
@@ -858,28 +880,13 @@
   //#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
 
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-
-  //===========================================================================
-  //========================= Unified Bed Leveling ============================
-  //===========================================================================
-
-  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
-  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
-  #define UBL_MESH_NUM_Y_POINTS 10
-  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
-  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
-  #define UBL_PROBE_PT_2_X 39
-  #define UBL_PROBE_PT_2_Y 20
-  #define UBL_PROBE_PT_3_X 180
-  #define UBL_PROBE_PT_3_Y 20
-
-#endif  // BED_LEVELING
+#endif // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

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,13 +844,28 @@
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+  //===========================================================================
+  //========================= Unified Bed Leveling ============================
+  //===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_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
@@ -851,28 +873,13 @@
   //#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
 
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-
-  //===========================================================================
-  //========================= Unified Bed Leveling ============================
-  //===========================================================================
-
-  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
-  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
-  #define UBL_MESH_NUM_Y_POINTS 10
-  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
-  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
-  #define UBL_PROBE_PT_2_X 39
-  #define UBL_PROBE_PT_2_Y 20
-  #define UBL_PROBE_PT_3_X 180
-  #define UBL_PROBE_PT_3_Y 20
-
-#endif  // BED_LEVELING
+#endif // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

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) {

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) (UBL_encoderPosition)) * .005 / 2.0 ;
-        Mesh_Edit_Value       = Mesh_Edit_Accumulator;
-        encoderPosition       = 0;
-        lcdDrawUpdate         = LCDVIEW_REDRAW_NOW;
+        mesh_edit_accumulator += float((int32_t)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
 

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