From f41fb2b6358cd10d3a0e7896a543c4bd123bdca9 Mon Sep 17 00:00:00 2001 From: Brian Date: Sat, 22 Apr 2017 17:04:28 -0400 Subject: [PATCH] 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 | 4 ++ Marlin/Marlin_main.cpp | 1 - Marlin/configuration_store.cpp | 70 +++++++++++++++++++++----------- Marlin/ubl.cpp | 74 ++++++---------------------------- Marlin/ubl.h | 28 ++----------- Marlin/ubl_G29.cpp | 11 +---- 6 files changed, 67 insertions(+), 121 deletions(-) mode change 100644 => 100755 Marlin/Configuration_adv.h mode change 100644 => 100755 Marlin/Marlin_main.cpp diff --git a/Marlin/Configuration_adv.h b/Marlin/Configuration_adv.h old mode 100644 new mode 100755 index 30e40fbffb..afad3eaa8a --- a/Marlin/Configuration_adv.h +++ b/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 diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp old mode 100644 new mode 100755 index 1069186821..8271056ecc --- a/Marlin/Marlin_main.cpp +++ b/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 diff --git a/Marlin/configuration_store.cpp b/Marlin/configuration_store.cpp index 3dd7595a8b..61e6e99108 100755 --- a/Marlin/configuration_store.cpp +++ b/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; diff --git a/Marlin/ubl.cpp b/Marlin/ubl.cpp index 1d6e06fdab..9eb469fdd6 100755 --- a/Marlin/ubl.cpp +++ b/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; } diff --git a/Marlin/ubl.h b/Marlin/ubl.h index 6cc45b4871..9ddf67b975 100755 --- a/Marlin/ubl.h +++ b/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 diff --git a/Marlin/ubl_G29.cpp b/Marlin/ubl_G29.cpp index ccd5035f15..e6ff144b89 100755 --- a/Marlin/ubl_G29.cpp +++ b/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)