void Config_ResetDefault() { float tmp1[] = DEFAULT_AXIS_STEPS_PER_UNIT; float tmp2[] = DEFAULT_MAX_FEEDRATE; long tmp3[] = DEFAULT_MAX_ACCELERATION; for (uint8_t 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]; #if ENABLED(SCARA) 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 reset_acceleration_rates(); acceleration = DEFAULT_ACCELERATION; retract_acceleration = DEFAULT_RETRACT_ACCELERATION; travel_acceleration = DEFAULT_TRAVEL_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; home_offset[X_AXIS] = home_offset[Y_AXIS] = home_offset[Z_AXIS] = 0; #if ENABLED(MESH_BED_LEVELING) mbl.active = 0; #endif #if ENABLED(AUTO_BED_LEVELING_FEATURE) zprobe_zoffset = Z_PROBE_OFFSET_FROM_EXTRUDER; #endif #if ENABLED(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); #elif ENABLED(Z_DUAL_ENDSTOPS) z_endstop_adj = 0; #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; #endif #if ENABLED(HAS_LCD_CONTRAST) lcd_contrast = DEFAULT_LCD_CONTRAST; #endif #if ENABLED(PIDTEMP) #if ENABLED(PID_PARAMS_PER_EXTRUDER) for (int e = 0; e < EXTRUDERS; e++) #else int e = 0; UNUSED(e); // 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); #if ENABLED(PID_ADD_EXTRUSION_RATE) PID_PARAM(Kc, e) = DEFAULT_Kc; #endif } #if ENABLED(PID_ADD_EXTRUSION_RATE) lpq_len = 20; // default last-position-queue size #endif // call updatePID (similar to when we have processed M301) updatePID(); #endif // PIDTEMP #if ENABLED(PIDTEMPBED) bedKp = DEFAULT_bedKp; bedKi = scalePID_i(DEFAULT_bedKi); bedKd = scalePID_d(DEFAULT_bedKd); #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; for (uint8_t q = 0; q < COUNT(filament_size); q++) filament_size[q] = DEFAULT_NOMINAL_FILAMENT_DIA; calculate_volumetric_multipliers(); SERIAL_ECHO_START; SERIAL_ECHOLNPGM("Hardcoded Default Settings Loaded"); }
void Config_PrintSettings(bool forReplay) { // 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; } SERIAL_ECHOPAIR(" M92 X", axis_steps_per_unit[X_AXIS]); SERIAL_ECHOPAIR(" Y", axis_steps_per_unit[Y_AXIS]); SERIAL_ECHOPAIR(" Z", axis_steps_per_unit[Z_AXIS]); SERIAL_ECHOPAIR(" E", axis_steps_per_unit[E_AXIS]); SERIAL_EOL; CONFIG_ECHO_START; #if ENABLED(SCARA) if (!forReplay) { SERIAL_ECHOLNPGM("Scaling factors:"); CONFIG_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_EOL; CONFIG_ECHO_START; #endif // SCARA if (!forReplay) { SERIAL_ECHOLNPGM("Maximum feedrates (mm/s):"); CONFIG_ECHO_START; } SERIAL_ECHOPAIR(" M203 X", max_feedrate[X_AXIS]); SERIAL_ECHOPAIR(" Y", max_feedrate[Y_AXIS]); SERIAL_ECHOPAIR(" Z", max_feedrate[Z_AXIS]); SERIAL_ECHOPAIR(" E", max_feedrate[E_AXIS]); SERIAL_EOL; CONFIG_ECHO_START; if (!forReplay) { SERIAL_ECHOLNPGM("Maximum Acceleration (mm/s2):"); CONFIG_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(" Z", max_acceleration_units_per_sq_second[Z_AXIS]); SERIAL_ECHOPAIR(" E", max_acceleration_units_per_sq_second[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", acceleration); SERIAL_ECHOPAIR(" R", retract_acceleration); SERIAL_ECHOPAIR(" T", 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", minimumfeedrate); SERIAL_ECHOPAIR(" T", mintravelfeedrate); SERIAL_ECHOPAIR(" B", minsegmenttime); SERIAL_ECHOPAIR(" X", max_xy_jerk); SERIAL_ECHOPAIR(" Z", max_z_jerk); SERIAL_ECHOPAIR(" E", max_e_jerk); 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 ENABLED(MESH_BED_LEVELING) if (!forReplay) { SERIAL_ECHOLNPGM("Mesh bed leveling:"); CONFIG_ECHO_START; } SERIAL_ECHOPAIR(" M420 S", (unsigned long)mbl.active); SERIAL_ECHOPAIR(" X", (unsigned long)MESH_NUM_X_POINTS); SERIAL_ECHOPAIR(" Y", (unsigned long)MESH_NUM_Y_POINTS); SERIAL_EOL; for (int y = 0; y < MESH_NUM_Y_POINTS; y++) { for (int x = 0; x < MESH_NUM_X_POINTS; x++) { CONFIG_ECHO_START; SERIAL_ECHOPAIR(" M421 X", mbl.get_x(x)); SERIAL_ECHOPAIR(" Y", mbl.get_y(y)); SERIAL_ECHOPAIR(" Z", mbl.z_values[y][x]); SERIAL_EOL; } } #endif #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; SERIAL_ECHOLNPGM("Delta settings: L=delta_diagonal_rod, R=delta_radius, S=delta_segments_per_second"); CONFIG_ECHO_START; SERIAL_ECHOPAIR(" M665 L", delta_diagonal_rod); SERIAL_ECHOPAIR(" R", delta_radius); SERIAL_ECHOPAIR(" S", delta_segments_per_second); 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 ENABLED(ULTIPANEL) CONFIG_ECHO_START; if (!forReplay) { SERIAL_ECHOLNPGM("Material heatup parameters:"); CONFIG_ECHO_START; } SERIAL_ECHOPAIR(" M145 M0 H", (unsigned long)plaPreheatHotendTemp); SERIAL_ECHOPAIR(" B", (unsigned long)plaPreheatHPBTemp); SERIAL_ECHOPAIR(" F", (unsigned long)plaPreheatFanSpeed); SERIAL_EOL; CONFIG_ECHO_START; SERIAL_ECHOPAIR(" M145 M1 H", (unsigned long)absPreheatHotendTemp); SERIAL_ECHOPAIR(" B", (unsigned long)absPreheatHPBTemp); SERIAL_ECHOPAIR(" F", (unsigned long)absPreheatFanSpeed); SERIAL_EOL; #endif // ULTIPANEL #if ENABLED(PIDTEMP) || ENABLED(PIDTEMPBED) CONFIG_ECHO_START; if (!forReplay) { SERIAL_ECHOLNPGM("PID settings:"); } #if ENABLED(PIDTEMP) #if EXTRUDERS > 1 if (forReplay) { for (uint8_t i = 0; i < EXTRUDERS; i++) { CONFIG_ECHO_START; SERIAL_ECHOPAIR(" M301 E", (unsigned long)i); SERIAL_ECHOPAIR(" P", PID_PARAM(Kp, i)); SERIAL_ECHOPAIR(" I", unscalePID_i(PID_PARAM(Ki, i))); SERIAL_ECHOPAIR(" D", unscalePID_d(PID_PARAM(Kd, i))); #if ENABLED(PID_ADD_EXTRUSION_RATE) SERIAL_ECHOPAIR(" C", PID_PARAM(Kc, i)); if (i == 0) SERIAL_ECHOPAIR(" L", lpq_len); #endif SERIAL_EOL; } } else #endif // EXTRUDERS > 1 // !forReplay || EXTRUDERS == 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_ADD_EXTRUSION_RATE) 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", bedKp); SERIAL_ECHOPAIR(" I", unscalePID_i(bedKi)); SERIAL_ECHOPAIR(" D", unscalePID_d(bedKd)); SERIAL_EOL; #endif #endif // PIDTEMP || PIDTEMPBED #if ENABLED(HAS_LCD_CONTRAST) CONFIG_ECHO_START; if (!forReplay) { SERIAL_ECHOLNPGM("LCD Contrast:"); CONFIG_ECHO_START; } SERIAL_ECHOPAIR(" M250 C", (unsigned long)lcd_contrast); SERIAL_EOL; #endif #if ENABLED(FWRETRACT) CONFIG_ECHO_START; if (!forReplay) { SERIAL_ECHOLNPGM("Retract: S=Length (mm) F:Speed (mm/m) Z: ZLift (mm)"); CONFIG_ECHO_START; } SERIAL_ECHOPAIR(" M207 S", retract_length); #if EXTRUDERS > 1 SERIAL_ECHOPAIR(" W", retract_length_swap); #endif SERIAL_ECHOPAIR(" F", retract_feedrate * 60); 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", retract_recover_feedrate * 60); 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", (unsigned long)(autoretract_enabled ? 1 : 0)); SERIAL_EOL; #endif // FWRETRACT /** * Volumetric extrusion M200 */ if (!forReplay) { CONFIG_ECHO_START; SERIAL_ECHOPGM("Filament settings:"); if (volumetric_enabled) SERIAL_EOL; else SERIAL_ECHOLNPGM(" Disabled"); } CONFIG_ECHO_START; SERIAL_ECHOPAIR(" M200 D", filament_size[0]); SERIAL_EOL; #if EXTRUDERS > 1 CONFIG_ECHO_START; SERIAL_ECHOPAIR(" M200 T1 D", filament_size[1]); SERIAL_EOL; #if EXTRUDERS > 2 CONFIG_ECHO_START; SERIAL_ECHOPAIR(" M200 T2 D", filament_size[2]); SERIAL_EOL; #if EXTRUDERS > 3 CONFIG_ECHO_START; SERIAL_ECHOPAIR(" M200 T3 D", filament_size[3]); SERIAL_EOL; #endif #endif #endif if (!volumetric_enabled) { CONFIG_ECHO_START; SERIAL_ECHOLNPGM(" M200 D0"); } /** * Auto Bed Leveling */ #if ENABLED(AUTO_BED_LEVELING_FEATURE) #if ENABLED(CUSTOM_M_CODES) if (!forReplay) { CONFIG_ECHO_START; SERIAL_ECHOLNPGM("Z-Probe Offset (mm):"); } CONFIG_ECHO_START; SERIAL_ECHOPAIR(" M" STRINGIFY(CUSTOM_M_CODE_SET_Z_PROBE_OFFSET) " Z", zprobe_zoffset); #else if (!forReplay) { CONFIG_ECHO_START; SERIAL_ECHOPAIR("Z-Probe Offset (mm):", zprobe_zoffset); } #endif SERIAL_EOL; #endif }
void Config_StoreSettings() { float dummy = 0.0f; char ver[4] = "000"; int i = EEPROM_OFFSET; EEPROM_WRITE_VAR(i, ver); // invalidate data first EEPROM_WRITE_VAR(i, axis_steps_per_unit); EEPROM_WRITE_VAR(i, max_feedrate); EEPROM_WRITE_VAR(i, max_acceleration_units_per_sq_second); EEPROM_WRITE_VAR(i, acceleration); EEPROM_WRITE_VAR(i, retract_acceleration); EEPROM_WRITE_VAR(i, travel_acceleration); EEPROM_WRITE_VAR(i, minimumfeedrate); EEPROM_WRITE_VAR(i, mintravelfeedrate); EEPROM_WRITE_VAR(i, minsegmenttime); EEPROM_WRITE_VAR(i, max_xy_jerk); EEPROM_WRITE_VAR(i, max_z_jerk); EEPROM_WRITE_VAR(i, max_e_jerk); EEPROM_WRITE_VAR(i, home_offset); uint8_t mesh_num_x = 3; uint8_t mesh_num_y = 3; #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]; mesh_num_x = MESH_NUM_X_POINTS; mesh_num_y = MESH_NUM_Y_POINTS; EEPROM_WRITE_VAR(i, mbl.active); EEPROM_WRITE_VAR(i, mesh_num_x); EEPROM_WRITE_VAR(i, mesh_num_y); EEPROM_WRITE_VAR(i, mbl.z_values); #else uint8_t dummy_uint8 = 0; EEPROM_WRITE_VAR(i, dummy_uint8); EEPROM_WRITE_VAR(i, mesh_num_x); EEPROM_WRITE_VAR(i, mesh_num_y); dummy = 0.0f; for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_WRITE_VAR(i, dummy); #endif // MESH_BED_LEVELING #if DISABLED(AUTO_BED_LEVELING_FEATURE) float zprobe_zoffset = 0; #endif EEPROM_WRITE_VAR(i, zprobe_zoffset); #if ENABLED(DELTA) EEPROM_WRITE_VAR(i, endstop_adj); // 3 floats EEPROM_WRITE_VAR(i, delta_radius); // 1 float EEPROM_WRITE_VAR(i, delta_diagonal_rod); // 1 float EEPROM_WRITE_VAR(i, delta_segments_per_second); // 1 float #elif ENABLED(Z_DUAL_ENDSTOPS) EEPROM_WRITE_VAR(i, z_endstop_adj); // 1 floats dummy = 0.0f; for (int q = 5; q--;) EEPROM_WRITE_VAR(i, dummy); #else dummy = 0.0f; for (int q = 6; q--;) EEPROM_WRITE_VAR(i, dummy); #endif #if DISABLED(ULTIPANEL) int 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 EEPROM_WRITE_VAR(i, plaPreheatHotendTemp); EEPROM_WRITE_VAR(i, plaPreheatHPBTemp); EEPROM_WRITE_VAR(i, plaPreheatFanSpeed); EEPROM_WRITE_VAR(i, absPreheatHotendTemp); EEPROM_WRITE_VAR(i, absPreheatHPBTemp); EEPROM_WRITE_VAR(i, absPreheatFanSpeed); for (int e = 0; e < 4; e++) { #if ENABLED(PIDTEMP) if (e < EXTRUDERS) { EEPROM_WRITE_VAR(i, PID_PARAM(Kp, e)); EEPROM_WRITE_VAR(i, PID_PARAM(Ki, e)); EEPROM_WRITE_VAR(i, PID_PARAM(Kd, e)); #if ENABLED(PID_ADD_EXTRUSION_RATE) EEPROM_WRITE_VAR(i, PID_PARAM(Kc, e)); #else dummy = 1.0f; // 1.0 = default kc EEPROM_WRITE_VAR(i, dummy); #endif } else #endif // !PIDTEMP { dummy = DUMMY_PID_VALUE; // When read, will not change the existing value EEPROM_WRITE_VAR(i, dummy); dummy = 0.0f; for (int q = 3; q--;) EEPROM_WRITE_VAR(i, dummy); } } // Extruders Loop #if DISABLED(PID_ADD_EXTRUSION_RATE) int lpq_len = 20; #endif EEPROM_WRITE_VAR(i, lpq_len); #if DISABLED(PIDTEMPBED) float bedKp = DUMMY_PID_VALUE, bedKi = DUMMY_PID_VALUE, bedKd = DUMMY_PID_VALUE; #endif EEPROM_WRITE_VAR(i, bedKp); EEPROM_WRITE_VAR(i, bedKi); EEPROM_WRITE_VAR(i, bedKd); #if DISABLED(HAS_LCD_CONTRAST) const int lcd_contrast = 32; #endif EEPROM_WRITE_VAR(i, lcd_contrast); #if ENABLED(SCARA) EEPROM_WRITE_VAR(i, axis_scaling); // 3 floats #else dummy = 1.0f; EEPROM_WRITE_VAR(i, dummy); #endif #if ENABLED(FWRETRACT) EEPROM_WRITE_VAR(i, autoretract_enabled); EEPROM_WRITE_VAR(i, retract_length); #if EXTRUDERS > 1 EEPROM_WRITE_VAR(i, retract_length_swap); #else dummy = 0.0f; EEPROM_WRITE_VAR(i, dummy); #endif EEPROM_WRITE_VAR(i, retract_feedrate); EEPROM_WRITE_VAR(i, retract_zlift); EEPROM_WRITE_VAR(i, retract_recover_length); #if EXTRUDERS > 1 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 EEPROM_WRITE_VAR(i, volumetric_enabled); // Save filament sizes for (int q = 0; q < 4; q++) { if (q < EXTRUDERS) dummy = filament_size[q]; EEPROM_WRITE_VAR(i, dummy); } char ver2[4] = EEPROM_VERSION; int j = EEPROM_OFFSET; EEPROM_WRITE_VAR(j, ver2); // validate data // Report storage size SERIAL_ECHO_START; SERIAL_ECHOPAIR("Settings Stored (", (unsigned long)i); SERIAL_ECHOLNPGM(" bytes)"); }
void Config_RetrieveSettings() { int i = EEPROM_OFFSET; char stored_ver[4]; 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, travel_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, home_offset); uint8_t dummy_uint8 = 0, mesh_num_x = 0, mesh_num_y = 0; EEPROM_READ_VAR(i, dummy_uint8); EEPROM_READ_VAR(i, mesh_num_x); EEPROM_READ_VAR(i, mesh_num_y); #if ENABLED(MESH_BED_LEVELING) mbl.active = dummy_uint8; if (mesh_num_x == MESH_NUM_X_POINTS && mesh_num_y == MESH_NUM_Y_POINTS) { EEPROM_READ_VAR(i, mbl.z_values); } else { mbl.reset(); for (int q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_READ_VAR(i, dummy); } #else for (int q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_READ_VAR(i, dummy); #endif // MESH_BED_LEVELING #if DISABLED(AUTO_BED_LEVELING_FEATURE) float zprobe_zoffset = 0; #endif EEPROM_READ_VAR(i, zprobe_zoffset); #if ENABLED(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 #elif ENABLED(Z_DUAL_ENDSTOPS) EEPROM_READ_VAR(i, z_endstop_adj); dummy = 0.0f; for (int q=5; q--;) EEPROM_READ_VAR(i, dummy); #else dummy = 0.0f; for (int q=6; q--;) EEPROM_READ_VAR(i, dummy); #endif #if DISABLED(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); #if ENABLED(PIDTEMP) for (int e = 0; e < 4; e++) { // 4 = max extruders currently supported by Marlin EEPROM_READ_VAR(i, dummy); // Kp 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)); #if ENABLED(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); // Ki, Kd, Kc } } #else // !PIDTEMP // 4 x 4 = 16 slots for PID parameters for (int q=16; q--;) EEPROM_READ_VAR(i, dummy); // 4x Kp, Ki, Kd, Kc #endif // !PIDTEMP #if DISABLED(PID_ADD_EXTRUSION_RATE) int lpq_len; #endif EEPROM_READ_VAR(i, lpq_len); #if DISABLED(PIDTEMPBED) float bedKp, bedKi, bedKd; #endif EEPROM_READ_VAR(i, dummy); // bedKp if (dummy != DUMMY_PID_VALUE) { bedKp = dummy; UNUSED(bedKp); EEPROM_READ_VAR(i, bedKi); EEPROM_READ_VAR(i, bedKd); } else { for (int q=2; q--;) EEPROM_READ_VAR(i, dummy); // bedKi, bedKd } #if DISABLED(HAS_LCD_CONTRAST) int lcd_contrast; #endif EEPROM_READ_VAR(i, lcd_contrast); #if ENABLED(SCARA) EEPROM_READ_VAR(i, axis_scaling); // 3 floats #else EEPROM_READ_VAR(i, dummy); #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 (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(ver); SERIAL_ECHOPAIR(" stored settings retrieved (", (unsigned long)i); SERIAL_ECHOLNPGM(" bytes)"); } #if ENABLED(EEPROM_CHITCHAT) Config_PrintSettings(); #endif }
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; travel_acceleration = DEFAULT_TRAVEL_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 LEVEL_SENSOR zprobe_zoffset = eeprom::StorageManager::single::instance().getOffset(); #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"); }
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_ECHO_START; } SERIAL_ECHOPAIR(" M92 X", axis_steps_per_unit[X_AXIS]); SERIAL_ECHOPAIR(" Y", axis_steps_per_unit[Y_AXIS]); SERIAL_ECHOPAIR(" Z", axis_steps_per_unit[Z_AXIS]); SERIAL_ECHOPAIR(" E", axis_steps_per_unit[E_AXIS]); SERIAL_EOL; SERIAL_ECHO_START; #ifdef SCARA if (!forReplay) { SERIAL_ECHOLNPGM("Scaling factors:"); 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_EOL; SERIAL_ECHO_START; #endif // SCARA if (!forReplay) { SERIAL_ECHOLNPGM("Maximum feedrates (mm/s):"); SERIAL_ECHO_START; } SERIAL_ECHOPAIR(" M203 X", max_feedrate[X_AXIS]); SERIAL_ECHOPAIR(" Y", max_feedrate[Y_AXIS]); SERIAL_ECHOPAIR(" Z", max_feedrate[Z_AXIS]); SERIAL_ECHOPAIR(" E", max_feedrate[E_AXIS]); SERIAL_EOL; SERIAL_ECHO_START; if (!forReplay) { SERIAL_ECHOLNPGM("Maximum Acceleration (mm/s2):"); 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(" Z", max_acceleration_units_per_sq_second[Z_AXIS] ); SERIAL_ECHOPAIR(" E", max_acceleration_units_per_sq_second[E_AXIS]); SERIAL_EOL; SERIAL_ECHO_START; if (!forReplay) { SERIAL_ECHOLNPGM("Acceleration: S=acceleration, T=retract acceleration"); SERIAL_ECHO_START; } SERIAL_ECHOPAIR(" M204 S", acceleration ); SERIAL_ECHOPAIR(" T", retract_acceleration); SERIAL_EOL; 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_ECHO_START; } SERIAL_ECHOPAIR(" M205 S", minimumfeedrate ); SERIAL_ECHOPAIR(" T", mintravelfeedrate ); SERIAL_ECHOPAIR(" B", minsegmenttime ); SERIAL_ECHOPAIR(" X", max_xy_jerk ); SERIAL_ECHOPAIR(" Z", max_z_jerk); SERIAL_ECHOPAIR(" E", max_e_jerk); SERIAL_EOL; SERIAL_ECHO_START; if (!forReplay) { SERIAL_ECHOLNPGM("Home offset (mm):"); SERIAL_ECHO_START; } SERIAL_ECHOPAIR(" M206 X", add_homing[X_AXIS] ); SERIAL_ECHOPAIR(" Y", add_homing[Y_AXIS] ); SERIAL_ECHOPAIR(" Z", add_homing[Z_AXIS] ); SERIAL_EOL; #ifdef DELTA SERIAL_ECHO_START; if (!forReplay) { SERIAL_ECHOLNPGM("Endstop adjustement (mm):"); 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_EOL; 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_EOL; #endif // DELTA #ifdef PIDTEMP SERIAL_ECHO_START; 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_EOL; #endif // PIDTEMP #ifdef FWRETRACT SERIAL_ECHO_START; 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_EOL; SERIAL_ECHO_START; 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_EOL; SERIAL_ECHO_START; if (!forReplay) { 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_EOL; #if EXTRUDERS > 1 if (!forReplay) { SERIAL_ECHO_START; SERIAL_ECHOLNPGM("Multi-extruder settings:"); SERIAL_ECHO_START; SERIAL_ECHOPAIR(" Swap retract length (mm): ", retract_length_swap); SERIAL_EOL; SERIAL_ECHO_START; SERIAL_ECHOPAIR(" Swap rec. addl. length (mm): ", retract_recover_length_swap); SERIAL_EOL; } #endif // EXTRUDERS > 1 #endif // FWRETRACT SERIAL_ECHO_START; if (volumetric_enabled) { if (!forReplay) { SERIAL_ECHOLNPGM("Filament settings:"); SERIAL_ECHO_START; } SERIAL_ECHOPAIR(" M200 D", filament_size[0]); SERIAL_EOL; #if EXTRUDERS > 1 SERIAL_ECHO_START; SERIAL_ECHOPAIR(" M200 T1 D", filament_size[1]); SERIAL_EOL; #if EXTRUDERS > 2 SERIAL_ECHO_START; SERIAL_ECHOPAIR(" M200 T2 D", filament_size[2]); SERIAL_EOL; #if EXTRUDERS > 3 SERIAL_ECHO_START; SERIAL_ECHOPAIR(" M200 T3 D", filament_size[3]); SERIAL_EOL; #endif #endif #endif } else { if (!forReplay) { SERIAL_ECHOLNPGM("Filament settings: Disabled"); } } #ifdef LEVEL_SENSOR SERIAL_ECHO_START; #ifdef CUSTOM_M_CODES if (!forReplay) { SERIAL_ECHOLNPGM("Z-Probe Offset (mm):"); SERIAL_ECHO_START; } SERIAL_ECHOPAIR(" M", (unsigned long)CUSTOM_M_CODE_SET_Z_PROBE_OFFSET); SERIAL_ECHOPAIR(" Z", zprobe_zoffset); #else if (!forReplay) { SERIAL_ECHOPAIR("Z-Probe Offset (mm):", zprobe_zoffset); } #endif SERIAL_EOL; #endif }
/** * M503 - Print Configuration */ void Config_PrintSettings(bool forReplay) { // Always have this function, even with EEPROM_SETTINGS disabled, the current values will be shown CONFIG_ECHO_START("Steps per unit:"); ECHO_SMV(CFG, " M92 X", planner.axis_steps_per_mm[X_AXIS]); ECHO_MV(" Y", planner.axis_steps_per_mm[Y_AXIS]); ECHO_MV(" Z", planner.axis_steps_per_mm[Z_AXIS]); ECHO_EMV(" E", planner.axis_steps_per_mm[E_AXIS]); #if EXTRUDERS > 1 for (short i = 1; i < EXTRUDERS; i++) { ECHO_SMV(CFG, " M92 T", i); ECHO_EMV(" E", planner.axis_steps_per_mm[E_AXIS + i]); } #endif //EXTRUDERS > 1 #if MECH(SCARA) CONFIG_ECHO_START("Scaling factors:"); ECHO_SMV(CFG, " M365 X", axis_scaling[X_AXIS]); ECHO_MV(" Y", axis_scaling[Y_AXIS]); ECHO_EMV(" Z", axis_scaling[Z_AXIS]); #endif // SCARA CONFIG_ECHO_START("Maximum feedrates (mm/s):"); ECHO_SMV(CFG, " M203 X", planner.max_feedrate[X_AXIS]); ECHO_MV(" Y", planner.max_feedrate[Y_AXIS] ); ECHO_MV(" Z", planner.max_feedrate[Z_AXIS] ); ECHO_EMV(" E", planner.max_feedrate[E_AXIS]); #if EXTRUDERS > 1 for (short i = 1; i < EXTRUDERS; i++) { ECHO_SMV(CFG, " M203 T", i); ECHO_EMV(" E", planner.max_acceleration_mm_per_s2[E_AXIS + i]); } #endif //EXTRUDERS > 1 CONFIG_ECHO_START("Maximum Acceleration (mm/s2):"); ECHO_SMV(CFG, " M201 X", planner.max_acceleration_mm_per_s2[X_AXIS] ); ECHO_MV(" Y", planner.max_acceleration_mm_per_s2[Y_AXIS] ); ECHO_MV(" Z", planner.max_acceleration_mm_per_s2[Z_AXIS] ); ECHO_EMV(" E", planner.max_acceleration_mm_per_s2[E_AXIS]); #if EXTRUDERS > 1 for (int8_t i = 1; i < EXTRUDERS; i++) { ECHO_SMV(CFG, " M201 T", i); ECHO_EMV(" E", planner.max_acceleration_mm_per_s2[E_AXIS + i]); } #endif //EXTRUDERS > 1 CONFIG_ECHO_START("Accelerations: P=printing, V=travel and T* R=retract"); ECHO_SMV(CFG," M204 P", planner.acceleration); ECHO_EMV(" V", planner.travel_acceleration); #if EXTRUDERS > 0 for (int8_t i = 0; i < EXTRUDERS; i++) { ECHO_SMV(CFG, " M204 T", i); ECHO_EMV(" R", planner.retract_acceleration[i]); } #endif CONFIG_ECHO_START("Advanced variables: S=Min feedrate (mm/s), V=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)"); ECHO_SMV(CFG, " M205 S", planner.min_feedrate ); ECHO_MV(" V", planner.min_travel_feedrate ); ECHO_MV(" B", planner.min_segment_time ); ECHO_MV(" X", planner.max_xy_jerk ); ECHO_MV(" Z", planner.max_z_jerk); ECHO_EMV(" E", planner.max_e_jerk[0]); #if (EXTRUDERS > 1) for(int8_t i = 1; i < EXTRUDERS; i++) { ECHO_SMV(CFG, " M205 T", i); ECHO_EMV(" E" , planner.max_e_jerk[i]); } #endif CONFIG_ECHO_START("Home offset (mm):"); ECHO_SMV(CFG, " M206 X", home_offset[X_AXIS] ); ECHO_MV(" Y", home_offset[Y_AXIS] ); ECHO_EMV(" Z", home_offset[Z_AXIS] ); CONFIG_ECHO_START("Hotend offset (mm):"); for (int8_t h = 0; h < HOTENDS; h++) { ECHO_SMV(CFG, " M218 T", h); ECHO_MV(" X", hotend_offset[X_AXIS][h]); ECHO_MV(" Y", hotend_offset[Y_AXIS][h]); ECHO_EMV(" Z", hotend_offset[Z_AXIS][h]); } #if HAS(LCD_CONTRAST) CONFIG_ECHO_START("LCD Contrast:"); ECHO_LMV(CFG, " M250 C", lcd_contrast); #endif #if ENABLED(MESH_BED_LEVELING) CONFIG_ECHO_START("Mesh bed leveling:"); ECHO_SMV(CFG, " M420 S", mbl.has_mesh() ? 1 : 0); ECHO_MV(" X", MESH_NUM_X_POINTS); ECHO_MV(" Y", MESH_NUM_Y_POINTS); ECHO_E; for (uint8_t py = 1; py <= MESH_NUM_Y_POINTS; py++) { for (uint8_t px = 1; px <= MESH_NUM_X_POINTS; px++) { ECHO_SMV(CFG, " G29 S3 X", px); ECHO_MV(" Y", py); ECHO_EMV(" Z", mbl.z_values[py-1][px-1], 5); } } #endif #if HEATER_USES_AD595 CONFIG_ECHO_START("AD595 Offset and Gain:"); for (int8_t h = 0; h < HOTENDS; h++) { ECHO_SMV(CFG, " M595 T", h); ECHO_MV(" O", ad595_offset[h]); ECHO_EMV(", S", ad595_gain[h]); } #endif // HEATER_USES_AD595 #if MECH(DELTA) CONFIG_ECHO_START("Delta Geometry adjustment:"); ECHO_SMV(CFG, " M666 A", tower_adj[0], 3); ECHO_MV(" B", tower_adj[1], 3); ECHO_MV(" C", tower_adj[2], 3); ECHO_MV(" I", tower_adj[3], 3); ECHO_MV(" J", tower_adj[4], 3); ECHO_MV(" K", tower_adj[5], 3); ECHO_MV(" U", diagrod_adj[0], 3); ECHO_MV(" V", diagrod_adj[1], 3); ECHO_MV(" W", diagrod_adj[2], 3); ECHO_MV(" R", delta_radius); ECHO_MV(" D", delta_diagonal_rod); ECHO_EMV(" H", sw_endstop_max[2]); CONFIG_ECHO_START("Endstop Offsets:"); ECHO_SMV(CFG, " M666 X", endstop_adj[X_AXIS]); ECHO_MV(" Y", endstop_adj[Y_AXIS]); ECHO_EMV(" Z", endstop_adj[Z_AXIS]); #elif ENABLED(Z_DUAL_ENDSTOPS) CONFIG_ECHO_START("Z2 Endstop adjustement (mm):"); ECHO_LMV(CFG, " M666 Z", z_endstop_adj ); #endif // DELTA /** * Auto Bed Leveling */ #if HAS(BED_PROBE) CONFIG_ECHO_START("Z Probe offset (mm):"); ECHO_LMV(CFG, " M666 P", zprobe_zoffset); #endif #if ENABLED(ULTIPANEL) CONFIG_ECHO_START("Material heatup parameters:"); ECHO_SMV(CFG, " M145 S0 H", plaPreheatHotendTemp); ECHO_MV(" B", plaPreheatHPBTemp); ECHO_MV(" F", plaPreheatFanSpeed); ECHO_EM(" (Material PLA)"); ECHO_SMV(CFG, " M145 S1 H", absPreheatHotendTemp); ECHO_MV(" B", absPreheatHPBTemp); ECHO_MV(" F", absPreheatFanSpeed); ECHO_EM(" (Material ABS)"); ECHO_SMV(CFG, " M145 S2 H", gumPreheatHotendTemp); ECHO_MV(" B", gumPreheatHPBTemp); ECHO_MV(" F", gumPreheatFanSpeed); ECHO_EM(" (Material GUM)"); #endif // ULTIPANEL #if ENABLED(PIDTEMP) || ENABLED(PIDTEMPBED) || ENABLED(PIDTEMPCHAMBER) || ENABLED(PIDTEMPCOOLER) CONFIG_ECHO_START("PID settings:"); #if ENABLED(PIDTEMP) for (int8_t h = 0; h < HOTENDS; h++) { ECHO_SMV(CFG, " M301 H", h); ECHO_MV(" P", PID_PARAM(Kp, h)); ECHO_MV(" I", unscalePID_i(PID_PARAM(Ki, h))); ECHO_MV(" D", unscalePID_d(PID_PARAM(Kd, h))); #if ENABLED(PID_ADD_EXTRUSION_RATE) ECHO_MV(" C", PID_PARAM(Kc, h)); #endif ECHO_E; } #if ENABLED(PID_ADD_EXTRUSION_RATE) ECHO_SMV(CFG, " M301 L", lpq_len); #endif #endif #if ENABLED(PIDTEMPBED) ECHO_SMV(CFG, " M304 P", bedKp); ECHO_MV(" I", unscalePID_i(bedKi)); ECHO_EMV(" D", unscalePID_d(bedKd)); #endif #if ENABLED(PIDTEMPCHAMBER) ECHO_SMV(CFG, " M305 P", chamberKp); ECHO_MV(" I", unscalePID_i(chamberKi)); ECHO_EMV(" D", unscalePID_d(chamberKd)); #endif #if ENABLED(PIDTEMPCOOLER) ECHO_SMV(CFG, " M306 P", coolerKp); ECHO_MV(" I", unscalePID_i(coolerKi)); ECHO_EMV(" D", unscalePID_d(coolerKd)); #endif #endif #if ENABLED(FWRETRACT) CONFIG_ECHO_START("Retract: S=Length (mm) F:Speed (mm/m) Z: ZLift (mm)"); ECHO_SMV(CFG, " M207 S", retract_length); #if EXTRUDERS > 1 ECHO_MV(" W", retract_length_swap); #endif ECHO_MV(" F", retract_feedrate * 60); ECHO_EMV(" Z", retract_zlift); CONFIG_ECHO_START("Recover: S=Extra length (mm) F:Speed (mm/m)"); ECHO_SMV(CFG, " M208 S", retract_recover_length); #if EXTRUDERS > 1 ECHO_MV(" W", retract_recover_length_swap); #endif ECHO_MV(" F", retract_recover_feedrate * 60); CONFIG_ECHO_START("Auto-Retract: S=0 to disable, 1 to interpret extrude-only moves as retracts or recoveries"); ECHO_LMV(CFG, " M209 S", autoretract_enabled ? 1 : 0); #endif // FWRETRACT if (volumetric_enabled) { CONFIG_ECHO_START("Filament settings:"); ECHO_LMV(CFG, " M200 D", filament_size[0]); #if EXTRUDERS > 1 ECHO_LMV(CFG, " M200 T1 D", filament_size[1]); #if EXTRUDERS > 2 ECHO_LMV(CFG, " M200 T2 D", filament_size[2]); #if EXTRUDERS > 3 ECHO_LMV(CFG, " M200 T3 D", filament_size[3]); #endif #endif #endif } else CONFIG_ECHO_START(" M200 D0"); #if MB(ALLIGATOR) CONFIG_ECHO_START("Motor current:"); ECHO_SMV(CFG, " M906 X", motor_current[X_AXIS]); ECHO_MV(" Y", motor_current[Y_AXIS]); ECHO_MV(" Z", motor_current[Z_AXIS]); ECHO_EMV(" E", motor_current[E_AXIS]); #if DRIVER_EXTRUDERS > 1 for (uint8_t i = 1; i < DRIVER_EXTRUDERS; i++) { ECHO_SMV(CFG, " M906 T", i); ECHO_EMV(" E", motor_current[E_AXIS + i]); } #endif // DRIVER_EXTRUDERS > 1 #endif // ALLIGATOR ConfigSD_PrintSettings(forReplay); }
void Config_StoreSettings() { float dummy = 0.0f; char ver[4] = "000"; int i = EEPROM_OFFSET; EEPROM_WRITE_VAR(i, ver); // invalidate data first EEPROM_WRITE_VAR(i, axis_steps_per_unit); EEPROM_WRITE_VAR(i, max_feedrate); EEPROM_WRITE_VAR(i, max_acceleration_units_per_sq_second); EEPROM_WRITE_VAR(i, acceleration); EEPROM_WRITE_VAR(i, retract_acceleration); EEPROM_WRITE_VAR(i, minimumfeedrate); EEPROM_WRITE_VAR(i, mintravelfeedrate); EEPROM_WRITE_VAR(i, minsegmenttime); EEPROM_WRITE_VAR(i, max_xy_jerk); EEPROM_WRITE_VAR(i, max_z_jerk); EEPROM_WRITE_VAR(i, max_e_jerk); EEPROM_WRITE_VAR(i, add_homing); #ifdef DELTA EEPROM_WRITE_VAR(i, endstop_adj); // 3 floats EEPROM_WRITE_VAR(i, delta_radius); // 1 float EEPROM_WRITE_VAR(i, delta_diagonal_rod); // 1 float EEPROM_WRITE_VAR(i, delta_segments_per_second); // 1 float #else dummy = 0.0f; for (int q=6; q--;) EEPROM_WRITE_VAR(i, dummy); #endif #ifndef ULTIPANEL int 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 EEPROM_WRITE_VAR(i, plaPreheatHotendTemp); EEPROM_WRITE_VAR(i, plaPreheatHPBTemp); EEPROM_WRITE_VAR(i, plaPreheatFanSpeed); EEPROM_WRITE_VAR(i, absPreheatHotendTemp); EEPROM_WRITE_VAR(i, absPreheatHPBTemp); EEPROM_WRITE_VAR(i, absPreheatFanSpeed); EEPROM_WRITE_VAR(i, zprobe_zoffset); for (int e = 0; e < 4; e++) { #ifdef PIDTEMP if (e < EXTRUDERS) { EEPROM_WRITE_VAR(i, PID_PARAM(Kp, e)); EEPROM_WRITE_VAR(i, PID_PARAM(Ki, e)); EEPROM_WRITE_VAR(i, PID_PARAM(Kd, e)); #ifdef PID_ADD_EXTRUSION_RATE EEPROM_WRITE_VAR(i, PID_PARAM(Kc, e)); #else dummy = 1.0f; // 1.0 = default kc EEPROM_WRITE_VAR(i, dummy); #endif } else { #else // !PIDTEMP { #endif // !PIDTEMP dummy = DUMMY_PID_VALUE; EEPROM_WRITE_VAR(i, dummy); dummy = 0.0f; for (int q = 3; q--;) EEPROM_WRITE_VAR(i, dummy); } } // Extruders Loop #ifndef DOGLCD int lcd_contrast = 32; #endif EEPROM_WRITE_VAR(i, lcd_contrast); #ifdef SCARA EEPROM_WRITE_VAR(i, axis_scaling); // 3 floats #else dummy = 1.0f; EEPROM_WRITE_VAR(i, dummy); #endif #ifdef FWRETRACT EEPROM_WRITE_VAR(i, autoretract_enabled); EEPROM_WRITE_VAR(i, retract_length); #if EXTRUDERS > 1 EEPROM_WRITE_VAR(i, retract_length_swap); #else dummy = 0.0f; EEPROM_WRITE_VAR(i, dummy); #endif EEPROM_WRITE_VAR(i, retract_feedrate); EEPROM_WRITE_VAR(i, retract_zlift); EEPROM_WRITE_VAR(i, retract_recover_length); #if EXTRUDERS > 1 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 EEPROM_WRITE_VAR(i, volumetric_enabled); // Save filament sizes for (int q = 0; q < 4; q++) { if (q < EXTRUDERS) dummy = filament_size[q]; EEPROM_WRITE_VAR(i, dummy); } int storageSize = i; char ver2[4] = EEPROM_VERSION; int j = EEPROM_OFFSET; EEPROM_WRITE_VAR(j, ver2); // validate data // Report storage size SERIAL_ECHO_START; SERIAL_ECHOPAIR("Settings Stored (", (unsigned long)i); SERIAL_ECHOLNPGM(" bytes)"); } void Config_RetrieveSettings() { int i = EEPROM_OFFSET; char stored_ver[4]; 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); // Ki, Kd, Kc } } #else // !PIDTEMP // 4 x 4 = 16 slots for PID parameters for (int q=16; q--;) EEPROM_READ_VAR(i, dummy); // 4x Kp, Ki, Kd, Kc #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(ver); SERIAL_ECHOPAIR(" stored settings retrieved (", (unsigned long)i); SERIAL_ECHOLNPGM(" bytes)"); } #ifdef EEPROM_CHITCHAT Config_PrintSettings(); #endif }
/** * 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 }
/** * M500 - Store Configuration */ void Config_StoreSettings() { float dummy = 0.0f; char ver[6] = "00000"; int i = EEPROM_OFFSET; EEPROM_WRITE_VAR(i, ver); // invalidate data first i += sizeof(eeprom_checksum); // Skip the checksum slot eeprom_checksum = 0; // clear before first "real data" EEPROM_WRITE_VAR(i, planner.axis_steps_per_mm); EEPROM_WRITE_VAR(i, planner.max_feedrate); EEPROM_WRITE_VAR(i, planner.max_acceleration_mm_per_s2); EEPROM_WRITE_VAR(i, planner.acceleration); EEPROM_WRITE_VAR(i, planner.retract_acceleration); EEPROM_WRITE_VAR(i, planner.travel_acceleration); EEPROM_WRITE_VAR(i, planner.min_feedrate); EEPROM_WRITE_VAR(i, planner.min_travel_feedrate); EEPROM_WRITE_VAR(i, planner.min_segment_time); EEPROM_WRITE_VAR(i, planner.max_xy_jerk); EEPROM_WRITE_VAR(i, planner.max_z_jerk); EEPROM_WRITE_VAR(i, planner.max_e_jerk); EEPROM_WRITE_VAR(i, home_offset); EEPROM_WRITE_VAR(i, hotend_offset); #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_VAR(i, dummy_uint8); EEPROM_WRITE_VAR(i, mbl.z_offset); EEPROM_WRITE_VAR(i, mesh_num_x); EEPROM_WRITE_VAR(i, mesh_num_y); EEPROM_WRITE_VAR(i, mbl.z_values); #endif #if HEATER_USES_AD595 EEPROM_WRITE_VAR(i, ad595_offset); EEPROM_WRITE_VAR(i, ad595_gain); #endif #if MECH(DELTA) EEPROM_WRITE_VAR(i, endstop_adj); EEPROM_WRITE_VAR(i, delta_radius); EEPROM_WRITE_VAR(i, delta_diagonal_rod); EEPROM_WRITE_VAR(i, sw_endstop_max); EEPROM_WRITE_VAR(i, tower_adj); EEPROM_WRITE_VAR(i, diagrod_adj); #elif ENABLED(Z_DUAL_ENDSTOPS) EEPROM_WRITE_VAR(i, z_endstop_adj); #endif #if HASNT(BED_PROBE) float zprobe_zoffset = 0; #endif EEPROM_WRITE_VAR(i, zprobe_zoffset); #if DISABLED(ULTIPANEL) int 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 EEPROM_WRITE_VAR(i, plaPreheatHotendTemp); EEPROM_WRITE_VAR(i, plaPreheatHPBTemp); EEPROM_WRITE_VAR(i, plaPreheatFanSpeed); EEPROM_WRITE_VAR(i, absPreheatHotendTemp); EEPROM_WRITE_VAR(i, absPreheatHPBTemp); EEPROM_WRITE_VAR(i, absPreheatFanSpeed); EEPROM_WRITE_VAR(i, gumPreheatHotendTemp); EEPROM_WRITE_VAR(i, gumPreheatHPBTemp); EEPROM_WRITE_VAR(i, gumPreheatFanSpeed); #if ENABLED(PIDTEMP) for (int h = 0; h < HOTENDS; h++) { EEPROM_WRITE_VAR(i, PID_PARAM(Kp, h)); EEPROM_WRITE_VAR(i, PID_PARAM(Ki, h)); EEPROM_WRITE_VAR(i, PID_PARAM(Kd, h)); EEPROM_WRITE_VAR(i, PID_PARAM(Kc, h)); } #endif #if DISABLED(PID_ADD_EXTRUSION_RATE) int lpq_len = 20; #endif EEPROM_WRITE_VAR(i, lpq_len); #if ENABLED(PIDTEMPBED) EEPROM_WRITE_VAR(i, bedKp); EEPROM_WRITE_VAR(i, bedKi); EEPROM_WRITE_VAR(i, bedKd); #endif #if ENABLED(PIDTEMPCHAMBER) EEPROM_WRITE_VAR(i, chamberKp); EEPROM_WRITE_VAR(i, chamberKi); EEPROM_WRITE_VAR(i, chamberKd); #endif #if ENABLED(PIDTEMPCOOLER) EEPROM_WRITE_VAR(i, coolerKp); EEPROM_WRITE_VAR(i, coolerKi); EEPROM_WRITE_VAR(i, coolerKd); #endif #if HASNT(LCD_CONTRAST) const int lcd_contrast = 32; #endif EEPROM_WRITE_VAR(i, lcd_contrast); #if MECH(SCARA) EEPROM_WRITE_VAR(i, axis_scaling); // 3 floats #endif #if ENABLED(FWRETRACT) EEPROM_WRITE_VAR(i, autoretract_enabled); EEPROM_WRITE_VAR(i, retract_length); #if EXTRUDERS > 1 EEPROM_WRITE_VAR(i, retract_length_swap); #else dummy = 0.0f; EEPROM_WRITE_VAR(i, dummy); #endif EEPROM_WRITE_VAR(i, retract_feedrate); EEPROM_WRITE_VAR(i, retract_zlift); EEPROM_WRITE_VAR(i, retract_recover_length); #if EXTRUDERS > 1 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 EEPROM_WRITE_VAR(i, volumetric_enabled); // Save filament sizes for (int e = 0; e < EXTRUDERS; e++) EEPROM_WRITE_VAR(i, filament_size[e]); #if ENABLED(IDLE_OOZING_PREVENT) EEPROM_WRITE_VAR(i, IDLE_OOZING_enabled); #endif #if MB(ALLIGATOR) EEPROM_WRITE_VAR(i, motor_current); #endif uint16_t final_checksum = eeprom_checksum; int j = EEPROM_OFFSET; EEPROM_WRITE_VAR(j, version); EEPROM_WRITE_VAR(j, final_checksum); // Report storage size ECHO_SMV(DB, "Settings Stored (", i); ECHO_EM(" bytes)"); }
/** * Print Configuration Settings - M503 */ void Config_PrintSettings(bool forReplay) { // Always have this function, even with EEPROM_SETTINGS disabled, the current values will be shown if (!forReplay) { ECHO_LM(CFG, "Steps per unit:"); } ECHO_SMV(CFG, " M92 X", axis_steps_per_unit[X_AXIS]); ECHO_MV(" Y", axis_steps_per_unit[Y_AXIS]); ECHO_MV(" Z", axis_steps_per_unit[Z_AXIS]); ECHO_EMV(" E", axis_steps_per_unit[E_AXIS]); #if EXTRUDERS > 1 for (short i = 1; i < EXTRUDERS; i++) { ECHO_SMV(CFG, " M92 T", i); ECHO_EMV(" E", axis_steps_per_unit[E_AXIS + i]); } #endif //EXTRUDERS > 1 #if MECH(SCARA) if (!forReplay) { ECHO_LM(CFG, "Scaling factors:"); } ECHO_SMV(CFG, " M365 X", axis_scaling[X_AXIS]); ECHO_MV(" Y", axis_scaling[Y_AXIS]); ECHO_EMV(" Z", axis_scaling[Z_AXIS]); #endif // SCARA if (!forReplay) { ECHO_LM(CFG, "Maximum feedrates (mm/s):"); } ECHO_SMV(CFG, " M203 X", max_feedrate[X_AXIS]); ECHO_MV(" Y", max_feedrate[Y_AXIS] ); ECHO_MV(" Z", max_feedrate[Z_AXIS] ); ECHO_EMV(" E", max_feedrate[E_AXIS]); #if EXTRUDERS > 1 for (short i = 1; i < EXTRUDERS; i++) { ECHO_SMV(CFG, " M203 T", i); ECHO_EMV(" E", max_feedrate[E_AXIS + i]); } #endif //EXTRUDERS > 1 if (!forReplay) { ECHO_LM(CFG, "Maximum Acceleration (mm/s2):"); } ECHO_SMV(CFG, " M201 X", max_acceleration_units_per_sq_second[X_AXIS] ); ECHO_MV(" Y", max_acceleration_units_per_sq_second[Y_AXIS] ); ECHO_MV(" Z", max_acceleration_units_per_sq_second[Z_AXIS] ); ECHO_EMV(" E", max_acceleration_units_per_sq_second[E_AXIS]); #if EXTRUDERS > 1 for (int8_t i = 1; i < EXTRUDERS; i++) { ECHO_SMV(CFG, " M201 T", i); ECHO_EMV(" E", max_acceleration_units_per_sq_second[E_AXIS + i]); } #endif //EXTRUDERS > 1 ECHO_E; if (!forReplay) { ECHO_LM(CFG, "Accelerations: P=printing, V=travel and T* R=retract"); } ECHO_SMV(CFG," M204 P", acceleration); ECHO_EMV(" V", travel_acceleration); #if EXTRUDERS > 0 for (int8_t i = 0; i < EXTRUDERS; i++) { ECHO_SMV(CFG, " M204 T", i); ECHO_EMV(" R", retract_acceleration[i]); } #endif if (!forReplay) { ECHO_LM(CFG, "Advanced variables: S=Min feedrate (mm/s), V=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)"); } ECHO_SMV(CFG, " M205 S", minimumfeedrate ); ECHO_MV(" V", mintravelfeedrate ); ECHO_MV(" B", minsegmenttime ); ECHO_MV(" X", max_xy_jerk ); ECHO_MV(" Z", max_z_jerk); ECHO_EMV(" E", max_e_jerk[0]); #if (EXTRUDERS > 1) for(int8_t i = 1; i < EXTRUDERS; i++) { ECHO_SMV(CFG, " M205 T", i); ECHO_EMV(" E" , max_e_jerk[i]); } #endif if (!forReplay) { ECHO_LM(CFG, "Home offset (mm):"); } ECHO_SMV(CFG, " M206 X", home_offset[X_AXIS] ); ECHO_MV(" Y", home_offset[Y_AXIS] ); ECHO_EMV(" Z", home_offset[Z_AXIS] ); if (!forReplay) { ECHO_LM(CFG, "Hotend offset (mm):"); } for (int8_t h = 0; h < HOTENDS; h++) { ECHO_SMV(CFG, " M218 T", h); ECHO_MV(" X", hotend_offset[X_AXIS][h]); ECHO_MV(" Y", hotend_offset[Y_AXIS][h]); ECHO_EMV(" Z", hotend_offset[Z_AXIS][h]); } #if HEATER_USES_AD595 if (!forReplay) { ECHO_LM(CFG, "AD595 Offset and Gain:"); } for (int8_t h = 0; h < HOTENDS; h++) { ECHO_SMV(CFG, " M595 T", h); ECHO_MV(" O", ad595_offset[h]); ECHO_EMV(", S", ad595_gain[h]); } #endif // HEATER_USES_AD595 #if MECH(DELTA) if (!forReplay) { ECHO_LM(CFG, "Delta Geometry adjustment:"); } ECHO_SMV(CFG, " M666 A", tower_adj[0], 3); ECHO_MV(" B", tower_adj[1], 3); ECHO_MV(" C", tower_adj[2], 3); ECHO_MV(" I", tower_adj[3], 3); ECHO_MV(" J", tower_adj[4], 3); ECHO_MV(" K", tower_adj[5], 3); ECHO_MV(" U", diagrod_adj[0], 3); ECHO_MV(" V", diagrod_adj[1], 3); ECHO_MV(" W", diagrod_adj[2], 3); ECHO_MV(" R", delta_radius); ECHO_MV(" D", delta_diagonal_rod); ECHO_EMV(" H", sw_endstop_max[2]); if (!forReplay) { ECHO_LM(CFG, "Endstop Offsets:"); } ECHO_SMV(CFG, " M666 X", endstop_adj[X_AXIS]); ECHO_MV(" Y", endstop_adj[Y_AXIS]); ECHO_EMV(" Z", endstop_adj[Z_AXIS]); if (!forReplay) { ECHO_LM(CFG, "Z-Probe Offset:"); } ECHO_SMV(CFG, " M666 P X", z_probe_offset[0]); ECHO_MV(" Y", z_probe_offset[1]); ECHO_EMV(" Z", z_probe_offset[2]); #elif ENABLED(Z_DUAL_ENDSTOPS) if (!forReplay) { ECHO_LM(CFG, "Z2 Endstop adjustement (mm):"); } ECHO_LMV(CFG, " M666 Z", z_endstop_adj ); #elif ENABLED(AUTO_BED_LEVELING_FEATURE) if (!forReplay) { ECHO_LM(CFG, "Z Probe offset (mm)"); } ECHO_LMV(CFG, " M666 P", zprobe_zoffset); #endif #if ENABLED(ULTIPANEL) if (!forReplay) { ECHO_LM(CFG, "Material heatup parameters:"); } ECHO_SMV(CFG, " M145 S0 H", plaPreheatHotendTemp); ECHO_MV(" B", plaPreheatHPBTemp); ECHO_MV(" F", plaPreheatFanSpeed); ECHO_EM(" (Material PLA)"); ECHO_SMV(CFG, " M145 S1 H", absPreheatHotendTemp); ECHO_MV(" B", absPreheatHPBTemp); ECHO_MV(" F", absPreheatFanSpeed); ECHO_EM(" (Material ABS)"); ECHO_SMV(CFG, " M145 S2 H", gumPreheatHotendTemp); ECHO_MV(" B", gumPreheatHPBTemp); ECHO_MV(" F", gumPreheatFanSpeed); ECHO_EM(" (Material GUM)"); #endif // ULTIPANEL #if ENABLED(PIDTEMP) || ENABLED(PIDTEMPBED) if (!forReplay) { ECHO_LM(CFG, "PID settings:"); } #if ENABLED(PIDTEMP) for (uint8_t h = 0; h < HOTENDS; h++) { ECHO_SMV(CFG, " M301 H", h); ECHO_MV(" P", PID_PARAM(Kp, h)); ECHO_MV(" I", unscalePID_i(PID_PARAM(Ki, h))); ECHO_MV(" D", unscalePID_d(PID_PARAM(Kd, h))); #if ENABLED(PID_ADD_EXTRUSION_RATE) ECHO_MV(" C", PID_PARAM(Kc, h)); #endif ECHO_E; } #if ENABLED(PID_ADD_EXTRUSION_RATE) ECHO_SMV(CFG, " M301 L", lpq_len); #endif #endif #if ENABLED(PIDTEMPBED) ECHO_SMV(CFG, " M304 P", bedKp); // for compatibility with hosts, only echos values for E0 ECHO_MV(" I", unscalePID_i(bedKi)); ECHO_EMV(" D", unscalePID_d(bedKd)); #endif #endif #if ENABLED(FWRETRACT) if (!forReplay) { ECHO_LM(CFG, "Retract: S=Length (mm) F:Speed (mm/m) Z: ZLift (mm)"); } ECHO_SMV(CFG, " M207 S", retract_length); ECHO_MV(" F", retract_feedrate*60); ECHO_EMV(" Z", retract_zlift); if (!forReplay) { ECHO_LM(CFG, "Recover: S=Extra length (mm) F:Speed (mm/m)"); } ECHO_SMV(CFG, " M208 S", retract_recover_length); ECHO_MV(" F", retract_recover_feedrate*60); if (!forReplay) { ECHO_LM(CFG, "Auto-Retract: S=0 to disable, 1 to interpret extrude-only moves as retracts or recoveries"); } ECHO_LMV(CFG, " M209 S", autoretract_enabled); #if EXTRUDERS > 1 if (!forReplay) { ECHO_LM(CFG, "Multi-extruder settings:"); ECHO_LMV(CFG, " Swap retract length (mm): ", retract_length_swap); ECHO_LMV(CFG, " Swap rec. addl. length (mm): ", retract_recover_length_swap); } #endif // EXTRUDERS > 1 #endif // FWRETRACT if (volumetric_enabled) { if (!forReplay) { ECHO_LM(CFG, "Filament settings:"); } ECHO_LMV(CFG, " M200 D", filament_size[0]); #if EXTRUDERS > 1 ECHO_LMV(CFG, " M200 T1 D", filament_size[1]); #if EXTRUDERS > 2 ECHO_LMV(CFG, " M200 T2 D", filament_size[2]); #if EXTRUDERS > 3 ECHO_LMV(CFG, " M200 T3 D", filament_size[3]); #endif #endif #endif } else { if (!forReplay) { ECHO_LM(CFG, "Filament settings: Disabled"); } } #if MB(ALLIGATOR) if (!forReplay) { ECHO_LM(CFG, "Current:"); } ECHO_SMV(CFG, " M906 X", motor_current[X_AXIS]); ECHO_MV(" Y", motor_current[Y_AXIS]); ECHO_MV(" Z", motor_current[Z_AXIS]); ECHO_EMV(" E", motor_current[E_AXIS]); #if DRIVER_EXTRUDERS > 1 for (uint8_t i = 1; i < DRIVER_EXTRUDERS; i++) { ECHO_SMV(CFG, " M906 T", i); ECHO_EMV(" E", motor_current[E_AXIS + i]); } #endif // DRIVER_EXTRUDERS > 1 #endif // ALLIGATOR ConfigSD_PrintSettings(forReplay); }
/** * Retrieve Configuration Settings - M501 */ void Config_RetrieveSettings() { int i = EEPROM_OFFSET; char stored_ver[7]; char ver[7] = EEPROM_VERSION; EEPROM_READ_VAR(i, stored_ver); // read stored version //ECHO_EM("Version: [" << ver << "] Stored version: [" << stored_ver << "]"); if (strncmp(ver, stored_ver, 6) != 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, travel_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, home_offset); EEPROM_READ_VAR(i, hotend_offset); #if !MECH(DELTA) EEPROM_READ_VAR(i, zprobe_zoffset); #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); EEPROM_READ_VAR(i, z_probe_offset); // Update delta constants for updated delta_radius & tower_adj values set_delta_constants(); #endif //DELTA #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 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]); calculate_volumetric_multipliers(); #if ENABLED(IDLE_OOZING_PREVENT) EEPROM_READ_VAR(i, IDLE_OOZING_enabled); #endif #if MB(ALLIGATOR) EEPROM_READ_VAR(i, motor_current); #endif // Call updatePID (similar to when we have processed M301) updatePID(); // Report settings retrieved and length ECHO_SV(DB, ver); ECHO_MV(" stored settings retrieved (", (unsigned long)i); ECHO_EM(" bytes)"); } #if ENABLED(EEPROM_CHITCHAT) Config_PrintSettings(); #endif }
void Config_StoreSettings() { float dummy = 0.0f; char ver[7] = "000000"; int i = EEPROM_OFFSET; EEPROM_WRITE_VAR(i, ver); // invalidate data first EEPROM_WRITE_VAR(i, axis_steps_per_unit); EEPROM_WRITE_VAR(i, max_feedrate); EEPROM_WRITE_VAR(i, max_acceleration_units_per_sq_second); EEPROM_WRITE_VAR(i, acceleration); EEPROM_WRITE_VAR(i, retract_acceleration); EEPROM_WRITE_VAR(i, travel_acceleration); EEPROM_WRITE_VAR(i, minimumfeedrate); EEPROM_WRITE_VAR(i, mintravelfeedrate); EEPROM_WRITE_VAR(i, minsegmenttime); EEPROM_WRITE_VAR(i, max_xy_jerk); EEPROM_WRITE_VAR(i, max_z_jerk); EEPROM_WRITE_VAR(i, max_e_jerk); EEPROM_WRITE_VAR(i, home_offset); EEPROM_WRITE_VAR(i, hotend_offset); #if !MECH(DELTA) EEPROM_WRITE_VAR(i, zprobe_zoffset); #endif #if HEATER_USES_AD595 EEPROM_WRITE_VAR(i, ad595_offset); EEPROM_WRITE_VAR(i, ad595_gain); #endif #if MECH(DELTA) EEPROM_WRITE_VAR(i, endstop_adj); EEPROM_WRITE_VAR(i, delta_radius); EEPROM_WRITE_VAR(i, delta_diagonal_rod); EEPROM_WRITE_VAR(i, sw_endstop_max); EEPROM_WRITE_VAR(i, tower_adj); EEPROM_WRITE_VAR(i, diagrod_adj); EEPROM_WRITE_VAR(i, z_probe_offset); #elif ENABLED(Z_DUAL_ENDSTOPS) EEPROM_WRITE_VAR(i, z_endstop_adj); // 1 floats #endif #if DISABLED(ULTIPANEL) int 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 EEPROM_WRITE_VAR(i, plaPreheatHotendTemp); EEPROM_WRITE_VAR(i, plaPreheatHPBTemp); EEPROM_WRITE_VAR(i, plaPreheatFanSpeed); EEPROM_WRITE_VAR(i, absPreheatHotendTemp); EEPROM_WRITE_VAR(i, absPreheatHPBTemp); EEPROM_WRITE_VAR(i, absPreheatFanSpeed); EEPROM_WRITE_VAR(i, gumPreheatHotendTemp); EEPROM_WRITE_VAR(i, gumPreheatHPBTemp); EEPROM_WRITE_VAR(i, gumPreheatFanSpeed); #if ENABLED(PIDTEMP) for (int h = 0; h < HOTENDS; h++) { EEPROM_WRITE_VAR(i, PID_PARAM(Kp, h)); EEPROM_WRITE_VAR(i, PID_PARAM(Ki, h)); EEPROM_WRITE_VAR(i, PID_PARAM(Kd, h)); EEPROM_WRITE_VAR(i, PID_PARAM(Kc, h)); } #endif #if DISABLED(PID_ADD_EXTRUSION_RATE) int lpq_len = 20; #endif EEPROM_WRITE_VAR(i, lpq_len); #if ENABLED(PIDTEMPBED) EEPROM_WRITE_VAR(i, bedKp); EEPROM_WRITE_VAR(i, bedKi); EEPROM_WRITE_VAR(i, bedKd); #endif #if HASNT(LCD_CONTRAST) const int lcd_contrast = 32; #endif EEPROM_WRITE_VAR(i, lcd_contrast); #if MECH(SCARA) EEPROM_WRITE_VAR(i, axis_scaling); // 3 floats #endif #if ENABLED(FWRETRACT) EEPROM_WRITE_VAR(i, autoretract_enabled); EEPROM_WRITE_VAR(i, retract_length); #if EXTRUDERS > 1 EEPROM_WRITE_VAR(i, retract_length_swap); #else dummy = 0.0f; EEPROM_WRITE_VAR(i, dummy); #endif EEPROM_WRITE_VAR(i, retract_feedrate); EEPROM_WRITE_VAR(i, retract_zlift); EEPROM_WRITE_VAR(i, retract_recover_length); #if EXTRUDERS > 1 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 EEPROM_WRITE_VAR(i, volumetric_enabled); // Save filament sizes for (int e = 0; e < EXTRUDERS; e++) EEPROM_WRITE_VAR(i, filament_size[e]); #if ENABLED(IDLE_OOZING_PREVENT) EEPROM_WRITE_VAR(i, IDLE_OOZING_enabled); #endif #if MB(ALLIGATOR) EEPROM_WRITE_VAR(i, motor_current); #endif char ver2[7] = EEPROM_VERSION; int j = EEPROM_OFFSET; EEPROM_WRITE_VAR(j, ver2); // validate data // Report storage size ECHO_SMV(DB, "Settings Stored (", (unsigned long)i); ECHO_EM(" bytes)"); }