Group UBL parameters, add comments

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

   typedef int16_t mesh_store_t[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y];
 #endif
 
+typedef struct {
+  bool      C_seen;
+  int8_t    V_verbosity,
+            P_phase,
+            R_repetition,
+            KLS_storage_slot,
+            T_map_type;
+  float     B_shim_thickness,
+            C_constant;
+  xy_pos_t  XY_pos;
+  xy_bool_t XY_seen;
+  #if HAS_BED_PROBE
+    int     grid_size;
+  #endif
+} G29_parameters_t;
+
 class unified_bed_leveling {
 private:
 
-  static int    g29_verbose_level,
-                g29_phase_value,
-                g29_repetition_cnt,
-                g29_storage_slot,
-                g29_map_type;
-  static bool   g29_c_flag;
-  static float  g29_card_thickness,
-                g29_constant;
-  static xy_pos_t g29_pos;
-  static xy_bool_t xy_seen;
-
-  #if HAS_BED_PROBE
-    static int  g29_grid_size;
-  #endif
+  static G29_parameters_t param;
 
   #if IS_NEWPANEL
     static void move_z_with_encoder(const float &multiplier);
     static void fine_tune_mesh(const xy_pos_t &pos, const bool do_ubl_mesh_map) _O0;
   #endif
 
-  static bool g29_parameter_parsing() _O0;
+  static bool G29_parse_parameters() _O0;
   static void shift_mesh_height();
   static void probe_entire_mesh(const xy_pos_t &near, const bool do_ubl_mesh_map, const bool stow_probe, const bool do_furthest) _O0;
   static void tilt_mesh_based_on_3pts(const float &z1, const float &z2, const float &z3);
     static inline void steppers_were_disabled() {}
   #endif
 
-  static volatile int16_t encoder_diff; // Volatile because buttons may changed it at interrupt time
+  static volatile int16_t encoder_diff; // Volatile because buttons may change it at interrupt time
 
   unified_bed_leveling();
 

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

 #define SIZE_OF_LITTLE_RAISE 1
 #define BIG_RAISE_NOT_NEEDED 0
 
-int    unified_bed_leveling::g29_verbose_level,
-       unified_bed_leveling::g29_phase_value,
-       unified_bed_leveling::g29_repetition_cnt,
-       unified_bed_leveling::g29_storage_slot = 0,
-       unified_bed_leveling::g29_map_type;
-bool   unified_bed_leveling::g29_c_flag;
-float  unified_bed_leveling::g29_card_thickness = 0,
-       unified_bed_leveling::g29_constant = 0;
-xy_bool_t unified_bed_leveling::xy_seen;
-xy_pos_t unified_bed_leveling::g29_pos;
-
-#if HAS_BED_PROBE
-  int  unified_bed_leveling::g29_grid_size;
-#endif
-
 /**
  *   G29: Unified Bed Leveling by Roxy
  *
  *   features of all three systems combined.
  */
 
+G29_parameters_t unified_bed_leveling::param;
+
 void unified_bed_leveling::G29() {
 
   bool probe_deployed = false;
-  if (g29_parameter_parsing()) return; // Abort on parameter error
+  if (G29_parse_parameters()) return; // Abort on parameter error
 
   const int8_t p_val = parser.intval('P', -1);
   const bool may_move = p_val == 1 || p_val == 2 || p_val == 4 || parser.seen('J');
     TERN_(HAS_MULTI_HOTEND, if (active_extruder) tool_change(0));
   }
 
-  // Invalidate Mesh Points. This command is a little bit asymmetrical because
-  // it directly specifies the repetition count and does not use the 'R' parameter.
+  // Invalidate one or more nearby mesh points, possibly all.
   if (parser.seen('I')) {
-    uint8_t cnt = 0;
-    g29_repetition_cnt = parser.has_value() ? parser.value_int() : 1;
-    if (g29_repetition_cnt >= GRID_MAX_POINTS) {
-      set_all_mesh_points_to_value(NAN);
-    }
-    else {
-      while (g29_repetition_cnt--) {
-        if (cnt > 20) { cnt = 0; idle(); }
-        const mesh_index_pair closest = find_closest_mesh_point_of_type(REAL, g29_pos);
-        const xy_int8_t &cpos = closest.pos;
-        if (cpos.x < 0) {
-          // No more REAL mesh points to invalidate, so we ASSUME the user
-          // meant to invalidate the ENTIRE mesh, which cannot be done with
-          // find_closest_mesh_point loop which only returns REAL points.
-          set_all_mesh_points_to_value(NAN);
-          SERIAL_ECHOLNPGM("Entire Mesh invalidated.\n");
-          break;            // No more invalid Mesh Points to populate
-        }
-        z_values[cpos.x][cpos.y] = NAN;
-        TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(cpos, 0.0f));
-        cnt++;
+    int16_t count = parser.has_value() ? parser.value_int() : 1;
+    bool invalidate_all = count >= GRID_MAX_POINTS;
+    if (!invalidate_all) {
+      while (count--) {
+        if ((count & 0x0F) == 0x0F) idle();
+        const mesh_index_pair closest = find_closest_mesh_point_of_type(REAL, param.XY_pos);
+        // No more REAL mesh points to invalidate? Assume the user meant
+        // to invalidate the ENTIRE mesh, which can't be done with
+        // find_closest_mesh_point (which only returns REAL points).
+        if (closest.pos.x < 0) { invalidate_all = true; break; }
+        z_values[closest.pos.x][closest.pos.y] = NAN;
+        TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(closest.pos, 0.0f));
       }
     }
-    SERIAL_ECHOLNPGM("Locations invalidated.\n");
+    if (invalidate_all) {
+      invalidate();
+      SERIAL_ECHOPGM("Entire Mesh");
+    }
+    else
+      SERIAL_ECHOPGM("Locations");
+    SERIAL_ECHOLNPGM(" invalidated.\n");
   }
 
   if (parser.seen('Q')) {
     SERIAL_ECHOLNPGM("Loading test_pattern values.\n");
     switch (test_pattern) {
 
-      #if ENABLED(UBL_DEVEL_DEBUGGING)
-        case -1:
-          g29_eeprom_dump();
-          break;
-      #endif
+      case -1: TERN_(UBL_DEVEL_DEBUGGING, g29_eeprom_dump()); break;
 
       case 0:
         GRID_LOOP(x, y) {                                     // Create a bowl shape similar to a poorly-calibrated Delta
         // Allow the user to specify the height because 10mm is a little extreme in some cases.
         for (uint8_t x = (GRID_MAX_POINTS_X) / 3; x < 2 * (GRID_MAX_POINTS_X) / 3; x++)     // Create a rectangular raised area in
           for (uint8_t y = (GRID_MAX_POINTS_Y) / 3; y < 2 * (GRID_MAX_POINTS_Y) / 3; y++) { // the center of the bed
-            z_values[x][y] += parser.seen('C') ? g29_constant : 9.99f;
+            z_values[x][y] += parser.seen('C') ? param.C_constant : 9.99f;
             TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(x, y, z_values[x][y]));
           }
         break;
 
     if (parser.seen('J')) {
       save_ubl_active_state_and_disable();
-      tilt_mesh_based_on_probed_grid(g29_grid_size == 0); // Zero size does 3-Point
+      tilt_mesh_based_on_probed_grid(param.grid_size == 0); // Zero size does 3-Point
       restore_ubl_active_state_and_leave();
       #if ENABLED(UBL_G29_J_RECENTER)
         do_blocking_move_to_xy(0.5f * ((MESH_MIN_X) + (MESH_MAX_X)), 0.5f * ((MESH_MIN_Y) + (MESH_MAX_Y)));
   #endif // HAS_BED_PROBE
 
   if (parser.seen('P')) {
-    if (WITHIN(g29_phase_value, 0, 1) && storage_slot == -1) {
+    if (WITHIN(param.P_phase, 0, 1) && storage_slot == -1) {
       storage_slot = 0;
       SERIAL_ECHOLNPGM("Default storage slot 0 selected.");
     }
 
-    switch (g29_phase_value) {
+    switch (param.P_phase) {
       case 0:
         //
         // Zero Mesh Data
             invalidate();
             SERIAL_ECHOLNPGM("Mesh invalidated. Probing mesh.");
           }
-          if (g29_verbose_level > 1) {
-            SERIAL_ECHOPAIR("Probing around (", g29_pos.x);
+          if (param.V_verbosity > 1) {
+            SERIAL_ECHOPAIR("Probing around (", param.XY_pos.x);
             SERIAL_CHAR(',');
-            SERIAL_DECIMAL(g29_pos.y);
+            SERIAL_DECIMAL(param.XY_pos.y);
             SERIAL_ECHOLNPGM(").\n");
           }
-          const xy_pos_t near_probe_xy = g29_pos + probe.offset_xy;
+          const xy_pos_t near_probe_xy = param.XY_pos + probe.offset_xy;
           probe_entire_mesh(near_probe_xy, parser.seen('T'), parser.seen('E'), parser.seen('U'));
 
           report_current_position();
           SERIAL_ECHOLNPGM("Manually probing unreachable points.");
           do_z_clearance(Z_CLEARANCE_BETWEEN_PROBES);
 
-          if (parser.seen('C') && !xy_seen) {
+          if (parser.seen('C') && !param.XY_seen) {
 
             /**
              * Use a good default location for the path.
              * It may make sense to have Delta printers default to the center of the bed.
              * Until that is decided, this can be forced with the X and Y parameters.
              */
-            g29_pos.set(
+            param.XY_pos.set(
               #if IS_KINEMATIC
                 X_HOME_POS, Y_HOME_POS
               #else
           }
 
           if (parser.seen('B')) {
-            g29_card_thickness = parser.has_value() ? parser.value_float() : measure_business_card_thickness();
-            if (ABS(g29_card_thickness) > 1.5f) {
+            param.B_shim_thickness = parser.has_value() ? parser.value_float() : measure_business_card_thickness();
+            if (ABS(param.B_shim_thickness) > 1.5f) {
               SERIAL_ECHOLNPGM("?Error in Business Card measurement.");
               return;
             }
             probe_deployed = true;
           }
 
-          if (!position_is_reachable(g29_pos)) {
+          if (!position_is_reachable(param.XY_pos)) {
             SERIAL_ECHOLNPGM("XY outside printable radius.");
             return;
           }
 
           const float height = parser.floatval('H', Z_CLEARANCE_BETWEEN_PROBES);
-          manually_probe_remaining_mesh(g29_pos, height, g29_card_thickness, parser.seen('T'));
+          manually_probe_remaining_mesh(param.XY_pos, height, param.B_shim_thickness, parser.seen('T'));
 
           SERIAL_ECHOLNPGM("G29 P2 finished.");
 
          *   - Allow 'G29 P3' to choose a 'reasonable' constant.
          */
 
-        if (g29_c_flag) {
-          if (g29_repetition_cnt >= GRID_MAX_POINTS) {
-            set_all_mesh_points_to_value(g29_constant);
+        if (param.C_seen) {
+          if (param.R_repetition >= GRID_MAX_POINTS) {
+            set_all_mesh_points_to_value(param.C_constant);
           }
           else {
-            while (g29_repetition_cnt--) {  // this only populates reachable mesh points near
-              const mesh_index_pair closest = find_closest_mesh_point_of_type(INVALID, g29_pos);
+            while (param.R_repetition--) {  // this only populates reachable mesh points near
+              const mesh_index_pair closest = find_closest_mesh_point_of_type(INVALID, param.XY_pos);
               const xy_int8_t &cpos = closest.pos;
               if (cpos.x < 0) {
                 // No more REAL INVALID mesh points to populate, so we ASSUME
                 // user meant to populate ALL INVALID mesh points to value
-                GRID_LOOP(x, y) if (isnan(z_values[x][y])) z_values[x][y] = g29_constant;
+                GRID_LOOP(x, y) if (isnan(z_values[x][y])) z_values[x][y] = param.C_constant;
                 break; // No more invalid Mesh Points to populate
               }
               else {
-                z_values[cpos.x][cpos.y] = g29_constant;
-                TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(cpos, g29_constant));
+                z_values[cpos.x][cpos.y] = param.C_constant;
+                TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(cpos, param.C_constant));
               }
             }
           }
 
       case 4: // Fine Tune (i.e., Edit) the Mesh
         #if HAS_LCD_MENU
-          fine_tune_mesh(g29_pos, parser.seen('T'));
+          fine_tune_mesh(param.XY_pos, parser.seen('T'));
         #else
           SERIAL_ECHOLNPGM("?P4 is only available when an LCD is present.");
           return;
         #endif
         break;
 
-      case 5: adjust_mesh_to_mean(g29_c_flag, g29_constant); break;
+      case 5: adjust_mesh_to_mean(param.C_seen, param.C_constant); break;
 
       case 6: shift_mesh_height(); break;
     }
   //
 
   if (parser.seen('L')) {     // Load Current Mesh Data
-    g29_storage_slot = parser.has_value() ? parser.value_int() : storage_slot;
+    param.KLS_storage_slot = parser.has_value() ? parser.value_int() : storage_slot;
 
     int16_t a = settings.calc_num_meshes();
 
       return;
     }
 
-    if (!WITHIN(g29_storage_slot, 0, a - 1)) {
+    if (!WITHIN(param.KLS_storage_slot, 0, a - 1)) {
       SERIAL_ECHOLNPAIR("?Invalid storage slot.\n?Use 0 to ", a - 1);
       return;
     }
 
-    settings.load_mesh(g29_storage_slot);
-    storage_slot = g29_storage_slot;
+    settings.load_mesh(param.KLS_storage_slot);
+    storage_slot = param.KLS_storage_slot;
 
     SERIAL_ECHOLNPGM("Done.");
   }
   //
 
   if (parser.seen('S')) {     // Store (or Save) Current Mesh Data
-    g29_storage_slot = parser.has_value() ? parser.value_int() : storage_slot;
+    param.KLS_storage_slot = parser.has_value() ? parser.value_int() : storage_slot;
 
-    if (g29_storage_slot == -1)                     // Special case, the user wants to 'Export' the mesh to the
+    if (param.KLS_storage_slot == -1)                     // Special case, the user wants to 'Export' the mesh to the
       return report_current_mesh();                 // host program to be saved on the user's computer
 
     int16_t a = settings.calc_num_meshes();
       goto LEAVE;
     }
 
-    if (!WITHIN(g29_storage_slot, 0, a - 1)) {
+    if (!WITHIN(param.KLS_storage_slot, 0, a - 1)) {
       SERIAL_ECHOLNPAIR("?Invalid storage slot.\n?Use 0 to ", a - 1);
       goto LEAVE;
     }
 
-    settings.store_mesh(g29_storage_slot);
-    storage_slot = g29_storage_slot;
+    settings.store_mesh(param.KLS_storage_slot);
+    storage_slot = param.KLS_storage_slot;
 
     SERIAL_ECHOLNPGM("Done.");
   }
 
   if (parser.seen('T'))
-    display_map(g29_map_type);
+    display_map(param.T_map_type);
 
   LEAVE:
 
   return;
 }
 
-void unified_bed_leveling::adjust_mesh_to_mean(const bool cflag, const float value) {
+/**
+ * M420 C<value>
+ * G29 P5 C<value> : Adjust Mesh To Mean (and subtract the given offset).
+ *                   Find the mean average and shift the mesh to center on that value.
+ */
+void unified_bed_leveling::adjust_mesh_to_mean(const bool cflag, const float offset) {
   float sum = 0;
   int n = 0;
   GRID_LOOP(x, y)
   if (cflag)
     GRID_LOOP(x, y)
       if (!isnan(z_values[x][y])) {
-        z_values[x][y] -= mean + value;
+        z_values[x][y] -= mean + offset;
         TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(x, y, z_values[x][y]));
       }
 }
 
+/**
+ * G29 P6 C<offset> : Shift Mesh Height by a uniform constant.
+ */
 void unified_bed_leveling::shift_mesh_height() {
   GRID_LOOP(x, y)
     if (!isnan(z_values[x][y])) {
-      z_values[x][y] += g29_constant;
+      z_values[x][y] += param.C_constant;
       TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(x, y, z_values[x][y]));
     }
 }
 
 #if HAS_BED_PROBE
   /**
-   * Probe all invalidated locations of the mesh that can be reached by the probe.
-   * This attempts to fill in locations closest to the nozzle's start location first.
+   * G29 P1 T<maptype> V<verbosity> : Probe Entire Mesh
+   *   Probe all invalidated locations of the mesh that can be reached by the probe.
+   *   This attempts to fill in locations closest to the nozzle's start location first.
    */
   void unified_bed_leveling::probe_entire_mesh(const xy_pos_t &nearby, const bool do_ubl_mesh_map, const bool stow_probe, const bool do_furthest) {
     probe.deploy(); // Deploy before ui.capture() to allow for PAUSE_BEFORE_DEPLOY_STOW
     mesh_index_pair best;
     TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(best.pos, ExtUI::MESH_START));
     do {
-      if (do_ubl_mesh_map) display_map(g29_map_type);
+      if (do_ubl_mesh_map) display_map(param.T_map_type);
 
       const int point_num = (GRID_MAX_POINTS) - count + 1;
       SERIAL_ECHOLNPAIR("Probing mesh point ", point_num, "/", GRID_MAX_POINTS, ".");
         TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(best.pos, ExtUI::PROBE_START));
         const float measured_z = probe.probe_at_point(
                       best.meshpos(),
-                      stow_probe ? PROBE_PT_STOW : PROBE_PT_RAISE, g29_verbose_level
+                      stow_probe ? PROBE_PT_STOW : PROBE_PT_RAISE, param.V_verbosity
                     );
         z_values[best.pos.x][best.pos.y] = measured_z;
         #if ENABLED(EXTENSIBLE_UI)
 
 #endif // HAS_BED_PROBE
 
+void set_message_with_feedback(PGM_P const msg_P) {
+  #if HAS_LCD_MENU
+    ui.set_status_P(msg_P);
+    ui.quick_feedback();
+  #else
+    UNUSED(msg_P);
+  #endif
+}
+
 #if HAS_LCD_MENU
 
   typedef void (*clickFunc_t)();
 
-  bool click_and_hold(const clickFunc_t func=nullptr) {
+  bool _click_and_hold(const clickFunc_t func=nullptr) {
     if (ui.button_pressed()) {
       ui.quick_feedback(false);         // Preserve button state for click-and-hold
       const millis_t nxt = millis() + 1500UL;
 
   float unified_bed_leveling::measure_point_with_encoder() {
     KEEPALIVE_STATE(PAUSED_FOR_USER);
-    move_z_with_encoder(0.01f);
+    const float z_step = 0.01f;
+    move_z_with_encoder(z_step);
     return current_position.z;
   }
 
 
     const float thickness = ABS(z1 - z2);
 
-    if (g29_verbose_level > 1) {
+    if (param.V_verbosity > 1) {
       SERIAL_ECHOPAIR_F("Business Card is ", thickness, 4);
       SERIAL_ECHOLNPGM("mm thick.");
     }
     return thickness;
   }
 
+  /**
+   * G29 P2 : Manually Probe Remaining Mesh Points.
+   *          Move to INVALID points and
+   *          NOTE: Blocks the G-code queue and captures Marlin UI during use.
+   */
   void unified_bed_leveling::manually_probe_remaining_mesh(const xy_pos_t &pos, const float &z_clearance, const float &thick, const bool do_ubl_mesh_map) {
     ui.capture();
 
       KEEPALIVE_STATE(PAUSED_FOR_USER);
       ui.capture();
 
-      if (do_ubl_mesh_map) display_map(g29_map_type);  // show user where we're probing
+      if (do_ubl_mesh_map) display_map(param.T_map_type);   // Show user where we're probing
 
       if (parser.seen('B')) {
         SERIAL_ECHOPGM_P(GET_TEXT(MSG_UBL_BC_INSERT));
         LCD_MESSAGEPGM(MSG_UBL_BC_INSERT2);
       }
 
-      const float z_step = 0.01f;                         // existing behavior: 0.01mm per click, occasionally step
-      //const float z_step = planner.steps_to_mm[Z_AXIS]; // approx one step each click
-
+      const float z_step = 0.01f;                         // 0.01mm per encoder tick, occasionally step
       move_z_with_encoder(z_step);
 
-      if (click_and_hold()) {
+      if (_click_and_hold([]{
         SERIAL_ECHOLNPGM("\nMesh only partially populated.");
         do_z_clearance(Z_CLEARANCE_DEPLOY_PROBE);
-        return restore_ubl_active_state_and_leave();
-      }
+      })) return restore_ubl_active_state_and_leave();
 
+      // Store the Z position minus the shim height
       z_values[lpos.x][lpos.y] = current_position.z - thick;
+
+      // Tell the external UI to update
       TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(location, z_values[lpos.x][lpos.y]));
 
-      if (g29_verbose_level > 2)
+      if (param.V_verbosity > 2)
         SERIAL_ECHOLNPAIR_F("Mesh Point Measured at: ", z_values[lpos.x][lpos.y], 6);
       SERIAL_FLUSH(); // Prevent host M105 buffer overrun.
     } while (location.valid());
 
-    if (do_ubl_mesh_map) display_map(g29_map_type);  // show user where we're probing
+    if (do_ubl_mesh_map) display_map(param.T_map_type);  // show user where we're probing
 
     restore_ubl_active_state_and_leave();
     do_blocking_move_to_xy_z(pos, Z_CLEARANCE_DEPLOY_PROBE);
   }
 
-  inline void set_message_with_feedback(PGM_P const msg_P) {
-    ui.set_status_P(msg_P);
-    ui.quick_feedback();
-  }
-
-  void abort_fine_tune() {
-    ui.return_to_status();
-    do_z_clearance(Z_CLEARANCE_BETWEEN_PROBES);
-    set_message_with_feedback(GET_TEXT(MSG_EDITING_STOPPED));
-  }
-
+  /**
+   * G29 P4 : Mesh Fine-Tuning. Go to point(s) and adjust values with the LCD.
+   *          NOTE: Blocks the G-code queue and captures Marlin UI during use.
+   */
   void unified_bed_leveling::fine_tune_mesh(const xy_pos_t &pos, const bool do_ubl_mesh_map) {
-    if (!parser.seen('R'))      // fine_tune_mesh() is special. If no repetition count flag is specified
-      g29_repetition_cnt = 1;   // do exactly one mesh location. Otherwise use what the parser decided.
+    if (!parser.seen('R'))        // fine_tune_mesh() is special. If no repetition count flag is specified
+      param.R_repetition = 1;   // do exactly one mesh location. Otherwise use what the parser decided.
 
     #if ENABLED(UBL_MESH_EDIT_MOVES_Z)
       const float h_offset = parser.seenval('H') ? parser.value_linear_units() : MANUAL_PROBE_START_Z;
     const xy_int8_t &lpos = location.pos;
 
     #if IS_TFTGLCD_PANEL
-      lcd_mesh_edit_setup(0);                             // Change current screen before calling ui.ubl_plot
+      ui.ubl_mesh_edit_start(0);                          // Change current screen before calling ui.ubl_plot
       safe_delay(50);
     #endif
 
 
       KEEPALIVE_STATE(PAUSED_FOR_USER);
 
-      if (do_ubl_mesh_map) display_map(g29_map_type);     // Display the current point
+      if (do_ubl_mesh_map) display_map(param.T_map_type);     // Display the current point
 
       #if IS_TFTGLCD_PANEL
         ui.ubl_plot(lpos.x, lpos.y);   // update plot screen
       if (isnan(new_z)) new_z = 0;                        // Invalid points begin at 0
       new_z = FLOOR(new_z * 1000) * 0.001f;               // Chop off digits after the 1000ths place
 
-      lcd_mesh_edit_setup(new_z);
+      ui.ubl_mesh_edit_start(new_z);
 
       SET_SOFT_ENDSTOP_LOOSE(true);
 
       do {
         idle();
-        new_z = lcd_mesh_edit();
+        new_z = ui.ubl_mesh_value();
         TERN_(UBL_MESH_EDIT_MOVES_Z, do_blocking_move_to_z(h_offset + new_z)); // Move the nozzle as the point is edited
         SERIAL_FLUSH();                                   // Prevent host M105 buffer overrun.
       } while (!ui.button_pressed());
 
       if (!lcd_map_control) ui.return_to_status();        // Just editing a single point? Return to status
 
-      if (click_and_hold(abort_fine_tune)) break;         // Button held down? Abort editing
+      // Button held down? Abort editing
+      if (_click_and_hold([]{
+        ui.return_to_status();
+        do_z_clearance(Z_CLEARANCE_BETWEEN_PROBES);
+        set_message_with_feedback(GET_TEXT(MSG_EDITING_STOPPED));
+      })) break;
+
+      // TODO: Disable leveling here so the Z value becomes the 'native' Z value.
 
       z_values[lpos.x][lpos.y] = new_z;                   // Save the updated Z value
+
+      // TODO: Re-enable leveling here so Z is correctly based on the updated mesh.
+
       TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(location, new_z));
 
       serial_delay(20);                                   // No switch noise
       ui.refresh();
 
-    } while (lpos.x >= 0 && --g29_repetition_cnt > 0);
+    } while (lpos.x >= 0 && --param.R_repetition > 0);
 
-    if (do_ubl_mesh_map) display_map(g29_map_type);
+    if (do_ubl_mesh_map) display_map(param.T_map_type);
     restore_ubl_active_state_and_leave();
 
     do_blocking_move_to_xy_z(pos, Z_CLEARANCE_BETWEEN_PROBES);
 
 #endif // HAS_LCD_MENU
 
-bool unified_bed_leveling::g29_parameter_parsing() {
+/**
+ * Parse and validate most G29 parameters, store for use by G29 functions.
+ */
+bool unified_bed_leveling::G29_parse_parameters() {
   bool err_flag = false;
 
-  TERN_(HAS_LCD_MENU, set_message_with_feedback(GET_TEXT(MSG_UBL_DOING_G29)));
+  set_message_with_feedback(GET_TEXT(MSG_UBL_DOING_G29));
 
-  g29_constant = 0;
-  g29_repetition_cnt = 0;
+  param.C_constant = 0;
+  param.R_repetition = 0;
 
   if (parser.seen('R')) {
-    g29_repetition_cnt = parser.has_value() ? parser.value_int() : GRID_MAX_POINTS;
-    NOMORE(g29_repetition_cnt, GRID_MAX_POINTS);
-    if (g29_repetition_cnt < 1) {
+    param.R_repetition = parser.has_value() ? parser.value_int() : GRID_MAX_POINTS;
+    NOMORE(param.R_repetition, GRID_MAX_POINTS);
+    if (param.R_repetition < 1) {
       SERIAL_ECHOLNPGM("?(R)epetition count invalid (1+).\n");
       return UBL_ERR;
     }
   }
 
-  g29_verbose_level = parser.seen('V') ? parser.value_int() : 0;
-  if (!WITHIN(g29_verbose_level, 0, 4)) {
+  param.V_verbosity = parser.seen('V') ? parser.value_int() : 0;
+  if (!WITHIN(param.V_verbosity, 0, 4)) {
     SERIAL_ECHOLNPGM("?(V)erbose level implausible (0-4).\n");
     err_flag = true;
   }
       else
     #endif
       {
-        g29_phase_value = pv;
-        if (!WITHIN(g29_phase_value, 0, 6)) {
+        param.P_phase = pv;
+        if (!WITHIN(param.P_phase, 0, 6)) {
           SERIAL_ECHOLNPGM("?(P)hase value invalid (0-6).\n");
           err_flag = true;
         }
 
   if (parser.seen('J')) {
     #if HAS_BED_PROBE
-      g29_grid_size = parser.has_value() ? parser.value_int() : 0;
-      if (g29_grid_size && !WITHIN(g29_grid_size, 2, 9)) {
+      param.grid_size = parser.has_value() ? parser.value_int() : 0;
+      if (param.grid_size && !WITHIN(param.grid_size, 2, 9)) {
         SERIAL_ECHOLNPGM("?Invalid grid size (J) specified (2-9).\n");
         err_flag = true;
       }
     #endif
   }
 
-  xy_seen.x = parser.seenval('X');
-  float sx = xy_seen.x ? parser.value_float() : current_position.x;
-  xy_seen.y = parser.seenval('Y');
-  float sy = xy_seen.y ? parser.value_float() : current_position.y;
+  param.XY_seen.x = parser.seenval('X');
+  float sx = param.XY_seen.x ? parser.value_float() : current_position.x;
+  param.XY_seen.y = parser.seenval('Y');
+  float sy = param.XY_seen.y ? parser.value_float() : current_position.y;
 
-  if (xy_seen.x != xy_seen.y) {
+  if (param.XY_seen.x != param.XY_seen.y) {
     SERIAL_ECHOLNPGM("Both X & Y locations must be specified.\n");
     err_flag = true;
   }
 
   if (err_flag) return UBL_ERR;
 
-  g29_pos.set(sx, sy);
+  param.XY_pos.set(sx, sy);
 
   /**
    * Activate or deactivate UBL
   }
 
   // Set global 'C' flag and its value
-  if ((g29_c_flag = parser.seen('C')))
-    g29_constant = parser.value_float();
+  if ((param.C_seen = parser.seen('C')))
+    param.C_constant = parser.value_float();
 
   #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
     if (parser.seenval('F')) {
     }
   #endif
 
-  g29_map_type = parser.intval('T');
-  if (!WITHIN(g29_map_type, 0, 2)) {
+  param.T_map_type = parser.intval('T');
+  if (!WITHIN(param.T_map_type, 0, 2)) {
     SERIAL_ECHOLNPGM("Invalid map type.\n");
     return UBL_ERR;
   }
     ubl_state_recursion_chk++;
     if (ubl_state_recursion_chk != 1) {
       SERIAL_ECHOLNPGM("save_ubl_active_state_and_disabled() called multiple times in a row.");
-      TERN_(HAS_LCD_MENU, set_message_with_feedback(GET_TEXT(MSG_UBL_SAVE_ERROR)));
+      set_message_with_feedback(GET_TEXT(MSG_UBL_SAVE_ERROR));
       return;
     }
   #endif
   #if ENABLED(UBL_DEVEL_DEBUGGING)
     if (--ubl_state_recursion_chk) {
       SERIAL_ECHOLNPGM("restore_ubl_active_state_and_leave() called too many times.");
-      TERN_(HAS_LCD_MENU, set_message_with_feedback(GET_TEXT(MSG_UBL_RESTORE_ERROR)));
+      set_message_with_feedback(GET_TEXT(MSG_UBL_RESTORE_ERROR));
       return;
     }
   #endif
   void unified_bed_leveling::tilt_mesh_based_on_probed_grid(const bool do_3_pt_leveling) {
     const float x_min = probe.min_x(), x_max = probe.max_x(),
                 y_min = probe.min_y(), y_max = probe.max_y(),
-                dx = (x_max - x_min) / (g29_grid_size - 1),
-                dy = (y_max - y_min) / (g29_grid_size - 1);
+                dx = (x_max - x_min) / (param.grid_size - 1),
+                dy = (y_max - y_min) / (param.grid_size - 1);
 
     xy_float_t points[3];
     probe.get_three_points(points);
       SERIAL_ECHOLNPGM("Tilting mesh (1/3)");
       TERN_(HAS_DISPLAY, ui.status_printf_P(0, PSTR(S_FMT " 1/3"), GET_TEXT(MSG_LCD_TILTING_MESH)));
 
-      measured_z = probe.probe_at_point(points[0], PROBE_PT_RAISE, g29_verbose_level);
+      measured_z = probe.probe_at_point(points[0], PROBE_PT_RAISE, param.V_verbosity);
       if (isnan(measured_z))
         abort_flag = true;
       else {
         #ifdef VALIDATE_MESH_TILT
           z1 = measured_z;
         #endif
-        if (g29_verbose_level > 3) {
+        if (param.V_verbosity > 3) {
           serial_spaces(16);
           SERIAL_ECHOLNPAIR("Corrected_Z=", measured_z);
         }
         SERIAL_ECHOLNPGM("Tilting mesh (2/3)");
         TERN_(HAS_DISPLAY, ui.status_printf_P(0, PSTR(S_FMT " 2/3"), GET_TEXT(MSG_LCD_TILTING_MESH)));
 
-        measured_z = probe.probe_at_point(points[1], PROBE_PT_RAISE, g29_verbose_level);
+        measured_z = probe.probe_at_point(points[1], PROBE_PT_RAISE, param.V_verbosity);
         #ifdef VALIDATE_MESH_TILT
           z2 = measured_z;
         #endif
           abort_flag = true;
         else {
           measured_z -= get_z_correction(points[1]);
-          if (g29_verbose_level > 3) {
+          if (param.V_verbosity > 3) {
             serial_spaces(16);
             SERIAL_ECHOLNPAIR("Corrected_Z=", measured_z);
           }
         SERIAL_ECHOLNPGM("Tilting mesh (3/3)");
         TERN_(HAS_DISPLAY, ui.status_printf_P(0, PSTR(S_FMT " 3/3"), GET_TEXT(MSG_LCD_TILTING_MESH)));
 
-        measured_z = probe.probe_at_point(points[2], PROBE_PT_STOW, g29_verbose_level);
+        measured_z = probe.probe_at_point(points[2], PROBE_PT_STOW, param.V_verbosity);
         #ifdef VALIDATE_MESH_TILT
           z3 = measured_z;
         #endif
           abort_flag = true;
         else {
           measured_z -= get_z_correction(points[2]);
-          if (g29_verbose_level > 3) {
+          if (param.V_verbosity > 3) {
             serial_spaces(16);
             SERIAL_ECHOLNPAIR("Corrected_Z=", measured_z);
           }
 
       bool zig_zag = false;
 
-      const uint16_t total_points = sq(g29_grid_size);
+      const uint16_t total_points = sq(param.grid_size);
       uint16_t point_num = 1;
 
       xy_pos_t rpos;
-      LOOP_L_N(ix, g29_grid_size) {
+      LOOP_L_N(ix, param.grid_size) {
         rpos.x = x_min + ix * dx;
-        LOOP_L_N(iy, g29_grid_size) {
-          rpos.y = y_min + dy * (zig_zag ? g29_grid_size - 1 - iy : iy);
+        LOOP_L_N(iy, param.grid_size) {
+          rpos.y = y_min + dy * (zig_zag ? param.grid_size - 1 - iy : iy);
 
           if (!abort_flag) {
             SERIAL_ECHOLNPAIR("Tilting mesh point ", point_num, "/", total_points, "\n");
             TERN_(HAS_DISPLAY, ui.status_printf_P(0, PSTR(S_FMT " %i/%i"), GET_TEXT(MSG_LCD_TILTING_MESH), point_num, total_points));
 
-            measured_z = probe.probe_at_point(rpos, parser.seen('E') ? PROBE_PT_STOW : PROBE_PT_RAISE, g29_verbose_level); // TODO: Needs error handling
+            measured_z = probe.probe_at_point(rpos, parser.seen('E') ? PROBE_PT_STOW : PROBE_PT_RAISE, param.V_verbosity); // TODO: Needs error handling
 
             abort_flag = isnan(measured_z);
 
 
             if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPAIR_F("   final >>>---> ", measured_z, 7);
 
-            if (g29_verbose_level > 3) {
+            if (param.V_verbosity > 3) {
               serial_spaces(16);
               SERIAL_ECHOLNPAIR("Corrected_Z=", measured_z);
             }
 
     vector_3 normal = vector_3(lsf_results.A, lsf_results.B, 1).get_normal();
 
-    if (g29_verbose_level > 2) {
+    if (param.V_verbosity > 2) {
       SERIAL_ECHOPAIR_F("bed plane normal = [", normal.x, 7);
       SERIAL_CHAR(',');
       SERIAL_ECHO_F(normal.y, 7);
       SERIAL_ECHOLNPAIR_F("Fade Height M420 Z", planner.z_fade_height, 4);
     #endif
 
-    adjust_mesh_to_mean(g29_c_flag, g29_constant);
+    adjust_mesh_to_mean(param.C_seen, param.C_constant);
 
     #if HAS_BED_PROBE
       SERIAL_ECHOLNPAIR_F("Probe Offset M851 Z", probe.offset.z, 7);
       return;
     }
 
-    if (!parser.has_value() || !WITHIN(g29_storage_slot, 0, a - 1)) {
+    if (!parser.has_value() || !WITHIN(parser.value_int(), 0, a - 1)) {
       SERIAL_ECHOLNPAIR("?Invalid storage slot.\n?Use 0 to ", a - 1);
       return;
     }
 
-    g29_storage_slot = parser.value_int();
+    param.KLS_storage_slot = parser.value_int();
 
     float tmp_z_values[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y];
-    settings.load_mesh(g29_storage_slot, &tmp_z_values);
+    settings.load_mesh(param.KLS_storage_slot, &tmp_z_values);
 
-    SERIAL_ECHOLNPAIR("Subtracting mesh in slot ", g29_storage_slot, " from current mesh.");
+    SERIAL_ECHOLNPAIR("Subtracting mesh in slot ", param.KLS_storage_slot, " from current mesh.");
 
     GRID_LOOP(x, y) {
       z_values[x][y] -= tmp_z_values[x][y];

Marlin/src/gcode/bedlevel/M420.cpp

             GRID_LOOP(x, y) mesh_sum += Z_VALUES(x, y);
             const float zmean = mesh_sum / float(GRID_MAX_POINTS);
 
-          #else
+          #else // midrange
 
-            // Find the low and high mesh values
+            // Find the low and high mesh values.
             float lo_val = 100, hi_val = -100;
             GRID_LOOP(x, y) {
               const float z = Z_VALUES(x, y);
               NOMORE(lo_val, z);
               NOLESS(hi_val, z);
             }
-            // Take the mean of the lowest and highest
+            // Get the midrange plus C value. (The median may be better.)
             const float zmean = (lo_val + hi_val) / 2.0 + cval;
 
           #endif

Marlin/src/lcd/marlinui.h

     typedef void (*screenFunc_t)();
     typedef void (*menuAction_t)();
 
-    #if ENABLED(AUTO_BED_LEVELING_UBL)
-      void lcd_mesh_edit_setup(const float &initial);
-      float lcd_mesh_edit();
-    #endif
-
   #endif // HAS_LCD_MENU
 
 #endif // HAS_WIRED_LCD
       static void ubl_plot(const uint8_t x_plot, const uint8_t y_plot);
     #endif
 
+    #if ENABLED(AUTO_BED_LEVELING_UBL)
+      static void ubl_mesh_edit_start(const float &initial);
+      static float ubl_mesh_value();
+    #endif
+
     static void draw_select_screen_prompt(PGM_P const pref, const char * const string=nullptr, PGM_P const suff=nullptr);
 
   #elif HAS_WIRED_LCD

Marlin/src/lcd/menu/menu_ubl.cpp

   return float(rounded - (rounded % 5L)) / 1000;
 }
 
-static void _lcd_mesh_fine_tune(PGM_P const msg) {
+/**
+ * This screen displays the temporary mesh value and updates it based on encoder
+ * movement. While this screen is active ubl.fine_tune_mesh sits in a loop getting
+ * the current value via ubl_mesh_value, moves the Z axis, and updates the mesh
+ * value until the encoder button is pressed.
+ *
+ * - Update the 'mesh_edit_accumulator' from encoder rotation
+ * - Draw the mesh value (with draw_edit_screen)
+ * - Draw the graphical overlay, if enabled.
+ * - Update the 'refresh' state according to the display type
+ */
+void _lcd_mesh_fine_tune(PGM_P const msg) {
+  constexpr float mesh_edit_step = 1.0f / 200.0f;
   ui.defer_status_screen();
   if (ubl.encoder_diff) {
     mesh_edit_accumulator += TERN(IS_TFTGLCD_PANEL,
-      ubl.encoder_diff * 0.005f / ENCODER_PULSES_PER_STEP,
-      ubl.encoder_diff > 0 ? 0.005f : -0.005f
+      ubl.encoder_diff * mesh_edit_step / ENCODER_PULSES_PER_STEP,
+      ubl.encoder_diff > 0 ? mesh_edit_step : -mesh_edit_step
     );
     ubl.encoder_diff = 0;
     IF_DISABLED(IS_TFTGLCD_PANEL, ui.refresh(LCDVIEW_CALL_REDRAW_NEXT));
 }
 
 //
-// Called external to the menu system to acquire the result of an edit.
+// Init mesh editing and go to the fine tuning screen (ubl.fine_tune_mesh)
+// To capture encoder events UBL will also call ui.capture and ui.release.
 //
-float lcd_mesh_edit() { return rounded_mesh_value(); }
-
-void lcd_mesh_edit_setup(const float &initial) {
-  TERN_(HAS_GRAPHICAL_TFT, ui.clear_lcd());
+void MarlinUI::ubl_mesh_edit_start(const float &initial) {
+  TERN_(HAS_GRAPHICAL_TFT, clear_lcd());
   mesh_edit_accumulator = initial;
-  ui.goto_screen([]{ _lcd_mesh_fine_tune(GET_TEXT(MSG_MESH_EDIT_Z)); });
-}
-
-void _lcd_z_offset_edit() {
-  _lcd_mesh_fine_tune(GET_TEXT(MSG_UBL_Z_OFFSET));
+  goto_screen([]{ _lcd_mesh_fine_tune(GET_TEXT(MSG_MESH_EDIT_Z)); });
 }
 
-float lcd_z_offset_edit() {
-  ui.goto_screen(_lcd_z_offset_edit);
-  return rounded_mesh_value();
-}
-
-void lcd_z_offset_edit_setup(const float &initial) {
-  mesh_edit_accumulator = initial;
-  ui.goto_screen(_lcd_z_offset_edit);
-}
+//
+// Get the mesh value within a Z adjustment loop (ubl.fine_tune_mesh)
+//
+float MarlinUI::ubl_mesh_value() { return rounded_mesh_value(); }
 
 /**
  * UBL Build Custom Mesh Command