bissen21/Marlin_Firmware
1
0
Fork 0
Code Issues Pull Requests Projects Releases 4 Wiki Activity

Merge pull request #6283 from thinkyhead/rc_eeprom_z_fade

Browse Source 
Save / restore z_fade_height in EEPROM
This commit is contained in:
Scott Lahteine 2017-04-10 20:05:20 -05:00 committed by GitHub
commit 67fb7f82ac
7 changed files with 165 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Marlin/Marlin.h
View File

@ -307,6 +307,10 @@ float code_value_temp_diff();
void reset_bed_level(); void reset_bed_level();
#endif #endif
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
void set_z_fade_height(const float zfh);
#endif
#if ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(Z_DUAL_ENDSTOPS)
extern float z_endstop_adj; extern float z_endstop_adj;
#endif #endif

12
Marlin/Marlin_main.cpp
View File

@ -573,7 +573,7 @@ static uint8_t target_extruder;
endstop_adj[ABC] = { 0 }; endstop_adj[ABC] = { 0 };
// These values are loaded or reset at boot time when setup() calls // These values are loaded or reset at boot time when setup() calls
// Config_RetrieveSettings(), which calls recalc_delta_settings(). // settings.load(), which calls recalc_delta_settings().
float delta_radius, float delta_radius,
delta_tower_angle_trim[ABC], delta_tower_angle_trim[ABC],
delta_tower[ABC][2], delta_tower[ABC][2],
@ -7898,28 +7898,28 @@ void quickstop_stepper() {
* M500: Store settings in EEPROM * M500: Store settings in EEPROM
*/ */
inline void gcode_M500() { inline void gcode_M500() {
(void)Config_StoreSettings(); (void)settings.save();
} }
/** /**
* M501: Read settings from EEPROM * M501: Read settings from EEPROM
*/ */
inline void gcode_M501() { inline void gcode_M501() {
(void)Config_RetrieveSettings(); (void)settings.load();
} }
/** /**
* M502: Revert to default settings * M502: Revert to default settings
*/ */
inline void gcode_M502() { inline void gcode_M502() {
(void)Config_ResetDefault(); (void)settings.reset();
} }
/** /**
* M503: print settings currently in memory * M503: print settings currently in memory
*/ */
inline void gcode_M503() { inline void gcode_M503() {
(void)Config_PrintSettings(code_seen('S') && !code_value_bool()); (void)settings.report(code_seen('S') && !code_value_bool());
} }
#if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED) #if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED)
@ -11343,7 +11343,7 @@ void setup() {
// Load data from EEPROM if available (or use defaults) // Load data from EEPROM if available (or use defaults)
// This also updates variables in the planner, elsewhere // This also updates variables in the planner, elsewhere
(void)Config_RetrieveSettings(); (void)settings.load();
#if DISABLED(NO_WORKSPACE_OFFSETS) #if DISABLED(NO_WORKSPACE_OFFSETS)
// Initialize current position based on home_offset // Initialize current position based on home_offset

158
Marlin/configuration_store.cpp
View File

@ -23,7 +23,7 @@
/** /**
* configuration_store.cpp * configuration_store.cpp
* *
* Configuration and EEPROM storage * Settings and EEPROM storage
* *
* IMPORTANT: Whenever there are changes made to the variables stored in EEPROM * IMPORTANT: Whenever there are changes made to the variables stored in EEPROM
* in the functions below, also increment the version number. This makes sure that * in the functions below, also increment the version number. This makes sure that
@ -36,13 +36,13 @@
* *
*/ */
#define EEPROM_VERSION "V32" #define EEPROM_VERSION "V33"
// Change EEPROM version if these are changed: // Change EEPROM version if these are changed:
#define EEPROM_OFFSET 100 #define EEPROM_OFFSET 100
/** /**
* V32 EEPROM Layout: * V33 EEPROM Layout:
* *
* 100 Version (char x4) * 100 Version (char x4)
* 104 EEPROM Checksum (uint16_t) * 104 EEPROM Checksum (uint16_t)
@ -64,25 +64,28 @@
* 195 M206 XYZ home_offset (float x3) * 195 M206 XYZ home_offset (float x3)
* 207 M218 XYZ hotend_offset (float x3 per additional hotend) * 207 M218 XYZ hotend_offset (float x3 per additional hotend)
* *
* Global Leveling:
* 219 z_fade_height (float)
*
* Mesh bed leveling: 43 bytes * Mesh bed leveling: 43 bytes
* 219 M420 S from mbl.status (bool) * 223 M420 S from mbl.status (bool)
* 220 mbl.z_offset (float) * 224 mbl.z_offset (float)
* 224 GRID_MAX_POINTS_X (uint8_t) * 228 GRID_MAX_POINTS_X (uint8_t)
* 225 GRID_MAX_POINTS_Y (uint8_t) * 229 GRID_MAX_POINTS_Y (uint8_t)
* 226 G29 S3 XYZ z_values[][] (float x9, up to float x 81) +288 * 230 G29 S3 XYZ z_values[][] (float x9, up to float x 81) +288
* *
* AUTO BED LEVELING 4 bytes * AUTO BED LEVELING 4 bytes
* 262 M851 zprobe_zoffset (float) * 266 M851 zprobe_zoffset (float)
* *
* ABL_PLANAR (or placeholder): 36 bytes * ABL_PLANAR (or placeholder): 36 bytes
* 266 planner.bed_level_matrix (matrix_3x3 = float x9) * 270 planner.bed_level_matrix (matrix_3x3 = float x9)
* *
* AUTO_BED_LEVELING_BILINEAR (or placeholder): 47 bytes * AUTO_BED_LEVELING_BILINEAR (or placeholder): 47 bytes
* 302 GRID_MAX_POINTS_X (uint8_t) * 306 GRID_MAX_POINTS_X (uint8_t)
* 303 GRID_MAX_POINTS_Y (uint8_t) * 307 GRID_MAX_POINTS_Y (uint8_t)
* 304 bilinear_grid_spacing (int x2) * 308 bilinear_grid_spacing (int x2)
* 308 G29 L F bilinear_start (int x2) * 312 G29 L F bilinear_start (int x2)
* 312 bed_level_grid[][] (float x9, up to float x256) +988 * 316 bed_level_grid[][] (float x9, up to float x256) +988
* *
* DELTA (if deltabot): 48 bytes * DELTA (if deltabot): 48 bytes
* 348 M666 XYZ endstop_adj (float x3) * 348 M666 XYZ endstop_adj (float x3)
@ -144,18 +147,21 @@
* 568 M906 E1 stepperE1 current (uint16_t) * 568 M906 E1 stepperE1 current (uint16_t)
* 570 M906 E2 stepperE2 current (uint16_t) * 570 M906 E2 stepperE2 current (uint16_t)
* 572 M906 E3 stepperE3 current (uint16_t) * 572 M906 E3 stepperE3 current (uint16_t)
* 572 M906 E4 stepperE4 current (uint16_t) * 576 M906 E4 stepperE4 current (uint16_t)
* *
* 576 Minimum end-point * 580 Minimum end-point
* 1897 (576 + 36 + 9 + 288 + 988) Maximum end-point * 1901 (580 + 36 + 9 + 288 + 988) Maximum end-point
*/ */
#include "configuration_store.h"
MarlinSettings settings;
#include "Marlin.h" #include "Marlin.h"
#include "language.h" #include "language.h"
#include "endstops.h" #include "endstops.h"
#include "planner.h" #include "planner.h"
#include "temperature.h" #include "temperature.h"
#include "ultralcd.h" #include "ultralcd.h"
#include "configuration_store.h"
#if ENABLED(MESH_BED_LEVELING) #if ENABLED(MESH_BED_LEVELING)
#include "mesh_bed_leveling.h" #include "mesh_bed_leveling.h"
@ -176,7 +182,7 @@
/** /**
* Post-process after Retrieve or Reset * Post-process after Retrieve or Reset
*/ */
void Config_Postprocess() { void MarlinSettings::postprocess() {
// steps per s2 needs to be updated to agree with units per s2 // steps per s2 needs to be updated to agree with units per s2
planner.reset_acceleration_rates(); planner.reset_acceleration_rates();
@ -200,16 +206,28 @@ void Config_Postprocess() {
// Software endstops depend on home_offset // Software endstops depend on home_offset
LOOP_XYZ(i) update_software_endstops((AxisEnum)i); LOOP_XYZ(i) update_software_endstops((AxisEnum)i);
#endif #endif
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
set_z_fade_height(
//#if ENABLED(AUTO_BED_LEVELING_UBL)
// ubl.state.g29_correction_fade_height
//#else
planner.z_fade_height
//#endif
);
#endif
} }
#if ENABLED(EEPROM_SETTINGS) #if ENABLED(EEPROM_SETTINGS)
uint16_t eeprom_checksum;
const char version[4] = EEPROM_VERSION; const char version[4] = EEPROM_VERSION;
bool eeprom_write_error; uint16_t MarlinSettings::eeprom_checksum;
void _EEPROM_writeData(int &pos, const uint8_t* value, uint16_t size) { bool MarlinSettings::eeprom_write_error,
MarlinSettings::eeprom_read_error;
void MarlinSettings::write_data(int &pos, const uint8_t* value, uint16_t size) {
if (eeprom_write_error) return; if (eeprom_write_error) return;
while (size--) { while (size--) {
uint8_t * const p = (uint8_t * const)pos; uint8_t * const p = (uint8_t * const)pos;
@ -230,8 +248,7 @@ void Config_Postprocess() {
value++; value++;
}; };
} }
bool eeprom_read_error; void MarlinSettings::read_data(int &pos, uint8_t* value, uint16_t size) {
void _EEPROM_readData(int &pos, uint8_t* value, uint16_t size) {
do { do {
uint8_t c = eeprom_read_byte((unsigned char*)pos); uint8_t c = eeprom_read_byte((unsigned char*)pos);
if (!eeprom_read_error) *value = c; if (!eeprom_read_error) *value = c;
@ -244,14 +261,14 @@ void Config_Postprocess() {
#define DUMMY_PID_VALUE 3000.0f #define DUMMY_PID_VALUE 3000.0f
#define EEPROM_START() int eeprom_index = EEPROM_OFFSET #define EEPROM_START() int eeprom_index = EEPROM_OFFSET
#define EEPROM_SKIP(VAR) eeprom_index += sizeof(VAR) #define EEPROM_SKIP(VAR) eeprom_index += sizeof(VAR)
#define EEPROM_WRITE(VAR) _EEPROM_writeData(eeprom_index, (uint8_t*)&VAR, sizeof(VAR)) #define EEPROM_WRITE(VAR) write_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR))
#define EEPROM_READ(VAR) _EEPROM_readData(eeprom_index, (uint8_t*)&VAR, sizeof(VAR)) #define EEPROM_READ(VAR) read_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR))
#define EEPROM_ASSERT(TST,ERR) if () do{ SERIAL_ERROR_START; SERIAL_ERRORLNPGM(ERR); eeprom_read_error |= true; }while(0) #define EEPROM_ASSERT(TST,ERR) if (!(TST)) do{ SERIAL_ERROR_START; SERIAL_ERRORLNPGM(ERR); eeprom_read_error = true; }while(0)
/** /**
* M500 - Store Configuration * M500 - Store Configuration
*/ */
bool Config_StoreSettings() { bool MarlinSettings::save() {
float dummy = 0.0f; float dummy = 0.0f;
char ver[4] = "000"; char ver[4] = "000";
@ -289,6 +306,17 @@ void Config_Postprocess() {
LOOP_XYZ(i) EEPROM_WRITE(hotend_offset[i][e]); LOOP_XYZ(i) EEPROM_WRITE(hotend_offset[i][e]);
#endif #endif
//
// General Leveling
//
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
EEPROM_WRITE(planner.z_fade_height);
#else
dummy = 10.0;
EEPROM_WRITE(dummy);
#endif
// //
// Mesh Bed Leveling // Mesh Bed Leveling
// //
@ -552,7 +580,7 @@ void Config_Postprocess() {
/** /**
* M501 - Retrieve Configuration * M501 - Retrieve Configuration
*/ */
bool Config_RetrieveSettings() { bool MarlinSettings::load() {
EEPROM_START(); EEPROM_START();
eeprom_read_error = false; // If set EEPROM_READ won't write into RAM eeprom_read_error = false; // If set EEPROM_READ won't write into RAM
@ -573,7 +601,7 @@ void Config_Postprocess() {
SERIAL_ECHOPGM("EEPROM version mismatch "); SERIAL_ECHOPGM("EEPROM version mismatch ");
SERIAL_ECHOPAIR("(EEPROM=", stored_ver); SERIAL_ECHOPAIR("(EEPROM=", stored_ver);
SERIAL_ECHOLNPGM(" Marlin=" EEPROM_VERSION ")"); SERIAL_ECHOLNPGM(" Marlin=" EEPROM_VERSION ")");
Config_ResetDefault(); reset();
} }
else { else {
float dummy = 0; float dummy = 0;
@ -618,6 +646,16 @@ void Config_Postprocess() {
LOOP_XYZ(i) EEPROM_READ(hotend_offset[i][e]); LOOP_XYZ(i) EEPROM_READ(hotend_offset[i][e]);
#endif #endif
//
// General Leveling
//
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
EEPROM_READ(planner.z_fade_height);
#else
EEPROM_READ(dummy);
#endif
// //
// Mesh (Manual) Bed Leveling // Mesh (Manual) Bed Leveling
// //
@ -713,6 +751,11 @@ void Config_Postprocess() {
EEPROM_READ(lcd_preheat_bed_temp); EEPROM_READ(lcd_preheat_bed_temp);
EEPROM_READ(lcd_preheat_fan_speed); EEPROM_READ(lcd_preheat_fan_speed);
//EEPROM_ASSERT(
// WITHIN(lcd_preheat_fan_speed, 0, 255),
// "lcd_preheat_fan_speed out of range"
//);
#if ENABLED(PIDTEMP) #if ENABLED(PIDTEMP)
for (uint8_t e = 0; e < MAX_EXTRUDERS; e++) { for (uint8_t e = 0; e < MAX_EXTRUDERS; e++) {
EEPROM_READ(dummy); // Kp EEPROM_READ(dummy); // Kp
@ -835,9 +878,9 @@ void Config_Postprocess() {
if (eeprom_checksum == stored_checksum) { if (eeprom_checksum == stored_checksum) {
if (eeprom_read_error) if (eeprom_read_error)
Config_ResetDefault(); reset();
else { else {
Config_Postprocess(); postprocess();
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHO(version); SERIAL_ECHO(version);
SERIAL_ECHOPAIR(" stored settings retrieved (", eeprom_index - (EEPROM_OFFSET)); SERIAL_ECHOPAIR(" stored settings retrieved (", eeprom_index - (EEPROM_OFFSET));
@ -847,7 +890,7 @@ void Config_Postprocess() {
else { else {
SERIAL_ERROR_START; SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("EEPROM checksum mismatch"); SERIAL_ERRORLNPGM("EEPROM checksum mismatch");
Config_ResetDefault(); reset();
} }
#if ENABLED(AUTO_BED_LEVELING_UBL) #if ENABLED(AUTO_BED_LEVELING_UBL)
@ -889,7 +932,7 @@ void Config_Postprocess() {
#endif #endif
} }
#if ENABLED(EEPROM_CHITCHAT) #if ENABLED(EEPROM_CHITCHAT)
Config_PrintSettings(); report();
#endif #endif
return !eeprom_read_error; return !eeprom_read_error;
@ -897,7 +940,7 @@ void Config_Postprocess() {
#else // !EEPROM_SETTINGS #else // !EEPROM_SETTINGS
bool Config_StoreSettings() { bool MarlinSettings::save() {
SERIAL_ERROR_START; SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("EEPROM disabled"); SERIAL_ERRORLNPGM("EEPROM disabled");
return false; return false;
@ -908,7 +951,7 @@ void Config_Postprocess() {
/** /**
* M502 - Reset Configuration * M502 - Reset Configuration
*/ */
void Config_ResetDefault() { void MarlinSettings::reset() {
const float tmp1[] = DEFAULT_AXIS_STEPS_PER_UNIT, tmp2[] = DEFAULT_MAX_FEEDRATE; const float tmp1[] = DEFAULT_AXIS_STEPS_PER_UNIT, tmp2[] = DEFAULT_MAX_FEEDRATE;
const uint32_t tmp3[] = DEFAULT_MAX_ACCELERATION; const uint32_t tmp3[] = DEFAULT_MAX_ACCELERATION;
LOOP_XYZE_N(i) { LOOP_XYZE_N(i) {
@ -927,6 +970,11 @@ void Config_ResetDefault() {
planner.max_jerk[Y_AXIS] = DEFAULT_YJERK; planner.max_jerk[Y_AXIS] = DEFAULT_YJERK;
planner.max_jerk[Z_AXIS] = DEFAULT_ZJERK; planner.max_jerk[Z_AXIS] = DEFAULT_ZJERK;
planner.max_jerk[E_AXIS] = DEFAULT_EJERK; planner.max_jerk[E_AXIS] = DEFAULT_EJERK;
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
planner.z_fade_height = 0.0;
#endif
#if DISABLED(NO_WORKSPACE_OFFSETS) #if DISABLED(NO_WORKSPACE_OFFSETS)
ZERO(home_offset); ZERO(home_offset);
#endif #endif
@ -968,11 +1016,13 @@ void Config_ResetDefault() {
COPY(delta_diagonal_rod_trim, drt); COPY(delta_diagonal_rod_trim, drt);
COPY(delta_tower_angle_trim, dta); COPY(delta_tower_angle_trim, dta);
#elif ENABLED(Z_DUAL_ENDSTOPS) #elif ENABLED(Z_DUAL_ENDSTOPS)
#if defined(Z_DUAL_ENDSTOPS_ADJUSTMENT) float z_endstop_adj =
float z_endstop_adj = Z_DUAL_ENDSTOPS_ADJUSTMENT; #ifdef Z_DUAL_ENDSTOPS_ADJUSTMENT
Z_DUAL_ENDSTOPS_ADJUSTMENT
#else #else
float z_endstop_adj = 0; 0
#endif #endif
;
#endif #endif
#if ENABLED(ULTIPANEL) #if ENABLED(ULTIPANEL)
@ -1077,7 +1127,7 @@ void Config_ResetDefault() {
#endif #endif
#endif #endif
Config_Postprocess(); postprocess();
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("Hardcoded Default Settings Loaded"); SERIAL_ECHOLNPGM("Hardcoded Default Settings Loaded");
@ -1088,10 +1138,11 @@ void Config_ResetDefault() {
#define CONFIG_ECHO_START do{ if (!forReplay) SERIAL_ECHO_START; }while(0) #define CONFIG_ECHO_START do{ if (!forReplay) SERIAL_ECHO_START; }while(0)
/** /**
* M503 - Print Configuration * M503 - Report current settings in RAM
*
* Unless specifically disabled, M503 is available even without EEPROM
*/ */
void Config_PrintSettings(bool forReplay) { void MarlinSettings::report(bool forReplay) {
// Always have this function, even with EEPROM_SETTINGS disabled, the current values will be shown
CONFIG_ECHO_START; CONFIG_ECHO_START;
@ -1211,7 +1262,11 @@ void Config_ResetDefault() {
SERIAL_ECHOLNPGM("Mesh Bed Leveling:"); SERIAL_ECHOLNPGM("Mesh Bed Leveling:");
CONFIG_ECHO_START; CONFIG_ECHO_START;
} }
SERIAL_ECHOLNPAIR(" M420 S", mbl.has_mesh() ? 1 : 0); SERIAL_ECHOPAIR(" M420 S", mbl.has_mesh() ? 1 : 0);
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
SERIAL_ECHOLNPAIR(" Z", planner.z_fade_height);
#endif
SERIAL_EOL;
for (uint8_t py = 1; py <= GRID_MAX_POINTS_Y; py++) { for (uint8_t py = 1; py <= GRID_MAX_POINTS_Y; py++) {
for (uint8_t px = 1; px <= GRID_MAX_POINTS_X; px++) { for (uint8_t px = 1; px <= GRID_MAX_POINTS_X; px++) {
CONFIG_ECHO_START; CONFIG_ECHO_START;
@ -1229,8 +1284,11 @@ void Config_ResetDefault() {
SERIAL_ECHOLNPGM("Unified Bed Leveling:"); SERIAL_ECHOLNPGM("Unified Bed Leveling:");
CONFIG_ECHO_START; CONFIG_ECHO_START;
} }
SERIAL_ECHOPAIR(" M420 S", ubl.state.active ? 1 : 0);
SERIAL_ECHOLNPAIR(" M420 S", ubl.state.active ? 1 : 0); //#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
// SERIAL_ECHOLNPAIR(" Z", ubl.state.g29_correction_fade_height);
//#endif
SERIAL_EOL;
if (!forReplay) { if (!forReplay) {
SERIAL_ECHOPGM("\nUBL is "); SERIAL_ECHOPGM("\nUBL is ");
@ -1264,7 +1322,11 @@ void Config_ResetDefault() {
SERIAL_ECHOLNPGM("Auto Bed Leveling:"); SERIAL_ECHOLNPGM("Auto Bed Leveling:");
CONFIG_ECHO_START; CONFIG_ECHO_START;
} }
SERIAL_ECHOLNPAIR(" M420 S", planner.abl_enabled ? 1 : 0); SERIAL_ECHOPAIR(" M420 S", planner.abl_enabled ? 1 : 0);
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
SERIAL_ECHOLNPAIR(" Z", planner.z_fade_height);
#endif
SERIAL_EOL;
#endif #endif

37
Marlin/configuration_store.h
View File

@ -25,19 +25,38 @@
#include "MarlinConfig.h" #include "MarlinConfig.h"
void Config_ResetDefault(); class MarlinSettings {
bool Config_StoreSettings(); public:
MarlinSettings() { }
#if DISABLED(DISABLE_M503) static void reset();
void Config_PrintSettings(bool forReplay=false); static bool save();
#else
FORCE_INLINE void Config_PrintSettings(bool forReplay=false) {}
#endif
#if ENABLED(EEPROM_SETTINGS) #if ENABLED(EEPROM_SETTINGS)
bool Config_RetrieveSettings(); static bool load();
#else #else
FORCE_INLINE bool Config_RetrieveSettings() { Config_ResetDefault(); Config_PrintSettings(); return true; } FORCE_INLINE
static bool load() { reset(); report(); return true; }
#endif #endif
#if DISABLED(DISABLE_M503)
static void report(bool forReplay=false);
#else
FORCE_INLINE
static void report(bool forReplay=false) { }
#endif
private:
static void postprocess();
#if ENABLED(EEPROM_SETTINGS)
static uint16_t eeprom_checksum;
static bool eeprom_read_error, eeprom_write_error;
static void write_data(int &pos, const uint8_t* value, uint16_t size);
static void read_data(int &pos, uint8_t* value, uint16_t size);
#endif
};
extern MarlinSettings settings;
#endif // CONFIGURATION_STORE_H #endif // CONFIGURATION_STORE_H

4
Marlin/planner.cpp
View File

@ -109,8 +109,8 @@ float Planner::min_feedrate_mm_s,
#endif #endif
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT) #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
float Planner::z_fade_height = 0.0, float Planner::z_fade_height,
Planner::inverse_z_fade_height = 0.0; Planner::inverse_z_fade_height;
#endif #endif
#if ENABLED(AUTOTEMP) #if ENABLED(AUTOTEMP)

6
Marlin/ultralcd.cpp
View File

@ -2046,12 +2046,12 @@ void kill_screen(const char* lcd_msg) {
*/ */
#if ENABLED(EEPROM_SETTINGS) #if ENABLED(EEPROM_SETTINGS)
static void lcd_store_settings() { lcd_completion_feedback(Config_StoreSettings()); } static void lcd_store_settings() { lcd_completion_feedback(settings.save()); }
static void lcd_load_settings() { lcd_completion_feedback(Config_RetrieveSettings()); } static void lcd_load_settings() { lcd_completion_feedback(settings.load()); }
#endif #endif
static void lcd_factory_settings() { static void lcd_factory_settings() {
Config_ResetDefault(); settings.reset();
lcd_completion_feedback(); lcd_completion_feedback();
} }