Adapt G26 to work for all meshes

.travis.yml

   # Test a probeless build of AUTO_BED_LEVELING_UBL
   #
   - restore_configs
-  - opt_enable AUTO_BED_LEVELING_UBL UBL_G26_MESH_EDITING ENABLE_LEVELING_FADE_HEIGHT EEPROM_SETTINGS G3D_PANEL
+  - opt_enable AUTO_BED_LEVELING_UBL G26_MESH_EDITING ENABLE_LEVELING_FADE_HEIGHT EEPROM_SETTINGS G3D_PANEL
   - opt_enable_adv CUSTOM_USER_MENUS I2C_POSITION_ENCODERS BABYSTEPPING
   - build_marlin_pio ${TRAVIS_BUILD_DIR} ${TEST_PLATFORM}
   #
   # Test MESH_BED_LEVELING feature, with LCD
   #
   - restore_configs
-  - opt_enable MESH_BED_LEVELING MESH_G28_REST_ORIGIN LCD_BED_LEVELING ULTIMAKERCONTROLLER
+  - opt_enable MESH_BED_LEVELING G26_MESH_EDITING MESH_G28_REST_ORIGIN LCD_BED_LEVELING ULTIMAKERCONTROLLER
   - build_marlin_pio ${TRAVIS_BUILD_DIR} ${TEST_PLATFORM}
   #
   # Test MINIRAMBO for PWM_MOTOR_CURRENT
   #
   - restore_configs
   - opt_set MOTHERBOARD BOARD_MINIRAMBO
-  - opt_enable PROBE_MANUALLY AUTO_BED_LEVELING_BILINEAR LCD_BED_LEVELING ULTIMAKERCONTROLLER
+  - opt_enable PROBE_MANUALLY AUTO_BED_LEVELING_BILINEAR G26_MESH_EDITING LCD_BED_LEVELING ULTIMAKERCONTROLLER
   - opt_enable EEPROM_SETTINGS EEPROM_CHITCHAT M100_FREE_MEMORY_WATCHER M100_FREE_MEMORY_DUMPER M100_FREE_MEMORY_CORRUPTOR INCH_MODE_SUPPORT TEMPERATURE_UNITS_SUPPORT
   - opt_enable ULTIMAKERCONTROLLER SDSUPPORT
   - opt_enable PRINTCOUNTER NOZZLE_PARK_FEATURE NOZZLE_CLEAN_FEATURE PCA9632 USE_XMAX_PLUG

Marlin/src/core/macros.h

 #define STRINGIFY(M) STRINGIFY_(M)
 
 // Macros for bit masks
+#ifndef _BV
+  #define _BV(B) (1UL<<(B))
+#endif
 #define TEST(n,b) (((n)&_BV(b))!=0)
 #define SBI(n,b) (n |= _BV(b))
 #define CBI(n,b) (n &= ~_BV(b))

Marlin/src/core/utility.h

 #ifndef __UTILITY_H__
 #define __UTILITY_H__
 
-#include "../inc/MarlinConfig.h"
+#include "../inc/MarlinConfigPre.h"
 
 constexpr char axis_codes[XYZE] = { 'X', 'Y', 'Z', 'E' };
 
   void crc16(uint16_t *crc, const void * const data, uint16_t cnt);
 #endif
 
+#if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(G26_MESH_VALIDATION)
+  /**
+   * These support functions allow the use of large bit arrays of flags that take very
+   * little RAM. Currently they are limited to being 16x16 in size. Changing the declaration
+   * to unsigned long will allow us to go to 32x32 if higher resolution Mesh's are needed
+   * in the future.
+   */
+  FORCE_INLINE void bit_clear(uint16_t bits[16], const uint8_t x, const uint8_t y)  { CBI(bits[y], x); }
+  FORCE_INLINE void bit_set(uint16_t bits[16], const uint8_t x, const uint8_t y)    { SBI(bits[y], x); }
+  FORCE_INLINE bool is_bit_set(uint16_t bits[16], const uint8_t x, const uint8_t y) { return TEST(bits[y], x); }
+#endif
+
 #if ENABLED(ULTRA_LCD)
 
   // Convert uint8_t to string with 123 format

Marlin/src/feature/bedlevel/bedlevel.cpp

   #endif
 #endif
 
+#if G26_MESH_VALIDATION
+  bool g26_debug_flag; // = false
+#endif
+
 bool leveling_is_valid() {
   return
     #if ENABLED(MESH_BED_LEVELING)

Marlin/src/feature/bedlevel/bedlevel.h

 #ifndef __BEDLEVEL_H__
 #define __BEDLEVEL_H__
 
-#include "../../inc/MarlinConfig.h"
+#include "../../inc/MarlinConfigPre.h"
 
-#if ENABLED(MESH_BED_LEVELING)
-  #include "mbl/mesh_bed_leveling.h"
-#elif ENABLED(AUTO_BED_LEVELING_UBL)
-  #include "ubl/ubl.h"
-#elif HAS_ABL
-  #include "abl/abl.h"
+typedef struct {
+  int8_t x_index, y_index;
+  float distance; // When populated, the distance from the search location
+} mesh_index_pair;
+
+#if ENABLED(G26_MESH_VALIDATION)
+  extern bool g26_debug_flag;
+#else
+  constexpr bool g26_debug_flag = false;
 #endif
 
 #if ENABLED(PROBE_MANUALLY)
   void out_of_range_error(const char* p_edge);
 #endif
 
+#if ENABLED(AUTO_BED_LEVELING_BILINEAR)
+  #define _GET_MESH_X(I) bilinear_start[X_AXIS] + I * bilinear_grid_spacing[X_AXIS]
+  #define _GET_MESH_Y(J) bilinear_start[Y_AXIS] + J * bilinear_grid_spacing[Y_AXIS]
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+  #define _GET_MESH_X(I) ubl.mesh_index_to_xpos(I)
+  #define _GET_MESH_Y(J) ubl.mesh_index_to_ypos(J)
+#elif ENABLED(MESH_BED_LEVELING)
+  #define _GET_MESH_X(I) mbl.index_to_xpos[I]
+  #define _GET_MESH_Y(J) mbl.index_to_ypos[J]
+#endif
+
+#if ENABLED(MESH_BED_LEVELING)
+  #include "mbl/mesh_bed_leveling.h"
+#elif ENABLED(AUTO_BED_LEVELING_UBL)
+  #include "ubl/ubl.h"
+#elif HAS_ABL
+  #include "abl/abl.h"
+#endif
+
 #endif // __BEDLEVEL_H__

Marlin/src/feature/bedlevel/ubl/ubl.cpp

 
   #include "math.h"
 
-  /**
-   * These support functions allow the use of large bit arrays of flags that take very
-   * little RAM. Currently they are limited to being 16x16 in size. Changing the declaration
-   * to unsigned long will allow us to go to 32x32 if higher resolution Mesh's are needed
-   * in the future.
-   */
-  void bit_clear(uint16_t bits[16], const uint8_t x, const uint8_t y) { CBI(bits[y], x); }
-  void bit_set(uint16_t bits[16], const uint8_t x, const uint8_t y) { SBI(bits[y], x); }
-  bool is_bit_set(uint16_t bits[16], const uint8_t x, const uint8_t y) { return TEST(bits[y], x); }
-
   uint8_t ubl_cnt = 0;
 
   void unified_bed_leveling::echo_name() { SERIAL_PROTOCOLPGM("Unified Bed Leveling"); }
   constexpr float unified_bed_leveling::_mesh_index_to_xpos[16],
                   unified_bed_leveling::_mesh_index_to_ypos[16];
 
-  bool unified_bed_leveling::g26_debug_flag = false,
-       unified_bed_leveling::has_control_of_lcd_panel = false;
-
   #if ENABLED(ULTRA_LCD)
     bool unified_bed_leveling::lcd_map_control = false;
   #endif

Marlin/src/feature/bedlevel/ubl/ubl.h

 #ifndef UNIFIED_BED_LEVELING_H
 #define UNIFIED_BED_LEVELING_H
 
-#include "../../../Marlin.h"
+#include "../bedlevel.h"
 #include "../../../module/planner.h"
 #include "../../../module/motion.h"
+#include "../../../Marlin.h"
 
 #define UBL_VERSION "1.01"
 #define UBL_OK false
 #define USE_NOZZLE_AS_REFERENCE 0
 #define USE_PROBE_AS_REFERENCE 1
 
-typedef struct {
-  int8_t x_index, y_index;
-  float distance; // When populated, the distance from the search location
-} mesh_index_pair;
-
-// ubl.cpp
-
-void bit_clear(uint16_t bits[16], const uint8_t x, const uint8_t y);
-void bit_set(uint16_t bits[16], const uint8_t x, const uint8_t y);
-bool is_bit_set(uint16_t bits[16], const uint8_t x, const uint8_t y);
-
 // ubl_motion.cpp
 
 void debug_current_and_destination(const char * const title);
 // External references
 
 char *ftostr43sign(const float&, char);
-bool ubl_lcd_clicked();
 
 extern uint8_t ubl_cnt;
 
       static int  g29_grid_size;
     #endif
 
-    #if ENABLED(UBL_G26_MESH_VALIDATION)
-      static float   g26_extrusion_multiplier,
-                     g26_retraction_multiplier,
-                     g26_nozzle,
-                     g26_filament_diameter,
-                     g26_prime_length,
-                     g26_x_pos, g26_y_pos,
-                     g26_ooze_amount,
-                     g26_layer_height;
-      static int16_t g26_bed_temp,
-                     g26_hotend_temp,
-                     g26_repeats;
-      static int8_t  g26_prime_flag;
-      static bool    g26_continue_with_closest, g26_keep_heaters_on;
-    #endif
-
     static float measure_point_with_encoder();
     static float measure_business_card_thickness(float);
     static bool g29_parameter_parsing();
     static bool smart_fill_one(const uint8_t x, const uint8_t y, const int8_t xdir, const int8_t ydir);
     static void smart_fill_mesh();
 
-    #if ENABLED(UBL_G26_MESH_VALIDATION)
-      static bool exit_from_g26();
-      static bool parse_G26_parameters();
-      static void G26_line_to_destination(const float &feed_rate);
-      static mesh_index_pair find_closest_circle_to_print(const float&, const float&);
-      static bool look_for_lines_to_connect();
-      static bool turn_on_heaters();
-      static bool prime_nozzle();
-      static void retract_filament(const float where[XYZE]);
-      static void recover_filament(const float where[XYZE]);
-      static void print_line_from_here_to_there(const float&, const float&, const float&, const float&, const float&, const float&);
-      static void move_to(const float&, const float&, const float&, const float&);
-      inline static void move_to(const float where[XYZE], const float &de) { move_to(where[X_AXIS], where[Y_AXIS], where[Z_AXIS], de); }
-    #endif
-
   public:
 
     static void echo_name();
     static void G29() _O0;                          // O0 for no optimization
     static void smart_fill_wlsf(const float &) _O2; // O2 gives smaller code than Os on A2560
 
-    #if ENABLED(UBL_G26_MESH_VALIDATION)
-      static void G26();
-    #endif
-
     static int8_t storage_slot;
 
     static float z_values[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y];
                               MESH_MIN_Y + 14 * (MESH_Y_DIST), MESH_MIN_Y + 15 * (MESH_Y_DIST)
                             };
 
-    static bool g26_debug_flag, has_control_of_lcd_panel;
-
     #if ENABLED(ULTRA_LCD)
       static bool lcd_map_control;
     #endif

Marlin/src/feature/bedlevel/ubl/ubl_G29.cpp

       lcd_reset_alert_level();
       LCD_MESSAGEPGM("");
       lcd_quick_feedback();
-
-      has_control_of_lcd_panel = false;
+      lcd_external_control = false;
     #endif
 
     return;
     void unified_bed_leveling::probe_entire_mesh(const float &rx, const float &ry, const bool do_ubl_mesh_map, const bool stow_probe, bool close_or_far) {
       mesh_index_pair location;
 
-      has_control_of_lcd_panel = true;
+      #if ENABLED(NEWPANEL)
+        lcd_external_control = true;
+      #endif
+
       save_ubl_active_state_and_disable();   // we don't do bed level correction because we want the raw data when we probe
       DEPLOY_PROBE();
 
         if (do_ubl_mesh_map) display_map(g29_map_type);
 
         #if ENABLED(NEWPANEL)
-          if (ubl_lcd_clicked()) {
+          if (is_lcd_clicked()) {
             SERIAL_PROTOCOLLNPGM("\nMesh only partially populated.\n");
             lcd_quick_feedback();
             STOW_PROBE();
-            while (ubl_lcd_clicked()) idle();
-            has_control_of_lcd_panel = false;
+            while (is_lcd_clicked()) idle();
+            lcd_external_control = false;
             restore_ubl_active_state_and_leave();
             safe_delay(50);  // Debounce the Encoder wheel
             return;
 
     float unified_bed_leveling::measure_point_with_encoder() {
 
-      while (ubl_lcd_clicked()) delay(50);  // wait for user to release encoder wheel
+      while (is_lcd_clicked()) delay(50);  // wait for user to release encoder wheel
       delay(50);  // debounce
 
       KEEPALIVE_STATE(PAUSED_FOR_USER);
-      while (!ubl_lcd_clicked()) {     // we need the loop to move the nozzle based on the encoder wheel here!
+      while (!is_lcd_clicked()) {     // we need the loop to move the nozzle based on the encoder wheel here!
         idle();
         if (encoder_diff) {
           do_blocking_move_to_z(current_position[Z_AXIS] + 0.01 * float(encoder_diff));
     static void echo_and_take_a_measurement() { SERIAL_PROTOCOLLNPGM(" and take a measurement."); }
 
     float unified_bed_leveling::measure_business_card_thickness(const float in_height) {
-      has_control_of_lcd_panel = true;
+      lcd_external_control = true;
       save_ubl_active_state_and_disable();   // Disable bed level correction for probing
 
       do_blocking_move_to(0.5 * (MESH_MAX_X - (MESH_MIN_X)), 0.5 * (MESH_MAX_Y - (MESH_MIN_Y)), in_height);
         SERIAL_PROTOCOLLNPGM("mm thick.");
       }
 
-      has_control_of_lcd_panel = false;
+      lcd_external_control = false;
 
       restore_ubl_active_state_and_leave();
 
 
     void unified_bed_leveling::manually_probe_remaining_mesh(const float &rx, const float &ry, const float &z_clearance, const float &thick, const bool do_ubl_mesh_map) {
 
-      has_control_of_lcd_panel = true;
+      lcd_external_control = true;
 
       save_ubl_active_state_and_disable();   // we don't do bed level correction because we want the raw data when we probe
 
         do_blocking_move_to_z(z_clearance);
 
         KEEPALIVE_STATE(PAUSED_FOR_USER);
-        has_control_of_lcd_panel = true;
+        lcd_external_control = true;
 
         if (do_ubl_mesh_map) display_map(g29_map_type);  // show user where we're probing
 
         const float z_step = 0.01;                                        // existing behavior: 0.01mm per click, occasionally step
         //const float z_step = 1.0 / planner.axis_steps_per_mm[Z_AXIS];   // approx one step each click
 
-        while (ubl_lcd_clicked()) delay(50);             // wait for user to release encoder wheel
+        while (is_lcd_clicked()) delay(50);             // wait for user to release encoder wheel
         delay(50);                                       // debounce
-        while (!ubl_lcd_clicked()) {                     // we need the loop to move the nozzle based on the encoder wheel here!
+        while (!is_lcd_clicked()) {                     // we need the loop to move the nozzle based on the encoder wheel here!
           idle();
           if (encoder_diff) {
             do_blocking_move_to_z(current_position[Z_AXIS] + float(encoder_diff) * z_step);
           }
         }
 
-        // this sequence to detect an ubl_lcd_clicked() debounce it and leave if it is
+        // this sequence to detect an is_lcd_clicked() debounce it and leave if it is
         // a Press and Hold is repeated in a lot of places (including G26_Mesh_Validation.cpp).   This
         // should be redone and compressed.
         const millis_t nxt = millis() + 1500L;
-        while (ubl_lcd_clicked()) {     // debounce and watch for abort
+        while (is_lcd_clicked()) {     // debounce and watch for abort
           idle();
           if (ELAPSED(millis(), nxt)) {
             SERIAL_PROTOCOLLNPGM("\nMesh only partially populated.");
 
             #if ENABLED(NEWPANEL)
               lcd_quick_feedback();
-              while (ubl_lcd_clicked()) idle();
-              has_control_of_lcd_panel = false;
+              while (is_lcd_clicked()) idle();
+              lcd_external_control = false;
             #endif
 
             KEEPALIVE_STATE(IN_HANDLER);
         new_z = FLOOR(new_z * 1000.0) * 0.001; // Chop off digits after the 1000ths place
 
         KEEPALIVE_STATE(PAUSED_FOR_USER);
-        has_control_of_lcd_panel = true;
+        lcd_external_control = true;
 
         if (do_ubl_mesh_map) display_map(g29_map_type);  // show the user which point is being adjusted
 
             do_blocking_move_to_z(h_offset + new_z); // Move the nozzle as the point is edited
           #endif
           idle();
-        } while (!ubl_lcd_clicked());
+        } while (!is_lcd_clicked());
 
         if (!lcd_map_control) lcd_return_to_status();
 
         // The technique used here generates a race condition for the encoder click.
         // It could get detected in lcd_mesh_edit (actually _lcd_mesh_fine_tune) or here.
         // Let's work on specifying a proper API for the LCD ASAP, OK?
-        has_control_of_lcd_panel = true;
+        lcd_external_control = true;
 
-        // this sequence to detect an ubl_lcd_clicked() debounce it and leave if it is
+        // this sequence to detect an is_lcd_clicked() debounce it and leave if it is
         // a Press and Hold is repeated in a lot of places (including G26_Mesh_Validation.cpp).   This
         // should be redone and compressed.
         const millis_t nxt = millis() + 1500UL;
-        while (ubl_lcd_clicked()) { // debounce and watch for abort
+        while (is_lcd_clicked()) { // debounce and watch for abort
           idle();
           if (ELAPSED(millis(), nxt)) {
             lcd_return_to_status();
             do_blocking_move_to_z(Z_CLEARANCE_BETWEEN_PROBES);
             LCD_MESSAGEPGM(MSG_EDITING_STOPPED);
 
-            while (ubl_lcd_clicked()) idle();
+            while (is_lcd_clicked()) idle();
 
             goto FINE_TUNE_EXIT;
           }
 
       FINE_TUNE_EXIT:
 
-      has_control_of_lcd_panel = false;
+      lcd_external_control = false;
       KEEPALIVE_STATE(IN_HANDLER);
 
       if (do_ubl_mesh_map) display_map(g29_map_type);

Marlin/src/feature/bedlevel/ubl/ubl_motion.cpp

 
 #if ENABLED(AUTO_BED_LEVELING_UBL)
 
-  #include "ubl.h"
-
-  #include "../../../Marlin.h"
+  #include "../bedlevel.h"
   #include "../../../module/planner.h"
   #include "../../../module/stepper.h"
   #include "../../../module/motion.h"
     #include "../../../module/delta.h"
   #endif
 
+  #include "../../../Marlin.h"
   #include <math.h>
 
   extern float destination[XYZE];
 
     // if the title message starts with a '!' it is so important, we are going to
     // ignore the status of the g26_debug_flag
-    if (*title != '!' && !ubl.g26_debug_flag) return;
+    if (*title != '!' && !g26_debug_flag) return;
 
     const float de = destination[E_AXIS] - current_position[E_AXIS];
 

Marlin/src/gcode/bedlevel/G42.cpp

       return;
     }
 
-    #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
-      #define _GET_MESH_X(I) bilinear_start[X_AXIS] + I * bilinear_grid_spacing[X_AXIS]
-      #define _GET_MESH_Y(J) bilinear_start[Y_AXIS] + J * bilinear_grid_spacing[Y_AXIS]
-    #elif ENABLED(AUTO_BED_LEVELING_UBL)
-      #define _GET_MESH_X(I) ubl.mesh_index_to_xpos(I)
-      #define _GET_MESH_Y(J) ubl.mesh_index_to_ypos(J)
-    #elif ENABLED(MESH_BED_LEVELING)
-      #define _GET_MESH_X(I) mbl.index_to_xpos[I]
-      #define _GET_MESH_Y(J) mbl.index_to_ypos[J]
-    #endif
-
     set_destination_from_current();
     if (hasI) destination[X_AXIS] = _GET_MESH_X(ix);
     if (hasJ) destination[Y_AXIS] = _GET_MESH_Y(iy);

Marlin/src/gcode/bedlevel/ubl/G26.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/>.
- *
- */
-
-/**
- * G26.cpp - Unified Bed Leveling
- */
-
-#include "../../../inc/MarlinConfig.h"
-
-#if ENABLED(UBL_G26_MESH_VALIDATION)
-
-#include "../../gcode.h"
-#include "../../../feature/bedlevel/ubl/ubl.h"
-
-void GcodeSuite::G26() { ubl.G26(); }
-
-#endif // UBL_G26_MESH_VALIDATION

Marlin/src/gcode/bedlevel/ubl/M421.cpp

 #if ENABLED(AUTO_BED_LEVELING_UBL)
 
 #include "../../gcode.h"
-#include "../../../feature/bedlevel/ubl/ubl.h"
+#include "../../../feature/bedlevel/bedlevel.h"
 
 /**
  * M421: Set a single Mesh Bed Leveling Z coordinate

Marlin/src/gcode/bedlevel/ubl/M49.cpp

  */
 
 /**
- * M49.cpp - Unified Bed Leveling
+ * M49.cpp - Toggle the G26 debug flag
  */
 
 #include "../../../inc/MarlinConfig.h"
 
-#if ENABLED(UBL_G26_MESH_VALIDATION)
+#if ENABLED(G26_MESH_VALIDATION)
 
 #include "../../gcode.h"
 #include "../../../feature/bedlevel/bedlevel.h"
 
 void GcodeSuite::M49() {
-  ubl.g26_debug_flag ^= true;
-  SERIAL_PROTOCOLPGM("UBL Debug Flag turned ");
-  serialprintPGM(ubl.g26_debug_flag ? PSTR("on.") : PSTR("off."));
+  g26_debug_flag ^= true;
+  SERIAL_PROTOCOLPGM("G26 Debug ");
+  serialprintPGM(g26_debug_flag ? PSTR("on.") : PSTR("off."));
 }
 
-#endif // UBL_G26_MESH_VALIDATION
+#endif // G26_MESH_VALIDATION

Marlin/src/gcode/gcode.cpp

           break;
       #endif // INCH_MODE_SUPPORT
 
-      #if ENABLED(UBL_G26_MESH_VALIDATION)
+      #if ENABLED(G26_MESH_VALIDATION)
         case 26: // G26: Mesh Validation Pattern generation
           G26();
           break;
         case 48: M48(); break;    // M48: Z probe repeatability test
       #endif
 
-      #if ENABLED(UBL_G26_MESH_VALIDATION)
+      #if ENABLED(G26_MESH_VALIDATION)
         case 49: M49(); break;    // M49: Turn on or off G26 debug flag for verbose output
       #endif
 

Marlin/src/gcode/gcode.h

  * G19  - Select Plane YZ (Requires CNC_WORKSPACE_PLANES)
  * G20  - Set input units to inches (Requires INCH_MODE_SUPPORT)
  * G21  - Set input units to millimeters (Requires INCH_MODE_SUPPORT)
- * G26  - Mesh Validation Pattern (Requires UBL_G26_MESH_VALIDATION)
+ * G26  - Mesh Validation Pattern (Requires G26_MESH_VALIDATION)
  * G27  - Park Nozzle (Requires NOZZLE_PARK_FEATURE)
  * G28  - Home one or more axes
  * G29  - Start or continue the bed leveling probe procedure (Requires bed leveling)
     static void G21();
   #endif
 
-  #if ENABLED(UBL_G26_MESH_VALIDATION)
+  #if ENABLED(G26_MESH_VALIDATION)
     static void G26();
   #endif
 
     static void M48();
   #endif
 
-  #if ENABLED(UBL_G26_MESH_VALIDATION)
+  #if ENABLED(G26_MESH_VALIDATION)
     static void M49();
   #endif
 

Marlin/src/inc/MarlinConfig.h

  *
  */
 
-#ifndef MARLIN_CONFIG_H
-#define MARLIN_CONFIG_H
+#ifndef _MARLIN_CONFIG_H_
+#define _MARLIN_CONFIG_H_
 
 #include "MarlinConfigPre.h"
 
 // Include all core headers
 #include "../core/enum.h"
 #include "../core/language.h"
-#include "../core/types.h"
 #include "../core/utility.h"
 #include "../core/serial.h"
 
-#endif // MARLIN_CONFIG_H
+#endif // _MARLIN_CONFIG_H_

Marlin/src/inc/MarlinConfigPre.h

  *
  */
 
-#ifndef MARLIN_CONFIGPRE_H
-#define MARLIN_CONFIGPRE_H
+#ifndef _MARLIN_CONFIGPRE_H_
+#define _MARLIN_CONFIGPRE_H_
 
 #include "../core/boards.h"
 #include "../core/macros.h"
 #include "../../Configuration_adv.h"
 #include "Conditionals_adv.h"
 
-#endif // MARLIN_CONFIGPRE_H
+#include "../core/types.h"
+
+#endif // _MARLIN_CONFIGPRE_H_

Marlin/src/lcd/ultralcd.cpp

   #include "../libs/buzzer.h"
 #endif
 
+#if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(G26_MESH_VALIDATION)
+  bool lcd_external_control; // = false
+#endif
+
 // Initialized by settings.load()
 int16_t lcd_preheat_hotend_temp[2], lcd_preheat_bed_temp[2], lcd_preheat_fan_speed[2];
 
 
     #if ENABLED(AUTO_BED_LEVELING_UBL)
       // Don't run the debouncer if UBL owns the display
-      #define UBL_CONDITION !ubl.has_control_of_lcd_panel
+      #define UBL_CONDITION !lcd_external_control
     #else
       #define UBL_CONDITION true
     #endif
         case encrot3: ENCODER_SPIN(encrot2, encrot0); break;
       }
       #if ENABLED(AUTO_BED_LEVELING_UBL)
-        if (ubl.has_control_of_lcd_panel) {
+        if (lcd_external_control) {
           ubl.encoder_diff = 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
                                             // knob has not turned.
     bool lcd_detected() { return true; }
   #endif
 
-  #if ENABLED(AUTO_BED_LEVELING_UBL)
-
-    void chirp_at_user() {
+  #if ENABLED(G26_MESH_VALIDATION)
+    void lcd_chirp() {
       lcd_buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ);
     }
+  #endif
 
-    bool ubl_lcd_clicked() { return LCD_CLICKED; }
-
+  #if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(G26_MESH_VALIDATION)
+    bool is_lcd_clicked() { return LCD_CLICKED; }
   #endif
 
 #endif // ULTIPANEL

Marlin/src/lcd/ultralcd.h

 
   #include "../Marlin.h"
 
+  #if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(G26_MESH_VALIDATION)
+    extern bool lcd_external_control;
+  #else
+    constexpr bool lcd_external_control = false;
+  #endif
+
   #define BUTTON_EXISTS(BN) (defined(BTN_## BN) && BTN_## BN >= 0)
   #define BUTTON_PRESSED(BN) !READ(BTN_## BN)
 
       void lcd_advanced_pause_show_message(const AdvancedPauseMessage message);
     #endif
 
+    #if ENABLED(G26_MESH_VALIDATION)
+      void lcd_chirp();
+    #endif
+
     #if ENABLED(AUTO_BED_LEVELING_UBL)
       void lcd_mesh_edit_setup(float initial);
       float lcd_mesh_edit();
     #define LCD_CLICKED false
   #endif
 
+  #if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(G26_MESH_VALIDATION)
+    bool is_lcd_clicked();
+  #endif
+
 #else // no LCD
 
   inline void lcd_update() {}