UBL G29 works without settings.load()

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

 
   void unified_bed_leveling::G29() {
 
-    if (!settings.calc_num_meshes()) {
-      SERIAL_PROTOCOLLNPGM("?Enable EEPROM and init with");
-      SERIAL_PROTOCOLLNPGM("M502, M500, M501 in that order.\n");
-      return;
-    }
-
     if (g29_parameter_parsing()) return; // abort if parsing the simple parameters causes a problem,
 
     // Check for commands that require the printer to be homed
       SERIAL_EOL();
       safe_delay(50);
 
-      SERIAL_PROTOCOLPAIR("Meshes go from ", hex_address((void*)settings.get_start_of_meshes()));
+      SERIAL_PROTOCOLPAIR("Meshes go from ", hex_address((void*)settings.meshes_start_index()));
-      SERIAL_PROTOCOLLNPAIR(" to ", hex_address((void*)settings.get_end_of_meshes()));
+      SERIAL_PROTOCOLLNPAIR(" to ", hex_address((void*)settings.meshes_end_index()));
       safe_delay(50);
 
       SERIAL_PROTOCOLLNPAIR("sizeof(ubl) :  ", (int)sizeof(ubl));
       SERIAL_EOL();
       safe_delay(25);
 
-      SERIAL_PROTOCOLLNPAIR("EEPROM free for UBL: ", hex_address((void*)(settings.get_end_of_meshes() - settings.get_start_of_meshes())));
+      SERIAL_PROTOCOLLNPAIR("EEPROM free for UBL: ", hex_address((void*)(settings.meshes_end_index() - settings.meshes_start_index())));
       safe_delay(50);
 
       SERIAL_PROTOCOLPAIR("EEPROM can hold ", settings.calc_num_meshes());

Marlin/src/lcd/ultralcd.cpp

       MENU_BACK(MSG_UBL_LEVEL_BED);
       if (!WITHIN(ubl_storage_slot, 0, a - 1)) {
         STATIC_ITEM(MSG_NO_STORAGE);
-        STATIC_ITEM(MSG_INIT_EEPROM);
       }
       else {
         MENU_ITEM_EDIT(int3, MSG_UBL_STORAGE_SLOT, &ubl_storage_slot, 0, a - 1);

Marlin/src/module/configuration_store.cpp

 
   bool MarlinSettings::eeprom_error, MarlinSettings::validating;
 
-  #if ENABLED(AUTO_BED_LEVELING_UBL)
-    int16_t MarlinSettings::meshes_begin;
-  #endif
-
   bool MarlinSettings::size_error(const uint16_t size) {
     if (size != datasize()) {
       SERIAL_ERROR_START();
       }
 
       #if ENABLED(AUTO_BED_LEVELING_UBL)
-        meshes_begin = (eeprom_index + 32) & 0xFFF8;  // Pad the end of configuration data so it
-                                                      // can float up or down a little bit without
-                                                      // disrupting the mesh data
         ubl.report_state();
 
         if (!validating) {
       }
     #endif
 
-    uint16_t MarlinSettings::calc_num_meshes() {
+    int16_t MarlinSettings::meshes_start_index() {
-      //obviously this will get more sophisticated once we've added an actual MAT
+      return (datasize() + EEPROM_OFFSET + 32) & 0xFFF8;  // Pad the end of configuration data so it can float up
-
+                                                          // or down a little bit without disrupting the mesh data
-      if (meshes_begin <= 0) return 0;
+    }
 
-      return (meshes_end - meshes_begin) / sizeof(ubl.z_values);
+    uint16_t MarlinSettings::calc_num_meshes() {
+      return (meshes_end - meshes_start_index()) / sizeof(ubl.z_values);
     }
 
     void MarlinSettings::store_mesh(const int8_t slot) {

Marlin/src/module/configuration_store.h

       bool success = true;
       reset();
       #if ENABLED(EEPROM_SETTINGS)
-        if ((success = save())) {
+        success = save();
-          #if ENABLED(AUTO_BED_LEVELING_UBL)
+        #if ENABLED(EEPROM_CHITCHAT)
-            success = load(); // UBL uses load() to know the end of EEPROM
+          if (success) report();
-          #elif ENABLED(EEPROM_CHITCHAT)
+        #endif
-            report();
-          #endif
-        }
       #endif
       return success;
     }
 
       #if ENABLED(AUTO_BED_LEVELING_UBL) // Eventually make these available if any leveling system
                                          // That can store is enabled
-        FORCE_INLINE static int16_t get_start_of_meshes() { return meshes_begin; }
+        static int16_t meshes_start_index();
-        FORCE_INLINE static int16_t get_end_of_meshes() { return meshes_end; }
+        FORCE_INLINE static int16_t meshes_end_index() { return meshes_end; }
         static uint16_t calc_num_meshes();
         static void store_mesh(const int8_t slot);
         static void load_mesh(const int8_t slot, void * const into=NULL);
 
       #if ENABLED(AUTO_BED_LEVELING_UBL) // Eventually make these available if any leveling system
                                          // That can store is enabled
-        static int16_t meshes_begin;
         const static int16_t meshes_end = E2END - 128; // 128 is a placeholder for the size of the MAT; the MAT will always
                                                        // live at the very end of the eeprom