From e2443997666f6ce86693bec0329be0974ed9a5f1 Mon Sep 17 00:00:00 2001
From: Scott Lahteine <sourcetree@thinkyhead.com>
Date: Mon, 20 Mar 2017 01:42:41 -0500
Subject: [PATCH] Additional cleanup of UBL code

---
 Marlin/Conditionals_post.h                    |    2 +-
 Marlin/Configuration.h                        |   80 +-
 Marlin/G26_Mesh_Validation_Tool.cpp           |  330 ++---
 Marlin/Marlin_main.cpp                        |   58 +-
 Marlin/SanityCheck.h                          |   60 +-
 Marlin/UBL.h                                  |   68 +-
 Marlin/UBL_Bed_Leveling.cpp                   |  123 +-
 Marlin/UBL_G29.cpp                            | 1158 ++++++++---------
 Marlin/UBL_line_to_destination.cpp            |  581 ++++-----
 Marlin/cardreader.cpp                         |    2 +-
 Marlin/configuration_store.cpp                |   48 +-
 .../Cartesio/Configuration.h                  |   79 +-
 .../Felix/Configuration.h                     |   79 +-
 .../Felix/DUAL/Configuration.h                |   79 +-
 .../Hephestos/Configuration.h                 |   79 +-
 .../Hephestos_2/Configuration.h               |   79 +-
 .../K8200/Configuration.h                     |   79 +-
 .../K8400/Configuration.h                     |   79 +-
 .../K8400/Dual-head/Configuration.h           |   79 +-
 .../RepRapWorld/Megatronics/Configuration.h   |   79 +-
 .../RigidBot/Configuration.h                  |   79 +-
 .../SCARA/Configuration.h                     |   79 +-
 .../TAZ4/Configuration.h                      |   79 +-
 .../WITBOX/Configuration.h                    |   79 +-
 .../adafruit/ST7565/Configuration.h           |   79 +-
 .../delta/flsun_kossel_mini/Configuration.h   |   79 +-
 .../delta/generic/Configuration.h             |   79 +-
 .../delta/kossel_mini/Configuration.h         |   79 +-
 .../delta/kossel_pro/Configuration.h          |   79 +-
 .../delta/kossel_xl/Configuration.h           |   79 +-
 .../makibox/Configuration.h                   |   79 +-
 .../tvrrug/Round2/Configuration.h             |   79 +-
 Marlin/servo.cpp                              |    4 +-
 Marlin/ultralcd.cpp                           |   91 +-
 Marlin/ultralcd.h                             |    7 +
 35 files changed, 2201 insertions(+), 2070 deletions(-)

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