Numerous UBL-related changes:

* relocated ubl state to config. store:
 * removed a number of ubl state variables and padding which were largely unused - saved 58 bytes of both SRAM and EEPROM;
 * modified ubl sanity_check - no longer checks removed state variables that were otherwise unused, where checking didn't seem to accomplish anything, ultimately;
 * removed pre_initialized state, saving 64 bytes of SRAM;
 * removed automatic saving of UBL state after UBL activation/deactivation;
* consolidated multiple GRID_MAX_POINTS_X/Y to 'Global Leveling' section of EEPROM;
* minor update to G29 Sx notes/instructions;
* renamed mesh load and save parameter to 'slot' from 'm' for clarity;

Marlin/Configuration_adv.h

@@ -666,6 +666,10 @@
   #define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET))
   #define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET)
   #define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET))
+
+  // If this is defined, the currently active mesh will be saved in the
+  // current slot on M500.
+  #define UBL_SAVE_ACTIVE_ON_M500
 #endif
 
 // @section extras

Marlin/Marlin_main.cpp

@@ -8282,7 +8282,6 @@ void quickstop_stepper() {
         }
 
         ubl.load_mesh(storage_slot);
-        if (storage_slot != ubl.state.eeprom_storage_slot) ubl.store_state();
         ubl.state.eeprom_storage_slot = storage_slot;
       }
     #endif // AUTO_BED_LEVELING_UBL

Marlin/configuration_store.cpp

@@ -36,7 +36,7 @@
  *
  */
 
-#define EEPROM_VERSION "V35"
+#define EEPROM_VERSION "V36"
 
 // Change EEPROM version if these are changed:
 #define EEPROM_OFFSET 100
@@ -72,7 +72,7 @@
  *  224            mbl.z_offset                     (float)
  *  228            GRID_MAX_POINTS_X                (uint8_t)
  *  229            GRID_MAX_POINTS_Y                (uint8_t)
- *  230 G29 S3 XYZ z_values[][]                     (float x9, up to float x 81) +288
+ *  230 G29 S3 XYZ z_values[][]                     (float x9, up to float x81) +288
  *
  * HAS_BED_PROBE:                                   4 bytes
  *  266  M851      zprobe_zoffset                   (float)
@@ -87,6 +87,11 @@
  *  312  G29 L F   bilinear_start                   (int x2)
  *  316            z_values[][]                     (float x9, up to float x256) +988
  *
+ * AUTO_BED_LEVELING_UBL:                           6 bytes
+ *  324  G29 A     ubl.state.active                 (bool)
+ *  325  G29 Z     ubl.state.z_offset               (float)
+ *  329  G29 S     ubl.state.eeprom_storage_slot    (int8_t)
+ *
  * DELTA:                                           48 bytes
  *  348  M666 XYZ  endstop_adj                      (float x3)
  *  360  M665 R    delta_radius                     (float)
@@ -322,15 +327,15 @@ void MarlinSettings::postprocess() {
     #endif
 
     //
-    // General Leveling
+    // Global Leveling
     //
 
     #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
-      EEPROM_WRITE(planner.z_fade_height);
+      const float zfh = planner.z_fade_height;
     #else
-      dummy = 10.0;
-      EEPROM_WRITE(dummy);
+      const float zfh = 10.0;
     #endif
+    EEPROM_WRITE(zfh);
 
     //
     // Mesh Bed Leveling
@@ -349,8 +354,7 @@ void MarlinSettings::postprocess() {
       EEPROM_WRITE(mesh_num_x);
       EEPROM_WRITE(mesh_num_y);
       EEPROM_WRITE(mbl.z_values);
-    #else
-      // For disabled MBL write a default mesh
+    #else // For disabled MBL write a default mesh
       const bool leveling_is_on = false;
       dummy = 0.0f;
       const uint8_t mesh_num_x = 3, mesh_num_y = 3;
@@ -405,6 +409,19 @@ void MarlinSettings::postprocess() {
       for (uint16_t q = grid_max_x * grid_max_y; q--;) EEPROM_WRITE(dummy);
     #endif // AUTO_BED_LEVELING_BILINEAR
 
+    #if ENABLED(AUTO_BED_LEVELING_UBL)
+      EEPROM_WRITE(ubl.state.active);
+      EEPROM_WRITE(ubl.state.z_offset);
+      EEPROM_WRITE(ubl.state.eeprom_storage_slot);
+    #else
+      const bool ubl_active = 0;
+      dummy = 0.0f;
+      const int8_t eeprom_slot = -1;
+      EEPROM_WRITE(ubl_active);
+      EEPROM_WRITE(dummy);
+      EEPROM_WRITE(eeprom_slot);
+    #endif //AUTO_BED_LEVELING_UBL
+
     // 9 floats for DELTA / Z_DUAL_ENDSTOPS
     #if ENABLED(DELTA)
       EEPROM_WRITE(endstop_adj);               // 3 floats
@@ -608,8 +625,7 @@ void MarlinSettings::postprocess() {
       SERIAL_ECHOLNPGM(" bytes)");
     }
 
-    #if ENABLED(AUTO_BED_LEVELING_UBL)
-      ubl.store_state();
+    #if ENABLED(UBL_SAVE_ACTIVE_ON_M500)
       if (ubl.state.eeprom_storage_slot >= 0)
         ubl.store_mesh(ubl.state.eeprom_storage_slot);
     #endif
@@ -693,7 +709,7 @@ void MarlinSettings::postprocess() {
       #endif
 
       //
-      // General Leveling
+      // Global Leveling
       //
 
       #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
@@ -769,6 +785,18 @@ void MarlinSettings::postprocess() {
           for (uint16_t q = grid_max_x * grid_max_y; q--;) EEPROM_READ(dummy);
         }
 
+      #if ENABLED(AUTO_BED_LEVELING_UBL)
+        EEPROM_READ(ubl.state.active);
+        EEPROM_READ(ubl.state.z_offset);
+        EEPROM_READ(ubl.state.eeprom_storage_slot);
+      #else
+        bool dummyb;
+        uint8_t dummyui8;
+        EEPROM_READ(dummyb);
+        EEPROM_READ(dummy);
+        EEPROM_READ(dummyui8);
+      #endif //AUTO_BED_LEVELING_UBL
+
       #if ENABLED(DELTA)
         EEPROM_READ(endstop_adj);               // 3 floats
         EEPROM_READ(delta_radius);              // 1 float
@@ -951,27 +979,16 @@ void MarlinSettings::postprocess() {
         ubl.eeprom_start = (eeprom_index + 32) & 0xFFF8; // Pad the end of configuration data so it
                                                          // can float up or down a little bit without
                                                          // disrupting the Unified Bed Leveling data
-        ubl.load_state();
-
         SERIAL_ECHOPGM(" UBL ");
         if (!ubl.state.active) SERIAL_ECHO("not ");
         SERIAL_ECHOLNPGM("active!");
 
         if (!ubl.sanity_check()) {
-          int tmp_mesh;                                // We want to preserve whether the UBL System is Active
-          bool tmp_active;                             // If it is, we want to preserve the Mesh that is being used.
-          tmp_mesh = ubl.state.eeprom_storage_slot;
-          tmp_active = ubl.state.active;
-          SERIAL_ECHOLNPGM("\nInitializing Bed Leveling State to current firmware settings.\n");
-          ubl.state = ubl.pre_initialized;             // Initialize with the pre_initialized data structure
-          ubl.state.eeprom_storage_slot = tmp_mesh;    // But then restore some data we don't want mangled
-          ubl.state.active = tmp_active;
+          SERIAL_ECHOLNPGM("\nUnified Bed Leveling system initialized.\n");
         }
         else {
-          SERIAL_PROTOCOLPGM("?Unable to enable Unified Bed Leveling.\n");
-          ubl.state = ubl.pre_initialized;
+          SERIAL_PROTOCOLPGM("?Unable to enable Unified Bed Leveling system.\n");
           ubl.reset();
-          ubl.store_state();
         }
 
         if (ubl.state.eeprom_storage_slot >= 0) {
@@ -985,6 +1002,7 @@ void MarlinSettings::postprocess() {
         }
       #endif
     }
+
     #if ENABLED(EEPROM_CHITCHAT)
       report();
     #endif
@@ -1190,6 +1208,10 @@ void MarlinSettings::reset() {
     planner.advance_ed_ratio = LIN_ADVANCE_E_D_RATIO;
   #endif
 
+  #if ENABLED(AUTO_BED_LEVELING_UBL)
+    ubl.reset();
+  #endif
+
   postprocess();
 
   SERIAL_ECHO_START;

Marlin/ubl.cpp

@@ -57,7 +57,7 @@
     }
   }
 
-  ubl_state unified_bed_leveling::state, unified_bed_leveling::pre_initialized;
+  ubl_state unified_bed_leveling::state;
 
   float unified_bed_leveling::z_values[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y],
         unified_bed_leveling::last_specified_z;
@@ -78,59 +78,46 @@
     reset();
   }
 
-  void unified_bed_leveling::store_state() {
-    const uint16_t i = UBL_LAST_EEPROM_INDEX;
-    eeprom_write_block((void *)&ubl.state, (void *)i, sizeof(state));
-  }
-
-  void unified_bed_leveling::load_state() {
-    const uint16_t i = UBL_LAST_EEPROM_INDEX;
-    eeprom_read_block((void *)&ubl.state, (void *)i, sizeof(state));
-
-    if (sanity_check())
-      SERIAL_PROTOCOLLNPGM("?In load_state() sanity_check() failed.\n");
-  }
-
-  void unified_bed_leveling::load_mesh(const int16_t m) {
+  void unified_bed_leveling::load_mesh(const int16_t slot) {
     int16_t j = (UBL_LAST_EEPROM_INDEX - eeprom_start) / sizeof(z_values);
 
-    if (m == -1) {
+    if (slot == -1) {
       SERIAL_PROTOCOLLNPGM("?No mesh saved in EEPROM. Zeroing mesh in memory.\n");
       reset();
       return;
     }
 
-    if (!WITHIN(m, 0, j - 1) || eeprom_start <= 0) {
+    if (!WITHIN(slot, 0, j - 1) || eeprom_start <= 0) {
       SERIAL_PROTOCOLLNPGM("?EEPROM storage not available to load mesh.\n");
       return;
     }
 
-    j = UBL_LAST_EEPROM_INDEX - (m + 1) * sizeof(z_values);
+    j = UBL_LAST_EEPROM_INDEX - (slot + 1) * sizeof(z_values);
     eeprom_read_block((void *)&z_values, (void *)j, sizeof(z_values));
 
-    SERIAL_PROTOCOLPAIR("Mesh loaded from slot ", m);
+    SERIAL_PROTOCOLPAIR("Mesh loaded from slot ", slot);
     SERIAL_PROTOCOLLNPAIR(" at offset ", hex_address((void*)j));
   }
 
-  void unified_bed_leveling::store_mesh(const int16_t m) {
+  void unified_bed_leveling::store_mesh(const int16_t slot) {
     int16_t j = (UBL_LAST_EEPROM_INDEX - eeprom_start) / sizeof(z_values);
 
-    if (!WITHIN(m, 0, j - 1) || eeprom_start <= 0) {
+    if (!WITHIN(slot, 0, j - 1) || eeprom_start <= 0) {
       SERIAL_PROTOCOLLNPGM("?EEPROM storage not available to load mesh.\n");
-      SERIAL_PROTOCOL(m);
+      SERIAL_PROTOCOL(slot);
       SERIAL_PROTOCOLLNPGM(" mesh slots available.\n");
       SERIAL_PROTOCOLLNPAIR("E2END     : ", E2END);
       SERIAL_PROTOCOLLNPAIR("k         : ", (int)UBL_LAST_EEPROM_INDEX);
       SERIAL_PROTOCOLLNPAIR("j         : ", j);
-      SERIAL_PROTOCOLLNPAIR("m         : ", m);
+      SERIAL_PROTOCOLLNPAIR("m         : ", slot);
       SERIAL_EOL;
       return;
     }
 
-    j = UBL_LAST_EEPROM_INDEX - (m + 1) * sizeof(z_values);
+    j = UBL_LAST_EEPROM_INDEX - (slot + 1) * sizeof(z_values);
     eeprom_write_block((const void *)&z_values, (void *)j, sizeof(z_values));
 
-    SERIAL_PROTOCOLPAIR("Mesh saved in slot ", m);
+    SERIAL_PROTOCOLPAIR("Mesh saved in slot ", slot);
     SERIAL_PROTOCOLLNPAIR(" at offset ", hex_address((void*)j));
   }
 
@@ -227,49 +214,12 @@
   bool unified_bed_leveling::sanity_check() {
     uint8_t error_flag = 0;
 
-    if (state.n_x != GRID_MAX_POINTS_X) {
-      SERIAL_PROTOCOLLNPGM("?GRID_MAX_POINTS_X set wrong\n");
-      error_flag++;
-    }
-    if (state.n_y != GRID_MAX_POINTS_Y) {
-      SERIAL_PROTOCOLLNPGM("?GRID_MAX_POINTS_Y set wrong\n");
-      error_flag++;
-    }
-    if (state.mesh_x_min != UBL_MESH_MIN_X) {
-      SERIAL_PROTOCOLLNPGM("?UBL_MESH_MIN_X set wrong\n");
-      error_flag++;
-    }
-    if (state.mesh_y_min != UBL_MESH_MIN_Y) {
-      SERIAL_PROTOCOLLNPGM("?UBL_MESH_MIN_Y set wrong\n");
-      error_flag++;
-    }
-    if (state.mesh_x_max != UBL_MESH_MAX_X) {
-      SERIAL_PROTOCOLLNPGM("?UBL_MESH_MAX_X set wrong\n");
-      error_flag++;
-    }
-    if (state.mesh_y_max != UBL_MESH_MAX_Y) {
-      SERIAL_PROTOCOLLNPGM("?UBL_MESH_MAX_Y set wrong\n");
-      error_flag++;
-    }
-    if (state.mesh_x_dist != MESH_X_DIST) {
-      SERIAL_PROTOCOLLNPGM("?MESH_X_DIST set wrong\n");
-      error_flag++;
-    }
-    if (state.mesh_y_dist != MESH_Y_DIST) {
-      SERIAL_PROTOCOLLNPGM("?MESH_Y_DIST set wrong\n");
-      error_flag++;
-    }
-
     const int j = (UBL_LAST_EEPROM_INDEX - eeprom_start) / sizeof(z_values);
     if (j < 1) {
       SERIAL_PROTOCOLLNPGM("?No EEPROM storage available for a mesh of this size.\n");
       error_flag++;
     }
 
-    //  SERIAL_PROTOCOLPGM("?sanity_check() return value: ");
-    //  SERIAL_PROTOCOL(error_flag);
-    //  SERIAL_EOL;
-
     return !!error_flag;
   }
 

Marlin/ubl.h

@@ -87,27 +87,7 @@
   typedef struct {
     bool active = false;
     float z_offset = 0.0;
-    int8_t eeprom_storage_slot = -1,
-           n_x = GRID_MAX_POINTS_X,
-           n_y = GRID_MAX_POINTS_Y;
-
-    float mesh_x_min = UBL_MESH_MIN_X,
-          mesh_y_min = UBL_MESH_MIN_Y,
-          mesh_x_max = UBL_MESH_MAX_X,
-          mesh_y_max = UBL_MESH_MAX_Y,
-          mesh_x_dist = MESH_X_DIST,
-          mesh_y_dist = MESH_Y_DIST;
-
-    // If you change this struct, adjust TOTAL_STRUCT_SIZE
-
-    #define TOTAL_STRUCT_SIZE 32 // Total size of the above fields
-
-    // padding provides space to add state variables without
-    // changing the location of data structures in the EEPROM.
-    // This is for compatibility with future versions to keep
-    // users from having to regenerate their mesh data.
-    unsigned char padding[64 - TOTAL_STRUCT_SIZE];
-
+    int8_t eeprom_storage_slot = -1;
   } ubl_state;
 
   class unified_bed_leveling {
@@ -117,7 +97,7 @@
 
     public:
 
-      static ubl_state state, pre_initialized;
+      static ubl_state state;
 
       static float z_values[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y];
 
@@ -156,8 +136,6 @@
       static void reset();
       static void invalidate();
 
-      static void store_state();
-      static void load_state();
       static void store_mesh(const int16_t);
       static void load_mesh(const int16_t);
 
@@ -351,7 +329,7 @@
 
   extern unified_bed_leveling ubl;
 
-  #define UBL_LAST_EEPROM_INDEX (E2END - sizeof(unified_bed_leveling::state))
+  #define UBL_LAST_EEPROM_INDEX E2END
 
 #endif // AUTO_BED_LEVELING_UBL
 #endif // UNIFIED_BED_LEVELING_H

Marlin/ubl_G29.cpp

@@ -247,8 +247,8 @@
    *                    current state of the Unified Bed Leveling system in the EEPROM.
    *
    *   S #   Store      Store the current Mesh at the specified location in EEPROM. Activate this location
-   *                    for subsequent Load and Store operations. It will also store the current state of
-   *                    the Unified Bed Leveling system in the EEPROM.
+   *                    for subsequent Load and Store operations. Valid storage slot numbers begin at 0 and
+   *                    extend to a limit related to the available EEPROM storage.
    *
    *   S -1  Store      Store the current Mesh as a print out that is suitable to be feed back into the system
    *                    at a later date. The GCode output can be saved and later replayed by the host software
@@ -574,8 +574,6 @@
       }
       ubl.load_mesh(storage_slot);
       ubl.state.eeprom_storage_slot = storage_slot;
-      if (storage_slot != ubl.state.eeprom_storage_slot)
-        ubl.store_state();
       SERIAL_PROTOCOLLNPGM("Done.\n");
     }
 
@@ -609,9 +607,6 @@
       }
       ubl.store_mesh(storage_slot);
       ubl.state.eeprom_storage_slot = storage_slot;
-      //
-      //  if (storage_slot != ubl.state.eeprom_storage_slot)
-      ubl.store_state();    // Always save an updated copy of the UBL State info
 
       SERIAL_PROTOCOLLNPGM("Done.\n");
     }
@@ -1048,7 +1043,6 @@
     if (code_seen('A')) {     // Activate the Unified Bed Leveling System
       ubl.state.active = 1;
       SERIAL_PROTOCOLLNPGM("Unified Bed Leveling System activated.\n");
-      ubl.store_state();
     }
 
     c_flag = code_seen('C') && code_has_value();
@@ -1057,7 +1051,6 @@
     if (code_seen('D')) {     // Disable the Unified Bed Leveling System
       ubl.state.active = 0;
       SERIAL_PROTOCOLLNPGM("Unified Bed Leveling System de-activated.\n");
-      ubl.store_state();
     }
 
     #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)