/**
* M502 - Reset Configuration
*/
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];
}
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_homeing[0] = add_homeing[1] = add_homeing[2] = 0;
#ifdef ULTIPANEL
#ifdef PRINT_PLA
plaPreheatHotendTemp = PLA_PREHEAT_HOTEND_TEMP;
plaPreheatHPBTemp = PLA_PREHEAT_HPB_TEMP;
plaPreheatFanSpeed = PLA_PREHEAT_FAN_SPEED;
#endif
#ifdef PRINT_ABS
absPreheatHotendTemp = ABS_PREHEAT_HOTEND_TEMP;
absPreheatHPBTemp = ABS_PREHEAT_HPB_TEMP;
absPreheatFanSpeed = ABS_PREHEAT_FAN_SPEED;
#endif
#endif
#ifdef DOGLCD
lcd_contrast = DEFAULT_LCD_CONTRAST;
#endif
#ifdef PIDTEMP
Kp = DEFAULT_Kp;
Ki = scalePID_i(DEFAULT_Ki);
Kd = scalePID_d(DEFAULT_Kd);
#ifdef PID_ADD_EXTRUSION_RATE
Kc = DEFAULT_Kc;
#endif // PID_ADD_EXTRUSION_RATE
#endif // PIDTEMP
#if HAS_BED_PROBE
zprobe_zoffset = Z_PROBE_OFFSET_FROM_EXTRUDER;
#endif
Config_Postprocess();
SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("Hardcoded Default Settings Loaded");
}
/**
* M502 - Reset Configuration
*/
void Config_ResetDefault() {
float tmp1[] = DEFAULT_AXIS_STEPS_PER_UNIT;
float tmp2[] = DEFAULT_MAX_FEEDRATE;
float tmp3[] = DEFAULT_MAX_ACCELERATION;
float tmp4[] = DEFAULT_RETRACT_ACCELERATION;
float tmp5[] = DEFAULT_EJERK;
float tmp6[] = DEFAULT_Kp;
float tmp7[] = DEFAULT_Ki;
float tmp8[] = DEFAULT_Kd;
float tmp9[] = DEFAULT_Kc;
#if ENABLED(HOTEND_OFFSET_X) && ENABLED(HOTEND_OFFSET_Y) && ENABLED(HOTEND_OFFSET_Z)
float tmp10[] = HOTEND_OFFSET_X;
float tmp11[] = HOTEND_OFFSET_Y;
float tmp12[] = HOTEND_OFFSET_Z;
#endif
#if MB(ALLIGATOR)
float tmp13[] = MOTOR_CURRENT;
for (int8_t i = 0; i < 3 + DRIVER_EXTRUDERS; i++)
motor_current[i] = tmp13[i];
#endif
for (int8_t i = 0; i < 3 + EXTRUDERS; i++) {
planner.axis_steps_per_mm[i] = tmp1[i];
planner.max_feedrate[i] = tmp2[i];
planner.max_acceleration_mm_per_s2[i] = tmp3[i];
}
for (int8_t i = 0; i < EXTRUDERS; i++) {
planner.retract_acceleration[i] = tmp4[i];
planner.max_e_jerk[i] = tmp5[i];
}
for (int8_t i = 0; i < HOTENDS; i++) {
#if ENABLED(HOTEND_OFFSET_X) && ENABLED(HOTEND_OFFSET_Y) && ENABLED(HOTEND_OFFSET_Z)
hotend_offset[X_AXIS][i] = tmp10[i];
hotend_offset[Y_AXIS][i] = tmp11[i];
hotend_offset[Z_AXIS][i] = tmp12[i];
#else
hotend_offset[X_AXIS][i] = 0;
hotend_offset[Y_AXIS][i] = 0;
hotend_offset[Z_AXIS][i] = 0;
#endif
}
#if MECH(SCARA)
for (int8_t i = 0; i < NUM_AXIS; i++) {
if (i < COUNT(axis_scaling))
axis_scaling[i] = 1;
}
#endif
// steps per sq second need to be updated to agree with the units per sq second
planner.reset_acceleration_rates();
planner.acceleration = DEFAULT_ACCELERATION;
planner.travel_acceleration = DEFAULT_TRAVEL_ACCELERATION;
planner.min_feedrate = DEFAULT_MINIMUMFEEDRATE;
planner.min_segment_time = DEFAULT_MINSEGMENTTIME;
planner.min_travel_feedrate = DEFAULT_MINTRAVELFEEDRATE;
planner.max_xy_jerk = DEFAULT_XYJERK;
planner.max_z_jerk = DEFAULT_ZJERK;
home_offset[X_AXIS] = home_offset[Y_AXIS] = home_offset[Z_AXIS] = 0;
#if ENABLED(MESH_BED_LEVELING)
mbl.reset();
#endif
#if HAS(BED_PROBE)
zprobe_zoffset = Z_PROBE_OFFSET_FROM_NOZZLE;
#endif
#if MECH(DELTA)
delta_radius = DEFAULT_DELTA_RADIUS;
delta_diagonal_rod = DELTA_DIAGONAL_ROD;
endstop_adj[0] = TOWER_A_ENDSTOP_ADJ;
endstop_adj[1] = TOWER_B_ENDSTOP_ADJ;
endstop_adj[2] = TOWER_C_ENDSTOP_ADJ;
tower_adj[0] = TOWER_A_POSITION_ADJ;
tower_adj[1] = TOWER_B_POSITION_ADJ;
tower_adj[2] = TOWER_C_POSITION_ADJ;
tower_adj[3] = TOWER_A_RADIUS_ADJ;
tower_adj[4] = TOWER_B_RADIUS_ADJ;
tower_adj[5] = TOWER_C_RADIUS_ADJ;
diagrod_adj[0] = TOWER_A_DIAGROD_ADJ;
diagrod_adj[1] = TOWER_B_DIAGROD_ADJ;
diagrod_adj[2] = TOWER_C_DIAGROD_ADJ;
#endif
#if ENABLED(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;
gumPreheatHotendTemp = GUM_PREHEAT_HOTEND_TEMP;
gumPreheatHPBTemp = GUM_PREHEAT_HPB_TEMP;
gumPreheatFanSpeed = GUM_PREHEAT_FAN_SPEED;
#endif
#if HAS(LCD_CONTRAST)
lcd_contrast = DEFAULT_LCD_CONTRAST;
#endif
#if ENABLED(PIDTEMP)
for (int8_t h = 0; h < HOTENDS; h++) {
Kp[h] = tmp6[h];
Ki[h] = scalePID_i(tmp7[h]);
Kd[h] = scalePID_d(tmp8[h]);
Kc[h] = tmp9[h];
}
#if ENABLED(PID_ADD_EXTRUSION_RATE)
lpq_len = 20; // default last-position-queue size
#endif
#endif // PIDTEMP
#if ENABLED(PIDTEMPBED)
bedKp = DEFAULT_bedKp;
bedKi = scalePID_i(DEFAULT_bedKi);
bedKd = scalePID_d(DEFAULT_bedKd);
#endif
#if ENABLED(PIDTEMPCHAMBER)
chamberKp = DEFAULT_chamberKp;
chamberKi = scalePID_i(DEFAULT_chamberKi);
chamberKd = scalePID_d(DEFAULT_chamberKd);
#endif
#if ENABLED(PIDTEMPCOOLER)
coolerKp = DEFAULT_coolerKp;
coolerKi = scalePID_i(DEFAULT_coolerKi);
coolerKd = scalePID_d(DEFAULT_coolerKd);
#endif
#if ENABLED(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;
#if ENABLED(IDLE_OOZING_PREVENT)
IDLE_OOZING_enabled = true;
#endif
Config_Postprocess();
ECHO_LM(DB, "Hardcoded Default Settings Loaded");
}
/**
* M501 - Retrieve Configuration
*/
void Config_RetrieveSettings() {
int i = EEPROM_OFFSET;
char stored_ver[6];
uint16_t stored_checksum;
EEPROM_READ_VAR(i, stored_ver);
EEPROM_READ_VAR(i, stored_checksum);
if (DEBUGGING(INFO)) {
ECHO_SMV(INFO, "Version: [", version);
ECHO_MV("] Stored version: [", stored_ver);
ECHO_EM("]");
}
if (strncmp(version, stored_ver, 5) != 0) {
Config_ResetDefault();
}
else {
float dummy = 0;
eeprom_checksum = 0; // clear before reading first "real data"
// version number match
EEPROM_READ_VAR(i, planner.axis_steps_per_mm);
EEPROM_READ_VAR(i, planner.max_feedrate);
EEPROM_READ_VAR(i, planner.max_acceleration_mm_per_s2);
EEPROM_READ_VAR(i, planner.acceleration);
EEPROM_READ_VAR(i, planner.retract_acceleration);
EEPROM_READ_VAR(i, planner.travel_acceleration);
EEPROM_READ_VAR(i, planner.min_feedrate);
EEPROM_READ_VAR(i, planner.min_travel_feedrate);
EEPROM_READ_VAR(i, planner.min_segment_time);
EEPROM_READ_VAR(i, planner.max_xy_jerk);
EEPROM_READ_VAR(i, planner.max_z_jerk);
EEPROM_READ_VAR(i, planner.max_e_jerk);
EEPROM_READ_VAR(i, home_offset);
EEPROM_READ_VAR(i, hotend_offset);
#if ENABLED(MESH_BED_LEVELING)
uint8_t mesh_num_x = 0, mesh_num_y = 0;
EEPROM_READ_VAR(i, mbl.status);
EEPROM_READ_VAR(i, mbl.z_offset);
EEPROM_READ_VAR(i, mesh_num_x);
EEPROM_READ_VAR(i, mesh_num_y);
EEPROM_READ_VAR(i, mbl.z_values);
#endif
#if HEATER_USES_AD595
EEPROM_READ_VAR(i, ad595_offset);
EEPROM_READ_VAR(i, ad595_gain);
for (int8_t h = 0; h < HOTENDS; h++)
if (ad595_gain[h] == 0) ad595_gain[h] == TEMP_SENSOR_AD595_GAIN;
#endif
#if MECH(DELTA)
EEPROM_READ_VAR(i, endstop_adj);
EEPROM_READ_VAR(i, delta_radius);
EEPROM_READ_VAR(i, delta_diagonal_rod);
EEPROM_READ_VAR(i, sw_endstop_max);
EEPROM_READ_VAR(i, tower_adj);
EEPROM_READ_VAR(i, diagrod_adj);
#endif //DELTA
#if HASNT(BED_PROBE)
float zprobe_zoffset = 0;
#endif
EEPROM_READ_VAR(i, zprobe_zoffset);
#if DISABLED(ULTIPANEL)
int plaPreheatHotendTemp, plaPreheatHPBTemp, plaPreheatFanSpeed,
absPreheatHotendTemp, absPreheatHPBTemp, absPreheatFanSpeed,
gumPreheatHotendTemp, gumPreheatHPBTemp, gumPreheatFanSpeed;
#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, gumPreheatHotendTemp);
EEPROM_READ_VAR(i, gumPreheatHPBTemp);
EEPROM_READ_VAR(i, gumPreheatFanSpeed);
#if ENABLED(PIDTEMP)
for (int8_t h = 0; h < HOTENDS; h++) {
EEPROM_READ_VAR(i, PID_PARAM(Kp, h));
EEPROM_READ_VAR(i, PID_PARAM(Ki, h));
EEPROM_READ_VAR(i, PID_PARAM(Kd, h));
EEPROM_READ_VAR(i, PID_PARAM(Kc, h));
}
#endif // PIDTEMP
#if DISABLED(PID_ADD_EXTRUSION_RATE)
int lpq_len;
#endif
EEPROM_READ_VAR(i, lpq_len);
#if ENABLED(PIDTEMPBED)
EEPROM_READ_VAR(i, bedKp);
EEPROM_READ_VAR(i, bedKi);
EEPROM_READ_VAR(i, bedKd);
#endif
#if ENABLED(PIDTEMPCHAMBER)
EEPROM_READ_VAR(i, chamberKp);
EEPROM_READ_VAR(i, chamberKi);
EEPROM_READ_VAR(i, chamberKd);
#endif
#if ENABLED(PIDTEMPCOOLER)
EEPROM_READ_VAR(i, coolerKp);
EEPROM_READ_VAR(i, coolerKi);
EEPROM_READ_VAR(i, coolerKd);
#endif
#if HASNT(LCD_CONTRAST)
int lcd_contrast;
#endif
EEPROM_READ_VAR(i, lcd_contrast);
#if MECH(SCARA)
EEPROM_READ_VAR(i, axis_scaling); // 3 floats
#endif
#if ENABLED(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 (int8_t e = 0; e < EXTRUDERS; e++)
EEPROM_READ_VAR(i, filament_size[e]);
#if ENABLED(IDLE_OOZING_PREVENT)
EEPROM_READ_VAR(i, IDLE_OOZING_enabled);
#endif
#if MB(ALLIGATOR)
EEPROM_READ_VAR(i, motor_current);
#endif
if (eeprom_checksum == stored_checksum) {
Config_Postprocess();
ECHO_SV(DB, version);
ECHO_MV(" stored settings retrieved (", i);
ECHO_EM(" bytes)");
}
else {
ECHO_LM(ER, "EEPROM checksum mismatch");
Config_ResetDefault();
}
}
#if ENABLED(EEPROM_CHITCHAT)
Config_PrintSettings();
#endif
}
/**
* M501 - Retrieve Configuration
*/
void Config_RetrieveSettings() {
EEPROM_START();
char stored_ver[4];
EEPROM_READ(stored_ver); // read stored version
uint16_t stored_checksum;
EEPROM_READ(stored_checksum);
// SERIAL_ECHOLN("Version: [" << ver << "] Stored version: [" << stored_ver << "]");
if (strncmp(version,stored_ver,3) == 0) {
eeprom_checksum = 0; // clear before reading first "real data"
// version number match
EEPROM_READ(axis_steps_per_unit);
EEPROM_READ(max_feedrate);
EEPROM_READ(max_acceleration_units_per_sq_second);
EEPROM_READ(acceleration);
EEPROM_READ(retract_acceleration);
EEPROM_READ(minimumfeedrate);
EEPROM_READ(mintravelfeedrate);
EEPROM_READ(minsegmenttime);
EEPROM_READ(max_xy_jerk);
EEPROM_READ(max_z_jerk);
EEPROM_READ(max_e_jerk);
EEPROM_READ(add_homeing);
#ifndef ULTIPANEL
#ifdef PRINT_PLA
int plaPreheatHotendTemp, plaPreheatHPBTemp, plaPreheatFanSpeed;
#endif
#ifdef PRINT_ABS
int absPreheatHotendTemp, absPreheatHPBTemp, absPreheatFanSpeed;
#endif
#endif
#ifdef PRINT_PLA
EEPROM_READ(plaPreheatHotendTemp);
EEPROM_READ(plaPreheatHPBTemp);
EEPROM_READ(plaPreheatFanSpeed);
#endif
/*#ifdef PRINT_ABS
EEPROM_READ(absPreheatHotendTemp);
EEPROM_READ(absPreheatHPBTemp);
EEPROM_READ(absPreheatFanSpeed);
#endif*/
#ifndef PIDTEMP
float Kp,Ki,Kd;
#endif
// do not need to scale PID values as the values in EEPROM are already scaled
EEPROM_READ(Kp);
EEPROM_READ(Ki);
EEPROM_READ(Kd);
#ifndef DOGLCD
int lcd_contrast;
#endif
EEPROM_READ(lcd_contrast);
#if !HAS_BED_PROBE
float zprobe_zoffset;
#endif
EEPROM_READ(zprobe_zoffset);
if (eeprom_checksum == stored_checksum) {
Config_Postprocess();
SERIAL_ECHO_START;
SERIAL_ECHO(version);
SERIAL_ECHOPAIR(" stored settings retrieved (", (unsigned long)eeprom_index);
SERIAL_ECHOLNPGM(" bytes)");
} else {
SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("EEPROM checksum mismatch");
Config_ResetDefault();
}
} else {
Config_ResetDefault();
}
#ifdef EEPROM_CHITCHAT
Config_PrintSettings();
#endif
}
