forksand
/
marlin-lulzbot-laser
1
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Indentation in configuration_store.cpp

Browse Source
master
Scott Lahteine 8 years ago
parent 97115d56f9
commit bff6bbdb12
1 changed files with 551 additions and 551 deletions
Show Stats Download Patch File Download Diff File

1102
Marlin/configuration_store.cpp
Unescape View File

@ -197,373 +197,373 @@ void Config_Postprocess() {
#define EEPROM_WRITE(VAR) _EEPROM_writeData(eeprom_index, (uint8_t*)&VAR, 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)) #define EEPROM_READ(VAR) _EEPROM_readData(eeprom_index, (uint8_t*)&VAR, sizeof(VAR))
/** /**
* M500 - Store Configuration * M500 - Store Configuration
*/ */
void Config_StoreSettings() { void Config_StoreSettings() {
float dummy = 0.0f; float dummy = 0.0f;
char ver[4] = "000"; char ver[4] = "000";
EEPROM_START();
EEPROM_WRITE(ver); // invalidate data first
EEPROM_SKIP(eeprom_checksum); // Skip the checksum slot
eeprom_checksum = 0; // clear before first "real data"
EEPROM_WRITE(planner.axis_steps_per_mm);
EEPROM_WRITE(planner.max_feedrate_mm_s);
EEPROM_WRITE(planner.max_acceleration_mm_per_s2);
EEPROM_WRITE(planner.acceleration);
EEPROM_WRITE(planner.retract_acceleration);
EEPROM_WRITE(planner.travel_acceleration);
EEPROM_WRITE(planner.min_feedrate_mm_s);
EEPROM_WRITE(planner.min_travel_feedrate_mm_s);
EEPROM_WRITE(planner.min_segment_time);
EEPROM_WRITE(planner.max_jerk);
EEPROM_WRITE(home_offset);
#if HOTENDS > 1
// Skip hotend 0 which must be 0
for (uint8_t e = 1; e < HOTENDS; e++)
LOOP_XYZ(i) EEPROM_WRITE(hotend_offset[i][e]);
#endif
#if ENABLED(MESH_BED_LEVELING)
// Compile time test that sizeof(mbl.z_values) is as expected
typedef char c_assert[(sizeof(mbl.z_values) == (MESH_NUM_X_POINTS) * (MESH_NUM_Y_POINTS) * sizeof(dummy)) ? 1 : -1];
uint8_t mesh_num_x = MESH_NUM_X_POINTS,
mesh_num_y = MESH_NUM_Y_POINTS,
dummy_uint8 = mbl.status & _BV(MBL_STATUS_HAS_MESH_BIT);
EEPROM_WRITE(dummy_uint8);
EEPROM_WRITE(mbl.z_offset);
EEPROM_WRITE(mesh_num_x);
EEPROM_WRITE(mesh_num_y);
EEPROM_WRITE(mbl.z_values);
#else
// For disabled MBL write a default mesh
uint8_t mesh_num_x = 3,
mesh_num_y = 3,
dummy_uint8 = 0;
dummy = 0.0f;
EEPROM_WRITE(dummy_uint8);
EEPROM_WRITE(dummy);
EEPROM_WRITE(mesh_num_x);
EEPROM_WRITE(mesh_num_y);
for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_WRITE(dummy);
#endif // MESH_BED_LEVELING
#if !HAS_BED_PROBE
float zprobe_zoffset = 0;
#endif
EEPROM_WRITE(zprobe_zoffset);
// 9 floats for DELTA / Z_DUAL_ENDSTOPS
#if ENABLED(DELTA)
EEPROM_WRITE(endstop_adj); // 3 floats
EEPROM_WRITE(delta_radius); // 1 float
EEPROM_WRITE(delta_diagonal_rod); // 1 float
EEPROM_WRITE(delta_segments_per_second); // 1 float
EEPROM_WRITE(delta_diagonal_rod_trim_tower_1); // 1 float
EEPROM_WRITE(delta_diagonal_rod_trim_tower_2); // 1 float
EEPROM_WRITE(delta_diagonal_rod_trim_tower_3); // 1 float
#elif ENABLED(Z_DUAL_ENDSTOPS)
EEPROM_WRITE(z_endstop_adj); // 1 float
dummy = 0.0f;
for (uint8_t q = 8; q--;) EEPROM_WRITE(dummy);
#else
dummy = 0.0f;
for (uint8_t q = 9; q--;) EEPROM_WRITE(dummy);
#endif
#if DISABLED(ULTIPANEL)
int preheatHotendTemp1 = PREHEAT_1_TEMP_HOTEND, preheatBedTemp1 = PREHEAT_1_TEMP_BED, preheatFanSpeed1 = PREHEAT_1_FAN_SPEED,
preheatHotendTemp2 = PREHEAT_2_TEMP_HOTEND, preheatBedTemp2 = PREHEAT_2_TEMP_BED, preheatFanSpeed2 = PREHEAT_2_FAN_SPEED;
#endif // !ULTIPANEL
EEPROM_WRITE(preheatHotendTemp1);
EEPROM_WRITE(preheatBedTemp1);
EEPROM_WRITE(preheatFanSpeed1);
EEPROM_WRITE(preheatHotendTemp2);
EEPROM_WRITE(preheatBedTemp2);
EEPROM_WRITE(preheatFanSpeed2);
for (uint8_t e = 0; e < MAX_EXTRUDERS; e++) {
#if ENABLED(PIDTEMP)
if (e < HOTENDS) {
EEPROM_WRITE(PID_PARAM(Kp, e));
EEPROM_WRITE(PID_PARAM(Ki, e));
EEPROM_WRITE(PID_PARAM(Kd, e));
#if ENABLED(PID_EXTRUSION_SCALING)
EEPROM_WRITE(PID_PARAM(Kc, e));
#else
dummy = 1.0f; // 1.0 = default kc
EEPROM_WRITE(dummy);
#endif
}
else
#endif // !PIDTEMP
{
dummy = DUMMY_PID_VALUE; // When read, will not change the existing value
EEPROM_WRITE(dummy); // Kp
dummy = 0.0f;
for (uint8_t q = 3; q--;) EEPROM_WRITE(dummy); // Ki, Kd, Kc
}
} // Hotends Loop
#if DISABLED(PID_EXTRUSION_SCALING)
int lpq_len = 20;
#endif
EEPROM_WRITE(lpq_len);
#if DISABLED(PIDTEMPBED)
dummy = DUMMY_PID_VALUE;
for (uint8_t q = 3; q--;) EEPROM_WRITE(dummy);
#else
EEPROM_WRITE(thermalManager.bedKp);
EEPROM_WRITE(thermalManager.bedKi);
EEPROM_WRITE(thermalManager.bedKd);
#endif
#if !HAS_LCD_CONTRAST
const int lcd_contrast = 32;
#endif
EEPROM_WRITE(lcd_contrast);
#if ENABLED(FWRETRACT)
EEPROM_WRITE(autoretract_enabled);
EEPROM_WRITE(retract_length);
#if EXTRUDERS > 1
EEPROM_WRITE(retract_length_swap);
#else
dummy = 0.0f;
EEPROM_WRITE(dummy);
#endif
EEPROM_WRITE(retract_feedrate_mm_s);
EEPROM_WRITE(retract_zlift);
EEPROM_WRITE(retract_recover_length);
#if EXTRUDERS > 1
EEPROM_WRITE(retract_recover_length_swap);
#else
dummy = 0.0f;
EEPROM_WRITE(dummy);
#endif
EEPROM_WRITE(retract_recover_feedrate_mm_s);
#endif // FWRETRACT
EEPROM_WRITE(volumetric_enabled);
// Save filament sizes
for (uint8_t q = 0; q < MAX_EXTRUDERS; q++) {
if (q < COUNT(filament_size)) dummy = filament_size[q];
EEPROM_WRITE(dummy);
}
uint16_t final_checksum = eeprom_checksum,
eeprom_size = eeprom_index;
eeprom_index = EEPROM_OFFSET;
EEPROM_WRITE(version);
EEPROM_WRITE(final_checksum);
// Report storage size
SERIAL_ECHO_START;
SERIAL_ECHOPAIR("Settings Stored (", eeprom_size);
SERIAL_ECHOLNPGM(" bytes)");
}
/**
* M501 - Retrieve Configuration
*/
void Config_RetrieveSettings() {
EEPROM_START();
char stored_ver[4];
EEPROM_READ(stored_ver);
uint16_t stored_checksum;
EEPROM_READ(stored_checksum);
// SERIAL_ECHOPAIR("Version: [", ver);
// SERIAL_ECHOPAIR("] Stored version: [", stored_ver);
// SERIAL_CHAR(']');
// SERIAL_EOL;
if (strncmp(version, stored_ver, 3) != 0) { EEPROM_START();
Config_ResetDefault();
}
else {
float dummy = 0;
eeprom_checksum = 0; // clear before reading first "real data" EEPROM_WRITE(ver); // invalidate data first
EEPROM_SKIP(eeprom_checksum); // Skip the checksum slot
// version number match eeprom_checksum = 0; // clear before first "real data"
EEPROM_READ(planner.axis_steps_per_mm);
EEPROM_READ(planner.max_feedrate_mm_s);
EEPROM_READ(planner.max_acceleration_mm_per_s2);
EEPROM_READ(planner.acceleration); EEPROM_WRITE(planner.axis_steps_per_mm);
EEPROM_READ(planner.retract_acceleration); EEPROM_WRITE(planner.max_feedrate_mm_s);
EEPROM_READ(planner.travel_acceleration); EEPROM_WRITE(planner.max_acceleration_mm_per_s2);
EEPROM_READ(planner.min_feedrate_mm_s); EEPROM_WRITE(planner.acceleration);
EEPROM_READ(planner.min_travel_feedrate_mm_s); EEPROM_WRITE(planner.retract_acceleration);
EEPROM_READ(planner.min_segment_time); EEPROM_WRITE(planner.travel_acceleration);
EEPROM_READ(planner.max_jerk); EEPROM_WRITE(planner.min_feedrate_mm_s);
EEPROM_READ(home_offset); EEPROM_WRITE(planner.min_travel_feedrate_mm_s);
EEPROM_WRITE(planner.min_segment_time);
EEPROM_WRITE(planner.max_jerk);
EEPROM_WRITE(home_offset);
#if HOTENDS > 1 #if HOTENDS > 1
// Skip hotend 0 which must be 0 // Skip hotend 0 which must be 0
for (uint8_t e = 1; e < HOTENDS; e++) for (uint8_t e = 1; e < HOTENDS; e++)
LOOP_XYZ(i) EEPROM_READ(hotend_offset[i][e]); LOOP_XYZ(i) EEPROM_WRITE(hotend_offset[i][e]);
#endif #endif
uint8_t dummy_uint8 = 0, mesh_num_x = 0, mesh_num_y = 0;
EEPROM_READ(dummy_uint8);
EEPROM_READ(dummy);
EEPROM_READ(mesh_num_x);
EEPROM_READ(mesh_num_y);
#if ENABLED(MESH_BED_LEVELING) #if ENABLED(MESH_BED_LEVELING)
mbl.status = dummy_uint8; // Compile time test that sizeof(mbl.z_values) is as expected
mbl.z_offset = dummy; typedef char c_assert[(sizeof(mbl.z_values) == (MESH_NUM_X_POINTS) * (MESH_NUM_Y_POINTS) * sizeof(dummy)) ? 1 : -1];
if (mesh_num_x == MESH_NUM_X_POINTS && mesh_num_y == MESH_NUM_Y_POINTS) { uint8_t mesh_num_x = MESH_NUM_X_POINTS,
// EEPROM data fits the current mesh mesh_num_y = MESH_NUM_Y_POINTS,
EEPROM_READ(mbl.z_values); dummy_uint8 = mbl.status & _BV(MBL_STATUS_HAS_MESH_BIT);
} EEPROM_WRITE(dummy_uint8);
else { EEPROM_WRITE(mbl.z_offset);
// EEPROM data is stale EEPROM_WRITE(mesh_num_x);
mbl.reset(); EEPROM_WRITE(mesh_num_y);
for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_READ(dummy); EEPROM_WRITE(mbl.z_values);
}
#else #else
// MBL is disabled - skip the stored data // For disabled MBL write a default mesh
for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_READ(dummy); uint8_t mesh_num_x = 3,
mesh_num_y = 3,
dummy_uint8 = 0;
dummy = 0.0f;
EEPROM_WRITE(dummy_uint8);
EEPROM_WRITE(dummy);
EEPROM_WRITE(mesh_num_x);
EEPROM_WRITE(mesh_num_y);
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_READ(zprobe_zoffset); EEPROM_WRITE(zprobe_zoffset);
// 9 floats for DELTA / Z_DUAL_ENDSTOPS
#if ENABLED(DELTA) #if ENABLED(DELTA)
EEPROM_READ(endstop_adj); // 3 floats EEPROM_WRITE(endstop_adj); // 3 floats
EEPROM_READ(delta_radius); // 1 float EEPROM_WRITE(delta_radius); // 1 float
EEPROM_READ(delta_diagonal_rod); // 1 float EEPROM_WRITE(delta_diagonal_rod); // 1 float
EEPROM_READ(delta_segments_per_second); // 1 float EEPROM_WRITE(delta_segments_per_second); // 1 float
EEPROM_READ(delta_diagonal_rod_trim_tower_1); // 1 float EEPROM_WRITE(delta_diagonal_rod_trim_tower_1); // 1 float
EEPROM_READ(delta_diagonal_rod_trim_tower_2); // 1 float EEPROM_WRITE(delta_diagonal_rod_trim_tower_2); // 1 float
EEPROM_READ(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_READ(z_endstop_adj); EEPROM_WRITE(z_endstop_adj); // 1 float
dummy = 0.0f; dummy = 0.0f;
for (uint8_t q=8; q--;) EEPROM_READ(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_READ(dummy); for (uint8_t q = 9; q--;) EEPROM_WRITE(dummy);
#endif #endif
#if DISABLED(ULTIPANEL) #if DISABLED(ULTIPANEL)
int preheatHotendTemp1, preheatBedTemp1, preheatFanSpeed1, int preheatHotendTemp1 = PREHEAT_1_TEMP_HOTEND, preheatBedTemp1 = PREHEAT_1_TEMP_BED, preheatFanSpeed1 = PREHEAT_1_FAN_SPEED,
preheatHotendTemp2, preheatBedTemp2, preheatFanSpeed2; preheatHotendTemp2 = PREHEAT_2_TEMP_HOTEND, preheatBedTemp2 = PREHEAT_2_TEMP_BED, preheatFanSpeed2 = PREHEAT_2_FAN_SPEED;
#endif #endif // !ULTIPANEL
EEPROM_READ(preheatHotendTemp1); EEPROM_WRITE(preheatHotendTemp1);
EEPROM_READ(preheatBedTemp1); EEPROM_WRITE(preheatBedTemp1);
EEPROM_READ(preheatFanSpeed1); EEPROM_WRITE(preheatFanSpeed1);
EEPROM_READ(preheatHotendTemp2); EEPROM_WRITE(preheatHotendTemp2);
EEPROM_READ(preheatBedTemp2); EEPROM_WRITE(preheatBedTemp2);
EEPROM_READ(preheatFanSpeed2); EEPROM_WRITE(preheatFanSpeed2);
#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 #if ENABLED(PIDTEMP)
if (e < HOTENDS && dummy != DUMMY_PID_VALUE) { if (e < HOTENDS) {
// do not need to scale PID values as the values in EEPROM are already scaled EEPROM_WRITE(PID_PARAM(Kp, e));
PID_PARAM(Kp, e) = dummy; EEPROM_WRITE(PID_PARAM(Ki, e));
EEPROM_READ(PID_PARAM(Ki, e)); EEPROM_WRITE(PID_PARAM(Kd, e));
EEPROM_READ(PID_PARAM(Kd, e));
#if ENABLED(PID_EXTRUSION_SCALING) #if ENABLED(PID_EXTRUSION_SCALING)
EEPROM_READ(PID_PARAM(Kc, e)); EEPROM_WRITE(PID_PARAM(Kc, e));
#else #else
EEPROM_READ(dummy); dummy = 1.0f; // 1.0 = default kc
EEPROM_WRITE(dummy);
#endif #endif
} }
else { else
for (uint8_t q=3; q--;) EEPROM_READ(dummy); // Ki, Kd, Kc #endif // !PIDTEMP
{
dummy = DUMMY_PID_VALUE; // When read, will not change the existing value
EEPROM_WRITE(dummy); // Kp
dummy = 0.0f;
for (uint8_t q = 3; q--;) EEPROM_WRITE(dummy); // Ki, Kd, Kc
} }
}
#else // !PIDTEMP } // Hotends Loop
// 4 x 4 = 16 slots for PID parameters
for (uint8_t q = MAX_EXTRUDERS * 4; q--;) EEPROM_READ(dummy); // Kp, Ki, Kd, Kc
#endif // !PIDTEMP
#if DISABLED(PID_EXTRUSION_SCALING) #if DISABLED(PID_EXTRUSION_SCALING)
int lpq_len; int lpq_len = 20;
#endif #endif
EEPROM_READ(lpq_len); EEPROM_WRITE(lpq_len);
#if ENABLED(PIDTEMPBED) #if DISABLED(PIDTEMPBED)
EEPROM_READ(dummy); // bedKp dummy = DUMMY_PID_VALUE;
if (dummy != DUMMY_PID_VALUE) { for (uint8_t q = 3; q--;) EEPROM_WRITE(dummy);
thermalManager.bedKp = dummy;
EEPROM_READ(thermalManager.bedKi);
EEPROM_READ(thermalManager.bedKd);
}
#else #else
for (uint8_t q=3; q--;) EEPROM_READ(dummy); // bedKp, bedKi, bedKd EEPROM_WRITE(thermalManager.bedKp);
EEPROM_WRITE(thermalManager.bedKi);
EEPROM_WRITE(thermalManager.bedKd);
#endif #endif
#if !HAS_LCD_CONTRAST #if !HAS_LCD_CONTRAST
int lcd_contrast; const int lcd_contrast = 32;
#endif #endif
EEPROM_READ(lcd_contrast); EEPROM_WRITE(lcd_contrast);
#if ENABLED(FWRETRACT) #if ENABLED(FWRETRACT)
EEPROM_READ(autoretract_enabled); EEPROM_WRITE(autoretract_enabled);
EEPROM_READ(retract_length); EEPROM_WRITE(retract_length);
#if EXTRUDERS > 1 #if EXTRUDERS > 1
EEPROM_READ(retract_length_swap); EEPROM_WRITE(retract_length_swap);
#else #else
EEPROM_READ(dummy); dummy = 0.0f;
EEPROM_WRITE(dummy);
#endif #endif
EEPROM_READ(retract_feedrate_mm_s); EEPROM_WRITE(retract_feedrate_mm_s);
EEPROM_READ(retract_zlift); EEPROM_WRITE(retract_zlift);
EEPROM_READ(retract_recover_length); EEPROM_WRITE(retract_recover_length);
#if EXTRUDERS > 1 #if EXTRUDERS > 1
EEPROM_READ(retract_recover_length_swap); EEPROM_WRITE(retract_recover_length_swap);
#else #else
EEPROM_READ(dummy); dummy = 0.0f;
EEPROM_WRITE(dummy);
#endif #endif
EEPROM_READ(retract_recover_feedrate_mm_s); EEPROM_WRITE(retract_recover_feedrate_mm_s);
#endif // FWRETRACT #endif // FWRETRACT
EEPROM_READ(volumetric_enabled); EEPROM_WRITE(volumetric_enabled);
// Save filament sizes
for (uint8_t q = 0; q < MAX_EXTRUDERS; q++) { for (uint8_t q = 0; q < MAX_EXTRUDERS; q++) {
EEPROM_READ(dummy); if (q < COUNT(filament_size)) dummy = filament_size[q];
if (q < COUNT(filament_size)) filament_size[q] = dummy; EEPROM_WRITE(dummy);
} }
if (eeprom_checksum == stored_checksum) { uint16_t final_checksum = eeprom_checksum,
Config_Postprocess(); eeprom_size = eeprom_index;
SERIAL_ECHO_START;
SERIAL_ECHO(version); eeprom_index = EEPROM_OFFSET;
SERIAL_ECHOPAIR(" stored settings retrieved (", eeprom_index); EEPROM_WRITE(version);
SERIAL_ECHOLNPGM(" bytes)"); EEPROM_WRITE(final_checksum);
}
else { // Report storage size
SERIAL_ERROR_START; SERIAL_ECHO_START;
SERIAL_ERRORLNPGM("EEPROM checksum mismatch"); SERIAL_ECHOPAIR("Settings Stored (", eeprom_size);
SERIAL_ECHOLNPGM(" bytes)");
}
/**
* M501 - Retrieve Configuration
*/
void Config_RetrieveSettings() {
EEPROM_START();
char stored_ver[4];
EEPROM_READ(stored_ver);
uint16_t stored_checksum;
EEPROM_READ(stored_checksum);
// SERIAL_ECHOPAIR("Version: [", ver);
// SERIAL_ECHOPAIR("] Stored version: [", stored_ver);
// SERIAL_CHAR(']');
// SERIAL_EOL;
if (strncmp(version, stored_ver, 3) != 0) {
Config_ResetDefault(); Config_ResetDefault();
} }
} else {
float dummy = 0;
#if ENABLED(EEPROM_CHITCHAT) eeprom_checksum = 0; // clear before reading first "real data"
Config_PrintSettings();
#endif // version number match
} EEPROM_READ(planner.axis_steps_per_mm);
EEPROM_READ(planner.max_feedrate_mm_s);
EEPROM_READ(planner.max_acceleration_mm_per_s2);
EEPROM_READ(planner.acceleration);
EEPROM_READ(planner.retract_acceleration);
EEPROM_READ(planner.travel_acceleration);
EEPROM_READ(planner.min_feedrate_mm_s);
EEPROM_READ(planner.min_travel_feedrate_mm_s);
EEPROM_READ(planner.min_segment_time);
EEPROM_READ(planner.max_jerk);
EEPROM_READ(home_offset);
#if HOTENDS > 1
// Skip hotend 0 which must be 0
for (uint8_t e = 1; e < HOTENDS; e++)
LOOP_XYZ(i) EEPROM_READ(hotend_offset[i][e]);
#endif
uint8_t dummy_uint8 = 0, mesh_num_x = 0, mesh_num_y = 0;
EEPROM_READ(dummy_uint8);
EEPROM_READ(dummy);
EEPROM_READ(mesh_num_x);
EEPROM_READ(mesh_num_y);
#if ENABLED(MESH_BED_LEVELING)
mbl.status = dummy_uint8;
mbl.z_offset = dummy;
if (mesh_num_x == MESH_NUM_X_POINTS && mesh_num_y == MESH_NUM_Y_POINTS) {
// EEPROM data fits the current mesh
EEPROM_READ(mbl.z_values);
}
else {
// EEPROM data is stale
mbl.reset();
for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_READ(dummy);
}
#else
// MBL is disabled - skip the stored data
for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_READ(dummy);
#endif // MESH_BED_LEVELING
#if !HAS_BED_PROBE
float zprobe_zoffset = 0;
#endif
EEPROM_READ(zprobe_zoffset);
#if ENABLED(DELTA)
EEPROM_READ(endstop_adj); // 3 floats
EEPROM_READ(delta_radius); // 1 float
EEPROM_READ(delta_diagonal_rod); // 1 float
EEPROM_READ(delta_segments_per_second); // 1 float
EEPROM_READ(delta_diagonal_rod_trim_tower_1); // 1 float
EEPROM_READ(delta_diagonal_rod_trim_tower_2); // 1 float
EEPROM_READ(delta_diagonal_rod_trim_tower_3); // 1 float
#elif ENABLED(Z_DUAL_ENDSTOPS)
EEPROM_READ(z_endstop_adj);
dummy = 0.0f;
for (uint8_t q=8; q--;) EEPROM_READ(dummy);
#else
dummy = 0.0f;
for (uint8_t q=9; q--;) EEPROM_READ(dummy);
#endif
#if DISABLED(ULTIPANEL)
int preheatHotendTemp1, preheatBedTemp1, preheatFanSpeed1,
preheatHotendTemp2, preheatBedTemp2, preheatFanSpeed2;
#endif
EEPROM_READ(preheatHotendTemp1);
EEPROM_READ(preheatBedTemp1);
EEPROM_READ(preheatFanSpeed1);
EEPROM_READ(preheatHotendTemp2);
EEPROM_READ(preheatBedTemp2);
EEPROM_READ(preheatFanSpeed2);
#if ENABLED(PIDTEMP)
for (uint8_t e = 0; e < MAX_EXTRUDERS; e++) {
EEPROM_READ(dummy); // Kp
if (e < HOTENDS && dummy != DUMMY_PID_VALUE) {
// do not need to scale PID values as the values in EEPROM are already scaled
PID_PARAM(Kp, e) = dummy;
EEPROM_READ(PID_PARAM(Ki, e));
EEPROM_READ(PID_PARAM(Kd, e));
#if ENABLED(PID_EXTRUSION_SCALING)
EEPROM_READ(PID_PARAM(Kc, e));
#else
EEPROM_READ(dummy);
#endif
}
else {
for (uint8_t q=3; q--;) EEPROM_READ(dummy); // Ki, Kd, Kc
}
}
#else // !PIDTEMP
// 4 x 4 = 16 slots for PID parameters
for (uint8_t q = MAX_EXTRUDERS * 4; q--;) EEPROM_READ(dummy); // Kp, Ki, Kd, Kc
#endif // !PIDTEMP
#if DISABLED(PID_EXTRUSION_SCALING)
int lpq_len;
#endif
EEPROM_READ(lpq_len);
#if ENABLED(PIDTEMPBED)
EEPROM_READ(dummy); // bedKp
if (dummy != DUMMY_PID_VALUE) {
thermalManager.bedKp = dummy;
EEPROM_READ(thermalManager.bedKi);
EEPROM_READ(thermalManager.bedKd);
}
#else
for (uint8_t q=3; q--;) EEPROM_READ(dummy); // bedKp, bedKi, bedKd
#endif
#if !HAS_LCD_CONTRAST
int lcd_contrast;
#endif
EEPROM_READ(lcd_contrast);
#if ENABLED(FWRETRACT)
EEPROM_READ(autoretract_enabled);
EEPROM_READ(retract_length);
#if EXTRUDERS > 1
EEPROM_READ(retract_length_swap);
#else
EEPROM_READ(dummy);
#endif
EEPROM_READ(retract_feedrate_mm_s);
EEPROM_READ(retract_zlift);
EEPROM_READ(retract_recover_length);
#if EXTRUDERS > 1
EEPROM_READ(retract_recover_length_swap);
#else
EEPROM_READ(dummy);
#endif
EEPROM_READ(retract_recover_feedrate_mm_s);
#endif // FWRETRACT
EEPROM_READ(volumetric_enabled);
for (uint8_t q = 0; q < MAX_EXTRUDERS; q++) {
EEPROM_READ(dummy);
if (q < COUNT(filament_size)) filament_size[q] = dummy;
}
if (eeprom_checksum == stored_checksum) {
Config_Postprocess();
SERIAL_ECHO_START;
SERIAL_ECHO(version);
SERIAL_ECHOPAIR(" stored settings retrieved (", eeprom_index);
SERIAL_ECHOLNPGM(" bytes)");
}
else {
SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("EEPROM checksum mismatch");
Config_ResetDefault();
}
}
#if ENABLED(EEPROM_CHITCHAT)
Config_PrintSettings();
#endif
}
#else // !EEPROM_SETTINGS #else // !EEPROM_SETTINGS
@ -711,310 +711,310 @@ void Config_ResetDefault() {
#if DISABLED(DISABLE_M503) #if DISABLED(DISABLE_M503)
#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 - Print Configuration
*/ */
void Config_PrintSettings(bool forReplay) { void Config_PrintSettings(bool forReplay) {
// Always have this function, even with EEPROM_SETTINGS disabled, the current values will be shown // Always have this function, even with EEPROM_SETTINGS disabled, the current values will be shown
CONFIG_ECHO_START;
if (!forReplay) {
SERIAL_ECHOLNPGM("Steps per unit:");
CONFIG_ECHO_START; CONFIG_ECHO_START;
}
SERIAL_ECHOPAIR(" M92 X", planner.axis_steps_per_mm[X_AXIS]);
SERIAL_ECHOPAIR(" Y", planner.axis_steps_per_mm[Y_AXIS]);
SERIAL_ECHOPAIR(" Z", planner.axis_steps_per_mm[Z_AXIS]);
SERIAL_ECHOPAIR(" E", planner.axis_steps_per_mm[E_AXIS]);
SERIAL_EOL;
CONFIG_ECHO_START;
if (!forReplay) {
SERIAL_ECHOLNPGM("Maximum feedrates (mm/s):");
CONFIG_ECHO_START;
}
SERIAL_ECHOPAIR(" M203 X", planner.max_feedrate_mm_s[X_AXIS]);
SERIAL_ECHOPAIR(" Y", planner.max_feedrate_mm_s[Y_AXIS]);
SERIAL_ECHOPAIR(" Z", planner.max_feedrate_mm_s[Z_AXIS]);
SERIAL_ECHOPAIR(" E", planner.max_feedrate_mm_s[E_AXIS]);
SERIAL_EOL;
CONFIG_ECHO_START;
if (!forReplay) {
SERIAL_ECHOLNPGM("Maximum Acceleration (mm/s2):");
CONFIG_ECHO_START;
}
SERIAL_ECHOPAIR(" M201 X", planner.max_acceleration_mm_per_s2[X_AXIS]);
SERIAL_ECHOPAIR(" Y", planner.max_acceleration_mm_per_s2[Y_AXIS]);
SERIAL_ECHOPAIR(" Z", planner.max_acceleration_mm_per_s2[Z_AXIS]);
SERIAL_ECHOPAIR(" E", planner.max_acceleration_mm_per_s2[E_AXIS]);
SERIAL_EOL;
CONFIG_ECHO_START;
if (!forReplay) {
SERIAL_ECHOLNPGM("Accelerations: P=printing, R=retract and T=travel");
CONFIG_ECHO_START;
}
SERIAL_ECHOPAIR(" M204 P", planner.acceleration);
SERIAL_ECHOPAIR(" R", planner.retract_acceleration);
SERIAL_ECHOPAIR(" T", planner.travel_acceleration);
SERIAL_EOL;
CONFIG_ECHO_START;
if (!forReplay) {
SERIAL_ECHOLNPGM("Advanced variables: S=Min feedrate (mm/s), T=Min travel feedrate (mm/s), B=minimum segment time (ms), X=maximum XY jerk (mm/s), Z=maximum Z jerk (mm/s), E=maximum E jerk (mm/s)");
CONFIG_ECHO_START;
}
SERIAL_ECHOPAIR(" M205 S", planner.min_feedrate_mm_s);
SERIAL_ECHOPAIR(" T", planner.min_travel_feedrate_mm_s);
SERIAL_ECHOPAIR(" B", planner.min_segment_time);
SERIAL_ECHOPAIR(" X", planner.max_jerk[X_AXIS]);
SERIAL_ECHOPAIR(" Y", planner.max_jerk[Y_AXIS]);
SERIAL_ECHOPAIR(" Z", planner.max_jerk[Z_AXIS]);
SERIAL_ECHOPAIR(" E", planner.max_jerk[E_AXIS]);
SERIAL_EOL;
CONFIG_ECHO_START;
if (!forReplay) {
SERIAL_ECHOLNPGM("Home offset (mm)");
CONFIG_ECHO_START;
}
SERIAL_ECHOPAIR(" M206 X", home_offset[X_AXIS]);
SERIAL_ECHOPAIR(" Y", home_offset[Y_AXIS]);
SERIAL_ECHOPAIR(" Z", home_offset[Z_AXIS]);
SERIAL_EOL;
#if HOTENDS > 1
CONFIG_ECHO_START;
if (!forReplay) { if (!forReplay) {
SERIAL_ECHOLNPGM("Hotend offsets (mm)"); SERIAL_ECHOLNPGM("Steps per unit:");
CONFIG_ECHO_START; CONFIG_ECHO_START;
} }
for (uint8_t e = 1; e < HOTENDS; e++) { SERIAL_ECHOPAIR(" M92 X", planner.axis_steps_per_mm[X_AXIS]);
SERIAL_ECHOPAIR(" M218 T", (int)e); SERIAL_ECHOPAIR(" Y", planner.axis_steps_per_mm[Y_AXIS]);
SERIAL_ECHOPAIR(" X", hotend_offset[X_AXIS]); SERIAL_ECHOPAIR(" Z", planner.axis_steps_per_mm[Z_AXIS]);
SERIAL_ECHOPAIR(" Y", hotend_offset[Y_AXIS]); SERIAL_ECHOPAIR(" E", planner.axis_steps_per_mm[E_AXIS]);
#if ENABLED(DUAL_X_CARRIAGE) || ENABLED(SWITCHING_EXTRUDER) SERIAL_EOL;
SERIAL_ECHOPAIR(" Z", hotend_offset[Z_AXIS]);
#endif CONFIG_ECHO_START;
SERIAL_EOL;
}
#endif
#if ENABLED(MESH_BED_LEVELING)
if (!forReplay) { if (!forReplay) {
SERIAL_ECHOLNPGM("Mesh bed leveling:"); SERIAL_ECHOLNPGM("Maximum feedrates (mm/s):");
CONFIG_ECHO_START; CONFIG_ECHO_START;
} }
SERIAL_ECHOPAIR(" M420 S", mbl.has_mesh() ? 1 : 0); SERIAL_ECHOPAIR(" M203 X", planner.max_feedrate_mm_s[X_AXIS]);
SERIAL_ECHOPAIR(" X", MESH_NUM_X_POINTS); SERIAL_ECHOPAIR(" Y", planner.max_feedrate_mm_s[Y_AXIS]);
SERIAL_ECHOPAIR(" Y", MESH_NUM_Y_POINTS); SERIAL_ECHOPAIR(" Z", planner.max_feedrate_mm_s[Z_AXIS]);
SERIAL_ECHOPAIR(" E", planner.max_feedrate_mm_s[E_AXIS]);
SERIAL_EOL; SERIAL_EOL;
for (uint8_t py = 1; py <= MESH_NUM_Y_POINTS; py++) {
for (uint8_t px = 1; px <= MESH_NUM_X_POINTS; px++) {
CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" G29 S3 X", (int)px);
SERIAL_ECHOPAIR(" Y", (int)py);
SERIAL_ECHOPGM(" Z");
SERIAL_PROTOCOL_F(mbl.z_values[py-1][px-1], 5);
SERIAL_EOL;
}
}
#endif
#if ENABLED(DELTA)
CONFIG_ECHO_START; CONFIG_ECHO_START;
if (!forReplay) { if (!forReplay) {
SERIAL_ECHOLNPGM("Endstop adjustment (mm):"); SERIAL_ECHOLNPGM("Maximum Acceleration (mm/s2):");
CONFIG_ECHO_START; CONFIG_ECHO_START;
} }
SERIAL_ECHOPAIR(" M666 X", endstop_adj[X_AXIS]); SERIAL_ECHOPAIR(" M201 X", planner.max_acceleration_mm_per_s2[X_AXIS]);
SERIAL_ECHOPAIR(" Y", endstop_adj[Y_AXIS]); SERIAL_ECHOPAIR(" Y", planner.max_acceleration_mm_per_s2[Y_AXIS]);
SERIAL_ECHOPAIR(" Z", endstop_adj[Z_AXIS]); SERIAL_ECHOPAIR(" Z", planner.max_acceleration_mm_per_s2[Z_AXIS]);
SERIAL_ECHOPAIR(" E", planner.max_acceleration_mm_per_s2[E_AXIS]);
SERIAL_EOL; SERIAL_EOL;
CONFIG_ECHO_START; CONFIG_ECHO_START;
if (!forReplay) { if (!forReplay) {
SERIAL_ECHOLNPGM("Delta settings: L=diagonal_rod, R=radius, S=segments_per_second, ABC=diagonal_rod_trim_tower_[123]"); SERIAL_ECHOLNPGM("Accelerations: P=printing, R=retract and T=travel");
CONFIG_ECHO_START; CONFIG_ECHO_START;
} }
SERIAL_ECHOPAIR(" M665 L", delta_diagonal_rod); SERIAL_ECHOPAIR(" M204 P", planner.acceleration);
SERIAL_ECHOPAIR(" R", delta_radius); SERIAL_ECHOPAIR(" R", planner.retract_acceleration);
SERIAL_ECHOPAIR(" S", delta_segments_per_second); SERIAL_ECHOPAIR(" T", planner.travel_acceleration);
SERIAL_ECHOPAIR(" A", delta_diagonal_rod_trim_tower_1);
SERIAL_ECHOPAIR(" B", delta_diagonal_rod_trim_tower_2);
SERIAL_ECHOPAIR(" C", delta_diagonal_rod_trim_tower_3);
SERIAL_EOL; SERIAL_EOL;
#elif ENABLED(Z_DUAL_ENDSTOPS)
CONFIG_ECHO_START; CONFIG_ECHO_START;
if (!forReplay) { if (!forReplay) {
SERIAL_ECHOLNPGM("Z2 Endstop adjustment (mm):"); SERIAL_ECHOLNPGM("Advanced variables: S=Min feedrate (mm/s), T=Min travel feedrate (mm/s), B=minimum segment time (ms), X=maximum XY jerk (mm/s), Z=maximum Z jerk (mm/s), E=maximum E jerk (mm/s)");
CONFIG_ECHO_START; CONFIG_ECHO_START;
} }
SERIAL_ECHOPAIR(" M666 Z", z_endstop_adj); SERIAL_ECHOPAIR(" M205 S", planner.min_feedrate_mm_s);
SERIAL_ECHOPAIR(" T", planner.min_travel_feedrate_mm_s);
SERIAL_ECHOPAIR(" B", planner.min_segment_time);
SERIAL_ECHOPAIR(" X", planner.max_jerk[X_AXIS]);
SERIAL_ECHOPAIR(" Y", planner.max_jerk[Y_AXIS]);
SERIAL_ECHOPAIR(" Z", planner.max_jerk[Z_AXIS]);
SERIAL_ECHOPAIR(" E", planner.max_jerk[E_AXIS]);
SERIAL_EOL; SERIAL_EOL;
#endif // DELTA
#if ENABLED(ULTIPANEL)
CONFIG_ECHO_START; CONFIG_ECHO_START;
if (!forReplay) { if (!forReplay) {
SERIAL_ECHOLNPGM("Material heatup parameters:"); SERIAL_ECHOLNPGM("Home offset (mm)");
CONFIG_ECHO_START; CONFIG_ECHO_START;
} }
SERIAL_ECHOPAIR(" M145 S0 H", preheatHotendTemp1); SERIAL_ECHOPAIR(" M206 X", home_offset[X_AXIS]);
SERIAL_ECHOPAIR(" B", preheatBedTemp1); SERIAL_ECHOPAIR(" Y", home_offset[Y_AXIS]);
SERIAL_ECHOPAIR(" F", preheatFanSpeed1); SERIAL_ECHOPAIR(" Z", home_offset[Z_AXIS]);
SERIAL_EOL; SERIAL_EOL;
CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" M145 S1 H", preheatHotendTemp2);
SERIAL_ECHOPAIR(" B", preheatBedTemp2);
SERIAL_ECHOPAIR(" F", preheatFanSpeed2);
SERIAL_EOL;
#endif // ULTIPANEL
#if HAS_PID_HEATING
CONFIG_ECHO_START; #if HOTENDS > 1
if (!forReplay) { CONFIG_ECHO_START;
SERIAL_ECHOLNPGM("PID settings:"); if (!forReplay) {
} SERIAL_ECHOLNPGM("Hotend offsets (mm)");
#if ENABLED(PIDTEMP)
#if HOTENDS > 1
if (forReplay) {
HOTEND_LOOP() {
CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" M301 E", e);
SERIAL_ECHOPAIR(" P", PID_PARAM(Kp, e));
SERIAL_ECHOPAIR(" I", unscalePID_i(PID_PARAM(Ki, e)));
SERIAL_ECHOPAIR(" D", unscalePID_d(PID_PARAM(Kd, e)));
#if ENABLED(PID_EXTRUSION_SCALING)
SERIAL_ECHOPAIR(" C", PID_PARAM(Kc, e));
if (e == 0) SERIAL_ECHOPAIR(" L", lpq_len);
#endif
SERIAL_EOL;
}
}
else
#endif // HOTENDS > 1
// !forReplay || HOTENDS == 1
{
CONFIG_ECHO_START; CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" M301 P", PID_PARAM(Kp, 0)); // for compatibility with hosts, only echo values for E0 }
SERIAL_ECHOPAIR(" I", unscalePID_i(PID_PARAM(Ki, 0))); for (uint8_t e = 1; e < HOTENDS; e++) {
SERIAL_ECHOPAIR(" D", unscalePID_d(PID_PARAM(Kd, 0))); SERIAL_ECHOPAIR(" M218 T", (int)e);
#if ENABLED(PID_EXTRUSION_SCALING) SERIAL_ECHOPAIR(" X", hotend_offset[X_AXIS]);
SERIAL_ECHOPAIR(" C", PID_PARAM(Kc, 0)); SERIAL_ECHOPAIR(" Y", hotend_offset[Y_AXIS]);
SERIAL_ECHOPAIR(" L", lpq_len); #if ENABLED(DUAL_X_CARRIAGE) || ENABLED(SWITCHING_EXTRUDER)
SERIAL_ECHOPAIR(" Z", hotend_offset[Z_AXIS]);
#endif #endif
SERIAL_EOL; SERIAL_EOL;
} }
#endif // PIDTEMP #endif
#if ENABLED(PIDTEMPBED) #if ENABLED(MESH_BED_LEVELING)
CONFIG_ECHO_START; if (!forReplay) {
SERIAL_ECHOPAIR(" M304 P", thermalManager.bedKp); SERIAL_ECHOLNPGM("Mesh bed leveling:");
SERIAL_ECHOPAIR(" I", unscalePID_i(thermalManager.bedKi)); CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" D", unscalePID_d(thermalManager.bedKd)); }
SERIAL_ECHOPAIR(" M420 S", mbl.has_mesh() ? 1 : 0);
SERIAL_ECHOPAIR(" X", MESH_NUM_X_POINTS);
SERIAL_ECHOPAIR(" Y", MESH_NUM_Y_POINTS);
SERIAL_EOL; SERIAL_EOL;
for (uint8_t py = 1; py <= MESH_NUM_Y_POINTS; py++) {
for (uint8_t px = 1; px <= MESH_NUM_X_POINTS; px++) {
CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" G29 S3 X", (int)px);
SERIAL_ECHOPAIR(" Y", (int)py);
SERIAL_ECHOPGM(" Z");
SERIAL_PROTOCOL_F(mbl.z_values[py-1][px-1], 5);
SERIAL_EOL;
}
}
#endif #endif
#endif // PIDTEMP || PIDTEMPBED #if ENABLED(DELTA)
CONFIG_ECHO_START;
if (!forReplay) {
SERIAL_ECHOLNPGM("Endstop adjustment (mm):");
CONFIG_ECHO_START;
}
SERIAL_ECHOPAIR(" M666 X", endstop_adj[X_AXIS]);
SERIAL_ECHOPAIR(" Y", endstop_adj[Y_AXIS]);
SERIAL_ECHOPAIR(" Z", endstop_adj[Z_AXIS]);
SERIAL_EOL;
CONFIG_ECHO_START;
if (!forReplay) {
SERIAL_ECHOLNPGM("Delta settings: L=diagonal_rod, R=radius, S=segments_per_second, ABC=diagonal_rod_trim_tower_[123]");
CONFIG_ECHO_START;
}
SERIAL_ECHOPAIR(" M665 L", delta_diagonal_rod);
SERIAL_ECHOPAIR(" R", delta_radius);
SERIAL_ECHOPAIR(" S", delta_segments_per_second);
SERIAL_ECHOPAIR(" A", delta_diagonal_rod_trim_tower_1);
SERIAL_ECHOPAIR(" B", delta_diagonal_rod_trim_tower_2);
SERIAL_ECHOPAIR(" C", delta_diagonal_rod_trim_tower_3);
SERIAL_EOL;
#elif ENABLED(Z_DUAL_ENDSTOPS)
CONFIG_ECHO_START;
if (!forReplay) {
SERIAL_ECHOLNPGM("Z2 Endstop adjustment (mm):");
CONFIG_ECHO_START;
}
SERIAL_ECHOPAIR(" M666 Z", z_endstop_adj);
SERIAL_EOL;
#endif // DELTA
#if HAS_LCD_CONTRAST #if ENABLED(ULTIPANEL)
CONFIG_ECHO_START;
if (!forReplay) {
SERIAL_ECHOLNPGM("LCD Contrast:");
CONFIG_ECHO_START; CONFIG_ECHO_START;
} if (!forReplay) {
SERIAL_ECHOPAIR(" M250 C", lcd_contrast); SERIAL_ECHOLNPGM("Material heatup parameters:");
SERIAL_EOL; CONFIG_ECHO_START;
#endif }
SERIAL_ECHOPAIR(" M145 S0 H", preheatHotendTemp1);
SERIAL_ECHOPAIR(" B", preheatBedTemp1);
SERIAL_ECHOPAIR(" F", preheatFanSpeed1);
SERIAL_EOL;
CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" M145 S1 H", preheatHotendTemp2);
SERIAL_ECHOPAIR(" B", preheatBedTemp2);
SERIAL_ECHOPAIR(" F", preheatFanSpeed2);
SERIAL_EOL;
#endif // ULTIPANEL
#if ENABLED(FWRETRACT) #if HAS_PID_HEATING
CONFIG_ECHO_START;
if (!forReplay) {
SERIAL_ECHOLNPGM("Retract: S=Length (mm) F:Speed (mm/m) Z: ZLift (mm)");
CONFIG_ECHO_START; CONFIG_ECHO_START;
} if (!forReplay) {
SERIAL_ECHOPAIR(" M207 S", retract_length); SERIAL_ECHOLNPGM("PID settings:");
#if EXTRUDERS > 1 }
SERIAL_ECHOPAIR(" W", retract_length_swap); #if ENABLED(PIDTEMP)
#endif #if HOTENDS > 1
SERIAL_ECHOPAIR(" F", MMS_TO_MMM(retract_feedrate_mm_s)); if (forReplay) {
SERIAL_ECHOPAIR(" Z", retract_zlift); HOTEND_LOOP() {
SERIAL_EOL; CONFIG_ECHO_START;
CONFIG_ECHO_START; SERIAL_ECHOPAIR(" M301 E", e);
if (!forReplay) { SERIAL_ECHOPAIR(" P", PID_PARAM(Kp, e));
SERIAL_ECHOLNPGM("Recover: S=Extra length (mm) F:Speed (mm/m)"); SERIAL_ECHOPAIR(" I", unscalePID_i(PID_PARAM(Ki, e)));
SERIAL_ECHOPAIR(" D", unscalePID_d(PID_PARAM(Kd, e)));
#if ENABLED(PID_EXTRUSION_SCALING)
SERIAL_ECHOPAIR(" C", PID_PARAM(Kc, e));
if (e == 0) SERIAL_ECHOPAIR(" L", lpq_len);
#endif
SERIAL_EOL;
}
}
else
#endif // HOTENDS > 1
// !forReplay || HOTENDS == 1
{
CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" M301 P", PID_PARAM(Kp, 0)); // for compatibility with hosts, only echo values for E0
SERIAL_ECHOPAIR(" I", unscalePID_i(PID_PARAM(Ki, 0)));
SERIAL_ECHOPAIR(" D", unscalePID_d(PID_PARAM(Kd, 0)));
#if ENABLED(PID_EXTRUSION_SCALING)
SERIAL_ECHOPAIR(" C", PID_PARAM(Kc, 0));
SERIAL_ECHOPAIR(" L", lpq_len);
#endif
SERIAL_EOL;
}
#endif // PIDTEMP
#if ENABLED(PIDTEMPBED)
CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" M304 P", thermalManager.bedKp);
SERIAL_ECHOPAIR(" I", unscalePID_i(thermalManager.bedKi));
SERIAL_ECHOPAIR(" D", unscalePID_d(thermalManager.bedKd));
SERIAL_EOL;
#endif
#endif // PIDTEMP || PIDTEMPBED
#if HAS_LCD_CONTRAST
CONFIG_ECHO_START; CONFIG_ECHO_START;
} if (!forReplay) {
SERIAL_ECHOPAIR(" M208 S", retract_recover_length); SERIAL_ECHOLNPGM("LCD Contrast:");
#if EXTRUDERS > 1 CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" W", retract_recover_length_swap); }
SERIAL_ECHOPAIR(" M250 C", lcd_contrast);
SERIAL_EOL;
#endif #endif
SERIAL_ECHOPAIR(" F", MMS_TO_MMM(retract_recover_feedrate_mm_s));
SERIAL_EOL;
CONFIG_ECHO_START;
if (!forReplay) {
SERIAL_ECHOLNPGM("Auto-Retract: S=0 to disable, 1 to interpret extrude-only moves as retracts or recoveries");
CONFIG_ECHO_START;
}
SERIAL_ECHOPAIR(" M209 S", autoretract_enabled ? 1 : 0);
SERIAL_EOL;
#endif // FWRETRACT #if ENABLED(FWRETRACT)
/** CONFIG_ECHO_START;
* Volumetric extrusion M200 if (!forReplay) {
*/ SERIAL_ECHOLNPGM("Retract: S=Length (mm) F:Speed (mm/m) Z: ZLift (mm)");
if (!forReplay) { CONFIG_ECHO_START;
CONFIG_ECHO_START; }
SERIAL_ECHOPGM("Filament settings:"); SERIAL_ECHOPAIR(" M207 S", retract_length);
if (volumetric_enabled) #if EXTRUDERS > 1
SERIAL_ECHOPAIR(" W", retract_length_swap);
#endif
SERIAL_ECHOPAIR(" F", MMS_TO_MMM(retract_feedrate_mm_s));
SERIAL_ECHOPAIR(" Z", retract_zlift);
SERIAL_EOL;
CONFIG_ECHO_START;
if (!forReplay) {
SERIAL_ECHOLNPGM("Recover: S=Extra length (mm) F:Speed (mm/m)");
CONFIG_ECHO_START;
}
SERIAL_ECHOPAIR(" M208 S", retract_recover_length);
#if EXTRUDERS > 1
SERIAL_ECHOPAIR(" W", retract_recover_length_swap);
#endif
SERIAL_ECHOPAIR(" F", MMS_TO_MMM(retract_recover_feedrate_mm_s));
SERIAL_EOL;
CONFIG_ECHO_START;
if (!forReplay) {
SERIAL_ECHOLNPGM("Auto-Retract: S=0 to disable, 1 to interpret extrude-only moves as retracts or recoveries");
CONFIG_ECHO_START;
}
SERIAL_ECHOPAIR(" M209 S", autoretract_enabled ? 1 : 0);
SERIAL_EOL; SERIAL_EOL;
else
SERIAL_ECHOLNPGM(" Disabled");
}
CONFIG_ECHO_START; #endif // FWRETRACT
SERIAL_ECHOPAIR(" M200 D", filament_size[0]);
SERIAL_EOL; /**
#if EXTRUDERS > 1 * Volumetric extrusion M200
*/
if (!forReplay) {
CONFIG_ECHO_START;
SERIAL_ECHOPGM("Filament settings:");
if (volumetric_enabled)
SERIAL_EOL;
else
SERIAL_ECHOLNPGM(" Disabled");
}
CONFIG_ECHO_START; CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" M200 T1 D", filament_size[1]); SERIAL_ECHOPAIR(" M200 D", filament_size[0]);
SERIAL_EOL; SERIAL_EOL;
#if EXTRUDERS > 2 #if EXTRUDERS > 1
CONFIG_ECHO_START; CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" M200 T2 D", filament_size[2]); SERIAL_ECHOPAIR(" M200 T1 D", filament_size[1]);
SERIAL_EOL; SERIAL_EOL;
#if EXTRUDERS > 3 #if EXTRUDERS > 2
CONFIG_ECHO_START; CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" M200 T3 D", filament_size[3]); SERIAL_ECHOPAIR(" M200 T2 D", filament_size[2]);
SERIAL_EOL; SERIAL_EOL;
#if EXTRUDERS > 3
CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" M200 T3 D", filament_size[3]);
SERIAL_EOL;
#endif
#endif #endif
#endif #endif
#endif
if (!volumetric_enabled) { if (!volumetric_enabled) {
CONFIG_ECHO_START;
SERIAL_ECHOLNPGM(" M200 D0");
}
/**
* Auto Bed Leveling
*/
#if HAS_BED_PROBE
if (!forReplay) {
CONFIG_ECHO_START; CONFIG_ECHO_START;
SERIAL_ECHOLNPGM("Z-Probe Offset (mm):"); SERIAL_ECHOLNPGM(" M200 D0");
} }
CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" M851 Z", zprobe_zoffset); /**
SERIAL_EOL; * Auto Bed Leveling
#endif */
} #if HAS_BED_PROBE
if (!forReplay) {
CONFIG_ECHO_START;
SERIAL_ECHOLNPGM("Z-Probe Offset (mm):");
}
CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" M851 Z", zprobe_zoffset);
SERIAL_EOL;
#endif
}
#endif // !DISABLE_M503 #endif // !DISABLE_M503

Write Preview
Loading…
Cancel
Save