Pending refactor tweaks

Marlin/src/core/serial.cpp

 
 void print_xyz(PGM_P const prefix, PGM_P const suffix, const float &x, const float &y, const float &z) {
   serialprintPGM(prefix);
-  SERIAL_CHAR('(');
-  SERIAL_ECHO(x);
-  SERIAL_ECHOPAIR(", ", y, ", ", z);
-  SERIAL_CHAR(')');
+  SERIAL_ECHOPAIR(" " MSG_X, x, " " MSG_Y, y, " " MSG_Z, z);
   if (suffix) serialprintPGM(suffix); else SERIAL_EOL();
 }
 

Marlin/src/feature/babystep.cpp

 
 Babystep babystep;
 
-volatile int16_t Babystep::todo[BS_TODO_AXIS(Z_AXIS) + 1];
+volatile int16_t Babystep::steps[BS_TODO_AXIS(Z_AXIS) + 1];
 
 #if HAS_LCD_MENU || ENABLED(EXTENSIBLE_UI)
   int16_t Babystep::accum;
 #endif
 
 void Babystep::step_axis(const AxisEnum axis) {
-  const int16_t curTodo = todo[BS_TODO_AXIS(axis)]; // get rid of volatile for performance
+  const int16_t curTodo = steps[BS_TODO_AXIS(axis)]; // get rid of volatile for performance
   if (curTodo) {
     stepper.babystep((AxisEnum)axis, curTodo > 0);
-    if (curTodo > 0) todo[BS_TODO_AXIS(axis)]--; else todo[BS_TODO_AXIS(axis)]++;
+    if (curTodo > 0) steps[BS_TODO_AXIS(axis)]--; else steps[BS_TODO_AXIS(axis)]++;
   }
 }
 
         case CORE_AXIS_1: // X on CoreXY and CoreXZ, Y on CoreYZ
           BSA_ENABLE(CORE_AXIS_1);
           BSA_ENABLE(CORE_AXIS_2);
-          todo[CORE_AXIS_1] += distance * 2;
-          todo[CORE_AXIS_2] += distance * 2;
+          steps[CORE_AXIS_1] += distance * 2;
+          steps[CORE_AXIS_2] += distance * 2;
           break;
         case CORE_AXIS_2: // Y on CoreXY, Z on CoreXZ and CoreYZ
           BSA_ENABLE(CORE_AXIS_1);
           BSA_ENABLE(CORE_AXIS_2);
-          todo[CORE_AXIS_1] += CORESIGN(distance * 2);
-          todo[CORE_AXIS_2] -= CORESIGN(distance * 2);
+          steps[CORE_AXIS_1] += CORESIGN(distance * 2);
+          steps[CORE_AXIS_2] -= CORESIGN(distance * 2);
           break;
         case NORMAL_AXIS: // Z on CoreXY, Y on CoreXZ, X on CoreYZ
         default:
           BSA_ENABLE(NORMAL_AXIS);
-          todo[NORMAL_AXIS] += distance;
+          steps[NORMAL_AXIS] += distance;
           break;
       }
     #elif CORE_IS_XZ || CORE_IS_YZ
       // Only Z stepping needs to be handled here
       BSA_ENABLE(CORE_AXIS_1);
       BSA_ENABLE(CORE_AXIS_2);
-      todo[CORE_AXIS_1] += CORESIGN(distance * 2);
-      todo[CORE_AXIS_2] -= CORESIGN(distance * 2);
+      steps[CORE_AXIS_1] += CORESIGN(distance * 2);
+      steps[CORE_AXIS_2] -= CORESIGN(distance * 2);
     #else
       BSA_ENABLE(Z_AXIS);
-      todo[Z_AXIS] += distance;
+      steps[Z_AXIS] += distance;
     #endif
   #else
     #if ENABLED(BABYSTEP_XY)
     #else
       BSA_ENABLE(Z_AXIS);
     #endif
-    todo[BS_TODO_AXIS(axis)] += distance;
+    steps[BS_TODO_AXIS(axis)] += distance;
   #endif
   #if ENABLED(BABYSTEP_ALWAYS_AVAILABLE)
     gcode.reset_stepper_timeout();

Marlin/src/feature/babystep.h

 
 class Babystep {
 public:
-  static volatile int16_t todo[BS_TODO_AXIS(Z_AXIS) + 1];
+  static volatile int16_t steps[BS_TODO_AXIS(Z_AXIS) + 1];
+
   #if HAS_LCD_MENU || ENABLED(EXTENSIBLE_UI)
+
     static int16_t accum;                                     // Total babysteps in current edit
+
     #if ENABLED(BABYSTEP_DISPLAY_TOTAL)
       static int16_t axis_total[BS_TOTAL_AXIS(Z_AXIS) + 1];   // Total babysteps since G28
       static inline void reset_total(const AxisEnum axis) {
-        #if ENABLED(BABYSTEP_XY)
-          if (axis == Z_AXIS)
-        #endif
-            axis_total[BS_TOTAL_AXIS(axis)] = 0;
+        if (true
+          #if ENABLED(BABYSTEP_XY)
+            && axis == Z_AXIS
+          #endif
+        ) axis_total[BS_TOTAL_AXIS(axis)] = 0;
       }
     #endif
+
   #endif
+
   static void add_steps(const AxisEnum axis, const int16_t distance);
   static void add_mm(const AxisEnum axis, const float &mm);
   static void task();

Marlin/src/module/stepper.h

 
 #include "../inc/MarlinConfig.h"
 
+#include "planner.h"
+#include "stepper/indirection.h"
+#ifdef __AVR__
+  #include "speed_lookuptable.h"
+#endif
+
 // Disable multiple steps per ISR
 //#define DISABLE_MULTI_STEPPING
 
 //
 // Stepper class definition
 //
-
-#include "stepper/indirection.h"
-
-#ifdef __AVR__
-  #include "speed_lookuptable.h"
-#endif
-
-#include "planner.h"
-#include "../core/language.h"
-
 class Stepper {
 
   public:

buildroot/share/tests/megaatmega1280-tests

 # Test MESH_BED_LEVELING feature, with LCD
 #
 restore_configs
-opt_enable SPINDLE_FEATURE MESH_BED_LEVELING G26_MESH_VALIDATION MESH_G28_REST_ORIGIN LCD_BED_LEVELING MESH_EDIT_MENU ULTIMAKERCONTROLLER
+opt_enable SPINDLE_FEATURE ULTIMAKERCONTROLLER LCD_BED_LEVELING \
+           MESH_BED_LEVELING ENABLE_LEVELING_FADE_HEIGHT MESH_G28_REST_ORIGIN \
+           G26_MESH_VALIDATION MESH_EDIT_MENU
 exec_test $1 $2 "Spindle, MESH_BED_LEVELING, and LCD"