Merge pull request #6697 from thinkyhead/bf_wednesday_cleanup

Wednesday-Thursday cleaning up after

Marlin/Conditionals_post.h

@@ -731,15 +731,12 @@
    * Set granular options based on the specific type of leveling
    */
 
-  #if ENABLED(AUTO_BED_LEVELING_UBL) && ENABLED(DELTA)
-    #define UBL_DELTA
-  #endif
-
+  #define UBL_DELTA  (ENABLED(AUTO_BED_LEVELING_UBL) && ENABLED(DELTA))
   #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 || ENABLED(AUTO_BED_LEVELING_UBL))
   #define HAS_LEVELING          (HAS_ABL || ENABLED(MESH_BED_LEVELING))
-  #define PLANNER_LEVELING      (ABL_PLANAR || ABL_GRID || ENABLED(MESH_BED_LEVELING) || ENABLED(UBL_DELTA))
+  #define PLANNER_LEVELING      (ABL_PLANAR || ABL_GRID || ENABLED(MESH_BED_LEVELING) || UBL_DELTA)
   #define HAS_PROBING_PROCEDURE (HAS_ABL || ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST))
   #if HAS_PROBING_PROCEDURE
     #define PROBE_BED_WIDTH abs(RIGHT_PROBE_BED_POSITION - (LEFT_PROBE_BED_POSITION))
@@ -823,8 +820,7 @@
   /**
    * DELTA_SEGMENT_MIN_LENGTH for UBL_DELTA
    */
-
-  #if ENABLED(UBL_DELTA)
+  #if UBL_DELTA
     #ifndef DELTA_SEGMENT_MIN_LENGTH
       #if IS_SCARA
         #define DELTA_SEGMENT_MIN_LENGTH 0.25 // SCARA minimum segment size is 0.25mm
@@ -836,4 +832,7 @@
     #endif
   #endif
 
+  // Shorthand
+  #define GRID_MAX_POINTS ((GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y))
+
 #endif // CONDITIONALS_POST_H

Marlin/G26_Mesh_Validation_Tool.cpp

@@ -100,7 +100,7 @@
    *                    'n' can be used instead if your host program does not appreciate you using 'N'.
    *
    *   O #  Ooooze      How much your nozzle will Ooooze filament while getting in position to print.  This
-   *                    is over kill, but using this parameter will let you get the very first 'cicle' perfect
+   *                    is over kill, but using this parameter will let you get the very first 'circle' perfect
    *                    so you have a trophy to peel off of the bed and hang up to show how perfectly you have your
    *                    Mesh calibrated.  If not specified, a filament length of .3mm is assumed.
    *
@@ -152,7 +152,7 @@
   bool turn_on_heaters();
   bool prime_nozzle();
 
-  static uint16_t circle_flags[16], horizontal_mesh_line_flags[16], vertical_mesh_line_flags[16], continue_with_closest = 0;
+  static uint16_t circle_flags[16], horizontal_mesh_line_flags[16], vertical_mesh_line_flags[16];
   float g26_e_axis_feedrate = 0.020,
         random_deviation = 0.0,
         layer_height = LAYER_HEIGHT;
@@ -176,7 +176,7 @@
 
   static int8_t prime_flag = 0;
 
-  static bool keep_heaters_on = false;
+  static bool continue_with_closest, keep_heaters_on;
 
   static int16_t g26_repeats;
 
@@ -278,8 +278,7 @@
 
         // If this mesh location is outside the printable_radius, skip it.
 
-        if ( ! position_is_reachable_raw_xy( circle_x, circle_y ))
-          continue;
+        if (!position_is_reachable_raw_xy(circle_x, circle_y)) continue;
 
         xi = location.x_index;  // Just to shrink the next few lines and make them easier to understand
         yi = location.y_index;
@@ -329,9 +328,7 @@
                 ye = circle_y + sin_table[tmp_div_30 + 1];
           #if IS_KINEMATIC
             // Check to make sure this segment is entirely on the bed, skip if not.
-            if (( ! position_is_reachable_raw_xy( x , y  )) ||
-                ( ! position_is_reachable_raw_xy( xe, ye )))
-              continue;
+            if (!position_is_reachable_raw_xy(x, y) || !position_is_reachable_raw_xy(xe, ye)) continue;
           #else                                              // not, we need to skip
             x  = constrain(x, X_MIN_POS + 1, X_MAX_POS - 1); // This keeps us from bumping the endstops
             y  = constrain(y, Y_MIN_POS + 1, Y_MAX_POS - 1);
@@ -361,7 +358,7 @@
 
       //debug_current_and_destination(PSTR("Done with current circle."));
 
-    } while (location.x_index >= 0 && location.y_index >= 0 && g26_repeats--);
+    } while (--g26_repeats && location.x_index >= 0 && location.y_index >= 0);
 
     LEAVE:
     lcd_reset_alert_level();
@@ -459,8 +456,7 @@
               sy = ey = constrain(pgm_read_float(&ubl.mesh_index_to_ypos[j]), Y_MIN_POS + 1, Y_MAX_POS - 1);
               ex = constrain(ex, X_MIN_POS + 1, X_MAX_POS - 1);
 
-              if (( position_is_reachable_raw_xy( sx, sy )) &&
-                  ( position_is_reachable_raw_xy( ex, ey ))) {
+              if (position_is_reachable_raw_xy(sx, sy) && position_is_reachable_raw_xy(ex, ey)) {
 
                 if (ubl.g26_debug_flag) {
                   SERIAL_ECHOPAIR(" Connecting with horizontal line (sx=", sx);
@@ -494,8 +490,7 @@
                 sy = constrain(sy, Y_MIN_POS + 1, Y_MAX_POS - 1);
                 ey = constrain(ey, Y_MIN_POS + 1, Y_MAX_POS - 1);
 
-                if (( position_is_reachable_raw_xy( sx, sy )) &&
-                    ( position_is_reachable_raw_xy( ex, ey ))) {
+                if (position_is_reachable_raw_xy(sx, sy) && position_is_reachable_raw_xy(ex, ey)) {
 
                   if (ubl.g26_debug_flag) {
                     SERIAL_ECHOPAIR(" Connecting with vertical line (sx=", sx);
@@ -623,8 +618,8 @@
 
       //if (ubl.g26_debug_flag) SERIAL_ECHOLNPGM("  Z bumping by 0.500 to minimize scraping.");
       //todo:  parameterize the bump height with a define
-      move_to(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS]+0.500, 0.0);  // Z bump to minimize scraping
-      move_to(sx, sy, sz+0.500, 0.0); // Get to the starting point with no extrusion while bumped
+      move_to(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS] + 0.500, 0.0);  // Z bump to minimize scraping
+      move_to(sx, sy, sz + 0.500, 0.0); // Get to the starting point with no extrusion while bumped
     }
 
     move_to(sx, sy, sz, 0.0); // Get to the starting point with no extrusion / un-Z bump
@@ -655,9 +650,11 @@
     prime_length          = PRIME_LENGTH;
     bed_temp              = BED_TEMP;
     hotend_temp           = HOTEND_TEMP;
-    ooze_amount           = OOZE_AMOUNT;
     prime_flag            = 0;
-    keep_heaters_on       = false;
+
+    ooze_amount           = code_seen('O') && code_has_value() ? code_value_linear_units() : OOZE_AMOUNT;
+    keep_heaters_on       = code_seen('K') && code_value_bool();
+    continue_with_closest = code_seen('C') && code_value_bool();
 
     if (code_seen('B')) {
       bed_temp = code_value_temp_abs();
@@ -667,8 +664,6 @@
       }
     }
 
-    if (code_seen('C')) continue_with_closest++;
-
     if (code_seen('L')) {
       layer_height = code_value_linear_units();
       if (!WITHIN(layer_height, 0.0, 2.0)) {
@@ -691,7 +686,7 @@
       }
     }
 
-    if (code_seen('N') || code_seen('n')) {
+    if (code_seen('N') || code_seen('n')) { // Warning! Use of 'N' / lowercase flouts established standards.
       nozzle = code_value_float();
       if (!WITHIN(nozzle, 0.1, 1.0)) {
         SERIAL_PROTOCOLLNPGM("?Specified nozzle size not plausible.");
@@ -699,11 +694,6 @@
       }
     }
 
-    if (code_seen('K')) keep_heaters_on++;
-
-    if (code_seen('O') && code_has_value())
-      ooze_amount = code_value_linear_units();
-
     if (code_seen('P')) {
       if (!code_has_value())
         prime_flag = -1;
@@ -738,35 +728,21 @@
       }
     }
 
-    if (code_seen('M')) {
+    if (code_seen('M')) { // Warning! Use of 'M' flouts established standards.
       randomSeed(millis());
+      // This setting will persist for the next G26
       random_deviation = code_has_value() ? code_value_float() : 50.0;
     }
 
-    if (code_seen('R')) {
-      g26_repeats = code_has_value() ? code_value_int() : 999;
-
-      if (g26_repeats <= 0) {
-        SERIAL_PROTOCOLLNPGM("?(R)epeat value not plausible; must be greater than 0.");
-        return UBL_ERR;
-      }
-
-      g26_repeats--;
-    }
-
-
-    x_pos = current_position[X_AXIS];
-    y_pos = current_position[Y_AXIS];
-
-    if (code_seen('X')) {
-      x_pos = code_value_float();
-    }
-
-    if (code_seen('Y')) {
-      y_pos = code_value_float();
+    g26_repeats = code_seen('R') ? (code_has_value() ? code_value_int() : 999) : 1;
+    if (g26_repeats < 1) {
+      SERIAL_PROTOCOLLNPGM("?(R)epeat value not plausible; must be at least 1.");
+      return UBL_ERR;
     }
 
-    if ( ! position_is_reachable_xy( x_pos, y_pos )) {
+    x_pos = code_seen('X') ? code_value_linear_units() : current_position[X_AXIS];
+    y_pos = code_seen('Y') ? code_value_linear_units() : current_position[Y_AXIS];
+    if (!position_is_reachable_xy(x_pos, y_pos)) {
       SERIAL_PROTOCOLLNPGM("?Specified X,Y coordinate out of bounds.");
       return UBL_ERR;
     }

Marlin/Marlin_main.cpp

@@ -56,6 +56,8 @@
  * G12 - Clean tool
  * G20 - Set input units to inches
  * G21 - Set input units to millimeters
+ * G26 - Mesh Validation Pattern (Requires UBL_G26_MESH_EDITING)
+ * G27 - Park Nozzle (Requires NOZZLE_PARK_FEATURE)
  * G28 - Home one or more axes
  * G29 - Detailed Z probe, probes the bed at 3 or more points.  Will fail if you haven't homed yet.
  * G30 - Single Z probe, probes bed at X Y location (defaults to current XY location)
@@ -97,14 +99,15 @@
  * M76  - Pause the print job timer.
  * M77  - Stop the print job timer.
  * M78  - Show statistical information about the print jobs. (Requires PRINTCOUNTER)
- * M80  - Turn on Power Supply. (Requires POWER_SUPPLY)
- * M81  - Turn off Power Supply. (Requires POWER_SUPPLY)
+ * M80  - Turn on Power Supply. (Requires POWER_SUPPLY > 0)
+ * M81  - Turn off Power Supply. (Requires POWER_SUPPLY > 0)
  * M82  - Set E codes absolute (default).
  * M83  - Set E codes relative while in Absolute (G90) mode.
  * M84  - Disable steppers until next move, or use S<seconds> to specify an idle
  *        duration after which steppers should turn off. S0 disables the timeout.
  * M85  - Set inactivity shutdown timer with parameter S<seconds>. To disable set zero (default)
  * M92  - Set planner.axis_steps_per_mm for one or more axes.
+ * M100 - Watch Free Memory (for debugging) (Requires M100_FREE_MEMORY_WATCHER)
  * M104 - Set extruder target temp.
  * M105 - Report current temperatures.
  * M106 - Fan on.
@@ -210,7 +213,6 @@
  * M364 - SCARA calibration: Move to cal-position PSIC (90 deg to Theta calibration position)
  *
  * ************ Custom codes - This can change to suit future G-code regulations
- * M100 - Watch Free Memory (For Debugging). (Requires M100_FREE_MEMORY_WATCHER)
  * M928 - Start SD logging: "M928 filename.gco". Stop with M29. (Requires SDSUPPORT)
  * M999 - Restart after being stopped by error
  *
@@ -2425,9 +2427,12 @@ static void clean_up_after_endstop_or_probe_move() {
 
     #elif ENABLED(AUTO_BED_LEVELING_UBL)
 
-      #if ENABLED(UBL_DELTA)
-        if (( ubl.state.active ) && ( ! enable )) {   // leveling from on to off
-          planner.unapply_leveling(current_position);
+      #if PLANNER_LEVELING
+        if (ubl.state.active != enable) {
+          if (!enable)   // leveling from on to off
+            planner.apply_leveling(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS]);
+          else
+            planner.unapply_leveling(current_position);
         }
       #endif
 
@@ -3729,7 +3734,7 @@ inline void gcode_G28() {
   // Disable the leveling matrix before homing
   #if HAS_LEVELING
     #if ENABLED(AUTO_BED_LEVELING_UBL)
-      const bool bed_leveling_state_at_entry = ubl.state.active;
+      const bool ubl_state_at_entry = ubl.state.active;
     #endif
     set_bed_leveling_enabled(false);
   #endif
@@ -3872,8 +3877,9 @@ inline void gcode_G28() {
     // move to a height where we can use the full xy-area
     do_blocking_move_to_z(delta_clip_start_height);
   #endif
+
   #if ENABLED(AUTO_BED_LEVELING_UBL)
-    set_bed_leveling_enabled(bed_leveling_state_at_entry);
+    set_bed_leveling_enabled(ubl_state_at_entry);
   #endif
 
   clean_up_after_endstop_or_probe_move();
@@ -4028,7 +4034,7 @@ void home_all_axes() { gcode_G28(); }
           #endif
         }
         // If there's another point to sample, move there with optional lift.
-        if (mbl_probe_index < (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y)) {
+        if (mbl_probe_index < GRID_MAX_POINTS) {
           mbl.zigzag(mbl_probe_index, px, py);
           _manual_goto_xy(mbl.index_to_xpos[px], mbl.index_to_ypos[py]);
 
@@ -4247,8 +4253,6 @@ void home_all_axes() { gcode_G28(); }
       ABL_VAR int left_probe_bed_position, right_probe_bed_position, front_probe_bed_position, back_probe_bed_position;
       ABL_VAR float xGridSpacing, yGridSpacing;
 
-      #define ABL_GRID_MAX (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y)
-
       #if ABL_PLANAR
         ABL_VAR uint8_t abl_grid_points_x = GRID_MAX_POINTS_X,
                         abl_grid_points_y = GRID_MAX_POINTS_Y;
@@ -4262,7 +4266,7 @@ void home_all_axes() { gcode_G28(); }
         #if ABL_PLANAR
           ABL_VAR int abl2;
         #else // 3-point
-          int constexpr abl2 = ABL_GRID_MAX;
+          int constexpr abl2 = GRID_MAX_POINTS;
         #endif
       #endif
 
@@ -4274,8 +4278,8 @@ void home_all_axes() { gcode_G28(); }
 
         ABL_VAR int indexIntoAB[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y];
 
-        ABL_VAR float eqnAMatrix[ABL_GRID_MAX * 3], // "A" matrix of the linear system of equations
-                     eqnBVector[ABL_GRID_MAX],     // "B" vector of Z points
+        ABL_VAR float eqnAMatrix[GRID_MAX_POINTS * 3], // "A" matrix of the linear system of equations
+                     eqnBVector[GRID_MAX_POINTS],     // "B" vector of Z points
                      mean;
       #endif
 
@@ -7619,7 +7623,6 @@ inline void gcode_M205() {
     if (code_seen('H')) {
       home_offset[Z_AXIS] = code_value_linear_units() - DELTA_HEIGHT;
       current_position[Z_AXIS] += code_value_linear_units() - DELTA_HEIGHT - home_offset[Z_AXIS];
-      home_offset[Z_AXIS] = code_value_linear_units() - DELTA_HEIGHT;
       update_software_endstops(Z_AXIS);
     }
     if (code_seen('L')) delta_diagonal_rod = code_value_linear_units();
@@ -8413,17 +8416,15 @@ void quickstop_stepper() {
    * Use either 'M421 X<linear> Y<linear> Z<linear>' or 'M421 I<xindex> J<yindex> Z<linear>'
    */
   inline void gcode_M421() {
-    int8_t px = 0, py = 0;
-    float z = 0;
-    bool hasX, hasY, hasZ, hasI, hasJ;
-    if ((hasX = code_seen('X'))) px = mbl.probe_index_x(code_value_linear_units());
-    if ((hasY = code_seen('Y'))) py = mbl.probe_index_y(code_value_linear_units());
-    if ((hasI = code_seen('I'))) px = code_value_linear_units();
-    if ((hasJ = code_seen('J'))) py = code_value_linear_units();
-    if ((hasZ = code_seen('Z'))) z = code_value_linear_units();
 
-    if (hasX && hasY && hasZ) {
+    const bool hasX = code_seen('X'), hasI = !hasX && code_seen('I');
+    const int8_t px = hasX || hasI ? mbl.probe_index_x(code_value_linear_units()) : 0;
+    const bool hasY = code_seen('Y'), hasJ = !hasY && code_seen('J');
+    const int8_t py = hasY || hasJ ? mbl.probe_index_y(code_value_linear_units()) : 0;
+    const bool hasZ = code_seen('Z');
+    const float z = hasZ ? code_value_linear_units() : 0;
 
+    if (hasX && hasY && hasZ) {
       if (px >= 0 && py >= 0)
         mbl.set_z(px, py, z);
       else {
@@ -8450,18 +8451,18 @@ void quickstop_stepper() {
   /**
    * M421: Set a single Mesh Bed Leveling Z coordinate
    *
+   * Usage:
    *   M421 I<xindex> J<yindex> Z<linear>
-   *   or
    *   M421 I<xindex> J<yindex> Q<offset>
    */
   inline void gcode_M421() {
-    int8_t px = 0, py = 0;
-    float z = 0;
-    bool hasI, hasJ, hasZ, hasQ;
-    if ((hasI = code_seen('I'))) px = code_value_int();
-    if ((hasJ = code_seen('J'))) py = code_value_int();
-    if ((hasZ = code_seen('Z'))) z = code_value_linear_units();
-    if ((hasQ = code_seen('Q'))) z = code_value_linear_units();
+
+    const bool hasI = code_seen('I');
+    const int8_t px = hasI ? code_value_int() : 0;
+    const bool hasJ = code_seen('J');
+    const int8_t py = hasJ ? code_value_int() : 0;
+    const bool hasZ = code_seen('Z'), hasQ = !hasZ && code_seen('Q');
+    const float z = hasZ || hasQ ? code_value_linear_units() : 0;
 
     if (!hasI || !hasJ || (hasQ && hasZ) || (!hasQ && !hasZ)) {
       SERIAL_ERROR_START;
@@ -8494,35 +8495,33 @@ void quickstop_stepper() {
   /**
    * M421: Set a single Mesh Bed Leveling Z coordinate
    *
+   * Usage:
    *   M421 I<xindex> J<yindex> Z<linear>
-   *   or
    *   M421 I<xindex> J<yindex> Q<offset>
+   *   M421 C Z<linear>
+   *   M421 C Q<offset>
    */
 
-  //todo:  change multiple points simultaneously?
-
   inline void gcode_M421() {
-    int8_t px = 0, py = 0;
-    float z = 0;
-    bool hasI, hasJ, hasZ, hasQ, hasC;
-    if ((hasI = code_seen('I'))) px = code_value_int();
-    if ((hasJ = code_seen('J'))) py = code_value_int();
-    if ((hasZ = code_seen('Z'))) z = code_value_linear_units();
-    if ((hasQ = code_seen('Q'))) z = code_value_linear_units();
-    hasC = code_seen('C');
-
-    if ( (!(hasI && hasJ) && !hasC) || (hasQ && hasZ) || (!hasQ && !hasZ)) {
+
+    // Get the closest position for 'C', if needed
+    const mesh_index_pair location = find_closest_mesh_point_of_type(REAL, current_position[X_AXIS], current_position[Y_AXIS], USE_NOZZLE_AS_REFERENCE, NULL, false);
+
+    const bool hasC = code_seen('C'), hasI = code_seen('I');
+    const int8_t px = hasC ? location.x_index : hasI ? code_value_int() : 0;
+
+    const bool hasJ = code_seen('J');
+    const int8_t py = hasC ? location.y_index : hasJ ? code_value_int() : 0;
+
+    const bool hasZ = code_seen('Z'), hasQ = !hasZ && code_seen('Q');
+    const float z = hasZ || hasQ ? code_value_linear_units() : 0;
+
+    if ( ((hasI && hasJ) == hasC) || (hasQ && hasZ) || (!hasQ && !hasZ)) {
       SERIAL_ERROR_START;
       SERIAL_ERRORLNPGM(MSG_ERR_M421_PARAMETERS);
       return;
     }
 
-    if (hasC) { // get closest position
-      const mesh_index_pair location = find_closest_mesh_point_of_type(REAL, current_position[X_AXIS], current_position[Y_AXIS], USE_NOZZLE_AS_REFERENCE, NULL, false);
-      px = location.x_index;
-      py = location.y_index;
-    }
-
     if (WITHIN(px, 0, GRID_MAX_POINTS_X - 1) && WITHIN(py, 0, GRID_MAX_POINTS_Y - 1)) {
       if (hasZ) // doing an absolute mesh value
         ubl.z_values[px][py] = z;
@@ -8534,7 +8533,8 @@ void quickstop_stepper() {
       SERIAL_ERRORLNPGM(MSG_ERR_MESH_XY);
     }
   }
-#endif
+
+#endif // AUTO_BED_LEVELING_UBL
 
 #if HAS_M206_COMMAND
 
@@ -11106,7 +11106,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) {
 
 #endif // AUTO_BED_LEVELING_BILINEAR
 
-#if IS_KINEMATIC && DISABLED(UBL_DELTA)
+#if IS_KINEMATIC && !UBL_DELTA
 
   /**
    * Prepare a linear move in a DELTA or SCARA setup.
@@ -11117,7 +11117,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) {
   inline bool prepare_kinematic_move_to(float ltarget[XYZE]) {
 
     // Get the top feedrate of the move in the XY plane
-    float _feedrate_mm_s = MMS_SCALED(feedrate_mm_s);
+    const float _feedrate_mm_s = MMS_SCALED(feedrate_mm_s);
 
     // If the move is only in Z/E don't split up the move
     if (ltarget[X_AXIS] == current_position[X_AXIS] && ltarget[Y_AXIS] == current_position[Y_AXIS]) {
@@ -11126,7 +11126,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) {
     }
 
     // Fail if attempting move outside printable radius
-    if ( ! position_is_reachable_xy( ltarget[X_AXIS], ltarget[Y_AXIS] )) return true;
+    if (!position_is_reachable_xy(ltarget[X_AXIS], ltarget[Y_AXIS])) return true;
 
     // Get the cartesian distances moved in XYZE
     float difference[XYZE];
@@ -11142,7 +11142,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) {
     if (UNEAR_ZERO(cartesian_mm)) return true;
 
     // Minimum number of seconds to move the given distance
-    float seconds = cartesian_mm / _feedrate_mm_s;
+    const float seconds = cartesian_mm / _feedrate_mm_s;
 
     // The number of segments-per-second times the duration
     // gives the number of segments
@@ -11227,7 +11227,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) {
     return false;
   }
 
-#else // !IS_KINEMATIC
+#else // !IS_KINEMATIC || UBL_DELTA
 
   /**
    * Prepare a linear move in a Cartesian setup.
@@ -11265,7 +11265,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) {
     return false;
   }
 
-#endif // !IS_KINEMATIC
+#endif // !IS_KINEMATIC || UBL_DELTA
 
 #if ENABLED(DUAL_X_CARRIAGE)
 
@@ -11377,21 +11377,21 @@ void prepare_move_to_destination() {
 
   #endif
 
-  #if IS_KINEMATIC
-    #if ENABLED(UBL_DELTA)
-      if (ubl_prepare_linear_move_to(destination,feedrate_mm_s)) return;
-    #else
-      if (prepare_kinematic_move_to(destination)) return;
-    #endif
-  #else
-    #if ENABLED(DUAL_X_CARRIAGE)
-      if (prepare_move_to_destination_dualx()) return;
-    #elif ENABLED(UBL_DELTA) // will work for CARTESIAN too (smaller segments follow mesh more closely)
-      if (ubl_prepare_linear_move_to(destination,feedrate_mm_s)) return;
+  if (
+    #if IS_KINEMATIC
+      #if UBL_DELTA
+        ubl_prepare_linear_move_to(destination, feedrate_mm_s)
+      #else
+        prepare_kinematic_move_to(destination)
+      #endif
+    #elif ENABLED(DUAL_X_CARRIAGE)
+      prepare_move_to_destination_dualx()
+    #elif UBL_DELTA // will work for CARTESIAN too (smaller segments follow mesh more closely)
+      ubl_prepare_linear_move_to(destination, feedrate_mm_s)
     #else
-      if (prepare_move_to_destination_cartesian()) return;
+      prepare_move_to_destination_cartesian()
     #endif
-  #endif
+  ) return;
 
   set_current_to_destination();
 }
@@ -11432,7 +11432,7 @@ void prepare_move_to_destination() {
     if (angular_travel == 0 && current_position[X_AXIS] == logical[X_AXIS] && current_position[Y_AXIS] == logical[Y_AXIS])
       angular_travel += RADIANS(360);
 
-    float mm_of_travel = HYPOT(angular_travel * radius, fabs(linear_travel));
+    const float mm_of_travel = HYPOT(angular_travel * radius, fabs(linear_travel));
     if (mm_of_travel < 0.001) return;
 
     uint16_t segments = floor(mm_of_travel / (MM_PER_ARC_SEGMENT));

Marlin/SanityCheck.h

@@ -248,11 +248,9 @@
 #if ENABLED(DELTA)
   #if DISABLED(USE_XMAX_PLUG) && DISABLED(USE_YMAX_PLUG) && DISABLED(USE_ZMAX_PLUG)
     #error "You probably want to use Max Endstops for DELTA!"
-  #endif
-  #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT) && DISABLED(UBL_DELTA)
-    #error "ENABLE_LEVELING_FADE_HEIGHT for DELTA requires UBL_DELTA and AUTO_BED_LEVELING_UBL."
-  #endif
-  #if ABL_GRID
+  #elif ENABLED(ENABLE_LEVELING_FADE_HEIGHT) && DISABLED(AUTO_BED_LEVELING_BILINEAR) && !UBL_DELTA
+    #error "ENABLE_LEVELING_FADE_HEIGHT on DELTA requires AUTO_BED_LEVELING_BILINEAR or AUTO_BED_LEVELING_UBL."
+  #elif ABL_GRID
     #if (GRID_MAX_POINTS_X & 1) == 0 || (GRID_MAX_POINTS_Y & 1) == 0
       #error "DELTA requires GRID_MAX_POINTS_X and GRID_MAX_POINTS_Y to be odd numbers."
     #elif GRID_MAX_POINTS_X < 3
@@ -431,20 +429,11 @@ static_assert(1 >= 0
  * Unified Bed Leveling
  */
 #if ENABLED(AUTO_BED_LEVELING_UBL)
-  #if IS_KINEMATIC
-    #if ENABLED(DELTA)
-      #if DISABLED(UBL_DELTA)
-        #error "AUTO_BED_LEVELING_UBL requires UBL_DELTA for DELTA printers."
-      #endif
-    #else // SCARA
-      #error "AUTO_BED_LEVELING_UBL not supported for SCARA printers."
-    #endif
-  #endif
-  #if DISABLED(NEWPANEL)
+  #if IS_SCARA
+    #error "AUTO_BED_LEVELING_UBL does not yet support SCARA printers."
+  #elif DISABLED(NEWPANEL)
     #error "AUTO_BED_LEVELING_UBL requires an LCD controller."
   #endif
-#elif ENABLED(UBL_DELTA)
-  #error "UBL_DELTA requires AUTO_BED_LEVELING_UBL."
 #endif
 
 /**
@@ -603,10 +592,8 @@ static_assert(1 >= 0
   /**
    * Delta and SCARA have limited bed leveling options
    */
-  #if IS_KINEMATIC
-    #if DISABLED(AUTO_BED_LEVELING_BILINEAR) && DISABLED(UBL_DELTA)
-      #error "Only AUTO_BED_LEVELING_BILINEAR or AUTO_BED_LEVELING_UBL with UBL_DELTA support DELTA and SCARA bed leveling."
-    #endif
+  #if IS_SCARA && DISABLED(AUTO_BED_LEVELING_BILINEAR)
+    #error "Only AUTO_BED_LEVELING_BILINEAR currently supports SCARA bed leveling."
   #endif
 
   /**

Marlin/configuration_store.cpp

@@ -342,7 +342,7 @@ void MarlinSettings::postprocess() {
     #if ENABLED(MESH_BED_LEVELING)
       // Compile time test that sizeof(mbl.z_values) is as expected
       static_assert(
-        sizeof(mbl.z_values) == (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y) * sizeof(mbl.z_values[0][0]),
+        sizeof(mbl.z_values) == GRID_MAX_POINTS * sizeof(mbl.z_values[0][0]),
         "MBL Z array is the wrong size."
       );
       const bool leveling_is_on = TEST(mbl.status, MBL_STATUS_HAS_MESH_BIT);
@@ -386,7 +386,7 @@ void MarlinSettings::postprocess() {
     #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
       // Compile time test that sizeof(z_values) is as expected
       static_assert(
-        sizeof(z_values) == (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y) * sizeof(z_values[0][0]),
+        sizeof(z_values) == GRID_MAX_POINTS * sizeof(z_values[0][0]),
         "Bilinear Z array is the wrong size."
       );
       const uint8_t grid_max_x = GRID_MAX_POINTS_X, grid_max_y = GRID_MAX_POINTS_Y;

Marlin/planner.cpp

@@ -534,12 +534,12 @@ void Planner::check_axes_activity() {
    */
   void Planner::apply_leveling(float &lx, float &ly, float &lz) {
 
-    #if ENABLED(AUTO_BED_LEVELING_UBL) && ENABLED(UBL_DELTA)  // probably should also be enabled for UBL without UBL_DELTA
+    #if ENABLED(AUTO_BED_LEVELING_UBL) && UBL_DELTA  // probably should also be enabled for UBL without UBL_DELTA
       if (!ubl.state.active) return;
       #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
         // if z_fade_height enabled (nonzero) and raw_z above it, no leveling required
         if ((planner.z_fade_height) && (planner.z_fade_height <= RAW_Z_POSITION(lz))) return;
-        lz += ubl.state.z_offset + ( ubl.get_z_correction(lx,ly) * ubl.fade_scaling_factor_for_z(lz));
+        lz += ubl.state.z_offset + ubl.get_z_correction(lx,ly) * ubl.fade_scaling_factor_for_z(lz);
       #else // no fade
         lz += ubl.state.z_offset + ubl.get_z_correction(lx,ly);
       #endif // FADE
@@ -598,13 +598,13 @@ void Planner::check_axes_activity() {
 
   void Planner::unapply_leveling(float logical[XYZ]) {
 
-    #if ENABLED(AUTO_BED_LEVELING_UBL) && ENABLED(UBL_DELTA)
+    #if ENABLED(AUTO_BED_LEVELING_UBL) && UBL_DELTA
 
-      if ( ubl.state.active ) {
+      if (ubl.state.active) {
 
-        float z_leveled = RAW_Z_POSITION(logical[Z_AXIS]);
-        float z_ublmesh = ubl.get_z_correction(logical[X_AXIS],logical[Y_AXIS]);
-        float z_unlevel = z_leveled - ubl.state.z_offset - z_ublmesh;
+        const float z_leveled = RAW_Z_POSITION(logical[Z_AXIS]),
+                    z_ublmesh = ubl.get_z_correction(logical[X_AXIS], logical[Y_AXIS]);
+              float z_unlevel = z_leveled - ubl.state.z_offset - z_ublmesh;
 
         #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
 
@@ -616,9 +616,9 @@ void Planner::check_axes_activity() {
           //    so U(1-M/H)==L-O-M
           //    so U==(L-O-M)/(1-M/H) for U<H
 
-          if ( planner.z_fade_height ) {
-            float z_unfaded = z_unlevel / ( 1.0 - ( z_ublmesh * planner.inverse_z_fade_height ));
-            if ( z_unfaded < planner.z_fade_height )  // don't know until after compute
+          if (planner.z_fade_height) {
+            float z_unfaded = z_unlevel / (1.0 - z_ublmesh * planner.inverse_z_fade_height);
+            if (z_unfaded < planner.z_fade_height)  // don't know until after compute
               z_unlevel = z_unfaded;
           }
 

Marlin/ubl_G29.cpp

@@ -209,7 +209,7 @@
    *                    Mesh Validation Pattern phase.   Please note that you are populating your mesh with unverified
    *                    numbers.  You should use some scrutiny and caution.
    *
-   *   P4    Phase 4    Fine tune the Mesh. The Delta Mesh Compensation System assume the existance of
+   *   P4    Phase 4    Fine tune the Mesh. The Delta Mesh Compensation System assume the existence of
    *                    an LCD Panel. It is possible to fine tune the mesh without the use of an LCD Panel.
    *                    (More work and details on doing this later!)
    *                    The System will search for the closest Mesh Point to the nozzle. It will move the
@@ -328,7 +328,8 @@
       return;
     }
 
-    if (!code_seen('N') && axis_unhomed_error(true, true, true))  // Don't allow auto-leveling without homing first
+    // Don't allow auto-leveling without homing first
+    if (!code_seen('N') && axis_unhomed_error(true, true, true)) // Warning! Use of 'N' flouts established standards.
       home_all_axes();
 
     if (g29_parameter_parsing()) return; // abort if parsing the simple parameters causes a problem,
@@ -385,7 +386,7 @@
 
     if (code_seen('J')) {
       ubl.save_ubl_active_state_and_disable();
-      ubl.tilt_mesh_based_on_probed_grid(code_seen('O') || code_seen('M'));
+      ubl.tilt_mesh_based_on_probed_grid(code_seen('O') || code_seen('M')); // Warning! Use of 'M' flouts established standards.
       ubl.restore_ubl_active_state_and_leave();
     }
 
@@ -419,7 +420,7 @@
             SERIAL_PROTOCOLLNPGM(").\n");
           }
           ubl.probe_entire_mesh(x_pos + X_PROBE_OFFSET_FROM_EXTRUDER, y_pos + Y_PROBE_OFFSET_FROM_EXTRUDER,
-                            code_seen('O') || code_seen('M'), code_seen('E'), code_seen('U'));
+                            code_seen('O') || code_seen('M'), code_seen('E'), code_seen('U')); // Warning! Use of 'M' flouts established standards.
           break;
 
         case 2: {
@@ -468,7 +469,7 @@
             return;
           }
 
-          manually_probe_remaining_mesh(x_pos, y_pos, height, card_thickness, code_seen('O') || code_seen('M'));
+          manually_probe_remaining_mesh(x_pos, y_pos, height, card_thickness, code_seen('O') || code_seen('M')); // Warning! Use of 'M' flouts established standards.
           SERIAL_PROTOCOLLNPGM("G29 P2 finished.");
         } break;
 
@@ -504,7 +505,7 @@
           //
           // Fine Tune (i.e., Edit) the Mesh
           //
-          fine_tune_mesh(x_pos, y_pos, code_seen('O') || code_seen('M'));
+          fine_tune_mesh(x_pos, y_pos, code_seen('O') || code_seen('M')); // Warning! Use of 'M' flouts established standards.
           break;
 
         case 5: ubl.find_mean_mesh_height(); break;
@@ -549,7 +550,7 @@
     // When we are fully debugged, the EEPROM dump command will get deleted also. But
     // right now, it is good to have the extra information. Soon... we prune this.
     //
-    if (code_seen('j')) g29_eeprom_dump();   // EEPROM Dump
+    if (code_seen('j')) g29_eeprom_dump(); // Warning! Use of lowercase flouts established standards.
 
     //
     // When we are fully debugged, this may go away. But there are some valid
@@ -613,7 +614,7 @@
       SERIAL_PROTOCOLLNPGM("Done.\n");
     }
 
-    if (code_seen('O') || code_seen('M'))
+    if (code_seen('O') || code_seen('M')) // Warning! Use of 'M' flouts established standards.
       ubl.display_map(code_has_value() ? code_value_int() : 0);
 
     if (code_seen('Z')) {
@@ -1048,8 +1049,8 @@
 
     repeat_flag = code_seen('R');
     if (repeat_flag) {
-      repetition_cnt = code_has_value() ? code_value_int() : (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y);
-      repetition_cnt = min(repetition_cnt, (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y));
+      repetition_cnt = code_has_value() ? code_value_int() : GRID_MAX_POINTS;
+      NOMORE(repetition_cnt, GRID_MAX_POINTS);
       if (repetition_cnt < 1) {
         SERIAL_PROTOCOLLNPGM("?(R)epetition count invalid (1+).\n");
         return UBL_ERR;
@@ -1128,8 +1129,8 @@
       SERIAL_PROTOCOLLNPGM("Invalid map type.\n");
       return UBL_ERR;
     }
-
-    if (code_seen('M')) {     // Check if a map type was specified
+    // Check if a map type was specified
+    if (code_seen('M')) { // Warning! Use of 'M' flouts established standards.
       map_type = code_has_value() ? code_value_int() : 0;
       if (!WITHIN(map_type, 0, 1)) {
         SERIAL_PROTOCOLLNPGM("Invalid map type.\n");

Marlin/ubl_motion.cpp

@@ -474,20 +474,10 @@
     set_current_to_destination();
   }
 
-
-  #ifdef UBL_DELTA
-
-    #define COPY_XYZE( target, source ) { \
-                target[X_AXIS] = source[X_AXIS]; \
-                target[Y_AXIS] = source[Y_AXIS]; \
-                target[Z_AXIS] = source[Z_AXIS]; \
-                target[E_AXIS] = source[E_AXIS]; \
-            }
+  #if UBL_DELTA
 
     #if IS_SCARA // scale the feed rate from mm/s to degrees/s
-      static float scara_feed_factor;
-      static float scara_oldA;
-      static float scara_oldB;
+      static float scara_feed_factor, scara_oldA, scara_oldB;
     #endif
 
     // We don't want additional apply_leveling() performed by regular buffer_line or buffer_line_kinematic, 
@@ -501,18 +491,18 @@
         float feedrate = fr_mm_s;
 
         #if IS_SCARA // scale the feed rate from mm/s to degrees/s
-          float adiff = abs(delta[A_AXIS] - scara_oldA);
-          float bdiff = abs(delta[B_AXIS] - scara_oldB);
+          float adiff = abs(delta[A_AXIS] - scara_oldA),
+                bdiff = abs(delta[B_AXIS] - scara_oldB);
           scara_oldA = delta[A_AXIS];
           scara_oldB = delta[B_AXIS];
           feedrate = max(adiff, bdiff) * scara_feed_factor;
         #endif
 
-        planner._buffer_line( delta[A_AXIS], delta[B_AXIS], delta[C_AXIS], ltarget[E_AXIS], feedrate, extruder );
+        planner._buffer_line(delta[A_AXIS], delta[B_AXIS], delta[C_AXIS], ltarget[E_AXIS], feedrate, extruder);
 
       #else // cartesian
 
-        planner._buffer_line( ltarget[X_AXIS], ltarget[Y_AXIS], ltarget[Z_AXIS], ltarget[E_AXIS], fr_mm_s, extruder );
+        planner._buffer_line(ltarget[X_AXIS], ltarget[Y_AXIS], ltarget[Z_AXIS], ltarget[E_AXIS], fr_mm_s, extruder);
 
       #endif
     }
@@ -525,7 +515,7 @@
 
     static bool ubl_prepare_linear_move_to(const float ltarget[XYZE], const float &feedrate) {
 
-      if ( ! position_is_reachable_xy( ltarget[X_AXIS], ltarget[Y_AXIS] ))  // fail if moving outside reachable boundary
+      if (!position_is_reachable_xy(ltarget[X_AXIS], ltarget[Y_AXIS]))  // fail if moving outside reachable boundary
         return true; // did not move, so current_position still accurate
 
       const float difference[XYZE] = {    // cartesian distances moved in XYZE
@@ -533,21 +523,21 @@
                     ltarget[Y_AXIS] - current_position[Y_AXIS],
                     ltarget[Z_AXIS] - current_position[Z_AXIS],
                     ltarget[E_AXIS] - current_position[E_AXIS]
-                    };
+                  };
 
-      float cartesian_xy_mm = sqrtf( sq(difference[X_AXIS]) + sq(difference[Y_AXIS]) ); // total horizontal xy distance
+      const float cartesian_xy_mm = HYPOT(difference[X_AXIS], difference[Y_AXIS]);        // total horizontal xy distance
 
       #if IS_KINEMATIC
-        float    seconds  = cartesian_xy_mm / feedrate;                                   // seconds to move xy distance at requested rate
-        uint16_t segments = lroundf( delta_segments_per_second * seconds );               // preferred number of segments for distance @ feedrate
-        uint16_t seglimit = lroundf( cartesian_xy_mm * (1.0/(DELTA_SEGMENT_MIN_LENGTH))); // number of segments at minimum segment length
-        NOMORE( segments, seglimit );                                                     // limit to minimum segment length (fewer segments)
+        const float seconds = cartesian_xy_mm / feedrate;                                 // seconds to move xy distance at requested rate
+        uint16_t segments = lroundf(delta_segments_per_second * seconds),                // preferred number of segments for distance @ feedrate
+                 seglimit = lroundf(cartesian_xy_mm * (1.0 / (DELTA_SEGMENT_MIN_LENGTH))); // number of segments at minimum segment length
+        NOMORE(segments, seglimit);                                                     // limit to minimum segment length (fewer segments)
       #else
-        uint16_t segments = lroundf( cartesian_xy_mm * (1.0/(DELTA_SEGMENT_MIN_LENGTH))); // cartesian fixed segment length
+        uint16_t segments = lroundf(cartesian_xy_mm * (1.0 / (DELTA_SEGMENT_MIN_LENGTH))); // cartesian fixed segment length
       #endif
 
-      NOLESS( segments, 1 );                // must have at least one segment
-      float inv_segments = 1.0 / segments;  // divide once, multiply thereafter
+      NOLESS(segments, 1);                        // must have at least one segment
+      const float inv_segments = 1.0 / segments;  // divide once, multiply thereafter
 
       #if IS_SCARA // scale the feed rate from mm/s to degrees/s
         scara_feed_factor = cartesian_xy_mm * inv_segments * feedrate;
@@ -560,57 +550,53 @@
                     difference[Y_AXIS] * inv_segments,
                     difference[Z_AXIS] * inv_segments,
                     difference[E_AXIS] * inv_segments 
-                    };
+                  };
 
       // Note that E segment distance could vary slightly as z mesh height
       // changes for each segment, but small enough to ignore.
 
-      bool above_fade_height = false;
-      #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
-        if (( planner.z_fade_height != 0 ) && 
-            ( planner.z_fade_height < RAW_Z_POSITION(ltarget[Z_AXIS]) )) {
-          above_fade_height = true;
-          }
-      #endif
+      const bool above_fade_height = (
+        #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
+          planner.z_fade_height != 0 && planner.z_fade_height < RAW_Z_POSITION(ltarget[Z_AXIS])
+        #else
+          false
+        #endif
+      );
 
       // Only compute leveling per segment if ubl active and target below z_fade_height.
 
-      if (( ! ubl.state.active ) || ( above_fade_height )) {   // no mesh leveling
+      if (!ubl.state.active || above_fade_height) {   // no mesh leveling
 
         const float z_offset = ubl.state.active ? ubl.state.z_offset : 0.0;
 
-        float seg_dest[XYZE];                     // per-segment destination,
-        COPY_XYZE( seg_dest, current_position );  // starting from current position
+        float seg_dest[XYZE];              // per-segment destination,
+        COPY(seg_dest, current_position);  // starting from current position
 
         while (--segments) {
           LOOP_XYZE(i) seg_dest[i] += segment_distance[i];
           float ztemp = seg_dest[Z_AXIS];
           seg_dest[Z_AXIS] += z_offset;
-          ubl_buffer_line_segment( seg_dest, feedrate, active_extruder );
+          ubl_buffer_line_segment(seg_dest, feedrate, active_extruder);
           seg_dest[Z_AXIS] = ztemp;
         }
 
         // Since repeated adding segment_distance accumulates small errors, final move to exact destination.
-        COPY_XYZE( seg_dest, ltarget );
+        COPY(seg_dest, ltarget);
         seg_dest[Z_AXIS] += z_offset;
-        ubl_buffer_line_segment( seg_dest, feedrate, active_extruder );
+        ubl_buffer_line_segment(seg_dest, feedrate, active_extruder);
         return false; // moved but did not set_current_to_destination();
       }
 
       // Otherwise perform per-segment leveling
 
-      #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
-        float fade_scaling_factor = ubl.fade_scaling_factor_for_z(ltarget[Z_AXIS]);
-      #endif
-
       float seg_dest[XYZE];  // per-segment destination, initialize to first segment
       LOOP_XYZE(i) seg_dest[i] = current_position[i] + segment_distance[i];
 
       const float& dx_seg = segment_distance[X_AXIS];  // alias for clarity
       const float& dy_seg = segment_distance[Y_AXIS];
 
-      float rx = RAW_X_POSITION(seg_dest[X_AXIS]);  // assume raw vs logical coordinates shifted but not scaled.
-      float ry = RAW_Y_POSITION(seg_dest[Y_AXIS]);
+      float rx = RAW_X_POSITION(seg_dest[X_AXIS]),  // assume raw vs logical coordinates shifted but not scaled.
+            ry = RAW_Y_POSITION(seg_dest[Y_AXIS]);
 
       do {  // for each mesh cell encountered during the move
 
@@ -621,74 +607,75 @@
         // in top of loop and again re-find same adjacent cell and use it, just less efficient
         // for mesh inset area.
 
-        int8_t cell_xi = (rx - (UBL_MESH_MIN_X)) * (1.0 / (MESH_X_DIST));
-               cell_xi = constrain( cell_xi, 0, (GRID_MAX_POINTS_X) - 1 );
+        int8_t cell_xi = (rx - (UBL_MESH_MIN_X)) * (1.0 / (MESH_X_DIST)),
+               cell_yi = (ry - (UBL_MESH_MIN_Y)) * (1.0 / (MESH_X_DIST));
 
-        int8_t cell_yi = (ry - (UBL_MESH_MIN_Y)) * (1.0 / (MESH_X_DIST));
-               cell_yi = constrain( cell_yi, 0, (GRID_MAX_POINTS_Y) - 1 );
+        cell_xi = constrain(cell_xi, 0, (GRID_MAX_POINTS_X) - 1);
+        cell_yi = constrain(cell_yi, 0, (GRID_MAX_POINTS_Y) - 1);
 
         // float x0 = (UBL_MESH_MIN_X) + ((MESH_X_DIST) * cell_xi );         // lower left cell corner
         // float y0 = (UBL_MESH_MIN_Y) + ((MESH_Y_DIST) * cell_yi );         // lower left cell corner
         // float x1 = x0 + MESH_X_DIST;                                      // upper right cell corner
         // float y1 = y0 + MESH_Y_DIST;                                      // upper right cell corner
 
-        float x0 = pgm_read_float(&(ubl.mesh_index_to_xpos[cell_xi  ]));  // 64 byte table lookup avoids mul+add
-        float y0 = pgm_read_float(&(ubl.mesh_index_to_ypos[cell_yi  ]));  // 64 byte table lookup avoids mul+add
-        float x1 = pgm_read_float(&(ubl.mesh_index_to_xpos[cell_xi+1]));  // 64 byte table lookup avoids mul+add
-        float y1 = pgm_read_float(&(ubl.mesh_index_to_ypos[cell_yi+1]));  // 64 byte table lookup avoids mul+add
+        const float x0 = pgm_read_float(&(ubl.mesh_index_to_xpos[cell_xi  ])),  // 64 byte table lookup avoids mul+add
+                    y0 = pgm_read_float(&(ubl.mesh_index_to_ypos[cell_yi  ])),  // 64 byte table lookup avoids mul+add
+                    x1 = pgm_read_float(&(ubl.mesh_index_to_xpos[cell_xi+1])),  // 64 byte table lookup avoids mul+add
+                    y1 = pgm_read_float(&(ubl.mesh_index_to_ypos[cell_yi+1])),  // 64 byte table lookup avoids mul+add
+
+                    cx = rx - x0,   // cell-relative x
+                    cy = ry - y0;   // cell-relative y
 
-        float cx = rx - x0;   // cell-relative x
-        float cy = ry - y0;   // cell-relative y
+        float z_x0y0 = ubl.z_values[cell_xi  ][cell_yi  ],  // z at lower left corner
+              z_x1y0 = ubl.z_values[cell_xi+1][cell_yi  ],  // z at upper left corner
+              z_x0y1 = ubl.z_values[cell_xi  ][cell_yi+1],  // z at lower right corner
+              z_x1y1 = ubl.z_values[cell_xi+1][cell_yi+1];  // z at upper right corner
 
-        float z_x0y0 = ubl.z_values[cell_xi  ][cell_yi  ];  // z at lower left corner
-        float z_x1y0 = ubl.z_values[cell_xi+1][cell_yi  ];  // z at upper left corner
-        float z_x0y1 = ubl.z_values[cell_xi  ][cell_yi+1];  // z at lower right corner
-        float z_x1y1 = ubl.z_values[cell_xi+1][cell_yi+1];  // z at upper right corner
+        if (isnan(z_x0y0)) z_x0y0 = 0;              // ideally activating ubl.state.active (G29 A) 
+        if (isnan(z_x1y0)) z_x1y0 = 0;              //   should refuse if any invalid mesh points
+        if (isnan(z_x0y1)) z_x0y1 = 0;              //   in order to avoid isnan tests per cell,
+        if (isnan(z_x1y1)) z_x1y1 = 0;              //   thus guessing zero for undefined points
 
-        if ( isnan( z_x0y0 )) z_x0y0 = 0;     // ideally activating ubl.state.active (G29 A) 
-        if ( isnan( z_x1y0 )) z_x1y0 = 0;     //   should refuse if any invalid mesh points
-        if ( isnan( z_x0y1 )) z_x0y1 = 0;     //   in order to avoid isnan tests per cell,
-        if ( isnan( z_x1y1 )) z_x1y1 = 0;     //   thus guessing zero for undefined points
+        const float z_xmy0 = (z_x1y0 - z_x0y0) * (1.0 / (MESH_X_DIST)),   // z slope per x along y0 (lower left to lower right)
+                    z_xmy1 = (z_x1y1 - z_x0y1) * (1.0 / (MESH_X_DIST));   // z slope per x along y1 (upper left to upper right)
 
-        float z_xmy0 = (z_x1y0 - z_x0y0) * (1.0/MESH_X_DIST);   // z slope per x along y0 (lower left to lower right)
-        float z_xmy1 = (z_x1y1 - z_x0y1) * (1.0/MESH_X_DIST);   // z slope per x along y1 (upper left to upper right)
+              float z_cxy0 = z_x0y0 + z_xmy0 * cx;          // z height along y0 at cx
 
-        float z_cxy0 = z_x0y0 + z_xmy0 * cx;        // z height along y0 at cx
-        float z_cxy1 = z_x0y1 + z_xmy1 * cx;        // z height along y1 at cx
-        float z_cxyd = z_cxy1 - z_cxy0;             // z height difference along cx from y0 to y1
+        const float z_cxy1 = z_x0y1 + z_xmy1 * cx,          // z height along y1 at cx
+                    z_cxyd = z_cxy1 - z_cxy0;               // z height difference along cx from y0 to y1
 
-        float z_cxym = z_cxyd * (1.0/MESH_Y_DIST);  // z slope per y along cx from y0 to y1
-        float z_cxcy = z_cxy0 + z_cxym * cy;        // z height along cx at cy
+              float z_cxym = z_cxyd * (1.0 / (MESH_Y_DIST)),  // z slope per y along cx from y0 to y1
+                    z_cxcy = z_cxy0 + z_cxym * cy;          // z height along cx at cy
 
         // As subsequent segments step through this cell, the z_cxy0 intercept will change
         // and the z_cxym slope will change, both as a function of cx within the cell, and
         // each change by a constant for fixed segment lengths.
 
-        float z_sxy0 = z_xmy0 * dx_seg;                                   // per-segment adjustment to z_cxy0
-        float z_sxym = ( z_xmy1 - z_xmy0 ) * (1.0/MESH_Y_DIST) * dx_seg;  // per-segment adjustment to z_cxym
+        const float z_sxy0 = z_xmy0 * dx_seg,                                     // per-segment adjustment to z_cxy0
+                    z_sxym = (z_xmy1 - z_xmy0) * (1.0 / (MESH_Y_DIST)) * dx_seg;  // per-segment adjustment to z_cxym
 
         do {  // for all segments within this mesh cell
 
           z_cxcy += ubl.state.z_offset;
 
-          if ( --segments == 0 ) {          // this is last segment, use ltarget for exact
-            COPY_XYZE( seg_dest, ltarget );
+          if (--segments == 0) {          // this is last segment, use ltarget for exact
+            COPY(seg_dest, ltarget);
             seg_dest[Z_AXIS] += z_cxcy;
-            ubl_buffer_line_segment( seg_dest, feedrate, active_extruder );
+            ubl_buffer_line_segment(seg_dest, feedrate, active_extruder);
             return false;   // did not set_current_to_destination()
           }
 
-          float z_orig = seg_dest[Z_AXIS];    // remember the pre-leveled segment z value
-          seg_dest[Z_AXIS] = z_orig + z_cxcy; // adjust segment z height per mesh leveling
-          ubl_buffer_line_segment( seg_dest, feedrate, active_extruder );
-          seg_dest[Z_AXIS] = z_orig;          // restore pre-leveled z before incrementing
+          const float z_orig = seg_dest[Z_AXIS];  // remember the pre-leveled segment z value
+          seg_dest[Z_AXIS] = z_orig + z_cxcy;     // adjust segment z height per mesh leveling
+          ubl_buffer_line_segment(seg_dest, feedrate, active_extruder);
+          seg_dest[Z_AXIS] = z_orig;              // restore pre-leveled z before incrementing
 
           LOOP_XYZE(i) seg_dest[i] += segment_distance[i];  // adjust seg_dest for next segment
 
           cx += dx_seg;
           cy += dy_seg;
 
-          if ( !WITHIN(cx,0,MESH_X_DIST) || !WITHIN(cy,0,MESH_Y_DIST)) {  // done within this cell, break to next
+          if (!WITHIN(cx, 0, MESH_X_DIST) || !WITHIN(cy, 0, MESH_Y_DIST)) {  // done within this cell, break to next
             rx = RAW_X_POSITION(seg_dest[X_AXIS]);
             ry = RAW_Y_POSITION(seg_dest[Y_AXIS]);
             break;  

Marlin/ultralcd.cpp

@@ -1430,17 +1430,13 @@ void kill_screen(const char* lcd_msg) {
     #endif
 
     // LCD probed points are from defaults
-    constexpr uint8_t total_probe_points =
-      #if ABL_GRID
-        (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y)
-      #elif ENABLED(AUTO_BED_LEVELING_3POINT)
-        int(3)
-      #elif ENABLED(AUTO_BED_LEVELING_UBL)
-        (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y)
-      #elif ENABLED(MESH_BED_LEVELING)
-        (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y)
+    constexpr uint8_t total_probe_points = (
+      #if ENABLED(AUTO_BED_LEVELING_3POINT)
+        3
+      #elif ABL_GRID || ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(MESH_BED_LEVELING)
+        GRID_MAX_POINTS
       #endif
-    ;
+    );
 
     #if ENABLED(MESH_BED_LEVELING)
 

buildroot/share/git/mfdoc

@@ -16,12 +16,6 @@ if [[ $ORG != "MarlinFirmware" || $REPO != "MarlinDocumentation" ]]; then
   exit
 fi
 
-if [[ $BRANCH != "master" ]]; then
-  echo "Stashing changes and changing to master."
-  git stash
-  git checkout master
-fi
-
 opensite() {
   TOOL=$(which gnome-open xdg-open open | awk '{ print $1 }')
   URL="http://127.0.0.1:4000/"
@@ -40,9 +34,3 @@ echo "Previewing MarlinDocumentation..."
 ( sleep 45; opensite ) &
 
 bundle exec jekyll serve --watch --incremental
-
-if [[ $BRANCH != "master" ]]; then
-  echo "Restoring branch '$BRANCH'"
-  git checkout $BRANCH
-  git stash pop
-fi

buildroot/share/git/mfpub

@@ -30,26 +30,25 @@ if [[ $BRANCH == "gh-pages" ]]; then
   exit
 fi
 
-if [[ $BRANCH != "master" ]]; then
-  echo "Stashing any changes to files..."
-  echo "Don't forget to update and push 'master'!"
-  # GOJF Card
-  git stash
-fi
+echo "Stashing any changes to files..."
+echo "Don't forget to update and push 'master'!"
+# GOJF Card
+git stash
 
 COMMIT=$( git log --format="%H" -n 1 )
 
 # Clean out changes and other junk in the branch
-git reset --hard
 git clean -d -f
 
 # Push 'master' to the fork and make a proper PR...
 if [[ $BRANCH == "master" ]]; then
 
   # Allow working directly with the main fork
+  echo
   echo -n "Pushing to origin/master... "
   git push -f origin
 
+  echo
   echo -n "Pushing to upstream/master... "
   git push -f upstream
 
@@ -58,6 +57,7 @@ else
   if [ -z "$(git branch -vv | grep ^\* | grep \\[origin)" ]; then
     firstpush
   else
+    echo
     echo -n "Pushing to origin/$BRANCH... "
     git push -f origin
   fi
@@ -79,6 +79,7 @@ fi
 # mv ./_plugins/jekyll-press.rb-disabled ./_plugins/jekyll-press.rb
 # bundle install
 
+echo
 echo "Generating MarlinDocumentation..."
 
 # build the site statically and proof it