Merge pull request #6054 from thinkyhead/rc_ubl_renewal

UBL for RCBugFix — cleanup, rebase, patch

.gitignore

 *.i
 *.ii
 *.swp
-
+tags
 
 #
 # C++

.travis.yml

   - opt_set ABL_GRID_POINTS_Y 16
   - build_marlin
   #
+  # Test a simple build of AUTO_BED_LEVELING_UBL
+  #
+  - restore_configs
+  - opt_enable AUTO_BED_LEVELING_UBL FIX_MOUNTED_PROBE EEPROM_SETTINGS G3D_PANEL
+  - build_marlin
+  #
   # Test a Sled Z Probe
   #
   - restore_configs

Marlin/Conditionals_post.h

    */
   #define ABL_PLANAR (ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_3POINT))
   #define ABL_GRID   (ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR))
-  #define HAS_ABL    (ABL_PLANAR || ABL_GRID)
+  #define HAS_ABL    (ABL_PLANAR || ABL_GRID || ENABLED(AUTO_BED_LEVELING_UBL))
 
   #define PLANNER_LEVELING      (HAS_ABL || ENABLED(MESH_BED_LEVELING))
   #define HAS_PROBING_PROCEDURE (HAS_ABL || ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST))

Marlin/Configuration.h

  *    60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950
  *    66 : 4.7M High Temperature thermistor from Dyze Design
  *    70 : the 100K thermistor found in the bq Hephestos 2
+ *    75 : 100k Generic Silicon Heat Pad with NTC 100K MGB18-104F39050L32 thermistor
  *
  *       1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k.
  *                              (but gives greater accuracy and more stable PID)
 //
 // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN.
 //
-// For a servo-based Z probe, you must set up servo support below, including
-// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES.
+// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above.
 //
 // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin.
 // - Use 5V for powered (usu. inductive) sensors.
 #endif
 
 //===========================================================================
-//============================ Mesh Bed Leveling ============================
-//===========================================================================
-
-//#define MESH_BED_LEVELING    // Enable mesh bed leveling.
-
-#if ENABLED(MESH_BED_LEVELING)
-  #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 MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment
-
-  //#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  // MANUAL_BED_LEVELING
-
-  // Gradually reduce leveling correction until a set height is reached,
-  // at which point movement will be level to the machine's XY plane.
-  // The height can be set with M420 Z<height>
-  #define ENABLE_LEVELING_FADE_HEIGHT
-
-#endif  // MESH_BED_LEVELING
-
-//===========================================================================
-//============================ Auto Bed Leveling ============================
+//=============================== Bed Leveling ==============================
 //===========================================================================
 // @section bedlevel
 
  *   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.
  */
 //#define AUTO_BED_LEVELING_3POINT
 //#define AUTO_BED_LEVELING_LINEAR
 //#define AUTO_BED_LEVELING_BILINEAR
+//#define MESH_BED_LEVELING
+//#define AUTO_BED_LEVELING_UBL
+
 
 /**
  * Enable detailed logging of G28, G29, M48, etc.
  */
 //#define DEBUG_LEVELING_FEATURE
 
+#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL)
+  // Gradually reduce leveling correction until a set height is reached,
+  // at which point movement will be level to the machine's XY plane.
+  // The height can be set with M420 Z<height>
+  #define ENABLE_LEVELING_FADE_HEIGHT
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
   // Set the number of grid points per dimension.
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
-    // Gradually reduce leveling correction until a set height is reached,
-    // at which point movement will be level to the machine's XY plane.
-    // The height can be set with M420 Z<height>
-    #define ENABLE_LEVELING_FADE_HEIGHT
-
     //
     // Experimental Subdivision of the grid by Catmull-Rom method.
     // Synthesizes intermediate points to produce a more detailed mesh.
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
-#endif
+#elif ENABLED(MESH_BED_LEVELING)
+
+//===========================================================================
+//=================================== Mesh ==================================
+//===========================================================================
+
+  #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0.
+  #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 at origin [0,0,0]
+
+  //#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  // MANUAL_BED_LEVELING
+
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+//===========================================================================
+//========================= Unified Bed Leveling ============================
+//===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_PROBE_PT_3_Y 20
+
+#endif  // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

Marlin/Configuration_adv.h

   #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET))
 #endif
 
+#if ENABLED(AUTO_BED_LEVELING_UBL)
+  #define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET)
+  #define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET))
+  #define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET)
+  #define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET))
+#endif
+
 // @section extras
 
 // Arc interpretation settings:
 #define I2C_SLAVE_ADDRESS  0 // Set a value from 8 to 127 to act as a slave
 
 /**
- * Add M43 command for pins info and testing
+ * Add M43, M44 and M45 commands for pins info and testing
  */
 //#define PINS_DEBUGGING
 

Marlin/M100_Free_Mem_Chk.cpp

  * M100 C x Corrupts x locations within the free memory block.   This is useful to check the
  *    correctness of the M100 F and M100 D commands.
  *
- * Initial version by Roxy-3DPrintBoard
+ * Initial version by Roxy-3D
  */
 #define M100_FREE_MEMORY_DUMPER     // Comment out to remove Dump sub-command
 #define M100_FREE_MEMORY_CORRUPTOR    // Comment out to remove Corrupt sub-command
 // Utility functions used by M100 to get its work done.
 //
 
+#include "hex_print_routines.h"
+
 char* top_of_stack();
-void prt_hex_nibble(unsigned int);
-void prt_hex_byte(unsigned int);
-void prt_hex_word(unsigned int);
 int how_many_E5s_are_here(char*);
 
 void gcode_M100() {
   return &x + 1; // x is pulled on return;
 }
 
-//
-// 3 support routines to print hex numbers.  We can print a nibble, byte and word
-//
-
-void prt_hex_nibble(unsigned int n) {
-  if (n <= 9)
-    SERIAL_ECHO(n);
-  else
-    SERIAL_ECHO((char)('A' + n - 10));
-}
-
-void prt_hex_byte(unsigned int b) {
-  prt_hex_nibble((b & 0xf0) >> 4);
-  prt_hex_nibble(b & 0x0f);
-}
-
-void prt_hex_word(unsigned int w) {
-  prt_hex_byte((w & 0xff00) >> 8);
-  prt_hex_byte(w & 0x0ff);
-}
-
 // how_many_E5s_are_here() is a utility function to easily find out how many 0xE5's are
 // at the specified location.  Having this logic as a function simplifies the search code.
 //

Marlin/Marlin.h

 #include "fastio.h"
 #include "utility.h"
 
+
 #ifdef USBCON
   #include "HardwareSerial.h"
   #if ENABLED(BLUETOOTH)
 #define SERIAL_ECHOLNPGM(x)            SERIAL_PROTOCOLLNPGM(x)
 #define SERIAL_ECHOPAIR(name,value)    SERIAL_PROTOCOLPAIR(name, value)
 #define SERIAL_ECHOLNPAIR(name, value) SERIAL_PROTOCOLLNPAIR(name, value)
+#define SERIAL_ECHO_F(x,y)             SERIAL_PROTOCOL_F(x,y)
 
 #define SERIAL_ERROR_START            (serialprintPGM(errormagic))
 #define SERIAL_ERROR(x)                SERIAL_PROTOCOL(x)
 void serial_echopair_P(const char* s_P, long v);
 void serial_echopair_P(const char* s_P, float v);
 void serial_echopair_P(const char* s_P, double v);
+void serial_echopair_P(const char* s_P, unsigned int v);
 void serial_echopair_P(const char* s_P, unsigned long v);
 FORCE_INLINE void serial_echopair_P(const char* s_P, uint8_t v) { serial_echopair_P(s_P, (int)v); }
 FORCE_INLINE void serial_echopair_P(const char* s_P, uint16_t v) { serial_echopair_P(s_P, (int)v); }

Marlin/Marlin_main.cpp

 /**
  * Marlin 3D Printer Firmware
- * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016, 2017 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
 #include "duration_t.h"
 #include "types.h"
 
+#if ENABLED(AUTO_BED_LEVELING_UBL)
+  #include "UBL.h"
+#endif
+
 #if HAS_ABL
   #include "vector_3.h"
   #if ENABLED(AUTO_BED_LEVELING_LINEAR)
        G38_endstop_hit = false;
 #endif
 
+#if ENABLED(AUTO_BED_LEVELING_UBL)
+  bed_leveling blm;
+#endif
+
 bool Running = true;
 
 uint8_t marlin_debug_flags = DEBUG_NONE;
  *   Set with 'gcode_get_destination' or 'set_destination_to_current'.
  *   'line_to_destination' sets 'current_position' to 'destination'.
  */
-static float destination[XYZE] = { 0.0 };
+float destination[XYZE] = { 0.0 };
 
 /**
  * axis_homed
     SERIAL_ECHOPAIR("(", x);
     SERIAL_ECHOPAIR(", ", y);
     SERIAL_ECHOPAIR(", ", z);
-    SERIAL_ECHOPGM(")");
+    SERIAL_CHAR(')');
 
     if (suffix) serialprintPGM(suffix);
     else SERIAL_EOL;
 #endif //HAS_BED_PROBE
 
 #if ENABLED(Z_PROBE_ALLEN_KEY) || ENABLED(Z_PROBE_SLED) || HAS_PROBING_PROCEDURE || HOTENDS > 1 || ENABLED(NOZZLE_CLEAN_FEATURE) || ENABLED(NOZZLE_PARK_FEATURE)
-  static bool axis_unhomed_error(const bool x, const bool y, const bool z) {
+  bool axis_unhomed_error(const bool x, const bool y, const bool z) {
     const bool xx = x && !axis_homed[X_AXIS],
                yy = y && !axis_homed[Y_AXIS],
                zz = z && !axis_homed[Z_AXIS];
   #endif
 
   // returns false for ok and true for failure
-  static bool set_probe_deployed(bool deploy) {
+  bool set_probe_deployed(bool deploy) {
 
     #if ENABLED(DEBUG_LEVELING_FEATURE)
       if (DEBUGGING(LEVELING)) {
   //   - Raise to the BETWEEN height
   // - Return the probed Z position
   //
-  static float probe_pt(const float &x, const float &y, const bool stow = true, const int verbose_level = 1) {
+//float probe_pt(const float &x, const float &y, const bool stow = true, const int verbose_level = 1) {
+  float probe_pt(const float x, const float y, const bool stow, const int verbose_level) {
     #if ENABLED(DEBUG_LEVELING_FEATURE)
       if (DEBUGGING(LEVELING)) {
         SERIAL_ECHOPAIR(">>> probe_pt(", x);
         SERIAL_ECHOPGM("BILINEAR");
       #elif ENABLED(AUTO_BED_LEVELING_3POINT)
         SERIAL_ECHOPGM("3POINT");
+      #elif ENABLED(AUTO_BED_LEVELING_UBL)
+        SERIAL_ECHOPGM("UBL");
       #endif
       if (planner.abl_enabled) {
         SERIAL_ECHOLNPGM(" (enabled)");
-        #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_3POINT)
+        #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_3POINT) || ENABLED(AUTO_BED_LEVELING_UBL)
           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],
     report_current_position();
   }
 
-#elif HAS_ABL
+#elif HAS_ABL && DISABLED(AUTO_BED_LEVELING_UBL)
 
   /**
    * G29: Detailed Z probe, probes the bed at 3 or more points.
       SYNC_PLAN_POSITION_KINEMATIC();
   }
 
-#endif // HAS_ABL
+#endif // HAS_ABL && DISABLED(AUTO_BED_LEVELING_UBL)
 
 #if HAS_BED_PROBE
 
             bed_level_virt_print();
           #endif
         }
+      #elif ENABLED(AUTO_BED_LEVELING_UBL)
+        blm.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:");
           break;
       #endif // INCH_MODE_SUPPORT
 
+      #if ENABLED(AUTO_BED_LEVELING_UBL)
+        case 26: // G26: Mesh Validation Pattern generation
+          gcode_G26();
+          break;
+      #endif // AUTO_BED_LEVELING_UBL
+
       #if ENABLED(NOZZLE_PARK_FEATURE)
         case 27: // G27: Nozzle Park
           gcode_G27();
         break;
 
       #if PLANNER_LEVELING
-        case 29: // G29 Detailed Z probe, probes the bed at 3 or more points.
+        case 29: // G29 Detailed Z probe, probes the bed at 3 or more points,
+                 // or provides access to the UBL System if enabled.
           gcode_G29();
           break;
       #endif // PLANNER_LEVELING
           gcode_M43(); break;
       #endif
 
+
       #if ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST)
         case 48: // M48: Z probe repeatability test
           gcode_M48();
           break;
       #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) {
+            SERIAL_PROTOCOLPGM("UBL Debug Flag turned off.\n");
+            G26_Debug_flag = 0; }
+    else {
+            SERIAL_PROTOCOLPGM("UBL Debug Flag turned on.\n");
+            G26_Debug_flag++; }
+          break;
+      #endif // Z_MIN_PROBE_REPEATABILITY_TEST
+
       case 75: // M75: Start print timer
         gcode_M75(); break;
       case 76: // M76: Pause print timer
       SERIAL_ECHOLNPAIR(" offset=", offset);
     }
     last_offset = offset;
-    //*/
+    */
 
     return offset;
   }
           return false;
         }
         else
+      #elif ENABLED(AUTO_BED_LEVELING_UBL)
+        if (blm.state.active) {
+
+//        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],
+//                      (feedrate*(1.0/60.0))*(feedrate_percentage*(1.0/100.0) ), active_extruder);
+                      MMS_SCALED(feedrate_mm_s), active_extruder);
+
+          return false;
+        }
+        else
       #elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
         if (planner.abl_enabled) {
           bilinear_line_to_destination(MMS_SCALED(feedrate_mm_s));
   #endif
 
   #if ENABLED(RGB_LED)
-    pinMode(RGB_LED_R_PIN, OUTPUT);
-    pinMode(RGB_LED_G_PIN, OUTPUT);
-    pinMode(RGB_LED_B_PIN, OUTPUT);
+    SET_OUTPUT(RGB_LED_R_PIN);
+    SET_OUTPUT(RGB_LED_G_PIN);
+    SET_OUTPUT(RGB_LED_B_PIN);
   #endif
 
   lcd_init();

Marlin/SanityCheck.h

   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
     + 1
   #endif
+  #if ENABLED(AUTO_BED_LEVELING_UBL)
+    + 1
+  #endif
   #if ENABLED(MESH_BED_LEVELING)
     + 1
   #endif
-  , "Select only one of: MESH_BED_LEVELING, AUTO_BED_LEVELING_LINEAR, AUTO_BED_LEVELING_3POINT, or AUTO_BED_LEVELING_BILINEAR."
+  , "Select only one of: MESH_BED_LEVELING, AUTO_BED_LEVELING_LINEAR, AUTO_BED_LEVELING_3POINT, AUTO_BED_LEVELING_BILINEAR or AUTO_BED_LEVELING_UBL."
 );
 
 /**
   #elif MESH_NUM_X_POINTS > 9 || MESH_NUM_Y_POINTS > 9
     #error "MESH_NUM_X_POINTS and MESH_NUM_Y_POINTS must be less than 10."
   #endif
+#elif ENABLED(MANUAL_BED_LEVELING)
+  #error "MANUAL_BED_LEVELING only applies to MESH_BED_LEVELING."
+#endif
+
+/**
+ * Unified Bed Leveling
+ */
+#if ENABLED(AUTO_BED_LEVELING_UBL)
+  #if ENABLED(DELTA)
+    #error "AUTO_BED_LEVELING_UBL does not yet support DELTA printers."
+  #elif DISABLED(NEWPANEL)
+    #error "AUTO_BED_LEVELING_UBL requires an LCD controller."
+  #elif UBL_MESH_NUM_X_POINTS > 15 || UBL_MESH_NUM_Y_POINTS > 15
+    #error "UBL_MESH_NUM_X_POINTS and UBL_MESH_NUM_Y_POINTS must be less than 16."
+  #endif
 #endif
 
 /**
   , "Please enable only one probe: PROBE_MANUALLY, FIX_MOUNTED_PROBE, Z Servo, BLTOUCH, Z_PROBE_ALLEN_KEY, or Z_PROBE_SLED."
 );
 
+
 #if PROBE_SELECTED
 
   /**
       #endif
     #endif
   #else // !ABL_GRID
-
-    // 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
+    #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
 

Marlin/UBL.h

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016, 2017 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "Marlin.h"
+#include "math.h"
+
+#ifndef UNIFIED_BED_LEVELING_H
+#define UNIFIED_BED_LEVELING_H
+
+  #if ENABLED(AUTO_BED_LEVELING_UBL)
+
+    #define UBL_OK false
+    #define UBL_ERR true
+
+    typedef struct {
+      int x_index, y_index;
+      float distance; // Not always used. But when populated, it is the distance
+                      // from the search location
+    } mesh_index_pair;
+
+    struct vector { double dx, dy, dz; };
+
+    enum Mesh_Point_Type { INVALID, REAL, SET_IN_BITMAP };
+
+    bool axis_unhomed_error(bool, bool, bool);
+    void dump(char *str, float f);
+    bool G29_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 manually_probe_remaining_mesh(float, float, float, float, bool);
+    struct 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);
+    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);
+    char *ftostr43sign(const float&, char);
+
+    void gcode_G26();
+    void gcode_G28();
+    void gcode_G29();
+    extern char conv[9];
+
+    void save_UBL_active_state_and_disable();
+    void restore_UBL_active_state_and_leave();
+
+    ///////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    #if ENABLED(ULTRA_LCD)
+      extern char lcd_status_message[];
+      void lcd_quick_feedback();
+    #endif
+
+    enum MBLStatus { MBL_STATUS_NONE = 0, MBL_STATUS_HAS_MESH_BIT = 0, MBL_STATUS_ACTIVE_BIT = 1 };
+
+    #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 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
+
+    class bed_leveling {
+      public:
+      struct ubl_state {
+        bool active = false;
+        float z_offset = 0.0;
+        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,
+              mesh_y_min = UBL_MESH_MIN_Y,
+              mesh_x_max = UBL_MESH_MAX_X,
+              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
+                                                       // 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.
+
+        unsigned char padding[24];  // This is just to allow room to add state variables without
+                                    // changing the location of data structures in the EEPROM.
+                                    // This is for compatability with future versions to keep
+                                    // people from having to regenerate thier mesh data.
+                                    //
+                                    // If you change the contents of this struct, please adjust
+                                    // the padding[] to keep the size the same!
+      } state, pre_initialized;
+
+      bed_leveling();
+      //  ~bed_leveling();  // No destructor because this object never goes away!
+
+      void display_map(int);
+
+      void reset();
+      void invalidate();
+
+      void store_state();
+      void load_state();
+      void store_mesh(int);
+      void load_mesh(int);
+
+      bool sanity_check();
+
+      FORCE_INLINE float map_x_index_to_bed_location(int8_t i){ return ((float) UBL_MESH_MIN_X) + (((float) MESH_X_DIST) * (float) i); };
+      FORCE_INLINE float map_y_index_to_bed_location(int8_t i){ return ((float) UBL_MESH_MIN_Y) + (((float) MESH_Y_DIST) * (float) i); };
+
+      void set_z(const int8_t px, const int8_t py, const float z) { z_values[px][py] = z; }
+
+      int8_t get_cell_index_x(float x) {
+        int8_t cx = (x - (UBL_MESH_MIN_X)) * (1.0 / (MESH_X_DIST));
+        return constrain(cx, 0, (UBL_MESH_NUM_X_POINTS) - 1);   // -1 is appropriate if we want all movement to the X_MAX
+      }                                                         // position. But with this defined this way, it is possible
+                                                                // to extrapolate off of this point even further out. Probably
+                                                                // that is OK because something else should be keeping that from
+                                                                // happening and should not be worried about at this level.
+      int8_t get_cell_index_y(float y) {
+        int8_t cy = (y - (UBL_MESH_MIN_Y)) * (1.0 / (MESH_Y_DIST));
+        return constrain(cy, 0, (UBL_MESH_NUM_Y_POINTS) - 1);   // -1 is appropriate if we want all movement to the Y_MAX
+      }                                                         // position. But with this defined this way, it is possible
+                                                                // to extrapolate off of this point even further out. Probably
+                                                                // that is OK because something else should be keeping that from
+                                                                // happening and should not be worried about at this level.
+
+      int8_t find_closest_x_index(float x) {
+        int8_t px = (x - (UBL_MESH_MIN_X) + (MESH_X_DIST) * 0.5) * (1.0 / (MESH_X_DIST));
+        return (px >= 0 && px < (UBL_MESH_NUM_X_POINTS)) ? px : -1;
+      }
+
+      int8_t find_closest_y_index(float y) {
+        int8_t py = (y - (UBL_MESH_MIN_Y) + (MESH_Y_DIST) * 0.5) * (1.0 / (MESH_Y_DIST));
+        return (py >= 0 && py < (UBL_MESH_NUM_Y_POINTS)) ? py : -1;
+      }
+
+      /**
+       *                           z2   --|
+       *                 z0        |      |
+       *                  |        |      + (z2-z1)
+       *   z1             |        |      |
+       * ---+-------------+--------+--  --|
+       *   a1            a0        a2
+       *    |<---delta_a---------->|
+       *
+       *  calc_z0 is the basis for all the Mesh Based correction. It is used to
+       *  find the expected Z Height at a position between two known Z-Height locations
+       *
+       *  It is farly expensive with its 4 floating point additions and 2 floating point
+       *  multiplications.
+       */
+      inline float calc_z0(float a0, float a1, float z1, float a2, float z2) {
+        float delta_z = (z2 - z1);
+        float delta_a = (a0 - a1) / (a2 - a1);
+        return z1 + delta_a * delta_z;
+      }
+
+      /**
+       * get_z_correction_at_Y_intercept(float x0, int x1_i, int yi) only takes
+       * three parameters. It assumes the x0 point is on a Mesh line denoted by yi. In theory
+       * we could use get_cell_index_x(float x) to obtain the 2nd parameter x1_i but any code calling
+       * the get_z_correction_along_vertical_mesh_line_at_specific_X routine  will already have
+       * the X index of the x0 intersection available and we don't want to perform any extra floating
+       * point operations.
+       */
+      inline float get_z_correction_along_horizontal_mesh_line_at_specific_X(float x0, int x1_i, int yi) {
+        if (x1_i < 0 || yi < 0 || x1_i >= UBL_MESH_NUM_X_POINTS || yi >= UBL_MESH_NUM_Y_POINTS) {
+          SERIAL_ECHOPAIR("? in get_z_correction_along_horizontal_mesh_line_at_specific_X(x0=", x0);
+          SERIAL_ECHOPAIR(",x1_i=", x1_i);
+          SERIAL_ECHOPAIR(",yi=", yi);
+          SERIAL_CHAR(')');
+          SERIAL_EOL;
+          return NAN;
+        }
+
+        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);
+
+        return z1 + a0ma1diva2ma1 * dz;
+      }
+
+      //
+      // See comments above for get_z_correction_along_horizontal_mesh_line_at_specific_X
+      //
+      inline float get_z_correction_along_vertical_mesh_line_at_specific_Y(float y0, int xi, int y1_i) {
+        if (xi < 0 || y1_i < 0 || xi >= UBL_MESH_NUM_X_POINTS || y1_i >= UBL_MESH_NUM_Y_POINTS) {
+          SERIAL_ECHOPAIR("? in get_z_correction_along_vertical_mesh_line_at_specific_X(y0=", y0);
+          SERIAL_ECHOPAIR(", x1_i=", xi);
+          SERIAL_ECHOPAIR(", yi=", y1_i);
+          SERIAL_CHAR(')');
+          SERIAL_EOL;
+          return NAN;
+        }
+
+        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);
+
+        return z1 + a0ma1diva2ma1 * dz;
+      }
+
+      /**
+       * This is the generic Z-Correction. It works anywhere within a Mesh Cell. It first
+       * does a linear interpolation along both of the bounding X-Mesh-Lines to find the
+       * Z-Height at both ends. Then it does a linear interpolation of these heights based
+       * on the Y position within the cell.
+       */
+      float get_z_correction(float x0, float y0) {
+        int8_t cx = get_cell_index_x(x0),
+        cy = get_cell_index_y(y0);
+
+        if (cx < 0 || cy < 0 || cx >= UBL_MESH_NUM_X_POINTS || cy >= UBL_MESH_NUM_Y_POINTS) {
+
+          SERIAL_ECHOPAIR("? in get_z_correction(x0=", x0);
+          SERIAL_ECHOPAIR(", y0=", y0);
+          SERIAL_CHAR(')');
+          SERIAL_EOL;
+
+          #if ENABLED(ULTRA_LCD)
+            strcpy(lcd_status_message, "get_z_correction() indexes out of range.");
+            lcd_quick_feedback();
+          #endif
+          return 0.0; // this used to return state.z_offset
+        }
+
+        float z1 = calc_z0(x0,
+          map_x_index_to_bed_location(cx), z_values[cx][cy],
+          map_x_index_to_bed_location(cx + 1), z_values[cx + 1][cy]);
+        float z2 = calc_z0(x0,
+          map_x_index_to_bed_location(cx), z_values[cx][cy + 1],
+          map_x_index_to_bed_location(cx + 1), z_values[cx + 1][cy + 1]);
+        float z0 = calc_z0(y0,
+          map_y_index_to_bed_location(cy), z1,
+          map_y_index_to_bed_location(cy + 1), z2);
+
+        #if ENABLED(DEBUG_LEVELING_FEATURE)
+          if (DEBUGGING(MESH_ADJUST)) {
+            SERIAL_ECHOPAIR(" raw get_z_correction(", x0);
+            SERIAL_ECHOPAIR(",", y0);
+            SERIAL_ECHOPGM(")=");
+            SERIAL_PROTOCOL_F(z0, 6);
+          }
+        #endif
+
+        #if ENABLED(DEBUG_LEVELING_FEATURE)
+          if (DEBUGGING(MESH_ADJUST)) {
+            SERIAL_ECHOPGM(" >>>---> ");
+            SERIAL_PROTOCOL_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
+                         // 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 ENABLED(DEBUG_LEVELING_FEATURE)
+            if (DEBUGGING(MESH_ADJUST)) {
+              SERIAL_ECHOPGM("??? Yikes!  NAN in get_z_correction( ");
+              SERIAL_ECHO(x0);
+              SERIAL_ECHOPGM(", ");
+              SERIAL_ECHO(y0);
+              SERIAL_ECHOLNPGM(" )");
+            }
+          #endif
+        }
+        return z0; // there used to be a +state.z_offset on this line
+      }
+
+      /**
+       * This routine is used to scale the Z correction depending upon the current nozzle height. It is
+       * optimized for speed. It avoids floating point operations by checking if the requested scaling
+       * factor is going to be the same as the last time the function calculated a value. If so, it just
+       * returns it.
+       *
+       * 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) {
+        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)
+          : 0.0;
+        return fade_scaling_factor_for_current_height;
+      }
+    };
+
+    extern bed_leveling blm;
+    extern int Unified_Bed_Leveling_EEPROM_start;
+
+#endif // AUTO_BED_LEVELING_UBL
+#endif // UNIFIED_BED_LEVELING_H

Marlin/UBL_Bed_Leveling.cpp

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "Marlin.h"
+#include "math.h"
+
+#if ENABLED(AUTO_BED_LEVELING_UBL)
+  #include "UBL.h"
+  #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.
+   */
+  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
+
+  bed_leveling::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);
+
+    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);
+
+    reset();
+  }
+
+  void bed_leveling::store_state() {
+    int k = E2END - sizeof(blm.state);
+    eeprom_write_block((void *)&blm.state, (void *)k, sizeof(blm.state));
+  }
+
+  void bed_leveling::load_state() {
+    int k = E2END - sizeof(blm.state);
+    eeprom_read_block((void *)&blm.state, (void *)k, sizeof(blm.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.
+  }
+
+  void bed_leveling::load_mesh(int m) {
+    int k = E2END - sizeof(blm.state),
+        j = (k - Unified_Bed_Leveling_EEPROM_start) / sizeof(z_values);
+
+    if (m == -1) {
+      SERIAL_PROTOCOLLNPGM("?No mesh saved in EEPROM. Zeroing mesh in memory.\n");
+      reset();
+      return;
+    }
+
+    if (m < 0 || m >= j || Unified_Bed_Leveling_EEPROM_start <= 0) {
+      SERIAL_PROTOCOLLNPGM("?EEPROM storage not available to load mesh.\n");
+      return;
+    }
+
+    j = k - (m + 1) * sizeof(z_values);
+    eeprom_read_block((void *)&z_values , (void *)j, sizeof(z_values));
+
+    SERIAL_PROTOCOLPGM("Mesh loaded from slot ");
+    SERIAL_PROTOCOL(m);
+    SERIAL_PROTOCOLPGM("  at offset 0x");
+    prt_hex_word(j);
+    SERIAL_EOL;
+  }
+
+  void bed_leveling:: store_mesh(int m) {
+    int k = E2END - sizeof(state),
+        j = (k - Unified_Bed_Leveling_EEPROM_start) / sizeof(z_values);
+
+    if (m < 0 || m >= j || Unified_Bed_Leveling_EEPROM_start <= 0) {
+      SERIAL_PROTOCOLLNPGM("?EEPROM storage not available to load mesh.\n");
+      SERIAL_PROTOCOL(m);
+      SERIAL_PROTOCOLLNPGM(" mesh slots available.\n");
+      SERIAL_PROTOCOLLNPAIR("E2END     : ", E2END);
+      SERIAL_PROTOCOLLNPAIR("k         : ", k);
+      SERIAL_PROTOCOLLNPAIR("j         : ", j);
+      SERIAL_PROTOCOLLNPAIR("m         : ", m);
+      SERIAL_EOL;
+      return;
+    }
+
+    j = k - (m + 1) * sizeof(z_values);
+    eeprom_write_block((const void *)&z_values, (void *)j, sizeof(z_values));
+
+    SERIAL_PROTOCOLPGM("Mesh saved in slot ");
+    SERIAL_PROTOCOL(m);
+    SERIAL_PROTOCOLPGM("  at offset 0x");
+    prt_hex_word(j);
+    SERIAL_EOL;
+  }
+
+  void bed_leveling::reset() {
+    state.active = false;
+    state.z_offset = 0;
+    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
+  }
+
+  void bed_leveling::invalidate() {
+    prt_hex_word((unsigned int)this);
+    SERIAL_EOL;
+
+    state.active = false;
+    state.z_offset = 0;
+    for (int x = 0; x < UBL_MESH_NUM_X_POINTS; x++)
+      for (int y = 0; y < UBL_MESH_NUM_Y_POINTS; y++)
+        z_values[x][y] = NAN;
+  }
+
+  void bed_leveling::display_map(int map_type) {
+    float f, current_xi, current_yi;
+    int8_t i, j;
+    UNUSED(map_type);
+
+    SERIAL_PROTOCOLLNPGM("\nBed Topography Report:\n");
+
+    SERIAL_ECHOPAIR("(", 0);
+    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);
+
+    for (i = 0; i < UBL_MESH_NUM_X_POINTS - 1; i++)
+      SERIAL_ECHOPGM("                 ");
+
+    SERIAL_ECHOPAIR("(", UBL_MESH_NUM_X_POINTS - 1);
+    SERIAL_ECHOPAIR(",", UBL_MESH_NUM_Y_POINTS - 1);
+    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_MAX_X);
+    SERIAL_ECHOPAIR(",", UBL_MESH_MAX_Y);
+    SERIAL_ECHOLNPGM(")");
+    //  }
+
+    for (j = UBL_MESH_NUM_Y_POINTS - 1; j >= 0; j--) {
+      for (i = 0; i < UBL_MESH_NUM_X_POINTS; i++) {
+        f = z_values[i][j];
+
+        // is the nozzle here?  if so, mark the number
+        SERIAL_CHAR(i == current_xi && j == current_yi ? '[' : ' ');
+
+        if (isnan(f))
+          SERIAL_PROTOCOLPGM("      .       ");
+        else {
+          // if we don't do this, the columns won't line up nicely
+          if (f >= 0.0) SERIAL_CHAR(' ');
+          SERIAL_PROTOCOL_F(f, 5);
+          idle();
+        }
+        if (i == current_xi && j == current_yi) // is the nozzle here? if so, finish marking the number
+          SERIAL_CHAR(']');
+        else
+          SERIAL_PROTOCOL("  ");
+
+        SERIAL_CHAR(' ');
+      }
+      SERIAL_EOL;
+      if (j) { // we want the (0,0) up tight against the block of numbers
+        SERIAL_CHAR(' ');
+        SERIAL_EOL;
+      }
+    }
+
+    //  if (map_type) {
+    SERIAL_ECHOPAIR("(", int(UBL_MESH_MIN_X));
+    SERIAL_ECHOPAIR(",", int(UBL_MESH_MIN_Y));
+    SERIAL_ECHOPGM(")    ");
+
+    for (i = 0; i < UBL_MESH_NUM_X_POINTS - 1; i++)
+      SERIAL_ECHOPGM("                 ");
+
+    SERIAL_ECHOPAIR("(", int(UBL_MESH_MAX_X));
+    SERIAL_ECHOPAIR(",", int(UBL_MESH_MIN_Y));
+    SERIAL_CHAR(')');
+    //  }
+
+    SERIAL_ECHOPAIR("(", 0);
+    SERIAL_ECHOPAIR(",", 0);
+    SERIAL_ECHOPGM(")       ");
+
+    for (i = 0; i < UBL_MESH_NUM_X_POINTS - 1; i++)
+      SERIAL_ECHOPGM("                 ");
+
+    SERIAL_ECHOPAIR("(", UBL_MESH_NUM_X_POINTS-1);
+    SERIAL_ECHOPAIR(",", 0);
+    SERIAL_CHAR(')');
+
+    SERIAL_CHAR(' ');
+    SERIAL_EOL;
+  }
+
+  bool bed_leveling::sanity_check() {
+    uint8_t error_flag = 0;
+
+    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)  {
+      SERIAL_PROTOCOLLNPGM("?UBL_MESH_NUM_Y_POINTS set wrong\n");
+      error_flag++;
+    }
+
+    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)  {
+      SERIAL_PROTOCOLLNPGM("?UBL_MESH_MIN_Y set wrong\n");
+      error_flag++;
+    }
+
+    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)  {
+      SERIAL_PROTOCOLLNPGM("?UBL_MESH_MAX_Y set wrong\n");
+      error_flag++;
+    }
+
+    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)  {
+      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);
+
+    if (j < 1) {
+      SERIAL_PROTOCOLLNPGM("?No EEPROM storage available for a mesh of this size.\n");
+      error_flag++;
+    }
+
+    //  SERIAL_PROTOCOLPGM("?sanity_check() return value: ");
+    //  SERIAL_PROTOCOL(error_flag);
+    //  SERIAL_EOL;
+
+    return !!error_flag;
+  }
+
+#endif // AUTO_BED_LEVELING_UBL

Marlin/UBL_line_to_destination.cpp

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#include "Marlin.h"
+
+#if ENABLED(AUTO_BED_LEVELING_UBL)
+
+  #include "UBL.h"
+  #include "planner.h"
+  #include <avr/io.h>
+  #include <math.h>
+
+  extern void set_current_to_destination();
+  extern bool G26_Debug_flag;
+  void debug_current_and_destination(char *title);
+
+  void wait_for_button_press();
+
+  void UBL_line_to_destination(const float &x_end, const float &y_end, const float &z_end, const float &e_end, const float &feed_rate, uint8_t extruder) {
+
+    int cell_start_xi, cell_start_yi, cell_dest_xi, cell_dest_yi;
+    int left_flag, down_flag;
+    int current_xi, current_yi;
+    int dxi, dyi, xi_cnt, yi_cnt;
+    bool use_X_dist, inf_normalized_flag, inf_m_flag;
+    float x_start, y_start;
+    float x, y, z1, z2, z0 /*, z_optimized */;
+    float next_mesh_line_x, next_mesh_line_y, a0ma1diva2ma1;
+    float on_axis_distance, e_normalized_dist, e_position, e_start, z_normalized_dist, z_position, z_start;
+    float dx, dy, adx, ady, m, c;
+
+    //
+    // Much of the nozzle movement will be within the same cell.  So we will do as little computation
+    // as possible to determine if this is the case.  If this move is within the same cell, we will
+    // just do the required Z-Height correction, call the Planner's buffer_line() routine, and leave
+    //
+
+    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);
+
+    if (G26_Debug_flag!=0) {
+      SERIAL_ECHOPGM(" UBL_line_to_destination(xe=");
+      SERIAL_ECHO(x_end);
+      SERIAL_ECHOPGM(",ye=");
+      SERIAL_ECHO(y_end);
+      SERIAL_ECHOPGM(",ze=");
+      SERIAL_ECHO(z_end);
+      SERIAL_ECHOPGM(",ee=");
+      SERIAL_ECHO(e_end);
+      SERIAL_ECHOPGM(")\n");
+      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_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
+        // a reasonable correction would be.
+
+        planner.buffer_line(x_end, y_end, z_end + blm.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()");
+        }
+        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;
+
+      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;
+
+      // 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);
+
+      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()
+      //
+      /*
+        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  ");
+        SERIAL_ECHOPAIR("  x_end=", x_end);
+        SERIAL_ECHOPAIR("  y_end=", y_end);
+        SERIAL_ECHOPAIR("  z0=", z0);
+        SERIAL_ECHOPAIR("  z_optimized=", z_optimized);
+        SERIAL_ECHOPAIR("  err=",fabs(z_optimized - z0));
+        SERIAL_EOL;
+        }
+      */
+      z0 = z0 * blm.fade_scaling_factor_for_Z( z_end );
+
+      if (isnan(z0)) {  // if part of the Mesh is undefined, it will show up as NAN
+        z0 = 0.0; // in z_values[][] and propagate through the
+        // calculations. If our correction is NAN, we throw it out
+        // because part of the Mesh is undefined and we don't have the
+        // information we need to complete the height correction.
+      }
+
+      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;
+
+    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
+      dxi = -1;
+      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
+      dxi = 1;  // to save setting up the abs() function call and actually doing the call.
+      adx = dx;
+    }
+    if (dy<0.0) {
+      dyi = -1;
+      ady = -dy;  // absolute value of dy
+    }
+    else {
+      dyi = 1;
+      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;
+    }
+    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;
+    }
+    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.
+    //
+    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
+        }
+
+        z0 = blm.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  ");
+          SERIAL_ECHOPAIR("  x=", x);
+          SERIAL_ECHOPAIR("  next_mesh_line_y=", next_mesh_line_y);
+          SERIAL_ECHOPAIR("  z0=", z0);
+          SERIAL_ECHOPAIR("  z_optimized=", z_optimized);
+          SERIAL_ECHOPAIR("  err=",fabs(z_optimized-z0));
+          SERIAL_ECHO("\n");
+          }
+        */
+
+        z0 = z0 * blm.fade_scaling_factor_for_Z( z_end );
+
+        if (isnan(z0)) {  // if part of the Mesh is undefined, it will show up as NAN
+          z0 = 0.0; // in z_values[][] and propagate through the
+          // calculations. If our correction is NAN, we throw it out
+          // because part of the Mesh is undefined and we don't have the
+          // information we need to complete the height correction.
+        }
+        y = mesh_index_to_Y_location[current_yi];
+
+        // Without this check, it is possible for the algorythm to generate a zero length move in the case
+        // where the line is heading down and it is starting right on a Mesh Line boundary.  For how often that
+        // happens, it might be best to remove the check and always 'schedule' the move because
+        // the planner.buffer_line() routine will filter it if that happens.
+        if ( y!=y_start)   {
+          if ( inf_normalized_flag == false ) {
+            on_axis_distance   = y - y_start;       // we don't need to check if the extruder position
+            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;
+          }
+          else {
+            e_position = e_start;
+            z_position = z_start;
+          }
+
+          planner.buffer_line(x, y, z_position + z0 + blm.state.z_offset, e_position, feed_rate, extruder);
+        } //else printf("FIRST MOVE PRUNED  ");
+      }
+      //
+      // 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) {
+        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.
+    //
+
+    if (dyi == 0) {       // Check for a horiziontal 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.
+      while (current_xi != cell_dest_xi + left_flag) {
+        current_xi += dxi;
+        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);
+
+        //
+        // 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  ");
+          SERIAL_ECHOPAIR("  next_mesh_line_x=", next_mesh_line_x);
+          SERIAL_ECHOPAIR("  y=", y);
+          SERIAL_ECHOPAIR("  z0=", z0);
+          SERIAL_ECHOPAIR("  z_optimized=", z_optimized);
+          SERIAL_ECHOPAIR("  err=",fabs(z_optimized-z0));
+          SERIAL_ECHO("\n");
+          }
+        */
+
+        z0 = z0 * blm.fade_scaling_factor_for_Z( z_end );
+
+        if (isnan(z0)) {  // if part of the Mesh is undefined, it will show up as NAN
+          z0 = 0.0; // in z_values[][] and propagate through the
+          // calculations. If our correction is NAN, we throw it out
+          // because part of the Mesh is undefined and we don't have the
+          // information we need to complete the height correction.
+        }
+        x = mesh_index_to_X_location[current_xi];
+
+        // Without this check, it is possible for the algorythm to generate a zero length move in the case
+        // where the line is heading left and it is starting right on a Mesh Line boundary.  For how often
+        // that happens, it might be best to remove the check and always 'schedule' the move because
+        // the planner.buffer_line() routine will filter it if that happens.
+        if ( x!=x_start)   {
+          if ( inf_normalized_flag == false ) {
+            on_axis_distance   = x - x_start;       // we don't need to check if the extruder position
+            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;
+          }
+          else {
+            e_position = e_start;
+            z_position = z_start;
+          }
+
+          planner.buffer_line(x, y, z_position + z0 + blm.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) {
+        goto FINAL_MOVE;
+      }
+      set_current_to_destination();
+      return;
+    }
+
+    //
+    //
+    //
+    //
+    // 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;
+    }
+
+    yi_cnt = cell_start_yi - cell_dest_yi;
+    if ( yi_cnt < 0 ) {
+      yi_cnt = -yi_cnt;
+    }
+
+    current_xi += left_flag;
+    current_yi += down_flag;
+
+    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];
+
+      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
+      // about m being equal to 0.0  If this was the case, we would have
+      // detected this as a vertical line move up above and we wouldn't
+      // be down here doing a generic type of move.
+
+      if ((left_flag && (x>next_mesh_line_x)) || (!left_flag && (x<next_mesh_line_x))) { // Check if we hit the Y line first
+        //
+        // Yes!  Crossing a Y Mesh Line next
+        //
+        z0 = blm.get_z_correction_along_horizontal_mesh_line_at_specific_X(x, current_xi-left_flag, current_yi+dyi);
+
+        //
+        // debug code to use non-optimized get_z_correction() and to do a sanity check
+        // that the correct value is being passed to planner.buffer_line()
+        //
+
+        /*
+
+          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  "); {
+              SERIAL_ECHOPAIR("  x=", x);
+            }
+            SERIAL_ECHOPAIR("  next_mesh_line_y=", next_mesh_line_y);
+            SERIAL_ECHOPAIR("  z0=", z0);
+            SERIAL_ECHOPAIR("  z_optimized=", z_optimized);
+            SERIAL_ECHOPAIR("  err=",fabs(z_optimized-z0));
+            SERIAL_ECHO("\n");
+          }
+        */
+
+        z0 = z0 * blm.fade_scaling_factor_for_Z( z_end );
+        if (isnan(z0)) {  // if part of the Mesh is undefined, it will show up as NAN
+          z0 = 0.0; // in z_values[][] and propagate through the
+          // calculations. If our correction is NAN, we throw it out
+          // because part of the Mesh is undefined and we don't have the
+          // information we need to complete the height correction.
+        }
+
+        if ( inf_normalized_flag == false ) {
+          if ( use_X_dist ) {
+            on_axis_distance   = x - x_start;
+          }
+          else {
+            on_axis_distance   = next_mesh_line_y - y_start;
+          }
+          e_position = e_start + on_axis_distance * e_normalized_dist;
+          z_position = z_start + on_axis_distance * z_normalized_dist;
+        }
+        else {
+          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);
+        current_yi += dyi;
+        yi_cnt--;
+      }
+      else {
+        //
+        // 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);
+
+
+        //
+        // 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  ");
+          SERIAL_ECHOPAIR("  next_mesh_line_x=", next_mesh_line_x);
+          SERIAL_ECHOPAIR("  y=", y);
+          SERIAL_ECHOPAIR("  z0=", z0);
+          SERIAL_ECHOPAIR("  z_optimized=", z_optimized);
+          SERIAL_ECHOPAIR("  err=",fabs(z_optimized-z0));
+          SERIAL_ECHO("\n");
+          }
+        */
+
+        z0 = z0 * blm.fade_scaling_factor_for_Z( z_end );
+
+        if (isnan(z0)) {  // if part of the Mesh is undefined, it will show up as NAN
+          z0 = 0.0; // in z_values[][] and propagate through the
+          // calculations. If our correction is NAN, we throw it out
+          // because part of the Mesh is undefined and we don't have the
+          // information we need to complete the height correction.
+        }
+        if ( inf_normalized_flag == false ) {
+          if ( use_X_dist ) {
+            on_axis_distance   = next_mesh_line_x - x_start;
+          }
+          else {
+            on_axis_distance   = y - y_start;
+          }
+          e_position = e_start + on_axis_distance * e_normalized_dist;
+          z_position = z_start + on_axis_distance * z_normalized_dist;
+        }
+        else {
+          e_position = e_start;
+          z_position = z_start;
+        }
+
+        planner.buffer_line(next_mesh_line_x, y, z_position + z0 + blm.state.z_offset, e_position, feed_rate, extruder);
+        current_xi += dxi;
+        xi_cnt--;
+      }
+    }
+    if (G26_Debug_flag) {
+      debug_current_and_destination( (char *) "generic move done in UBL_line_to_destination()");
+    }
+    if (current_position[0] != x_end || current_position[1] != y_end)  {
+      goto FINAL_MOVE;
+    }
+    set_current_to_destination();
+    return;
+  }
+
+  void wait_for_button_press() {
+    //  if ( !been_to_2_6 )
+    //return;   // bob - I think this should be commented out
+
+    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
+
+

Marlin/configuration_store.cpp

   #include "stepper_indirection.h"
 #endif
 
+#if ENABLED(AUTO_BED_LEVELING_UBL)
+  #include "UBL.h"
+#endif
+
 #if ENABLED(ABL_BILINEAR_SUBDIVISION)
   extern void bed_level_virt_interpolate();
 #endif
       SERIAL_ECHOPAIR("Settings Stored (", eeprom_size - (EEPROM_OFFSET));
       SERIAL_ECHOLNPGM(" bytes)");
     }
+    #if ENABLED(AUTO_BED_LEVELING_UBL)
+      blm.store_state();
+      if (blm.state.EEPROM_storage_slot >= 0)
+        blm.store_mesh(blm.state.EEPROM_storage_slot);
+    #endif
   }
 
   /**
         SERIAL_ERRORLNPGM("EEPROM checksum mismatch");
         Config_ResetDefault();
       }
-   }
 
+      #if ENABLED(AUTO_BED_LEVELING_UBL)
+        Unified_Bed_Leveling_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();
+
+        SERIAL_ECHOPGM(" UBL ");
+        if (!blm.state.active) SERIAL_ECHO("not ");
+        SERIAL_ECHOLNPGM("active!");
+
+        if (!blm.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;
+          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;
+        }
+        else {
+          SERIAL_PROTOCOLPGM("?Unable to enable Unified Bed Leveling.\n");
+          blm.state = blm.pre_initialized;
+          blm.reset();
+          blm.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);
+          SERIAL_ECHOLNPGM(" loaded from storage.");
+        }
+        else {
+          blm.reset();
+          SERIAL_ECHOPGM("UBL System reset() \n");
+        }
+      #endif
+    }
     #if ENABLED(EEPROM_CHITCHAT)
       Config_PrintSettings();
     #endif
       SERIAL_ECHOPAIR(" Z", home_offset[Z_AXIS]);
       SERIAL_EOL;
     #endif
+  #if ENABLED(AUTO_BED_LEVELING_UBL)
+    SERIAL_ECHOLNPGM("Unified Bed Leveling:");
+    CONFIG_ECHO_START;
+
+    SERIAL_ECHOPGM("System is: ");
+    if (blm.state.active)
+       SERIAL_ECHOLNPGM("Active\n");
+    else
+       SERIAL_ECHOLNPGM("Deactive\n");
+
+    SERIAL_ECHOPAIR("Active Mesh Slot: ", blm.state.EEPROM_storage_slot);
+    SERIAL_EOL;
+
+    SERIAL_ECHOPGM("z_offset: ");
+    SERIAL_ECHO_F(blm.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_ECHOLNPGM(" meshes. \n");
+
+    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_ECHO_F(MESH_X_DIST, 6);
+    SERIAL_ECHOPGM("\nMESH_Y_DIST        ");
+    SERIAL_ECHO_F(MESH_Y_DIST, 6);
+    SERIAL_EOL;
+    SERIAL_EOL;
+  #endif
 
     #if HOTENDS > 1
       CONFIG_ECHO_START;

Marlin/example_configurations/Cartesio/Configuration.h

  *    60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950
  *    66 : 4.7M High Temperature thermistor from Dyze Design
  *    70 : the 100K thermistor found in the bq Hephestos 2
+ *    75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor
  *
  *       1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k.
  *                              (but gives greater accuracy and more stable PID)
 //
 // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN.
 //
-// For a servo-based Z probe, you must set up servo support below, including
-// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES.
+// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above.
 //
 // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin.
 // - Use 5V for powered (usu. inductive) sensors.
   #define FILAMENT_RUNOUT_SCRIPT "M600"
 #endif
 
-//===========================================================================
-//============================ Mesh Bed Leveling ============================
-//===========================================================================
-
-//#define MESH_BED_LEVELING    // Enable mesh bed leveling.
-
-#if ENABLED(MESH_BED_LEVELING)
-  #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 MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment
-
-  //#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  // MANUAL_BED_LEVELING
-
-  // Gradually reduce leveling correction until a set height is reached,
-  // at which point movement will be level to the machine's XY plane.
-  // The height can be set with M420 Z<height>
-  #define ENABLE_LEVELING_FADE_HEIGHT
-
-#endif  // MESH_BED_LEVELING
 
 //===========================================================================
-//============================ Auto Bed Leveling ============================
+//=============================== Bed Leveling ==============================
 //===========================================================================
 // @section bedlevel
 
  *   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.
  */
 //#define AUTO_BED_LEVELING_3POINT
 //#define AUTO_BED_LEVELING_LINEAR
 //#define AUTO_BED_LEVELING_BILINEAR
+//#define MESH_BED_LEVELING
+//#define AUTO_BED_LEVELING_UBL
 
 /**
  * Enable detailed logging of G28, G29, M48, etc.
  */
 //#define DEBUG_LEVELING_FEATURE
 
+#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL)
+  // Gradually reduce leveling correction until a set height is reached,
+  // at which point movement will be level to the machine's XY plane.
+  // The height can be set with M420 Z<height>
+  #define ENABLE_LEVELING_FADE_HEIGHT
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
   // Set the number of grid points per dimension.
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
-    // Gradually reduce leveling correction until a set height is reached,
-    // at which point movement will be level to the machine's XY plane.
-    // The height can be set with M420 Z<height>
-    #define ENABLE_LEVELING_FADE_HEIGHT
-
     //
     // Experimental Subdivision of the grid by Catmull-Rom method.
     // Synthesizes intermediate points to produce a more detailed mesh.
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
-#endif
+#elif ENABLED(MESH_BED_LEVELING)
+
+//===========================================================================
+//=================================== Mesh ==================================
+//===========================================================================
+
+  #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0.
+  #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 at origin [0,0,0]
+
+  //#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  // MANUAL_BED_LEVELING
+
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+//===========================================================================
+//========================= Unified Bed Leveling ============================
+//===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_PROBE_PT_3_Y 20
+
+#endif  // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

Marlin/example_configurations/Felix/Configuration.h

  *    60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950
  *    66 : 4.7M High Temperature thermistor from Dyze Design
  *    70 : the 100K thermistor found in the bq Hephestos 2
+ *    75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor
  *
  *       1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k.
  *                              (but gives greater accuracy and more stable PID)
 //
 // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN.
 //
-// For a servo-based Z probe, you must set up servo support below, including
-// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES.
+// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above.
 //
 // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin.
 // - Use 5V for powered (usu. inductive) sensors.
   #define FILAMENT_RUNOUT_SCRIPT "M600"
 #endif
 
-//===========================================================================
-//============================ Mesh Bed Leveling ============================
-//===========================================================================
-
-//#define MESH_BED_LEVELING    // Enable mesh bed leveling.
-
-#if ENABLED(MESH_BED_LEVELING)
-  #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 MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment
-
-  //#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  // MANUAL_BED_LEVELING
-
-  // Gradually reduce leveling correction until a set height is reached,
-  // at which point movement will be level to the machine's XY plane.
-  // The height can be set with M420 Z<height>
-  #define ENABLE_LEVELING_FADE_HEIGHT
-
-#endif  // MESH_BED_LEVELING
 
 //===========================================================================
-//============================ Auto Bed Leveling ============================
+//=============================== Bed Leveling ==============================
 //===========================================================================
 // @section bedlevel
 
  *   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.
  */
 //#define AUTO_BED_LEVELING_3POINT
 //#define AUTO_BED_LEVELING_LINEAR
 //#define AUTO_BED_LEVELING_BILINEAR
+//#define MESH_BED_LEVELING
+//#define AUTO_BED_LEVELING_UBL
 
 /**
  * Enable detailed logging of G28, G29, M48, etc.
  */
 //#define DEBUG_LEVELING_FEATURE
 
+#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL)
+  // Gradually reduce leveling correction until a set height is reached,
+  // at which point movement will be level to the machine's XY plane.
+  // The height can be set with M420 Z<height>
+  #define ENABLE_LEVELING_FADE_HEIGHT
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
   // Set the number of grid points per dimension.
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
-    // Gradually reduce leveling correction until a set height is reached,
-    // at which point movement will be level to the machine's XY plane.
-    // The height can be set with M420 Z<height>
-    #define ENABLE_LEVELING_FADE_HEIGHT
-
     //
     // Experimental Subdivision of the grid by Catmull-Rom method.
     // Synthesizes intermediate points to produce a more detailed mesh.

Marlin/example_configurations/Felix/DUAL/Configuration.h

  *    60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950
  *    66 : 4.7M High Temperature thermistor from Dyze Design
  *    70 : the 100K thermistor found in the bq Hephestos 2
+ *    75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor
  *
  *       1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k.
  *                              (but gives greater accuracy and more stable PID)
 //
 // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN.
 //
-// For a servo-based Z probe, you must set up servo support below, including
-// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES.
+// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above.
 //
 // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin.
 // - Use 5V for powered (usu. inductive) sensors.
   #define FILAMENT_RUNOUT_SCRIPT "M600"
 #endif
 
-//===========================================================================
-//============================ Mesh Bed Leveling ============================
-//===========================================================================
-
-//#define MESH_BED_LEVELING    // Enable mesh bed leveling.
-
-#if ENABLED(MESH_BED_LEVELING)
-  #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 MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment
-
-  //#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  // MANUAL_BED_LEVELING
-
-  // Gradually reduce leveling correction until a set height is reached,
-  // at which point movement will be level to the machine's XY plane.
-  // The height can be set with M420 Z<height>
-  #define ENABLE_LEVELING_FADE_HEIGHT
-
-#endif  // MESH_BED_LEVELING
 
 //===========================================================================
-//============================ Auto Bed Leveling ============================
+//=============================== Bed Leveling ==============================
 //===========================================================================
 // @section bedlevel
 
  *   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.
  */
 //#define AUTO_BED_LEVELING_3POINT
 //#define AUTO_BED_LEVELING_LINEAR
 //#define AUTO_BED_LEVELING_BILINEAR
+//#define MESH_BED_LEVELING
+//#define AUTO_BED_LEVELING_UBL
 
 /**
  * Enable detailed logging of G28, G29, M48, etc.
  */
 //#define DEBUG_LEVELING_FEATURE
 
+#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL)
+  // Gradually reduce leveling correction until a set height is reached,
+  // at which point movement will be level to the machine's XY plane.
+  // The height can be set with M420 Z<height>
+  #define ENABLE_LEVELING_FADE_HEIGHT
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
   // Set the number of grid points per dimension.
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
-    // Gradually reduce leveling correction until a set height is reached,
-    // at which point movement will be level to the machine's XY plane.
-    // The height can be set with M420 Z<height>
-    #define ENABLE_LEVELING_FADE_HEIGHT
-
     //
     // Experimental Subdivision of the grid by Catmull-Rom method.
     // Synthesizes intermediate points to produce a more detailed mesh.
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
-#endif
+#elif ENABLED(MESH_BED_LEVELING)
+
+//===========================================================================
+//=================================== Mesh ==================================
+//===========================================================================
+
+  #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0.
+  #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 at origin [0,0,0]
+
+  //#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  // MANUAL_BED_LEVELING
+
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+//===========================================================================
+//========================= Unified Bed Leveling ============================
+//===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_PROBE_PT_3_Y 20
+
+#endif  // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

Marlin/example_configurations/Hephestos/Configuration.h

  *    60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950
  *    66 : 4.7M High Temperature thermistor from Dyze Design
  *    70 : the 100K thermistor found in the bq Hephestos 2
+ *    75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor
  *
  *       1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k.
  *                              (but gives greater accuracy and more stable PID)
 //
 // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN.
 //
-// For a servo-based Z probe, you must set up servo support below, including
-// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES.
+// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above.
 //
 // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin.
 // - Use 5V for powered (usu. inductive) sensors.
   #define FILAMENT_RUNOUT_SCRIPT "M600"
 #endif
 
-//===========================================================================
-//============================ Mesh Bed Leveling ============================
-//===========================================================================
-
-//#define MESH_BED_LEVELING    // Enable mesh bed leveling.
-
-#if ENABLED(MESH_BED_LEVELING)
-  #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 MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment
-
-  //#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  // MANUAL_BED_LEVELING
-
-  // Gradually reduce leveling correction until a set height is reached,
-  // at which point movement will be level to the machine's XY plane.
-  // The height can be set with M420 Z<height>
-  #define ENABLE_LEVELING_FADE_HEIGHT
-
-#endif  // MESH_BED_LEVELING
 
 //===========================================================================
-//============================ Auto Bed Leveling ============================
+//=============================== Bed Leveling ==============================
 //===========================================================================
 // @section bedlevel
 
  *   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.
  */
 //#define AUTO_BED_LEVELING_3POINT
 //#define AUTO_BED_LEVELING_LINEAR
 //#define AUTO_BED_LEVELING_BILINEAR
+//#define MESH_BED_LEVELING
+//#define AUTO_BED_LEVELING_UBL
 
 /**
  * Enable detailed logging of G28, G29, M48, etc.
  */
 //#define DEBUG_LEVELING_FEATURE
 
+#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL)
+  // Gradually reduce leveling correction until a set height is reached,
+  // at which point movement will be level to the machine's XY plane.
+  // The height can be set with M420 Z<height>
+  #define ENABLE_LEVELING_FADE_HEIGHT
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
   // Set the number of grid points per dimension.
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
-    // Gradually reduce leveling correction until a set height is reached,
-    // at which point movement will be level to the machine's XY plane.
-    // The height can be set with M420 Z<height>
-    #define ENABLE_LEVELING_FADE_HEIGHT
-
     //
     // Experimental Subdivision of the grid by Catmull-Rom method.
     // Synthesizes intermediate points to produce a more detailed mesh.
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
-#endif
+#elif ENABLED(MESH_BED_LEVELING)
+
+//===========================================================================
+//=================================== Mesh ==================================
+//===========================================================================
+
+  #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0.
+  #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 at origin [0,0,0]
+
+  //#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  // MANUAL_BED_LEVELING
+
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+//===========================================================================
+//========================= Unified Bed Leveling ============================
+//===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_PROBE_PT_3_Y 20
+
+#endif  // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

Marlin/example_configurations/Hephestos_2/Configuration.h

  *    60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950
  *    66 : 4.7M High Temperature thermistor from Dyze Design
  *    70 : the 100K thermistor found in the bq Hephestos 2
+ *    75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor
  *
  *       1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k.
  *                              (but gives greater accuracy and more stable PID)
 //
 // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN.
 //
-// For a servo-based Z probe, you must set up servo support below, including
-// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES.
+// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above.
 //
 // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin.
 // - Use 5V for powered (usu. inductive) sensors.
   #define FILAMENT_RUNOUT_SCRIPT "M600"
 #endif
 
-//===========================================================================
-//============================ Mesh Bed Leveling ============================
-//===========================================================================
-
-//#define MESH_BED_LEVELING    // Enable mesh bed leveling.
-
-#if ENABLED(MESH_BED_LEVELING)
-  #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 MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment
-
-  //#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  // MANUAL_BED_LEVELING
-
-  // Gradually reduce leveling correction until a set height is reached,
-  // at which point movement will be level to the machine's XY plane.
-  // The height can be set with M420 Z<height>
-  #define ENABLE_LEVELING_FADE_HEIGHT
-
-#endif  // MESH_BED_LEVELING
 
 //===========================================================================
-//============================ Auto Bed Leveling ============================
+//=============================== Bed Leveling ==============================
 //===========================================================================
 // @section bedlevel
 
  *   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.
  */
 //#define AUTO_BED_LEVELING_3POINT
-#define AUTO_BED_LEVELING_LINEAR
+//#define AUTO_BED_LEVELING_LINEAR
 //#define AUTO_BED_LEVELING_BILINEAR
+//#define MESH_BED_LEVELING
+//#define AUTO_BED_LEVELING_UBL
 
 /**
  * Enable detailed logging of G28, G29, M48, etc.
  */
 //#define DEBUG_LEVELING_FEATURE
 
+#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL)
+  // Gradually reduce leveling correction until a set height is reached,
+  // at which point movement will be level to the machine's XY plane.
+  // The height can be set with M420 Z<height>
+  #define ENABLE_LEVELING_FADE_HEIGHT
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
   // Set the number of grid points per dimension.
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
-    // Gradually reduce leveling correction until a set height is reached,
-    // at which point movement will be level to the machine's XY plane.
-    // The height can be set with M420 Z<height>
-    #define ENABLE_LEVELING_FADE_HEIGHT
-
     //
     // Experimental Subdivision of the grid by Catmull-Rom method.
     // Synthesizes intermediate points to produce a more detailed mesh.
   #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)
 
-#endif
+#elif ENABLED(MESH_BED_LEVELING)
+
+//===========================================================================
+//=================================== Mesh ==================================
+//===========================================================================
+
+  #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0.
+  #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 at origin [0,0,0]
+
+  //#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  // MANUAL_BED_LEVELING
+
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+//===========================================================================
+//========================= Unified Bed Leveling ============================
+//===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_PROBE_PT_3_Y 20
+
+#endif  // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

Marlin/example_configurations/K8200/Configuration.h

  *    60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950
  *    66 : 4.7M High Temperature thermistor from Dyze Design
  *    70 : the 100K thermistor found in the bq Hephestos 2
+ *    75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor
  *
  *       1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k.
  *                              (but gives greater accuracy and more stable PID)
 //
 // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN.
 //
-// For a servo-based Z probe, you must set up servo support below, including
-// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES.
+// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above.
 //
 // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin.
 // - Use 5V for powered (usu. inductive) sensors.
   #define FILAMENT_RUNOUT_SCRIPT "M600"
 #endif
 
-//===========================================================================
-//============================ Mesh Bed Leveling ============================
-//===========================================================================
-
-//#define MESH_BED_LEVELING    // Enable mesh bed leveling.
-
-#if ENABLED(MESH_BED_LEVELING)
-  #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 MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment
-
-  //#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  // MANUAL_BED_LEVELING
-
-  // Gradually reduce leveling correction until a set height is reached,
-  // at which point movement will be level to the machine's XY plane.
-  // The height can be set with M420 Z<height>
-  #define ENABLE_LEVELING_FADE_HEIGHT
-
-#endif  // MESH_BED_LEVELING
 
 //===========================================================================
-//============================ Auto Bed Leveling ============================
+//=============================== Bed Leveling ==============================
 //===========================================================================
 // @section bedlevel
 
  *   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.
  */
 //#define AUTO_BED_LEVELING_3POINT
 //#define AUTO_BED_LEVELING_LINEAR
 //#define AUTO_BED_LEVELING_BILINEAR
+//#define MESH_BED_LEVELING
+//#define AUTO_BED_LEVELING_UBL
 
 /**
  * Enable detailed logging of G28, G29, M48, etc.
  */
 //#define DEBUG_LEVELING_FEATURE
 
+#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL)
+  // Gradually reduce leveling correction until a set height is reached,
+  // at which point movement will be level to the machine's XY plane.
+  // The height can be set with M420 Z<height>
+  #define ENABLE_LEVELING_FADE_HEIGHT
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
   // Set the number of grid points per dimension.
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
-    // Gradually reduce leveling correction until a set height is reached,
-    // at which point movement will be level to the machine's XY plane.
-    // The height can be set with M420 Z<height>
-    #define ENABLE_LEVELING_FADE_HEIGHT
-
     //
     // Experimental Subdivision of the grid by Catmull-Rom method.
     // Synthesizes intermediate points to produce a more detailed mesh.
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
-#endif
+#elif ENABLED(MESH_BED_LEVELING)
+
+//===========================================================================
+//=================================== Mesh ==================================
+//===========================================================================
+
+  #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0.
+  #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 at origin [0,0,0]
+
+  //#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  // MANUAL_BED_LEVELING
+
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+//===========================================================================
+//========================= Unified Bed Leveling ============================
+//===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_PROBE_PT_3_Y 20
+
+#endif  // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

Marlin/example_configurations/K8400/Configuration.h

  *    60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950
  *    66 : 4.7M High Temperature thermistor from Dyze Design
  *    70 : the 100K thermistor found in the bq Hephestos 2
+ *    75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor
  *
  *       1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k.
  *                              (but gives greater accuracy and more stable PID)
 //
 // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN.
 //
-// For a servo-based Z probe, you must set up servo support below, including
-// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES.
+// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above.
 //
 // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin.
 // - Use 5V for powered (usu. inductive) sensors.
   #define FILAMENT_RUNOUT_SCRIPT "M600"
 #endif
 
-//===========================================================================
-//============================ Mesh Bed Leveling ============================
-//===========================================================================
-
-//#define MESH_BED_LEVELING    // Enable mesh bed leveling.
-
-#if ENABLED(MESH_BED_LEVELING)
-  #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 MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment
-
-  //#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  // MANUAL_BED_LEVELING
-
-  // Gradually reduce leveling correction until a set height is reached,
-  // at which point movement will be level to the machine's XY plane.
-  // The height can be set with M420 Z<height>
-  #define ENABLE_LEVELING_FADE_HEIGHT
-
-#endif  // MESH_BED_LEVELING
 
 //===========================================================================
-//============================ Auto Bed Leveling ============================
+//=============================== Bed Leveling ==============================
 //===========================================================================
 // @section bedlevel
 
  *   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.
  */
 //#define AUTO_BED_LEVELING_3POINT
 //#define AUTO_BED_LEVELING_LINEAR
 //#define AUTO_BED_LEVELING_BILINEAR
+//#define MESH_BED_LEVELING
+//#define AUTO_BED_LEVELING_UBL
 
 /**
  * Enable detailed logging of G28, G29, M48, etc.
  */
 //#define DEBUG_LEVELING_FEATURE
 
+#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL)
+  // Gradually reduce leveling correction until a set height is reached,
+  // at which point movement will be level to the machine's XY plane.
+  // The height can be set with M420 Z<height>
+  #define ENABLE_LEVELING_FADE_HEIGHT
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
   // Set the number of grid points per dimension.
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
-    // Gradually reduce leveling correction until a set height is reached,
-    // at which point movement will be level to the machine's XY plane.
-    // The height can be set with M420 Z<height>
-    #define ENABLE_LEVELING_FADE_HEIGHT
-
     //
     // Experimental Subdivision of the grid by Catmull-Rom method.
     // Synthesizes intermediate points to produce a more detailed mesh.
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
-#endif
+#elif ENABLED(MESH_BED_LEVELING)
+
+//===========================================================================
+//=================================== Mesh ==================================
+//===========================================================================
+
+  #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0.
+  #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 at origin [0,0,0]
+
+  //#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  // MANUAL_BED_LEVELING
+
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+//===========================================================================
+//========================= Unified Bed Leveling ============================
+//===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_PROBE_PT_3_Y 20
+
+#endif  // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

Marlin/example_configurations/K8400/Dual-head/Configuration.h

  *    60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950
  *    66 : 4.7M High Temperature thermistor from Dyze Design
  *    70 : the 100K thermistor found in the bq Hephestos 2
+ *    75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor
  *
  *       1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k.
  *                              (but gives greater accuracy and more stable PID)
 //
 // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN.
 //
-// For a servo-based Z probe, you must set up servo support below, including
-// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES.
+// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above.
 //
 // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin.
 // - Use 5V for powered (usu. inductive) sensors.
   #define FILAMENT_RUNOUT_SCRIPT "M600"
 #endif
 
-//===========================================================================
-//============================ Mesh Bed Leveling ============================
-//===========================================================================
-
-//#define MESH_BED_LEVELING    // Enable mesh bed leveling.
-
-#if ENABLED(MESH_BED_LEVELING)
-  #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 MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment
-
-  //#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  // MANUAL_BED_LEVELING
-
-  // Gradually reduce leveling correction until a set height is reached,
-  // at which point movement will be level to the machine's XY plane.
-  // The height can be set with M420 Z<height>
-  #define ENABLE_LEVELING_FADE_HEIGHT
-
-#endif  // MESH_BED_LEVELING
 
 //===========================================================================
-//============================ Auto Bed Leveling ============================
+//=============================== Bed Leveling ==============================
 //===========================================================================
 // @section bedlevel
 
  *   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.
  */
 //#define AUTO_BED_LEVELING_3POINT
 //#define AUTO_BED_LEVELING_LINEAR
 //#define AUTO_BED_LEVELING_BILINEAR
+//#define MESH_BED_LEVELING
+//#define AUTO_BED_LEVELING_UBL
 
 /**
  * Enable detailed logging of G28, G29, M48, etc.
  */
 //#define DEBUG_LEVELING_FEATURE
 
+#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL)
+  // Gradually reduce leveling correction until a set height is reached,
+  // at which point movement will be level to the machine's XY plane.
+  // The height can be set with M420 Z<height>
+  #define ENABLE_LEVELING_FADE_HEIGHT
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
   // Set the number of grid points per dimension.
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
-    // Gradually reduce leveling correction until a set height is reached,
-    // at which point movement will be level to the machine's XY plane.
-    // The height can be set with M420 Z<height>
-    #define ENABLE_LEVELING_FADE_HEIGHT
-
     //
     // Experimental Subdivision of the grid by Catmull-Rom method.
     // Synthesizes intermediate points to produce a more detailed mesh.
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
-#endif
+#elif ENABLED(MESH_BED_LEVELING)
+
+//===========================================================================
+//=================================== Mesh ==================================
+//===========================================================================
+
+  #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0.
+  #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 at origin [0,0,0]
+
+  //#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  // MANUAL_BED_LEVELING
+
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+//===========================================================================
+//========================= Unified Bed Leveling ============================
+//===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_PROBE_PT_3_Y 20
+
+#endif  // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

Marlin/example_configurations/RepRapWorld/Megatronics/Configuration.h

  *    60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950
  *    66 : 4.7M High Temperature thermistor from Dyze Design
  *    70 : the 100K thermistor found in the bq Hephestos 2
+ *    75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor
  *
  *       1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k.
  *                              (but gives greater accuracy and more stable PID)
 //
 // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN.
 //
-// For a servo-based Z probe, you must set up servo support below, including
-// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES.
+// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above.
 //
 // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin.
 // - Use 5V for powered (usu. inductive) sensors.
   #define FILAMENT_RUNOUT_SCRIPT "M600"
 #endif
 
-//===========================================================================
-//============================ Mesh Bed Leveling ============================
-//===========================================================================
-
-//#define MESH_BED_LEVELING    // Enable mesh bed leveling.
-
-#if ENABLED(MESH_BED_LEVELING)
-  #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 MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment
-
-  //#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  // MANUAL_BED_LEVELING
-
-  // Gradually reduce leveling correction until a set height is reached,
-  // at which point movement will be level to the machine's XY plane.
-  // The height can be set with M420 Z<height>
-  #define ENABLE_LEVELING_FADE_HEIGHT
-
-#endif  // MESH_BED_LEVELING
 
 //===========================================================================
-//============================ Auto Bed Leveling ============================
+//=============================== Bed Leveling ==============================
 //===========================================================================
 // @section bedlevel
 
  *   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.
  */
 //#define AUTO_BED_LEVELING_3POINT
 //#define AUTO_BED_LEVELING_LINEAR
 //#define AUTO_BED_LEVELING_BILINEAR
+//#define MESH_BED_LEVELING
+//#define AUTO_BED_LEVELING_UBL
 
 /**
  * Enable detailed logging of G28, G29, M48, etc.
  */
 //#define DEBUG_LEVELING_FEATURE
 
+#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL)
+  // Gradually reduce leveling correction until a set height is reached,
+  // at which point movement will be level to the machine's XY plane.
+  // The height can be set with M420 Z<height>
+  #define ENABLE_LEVELING_FADE_HEIGHT
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
   // Set the number of grid points per dimension.
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
-    // Gradually reduce leveling correction until a set height is reached,
-    // at which point movement will be level to the machine's XY plane.
-    // The height can be set with M420 Z<height>
-    #define ENABLE_LEVELING_FADE_HEIGHT
-
     //
     // Experimental Subdivision of the grid by Catmull-Rom method.
     // Synthesizes intermediate points to produce a more detailed mesh.
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
-#endif
+#elif ENABLED(MESH_BED_LEVELING)
+
+//===========================================================================
+//=================================== Mesh ==================================
+//===========================================================================
+
+  #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0.
+  #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 at origin [0,0,0]
+
+  //#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  // MANUAL_BED_LEVELING
+
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+//===========================================================================
+//========================= Unified Bed Leveling ============================
+//===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_PROBE_PT_3_Y 20
+
+#endif  // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

Marlin/example_configurations/RigidBot/Configuration.h

  *    60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950
  *    66 : 4.7M High Temperature thermistor from Dyze Design
  *    70 : the 100K thermistor found in the bq Hephestos 2
+ *    75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor
  *
  *       1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k.
  *                              (but gives greater accuracy and more stable PID)
 //
 // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN.
 //
-// For a servo-based Z probe, you must set up servo support below, including
-// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES.
+// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above.
 //
 // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin.
 // - Use 5V for powered (usu. inductive) sensors.
   #define FILAMENT_RUNOUT_SCRIPT "M600"
 #endif
 
-//===========================================================================
-//============================ Mesh Bed Leveling ============================
-//===========================================================================
-
-//#define MESH_BED_LEVELING    // Enable mesh bed leveling.
-
-#if ENABLED(MESH_BED_LEVELING)
-  #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 MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment
-
-  //#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  // MANUAL_BED_LEVELING
-
-  // Gradually reduce leveling correction until a set height is reached,
-  // at which point movement will be level to the machine's XY plane.
-  // The height can be set with M420 Z<height>
-  #define ENABLE_LEVELING_FADE_HEIGHT
-
-#endif  // MESH_BED_LEVELING
 
 //===========================================================================
-//============================ Auto Bed Leveling ============================
+//=============================== Bed Leveling ==============================
 //===========================================================================
 // @section bedlevel
 
  *   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.
  */
 //#define AUTO_BED_LEVELING_3POINT
 //#define AUTO_BED_LEVELING_LINEAR
 //#define AUTO_BED_LEVELING_BILINEAR
+//#define MESH_BED_LEVELING
+//#define AUTO_BED_LEVELING_UBL
 
 /**
  * Enable detailed logging of G28, G29, M48, etc.
  */
 //#define DEBUG_LEVELING_FEATURE
 
+#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL)
+  // Gradually reduce leveling correction until a set height is reached,
+  // at which point movement will be level to the machine's XY plane.
+  // The height can be set with M420 Z<height>
+  #define ENABLE_LEVELING_FADE_HEIGHT
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
   // Set the number of grid points per dimension.
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
-    // Gradually reduce leveling correction until a set height is reached,
-    // at which point movement will be level to the machine's XY plane.
-    // The height can be set with M420 Z<height>
-    #define ENABLE_LEVELING_FADE_HEIGHT
-
     //
     // Experimental Subdivision of the grid by Catmull-Rom method.
     // Synthesizes intermediate points to produce a more detailed mesh.
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
-#endif
+#elif ENABLED(MESH_BED_LEVELING)
+
+//===========================================================================
+//=================================== Mesh ==================================
+//===========================================================================
+
+  #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0.
+  #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 at origin [0,0,0]
+
+  //#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  // MANUAL_BED_LEVELING
+
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+//===========================================================================
+//========================= Unified Bed Leveling ============================
+//===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_PROBE_PT_3_Y 20
+
+#endif  // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.
 // leaving it undefined or defining as 0 will disable the servo subsystem
 // If unsure, leave commented / disabled
 //
-#define NUM_SERVOS 0 // DGlass3D - Servo index starts with 0 for M280 command
+//#define NUM_SERVOS 3 // Servo index starts with 0 for M280 command
 
 // Delay (in milliseconds) before the next move will start, to give the servo time to reach its target angle.
 // 300ms is a good value but you can try less delay.

Marlin/example_configurations/SCARA/Configuration.h

  *    60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950
  *    66 : 4.7M High Temperature thermistor from Dyze Design
  *    70 : the 100K thermistor found in the bq Hephestos 2
+ *    75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor
  *
  *       1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k.
  *                              (but gives greater accuracy and more stable PID)
 //
 // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN.
 //
-// For a servo-based Z probe, you must set up servo support below, including
-// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES.
+// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above.
 //
 // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin.
 // - Use 5V for powered (usu. inductive) sensors.
   #define FILAMENT_RUNOUT_SCRIPT "M600"
 #endif
 
-//===========================================================================
-//============================ Mesh Bed Leveling ============================
-//===========================================================================
-
-//#define MESH_BED_LEVELING    // Enable mesh bed leveling.
-
-#if ENABLED(MESH_BED_LEVELING)
-  #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 MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment
-
-  //#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  // MANUAL_BED_LEVELING
-
-  // Gradually reduce leveling correction until a set height is reached,
-  // at which point movement will be level to the machine's XY plane.
-  // The height can be set with M420 Z<height>
-  #define ENABLE_LEVELING_FADE_HEIGHT
-
-#endif  // MESH_BED_LEVELING
 
 //===========================================================================
-//============================ Auto Bed Leveling ============================
+//=============================== Bed Leveling ==============================
 //===========================================================================
 // @section bedlevel
 
  *   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.
  */
 //#define AUTO_BED_LEVELING_3POINT
 //#define AUTO_BED_LEVELING_LINEAR
 //#define AUTO_BED_LEVELING_BILINEAR
+//#define MESH_BED_LEVELING
+//#define AUTO_BED_LEVELING_UBL
 
 /**
  * Enable detailed logging of G28, G29, M48, etc.
  */
 //#define DEBUG_LEVELING_FEATURE
 
+#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL)
+  // Gradually reduce leveling correction until a set height is reached,
+  // at which point movement will be level to the machine's XY plane.
+  // The height can be set with M420 Z<height>
+  #define ENABLE_LEVELING_FADE_HEIGHT
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
   // Set the number of grid points per dimension.
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
-    // Gradually reduce leveling correction until a set height is reached,
-    // at which point movement will be level to the machine's XY plane.
-    // The height can be set with M420 Z<height>
-    #define ENABLE_LEVELING_FADE_HEIGHT
-
     //
     // Experimental Subdivision of the grid by Catmull-Rom method.
     // Synthesizes intermediate points to produce a more detailed mesh.
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
-#endif
+#elif ENABLED(MESH_BED_LEVELING)
+
+//===========================================================================
+//=================================== Mesh ==================================
+//===========================================================================
+
+  #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0.
+  #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 at origin [0,0,0]
+
+  //#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  // MANUAL_BED_LEVELING
+
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+//===========================================================================
+//========================= Unified Bed Leveling ============================
+//===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_PROBE_PT_3_Y 20
+
+#endif  // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

Marlin/example_configurations/TAZ4/Configuration.h

  *    60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950
  *    66 : 4.7M High Temperature thermistor from Dyze Design
  *    70 : the 100K thermistor found in the bq Hephestos 2
+ *    75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor
  *
  *       1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k.
  *                              (but gives greater accuracy and more stable PID)
 //
 // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN.
 //
-// For a servo-based Z probe, you must set up servo support below, including
-// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES.
+// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above.
 //
 // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin.
 // - Use 5V for powered (usu. inductive) sensors.
   #define FILAMENT_RUNOUT_SCRIPT "M600"
 #endif
 
-//===========================================================================
-//============================ Mesh Bed Leveling ============================
-//===========================================================================
-
-//#define MESH_BED_LEVELING    // Enable mesh bed leveling.
-
-#if ENABLED(MESH_BED_LEVELING)
-  #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 MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment
-
-  //#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  // MANUAL_BED_LEVELING
-
-  // Gradually reduce leveling correction until a set height is reached,
-  // at which point movement will be level to the machine's XY plane.
-  // The height can be set with M420 Z<height>
-  #define ENABLE_LEVELING_FADE_HEIGHT
-
-#endif  // MESH_BED_LEVELING
 
 //===========================================================================
-//============================ Auto Bed Leveling ============================
+//=============================== Bed Leveling ==============================
 //===========================================================================
 // @section bedlevel
 
  *   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.
  */
 //#define AUTO_BED_LEVELING_3POINT
 //#define AUTO_BED_LEVELING_LINEAR
 //#define AUTO_BED_LEVELING_BILINEAR
+//#define MESH_BED_LEVELING
+//#define AUTO_BED_LEVELING_UBL
 
 /**
  * Enable detailed logging of G28, G29, M48, etc.
  */
 //#define DEBUG_LEVELING_FEATURE
 
+#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL)
+  // Gradually reduce leveling correction until a set height is reached,
+  // at which point movement will be level to the machine's XY plane.
+  // The height can be set with M420 Z<height>
+  #define ENABLE_LEVELING_FADE_HEIGHT
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
   // Set the number of grid points per dimension.
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
-    // Gradually reduce leveling correction until a set height is reached,
-    // at which point movement will be level to the machine's XY plane.
-    // The height can be set with M420 Z<height>
-    #define ENABLE_LEVELING_FADE_HEIGHT
-
     //
     // Experimental Subdivision of the grid by Catmull-Rom method.
     // Synthesizes intermediate points to produce a more detailed mesh.
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
-#endif
+#elif ENABLED(MESH_BED_LEVELING)
+
+//===========================================================================
+//=================================== Mesh ==================================
+//===========================================================================
+
+  #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0.
+  #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 at origin [0,0,0]
+
+  //#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  // MANUAL_BED_LEVELING
+
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+//===========================================================================
+//========================= Unified Bed Leveling ============================
+//===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_PROBE_PT_3_Y 20
+
+#endif  // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

Marlin/example_configurations/WITBOX/Configuration.h

  *    60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950
  *    66 : 4.7M High Temperature thermistor from Dyze Design
  *    70 : the 100K thermistor found in the bq Hephestos 2
+ *    75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor
  *
  *       1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k.
  *                              (but gives greater accuracy and more stable PID)
 //
 // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN.
 //
-// For a servo-based Z probe, you must set up servo support below, including
-// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES.
+// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above.
 //
 // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin.
 // - Use 5V for powered (usu. inductive) sensors.
   #define FILAMENT_RUNOUT_SCRIPT "M600"
 #endif
 
-//===========================================================================
-//============================ Mesh Bed Leveling ============================
-//===========================================================================
-
-//#define MESH_BED_LEVELING    // Enable mesh bed leveling.
-
-#if ENABLED(MESH_BED_LEVELING)
-  #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 MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment
-
-  //#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  // MANUAL_BED_LEVELING
-
-  // Gradually reduce leveling correction until a set height is reached,
-  // at which point movement will be level to the machine's XY plane.
-  // The height can be set with M420 Z<height>
-  #define ENABLE_LEVELING_FADE_HEIGHT
-
-#endif  // MESH_BED_LEVELING
 
 //===========================================================================
-//============================ Auto Bed Leveling ============================
+//=============================== Bed Leveling ==============================
 //===========================================================================
 // @section bedlevel
 
  *   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.
  */
 //#define AUTO_BED_LEVELING_3POINT
 //#define AUTO_BED_LEVELING_LINEAR
 //#define AUTO_BED_LEVELING_BILINEAR
+//#define MESH_BED_LEVELING
+//#define AUTO_BED_LEVELING_UBL
 
 /**
  * Enable detailed logging of G28, G29, M48, etc.
  */
 //#define DEBUG_LEVELING_FEATURE
 
+#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL)
+  // Gradually reduce leveling correction until a set height is reached,
+  // at which point movement will be level to the machine's XY plane.
+  // The height can be set with M420 Z<height>
+  #define ENABLE_LEVELING_FADE_HEIGHT
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
   // Set the number of grid points per dimension.
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
-    // Gradually reduce leveling correction until a set height is reached,
-    // at which point movement will be level to the machine's XY plane.
-    // The height can be set with M420 Z<height>
-    #define ENABLE_LEVELING_FADE_HEIGHT
-
     //
     // Experimental Subdivision of the grid by Catmull-Rom method.
     // Synthesizes intermediate points to produce a more detailed mesh.
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
-#endif
+#elif ENABLED(MESH_BED_LEVELING)
+
+//===========================================================================
+//=================================== Mesh ==================================
+//===========================================================================
+
+  #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0.
+  #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 at origin [0,0,0]
+
+  //#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  // MANUAL_BED_LEVELING
+
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+//===========================================================================
+//========================= Unified Bed Leveling ============================
+//===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_PROBE_PT_3_Y 20
+
+#endif  // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

Marlin/example_configurations/adafruit/ST7565/Configuration.h

  *    60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950
  *    66 : 4.7M High Temperature thermistor from Dyze Design
  *    70 : the 100K thermistor found in the bq Hephestos 2
+ *    75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor
  *
  *       1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k.
  *                              (but gives greater accuracy and more stable PID)
 //
 // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN.
 //
-// For a servo-based Z probe, you must set up servo support below, including
-// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES.
+// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above.
 //
 // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin.
 // - Use 5V for powered (usu. inductive) sensors.
   #define FILAMENT_RUNOUT_SCRIPT "M600"
 #endif
 
-//===========================================================================
-//============================ Mesh Bed Leveling ============================
-//===========================================================================
-
-//#define MESH_BED_LEVELING    // Enable mesh bed leveling.
-
-#if ENABLED(MESH_BED_LEVELING)
-  #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 MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment
-
-  //#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  // MANUAL_BED_LEVELING
-
-  // Gradually reduce leveling correction until a set height is reached,
-  // at which point movement will be level to the machine's XY plane.
-  // The height can be set with M420 Z<height>
-  #define ENABLE_LEVELING_FADE_HEIGHT
-
-#endif  // MESH_BED_LEVELING
 
 //===========================================================================
-//============================ Auto Bed Leveling ============================
+//=============================== Bed Leveling ==============================
 //===========================================================================
 // @section bedlevel
 
  *   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.
  */
 //#define AUTO_BED_LEVELING_3POINT
 //#define AUTO_BED_LEVELING_LINEAR
 //#define AUTO_BED_LEVELING_BILINEAR
+//#define MESH_BED_LEVELING
+//#define AUTO_BED_LEVELING_UBL
 
 /**
  * Enable detailed logging of G28, G29, M48, etc.
  */
 //#define DEBUG_LEVELING_FEATURE
 
+#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL)
+  // Gradually reduce leveling correction until a set height is reached,
+  // at which point movement will be level to the machine's XY plane.
+  // The height can be set with M420 Z<height>
+  #define ENABLE_LEVELING_FADE_HEIGHT
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
   // Set the number of grid points per dimension.
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
-    // Gradually reduce leveling correction until a set height is reached,
-    // at which point movement will be level to the machine's XY plane.
-    // The height can be set with M420 Z<height>
-    #define ENABLE_LEVELING_FADE_HEIGHT
-
     //
     // Experimental Subdivision of the grid by Catmull-Rom method.
     // Synthesizes intermediate points to produce a more detailed mesh.
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
-#endif
+#elif ENABLED(MESH_BED_LEVELING)
+
+//===========================================================================
+//=================================== Mesh ==================================
+//===========================================================================
+
+  #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0.
+  #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 at origin [0,0,0]
+
+  //#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  // MANUAL_BED_LEVELING
+
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+//===========================================================================
+//========================= Unified Bed Leveling ============================
+//===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_PROBE_PT_3_Y 20
+
+#endif  // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

Marlin/example_configurations/delta/flsun_kossel_mini/Configuration.h

  *    60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950
  *    66 : 4.7M High Temperature thermistor from Dyze Design
  *    70 : the 100K thermistor found in the bq Hephestos 2
+ *    75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor
  *
  *       1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k.
  *                              (but gives greater accuracy and more stable PID)
 //
 // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN.
 //
-// For a servo-based Z probe, you must set up servo support below, including
-// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES.
+// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above.
 //
 // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin.
 // - Use 5V for powered (usu. inductive) sensors.
 #endif
 
 //===========================================================================
-//============================ Mesh Bed Leveling ============================
-//===========================================================================
-//
-// MESH_BED_LEVELING does not yet support DELTA printers.
-//#define MESH_BED_LEVELING    // Enable mesh bed leveling.
-
-#if ENABLED(MESH_BED_LEVELING)
-  #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 MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment
-
-  //#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  // MANUAL_BED_LEVELING
-
-  // Gradually reduce leveling correction until a set height is reached,
-  // at which point movement will be level to the machine's XY plane.
-  // The height can be set with M420 Z<height>
-  #define ENABLE_LEVELING_FADE_HEIGHT
-
-#endif  // MESH_BED_LEVELING
-
-//===========================================================================
-//============================ Auto Bed Leveling ============================
+//=============================== Bed Leveling ==============================
 //===========================================================================
 // @section bedlevel
 
  *   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.
  */
 //#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
 
 /**
  * Enable detailed logging of G28, G29, M48, etc.
  */
 //#define DEBUG_LEVELING_FEATURE
 
+#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL)
+  // Gradually reduce leveling correction until a set height is reached,
+  // at which point movement will be level to the machine's XY plane.
+  // The height can be set with M420 Z<height>
+  //#define ENABLE_LEVELING_FADE_HEIGHT
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
   // Set the number of grid points per dimension.
   //#define PROBE_Y_FIRST
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
-
-    // Gradually reduce leveling correction until a set height is reached,
-    // at which point movement will be level to the machine's XY plane.
-    // The height can be set with M420 Z<height>
-    //#define ENABLE_LEVELING_FADE_HEIGHT
-
     //
     // Experimental Subdivision of the grid by Catmull-Rom method.
     // Synthesizes intermediate points to produce a more detailed mesh.
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
-#endif
+#elif ENABLED(MESH_BED_LEVELING)
+
+//===========================================================================
+//=================================== Mesh ==================================
+//===========================================================================
+
+  #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0.
+  #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 at origin [0,0,0]
+
+  //#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  // MANUAL_BED_LEVELING
+
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+//===========================================================================
+//========================= Unified Bed Leveling ============================
+//===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_PROBE_PT_3_Y 20
+
+#endif  // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

Marlin/example_configurations/delta/generic/Configuration.h

  *    60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950
  *    66 : 4.7M High Temperature thermistor from Dyze Design
  *    70 : the 100K thermistor found in the bq Hephestos 2
+ *    75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor
  *
  *       1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k.
  *                              (but gives greater accuracy and more stable PID)
 //
 // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN.
 //
-// For a servo-based Z probe, you must set up servo support below, including
-// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES.
+// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above.
 //
 // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin.
 // - Use 5V for powered (usu. inductive) sensors.
   #define FILAMENT_RUNOUT_SCRIPT "M600"
 #endif
 
-//===========================================================================
-//============================ Mesh Bed Leveling ============================
-//===========================================================================
-
-//#define MESH_BED_LEVELING    // Enable mesh bed leveling.
-
-#if ENABLED(MESH_BED_LEVELING)
-  #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 MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment
-
-  //#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  // MANUAL_BED_LEVELING
-
-  // Gradually reduce leveling correction until a set height is reached,
-  // at which point movement will be level to the machine's XY plane.
-  // The height can be set with M420 Z<height>
-  #define ENABLE_LEVELING_FADE_HEIGHT
-
-#endif  // MESH_BED_LEVELING
 
 //===========================================================================
-//============================ Auto Bed Leveling ============================
+//=============================== Bed Leveling ==============================
 //===========================================================================
 // @section bedlevel
 
  *   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.
  */
 //#define AUTO_BED_LEVELING_3POINT
 //#define AUTO_BED_LEVELING_LINEAR
 //#define AUTO_BED_LEVELING_BILINEAR
+//#define MESH_BED_LEVELING
+//#define AUTO_BED_LEVELING_UBL
 
 /**
  * Enable detailed logging of G28, G29, M48, etc.
  */
 //#define DEBUG_LEVELING_FEATURE
 
+#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL)
+  // Gradually reduce leveling correction until a set height is reached,
+  // at which point movement will be level to the machine's XY plane.
+  // The height can be set with M420 Z<height>
+  //#define ENABLE_LEVELING_FADE_HEIGHT
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
   // Set the number of grid points per dimension.
   //#define PROBE_Y_FIRST
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
-
-    // Gradually reduce leveling correction until a set height is reached,
-    // at which point movement will be level to the machine's XY plane.
-    // The height can be set with M420 Z<height>
-    //#define ENABLE_LEVELING_FADE_HEIGHT
-
     //
     // Experimental Subdivision of the grid by Catmull-Rom method.
     // Synthesizes intermediate points to produce a more detailed mesh.
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
-#endif
+#elif ENABLED(MESH_BED_LEVELING)
+
+//===========================================================================
+//=================================== Mesh ==================================
+//===========================================================================
+
+  #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0.
+  #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 at origin [0,0,0]
+
+  //#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  // MANUAL_BED_LEVELING
+
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+//===========================================================================
+//========================= Unified Bed Leveling ============================
+//===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_PROBE_PT_3_Y 20
+
+#endif  // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

Marlin/example_configurations/delta/kossel_mini/Configuration.h

  *    60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950
  *    66 : 4.7M High Temperature thermistor from Dyze Design
  *    70 : the 100K thermistor found in the bq Hephestos 2
+ *    75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor
  *
  *       1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k.
  *                              (but gives greater accuracy and more stable PID)
 //
 // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN.
 //
-// For a servo-based Z probe, you must set up servo support below, including
-// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES.
+// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above.
 //
 // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin.
 // - Use 5V for powered (usu. inductive) sensors.
   #define FILAMENT_RUNOUT_SCRIPT "M600"
 #endif
 
-//===========================================================================
-//============================ Mesh Bed Leveling ============================
-//===========================================================================
-
-//#define MESH_BED_LEVELING    // Enable mesh bed leveling.
-
-#if ENABLED(MESH_BED_LEVELING)
-  #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 MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment
-
-  //#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  // MANUAL_BED_LEVELING
-
-  // Gradually reduce leveling correction until a set height is reached,
-  // at which point movement will be level to the machine's XY plane.
-  // The height can be set with M420 Z<height>
-  #define ENABLE_LEVELING_FADE_HEIGHT
-
-#endif  // MESH_BED_LEVELING
 
 //===========================================================================
-//============================ Auto Bed Leveling ============================
+//=============================== Bed Leveling ==============================
 //===========================================================================
 // @section bedlevel
 
  *   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.
  */
 //#define AUTO_BED_LEVELING_3POINT
 //#define AUTO_BED_LEVELING_LINEAR
 //#define AUTO_BED_LEVELING_BILINEAR
+//#define MESH_BED_LEVELING
+//#define AUTO_BED_LEVELING_UBL
 
 /**
  * Enable detailed logging of G28, G29, M48, etc.
  */
 //#define DEBUG_LEVELING_FEATURE
 
+#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL)
+  // Gradually reduce leveling correction until a set height is reached,
+  // at which point movement will be level to the machine's XY plane.
+  // The height can be set with M420 Z<height>
+  //#define ENABLE_LEVELING_FADE_HEIGHT
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
   // Set the number of grid points per dimension.
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
-    // Gradually reduce leveling correction until a set height is reached,
-    // at which point movement will be level to the machine's XY plane.
-    // The height can be set with M420 Z<height>
-    #define ENABLE_LEVELING_FADE_HEIGHT
-
     //
     // Experimental Subdivision of the grid by Catmull-Rom method.
     // Synthesizes intermediate points to produce a more detailed mesh.
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
-#endif
+#elif ENABLED(MESH_BED_LEVELING)
+
+//===========================================================================
+//=================================== Mesh ==================================
+//===========================================================================
+
+  #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0.
+  #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 at origin [0,0,0]
+
+  //#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  // MANUAL_BED_LEVELING
+
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+//===========================================================================
+//========================= Unified Bed Leveling ============================
+//===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_PROBE_PT_3_Y 20
+
+#endif  // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

Marlin/example_configurations/delta/kossel_pro/Configuration.h

  *    60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950
  *    66 : 4.7M High Temperature thermistor from Dyze Design
  *    70 : the 100K thermistor found in the bq Hephestos 2
+ *    75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor
  *
  *       1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k.
  *                              (but gives greater accuracy and more stable PID)
 //
 // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN.
 //
-// For a servo-based Z probe, you must set up servo support below, including
-// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES.
+// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above.
 //
 // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin.
 // - Use 5V for powered (usu. inductive) sensors.
   #define FILAMENT_RUNOUT_SCRIPT "M600"
 #endif
 
-//===========================================================================
-//============================ Mesh Bed Leveling ============================
-//===========================================================================
-
-//#define MESH_BED_LEVELING    // Enable mesh bed leveling.
-
-#if ENABLED(MESH_BED_LEVELING)
-  #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 MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment
-
-  //#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  // MANUAL_BED_LEVELING
-
-  // Gradually reduce leveling correction until a set height is reached,
-  // at which point movement will be level to the machine's XY plane.
-  // The height can be set with M420 Z<height>
-  #define ENABLE_LEVELING_FADE_HEIGHT
-
-#endif  // MESH_BED_LEVELING
 
 //===========================================================================
-//============================ Auto Bed Leveling ============================
+//=============================== Bed Leveling ==============================
 //===========================================================================
 // @section bedlevel
 
  *   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.
  */
 //#define AUTO_BED_LEVELING_3POINT
 //#define AUTO_BED_LEVELING_LINEAR
-#define AUTO_BED_LEVELING_BILINEAR
+//#define AUTO_BED_LEVELING_BILINEAR
+//#define MESH_BED_LEVELING
+//#define AUTO_BED_LEVELING_UBL
 
 /**
  * Enable detailed logging of G28, G29, M48, etc.
  */
 //#define DEBUG_LEVELING_FEATURE
 
+#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL)
+  // Gradually reduce leveling correction until a set height is reached,
+  // at which point movement will be level to the machine's XY plane.
+  // The height can be set with M420 Z<height>
+  //#define ENABLE_LEVELING_FADE_HEIGHT
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
   // Set the number of grid points per dimension.
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
-    // Gradually reduce leveling correction until a set height is reached,
-    // at which point movement will be level to the machine's XY plane.
-    // The height can be set with M420 Z<height>
-    //#define ENABLE_LEVELING_FADE_HEIGHT
-
     //
     // Experimental Subdivision of the grid by Catmull-Rom method.
     // Synthesizes intermediate points to produce a more detailed mesh.
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
-#endif
+#elif ENABLED(MESH_BED_LEVELING)
+
+//===========================================================================
+//=================================== Mesh ==================================
+//===========================================================================
+
+  #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0.
+  #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 at origin [0,0,0]
+
+  //#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  // MANUAL_BED_LEVELING
+
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+//===========================================================================
+//========================= Unified Bed Leveling ============================
+//===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_PROBE_PT_3_Y 20
+
+#endif  // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

Marlin/example_configurations/delta/kossel_xl/Configuration.h

 // example_configurations/delta directory.
 //
 
+//===========================================================================
+//============================= SCARA Printer ===============================
+//===========================================================================
+// For a Scara printer replace the configuration files with the files in the
+// example_configurations/SCARA directory.
+//
+
 // @section info
 
 // User-specified version info of this build to display in [Pronterface, etc] terminal window during
  *    60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950
  *    66 : 4.7M High Temperature thermistor from Dyze Design
  *    70 : the 100K thermistor found in the bq Hephestos 2
+ *    75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor
  *
  *       1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k.
  *                              (but gives greater accuracy and more stable PID)
 //
 // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN.
 //
-// For a servo-based Z probe, you must set up servo support below, including
-// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES.
+// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above.
 //
 // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin.
 // - Use 5V for powered (usu. inductive) sensors.
   #define FILAMENT_RUNOUT_SCRIPT "M600"
 #endif
 
-//===========================================================================
-//============================ Mesh Bed Leveling ============================
-//===========================================================================
-
-//#define MESH_BED_LEVELING    // Enable mesh bed leveling.
-
-#if ENABLED(MESH_BED_LEVELING)
-  #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 MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment
-
-  //#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  // MANUAL_BED_LEVELING
-
-  // Gradually reduce leveling correction until a set height is reached,
-  // at which point movement will be level to the machine's XY plane.
-  // The height can be set with M420 Z<height>
-  #define ENABLE_LEVELING_FADE_HEIGHT
-
-#endif  // MESH_BED_LEVELING
 
 //===========================================================================
-//============================ Auto Bed Leveling ============================
+//=============================== Bed Leveling ==============================
 //===========================================================================
 // @section bedlevel
 
  *   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.
  */
 //#define AUTO_BED_LEVELING_3POINT
 //#define AUTO_BED_LEVELING_LINEAR
-#define AUTO_BED_LEVELING_BILINEAR
+//#define AUTO_BED_LEVELING_BILINEAR
+//#define MESH_BED_LEVELING
+//#define AUTO_BED_LEVELING_UBL
 
 /**
  * Enable detailed logging of G28, G29, M48, etc.
  */
 //#define DEBUG_LEVELING_FEATURE
 
+#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL)
+  // Gradually reduce leveling correction until a set height is reached,
+  // at which point movement will be level to the machine's XY plane.
+  // The height can be set with M420 Z<height>
+  //#define ENABLE_LEVELING_FADE_HEIGHT
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
   // Set the number of grid points per dimension.
   //#define PROBE_Y_FIRST
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
-
-    // Gradually reduce leveling correction until a set height is reached,
-    // at which point movement will be level to the machine's XY plane.
-    // The height can be set with M420 Z<height>
-    //#define ENABLE_LEVELING_FADE_HEIGHT
-
     //
     // Experimental Subdivision of the grid by Catmull-Rom method.
     // Synthesizes intermediate points to produce a more detailed mesh.
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
-#endif
+#elif ENABLED(MESH_BED_LEVELING)
+
+//===========================================================================
+//=================================== Mesh ==================================
+//===========================================================================
+
+  #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0.
+  #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 at origin [0,0,0]
+
+  //#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  // MANUAL_BED_LEVELING
+
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+//===========================================================================
+//========================= Unified Bed Leveling ============================
+//===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_PROBE_PT_3_Y 20
+
+#endif  // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

Marlin/example_configurations/makibox/Configuration.h

  *    60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950
  *    66 : 4.7M High Temperature thermistor from Dyze Design
  *    70 : the 100K thermistor found in the bq Hephestos 2
+ *    75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor
  *
  *       1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k.
  *                              (but gives greater accuracy and more stable PID)
 //
 // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN.
 //
-// For a servo-based Z probe, you must set up servo support below, including
-// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES.
+// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above.
 //
 // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin.
 // - Use 5V for powered (usu. inductive) sensors.
   #define FILAMENT_RUNOUT_SCRIPT "M600"
 #endif
 
-//===========================================================================
-//============================ Mesh Bed Leveling ============================
-//===========================================================================
-
-//#define MESH_BED_LEVELING    // Enable mesh bed leveling.
-
-#if ENABLED(MESH_BED_LEVELING)
-  #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 MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment
-
-  //#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  // MANUAL_BED_LEVELING
-
-  // Gradually reduce leveling correction until a set height is reached,
-  // at which point movement will be level to the machine's XY plane.
-  // The height can be set with M420 Z<height>
-  #define ENABLE_LEVELING_FADE_HEIGHT
-
-#endif  // MESH_BED_LEVELING
 
 //===========================================================================
-//============================ Auto Bed Leveling ============================
+//=============================== Bed Leveling ==============================
 //===========================================================================
 // @section bedlevel
 
  *   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.
  */
 //#define AUTO_BED_LEVELING_3POINT
 //#define AUTO_BED_LEVELING_LINEAR
 //#define AUTO_BED_LEVELING_BILINEAR
+//#define MESH_BED_LEVELING
+//#define AUTO_BED_LEVELING_UBL
 
 /**
  * Enable detailed logging of G28, G29, M48, etc.
  */
 //#define DEBUG_LEVELING_FEATURE
 
+#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL)
+  // Gradually reduce leveling correction until a set height is reached,
+  // at which point movement will be level to the machine's XY plane.
+  // The height can be set with M420 Z<height>
+  #define ENABLE_LEVELING_FADE_HEIGHT
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
   // Set the number of grid points per dimension.
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
-    // Gradually reduce leveling correction until a set height is reached,
-    // at which point movement will be level to the machine's XY plane.
-    // The height can be set with M420 Z<height>
-    #define ENABLE_LEVELING_FADE_HEIGHT
-
     //
     // Experimental Subdivision of the grid by Catmull-Rom method.
     // Synthesizes intermediate points to produce a more detailed mesh.
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
-#endif
+#elif ENABLED(MESH_BED_LEVELING)
+
+//===========================================================================
+//=================================== Mesh ==================================
+//===========================================================================
+
+  #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0.
+  #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 at origin [0,0,0]
+
+  //#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  // MANUAL_BED_LEVELING
+
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+//===========================================================================
+//========================= Unified Bed Leveling ============================
+//===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_PROBE_PT_3_Y 20
+
+#endif  // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

Marlin/example_configurations/tvrrug/Round2/Configuration.h

  *    60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950
  *    66 : 4.7M High Temperature thermistor from Dyze Design
  *    70 : the 100K thermistor found in the bq Hephestos 2
+ *    75 : 100k Generic Silicon Heat Pad typically a NTC 100K MGB18-104F39050L32 thermistor
  *
  *       1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k.
  *                              (but gives greater accuracy and more stable PID)
 //
 // To use a separate Z probe, your board must define a Z_MIN_PROBE_PIN.
 //
-// For a servo-based Z probe, you must set up servo support below, including
-// NUM_SERVOS, Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES.
+// For a servo-based Z probe, just set Z_ENDSTOP_SERVO_NR and Z_SERVO_ANGLES above.
 //
 // - RAMPS 1.3/1.4 boards may be able to use the 5V, GND, and Aux4->D32 pin.
 // - Use 5V for powered (usu. inductive) sensors.
   #define FILAMENT_RUNOUT_SCRIPT "M600"
 #endif
 
-//===========================================================================
-//============================ Mesh Bed Leveling ============================
-//===========================================================================
-
-//#define MESH_BED_LEVELING    // Enable mesh bed leveling.
-
-#if ENABLED(MESH_BED_LEVELING)
-  #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 MANUAL_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment
-
-  //#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  // MANUAL_BED_LEVELING
-
-  // Gradually reduce leveling correction until a set height is reached,
-  // at which point movement will be level to the machine's XY plane.
-  // The height can be set with M420 Z<height>
-  #define ENABLE_LEVELING_FADE_HEIGHT
-
-#endif  // MESH_BED_LEVELING
 
 //===========================================================================
-//============================ Auto Bed Leveling ============================
+//=============================== Bed Leveling ==============================
 //===========================================================================
 // @section bedlevel
 
  *   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.
  */
 //#define AUTO_BED_LEVELING_3POINT
 //#define AUTO_BED_LEVELING_LINEAR
 //#define AUTO_BED_LEVELING_BILINEAR
+//#define MESH_BED_LEVELING
+//#define AUTO_BED_LEVELING_UBL
 
 /**
  * Enable detailed logging of G28, G29, M48, etc.
  */
 //#define DEBUG_LEVELING_FEATURE
 
+#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL)
+  // Gradually reduce leveling correction until a set height is reached,
+  // at which point movement will be level to the machine's XY plane.
+  // The height can be set with M420 Z<height>
+  #define ENABLE_LEVELING_FADE_HEIGHT
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
   // Set the number of grid points per dimension.
 
   #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
-    // Gradually reduce leveling correction until a set height is reached,
-    // at which point movement will be level to the machine's XY plane.
-    // The height can be set with M420 Z<height>
-    #define ENABLE_LEVELING_FADE_HEIGHT
-
     //
     // Experimental Subdivision of the grid by Catmull-Rom method.
     // Synthesizes intermediate points to produce a more detailed mesh.
   #define ABL_PROBE_PT_3_X 170
   #define ABL_PROBE_PT_3_Y 20
 
-#endif
+#elif ENABLED(MESH_BED_LEVELING)
+
+//===========================================================================
+//=================================== Mesh ==================================
+//===========================================================================
+
+  #define MANUAL_PROBE_Z_RANGE 4 // Z after Home, bed somewhere below but above 0.0.
+  #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 at origin [0,0,0]
+
+  //#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  // MANUAL_BED_LEVELING
+
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+
+//===========================================================================
+//========================= Unified Bed Leveling ============================
+//===========================================================================
+
+  #define UBL_MESH_INSET 1          // Mesh inset margin on print area
+  #define UBL_MESH_NUM_X_POINTS 10  // Don't use more than 15 points per axis, implementation limited.
+  #define UBL_MESH_NUM_Y_POINTS 10
+  #define UBL_PROBE_PT_1_X 39       // These set the probe locations for when UBL does a 3-Point leveling
+  #define UBL_PROBE_PT_1_Y 180      // of the mesh.
+  #define UBL_PROBE_PT_2_X 39
+  #define UBL_PROBE_PT_2_Y 20
+  #define UBL_PROBE_PT_3_X 180
+  #define UBL_PROBE_PT_3_Y 20
+
+#endif  // BED_LEVELING
 
 /**
  * Commands to execute at the end of G29 probing.

Marlin/hex_print_routines.cpp

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+
+#include "Marlin.h"
+#if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(M100_FREE_MEMORY_WATCHER)
+
+#include "hex_print_routines.h"
+
+void prt_hex_nibble(uint8_t n) {
+  if (n <= 9)
+    SERIAL_ECHO(n);
+  else
+    SERIAL_ECHO((char)('A' + n - 10));
+  delay(3);
+}
+
+void prt_hex_byte(uint8_t b) {
+  prt_hex_nibble((b & 0xF0) >> 4);
+  prt_hex_nibble(b & 0x0F);
+}
+
+void prt_hex_word(uint16_t w) {
+  prt_hex_byte((w & 0xFF00) >> 8);
+  prt_hex_byte(w & 0x0FF);
+}
+
+#endif // AUTO_BED_LEVELING_UBL || M100_FREE_MEMORY_WATCHER

Marlin/hex_print_routines.h

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef HEX_PRINT_ROUTINES_H
+#define HEX_PRINT_ROUTINES_H
+
+//
+// 3 support routines to print hex numbers.  We can print a nibble, byte and word
+//
+void prt_hex_nibble(uint8_t n);
+void prt_hex_byte(uint8_t b);
+void prt_hex_word(uint16_t w);
+
+#endif // HEX_PRINT_ROUTINES_H

Marlin/printcounter.cpp

   #if ENABLED(DEBUG_PRINTCOUNTER)
     SERIAL_ECHOPGM(" (");
     SERIAL_ECHO(this->data.printTime);
-    SERIAL_ECHOPGM(")");
+    SERIAL_CHAR(')');
   #endif
 
   elapsed = this->data.longestPrint;
   #if ENABLED(DEBUG_PRINTCOUNTER)
     SERIAL_ECHOPGM(" (");
     SERIAL_ECHO(this->data.longestPrint);
-    SERIAL_ECHOPGM(")");
+    SERIAL_CHAR(')');
   #endif
 
   SERIAL_EOL;

Marlin/temperature.cpp

  * temperature.cpp - temperature control
  */
 
+
+
 #include "Marlin.h"
 #include "ultralcd.h"
 #include "temperature.h"
  *  - Apply filament width to the extrusion rate (may move)
  *  - Update the heated bed PID output value
  */
+
+/**
+ * The following line SOMETIMES results in the dreaded "unable to find a register to spill in class 'POINTER_REGS'"
+ * compile error.
+ *    thermal_runaway_protection(&thermal_runaway_state_machine[e], &thermal_runaway_timer[e], current_temperature[e], target_temperature[e], e, THERMAL_PROTECTION_PERIOD, THERMAL_PROTECTION_HYSTERESIS);
+ *
+ * This is due to a bug in the C++ compiler used by the Arduino IDE from 1.6.10 to at least 1.8.1.
+ *
+ * The work around is to add the compiler flag "__attribute__((__optimize__("O2")))" to the declaration for manage_heater()
+ */
+//void Temperature::manage_heater()  __attribute__((__optimize__("O2")));
 void Temperature::manage_heater() {
 
   if (!temp_meas_ready) return;

Marlin/temperature.h

     /**
      * Call periodically to manage heaters
      */
-    static void manage_heater();
+    //static void manage_heater(); // changed to address compiler error
+    static void manage_heater()  __attribute__((__optimize__("O2")));
 
     /**
      * Preheating hotends

Marlin/thermistornames.h

   #define THERMISTOR_NAME "Makers Tool"
 #elif THERMISTOR_ID == 70
   #define THERMISTOR_NAME "Hephestos 2"
+#elif THERMISTOR_ID == 75
+  #define THERMISTOR_NAME "MGB18"
 
 // Modified thermistors
 #elif THERMISTOR_ID == 51

Marlin/thermistortable_75.h

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+// Generic Silicon Heat Pad with NTC 100K thermistor ( Beta 25/50 3950K)
+//
+// Many of the generic silicon heat pads use the MGB18-104F39050L32 Thermistor   It is used for various
+// wattage and voltage heat pads.  This table is correct if this part is used.   It has been
+// optimized to provide good granularity around the 60 C. and 110 C. which corrisponds to bed temperatures
+// for PLA and ABS.  If you are printing higher temperature filament such as nylon you can uncomment
+// the higher earlier entries in the table to give better accuracy.  But for speed reasons, if these
+// temperatures are not going to be used, it is better to leave them commented out.
+
+const short temptable_75[][2] PROGMEM = { // Generic Silicon Heat Pad with NTC 100K MGB18-104F39050L32 thermistor
+    { (short) ( 111.06 * OVERSAMPLENR ),  200 }, // v=0.542 r=571.747 res=0.501 degC/count
+//  { (short) ( 174.87 * OVERSAMPLENR ),  175 }, // v=0.854 r=967.950 res=0.311 degC/count  These values are valid.  But they serve no
+//  { (short) ( 191.64 * OVERSAMPLENR ),  170 }, // v=0.936 r=1082.139 res=0.284 degC/count  purpose.  It is better to delete them so
+//  { (short) ( 209.99 * OVERSAMPLENR ),  165 }, // v=1.025 r=1212.472 res=0.260 degC/count  the search is quicker and get to the meaningful
+//  { (short) ( 230.02 * OVERSAMPLENR ),  160 }, // v=1.123 r=1361.590 res=0.239 degC/count  part of the table sooner.
+//  { (short) ( 251.80 * OVERSAMPLENR ),  155 }, // v=1.230 r=1532.621 res=0.220 degC/count
+    { (short) ( 275.43 * OVERSAMPLENR ),  150 }, // v=1.345 r=1729.283 res=0.203 degC/count
+//  { (short) ( 300.92 * OVERSAMPLENR ),  145 }, // v=1.469 r=1956.004 res=0.189 degC/coun
+    { (short) ( 328.32 * OVERSAMPLENR ),  140 }, // v=1.603 r=2218.081 res=0.176 degC/count
+    { (short) ( 388.65 * OVERSAMPLENR ),  130 }, // v=1.898 r=2874.980 res=0.156 degC/count
+    { (short) ( 421.39 * OVERSAMPLENR ),  125 }, // v=2.058 r=3286.644 res=0.149 degC/count
+    { (short) ( 455.65 * OVERSAMPLENR ),  120 }, // v=2.225 r=3768.002 res=0.143 degC/count
+    { (short) ( 491.17 * OVERSAMPLENR ),  115 }, // v=2.398 r=4332.590 res=0.139 degC/count
+    { (short) ( 527.68 * OVERSAMPLENR ),  110 }, // v=2.577 r=4996.905 res=0.136 degC/count
+    { (short) ( 564.81 * OVERSAMPLENR ),  105 }, // v=2.758 r=5781.120 res=0.134 degC/count
+    { (short) ( 602.19 * OVERSAMPLENR ),  100 }, // v=2.940 r=6710.000 res=0.134 degC/count
+    { (short) ( 676.03 * OVERSAMPLENR ),   90 }, // v=3.301 r=9131.018 res=0.138 degC/count
+    { (short) ( 745.85 * OVERSAMPLENR ),   80 }, // v=3.642 r=12602.693 res=0.150 degC/count
+    { (short) ( 778.31 * OVERSAMPLENR ),   75 }, // v=3.800 r=14889.001 res=0.159 degC/count
+    { (short) ( 808.75 * OVERSAMPLENR ),   70 }, // v=3.949 r=17658.700 res=0.171 degC/count
+    { (short) ( 836.94 * OVERSAMPLENR ),   65 }, // v=4.087 r=21028.040 res=0.185 degC/count
+    { (short) ( 862.74 * OVERSAMPLENR ),   60 }, // v=4.213 r=25144.568 res=0.204 degC/count
+    { (short) ( 886.08 * OVERSAMPLENR ),   55 }, // v=4.327 r=30196.449 res=0.227 degC/count
+    { (short) ( 906.97 * OVERSAMPLENR ),   50 }, // v=4.429 r=36424.838 res=0.255 degC/count
+    { (short) ( 941.65 * OVERSAMPLENR ),   40 }, // v=4.598 r=53745.337 res=0.333 degC/count
+    { (short) ( 967.76 * OVERSAMPLENR ),   30 }, // v=4.725 r=80880.630 res=0.452 degC/count
+    { (short) ( 978.03 * OVERSAMPLENR ),   25 }, // v=4.776 r=100000.000 res=0.535 degC/count
+    { (short) ( 981.68 * OVERSAMPLENR ),   23 }, // v=4.793 r=109024.395 res=0.573 degC/count
+    { (short) ( 983.41 * OVERSAMPLENR ),   22 }, // v=4.802 r=113875.430 res=0.594 degC/count
+    { (short) ( 985.08 * OVERSAMPLENR ),   21 }, // v=4.810 r=118968.955 res=0.616 degC/count
+    { (short) ( 986.70 * OVERSAMPLENR ),   20 }, // v=4.818 r=124318.354 res=0.638 degC/count
+    { (short) ( 993.94 * OVERSAMPLENR ),   15 }, // v=4.853 r=155431.302 res=0.768 degC/count
+    { (short) ( 999.96 * OVERSAMPLENR ),   10 }, // v=4.883 r=195480.023 res=0.934 degC/count
+    { (short) (1008.95 * OVERSAMPLENR ),    0 }  // v=4.926 r=314997.575 res=1.418 degC/count
+};
+
+

Marlin/thermistortables.h

 #if ANY_THERMISTOR_IS(70) // bqh2 stock thermistor
   #include "thermistortable_70.h"
 #endif
+#if ANY_THERMISTOR_IS(75) // Many of the generic silicon heat pads use the MGB18-104F39050L32 Thermistor
+  #include "thermistortable_75.h"
+#endif
 #if ANY_THERMISTOR_IS(110) // Pt100 with 1k0 pullup
   #include "thermistortable_110.h"
 #endif

Marlin/ultralcd.cpp

 #include "configuration_store.h"
 #include "utility.h"
 
+extern float zprobe_zoffset;
+
 #if HAS_BUZZER && DISABLED(LCD_USE_I2C_BUZZER)
   #include "buzzer.h"
 #endif
   bool encoderRateMultiplierEnabled;
   int32_t lastEncoderMovementMillis;
 
+  #if ENABLED(AUTO_BED_LEVELING_UBL)
+  extern int UBL_has_control_of_LCD_Panel;
+  extern int G29_encoderDiff;
+  #endif
+
   #if HAS_POWER_SWITCH
     extern bool powersupply;
   #endif
 
   #endif //BABYSTEPPING
 
+  #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
+                                                  // seperate value that doesn't lose precision.
+    static int loop_cnt=0, last_seen_bits;
+
+    static void _lcd_mesh_fine_tune( const char* msg) {
+      static unsigned long last_click=0;
+      int  last_digit, movement;
+      long int rounded;
+
+      defer_return_to_status = true;
+      if (encoderPosition) {                     // If moving the Encoder wheel very slowly, we just go
+        if ( (millis() - last_click) > 500L) {   // up or down by 1 position
+          if ( ((int32_t)encoderPosition) > 0 ) {
+            encoderPosition = 1;
+          }
+          else {
+            encoderPosition = (uint32_t) -1;
+          }
+        }
+        last_click = millis();
+
+        Mesh_Edit_Accumulator += ( (float) ((int32_t)encoderPosition)) * .005 / 2.0 ;
+        Mesh_Edit_Value       = Mesh_Edit_Accumulator;
+        encoderPosition       = 0;
+        lcdDrawUpdate       = LCDVIEW_REDRAW_NOW;
+
+        rounded    = (long int) (Mesh_Edit_Value * 1000.0);
+        last_digit = rounded % 5L; //10L;
+        rounded    = rounded - last_digit;
+        last_digit = rounded % 5L; //10L;
+        Mesh_Edit_Value  = ((float) rounded) / 1000.0;
+      }
+
+      if (lcdDrawUpdate) {
+        lcd_implementation_drawedit(msg, ftostr43sign( (float) Mesh_Edit_Value  ));
+      }
+
+      if ( !UBL_has_control_of_LCD_Panel && LCD_CLICKED ) {
+        UBL_has_control_of_LCD_Panel=1;   // We need to lock the normal LCD Panel System outbecause G29 (and G26) are looking for
+        lcd_return_to_status();           // long presses of the Encoder Wheel and the LCD System goes spastic when that happens.
+                                          // We will give back control from those routines when the switch is debounced.
+      }
+    }
+
+
+    void _lcd_mesh_edit() {
+      _lcd_mesh_fine_tune( PSTR("Mesh Editor: "));
+    }
+
+    float lcd_mesh_edit() {
+      lcd_goto_screen(_lcd_mesh_edit);
+      return Mesh_Edit_Value;
+    }
+
+    void lcd_mesh_edit_setup(float inital) {
+      Mesh_Edit_Value       = inital;
+      Mesh_Edit_Accumulator = inital;
+      lcd_goto_screen(_lcd_mesh_edit);
+      return ;
+    }
+
+    void _lcd_z_offset_edit() {
+      _lcd_mesh_fine_tune( PSTR("Z-Offset: "));
+    }
+
+    float lcd_z_offset_edit() {
+      lcd_goto_screen(_lcd_z_offset_edit);
+      return Mesh_Edit_Value;
+    }
+
+    void lcd_z_offset_edit_setup(float inital) {
+      Mesh_Edit_Value       = inital;
+      Mesh_Edit_Accumulator = inital;
+      lcd_goto_screen(_lcd_z_offset_edit);
+      return ;
+    }
+
+
+  #endif // AUTO_BED_LEVELING_UBL
+
+
   /**
    * Watch temperature callbacks
    */
     void _lcd_level_bed_moving() {
       if (lcdDrawUpdate) {
         char msg[10];
-        sprintf_P(msg, PSTR("%i / %u"), (int)(manual_probe_index + 1), (MESH_NUM_X_POINTS) * (MESH_NUM_Y_POINTS));
+        #if ENABLED(MESH_BED_LEVELING)
+          sprintf_P(msg, PSTR("%i / %u"), (int)(manual_probe_index + 1), (MESH_NUM_X_POINTS) * (MESH_NUM_Y_POINTS));
+        #elif ENABLED(AUTO_BED_LEVELING_UBL)
+          sprintf_P(msg, PSTR("%i / %u"), (int)(manual_probe_index + 1), (UBL_MESH_NUM_X_POINTS) * (UBL_MESH_NUM_Y_POINTS));
+        #endif
         lcd_implementation_drawedit(PSTR(MSG_LEVEL_BED_NEXT_POINT), msg);
       }
 
 
     lcd_buttons_update();
 
+    #if ENABLED(AUTO_BED_LEVELING_UBL)
+      const bool UBL_CONDITION = !UBL_has_control_of_LCD_Panel;
+    #else
+      constexpr bool UBL_CONDITION = true;
+    #endif
+
     // If the action button is pressed...
-    if (LCD_CLICKED) {
+    if (UBL_CONDITION && LCD_CLICKED) {
       if (!wait_for_unclick) {           // If not waiting for a debounce release:
         wait_for_unclick = true;         //  Set debounce flag to ignore continous clicks
         lcd_clicked = !wait_for_user;    //  Keep the click if not waiting for a user-click
         case encrot2: ENCODER_SPIN(encrot1, encrot3); break;
         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
+          encoderDiff = 0;                  // We are going to lie to the LCD Panel and claim the encoder
+                                            // wheel has not turned.
+        }
+      #endif
+      lastEncoderBits = enc;
     }
-    lastEncoderBits = enc;
   }
 
   #if (ENABLED(LCD_I2C_TYPE_MCP23017) || ENABLED(LCD_I2C_TYPE_MCP23008)) && ENABLED(DETECT_DEVICE)
     bool lcd_detected() { return true; }
   #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);
+      #elif PIN_EXISTS(BEEPER)
+        buzzer.tone(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ);
+      #endif
+    }
+
+    bool G29_lcd_clicked() { return LCD_CLICKED; }
+
+  #endif
+
 #endif // ULTIPANEL
 
 #endif // ULTRA_LCD

Marlin/ultralcd_impl_DOGM.h

   lcd_printPGM(PSTR(MSG_PLEASE_RESET));
 }
 
-static void lcd_implementation_clear() { } // Automatically cleared by Picture Loop
+void lcd_implementation_clear() { } // Automatically cleared by Picture Loop
 
 //
 // Status Screen

Marlin/ultralcd_impl_HD44780.h

   lcd.clear();
 }
 
-static void lcd_implementation_clear() { lcd.clear(); }
+void lcd_implementation_clear() { lcd.clear(); }
 
 /* Arduino < 1.0.0 is missing a function to print PROGMEM strings, so we need to implement our own */
 void lcd_printPGM(const char *str) {