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

Make EEPROM storage consistent

Browse Source 
Update ConfigurationStore to always write dummy values for disabled
options, including FWRETRACT, DELTA, and SCARA. Update the EEPROM
version to “V15.” Also fixes a buffer overrun with axis_scaling in
Config_ResetDefault.
master
Scott Lahteine 10 years ago
parent 34377ee512
commit 093fedfde8
3 changed files with 593 additions and 478 deletions
Show Stats Download Patch File Download Diff File

1053
Marlin/ConfigurationStore.cpp
Unescape View File

@ -1,33 +1,92 @@
/**
* ConfigurationStore.cpp
*
* Configuration and EEPROM storage
*
* V15 EEPROM Layout:
*
* ver
* axis_steps_per_unit (x4)
* max_feedrate (x4)
* max_acceleration_units_per_sq_second (x4)
* acceleration
* retract_acceleration
* minimumfeedrate
* mintravelfeedrate
* minsegmenttime
* max_xy_jerk
* max_z_jerk
* max_e_jerk
* add_homing (x3)
*
* DELTA:
* endstop_adj (x3)
* delta_radius
* delta_diagonal_rod
* delta_segments_per_second
*
* ULTIPANEL:
* plaPreheatHotendTemp
* plaPreheatHPBTemp
* plaPreheatFanSpeed
* absPreheatHotendTemp
* absPreheatHPBTemp
* absPreheatFanSpeed
* zprobe_zoffset
*
* PIDTEMP:
* Kp[0], Ki[0], Kd[0], Kc[0]
* Kp[1], Ki[1], Kd[1], Kc[1]
* Kp[2], Ki[2], Kd[2], Kc[2]
* Kp[3], Ki[3], Kd[3], Kc[3]
*
* DOGLCD:
* lcd_contrast
*
* SCARA:
* axis_scaling (x3)
*
* FWRETRACT:
* autoretract_enabled
* retract_length
* retract_length_swap
* retract_feedrate
* retract_zlift
* retract_recover_length
* retract_recover_length_swap
* retract_recover_feedrate
*
* volumetric_enabled
*
* filament_size (x4)
*
*/
#include "Marlin.h" #include "Marlin.h"
#include "planner.h" #include "planner.h"
#include "temperature.h" #include "temperature.h"
#include "ultralcd.h" #include "ultralcd.h"
#include "ConfigurationStore.h" #include "ConfigurationStore.h"
void _EEPROM_writeData(int &pos, uint8_t* value, uint8_t size) void _EEPROM_writeData(int &pos, uint8_t* value, uint8_t size) {
{ do {
do eeprom_write_byte((unsigned char*)pos, *value);
{ pos++;
eeprom_write_byte((unsigned char*)pos, *value); value++;
pos++; } while (--size);
value++;
}while(--size);
} }
#define EEPROM_WRITE_VAR(pos, value) _EEPROM_writeData(pos, (uint8_t*)&value, sizeof(value)) void _EEPROM_readData(int &pos, uint8_t* value, uint8_t size) {
void _EEPROM_readData(int &pos, uint8_t* value, uint8_t size) do {
{ *value = eeprom_read_byte((unsigned char*)pos);
do pos++;
{ value++;
*value = eeprom_read_byte((unsigned char*)pos); } while (--size);
pos++;
value++;
}while(--size);
} }
#define EEPROM_WRITE_VAR(pos, value) _EEPROM_writeData(pos, (uint8_t*)&value, sizeof(value))
#define EEPROM_READ_VAR(pos, value) _EEPROM_readData(pos, (uint8_t*)&value, sizeof(value)) #define EEPROM_READ_VAR(pos, value) _EEPROM_readData(pos, (uint8_t*)&value, sizeof(value))
//======================================================================================
//======================================================================================
#define DUMMY_PID_VALUE 3000.0f
#define EEPROM_OFFSET 100 #define EEPROM_OFFSET 100
@ -38,506 +97,562 @@ void _EEPROM_readData(int &pos, uint8_t* value, uint8_t size)
// wrong data being written to the variables. // wrong data being written to the variables.
// ALSO: always make sure the variables in the Store and retrieve sections are in the same order. // ALSO: always make sure the variables in the Store and retrieve sections are in the same order.
#define EEPROM_VERSION "V14" #define EEPROM_VERSION "V15"
#ifdef EEPROM_SETTINGS #ifdef EEPROM_SETTINGS
void Config_StoreSettings()
{ void Config_StoreSettings() {
char ver[4]= "000"; float dummy = 0.0f;
int i=EEPROM_OFFSET; char ver[4] = "000";
EEPROM_WRITE_VAR(i,ver); // invalidate data first int i = EEPROM_OFFSET;
EEPROM_WRITE_VAR(i,axis_steps_per_unit); EEPROM_WRITE_VAR(i, ver); // invalidate data first
EEPROM_WRITE_VAR(i,max_feedrate); EEPROM_WRITE_VAR(i, axis_steps_per_unit);
EEPROM_WRITE_VAR(i,max_acceleration_units_per_sq_second); EEPROM_WRITE_VAR(i, max_feedrate);
EEPROM_WRITE_VAR(i,acceleration); EEPROM_WRITE_VAR(i, max_acceleration_units_per_sq_second);
EEPROM_WRITE_VAR(i,retract_acceleration); EEPROM_WRITE_VAR(i, acceleration);
EEPROM_WRITE_VAR(i,minimumfeedrate); EEPROM_WRITE_VAR(i, retract_acceleration);
EEPROM_WRITE_VAR(i,mintravelfeedrate); EEPROM_WRITE_VAR(i, minimumfeedrate);
EEPROM_WRITE_VAR(i,minsegmenttime); EEPROM_WRITE_VAR(i, mintravelfeedrate);
EEPROM_WRITE_VAR(i,max_xy_jerk); EEPROM_WRITE_VAR(i, minsegmenttime);
EEPROM_WRITE_VAR(i,max_z_jerk); EEPROM_WRITE_VAR(i, max_xy_jerk);
EEPROM_WRITE_VAR(i,max_e_jerk); EEPROM_WRITE_VAR(i, max_z_jerk);
EEPROM_WRITE_VAR(i,add_homing); EEPROM_WRITE_VAR(i, max_e_jerk);
EEPROM_WRITE_VAR(i, add_homing);
#ifdef DELTA #ifdef DELTA
EEPROM_WRITE_VAR(i,endstop_adj); EEPROM_WRITE_VAR(i, endstop_adj); // 3 floats
EEPROM_WRITE_VAR(i,delta_radius); EEPROM_WRITE_VAR(i, delta_radius); // 1 float
EEPROM_WRITE_VAR(i,delta_diagonal_rod); EEPROM_WRITE_VAR(i, delta_diagonal_rod); // 1 float
EEPROM_WRITE_VAR(i,delta_segments_per_second); EEPROM_WRITE_VAR(i, delta_segments_per_second); // 1 float
#endif//DELTA #else
dummy = 0.0f;
for (int q=6; q--;) EEPROM_WRITE_VAR(i, dummy);
#endif
#ifndef ULTIPANEL #ifndef ULTIPANEL
int plaPreheatHotendTemp = PLA_PREHEAT_HOTEND_TEMP, plaPreheatHPBTemp = PLA_PREHEAT_HPB_TEMP, plaPreheatFanSpeed = PLA_PREHEAT_FAN_SPEED; int plaPreheatHotendTemp = PLA_PREHEAT_HOTEND_TEMP, plaPreheatHPBTemp = PLA_PREHEAT_HPB_TEMP, plaPreheatFanSpeed = PLA_PREHEAT_FAN_SPEED,
int absPreheatHotendTemp = ABS_PREHEAT_HOTEND_TEMP, absPreheatHPBTemp = ABS_PREHEAT_HPB_TEMP, absPreheatFanSpeed = ABS_PREHEAT_FAN_SPEED; absPreheatHotendTemp = ABS_PREHEAT_HOTEND_TEMP, absPreheatHPBTemp = ABS_PREHEAT_HPB_TEMP, absPreheatFanSpeed = ABS_PREHEAT_FAN_SPEED;
#endif//ULTIPANEL #endif // !ULTIPANEL
EEPROM_WRITE_VAR(i,plaPreheatHotendTemp);
EEPROM_WRITE_VAR(i,plaPreheatHPBTemp); EEPROM_WRITE_VAR(i, plaPreheatHotendTemp);
EEPROM_WRITE_VAR(i,plaPreheatFanSpeed); EEPROM_WRITE_VAR(i, plaPreheatHPBTemp);
EEPROM_WRITE_VAR(i,absPreheatHotendTemp); EEPROM_WRITE_VAR(i, plaPreheatFanSpeed);
EEPROM_WRITE_VAR(i,absPreheatHPBTemp); EEPROM_WRITE_VAR(i, absPreheatHotendTemp);
EEPROM_WRITE_VAR(i,absPreheatFanSpeed); EEPROM_WRITE_VAR(i, absPreheatHPBTemp);
EEPROM_WRITE_VAR(i,zprobe_zoffset); EEPROM_WRITE_VAR(i, absPreheatFanSpeed);
#ifdef PIDTEMP EEPROM_WRITE_VAR(i, zprobe_zoffset);
float dummy = 0.0f;
for (int e = 0; e < 4; e++) for (int e = 0; e < 4; e++) {
{
if (e < EXTRUDERS) #ifdef PIDTEMP
{ if (e < EXTRUDERS) {
EEPROM_WRITE_VAR(i,PID_PARAM(Kp,e)); EEPROM_WRITE_VAR(i, PID_PARAM(Kp, e));
EEPROM_WRITE_VAR(i,PID_PARAM(Ki,e)); EEPROM_WRITE_VAR(i, PID_PARAM(Ki, e));
EEPROM_WRITE_VAR(i,PID_PARAM(Kd,e)); EEPROM_WRITE_VAR(i, PID_PARAM(Kd, e));
#ifdef PID_ADD_EXTRUSION_RATE #ifdef PID_ADD_EXTRUSION_RATE
EEPROM_WRITE_VAR(i,PID_PARAM(Kc,e)); EEPROM_WRITE_VAR(i, PID_PARAM(Kc, e));
#else//PID_ADD_EXTRUSION_RATE #else
dummy = 1.0f; // 1.0 = default kc dummy = 1.0f; // 1.0 = default kc
EEPROM_WRITE_VAR(dummmy); EEPROM_WRITE_VAR(dummmy);
#endif//PID_ADD_EXTRUSION_RATE #endif
} }
else else {
{ #else // !PIDTEMP
dummy = 3000.0f; {
EEPROM_WRITE_VAR(i, dummy); #endif // !PIDTEMP
dummy = 0.0f;
EEPROM_WRITE_VAR(i,dummy); dummy = DUMMY_PID_VALUE;
EEPROM_WRITE_VAR(i,dummy); EEPROM_WRITE_VAR(i, dummy);
EEPROM_WRITE_VAR(i,dummy); dummy = 0.0f;
} for (int q = 3; q--;) EEPROM_WRITE_VAR(i, dummy);
} }
#else//PIDTEMP } // Extruders Loop
float dummy = 3000.0f;
EEPROM_WRITE_VAR(i,dummy);
dummy = 0.0f;
EEPROM_WRITE_VAR(i,dummy);
EEPROM_WRITE_VAR(i,dummy);
EEPROM_WRITE_VAR(i,dummy);
#endif//PIDTEMP
#ifndef DOGLCD #ifndef DOGLCD
int lcd_contrast = 32; int lcd_contrast = 32;
#endif//DOGLCD #endif
EEPROM_WRITE_VAR(i,lcd_contrast); EEPROM_WRITE_VAR(i, lcd_contrast);
#ifdef SCARA #ifdef SCARA
EEPROM_WRITE_VAR(i,axis_scaling); // Add scaling for SCARA EEPROM_WRITE_VAR(i, axis_scaling); // 3 floats
#endif//SCARA #else
dummy = 1.0f;
EEPROM_WRITE_VAR(i, dummy);
#endif
#ifdef FWRETRACT #ifdef FWRETRACT
EEPROM_WRITE_VAR(i,autoretract_enabled); EEPROM_WRITE_VAR(i, autoretract_enabled);
EEPROM_WRITE_VAR(i,retract_length); EEPROM_WRITE_VAR(i, retract_length);
#if EXTRUDERS > 1 #if EXTRUDERS > 1
EEPROM_WRITE_VAR(i,retract_length_swap); EEPROM_WRITE_VAR(i, retract_length_swap);
#endif//EXTRUDERS > 1 #else
EEPROM_WRITE_VAR(i,retract_feedrate); dummy = 0.0f;
EEPROM_WRITE_VAR(i,retract_zlift); EEPROM_WRITE_VAR(i, dummy);
EEPROM_WRITE_VAR(i,retract_recover_length); #endif
#if EXTRUDERS > 1 EEPROM_WRITE_VAR(i, retract_feedrate);
EEPROM_WRITE_VAR(i,retract_recover_length_swap); EEPROM_WRITE_VAR(i, retract_zlift);
#endif//EXTRUDERS > 1 EEPROM_WRITE_VAR(i, retract_recover_length);
EEPROM_WRITE_VAR(i,retract_recover_feedrate); #if EXTRUDERS > 1
#endif//FWRETRACT EEPROM_WRITE_VAR(i, retract_recover_length_swap);
#else
dummy = 0.0f;
EEPROM_WRITE_VAR(i, dummy);
#endif
EEPROM_WRITE_VAR(i, retract_recover_feedrate);
#endif // FWRETRACT
// Save filament sizes
EEPROM_WRITE_VAR(i, volumetric_enabled); EEPROM_WRITE_VAR(i, volumetric_enabled);
EEPROM_WRITE_VAR(i, filament_size[0]);
#if EXTRUDERS > 1 // Save filament sizes
EEPROM_WRITE_VAR(i, filament_size[1]); for (int q = 0; q < 4; q++) {
#if EXTRUDERS > 2 if (q < EXTRUDERS) dummy = filament_size[q];
EEPROM_WRITE_VAR(i, filament_size[2]); EEPROM_WRITE_VAR(i, dummy);
#if EXTRUDERS > 3 }
EEPROM_WRITE_VAR(i, filament_size[3]);
#endif //EXTRUDERS > 3 int storageSize = i;
#endif //EXTRUDERS > 2
#endif //EXTRUDERS > 1 char ver2[4] = EEPROM_VERSION;
int j = EEPROM_OFFSET;
char ver2[4]=EEPROM_VERSION; EEPROM_WRITE_VAR(j, ver2); // validate data
i=EEPROM_OFFSET;
EEPROM_WRITE_VAR(i,ver2); // validate data // Report storage size
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("Settings Stored"); SERIAL_ECHOPAIR("Settings Stored (", (unsigned long)i);
SERIAL_ECHOLNPGM(" bytes)");
} }
#endif //EEPROM_SETTINGS
void Config_RetrieveSettings() {
#ifndef DISABLE_M503 int i = EEPROM_OFFSET;
void Config_PrintSettings() char stored_ver[4];
{ // Always have this function, even with EEPROM_SETTINGS disabled, the current values will be shown char ver[4] = EEPROM_VERSION;
EEPROM_READ_VAR(i, stored_ver); //read stored version
// SERIAL_ECHOLN("Version: [" << ver << "] Stored version: [" << stored_ver << "]");
if (strncmp(ver, stored_ver, 3) != 0) {
Config_ResetDefault();
}
else {
float dummy = 0;
// version number match
EEPROM_READ_VAR(i, axis_steps_per_unit);
EEPROM_READ_VAR(i, max_feedrate);
EEPROM_READ_VAR(i, max_acceleration_units_per_sq_second);
// steps per sq second need to be updated to agree with the units per sq second (as they are what is used in the planner)
reset_acceleration_rates();
EEPROM_READ_VAR(i, acceleration);
EEPROM_READ_VAR(i, retract_acceleration);
EEPROM_READ_VAR(i, minimumfeedrate);
EEPROM_READ_VAR(i, mintravelfeedrate);
EEPROM_READ_VAR(i, minsegmenttime);
EEPROM_READ_VAR(i, max_xy_jerk);
EEPROM_READ_VAR(i, max_z_jerk);
EEPROM_READ_VAR(i, max_e_jerk);
EEPROM_READ_VAR(i, add_homing);
#ifdef DELTA
EEPROM_READ_VAR(i, endstop_adj); // 3 floats
EEPROM_READ_VAR(i, delta_radius); // 1 float
EEPROM_READ_VAR(i, delta_diagonal_rod); // 1 float
EEPROM_READ_VAR(i, delta_segments_per_second); // 1 float
#else
for (int q=6; q--;) EEPROM_READ_VAR(i, dummy);
#endif
#ifndef ULTIPANEL
int plaPreheatHotendTemp, plaPreheatHPBTemp, plaPreheatFanSpeed,
absPreheatHotendTemp, absPreheatHPBTemp, absPreheatFanSpeed;
#endif
EEPROM_READ_VAR(i, plaPreheatHotendTemp);
EEPROM_READ_VAR(i, plaPreheatHPBTemp);
EEPROM_READ_VAR(i, plaPreheatFanSpeed);
EEPROM_READ_VAR(i, absPreheatHotendTemp);
EEPROM_READ_VAR(i, absPreheatHPBTemp);
EEPROM_READ_VAR(i, absPreheatFanSpeed);
EEPROM_READ_VAR(i, zprobe_zoffset);
#ifdef PIDTEMP
for (int e = 0; e < 4; e++) { // 4 = max extruders currently supported by Marlin
EEPROM_READ_VAR(i, dummy);
if (e < EXTRUDERS && 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_VAR(i, PID_PARAM(Ki, e));
EEPROM_READ_VAR(i, PID_PARAM(Kd, e));
#ifdef PID_ADD_EXTRUSION_RATE
EEPROM_READ_VAR(i, PID_PARAM(Kc, e));
#else
EEPROM_READ_VAR(i, dummy);
#endif
}
else {
for (int q=3; q--;) EEPROM_READ_VAR(i, dummy);
}
}
#else // !PIDTEMP
// 4 x 3 = 12 slots for PID parameters
for (int q=12; q--;) EEPROM_READ_VAR(i, dummy);
#endif // !PIDTEMP
#ifndef DOGLCD
int lcd_contrast;
#endif
EEPROM_READ_VAR(i, lcd_contrast);
#ifdef SCARA
EEPROM_READ_VAR(i, axis_scaling); // 3 floats
#else
EEPROM_READ_VAR(i, dummy);
#endif
#ifdef FWRETRACT
EEPROM_READ_VAR(i, autoretract_enabled);
EEPROM_READ_VAR(i, retract_length);
#if EXTRUDERS > 1
EEPROM_READ_VAR(i, retract_length_swap);
#else
EEPROM_READ_VAR(i, dummy);
#endif
EEPROM_READ_VAR(i, retract_feedrate);
EEPROM_READ_VAR(i, retract_zlift);
EEPROM_READ_VAR(i, retract_recover_length);
#if EXTRUDERS > 1
EEPROM_READ_VAR(i, retract_recover_length_swap);
#else
EEPROM_READ_VAR(i, dummy);
#endif
EEPROM_READ_VAR(i, retract_recover_feedrate);
#endif // FWRETRACT
EEPROM_READ_VAR(i, volumetric_enabled);
for (int q = 0; q < 4; q++) {
EEPROM_READ_VAR(i, dummy);
if (q < EXTRUDERS) filament_size[q] = dummy;
}
calculate_volumetric_multipliers();
// Call updatePID (similar to when we have processed M301)
updatePID();
// Report settings retrieved and length
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHO(ver);
SERIAL_ECHOPAIR(" stored settings retrieved (", (unsigned long)i);
SERIAL_ECHOLNPGM(" bytes)");
}
#ifdef EEPROM_CHITCHAT
Config_PrintSettings();
#endif
}
#endif // EEPROM_SETTINGS
void Config_ResetDefault() {
float tmp1[] = DEFAULT_AXIS_STEPS_PER_UNIT;
float tmp2[] = DEFAULT_MAX_FEEDRATE;
long tmp3[] = DEFAULT_MAX_ACCELERATION;
for (int i = 0; i < NUM_AXIS; i++) {
axis_steps_per_unit[i] = tmp1[i];
max_feedrate[i] = tmp2[i];
max_acceleration_units_per_sq_second[i] = tmp3[i];
#ifdef SCARA
if (i < sizeof(axis_scaling) / sizeof(*axis_scaling))
axis_scaling[i] = 1;
#endif
}
// steps per sq second need to be updated to agree with the units per sq second
reset_acceleration_rates();
acceleration = DEFAULT_ACCELERATION;
retract_acceleration = DEFAULT_RETRACT_ACCELERATION;
minimumfeedrate = DEFAULT_MINIMUMFEEDRATE;
minsegmenttime = DEFAULT_MINSEGMENTTIME;
mintravelfeedrate = DEFAULT_MINTRAVELFEEDRATE;
max_xy_jerk = DEFAULT_XYJERK;
max_z_jerk = DEFAULT_ZJERK;
max_e_jerk = DEFAULT_EJERK;
add_homing[X_AXIS] = add_homing[Y_AXIS] = add_homing[Z_AXIS] = 0;
#ifdef DELTA
endstop_adj[X_AXIS] = endstop_adj[Y_AXIS] = endstop_adj[Z_AXIS] = 0;
delta_radius = DELTA_RADIUS;
delta_diagonal_rod = DELTA_DIAGONAL_ROD;
delta_segments_per_second = DELTA_SEGMENTS_PER_SECOND;
recalc_delta_settings(delta_radius, delta_diagonal_rod);
#endif
#ifdef ULTIPANEL
plaPreheatHotendTemp = PLA_PREHEAT_HOTEND_TEMP;
plaPreheatHPBTemp = PLA_PREHEAT_HPB_TEMP;
plaPreheatFanSpeed = PLA_PREHEAT_FAN_SPEED;
absPreheatHotendTemp = ABS_PREHEAT_HOTEND_TEMP;
absPreheatHPBTemp = ABS_PREHEAT_HPB_TEMP;
absPreheatFanSpeed = ABS_PREHEAT_FAN_SPEED;
#endif
#ifdef ENABLE_AUTO_BED_LEVELING
zprobe_zoffset = -Z_PROBE_OFFSET_FROM_EXTRUDER;
#endif
#ifdef DOGLCD
lcd_contrast = DEFAULT_LCD_CONTRAST;
#endif
#ifdef PIDTEMP
#ifdef PID_PARAMS_PER_EXTRUDER
for (int e = 0; e < EXTRUDERS; e++)
#else
int e = 0; // only need to write once
#endif
{
PID_PARAM(Kp, e) = DEFAULT_Kp;
PID_PARAM(Ki, e) = scalePID_i(DEFAULT_Ki);
PID_PARAM(Kd, e) = scalePID_d(DEFAULT_Kd);
#ifdef PID_ADD_EXTRUSION_RATE
PID_PARAM(Kc, e) = DEFAULT_Kc;
#endif
}
// call updatePID (similar to when we have processed M301)
updatePID();
#endif // PIDTEMP
#ifdef FWRETRACT
autoretract_enabled = false;
retract_length = RETRACT_LENGTH;
#if EXTRUDERS > 1
retract_length_swap = RETRACT_LENGTH_SWAP;
#endif
retract_feedrate = RETRACT_FEEDRATE;
retract_zlift = RETRACT_ZLIFT;
retract_recover_length = RETRACT_RECOVER_LENGTH;
#if EXTRUDERS > 1
retract_recover_length_swap = RETRACT_RECOVER_LENGTH_SWAP;
#endif
retract_recover_feedrate = RETRACT_RECOVER_FEEDRATE;
#endif
volumetric_enabled = false;
filament_size[0] = DEFAULT_NOMINAL_FILAMENT_DIA;
#if EXTRUDERS > 1
filament_size[1] = DEFAULT_NOMINAL_FILAMENT_DIA;
#if EXTRUDERS > 2
filament_size[2] = DEFAULT_NOMINAL_FILAMENT_DIA;
#if EXTRUDERS > 3
filament_size[3] = DEFAULT_NOMINAL_FILAMENT_DIA;
#endif
#endif
#endif
calculate_volumetric_multipliers();
SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("Hardcoded Default Settings Loaded");
}
#ifndef DISABLE_M503
void Config_PrintSettings(bool forReplay) {
// Always have this function, even with EEPROM_SETTINGS disabled, the current values will be shown
SERIAL_ECHO_START;
if (!forReplay) {
SERIAL_ECHOLNPGM("Steps per unit:"); SERIAL_ECHOLNPGM("Steps per unit:");
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" M92 X",axis_steps_per_unit[X_AXIS]); }
SERIAL_ECHOPAIR(" Y",axis_steps_per_unit[Y_AXIS]); SERIAL_ECHOPAIR(" M92 X", axis_steps_per_unit[X_AXIS]);
SERIAL_ECHOPAIR(" Z",axis_steps_per_unit[Z_AXIS]); SERIAL_ECHOPAIR(" Y", axis_steps_per_unit[Y_AXIS]);
SERIAL_ECHOPAIR(" E",axis_steps_per_unit[E_AXIS]); SERIAL_ECHOPAIR(" Z", axis_steps_per_unit[Z_AXIS]);
SERIAL_ECHOLN(""); SERIAL_ECHOPAIR(" E", axis_steps_per_unit[E_AXIS]);
SERIAL_ECHOLN("");
SERIAL_ECHO_START;
#ifdef SCARA SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("Scaling factors:");
SERIAL_ECHO_START; #ifdef SCARA
SERIAL_ECHOPAIR(" M365 X",axis_scaling[X_AXIS]); if (!forReplay) {
SERIAL_ECHOPAIR(" Y",axis_scaling[Y_AXIS]); SERIAL_ECHOLNPGM("Scaling factors:");
SERIAL_ECHOPAIR(" Z",axis_scaling[Z_AXIS]); SERIAL_ECHO_START;
}
SERIAL_ECHOPAIR(" M365 X", axis_scaling[X_AXIS]);
SERIAL_ECHOPAIR(" Y", axis_scaling[Y_AXIS]);
SERIAL_ECHOPAIR(" Z", axis_scaling[Z_AXIS]);
SERIAL_ECHOLN(""); SERIAL_ECHOLN("");
SERIAL_ECHO_START; SERIAL_ECHO_START;
#endif//SCARA #endif // SCARA
if (!forReplay) {
SERIAL_ECHOLNPGM("Maximum feedrates (mm/s):"); SERIAL_ECHOLNPGM("Maximum feedrates (mm/s):");
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" M203 X", max_feedrate[X_AXIS]); }
SERIAL_ECHOPAIR(" Y", max_feedrate[Y_AXIS]); SERIAL_ECHOPAIR(" M203 X", max_feedrate[X_AXIS]);
SERIAL_ECHOPAIR(" Z", max_feedrate[Z_AXIS]); SERIAL_ECHOPAIR(" Y", max_feedrate[Y_AXIS]);
SERIAL_ECHOPAIR(" E", max_feedrate[E_AXIS]); SERIAL_ECHOPAIR(" Z", max_feedrate[Z_AXIS]);
SERIAL_ECHOLN(""); SERIAL_ECHOPAIR(" E", max_feedrate[E_AXIS]);
SERIAL_ECHOLN("");
SERIAL_ECHO_START; SERIAL_ECHO_START;
if (!forReplay) {
SERIAL_ECHOLNPGM("Maximum Acceleration (mm/s2):"); SERIAL_ECHOLNPGM("Maximum Acceleration (mm/s2):");
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" M201 X" ,max_acceleration_units_per_sq_second[X_AXIS] ); }
SERIAL_ECHOPAIR(" Y" , max_acceleration_units_per_sq_second[Y_AXIS] ); SERIAL_ECHOPAIR(" M201 X", max_acceleration_units_per_sq_second[X_AXIS] );
SERIAL_ECHOPAIR(" Z" ,max_acceleration_units_per_sq_second[Z_AXIS] ); SERIAL_ECHOPAIR(" Y", max_acceleration_units_per_sq_second[Y_AXIS] );
SERIAL_ECHOPAIR(" E" ,max_acceleration_units_per_sq_second[E_AXIS]); SERIAL_ECHOPAIR(" Z", max_acceleration_units_per_sq_second[Z_AXIS] );
SERIAL_ECHOLN(""); SERIAL_ECHOPAIR(" E", max_acceleration_units_per_sq_second[E_AXIS]);
SERIAL_ECHO_START; SERIAL_ECHOLN("");
SERIAL_ECHO_START;
if (!forReplay) {
SERIAL_ECHOLNPGM("Acceleration: S=acceleration, T=retract acceleration"); SERIAL_ECHOLNPGM("Acceleration: S=acceleration, T=retract acceleration");
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" M204 S",acceleration ); }
SERIAL_ECHOPAIR(" T" ,retract_acceleration); SERIAL_ECHOPAIR(" M204 S", acceleration );
SERIAL_ECHOLN(""); SERIAL_ECHOPAIR(" T", retract_acceleration);
SERIAL_ECHOLN("");
SERIAL_ECHO_START; SERIAL_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)"); 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)");
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" M205 S",minimumfeedrate ); }
SERIAL_ECHOPAIR(" T" ,mintravelfeedrate ); SERIAL_ECHOPAIR(" M205 S", minimumfeedrate );
SERIAL_ECHOPAIR(" B" ,minsegmenttime ); SERIAL_ECHOPAIR(" T", mintravelfeedrate );
SERIAL_ECHOPAIR(" X" ,max_xy_jerk ); SERIAL_ECHOPAIR(" B", minsegmenttime );
SERIAL_ECHOPAIR(" Z" ,max_z_jerk); SERIAL_ECHOPAIR(" X", max_xy_jerk );
SERIAL_ECHOPAIR(" E" ,max_e_jerk); SERIAL_ECHOPAIR(" Z", max_z_jerk);
SERIAL_ECHOLN(""); SERIAL_ECHOPAIR(" E", max_e_jerk);
SERIAL_ECHOLN("");
SERIAL_ECHO_START; SERIAL_ECHO_START;
if (!forReplay) {
SERIAL_ECHOLNPGM("Home offset (mm):"); SERIAL_ECHOLNPGM("Home offset (mm):");
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" M206 X",add_homing[X_AXIS] ); }
SERIAL_ECHOPAIR(" Y" ,add_homing[Y_AXIS] ); SERIAL_ECHOPAIR(" M206 X", add_homing[X_AXIS] );
SERIAL_ECHOPAIR(" Z" ,add_homing[Z_AXIS] ); SERIAL_ECHOPAIR(" Y", add_homing[Y_AXIS] );
SERIAL_ECHOLN(""); SERIAL_ECHOPAIR(" Z", add_homing[Z_AXIS] );
#ifdef DELTA SERIAL_ECHOLN("");
SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("Endstop adjustement (mm):"); #ifdef DELTA
SERIAL_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_ECHOLN("");
SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("Delta settings: L=delta_diagonal_rod, R=delta_radius, S=delta_segments_per_second");
SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" M665 L",delta_diagonal_rod );
SERIAL_ECHOPAIR(" R" ,delta_radius );
SERIAL_ECHOPAIR(" S" ,delta_segments_per_second );
SERIAL_ECHOLN("");
#endif//DELTA
#ifdef PIDTEMP
SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("PID settings:");
SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" M301 P", PID_PARAM(Kp,0)); // for compatibility with hosts, only echos values for E0
SERIAL_ECHOPAIR(" I", unscalePID_i(PID_PARAM(Ki, 0)));
SERIAL_ECHOPAIR(" D", unscalePID_d(PID_PARAM(Kd, 0)));
SERIAL_ECHOLN("");
#endif//PIDTEMP
#ifdef FWRETRACT
SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("Retract: S=Length (mm) F:Speed (mm/m) Z: ZLift (mm)");
SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" M207 S",retract_length);
SERIAL_ECHOPAIR(" F" ,retract_feedrate*60);
SERIAL_ECHOPAIR(" Z" ,retract_zlift);
SERIAL_ECHOLN("");
SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("Recover: S=Extra length (mm) F:Speed (mm/m)");
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" M208 S",retract_recover_length); if (!forReplay) {
SERIAL_ECHOPAIR(" F", retract_recover_feedrate*60); SERIAL_ECHOLNPGM("Endstop adjustement (mm):");
SERIAL_ECHOLN(""); SERIAL_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_ECHOLN("");
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("Auto-Retract: S=0 to disable, 1 to interpret extrude-only moves as retracts or recoveries"); SERIAL_ECHOLNPGM("Delta settings: L=delta_diagonal_rod, R=delta_radius, S=delta_segments_per_second");
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" M209 S", (unsigned long)(autoretract_enabled ? 1 : 0)); SERIAL_ECHOPAIR(" M665 L", delta_diagonal_rod );
SERIAL_ECHOPAIR(" R", delta_radius );
SERIAL_ECHOPAIR(" S", delta_segments_per_second );
SERIAL_ECHOLN(""); SERIAL_ECHOLN("");
#if EXTRUDERS > 1 #endif // DELTA
#ifdef PIDTEMP
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("Multi-extruder settings:"); if (!forReplay) {
SERIAL_ECHOLNPGM("PID settings:");
SERIAL_ECHO_START;
}
SERIAL_ECHOPAIR(" M301 P", PID_PARAM(Kp, 0)); // for compatibility with hosts, only echos values for E0
SERIAL_ECHOPAIR(" I", unscalePID_i(PID_PARAM(Ki, 0)));
SERIAL_ECHOPAIR(" D", unscalePID_d(PID_PARAM(Kd, 0)));
SERIAL_ECHOLN("");
#endif // PIDTEMP
#ifdef FWRETRACT
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" Swap retract length (mm): ", retract_length_swap); if (!forReplay) {
SERIAL_ECHOLNPGM("Retract: S=Length (mm) F:Speed (mm/m) Z: ZLift (mm)");
SERIAL_ECHO_START;
}
SERIAL_ECHOPAIR(" M207 S", retract_length);
SERIAL_ECHOPAIR(" F", retract_feedrate*60);
SERIAL_ECHOPAIR(" Z", retract_zlift);
SERIAL_ECHOLN(""); SERIAL_ECHOLN("");
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" Swap rec. addl. length (mm): ", retract_recover_length_swap); if (!forReplay) {
SERIAL_ECHOLNPGM("Recover: S=Extra length (mm) F:Speed (mm/m)");
SERIAL_ECHO_START;
}
SERIAL_ECHOPAIR(" M208 S", retract_recover_length);
SERIAL_ECHOPAIR(" F", retract_recover_feedrate*60);
SERIAL_ECHOLN(""); SERIAL_ECHOLN("");
#endif//EXTRUDERS > 1
#endif//FWRETRACT
SERIAL_ECHO_START; SERIAL_ECHO_START;
if (volumetric_enabled) { if (!forReplay) {
SERIAL_ECHOLNPGM("Filament settings:"); SERIAL_ECHOLNPGM("Auto-Retract: S=0 to disable, 1 to interpret extrude-only moves as retracts or recoveries");
SERIAL_ECHO_START;
}
SERIAL_ECHOPAIR(" M209 S", (unsigned long)(autoretract_enabled ? 1 : 0));
SERIAL_ECHOLN("");
#if EXTRUDERS > 1
if (!forReplay) {
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" M200 D", filament_size[0]); SERIAL_ECHOLNPGM("Multi-extruder settings:");
SERIAL_ECHOLN("");
#if EXTRUDERS > 1
SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" M200 T1 D", filament_size[1]);
SERIAL_ECHOLN("");
#if EXTRUDERS > 2
SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" M200 T2 D", filament_size[2]);
SERIAL_ECHOLN("");
#if EXTRUDERS > 3
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" M200 T3 D", filament_size[3]); SERIAL_ECHOPAIR(" Swap retract length (mm): ", retract_length_swap);
SERIAL_ECHOLN(""); SERIAL_ECHOLN("");
#endif //EXTRUDERS > 3 SERIAL_ECHO_START;
#endif //EXTRUDERS > 2 SERIAL_ECHOPAIR(" Swap rec. addl. length (mm): ", retract_recover_length_swap);
#endif //EXTRUDERS > 1 SERIAL_ECHOLN("");
} else { }
SERIAL_ECHOLNPGM("Filament settings: Disabled"); #endif // EXTRUDERS > 1
}
#ifdef CUSTOM_M_CODES
SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("Z-Probe Offset (mm):");
SERIAL_ECHO_START;
SERIAL_ECHO(" M");
SERIAL_ECHO(CUSTOM_M_CODE_SET_Z_PROBE_OFFSET);
SERIAL_ECHOPAIR(" Z",-zprobe_zoffset);
SERIAL_ECHOLN("");
#endif
}
#endif//DISABLE_M503
#endif // FWRETRACT
#ifdef EEPROM_SETTINGS SERIAL_ECHO_START;
void Config_RetrieveSettings() if (volumetric_enabled) {
{ if (!forReplay) {
int i=EEPROM_OFFSET; SERIAL_ECHOLNPGM("Filament settings:");
char stored_ver[4]; SERIAL_ECHO_START;
char ver[4]=EEPROM_VERSION; }
EEPROM_READ_VAR(i,stored_ver); //read stored version SERIAL_ECHOPAIR(" M200 D", filament_size[0]);
// SERIAL_ECHOLN("Version: [" << ver << "] Stored version: [" << stored_ver << "]"); SERIAL_ECHOLN("");
if (strncmp(ver,stored_ver,3) == 0)
{ #if EXTRUDERS > 1
// version number match SERIAL_ECHO_START;
EEPROM_READ_VAR(i,axis_steps_per_unit); SERIAL_ECHOPAIR(" M200 T1 D", filament_size[1]);
EEPROM_READ_VAR(i,max_feedrate); SERIAL_ECHOLN("");
EEPROM_READ_VAR(i,max_acceleration_units_per_sq_second); #if EXTRUDERS > 2
// steps per sq second need to be updated to agree with the units per sq second (as they are what is used in the planner)
reset_acceleration_rates();
EEPROM_READ_VAR(i,acceleration);
EEPROM_READ_VAR(i,retract_acceleration);
EEPROM_READ_VAR(i,minimumfeedrate);
EEPROM_READ_VAR(i,mintravelfeedrate);
EEPROM_READ_VAR(i,minsegmenttime);
EEPROM_READ_VAR(i,max_xy_jerk);
EEPROM_READ_VAR(i,max_z_jerk);
EEPROM_READ_VAR(i,max_e_jerk);
EEPROM_READ_VAR(i,add_homing);
#ifdef DELTA
EEPROM_READ_VAR(i,endstop_adj);
EEPROM_READ_VAR(i,delta_radius);
EEPROM_READ_VAR(i,delta_diagonal_rod);
EEPROM_READ_VAR(i,delta_segments_per_second);
#endif//DELTA
#ifndef ULTIPANEL
int plaPreheatHotendTemp, plaPreheatHPBTemp, plaPreheatFanSpeed;
int absPreheatHotendTemp, absPreheatHPBTemp, absPreheatFanSpeed;
#endif//ULTIPANEL
EEPROM_READ_VAR(i,plaPreheatHotendTemp);
EEPROM_READ_VAR(i,plaPreheatHPBTemp);
EEPROM_READ_VAR(i,plaPreheatFanSpeed);
EEPROM_READ_VAR(i,absPreheatHotendTemp);
EEPROM_READ_VAR(i,absPreheatHPBTemp);
EEPROM_READ_VAR(i,absPreheatFanSpeed);
EEPROM_READ_VAR(i,zprobe_zoffset);
#ifdef PIDTEMP
float dummy = 0.0f;
for (int e = 0; e < 4; e++) // 4 = max extruders supported by marlin
{
if (e < EXTRUDERS)
{
// do not need to scale PID values as the values in EEPROM are already scaled
EEPROM_READ_VAR(i,PID_PARAM(Kp,e));
EEPROM_READ_VAR(i,PID_PARAM(Ki,e));
EEPROM_READ_VAR(i,PID_PARAM(Kd,e));
#ifdef PID_ADD_EXTRUSION_RATE
EEPROM_READ_VAR(i,PID_PARAM(Kc,e));
#else//PID_ADD_EXTRUSION_RATE
EEPROM_READ_VAR(i,dummy);
#endif//PID_ADD_EXTRUSION_RATE
}
else
{
EEPROM_READ_VAR(i,dummy);
EEPROM_READ_VAR(i,dummy);
EEPROM_READ_VAR(i,dummy);
EEPROM_READ_VAR(i,dummy);
}
}
#else//PIDTEMP
// 4 x 3 = 12 slots for PID parameters
float dummy = 0.0f;
EEPROM_READ_VAR(i,dummy);
EEPROM_READ_VAR(i,dummy);
EEPROM_READ_VAR(i,dummy);
EEPROM_READ_VAR(i,dummy);
EEPROM_READ_VAR(i,dummy);
EEPROM_READ_VAR(i,dummy);
EEPROM_READ_VAR(i,dummy);
EEPROM_READ_VAR(i,dummy);
EEPROM_READ_VAR(i,dummy);
EEPROM_READ_VAR(i,dummy);
EEPROM_READ_VAR(i,dummy);
EEPROM_READ_VAR(i,dummy);
#endif//PIDTEMP
#ifndef DOGLCD
int lcd_contrast;
#endif//DOGLCD
EEPROM_READ_VAR(i,lcd_contrast);
#ifdef SCARA
EEPROM_READ_VAR(i,axis_scaling);
#endif//SCARA
#ifdef FWRETRACT
EEPROM_READ_VAR(i,autoretract_enabled);
EEPROM_READ_VAR(i,retract_length);
#if EXTRUDERS > 1
EEPROM_READ_VAR(i,retract_length_swap);
#endif//EXTRUDERS > 1
EEPROM_READ_VAR(i,retract_feedrate);
EEPROM_READ_VAR(i,retract_zlift);
EEPROM_READ_VAR(i,retract_recover_length);
#if EXTRUDERS > 1
EEPROM_READ_VAR(i,retract_recover_length_swap);
#endif//EXTRUDERS > 1
EEPROM_READ_VAR(i,retract_recover_feedrate);
#endif//FWRETRACT
EEPROM_READ_VAR(i, volumetric_enabled);
EEPROM_READ_VAR(i, filament_size[0]);
#if EXTRUDERS > 1
EEPROM_READ_VAR(i, filament_size[1]);
#if EXTRUDERS > 2
EEPROM_READ_VAR(i, filament_size[2]);
#if EXTRUDERS > 3
EEPROM_READ_VAR(i, filament_size[3]);
#endif //EXTRUDERS > 3
#endif //EXTRUDERS > 2
#endif //EXTRUDERS > 1
calculate_volumetric_multipliers();
// Call updatePID (similar to when we have processed M301)
updatePID();
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("Stored settings retrieved"); SERIAL_ECHOPAIR(" M200 T2 D", filament_size[2]);
SERIAL_ECHOLN("");
#if EXTRUDERS > 3
SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" M200 T3 D", filament_size[3]);
SERIAL_ECHOLN("");
#endif
#endif
#endif
} else {
if (!forReplay) {
SERIAL_ECHOLNPGM("Filament settings: Disabled");
} }
else }
{
Config_ResetDefault(); #ifdef CUSTOM_M_CODES
SERIAL_ECHO_START;
if (!forReplay) {
SERIAL_ECHOLNPGM("Z-Probe Offset (mm):");
SERIAL_ECHO_START;
} }
#ifdef EEPROM_CHITCHAT SERIAL_ECHO(" M");
Config_PrintSettings(); SERIAL_ECHO(CUSTOM_M_CODE_SET_Z_PROBE_OFFSET);
#endif//EEPROM_CHITCHAT SERIAL_ECHOPAIR(" Z", -zprobe_zoffset);
SERIAL_ECHOLN("");
#endif
} }
#endif//EEPROM_SETTINGS
void Config_ResetDefault()
{
float tmp1[]=DEFAULT_AXIS_STEPS_PER_UNIT;
float tmp2[]=DEFAULT_MAX_FEEDRATE;
long tmp3[]=DEFAULT_MAX_ACCELERATION;
for (short i=0;i<4;i++)
{
axis_steps_per_unit[i]=tmp1[i];
max_feedrate[i]=tmp2[i];
max_acceleration_units_per_sq_second[i]=tmp3[i];
#ifdef SCARA
axis_scaling[i]=1;
#endif//SCARA
}
// steps per sq second need to be updated to agree with the units per sq second
reset_acceleration_rates();
acceleration=DEFAULT_ACCELERATION;
retract_acceleration=DEFAULT_RETRACT_ACCELERATION;
minimumfeedrate=DEFAULT_MINIMUMFEEDRATE;
minsegmenttime=DEFAULT_MINSEGMENTTIME;
mintravelfeedrate=DEFAULT_MINTRAVELFEEDRATE;
max_xy_jerk=DEFAULT_XYJERK;
max_z_jerk=DEFAULT_ZJERK;
max_e_jerk=DEFAULT_EJERK;
add_homing[X_AXIS] = add_homing[Y_AXIS] = add_homing[Z_AXIS] = 0;
#ifdef DELTA
endstop_adj[X_AXIS] = endstop_adj[Y_AXIS] = endstop_adj[Z_AXIS] = 0;
delta_radius= DELTA_RADIUS;
delta_diagonal_rod= DELTA_DIAGONAL_ROD;
delta_segments_per_second= DELTA_SEGMENTS_PER_SECOND;
recalc_delta_settings(delta_radius, delta_diagonal_rod);
#endif//DELTA
#ifdef ULTIPANEL
plaPreheatHotendTemp = PLA_PREHEAT_HOTEND_TEMP;
plaPreheatHPBTemp = PLA_PREHEAT_HPB_TEMP;
plaPreheatFanSpeed = PLA_PREHEAT_FAN_SPEED;
absPreheatHotendTemp = ABS_PREHEAT_HOTEND_TEMP;
absPreheatHPBTemp = ABS_PREHEAT_HPB_TEMP;
absPreheatFanSpeed = ABS_PREHEAT_FAN_SPEED;
#endif//ULTIPANEL
#ifdef ENABLE_AUTO_BED_LEVELING
zprobe_zoffset = -Z_PROBE_OFFSET_FROM_EXTRUDER;
#endif//ENABLE_AUTO_BED_LEVELING
#ifdef DOGLCD
lcd_contrast = DEFAULT_LCD_CONTRAST;
#endif//DOGLCD
#ifdef PIDTEMP
#ifdef PID_PARAMS_PER_EXTRUDER
for (int e = 0; e < EXTRUDERS; e++)
#else // PID_PARAMS_PER_EXTRUDER
int e = 0; // only need to write once
#endif // PID_PARAMS_PER_EXTRUDER
{
PID_PARAM(Kp,e) = DEFAULT_Kp;
PID_PARAM(Ki,e) = scalePID_i(DEFAULT_Ki);
PID_PARAM(Kd,e) = scalePID_d(DEFAULT_Kd);
#ifdef PID_ADD_EXTRUSION_RATE
PID_PARAM(Kc,e) = DEFAULT_Kc;
#endif//PID_ADD_EXTRUSION_RATE
}
// call updatePID (similar to when we have processed M301)
updatePID();
#endif//PIDTEMP
#ifdef FWRETRACT
autoretract_enabled = false;
retract_length = RETRACT_LENGTH;
#if EXTRUDERS > 1
retract_length_swap = RETRACT_LENGTH_SWAP;
#endif//EXTRUDERS > 1
retract_feedrate = RETRACT_FEEDRATE;
retract_zlift = RETRACT_ZLIFT;
retract_recover_length = RETRACT_RECOVER_LENGTH;
#if EXTRUDERS > 1
retract_recover_length_swap = RETRACT_RECOVER_LENGTH_SWAP;
#endif//EXTRUDERS > 1
retract_recover_feedrate = RETRACT_RECOVER_FEEDRATE;
#endif//FWRETRACT
volumetric_enabled = false;
filament_size[0] = DEFAULT_NOMINAL_FILAMENT_DIA;
#if EXTRUDERS > 1
filament_size[1] = DEFAULT_NOMINAL_FILAMENT_DIA;
#if EXTRUDERS > 2
filament_size[2] = DEFAULT_NOMINAL_FILAMENT_DIA;
#if EXTRUDERS > 3
filament_size[3] = DEFAULT_NOMINAL_FILAMENT_DIA;
#endif //EXTRUDERS > 3
#endif //EXTRUDERS > 2
#endif //EXTRUDERS > 1
calculate_volumetric_multipliers();
SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("Hardcoded Default Settings Loaded");
} #endif // !DISABLE_M503

14
Marlin/ConfigurationStore.h
Unescape View File

@ -6,17 +6,17 @@
void Config_ResetDefault(); void Config_ResetDefault();
#ifndef DISABLE_M503 #ifndef DISABLE_M503
void Config_PrintSettings(); void Config_PrintSettings(bool forReplay=false);
#else #else
FORCE_INLINE void Config_PrintSettings() {} FORCE_INLINE void Config_PrintSettings(bool forReplay=false) {}
#endif #endif
#ifdef EEPROM_SETTINGS #ifdef EEPROM_SETTINGS
void Config_StoreSettings(); void Config_StoreSettings();
void Config_RetrieveSettings(); void Config_RetrieveSettings();
#else #else
FORCE_INLINE void Config_StoreSettings() {} FORCE_INLINE void Config_StoreSettings() {}
FORCE_INLINE void Config_RetrieveSettings() { Config_ResetDefault(); Config_PrintSettings(); } FORCE_INLINE void Config_RetrieveSettings() { Config_ResetDefault(); Config_PrintSettings(); }
#endif #endif
#endif//CONFIG_STORE_H #endif // __CONFIG_STORE_H

4
Marlin/Marlin_main.cpp
Unescape View File

@ -164,7 +164,7 @@
// M500 - stores parameters in EEPROM // M500 - stores parameters in EEPROM
// M501 - reads parameters from EEPROM (if you need reset them after you changed them temporarily). // M501 - reads parameters from EEPROM (if you need reset them after you changed them temporarily).
// M502 - reverts to the default "factory settings". You still need to store them in EEPROM afterwards if you want to. // M502 - reverts to the default "factory settings". You still need to store them in EEPROM afterwards if you want to.
// M503 - print the current settings (from memory not from EEPROM) // M503 - print the current settings (from memory not from EEPROM). Use S0 to leave off headings.
// M540 - Use S[0|1] to enable or disable the stop SD card print on endstop hit (requires ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED) // M540 - Use S[0|1] to enable or disable the stop SD card print on endstop hit (requires ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED)
// M600 - Pause for filament change X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal] // M600 - Pause for filament change X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
// M665 - set delta configurations // M665 - set delta configurations
@ -3581,7 +3581,7 @@ case 404: //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or disp
break; break;
case 503: // M503 print settings currently in memory case 503: // M503 print settings currently in memory
{ {
Config_PrintSettings(); Config_PrintSettings(code_seen('S') && code_value == 0);
} }
break; break;
#ifdef ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED #ifdef ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED

Write Preview
Loading…
Cancel
Save