andrey
/
Marlin_FB4S
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Merge pull request #4397 from thinkyhead/rc_tweak_eeprom 

Neaten up EEPROM read/write functions
pull/1/head
Scott Lahteine 8 years ago
committed by GitHub
parent
b7b7c90477 060dc6d95a
commit
7c27f34996
2 changed files with 155 additions and 146 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      Marlin/Marlin.h
  2. 300
      Marlin/configuration_store.cpp

1
Marlin/Marlin.h
View File

@ -114,6 +114,7 @@ void serial_echopair_P(const char* s_P, long v);
void serial_echopair_P(const char* s_P, float v); void serial_echopair_P(const char* s_P, float v);
void serial_echopair_P(const char* s_P, double v); void serial_echopair_P(const char* s_P, double v);
void serial_echopair_P(const char* s_P, unsigned long v); void serial_echopair_P(const char* s_P, unsigned long v);
FORCE_INLINE void serial_echopair_P(const char* s_P, uint16_t v) { serial_echopair_P(s_P, (int)v); }
FORCE_INLINE void serial_echopair_P(const char* s_P, bool v) { serial_echopair_P(s_P, (int)v); } FORCE_INLINE void serial_echopair_P(const char* s_P, bool v) { serial_echopair_P(s_P, (int)v); }
FORCE_INLINE void serial_echopair_P(const char* s_P, void *v) { serial_echopair_P(s_P, (unsigned long)v); } FORCE_INLINE void serial_echopair_P(const char* s_P, void *v) { serial_echopair_P(s_P, (unsigned long)v); }

300
Marlin/configuration_store.cpp
View File

@ -191,8 +191,10 @@ void Config_Postprocess() {
#if ENABLED(EEPROM_SETTINGS) #if ENABLED(EEPROM_SETTINGS)
#define DUMMY_PID_VALUE 3000.0f #define DUMMY_PID_VALUE 3000.0f
#define EEPROM_WRITE_VAR(pos, value) _EEPROM_writeData(pos, (uint8_t*)&value, sizeof(value)) #define EEPROM_START() int eeprom_index = EEPROM_OFFSET
#define EEPROM_READ_VAR(pos, value) _EEPROM_readData(pos, (uint8_t*)&value, sizeof(value)) #define EEPROM_SKIP(VAR) eeprom_index += sizeof(VAR)
#define EEPROM_WRITE(VAR) _EEPROM_writeData(eeprom_index, (uint8_t*)&VAR, sizeof(VAR))
#define EEPROM_READ(VAR) _EEPROM_readData(eeprom_index, (uint8_t*)&VAR, sizeof(VAR))
/** /**
* M500 - Store Configuration * M500 - Store Configuration
@ -200,26 +202,27 @@ void Config_Postprocess() {
void Config_StoreSettings() { void Config_StoreSettings() {
float dummy = 0.0f; float dummy = 0.0f;
char ver[4] = "000"; char ver[4] = "000";
int i = EEPROM_OFFSET;
EEPROM_WRITE_VAR(i, ver); // invalidate data first EEPROM_START();
i += sizeof(eeprom_checksum); // Skip the checksum slot
EEPROM_WRITE(ver); // invalidate data first
EEPROM_SKIP(eeprom_checksum); // Skip the checksum slot
eeprom_checksum = 0; // clear before first "real data" eeprom_checksum = 0; // clear before first "real data"
EEPROM_WRITE_VAR(i, planner.axis_steps_per_mm); EEPROM_WRITE(planner.axis_steps_per_mm);
EEPROM_WRITE_VAR(i, planner.max_feedrate_mm_s); EEPROM_WRITE(planner.max_feedrate_mm_s);
EEPROM_WRITE_VAR(i, planner.max_acceleration_mm_per_s2); EEPROM_WRITE(planner.max_acceleration_mm_per_s2);
EEPROM_WRITE_VAR(i, planner.acceleration); EEPROM_WRITE(planner.acceleration);
EEPROM_WRITE_VAR(i, planner.retract_acceleration); EEPROM_WRITE(planner.retract_acceleration);
EEPROM_WRITE_VAR(i, planner.travel_acceleration); EEPROM_WRITE(planner.travel_acceleration);
EEPROM_WRITE_VAR(i, planner.min_feedrate_mm_s); EEPROM_WRITE(planner.min_feedrate_mm_s);
EEPROM_WRITE_VAR(i, planner.min_travel_feedrate_mm_s); EEPROM_WRITE(planner.min_travel_feedrate_mm_s);
EEPROM_WRITE_VAR(i, planner.min_segment_time); EEPROM_WRITE(planner.min_segment_time);
EEPROM_WRITE_VAR(i, planner.max_xy_jerk); EEPROM_WRITE(planner.max_xy_jerk);
EEPROM_WRITE_VAR(i, planner.max_z_jerk); EEPROM_WRITE(planner.max_z_jerk);
EEPROM_WRITE_VAR(i, planner.max_e_jerk); EEPROM_WRITE(planner.max_e_jerk);
EEPROM_WRITE_VAR(i, home_offset); EEPROM_WRITE(home_offset);
#if ENABLED(MESH_BED_LEVELING) #if ENABLED(MESH_BED_LEVELING)
// Compile time test that sizeof(mbl.z_values) is as expected // Compile time test that sizeof(mbl.z_values) is as expected
@ -227,45 +230,45 @@ void Config_StoreSettings() {
uint8_t mesh_num_x = MESH_NUM_X_POINTS, uint8_t mesh_num_x = MESH_NUM_X_POINTS,
mesh_num_y = MESH_NUM_Y_POINTS, mesh_num_y = MESH_NUM_Y_POINTS,
dummy_uint8 = mbl.status & _BV(MBL_STATUS_HAS_MESH_BIT); dummy_uint8 = mbl.status & _BV(MBL_STATUS_HAS_MESH_BIT);
EEPROM_WRITE_VAR(i, dummy_uint8); EEPROM_WRITE(dummy_uint8);
EEPROM_WRITE_VAR(i, mbl.z_offset); EEPROM_WRITE(mbl.z_offset);
EEPROM_WRITE_VAR(i, mesh_num_x); EEPROM_WRITE(mesh_num_x);
EEPROM_WRITE_VAR(i, mesh_num_y); EEPROM_WRITE(mesh_num_y);
EEPROM_WRITE_VAR(i, mbl.z_values); EEPROM_WRITE(mbl.z_values);
#else #else
// For disabled MBL write a default mesh // For disabled MBL write a default mesh
uint8_t mesh_num_x = 3, uint8_t mesh_num_x = 3,
mesh_num_y = 3, mesh_num_y = 3,
dummy_uint8 = 0; dummy_uint8 = 0;
dummy = 0.0f; dummy = 0.0f;
EEPROM_WRITE_VAR(i, dummy_uint8); EEPROM_WRITE(dummy_uint8);
EEPROM_WRITE_VAR(i, dummy); EEPROM_WRITE(dummy);
EEPROM_WRITE_VAR(i, mesh_num_x); EEPROM_WRITE(mesh_num_x);
EEPROM_WRITE_VAR(i, mesh_num_y); EEPROM_WRITE(mesh_num_y);
for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_WRITE_VAR(i, dummy); for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_WRITE(dummy);
#endif // MESH_BED_LEVELING #endif // MESH_BED_LEVELING
#if !HAS_BED_PROBE #if !HAS_BED_PROBE
float zprobe_zoffset = 0; float zprobe_zoffset = 0;
#endif #endif
EEPROM_WRITE_VAR(i, zprobe_zoffset); EEPROM_WRITE(zprobe_zoffset);
// 9 floats for DELTA / Z_DUAL_ENDSTOPS // 9 floats for DELTA / Z_DUAL_ENDSTOPS
#if ENABLED(DELTA) #if ENABLED(DELTA)
EEPROM_WRITE_VAR(i, endstop_adj); // 3 floats EEPROM_WRITE(endstop_adj); // 3 floats
EEPROM_WRITE_VAR(i, delta_radius); // 1 float EEPROM_WRITE(delta_radius); // 1 float
EEPROM_WRITE_VAR(i, delta_diagonal_rod); // 1 float EEPROM_WRITE(delta_diagonal_rod); // 1 float
EEPROM_WRITE_VAR(i, delta_segments_per_second); // 1 float EEPROM_WRITE(delta_segments_per_second); // 1 float
EEPROM_WRITE_VAR(i, delta_diagonal_rod_trim_tower_1); // 1 float EEPROM_WRITE(delta_diagonal_rod_trim_tower_1); // 1 float
EEPROM_WRITE_VAR(i, delta_diagonal_rod_trim_tower_2); // 1 float EEPROM_WRITE(delta_diagonal_rod_trim_tower_2); // 1 float
EEPROM_WRITE_VAR(i, delta_diagonal_rod_trim_tower_3); // 1 float EEPROM_WRITE(delta_diagonal_rod_trim_tower_3); // 1 float
#elif ENABLED(Z_DUAL_ENDSTOPS) #elif ENABLED(Z_DUAL_ENDSTOPS)
EEPROM_WRITE_VAR(i, z_endstop_adj); // 1 float EEPROM_WRITE(z_endstop_adj); // 1 float
dummy = 0.0f; dummy = 0.0f;
for (uint8_t q = 8; q--;) EEPROM_WRITE_VAR(i, dummy); for (uint8_t q = 8; q--;) EEPROM_WRITE(dummy);
#else #else
dummy = 0.0f; dummy = 0.0f;
for (uint8_t q = 9; q--;) EEPROM_WRITE_VAR(i, dummy); for (uint8_t q = 9; q--;) EEPROM_WRITE(dummy);
#endif #endif
#if DISABLED(ULTIPANEL) #if DISABLED(ULTIPANEL)
@ -273,34 +276,34 @@ void Config_StoreSettings() {
preheatHotendTemp2 = PREHEAT_2_TEMP_HOTEND, preheatBedTemp2 = PREHEAT_2_TEMP_BED, preheatFanSpeed2 = PREHEAT_2_FAN_SPEED; preheatHotendTemp2 = PREHEAT_2_TEMP_HOTEND, preheatBedTemp2 = PREHEAT_2_TEMP_BED, preheatFanSpeed2 = PREHEAT_2_FAN_SPEED;
#endif // !ULTIPANEL #endif // !ULTIPANEL
EEPROM_WRITE_VAR(i, preheatHotendTemp1); EEPROM_WRITE(preheatHotendTemp1);
EEPROM_WRITE_VAR(i, preheatBedTemp1); EEPROM_WRITE(preheatBedTemp1);
EEPROM_WRITE_VAR(i, preheatFanSpeed1); EEPROM_WRITE(preheatFanSpeed1);
EEPROM_WRITE_VAR(i, preheatHotendTemp2); EEPROM_WRITE(preheatHotendTemp2);
EEPROM_WRITE_VAR(i, preheatBedTemp2); EEPROM_WRITE(preheatBedTemp2);
EEPROM_WRITE_VAR(i, preheatFanSpeed2); EEPROM_WRITE(preheatFanSpeed2);
for (uint8_t e = 0; e < MAX_EXTRUDERS; e++) { for (uint8_t e = 0; e < MAX_EXTRUDERS; e++) {
#if ENABLED(PIDTEMP) #if ENABLED(PIDTEMP)
if (e < HOTENDS) { if (e < HOTENDS) {
EEPROM_WRITE_VAR(i, PID_PARAM(Kp, e)); EEPROM_WRITE(PID_PARAM(Kp, e));
EEPROM_WRITE_VAR(i, PID_PARAM(Ki, e)); EEPROM_WRITE(PID_PARAM(Ki, e));
EEPROM_WRITE_VAR(i, PID_PARAM(Kd, e)); EEPROM_WRITE(PID_PARAM(Kd, e));
#if ENABLED(PID_ADD_EXTRUSION_RATE) #if ENABLED(PID_ADD_EXTRUSION_RATE)
EEPROM_WRITE_VAR(i, PID_PARAM(Kc, e)); EEPROM_WRITE(PID_PARAM(Kc, e));
#else #else
dummy = 1.0f; // 1.0 = default kc dummy = 1.0f; // 1.0 = default kc
EEPROM_WRITE_VAR(i, dummy); EEPROM_WRITE(dummy);
#endif #endif
} }
else else
#endif // !PIDTEMP #endif // !PIDTEMP
{ {
dummy = DUMMY_PID_VALUE; // When read, will not change the existing value dummy = DUMMY_PID_VALUE; // When read, will not change the existing value
EEPROM_WRITE_VAR(i, dummy); // Kp EEPROM_WRITE(dummy); // Kp
dummy = 0.0f; dummy = 0.0f;
for (uint8_t q = 3; q--;) EEPROM_WRITE_VAR(i, dummy); // Ki, Kd, Kc for (uint8_t q = 3; q--;) EEPROM_WRITE(dummy); // Ki, Kd, Kc
} }
} // Hotends Loop } // Hotends Loop
@ -308,67 +311,68 @@ void Config_StoreSettings() {
#if DISABLED(PID_ADD_EXTRUSION_RATE) #if DISABLED(PID_ADD_EXTRUSION_RATE)
int lpq_len = 20; int lpq_len = 20;
#endif #endif
EEPROM_WRITE_VAR(i, lpq_len); EEPROM_WRITE(lpq_len);
#if DISABLED(PIDTEMPBED) #if DISABLED(PIDTEMPBED)
dummy = DUMMY_PID_VALUE; dummy = DUMMY_PID_VALUE;
for (uint8_t q = 3; q--;) EEPROM_WRITE_VAR(i, dummy); for (uint8_t q = 3; q--;) EEPROM_WRITE(dummy);
#else #else
EEPROM_WRITE_VAR(i, thermalManager.bedKp); EEPROM_WRITE(thermalManager.bedKp);
EEPROM_WRITE_VAR(i, thermalManager.bedKi); EEPROM_WRITE(thermalManager.bedKi);
EEPROM_WRITE_VAR(i, thermalManager.bedKd); EEPROM_WRITE(thermalManager.bedKd);
#endif #endif
#if !HAS_LCD_CONTRAST #if !HAS_LCD_CONTRAST
const int lcd_contrast = 32; const int lcd_contrast = 32;
#endif #endif
EEPROM_WRITE_VAR(i, lcd_contrast); EEPROM_WRITE(lcd_contrast);
#if ENABLED(SCARA) #if ENABLED(SCARA)
EEPROM_WRITE_VAR(i, axis_scaling); // 3 floats EEPROM_WRITE(axis_scaling); // 3 floats
#else #else
dummy = 1.0f; dummy = 1.0f;
EEPROM_WRITE_VAR(i, dummy); EEPROM_WRITE(dummy);
#endif #endif
#if ENABLED(FWRETRACT) #if ENABLED(FWRETRACT)
EEPROM_WRITE_VAR(i, autoretract_enabled); EEPROM_WRITE(autoretract_enabled);
EEPROM_WRITE_VAR(i, retract_length); EEPROM_WRITE(retract_length);
#if EXTRUDERS > 1 #if EXTRUDERS > 1
EEPROM_WRITE_VAR(i, retract_length_swap); EEPROM_WRITE(retract_length_swap);
#else #else
dummy = 0.0f; dummy = 0.0f;
EEPROM_WRITE_VAR(i, dummy); EEPROM_WRITE(dummy);
#endif #endif
EEPROM_WRITE_VAR(i, retract_feedrate_mm_s); EEPROM_WRITE(retract_feedrate_mm_s);
EEPROM_WRITE_VAR(i, retract_zlift); EEPROM_WRITE(retract_zlift);
EEPROM_WRITE_VAR(i, retract_recover_length); EEPROM_WRITE(retract_recover_length);
#if EXTRUDERS > 1 #if EXTRUDERS > 1
EEPROM_WRITE_VAR(i, retract_recover_length_swap); EEPROM_WRITE(retract_recover_length_swap);
#else #else
dummy = 0.0f; dummy = 0.0f;
EEPROM_WRITE_VAR(i, dummy); EEPROM_WRITE(dummy);
#endif #endif
EEPROM_WRITE_VAR(i, retract_recover_feedrate_mm_s); EEPROM_WRITE(retract_recover_feedrate_mm_s);
#endif // FWRETRACT #endif // FWRETRACT
EEPROM_WRITE_VAR(i, volumetric_enabled); EEPROM_WRITE(volumetric_enabled);
// Save filament sizes // Save filament sizes
for (uint8_t q = 0; q < MAX_EXTRUDERS; q++) { for (uint8_t q = 0; q < MAX_EXTRUDERS; q++) {
if (q < COUNT(filament_size)) dummy = filament_size[q]; if (q < COUNT(filament_size)) dummy = filament_size[q];
EEPROM_WRITE_VAR(i, dummy); EEPROM_WRITE(dummy);
} }
uint16_t final_checksum = eeprom_checksum; uint16_t final_checksum = eeprom_checksum,
eeprom_size = eeprom_index;
int j = EEPROM_OFFSET; eeprom_index = EEPROM_OFFSET;
EEPROM_WRITE_VAR(j, version); EEPROM_WRITE(version);
EEPROM_WRITE_VAR(j, final_checksum); EEPROM_WRITE(final_checksum);
// Report storage size // Report storage size
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOPAIR("Settings Stored (", i); SERIAL_ECHOPAIR("Settings Stored (", eeprom_size);
SERIAL_ECHOLNPGM(" bytes)"); SERIAL_ECHOLNPGM(" bytes)");
} }
@ -376,11 +380,15 @@ void Config_StoreSettings() {
* M501 - Retrieve Configuration * M501 - Retrieve Configuration
*/ */
void Config_RetrieveSettings() { void Config_RetrieveSettings() {
int i = EEPROM_OFFSET;
EEPROM_START();
char stored_ver[4]; char stored_ver[4];
EEPROM_READ(stored_ver);
uint16_t stored_checksum; uint16_t stored_checksum;
EEPROM_READ_VAR(i, stored_ver); EEPROM_READ(stored_checksum);
EEPROM_READ_VAR(i, stored_checksum);
// SERIAL_ECHOPAIR("Version: [", ver); // SERIAL_ECHOPAIR("Version: [", ver);
// SERIAL_ECHOPAIR("] Stored version: [", stored_ver); // SERIAL_ECHOPAIR("] Stored version: [", stored_ver);
// SERIAL_ECHOLNPGM("]"); // SERIAL_ECHOLNPGM("]");
@ -394,63 +402,63 @@ void Config_RetrieveSettings() {
eeprom_checksum = 0; // clear before reading first "real data" eeprom_checksum = 0; // clear before reading first "real data"
// version number match // version number match
EEPROM_READ_VAR(i, planner.axis_steps_per_mm); EEPROM_READ(planner.axis_steps_per_mm);
EEPROM_READ_VAR(i, planner.max_feedrate_mm_s); EEPROM_READ(planner.max_feedrate_mm_s);
EEPROM_READ_VAR(i, planner.max_acceleration_mm_per_s2); EEPROM_READ(planner.max_acceleration_mm_per_s2);
EEPROM_READ_VAR(i, planner.acceleration); EEPROM_READ(planner.acceleration);
EEPROM_READ_VAR(i, planner.retract_acceleration); EEPROM_READ(planner.retract_acceleration);
EEPROM_READ_VAR(i, planner.travel_acceleration); EEPROM_READ(planner.travel_acceleration);
EEPROM_READ_VAR(i, planner.min_feedrate_mm_s); EEPROM_READ(planner.min_feedrate_mm_s);
EEPROM_READ_VAR(i, planner.min_travel_feedrate_mm_s); EEPROM_READ(planner.min_travel_feedrate_mm_s);
EEPROM_READ_VAR(i, planner.min_segment_time); EEPROM_READ(planner.min_segment_time);
EEPROM_READ_VAR(i, planner.max_xy_jerk); EEPROM_READ(planner.max_xy_jerk);
EEPROM_READ_VAR(i, planner.max_z_jerk); EEPROM_READ(planner.max_z_jerk);
EEPROM_READ_VAR(i, planner.max_e_jerk); EEPROM_READ(planner.max_e_jerk);
EEPROM_READ_VAR(i, home_offset); EEPROM_READ(home_offset);
uint8_t dummy_uint8 = 0, mesh_num_x = 0, mesh_num_y = 0; uint8_t dummy_uint8 = 0, mesh_num_x = 0, mesh_num_y = 0;
EEPROM_READ_VAR(i, dummy_uint8); EEPROM_READ(dummy_uint8);
EEPROM_READ_VAR(i, dummy); EEPROM_READ(dummy);
EEPROM_READ_VAR(i, mesh_num_x); EEPROM_READ(mesh_num_x);
EEPROM_READ_VAR(i, mesh_num_y); EEPROM_READ(mesh_num_y);
#if ENABLED(MESH_BED_LEVELING) #if ENABLED(MESH_BED_LEVELING)
mbl.status = dummy_uint8; mbl.status = dummy_uint8;
mbl.z_offset = dummy; mbl.z_offset = dummy;
if (mesh_num_x == MESH_NUM_X_POINTS && mesh_num_y == MESH_NUM_Y_POINTS) { if (mesh_num_x == MESH_NUM_X_POINTS && mesh_num_y == MESH_NUM_Y_POINTS) {
// EEPROM data fits the current mesh // EEPROM data fits the current mesh
EEPROM_READ_VAR(i, mbl.z_values); EEPROM_READ(mbl.z_values);
} }
else { else {
// EEPROM data is stale // EEPROM data is stale
mbl.reset(); mbl.reset();
for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_READ_VAR(i, dummy); for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_READ(dummy);
} }
#else #else
// MBL is disabled - skip the stored data // MBL is disabled - skip the stored data
for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_READ_VAR(i, dummy); for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_READ(dummy);
#endif // MESH_BED_LEVELING #endif // MESH_BED_LEVELING
#if !HAS_BED_PROBE #if !HAS_BED_PROBE
float zprobe_zoffset = 0; float zprobe_zoffset = 0;
#endif #endif
EEPROM_READ_VAR(i, zprobe_zoffset); EEPROM_READ(zprobe_zoffset);
#if ENABLED(DELTA) #if ENABLED(DELTA)
EEPROM_READ_VAR(i, endstop_adj); // 3 floats EEPROM_READ(endstop_adj); // 3 floats
EEPROM_READ_VAR(i, delta_radius); // 1 float EEPROM_READ(delta_radius); // 1 float
EEPROM_READ_VAR(i, delta_diagonal_rod); // 1 float EEPROM_READ(delta_diagonal_rod); // 1 float
EEPROM_READ_VAR(i, delta_segments_per_second); // 1 float EEPROM_READ(delta_segments_per_second); // 1 float
EEPROM_READ_VAR(i, delta_diagonal_rod_trim_tower_1); // 1 float EEPROM_READ(delta_diagonal_rod_trim_tower_1); // 1 float
EEPROM_READ_VAR(i, delta_diagonal_rod_trim_tower_2); // 1 float EEPROM_READ(delta_diagonal_rod_trim_tower_2); // 1 float
EEPROM_READ_VAR(i, delta_diagonal_rod_trim_tower_3); // 1 float EEPROM_READ(delta_diagonal_rod_trim_tower_3); // 1 float
#elif ENABLED(Z_DUAL_ENDSTOPS) #elif ENABLED(Z_DUAL_ENDSTOPS)
EEPROM_READ_VAR(i, z_endstop_adj); EEPROM_READ(z_endstop_adj);
dummy = 0.0f; dummy = 0.0f;
for (uint8_t q=8; q--;) EEPROM_READ_VAR(i, dummy); for (uint8_t q=8; q--;) EEPROM_READ(dummy);
#else #else
dummy = 0.0f; dummy = 0.0f;
for (uint8_t q=9; q--;) EEPROM_READ_VAR(i, dummy); for (uint8_t q=9; q--;) EEPROM_READ(dummy);
#endif #endif
#if DISABLED(ULTIPANEL) #if DISABLED(ULTIPANEL)
@ -458,86 +466,86 @@ void Config_RetrieveSettings() {
preheatHotendTemp2, preheatBedTemp2, preheatFanSpeed2; preheatHotendTemp2, preheatBedTemp2, preheatFanSpeed2;
#endif #endif
EEPROM_READ_VAR(i, preheatHotendTemp1); EEPROM_READ(preheatHotendTemp1);
EEPROM_READ_VAR(i, preheatBedTemp1); EEPROM_READ(preheatBedTemp1);
EEPROM_READ_VAR(i, preheatFanSpeed1); EEPROM_READ(preheatFanSpeed1);
EEPROM_READ_VAR(i, preheatHotendTemp2); EEPROM_READ(preheatHotendTemp2);
EEPROM_READ_VAR(i, preheatBedTemp2); EEPROM_READ(preheatBedTemp2);
EEPROM_READ_VAR(i, preheatFanSpeed2); EEPROM_READ(preheatFanSpeed2);
#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_VAR(i, dummy); // Kp EEPROM_READ(dummy); // Kp
if (e < HOTENDS && dummy != DUMMY_PID_VALUE) { if (e < HOTENDS && dummy != DUMMY_PID_VALUE) {
// do not need to scale PID values as the values in EEPROM are already scaled // do not need to scale PID values as the values in EEPROM are already scaled
PID_PARAM(Kp, e) = dummy; PID_PARAM(Kp, e) = dummy;
EEPROM_READ_VAR(i, PID_PARAM(Ki, e)); EEPROM_READ(PID_PARAM(Ki, e));
EEPROM_READ_VAR(i, PID_PARAM(Kd, e)); EEPROM_READ(PID_PARAM(Kd, e));
#if ENABLED(PID_ADD_EXTRUSION_RATE) #if ENABLED(PID_ADD_EXTRUSION_RATE)
EEPROM_READ_VAR(i, PID_PARAM(Kc, e)); EEPROM_READ(PID_PARAM(Kc, e));
#else #else
EEPROM_READ_VAR(i, dummy); EEPROM_READ(dummy);
#endif #endif
} }
else { else {
for (uint8_t q=3; q--;) EEPROM_READ_VAR(i, dummy); // Ki, Kd, Kc for (uint8_t q=3; q--;) EEPROM_READ(dummy); // Ki, Kd, Kc
} }
} }
#else // !PIDTEMP #else // !PIDTEMP
// 4 x 4 = 16 slots for PID parameters // 4 x 4 = 16 slots for PID parameters
for (uint8_t q = MAX_EXTRUDERS * 4; q--;) EEPROM_READ_VAR(i, dummy); // Kp, Ki, Kd, Kc for (uint8_t q = MAX_EXTRUDERS * 4; q--;) EEPROM_READ(dummy); // Kp, Ki, Kd, Kc
#endif // !PIDTEMP #endif // !PIDTEMP
#if DISABLED(PID_ADD_EXTRUSION_RATE) #if DISABLED(PID_ADD_EXTRUSION_RATE)
int lpq_len; int lpq_len;
#endif #endif
EEPROM_READ_VAR(i, lpq_len); EEPROM_READ(lpq_len);
#if ENABLED(PIDTEMPBED) #if ENABLED(PIDTEMPBED)
EEPROM_READ_VAR(i, dummy); // bedKp EEPROM_READ(dummy); // bedKp
if (dummy != DUMMY_PID_VALUE) { if (dummy != DUMMY_PID_VALUE) {
thermalManager.bedKp = dummy; thermalManager.bedKp = dummy;
EEPROM_READ_VAR(i, thermalManager.bedKi); EEPROM_READ(thermalManager.bedKi);
EEPROM_READ_VAR(i, thermalManager.bedKd); EEPROM_READ(thermalManager.bedKd);
} }
#else #else
for (uint8_t q=3; q--;) EEPROM_READ_VAR(i, dummy); // bedKp, bedKi, bedKd for (uint8_t q=3; q--;) EEPROM_READ(dummy); // bedKp, bedKi, bedKd
#endif #endif
#if !HAS_LCD_CONTRAST #if !HAS_LCD_CONTRAST
int lcd_contrast; int lcd_contrast;
#endif #endif
EEPROM_READ_VAR(i, lcd_contrast); EEPROM_READ(lcd_contrast);
#if ENABLED(SCARA) #if ENABLED(SCARA)
EEPROM_READ_VAR(i, axis_scaling); // 3 floats EEPROM_READ(axis_scaling); // 3 floats
#else #else
EEPROM_READ_VAR(i, dummy); EEPROM_READ(dummy);
#endif #endif
#if ENABLED(FWRETRACT) #if ENABLED(FWRETRACT)
EEPROM_READ_VAR(i, autoretract_enabled); EEPROM_READ(autoretract_enabled);
EEPROM_READ_VAR(i, retract_length); EEPROM_READ(retract_length);
#if EXTRUDERS > 1 #if EXTRUDERS > 1
EEPROM_READ_VAR(i, retract_length_swap); EEPROM_READ(retract_length_swap);
#else #else
EEPROM_READ_VAR(i, dummy); EEPROM_READ(dummy);
#endif #endif
EEPROM_READ_VAR(i, retract_feedrate_mm_s); EEPROM_READ(retract_feedrate_mm_s);
EEPROM_READ_VAR(i, retract_zlift); EEPROM_READ(retract_zlift);
EEPROM_READ_VAR(i, retract_recover_length); EEPROM_READ(retract_recover_length);
#if EXTRUDERS > 1 #if EXTRUDERS > 1
EEPROM_READ_VAR(i, retract_recover_length_swap); EEPROM_READ(retract_recover_length_swap);
#else #else
EEPROM_READ_VAR(i, dummy); EEPROM_READ(dummy);
#endif #endif
EEPROM_READ_VAR(i, retract_recover_feedrate_mm_s); EEPROM_READ(retract_recover_feedrate_mm_s);
#endif // FWRETRACT #endif // FWRETRACT
EEPROM_READ_VAR(i, volumetric_enabled); EEPROM_READ(volumetric_enabled);
for (uint8_t q = 0; q < MAX_EXTRUDERS; q++) { for (uint8_t q = 0; q < MAX_EXTRUDERS; q++) {
EEPROM_READ_VAR(i, dummy); EEPROM_READ(dummy);
if (q < COUNT(filament_size)) filament_size[q] = dummy; if (q < COUNT(filament_size)) filament_size[q] = dummy;
} }
@ -545,7 +553,7 @@ void Config_RetrieveSettings() {
Config_Postprocess(); Config_Postprocess();
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHO(version); SERIAL_ECHO(version);
SERIAL_ECHOPAIR(" stored settings retrieved (", i); SERIAL_ECHOPAIR(" stored settings retrieved (", eeprom_index);
SERIAL_ECHOLNPGM(" bytes)"); SERIAL_ECHOLNPGM(" bytes)");
} }
else { else {

Write Preview
Loading…
Cancel
Save