Backlash cleanup (#13659)

…And save backlash, fil. sensor, ExtUI userdata to EEPROM.

Marlin/src/Marlin.cpp

 
   queue_setup();
 
+  // UI must be initialized before EEPROM
+  // (because EEPROM code calls the UI).
+  ui.init();
+  ui.reset_status();
+
+  #if HAS_SPI_LCD && ENABLED(SHOW_BOOTSCREEN)
+    ui.show_bootscreen();
+  #endif
+
   #if ENABLED(SDIO_SUPPORT) && SD_DETECT_PIN == -1
     // Auto-mount the SD for EEPROM.dat emulation
     if (!card.isDetected()) card.initsd();
     fanmux_init();
   #endif
 
-  ui.init();
-  ui.reset_status();
-
-  #if HAS_SPI_LCD && ENABLED(SHOW_BOOTSCREEN)
-    ui.show_bootscreen();
-  #endif
-
   #if ENABLED(MIXING_EXTRUDER)
     mixer.init();
   #endif

Marlin/src/feature/backlash.cpp

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../Marlin.h"
+
+#if ENABLED(BACKLASH_COMPENSATION)
+
+#include "backlash.h"
+#include "../module/planner.h"
+
+#if ENABLED(BACKLASH_GCODE)
+  uint8_t Backlash::correction = (BACKLASH_CORRECTION) * 0xFF;
+  #ifdef BACKLASH_DISTANCE_MM
+    float Backlash::distance_mm[XYZ] = BACKLASH_DISTANCE_MM;
+  #endif
+  #ifdef BACKLASH_SMOOTHING_MM
+    float Backlash::smoothing_mm = BACKLASH_SMOOTHING_MM;
+  #endif
+#endif
+
+#if ENABLED(MEASURE_BACKLASH_WHEN_PROBING)
+  float Backlash::measured_mm[XYZ] = { 0 };
+  uint8_t Backlash::measured_count[XYZ] = { 0 };
+#endif
+
+Backlash backlash;
+
+/**
+ * To minimize seams in the printed part, backlash correction only adds
+ * steps to the current segment (instead of creating a new segment, which
+ * causes discontinuities and print artifacts).
+ *
+ * With a non-zero BACKLASH_SMOOTHING_MM value the backlash correction is
+ * spread over multiple segments, smoothing out artifacts even more.
+ */
+
+void Backlash::add_correction_steps(const int32_t &da, const int32_t &db, const int32_t &dc, const uint8_t dm, block_t * const block) {
+  static uint8_t last_direction_bits;
+  uint8_t changed_dir = last_direction_bits ^ dm;
+  // Ignore direction change if no steps are taken in that direction
+  if (da == 0) CBI(changed_dir, X_AXIS);
+  if (db == 0) CBI(changed_dir, Y_AXIS);
+  if (dc == 0) CBI(changed_dir, Z_AXIS);
+  last_direction_bits ^= changed_dir;
+
+  if (correction == 0) return;
+
+  #ifdef BACKLASH_SMOOTHING_MM
+    // The segment proportion is a value greater than 0.0 indicating how much residual_error
+    // is corrected for in this segment. The contribution is based on segment length and the
+    // smoothing distance. Since the computation of this proportion involves a floating point
+    // division, defer computation until needed.
+    float segment_proportion = 0;
+
+    // Residual error carried forward across multiple segments, so correction can be applied
+    // to segments where there is no direction change.
+    static int32_t residual_error[XYZ] = { 0 };
+  #else
+    // No leftover residual error from segment to segment
+    int32_t residual_error[XYZ] = { 0 };
+    // No direction change, no correction.
+    if (!changed_dir) return;
+  #endif
+
+  const float f_corr = float(correction) / 255.0f;
+
+  LOOP_XYZ(axis) {
+    if (distance_mm[axis]) {
+      const bool reversing = TEST(dm,axis);
+
+      // When an axis changes direction, add axis backlash to the residual error
+      if (TEST(changed_dir, axis))
+        residual_error[axis] += (reversing ? -f_corr : f_corr) * distance_mm[axis] * planner.settings.axis_steps_per_mm[axis];
+
+      // Decide how much of the residual error to correct in this segment
+      int32_t error_correction = residual_error[axis];
+      #ifdef BACKLASH_SMOOTHING_MM
+        if (error_correction && smoothing_mm != 0) {
+          // Take up a portion of the residual_error in this segment, but only when
+          // the current segment travels in the same direction as the correction
+          if (reversing == (error_correction < 0)) {
+            if (segment_proportion == 0)
+              segment_proportion = MIN(1.0f, block->millimeters / smoothing_mm);
+            error_correction = ceil(segment_proportion * error_correction);
+          }
+          else
+            error_correction = 0; // Don't take up any backlash in this segment, as it would subtract steps
+        }
+      #endif
+      // Making a correction reduces the residual error and modifies delta_mm
+      if (error_correction) {
+        block->steps[axis] += ABS(error_correction);
+        residual_error[axis] -= error_correction;
+      }
+    }
+  }
+}
+
+#if ENABLED(MEASURE_BACKLASH_WHEN_PROBING)
+  #if USES_Z_MIN_PROBE_ENDSTOP
+    #define TEST_PROBE_PIN (READ(Z_MIN_PROBE_PIN) != Z_MIN_PROBE_ENDSTOP_INVERTING)
+  #else
+    #define TEST_PROBE_PIN (READ(Z_MIN_PIN) != Z_MIN_ENDSTOP_INVERTING)
+  #endif
+
+  // Measure Z backlash by raising nozzle in increments until probe deactivates
+  void Backlash::measure_with_probe() {
+    if (measured_count[Z_AXIS] == 255) return;
+
+    float start_height = current_position[Z_AXIS];
+    while (current_position[Z_AXIS] < (start_height + BACKLASH_MEASUREMENT_LIMIT) && TEST_PROBE_PIN)
+      do_blocking_move_to_z(current_position[Z_AXIS] + BACKLASH_MEASUREMENT_RESOLUTION, MMM_TO_MMS(BACKLASH_MEASUREMENT_FEEDRATE));
+
+    // The backlash from all probe points is averaged, so count the number of measurements
+    measured_mm[Z_AXIS] += current_position[Z_AXIS] - start_height;
+    measured_count[Z_AXIS]++;
+  }
+#endif
+
+#endif // BACKLASH_COMPENSATION

Marlin/src/feature/backlash.h

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2019 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/>.
+ *
+ */
+#pragma once
+
+#include "../inc/MarlinConfigPre.h"
+#include "../module/planner.h"
+
+class Backlash {
+public:
+  #if ENABLED(BACKLASH_GCODE)
+    static uint8_t correction;
+    #ifdef BACKLASH_DISTANCE_MM
+      static float distance_mm[XYZ];
+    #endif
+    #ifdef BACKLASH_SMOOTHING_MM
+      static float smoothing_mm;
+    #endif
+    static inline void set_correction(const float &v) { correction = MAX(0, MIN(1.0, v)) * all_on; }
+    static inline float get_correction() { return float(ui8_to_percent(correction)) / 100.0f; }
+  #elif ENABLED(BACKLASH_COMPENSATION)
+    static constexpr uint8_t correction = (BACKLASH_CORRECTION) * 0xFF;
+    #ifdef BACKLASH_DISTANCE_MM
+      static constexpr float distance_mm[XYZ] = BACKLASH_DISTANCE_MM;
+    #endif
+    #ifdef BACKLASH_SMOOTHING_MM
+      static constexpr float smoothing_mm = BACKLASH_SMOOTHING_MM;
+    #endif
+    static inline void set_correction(float) { }
+    static inline float get_correction() { return float(ui8_to_percent(correction)) / 100.0f; }
+  #else
+    static constexpr uint8_t correction = 0;
+    static inline void set_correction(float) { }
+    static inline float get_correction() { return 0; }
+  #endif
+
+  #if ENABLED(MEASURE_BACKLASH_WHEN_PROBING)
+    private:
+      static float measured_mm[XYZ];
+      static uint8_t measured_count[XYZ];
+    public:
+      static void measure_with_probe();
+  #endif
+
+  static inline float get_measurement(const uint8_t e) {
+    // Return the measurement averaged over all readings
+    return (
+      #if ENABLED(MEASURE_BACKLASH_WHEN_PROBING)
+        measured_count[e] > 0 ? measured_mm[e] / measured_count[e] :
+      #endif
+      0
+    );
+  }
+
+  static inline bool has_measurement(const uint8_t e) {
+    return (false
+      #if ENABLED(MEASURE_BACKLASH_WHEN_PROBING)
+        || (measured_count[e] > 0)
+      #endif
+    );
+  }
+
+  static inline bool has_any_measurement() {
+    return has_measurement(X_AXIS) || has_measurement(Y_AXIS) || has_measurement(Z_AXIS);
+  }
+
+  void add_correction_steps(const int32_t &da, const int32_t &db, const int32_t &dc, const uint8_t dm, block_t * const block);
+};
+
+extern Backlash backlash;

Marlin/src/feature/runout.cpp

   uint8_t FilamentSensorEncoder::motion_detected;
 #endif
 
-#if FILAMENT_RUNOUT_DISTANCE_MM > 0
+#ifdef FILAMENT_RUNOUT_DISTANCE_MM
   float RunoutResponseDelayed::runout_distance_mm = FILAMENT_RUNOUT_DISTANCE_MM;
   volatile float RunoutResponseDelayed::runout_mm_countdown[EXTRUDERS];
 #else

Marlin/src/feature/runout.h

       response.filament_present(extruder);
     }
 
+    #ifdef FILAMENT_RUNOUT_DISTANCE_MM
+      static inline float& runout_distance() { return response.runout_distance_mm; }
+      static inline void set_runout_distance(const float &mm) { response.runout_distance_mm = mm; }
+    #endif
+
     // Handle a block completion. RunoutResponseDelayed uses this to
     // add up the length of filament moved while the filament is out.
     static inline void block_completed(const block_t* const b) {
     // Give the response a chance to update its counter.
     static inline void run() {
       if (enabled && !filament_ran_out && (IS_SD_PRINTING() || print_job_timer.isRunning() || did_pause_print)) {
-        #if FILAMENT_RUNOUT_DISTANCE_MM > 0
+        #ifdef FILAMENT_RUNOUT_DISTANCE_MM
           cli(); // Prevent RunoutResponseDelayed::block_completed from accumulating here
         #endif
         response.run();
         sensor.run();
         const bool ran_out = response.has_run_out();
-        #if FILAMENT_RUNOUT_DISTANCE_MM > 0
+        #ifdef FILAMENT_RUNOUT_DISTANCE_MM
           sei();
         #endif
         if (ran_out) {
 
 /********************************* RESPONSE TYPE *********************************/
 
-#if FILAMENT_RUNOUT_DISTANCE_MM > 0
+#ifdef FILAMENT_RUNOUT_DISTANCE_MM
 
   // RunoutResponseDelayed triggers a runout event only if the length
   // of filament specified by FILAMENT_RUNOUT_DISTANCE_MM has been fed
 /********************************* TEMPLATE SPECIALIZATION *********************************/
 
 typedef TFilamentMonitor<
-  #if FILAMENT_RUNOUT_DISTANCE_MM > 0
+  #ifdef FILAMENT_RUNOUT_DISTANCE_MM
+    RunoutResponseDelayed,
     #if ENABLED(FILAMENT_MOTION_SENSOR)
-      RunoutResponseDelayed, FilamentSensorEncoder
+      FilamentSensorEncoder
     #else
-      RunoutResponseDelayed, FilamentSensorSwitch
+      FilamentSensorSwitch
     #endif
   #else
     RunoutResponseDebounced, FilamentSensorSwitch

Marlin/src/gcode/calibrate/G425.cpp

 #include "../../module/tool_change.h"
 #include "../../module/endstops.h"
 #include "../../feature/bedlevel/bedlevel.h"
+#include "../../feature/backlash.h"
 
 
 /**
 #define HAS_X_CENTER BOTH(CALIBRATION_MEASURE_LEFT, CALIBRATION_MEASURE_RIGHT)
 #define HAS_Y_CENTER BOTH(CALIBRATION_MEASURE_FRONT, CALIBRATION_MEASURE_BACK)
 
-#if ENABLED(BACKLASH_GCODE)
-  extern float backlash_distance_mm[], backlash_smoothing_mm;
-  extern uint8_t backlash_correction;
-#endif
-
 enum side_t : uint8_t { TOP, RIGHT, FRONT, LEFT, BACK, NUM_SIDES };
 
 struct measurements_t {
 #define TEMPORARY_SOFT_ENDSTOP_STATE(enable) REMEMBER(tes, soft_endstops_enabled, enable);
 
 #if ENABLED(BACKLASH_GCODE)
-  #define TEMPORARY_BACKLASH_CORRECTION(value) REMEMBER(tbst, backlash_correction, value)
+  #define TEMPORARY_BACKLASH_CORRECTION(value) REMEMBER(tbst, backlash.correction, value)
 #else
   #define TEMPORARY_BACKLASH_CORRECTION(value)
 #endif
 
 #if ENABLED(BACKLASH_GCODE) && defined(BACKLASH_SMOOTHING_MM)
-  #define TEMPORARY_BACKLASH_SMOOTHING(value) REMEMBER(tbsm, backlash_smoothing_mm, value)
+  #define TEMPORARY_BACKLASH_SMOOTHING(value) REMEMBER(tbsm, backlash.smoothing_mm, value)
 #else
   #define TEMPORARY_BACKLASH_SMOOTHING(value)
 #endif
 
     #if ENABLED(BACKLASH_GCODE)
       #if HAS_X_CENTER
-        backlash_distance_mm[X_AXIS] = (m.backlash[LEFT] + m.backlash[RIGHT]) / 2;
+        backlash.distance_mm[X_AXIS] = (m.backlash[LEFT] + m.backlash[RIGHT]) / 2;
       #elif ENABLED(CALIBRATION_MEASURE_LEFT)
-        backlash_distance_mm[X_AXIS] = m.backlash[LEFT];
+        backlash.distance_mm[X_AXIS] = m.backlash[LEFT];
       #elif ENABLED(CALIBRATION_MEASURE_RIGHT)
-        backlash_distance_mm[X_AXIS] = m.backlash[RIGHT];
+        backlash.distance_mm[X_AXIS] = m.backlash[RIGHT];
       #endif
 
       #if HAS_Y_CENTER
-        backlash_distance_mm[Y_AXIS] = (m.backlash[FRONT] + m.backlash[BACK]) / 2;
+        backlash.distance_mm[Y_AXIS] = (m.backlash[FRONT] + m.backlash[BACK]) / 2;
       #elif ENABLED(CALIBRATION_MEASURE_FRONT)
-        backlash_distance_mm[Y_AXIS] = m.backlash[FRONT];
+        backlash.distance_mm[Y_AXIS] = m.backlash[FRONT];
       #elif ENABLED(CALIBRATION_MEASURE_BACK)
-        backlash_distance_mm[Y_AXIS] = m.backlash[BACK];
+        backlash.distance_mm[Y_AXIS] = m.backlash[BACK];
       #endif
 
-      backlash_distance_mm[Z_AXIS] = m.backlash[TOP];
+      backlash.distance_mm[Z_AXIS] = m.backlash[TOP];
     #endif
   }
 

Marlin/src/gcode/calibrate/M425.cpp

 
 #if ENABLED(BACKLASH_GCODE)
 
+#include "../../feature/backlash.h"
 #include "../../module/planner.h"
 
-float   backlash_distance_mm[XYZ] = BACKLASH_DISTANCE_MM;
-uint8_t backlash_correction = BACKLASH_CORRECTION * all_on;
-
-#ifdef BACKLASH_SMOOTHING_MM
-  float backlash_smoothing_mm = BACKLASH_SMOOTHING_MM;
-#endif
-
-#if ENABLED(MEASURE_BACKLASH_WHEN_PROBING)
-  float backlash_measured_mm[XYZ] = { 0 };
-  uint8_t backlash_measured_num[XYZ] = { 0 };
-#endif
-
 #include "../gcode.h"
 
 /**
   LOOP_XYZ(i) {
     if (parser.seen(axis_codes[i])) {
       planner.synchronize();
-      const float measured_backlash = (
-        #if ENABLED(MEASURE_BACKLASH_WHEN_PROBING)
-          backlash_measured_num[i] > 0 ? backlash_measured_mm[i] / backlash_measured_num[i] : 0
-        #else
-          0
-        #endif
-      );
-      backlash_distance_mm[i] = parser.has_value() ? parser.value_linear_units() : measured_backlash;
+      backlash.distance_mm[i] = parser.has_value() ? parser.value_linear_units() : backlash.get_measurement(i);
       noArgs = false;
     }
   }
 
   if (parser.seen('F')) {
     planner.synchronize();
-    backlash_correction = MAX(0, MIN(1.0, parser.value_float())) * all_on;
+    backlash.set_correction(parser.value_float());
     noArgs = false;
   }
 
   #ifdef BACKLASH_SMOOTHING_MM
     if (parser.seen('S')) {
       planner.synchronize();
-      backlash_smoothing_mm = parser.value_linear_units();
+      backlash.smoothing_mm = parser.value_linear_units();
       noArgs = false;
     }
   #endif
 
   if (noArgs) {
-    SERIAL_ECHOPGM("Backlash correction is ");
-    if (!backlash_correction) SERIAL_ECHOPGM("in");
+    SERIAL_ECHOPGM("Backlash Correction ");
+    if (!backlash.correction) SERIAL_ECHOPGM("in");
     SERIAL_ECHOLNPGM("active:");
-    SERIAL_ECHOLNPAIR("  Correction Amount/Fade-out:     F", float(ui8_to_percent(backlash_correction)) / 100, "     (F1.0 = full, F0.0 = none)");
+    SERIAL_ECHOLNPAIR("  Correction Amount/Fade-out:     F", backlash.get_correction(), " (F1.0 = full, F0.0 = none)");
     SERIAL_ECHOPGM("  Backlash Distance (mm):        ");
     LOOP_XYZ(a) {
       SERIAL_CHAR(' ');
       SERIAL_CHAR(axis_codes[a]);
-      SERIAL_ECHO(backlash_distance_mm[a]);
+      SERIAL_ECHO(backlash.distance_mm[a]);
       SERIAL_EOL();
     }
 
     #ifdef BACKLASH_SMOOTHING_MM
-      SERIAL_ECHOLNPAIR("  Smoothing (mm):                 S", backlash_smoothing_mm);
+      SERIAL_ECHOLNPAIR("  Smoothing (mm):                 S", backlash.smoothing_mm);
     #endif
 
     #if ENABLED(MEASURE_BACKLASH_WHEN_PROBING)
       SERIAL_ECHOPGM("  Average measured backlash (mm):");
-      LOOP_XYZ(a) {
-        if (backlash_measured_num[a] > 0) {
+      if (backlash.has_any_measurement()) {
+        LOOP_XYZ(a) if (backlash.has_measurement(a)) {
           SERIAL_CHAR(' ');
           SERIAL_CHAR(axis_codes[a]);
-          SERIAL_ECHO(backlash_measured_mm[a] / backlash_measured_num[a]);
+          SERIAL_ECHO(backlash.get_measurement(a));
         }
       }
-      if (!backlash_measured_num[X_AXIS] && !backlash_measured_num[Y_AXIS] && !backlash_measured_num[Z_AXIS])
+      else
         SERIAL_ECHOPGM(" (Not yet measured)");
       SERIAL_EOL();
     #endif

Marlin/src/gcode/feature/runout/M412.cpp

  */
 void GcodeSuite::M412() {
   if (parser.seen("HS"
+    #ifdef FILAMENT_RUNOUT_DISTANCE_MM
+      "D"
+    #endif
     #if ENABLED(HOST_ACTION_COMMANDS)
       "R"
     #endif
     const bool seenR = parser.seen('R'), seenS = parser.seen('S');
     if (seenR || seenS) runout.reset();
     if (seenS) runout.enabled = parser.value_bool();
+    #ifdef FILAMENT_RUNOUT_DISTANCE_MM
+      if (parser.seen('D')) runout.set_runout_distance(parser.value_linear_units());
+    #endif
   }
   else {
     SERIAL_ECHO_START();
     SERIAL_ECHOPGM("Filament runout ");
     serialprintln_onoff(runout.enabled);
+    #ifdef FILAMENT_RUNOUT_DISTANCE_MM
+      SERIAL_ECHOLNPAIR("Filament runout distance (mm): ", runout.runout_distance());
+    #endif
   }
 }
 

Marlin/src/inc/Conditionals_LCD.h

   #define GRID_MAX_POINTS ((GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y))
 #endif
 
+#if ENABLED(MALYAN_LCD)
+  #define EXTENSIBLE_UI
+#endif
 #define HAS_SOFTWARE_ENDSTOPS EITHER(MIN_SOFTWARE_ENDSTOPS, MAX_SOFTWARE_ENDSTOPS)
 #define HAS_RESUME_CONTINUE   ANY(EXTENSIBLE_UI, NEWPANEL, EMERGENCY_PARSER)
 #define HAS_COLOR_LEDS        ANY(BLINKM, RGB_LED, RGBW_LED, PCA9632, PCA9533, NEOPIXEL_LED)

Marlin/src/inc/SanityCheck.h

     #error "FILAMENT_RUNOUT_SENSOR with NUM_RUNOUT_SENSORS > 5 requires FIL_RUNOUT6_PIN."
   #elif DISABLED(SDSUPPORT, PRINTJOB_TIMER_AUTOSTART)
     #error "FILAMENT_RUNOUT_SENSOR requires SDSUPPORT or PRINTJOB_TIMER_AUTOSTART."
+  #elif FILAMENT_RUNOUT_DISTANCE_MM < 0
+    #error "FILAMENT_RUNOUT_DISTANCE_MM must be greater than or equal to zero."
   #elif DISABLED(ADVANCED_PAUSE_FEATURE)
     static_assert(NULL == strstr(FILAMENT_RUNOUT_SCRIPT, "M600"), "ADVANCED_PAUSE_FEATURE is required to use M600 with FILAMENT_RUNOUT_SENSOR.");
   #endif
   + ENABLED(OLED_PANEL_TINYBOY2) \
   + ENABLED(ZONESTAR_LCD) \
   + ENABLED(ULTI_CONTROLLER) \
-  + ENABLED(EXTENSIBLE_UI)
+  + (ENABLED(EXTENSIBLE_UI) && DISABLED(MALYAN_LCD))
   #error "Please select no more than one LCD controller option."
 #endif
 

Marlin/src/lcd/extensible_ui/lib/example.cpp

-/*************
- * dummy.cpp *
- *************/
+/***************
+ * example.cpp *
+ ***************/
 
 /****************************************************************************
  *   Written By Marcio Teixeira 2018 - Aleph Objects, Inc.                  *
 
 #include "../../../inc/MarlinConfigPre.h"
 
-#if ENABLED(EXTENSIBLE_UI)
+#if BOTH(EXTUI_EXAMPLE, EXTENSIBLE_UI)
 
 #include "../ui_api.h"
 
   void onUserConfirmRequired(const char * const msg) {}
   void onStatusChanged(const char * const msg) {}
   void onFactoryReset() {}
-  void onLoadSettings() {}
-  void onStoreSettings() {}
+
+  void onStoreSettings(char *buff) {
+    // This is called when saving to EEPROM (i.e. M500). If the ExtUI needs
+    // permanent data to be stored, it can write up to eeprom_data_size bytes
+    // into buff.
+
+    // Example:
+    //  static_assert(sizeof(myDataStruct) <= ExtUI::eeprom_data_size);
+    //  memcpy(buff, &myDataStruct, sizeof(myDataStruct));
+  }
+
+  void onLoadSettings(const char *buff) {
+    // This is called while loading settings from EEPROM. If the ExtUI
+    // needs to retrieve data, it should copy up to eeprom_data_size bytes
+    // from buff
+
+    // Example:
+    //  static_assert(sizeof(myDataStruct) <= ExtUI::eeprom_data_size);
+    //  memcpy(&myDataStruct, buff, sizeof(myDataStruct));
+  }
+
+  void onConfigurationStoreWritten(bool success) {
+    // This is called after the entire EEPROM has been written,
+    // whether successful or not.
+  }
+
+  void onConfigurationStoreRead(bool success) {
+    // This is called after the entire EEPROM has been read,
+    // whether successful or not.
+  }
 }
 
-#endif // EXTENSIBLE_UI
+#endif // EXTUI_EXAMPLE && EXTENSIBLE_UI

Marlin/src/lcd/extensible_ui/ui_api.cpp

 #include "ui_api.h"
 
 #if ENABLED(BACKLASH_GCODE)
-  extern float backlash_distance_mm[XYZ];
-  extern uint8_t backlash_correction;
-  #ifdef BACKLASH_SMOOTHING_MM
-    extern float backlash_smoothing_mm;
-  #endif
+  #include "../../feature/backlash.h"
 #endif
 
 #if HAS_LEVELING
 } flags;
 
 namespace ExtUI {
-
   #ifdef __SAM3X8E__
     /**
      * Implement a special millis() to allow time measurement
     bool getFilamentRunoutEnabled()                 { return runout.enabled; }
     void setFilamentRunoutEnabled(const bool value) { runout.enabled = value; }
 
-    #if FILAMENT_RUNOUT_DISTANCE_MM > 0
+    #ifdef FILAMENT_RUNOUT_DISTANCE_MM
       float getFilamentRunoutDistance_mm() {
-        return RunoutResponseDelayed::runout_distance_mm;
+        return runout.runout_distance();
       }
 
       void setFilamentRunoutDistance_mm(const float value) {
-        RunoutResponseDelayed::runout_distance_mm = clamp(value, 0, 999);
+        runout.set_runout_distance(clamp(value, 0, 999));
       }
     #endif
   #endif
   #endif // HAS_HOTEND_OFFSET
 
   #if ENABLED(BACKLASH_GCODE)
-    float getAxisBacklash_mm(const axis_t axis)       { return backlash_distance_mm[axis]; }
+    float getAxisBacklash_mm(const axis_t axis)       { return backlash.distance_mm[axis]; }
     void setAxisBacklash_mm(const float value, const axis_t axis)
-                                                      { backlash_distance_mm[axis] = clamp(value,0,5); }
+                                                      { backlash.distance_mm[axis] = clamp(value,0,5); }
 
-    float getBacklashCorrection_percent()             { return ui8_to_percent(backlash_correction); }
-    void setBacklashCorrection_percent(const float value) { backlash_correction = map(clamp(value, 0, 100), 0, 100, 0, 255); }
+    float getBacklashCorrection_percent()             { return ui8_to_percent(backlash.correction); }
+    void setBacklashCorrection_percent(const float value) { backlash.correction = map(clamp(value, 0, 100), 0, 100, 0, 255); }
 
     #ifdef BACKLASH_SMOOTHING_MM
-      float getBacklashSmoothing_mm()                 { return backlash_smoothing_mm; }
-      void setBacklashSmoothing_mm(const float value) { backlash_smoothing_mm = clamp(value, 0, 999); }
+      float getBacklashSmoothing_mm()                 { return backlash.smoothing_mm; }
+      void setBacklashSmoothing_mm(const float value) { backlash.smoothing_mm = clamp(value, 0, 999); }
     #endif
   #endif
 
   }
 
   bool commandsInQueue() { return (planner.movesplanned() || commands_in_queue); }
-  
+
   bool isAxisPositionKnown(const axis_t axis) {
     return TEST(axis_known_position, axis);
   }

Marlin/src/lcd/extensible_ui/ui_api.h

 #include "../../inc/MarlinConfig.h"
 
 namespace ExtUI {
+  // The ExtUI implementation can store up to this many bytes
+  // in the EEPROM when the methods onStoreSettings and
+  // onLoadSettings are called.
+
+  static constexpr size_t eeprom_data_size = 48;
 
   enum axis_t     : uint8_t { X, Y, Z };
   enum extruder_t : uint8_t { E0, E1, E2, E3, E4, E5 };
     bool getFilamentRunoutEnabled();
     void setFilamentRunoutEnabled(const bool);
 
-    #if FILAMENT_RUNOUT_DISTANCE_MM > 0
+    #ifdef FILAMENT_RUNOUT_DISTANCE_MM
       float getFilamentRunoutDistance_mm();
       void setFilamentRunoutDistance_mm(const float);
     #endif
   void onUserConfirmRequired(const char * const msg);
   void onStatusChanged(const char * const msg);
   void onFactoryReset();
-  void onStoreSettings();
-  void onLoadSettings();
+  void onStoreSettings(char *);
+  void onLoadSettings(const char *);
+  void onConfigurationStoreWritten(bool success);
+  void onConfigurationStoreRead(bool success);
 };
 
 /**

Marlin/src/lcd/malyanlcd.cpp

  * Copyright (c) 2017 Jason Nelson (xC0000005)
  */
 
-#include "../inc/MarlinConfig.h"
+#include "../inc/MarlinConfigPre.h"
 
 #if ENABLED(MALYAN_LCD)
 
+#include "extensible_ui/ui_api.h"
+
 #include "ultralcd.h"
 #include "../module/temperature.h"
-#include "../module/planner.h"
 #include "../module/stepper.h"
 #include "../module/motion.h"
-#include "../module/probe.h"
 #include "../libs/duration_t.h"
 #include "../module/printcounter.h"
-#include "../gcode/gcode.h"
 #include "../gcode/queue.h"
-#include "../module/configuration_store.h"
-
-#include "../Marlin.h"
 
 #if ENABLED(SDSUPPORT)
   #include "../sd/cardreader.h"
   }
 }
 
-/**
- * - from printer on startup:
- * {SYS:STARTED}{VER:29}{SYS:STARTED}{R:UD}
- * The optimize attribute fixes a register Compile
- * error for amtel.
- */
-void MarlinUI::update() {
-  static char inbound_buffer[MAX_CURLY_COMMAND];
-
-  // First report USB status.
-  update_usb_status(false);
-
-  // now drain commands...
-  while (LCD_SERIAL.available()) {
-    const byte b = (byte)LCD_SERIAL.read() & 0x7F;
-    inbound_buffer[inbound_count++] = b;
-    if (b == '}' || inbound_count == sizeof(inbound_buffer) - 1) {
-      inbound_buffer[inbound_count - 1] = '\0';
-      process_lcd_command(inbound_buffer);
-      inbound_count = 0;
-      inbound_buffer[0] = 0;
-    }
+namespace ExtUI {
+  void onStartup() {
+    /**
+     * The Malyan LCD actually runs as a separate MCU on Serial 1.
+     * This code's job is to siphon the weird curly-brace commands from
+     * it and translate into gcode, which then gets injected into
+     * the command queue where possible.
+     */
+    inbound_count = 0;
+    LCD_SERIAL.begin(500000);
+
+    // Signal init
+    write_to_lcd_P(PSTR("{SYS:STARTED}\r\n"));
+
+    // send a version that says "unsupported"
+    write_to_lcd_P(PSTR("{VER:99}\r\n"));
+
+    // No idea why it does this twice.
+    write_to_lcd_P(PSTR("{SYS:STARTED}\r\n"));
+    update_usb_status(true);
   }
 
-  #if ENABLED(SDSUPPORT)
-    // The way last printing status works is simple:
-    // The UI needs to see at least one TQ which is not 100%
-    // and then when the print is complete, one which is.
-    static uint8_t last_percent_done = 100;
-
-    // If there was a print in progress, we need to emit the final
-    // print status as {TQ:100}. Reset last percent done so a new print will
-    // issue a percent of 0.
-    const uint8_t percent_done = IS_SD_PRINTING() ? card.percentDone() : last_printing_status ? 100 : 0;
-    if (percent_done != last_percent_done) {
-      char message_buffer[10];
-      sprintf_P(message_buffer, PSTR("{TQ:%03i}"), percent_done);
-      write_to_lcd(message_buffer);
-      last_percent_done = percent_done;
-      last_printing_status = IS_SD_PRINTING();
+  void onIdle() {
+    /**
+     * - from printer on startup:
+     * {SYS:STARTED}{VER:29}{SYS:STARTED}{R:UD}
+     * The optimize attribute fixes a register Compile
+     * error for amtel.
+     */
+    static char inbound_buffer[MAX_CURLY_COMMAND];
+
+    // First report USB status.
+    update_usb_status(false);
+
+    // now drain commands...
+    while (LCD_SERIAL.available()) {
+      const byte b = (byte)LCD_SERIAL.read() & 0x7F;
+      inbound_buffer[inbound_count++] = b;
+      if (b == '}' || inbound_count == sizeof(inbound_buffer) - 1) {
+        inbound_buffer[inbound_count - 1] = '\0';
+        process_lcd_command(inbound_buffer);
+        inbound_count = 0;
+        inbound_buffer[0] = 0;
+      }
     }
-  #endif
-}
 
-/**
- * The Malyan LCD actually runs as a separate MCU on Serial 1.
- * This code's job is to siphon the weird curly-brace commands from
- * it and translate into gcode, which then gets injected into
- * the command queue where possible.
- */
-void MarlinUI::init() {
-  inbound_count = 0;
-  LCD_SERIAL.begin(500000);
+    #if ENABLED(SDSUPPORT)
+      // The way last printing status works is simple:
+      // The UI needs to see at least one TQ which is not 100%
+      // and then when the print is complete, one which is.
+      static uint8_t last_percent_done = 100;
+
+      // If there was a print in progress, we need to emit the final
+      // print status as {TQ:100}. Reset last percent done so a new print will
+      // issue a percent of 0.
+      const uint8_t percent_done = IS_SD_PRINTING() ? card.percentDone() : last_printing_status ? 100 : 0;
+      if (percent_done != last_percent_done) {
+        char message_buffer[10];
+        sprintf_P(message_buffer, PSTR("{TQ:%03i}"), percent_done);
+        write_to_lcd(message_buffer);
+        last_percent_done = percent_done;
+        last_printing_status = IS_SD_PRINTING();
+      }
+    #endif
+  }
 
-  // Signal init
-  write_to_lcd_P(PSTR("{SYS:STARTED}\r\n"));
+  void onPrinterKilled(PGM_P const msg) {}
+  void onMediaInserted() {};
+  void onMediaError() {};
+  void onMediaRemoved() {};
+  void onPlayTone(const uint16_t frequency, const uint16_t duration) {}
+  void onPrintTimerStarted() {}
+  void onPrintTimerPaused() {}
+  void onPrintTimerStopped() {}
+  void onFilamentRunout() {}
+  void onUserConfirmRequired(const char * const msg) {}
+  void onStatusChanged(const char * const msg) {
+    write_to_lcd_P(PSTR("{E:"));
+    write_to_lcd(msg);
+    write_to_lcd_P("}");
+  }
+  void onFactoryReset() {}
 
-  // send a version that says "unsupported"
-  write_to_lcd_P(PSTR("{VER:99}\r\n"));
+  void onStoreSettings(char *buff) {
+    // This is called when saving to EEPROM (i.e. M500). If the ExtUI needs
+    // permanent data to be stored, it can write up to eeprom_data_size bytes
+    // into buff.
 
-  // No idea why it does this twice.
-  write_to_lcd_P(PSTR("{SYS:STARTED}\r\n"));
-  update_usb_status(true);
-}
+    // Example:
+    //  static_assert(sizeof(myDataStruct) <= ExtUI::eeprom_data_size);
+    //  memcpy(buff, &myDataStruct, sizeof(myDataStruct));
+  }
 
-/**
- * Set an alert.
- */
-void MarlinUI::set_alert_status_P(PGM_P const message) {
-  write_to_lcd_P(PSTR("{E:"));
-  write_to_lcd_P(message);
-  write_to_lcd_P("}");
+  void onLoadSettings(const char *buff) {
+    // This is called while loading settings from EEPROM. If the ExtUI
+    // needs to retrieve data, it should copy up to eeprom_data_size bytes
+    // from buff
+
+    // Example:
+    //  static_assert(sizeof(myDataStruct) <= ExtUI::eeprom_data_size);
+    //  memcpy(&myDataStruct, buff, sizeof(myDataStruct));
+  }
+
+  void onConfigurationStoreWritten(bool success) {
+    // This is called after the entire EEPROM has been written,
+    // whether successful or not.
+  }
+
+  void onConfigurationStoreRead(bool success) {
+    // This is called after the entire EEPROM has been read,
+    // whether successful or not.
+  }
 }
 
 #endif // MALYAN_LCD

Marlin/src/lcd/menu/menu_backlash.cpp

 
 #include "menu.h"
 
-extern float backlash_distance_mm[XYZ];
-extern uint8_t backlash_correction;
-
-#ifdef BACKLASH_SMOOTHING_MM
-  extern float backlash_smoothing_mm;
-#endif
+#include "../../feature/backlash.h"
 
 void menu_backlash() {
   START_MENU();
   MENU_BACK(MSG_MAIN);
 
-  MENU_MULTIPLIER_ITEM_EDIT(percent, MSG_BACKLASH_CORRECTION, &backlash_correction, all_off, all_on);
+  MENU_MULTIPLIER_ITEM_EDIT(percent, MSG_BACKLASH_CORRECTION, &backlash.correction, all_off, all_on);
 
-  #define EDIT_BACKLASH_DISTANCE(N) MENU_MULTIPLIER_ITEM_EDIT(float43, MSG_##N, &backlash_distance_mm[_AXIS(N)], 0.0f, 9.9f);
+  #define EDIT_BACKLASH_DISTANCE(N) MENU_MULTIPLIER_ITEM_EDIT(float43, MSG_##N, &backlash.distance_mm[_AXIS(N)], 0.0f, 9.9f);
   EDIT_BACKLASH_DISTANCE(A);
   EDIT_BACKLASH_DISTANCE(B);
   EDIT_BACKLASH_DISTANCE(C);
 
   #ifdef BACKLASH_SMOOTHING_MM
-    MENU_MULTIPLIER_ITEM_EDIT(float43, MSG_BACKLASH_SMOOTHING, &backlash_smoothing_mm, 0.0f, 9.9f);
+    MENU_MULTIPLIER_ITEM_EDIT(float43, MSG_BACKLASH_SMOOTHING, &backlash.smoothing_mm, 0.0f, 9.9f);
   #endif
 
   END_MENU();

Marlin/src/lcd/ultralcd.cpp

 #include "../inc/MarlinConfigPre.h"
 
 // These displays all share the MarlinUI class
-#if HAS_SPI_LCD || EITHER(MALYAN_LCD, EXTENSIBLE_UI)
+#if HAS_SPI_LCD || ENABLED(EXTENSIBLE_UI)
   #include "ultralcd.h"
   #include "fontutils.h"
   MarlinUI ui;

Marlin/src/module/configuration_store.cpp

  */
 
 // Change EEPROM version if the structure changes
-#define EEPROM_VERSION "V65"
+#define EEPROM_VERSION "V66"
 #define EEPROM_OFFSET 100
 
 // Check the integrity of data offsets.
 
 #include "../feature/pause.h"
 
+#if ENABLED(BACKLASH_COMPENSATION)
+  #include "../feature/backlash.h"
+#endif
+
 #if HAS_FILAMENT_SENSOR
   #include "../feature/runout.h"
 #endif
 
+#include "../lcd/extensible_ui/ui_api.h"
+
 #if ENABLED(EXTRA_LIN_ADVANCE_K)
 extern float saved_extruder_advance_K[EXTRUDERS];
 #endif
   // FILAMENT_RUNOUT_SENSOR
   //
   bool runout_sensor_enabled;                           // M412 S
+  float runout_distance_mm;                             // M412 D
 
   //
   // ENABLE_LEVELING_FADE_HEIGHT
     toolchange_settings_t toolchange_settings;          // M217 S P R
   #endif
 
+  //
+  // BACKLASH_COMPENSATION
+  //
+  float backlash_distance_mm[XYZ];                      // M425 X Y Z
+  uint8_t backlash_correction;                          // M425 F
+  float backlash_smoothing_mm;                          // M425 S
+
+  //
+  // EXTENSIBLE_UI
+  //
+  #if ENABLED(EXTENSIBLE_UI)
+    // This is a significant hardware change; don't reserve space when not present
+    uint8_t extui_data[ExtUI::eeprom_data_size];
+  #endif
+
 } SettingsData;
 
 //static_assert(sizeof(SettingsData) <= E2END + 1, "EEPROM too small to contain SettingsData!");
     report_current_position();
 }
 
+#if ENABLED(PRINTCOUNTER) && ENABLED(EEPROM_SETTINGS)
+  #include "printcounter.h"
+
+  static_assert(
+    !WITHIN(STATS_EEPROM_ADDRESS, EEPROM_OFFSET, EEPROM_OFFSET + sizeof(SettingsData)) &&
+    !WITHIN(STATS_EEPROM_ADDRESS + sizeof(printStatistics), EEPROM_OFFSET, EEPROM_OFFSET + sizeof(SettingsData)),
+    "STATS_EEPROM_ADDRESS collides with EEPROM settings storage."
+  );
+#endif
+
 #if ENABLED(SD_FIRMWARE_UPDATE)
 
   #if ENABLED(EEPROM_SETTINGS)
     //
     {
       #if HAS_FILAMENT_SENSOR
-        EEPROM_WRITE(runout.enabled);
+        const bool &runout_sensor_enabled = runout.enabled;
       #else
-        const bool runout_sensor_enabled = true;
-        EEPROM_WRITE(runout_sensor_enabled);
+        const bool runout_sensor_enabled = false;
       #endif
+      #if HAS_FILAMENT_SENSOR && defined(FILAMENT_RUNOUT_DISTANCE_MM)
+        const float &runout_distance_mm = runout.runout_distance();
+      #else
+        const float runout_distance_mm = 0;
+      #endif
+      _FIELD_TEST(runout_sensor_enabled);
+      EEPROM_WRITE(runout_sensor_enabled);
+      EEPROM_WRITE(runout_distance_mm);
     }
 
     //
     #endif
 
     //
+    // Backlash Compensation
+    //
+    {
+      #if ENABLED(BACKLASH_COMPENSATION)
+        const float   (&backlash_distance_mm)[XYZ] = backlash.distance_mm;
+        const uint8_t &backlash_correction         = backlash.correction;
+      #else
+        const float    backlash_distance_mm[XYZ]   = { 0 };
+        const uint8_t  backlash_correction         = 0;
+      #endif
+      #ifdef BACKLASH_SMOOTHING_MM
+        const float   &backlash_smoothing_mm       = backlash.smoothing_mm;
+      #else
+        const float    backlash_smoothing_mm       = 3;
+      #endif
+      _FIELD_TEST(backlash_distance_mm);
+      EEPROM_WRITE(backlash_distance_mm[X_AXIS]);
+      EEPROM_WRITE(backlash_distance_mm[Y_AXIS]);
+      EEPROM_WRITE(backlash_distance_mm[Z_AXIS]);
+      EEPROM_WRITE(backlash_correction);
+      EEPROM_WRITE(backlash_smoothing_mm);
+    }
+
+    //
+    // Extensible UI User Data
+    //
+    #if ENABLED(EXTENSIBLE_UI)
+      {
+        char extui_data[ExtUI::eeprom_data_size] = { 0 };
+        ExtUI::onStoreSettings(extui_data);
+        _FIELD_TEST(extui_data);
+        EEPROM_WRITE(extui_data);
+      }
+    #endif
+
+    //
     // Validate CRC and Data Size
     //
     if (!eeprom_error) {
     #endif
 
     #if ENABLED(EXTENSIBLE_UI)
-      if (!eeprom_error) ExtUI::onStoreSettings();
+      ExtUI::onConfigurationStoreWritten(!eeprom_error);
     #endif
 
     return !eeprom_error;
       // Filament Runout Sensor
       //
       {
-        _FIELD_TEST(runout_sensor_enabled);
         #if HAS_FILAMENT_SENSOR
-          EEPROM_READ(runout.enabled);
+          bool &runout_sensor_enabled = runout.enabled;
         #else
           bool runout_sensor_enabled;
-          EEPROM_READ(runout_sensor_enabled);
+        #endif
+        _FIELD_TEST(runout_sensor_enabled);
+        EEPROM_READ(runout_sensor_enabled);
+
+        float runout_distance_mm;
+        EEPROM_READ(runout_distance_mm);
+        #if HAS_FILAMENT_SENSOR && defined(FILAMENT_RUNOUT_DISTANCE_MM)
+          runout.set_runout_distance(runout_distance_mm);
         #endif
       }
 
         EEPROM_READ(toolchange_settings);
       #endif
 
+      //
+      // Backlash Compensation
+      //
+      {
+        #if ENABLED(BACKLASH_COMPENSATION)
+          float   (&backlash_distance_mm)[XYZ] = backlash.distance_mm;
+          uint8_t &backlash_correction         = backlash.correction;
+        #else
+          float   backlash_distance_mm[XYZ];
+          uint8_t backlash_correction;
+        #endif
+        #ifdef BACKLASH_SMOOTHING_MM
+          float &backlash_smoothing_mm = backlash.smoothing_mm;
+        #else
+          float  backlash_smoothing_mm;
+        #endif
+        _FIELD_TEST(backlash_distance_mm);
+        EEPROM_READ(backlash_distance_mm[X_AXIS]);
+        EEPROM_READ(backlash_distance_mm[Y_AXIS]);
+        EEPROM_READ(backlash_distance_mm[Z_AXIS]);
+        EEPROM_READ(backlash_correction);
+        EEPROM_READ(backlash_smoothing_mm);
+      }
+
+      //
+      // Extensible UI User Data
+      //
+      #if ENABLED(EXTENSIBLE_UI)
+        // This is a significant hardware change; don't reserve EEPROM space when not present
+        {
+          const char extui_data[ExtUI::eeprom_data_size] = { 0 };
+          _FIELD_TEST(extui_data);
+          EEPROM_READ(extui_data);
+          if(!validating)
+            ExtUI::onLoadSettings(extui_data);
+        }
+      #endif
+
       eeprom_error = size_error(eeprom_index - (EEPROM_OFFSET));
       if (eeprom_error) {
         DEBUG_ECHO_START();
     if (validate()) {
       const bool success = _load();
       #if ENABLED(EXTENSIBLE_UI)
-        if (success) ExtUI::onLoadSettings();
+        ExtUI::onConfigurationStoreRead(success);
       #endif
       return success;
     }
   #if HAS_FILAMENT_SENSOR
     runout.enabled = true;
     runout.reset();
+    #ifdef FILAMENT_RUNOUT_DISTANCE_MM
+      runout.set_runout_distance(FILAMENT_RUNOUT_DISTANCE_MM);
+    #endif
   #endif
 
   //
     toolchange_settings.z_raise = TOOLCHANGE_ZRAISE;
   #endif
 
+  #if ENABLED(BACKLASH_GCODE)
+    backlash.correction = (BACKLASH_CORRECTION) * 255;
+    #ifdef BACKLASH_DISTANCE_MM
+      constexpr float tmp[XYZ] = BACKLASH_DISTANCE_MM;
+      backlash.distance_mm[X_AXIS] = tmp[X_AXIS];
+      backlash.distance_mm[Y_AXIS] = tmp[Y_AXIS];
+      backlash.distance_mm[Z_AXIS] = tmp[Z_AXIS];
+    #endif
+    #ifdef BACKLASH_SMOOTHING_MM
+      backlash.smoothing_mm = BACKLASH_SMOOTHING_MM;
+    #endif
+  #endif
+
+  #if ENABLED(EXTENSIBLE_UI)
+    ExtUI::onFactoryReset();
+  #endif
+
   //
   // Magnetic Parking Extruder
   //
       CONFIG_ECHO_START();
       M217_report(true);
     #endif
+
+    #if ENABLED(BACKLASH_GCODE)
+      CONFIG_ECHO_HEADING("Backlash compensation:");
+      CONFIG_ECHO_START();
+      SERIAL_ECHOLNPAIR(
+        "  M425 F", backlash.get_correction(),
+        " X", LINEAR_UNIT(backlash.distance_mm[X_AXIS]),
+        " Y", LINEAR_UNIT(backlash.distance_mm[Y_AXIS]),
+        " Z", LINEAR_UNIT(backlash.distance_mm[Z_AXIS])
+        #ifdef BACKLASH_SMOOTHING_MM
+          , " S", LINEAR_UNIT(backlash.smoothing_mm)
+        #endif
+      );
+    #endif
+
+    #if HAS_FILAMENT_SENSOR
+      CONFIG_ECHO_HEADING("Filament runout sensor:");
+      CONFIG_ECHO_START();
+      SERIAL_ECHOLNPAIR(
+        "  M412 S", int(runout.enabled)
+        #ifdef FILAMENT_RUNOUT_DISTANCE_MM
+          , " D", LINEAR_UNIT(runout.runout_distance())
+        #endif
+      );
+    #endif
   }
 
 #endif // !DISABLE_M503

Marlin/src/module/planner.cpp

   #include "../feature/power.h"
 #endif
 
+#if ENABLED(BACKLASH_COMPENSATION)
+  #include "../feature/backlash.h"
+#endif
+
 // Delay for delivery of first block to the stepper ISR, if the queue contains 2 or
 // fewer movements. The delay is measured in milliseconds, and must be less than 250ms
 #define BLOCK_DELAY_FOR_1ST_MOVE 100
 }
 
 /**
- * The following implements axis backlash correction. To minimize seams
- * on the printed part, the backlash correction only adds steps to the
- * current segment (instead of creating a new segment, which causes
- * discontinuities and print artifacts).
- *
- * When BACKLASH_SMOOTHING_MM is enabled and non-zero, the backlash
- * correction is spread over multiple segments, smoothing out print
- * artifacts even more.
- */
-#if ENABLED(BACKLASH_COMPENSATION)
-  #if ENABLED(BACKLASH_GCODE)
-    extern float backlash_distance_mm[];
-    extern uint8_t backlash_correction;
-    #ifdef BACKLASH_SMOOTHING_MM
-      extern float backlash_smoothing_mm;
-    #endif
-  #else
-    constexpr float backlash_distance_mm[XYZ] = BACKLASH_DISTANCE_MM,
-    constexpr uint8_t backlash_correction = BACKLASH_CORRECTION * 255;
-    #ifdef BACKLASH_SMOOTHING_MM
-      constexpr float backlash_smoothing_mm = BACKLASH_SMOOTHING_MM;
-    #endif
-  #endif
-
-  void Planner::add_backlash_correction_steps(const int32_t da, const int32_t db, const int32_t dc, const uint8_t dm, block_t * const block) {
-    static uint8_t last_direction_bits;
-    uint8_t changed_dir = last_direction_bits ^ dm;
-    // Ignore direction change if no steps are taken in that direction
-    if (da == 0) CBI(changed_dir, X_AXIS);
-    if (db == 0) CBI(changed_dir, Y_AXIS);
-    if (dc == 0) CBI(changed_dir, Z_AXIS);
-    last_direction_bits ^= changed_dir;
-
-    if (backlash_correction == 0) return;
-
-    #ifdef BACKLASH_SMOOTHING_MM
-      // The segment proportion is a value greater than 0.0 indicating how much residual_error
-      // is corrected for in this segment. The contribution is based on segment length and the
-      // smoothing distance. Since the computation of this proportion involves a floating point
-      // division, defer computation until needed.
-      float segment_proportion = 0;
-
-      // Residual error carried forward across multiple segments, so correction can be applied
-      // to segments where there is no direction change.
-      static int32_t residual_error[XYZ] = { 0 };
-    #else
-      // No leftover residual error from segment to segment
-      int32_t residual_error[XYZ] = { 0 };
-      // No direction change, no correction.
-      if (!changed_dir) return;
-    #endif
-
-    const float f_corr = float(backlash_correction) / 255.0f;
-
-    LOOP_XYZ(axis) {
-      if (backlash_distance_mm[axis]) {
-        const bool reversing = TEST(dm,axis);
-
-        // When an axis changes direction, add axis backlash to the residual error
-        if (TEST(changed_dir, axis))
-          residual_error[axis] += (reversing ? -f_corr : f_corr) * backlash_distance_mm[axis] * planner.settings.axis_steps_per_mm[axis];
-
-        // Decide how much of the residual error to correct in this segment
-        int32_t error_correction = residual_error[axis];
-        #ifdef BACKLASH_SMOOTHING_MM
-          if (error_correction && backlash_smoothing_mm != 0) {
-            // Take up a portion of the residual_error in this segment, but only when
-            // the current segment travels in the same direction as the correction
-            if (reversing == (error_correction < 0)) {
-              if (segment_proportion == 0)
-                segment_proportion = MIN(1.0f, block->millimeters / backlash_smoothing_mm);
-              error_correction = ceil(segment_proportion * error_correction);
-            }
-            else
-              error_correction = 0; // Don't take up any backlash in this segment, as it would subtract steps
-          }
-        #endif
-        // Making a correction reduces the residual error and modifies delta_mm
-        if (error_correction) {
-          block->steps[axis] += ABS(error_correction);
-          residual_error[axis] -= error_correction;
-        }
-      }
-    }
-  }
-#endif // BACKLASH_COMPENSATION
-
-/**
  * Planner::_buffer_steps
  *
  * Add a new linear movement to the planner queue (in terms of steps).
      * should *never* remove steps!
      */
     #if ENABLED(BACKLASH_COMPENSATION)
-      add_backlash_correction_steps(da, db, dc, dm, block);
+      backlash.add_correction_steps(da, db, dc, dm, block);
     #endif
   }
 

Marlin/src/module/planner.h

       volatile static uint32_t block_buffer_runtime_us; //Theoretical block buffer runtime in µs
     #endif
 
-    #if ENABLED(BACKLASH_COMPENSATION)
-      static void add_backlash_correction_steps(const int32_t da, const int32_t db, const int32_t dc, const uint8_t dm, block_t * const block);
-    #endif
-
   public:
 
     /**

Marlin/src/module/printcounter.cpp

 
 #else // PRINTCOUNTER
 
+#if ENABLED(EXTENSIBLE_UI)
+  #include "../lcd/extensible_ui/ui_api.h"
+#endif
+
 #include "printcounter.h"
 #include "../Marlin.h"
 #include "../HAL/shared/persistent_store_api.h"
   persistentStore.access_start();
   persistentStore.write_data(address + sizeof(uint8_t), (uint8_t*)&data, sizeof(printStatistics));
   persistentStore.access_finish();
+
+  #if ENABLED(EXTENSIBLE_UI)
+    ExtUI::onConfigurationStoreWritten(true);
+  #endif
 }
 
 #if HAS_SERVICE_INTERVALS

Marlin/src/module/probe.cpp

   #include "planner.h"
 #endif
 
+#if ENABLED(MEASURE_BACKLASH_WHEN_PROBING)
+  #include "../feature/backlash.h"
+#endif
+
 float zprobe_zoffset; // Initialized by settings.load()
 
 #if ENABLED(BLTOUCH)
   }
 #endif
 
-#if ENABLED(MEASURE_BACKLASH_WHEN_PROBING)
-  #if USES_Z_MIN_PROBE_ENDSTOP
-    #define TEST_PROBE_PIN (READ(Z_MIN_PROBE_PIN) != Z_MIN_PROBE_ENDSTOP_INVERTING)
-  #else
-    #define TEST_PROBE_PIN (READ(Z_MIN_PIN) != Z_MIN_ENDSTOP_INVERTING)
-  #endif
-
-  extern float backlash_measured_mm[];
-  extern uint8_t backlash_measured_num[];
-
-  /* Measure Z backlash by raising nozzle in increments until probe deactivates */
-  static void measure_backlash_with_probe() {
-    if (backlash_measured_num[Z_AXIS] == 255) return;
-
-    float start_height = current_position[Z_AXIS];
-    while (current_position[Z_AXIS] < (start_height + BACKLASH_MEASUREMENT_LIMIT) && TEST_PROBE_PIN)
-      do_blocking_move_to_z(current_position[Z_AXIS] + BACKLASH_MEASUREMENT_RESOLUTION, MMM_TO_MMS(BACKLASH_MEASUREMENT_FEEDRATE));
-
-    // The backlash from all probe points is averaged, so count the number of measurements
-    backlash_measured_mm[Z_AXIS] += current_position[Z_AXIS] - start_height;
-    backlash_measured_num[Z_AXIS]++;
-  }
-#endif
-
 /**
  * @brief Used by run_z_probe to do a single Z probe move.
  *
       }
 
       #if ENABLED(MEASURE_BACKLASH_WHEN_PROBING)
-        measure_backlash_with_probe();
+        backlash.measure_with_probe();
       #endif
 
   #if MULTIPLE_PROBING > 2

Marlin/src/module/stepper.cpp

   #include "../feature/mixing.h"
 #endif
 
-#if FILAMENT_RUNOUT_DISTANCE_MM > 0
+#ifdef FILAMENT_RUNOUT_DISTANCE_MM
   #include "../feature/runout.h"
 #endif
 
 
     // If current block is finished, reset pointer
     if (step_events_completed >= step_event_count) {
-      #if FILAMENT_RUNOUT_DISTANCE_MM > 0
+      #ifdef FILAMENT_RUNOUT_DISTANCE_MM
         runout.block_completed(current_block);
       #endif
       axis_did_move = 0;