2015-01-28 03:08:48 -06:00
|
|
|
/**
|
2015-04-25 23:04:54 -05:00
|
|
|
* configuration_store.cpp
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
|
|
|
|
* Configuration and EEPROM storage
|
|
|
|
|
*
|
2015-04-03 18:38:05 -05:00
|
|
|
* IMPORTANT: Whenever there are changes made to the variables stored in EEPROM
|
|
|
|
|
* in the functions below, also increment the version number. This makes sure that
|
|
|
|
|
* the default values are used whenever there is a change to the data, to prevent
|
|
|
|
|
* wrong data being written to the variables.
|
|
|
|
|
*
|
|
|
|
|
* ALSO: Variables in the Store and Retrieve sections must be in the same order.
|
|
|
|
|
* If a feature is disabled, some data must still be written that, when read,
|
|
|
|
|
* either sets a Sane Default, or results in No Change to the existing value.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
2015-08-30 21:04:30 -05:00
|
|
|
#define EEPROM_VERSION "V21"
|
2015-04-03 18:38:05 -05:00
|
|
|
|
|
|
|
|
/**
|
2016-02-17 15:05:12 -06:00
|
|
|
* V21 EEPROM Layout:
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
2016-02-17 15:05:12 -06:00
|
|
|
* 100 Version (char x4)
|
|
|
|
|
*
|
|
|
|
|
* 104 M92 XYZE axis_steps_per_unit (float x4)
|
|
|
|
|
* 120 M203 XYZE max_feedrate (float x4)
|
|
|
|
|
* 136 M201 XYZE max_acceleration_units_per_sq_second (uint32_t x4)
|
|
|
|
|
* 152 M204 P acceleration (float)
|
|
|
|
|
* 156 M204 R retract_acceleration (float)
|
|
|
|
|
* 160 M204 T travel_acceleration (float)
|
|
|
|
|
* 164 M205 S minimumfeedrate (float)
|
|
|
|
|
* 168 M205 T mintravelfeedrate (float)
|
|
|
|
|
* 172 M205 B minsegmenttime (ulong)
|
|
|
|
|
* 176 M205 X max_xy_jerk (float)
|
|
|
|
|
* 180 M205 Z max_z_jerk (float)
|
|
|
|
|
* 184 M205 E max_e_jerk (float)
|
|
|
|
|
* 188 M206 XYZ home_offset (float x3)
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
2015-03-15 17:18:11 -05:00
|
|
|
* Mesh bed leveling:
|
2016-02-17 15:05:12 -06:00
|
|
|
* 200 M420 S active (bool)
|
|
|
|
|
* 201 mesh_num_x (uint8 as set in firmware)
|
|
|
|
|
* 202 mesh_num_y (uint8 as set in firmware)
|
|
|
|
|
* 203 M421 XYZ z_values[][] (float x9, by default)
|
|
|
|
|
* 239 M851 zprobe_zoffset (float)
|
2015-03-15 17:18:11 -05:00
|
|
|
*
|
2015-01-28 03:08:48 -06:00
|
|
|
* DELTA:
|
2016-02-17 15:05:12 -06:00
|
|
|
* 243 M666 XYZ endstop_adj (float x3)
|
|
|
|
|
* 255 M665 R delta_radius (float)
|
|
|
|
|
* 259 M665 L delta_diagonal_rod (float)
|
|
|
|
|
* 263 M665 S delta_segments_per_second (float)
|
|
|
|
|
*
|
|
|
|
|
* Z_DUAL_ENDSTOPS:
|
|
|
|
|
* 267 M666 Z z_endstop_adj (float)
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
|
|
|
|
* ULTIPANEL:
|
2016-02-17 15:05:12 -06:00
|
|
|
* 271 M145 S0 H plaPreheatHotendTemp (int)
|
|
|
|
|
* 273 M145 S0 B plaPreheatHPBTemp (int)
|
|
|
|
|
* 275 M145 S0 F plaPreheatFanSpeed (int)
|
|
|
|
|
* 277 M145 S1 H absPreheatHotendTemp (int)
|
|
|
|
|
* 279 M145 S1 B absPreheatHPBTemp (int)
|
|
|
|
|
* 281 M145 S1 F absPreheatFanSpeed (int)
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
|
|
|
|
* PIDTEMP:
|
2016-02-17 15:05:12 -06:00
|
|
|
* 283 M301 E0 PIDC Kp[0], Ki[0], Kd[0], Kc[0] (float x4)
|
|
|
|
|
* 299 M301 E1 PIDC Kp[1], Ki[1], Kd[1], Kc[1] (float x4)
|
|
|
|
|
* 315 M301 E2 PIDC Kp[2], Ki[2], Kd[2], Kc[2] (float x4)
|
|
|
|
|
* 331 M301 E3 PIDC Kp[3], Ki[3], Kd[3], Kc[3] (float x4)
|
|
|
|
|
* 347 M301 L lpq_len (int)
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
2015-04-03 18:38:05 -05:00
|
|
|
* PIDTEMPBED:
|
2016-02-17 15:05:12 -06:00
|
|
|
* 349 M304 PID bedKp, bedKi, bedKd (float x3)
|
2015-04-03 18:38:05 -05:00
|
|
|
*
|
2015-01-28 03:08:48 -06:00
|
|
|
* DOGLCD:
|
2016-02-17 15:05:12 -06:00
|
|
|
* 361 M250 C lcd_contrast (int)
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
|
|
|
|
* SCARA:
|
2016-02-17 15:05:12 -06:00
|
|
|
* 363 M365 XYZ axis_scaling (float x3)
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
|
|
|
|
* FWRETRACT:
|
2016-02-17 15:05:12 -06:00
|
|
|
* 375 M209 S autoretract_enabled (bool)
|
|
|
|
|
* 376 M207 S retract_length (float)
|
|
|
|
|
* 380 M207 W retract_length_swap (float)
|
|
|
|
|
* 384 M207 F retract_feedrate (float)
|
|
|
|
|
* 388 M207 Z retract_zlift (float)
|
|
|
|
|
* 392 M208 S retract_recover_length (float)
|
|
|
|
|
* 396 M208 W retract_recover_length_swap (float)
|
|
|
|
|
* 400 M208 F retract_recover_feedrate (float)
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
2016-02-17 15:05:12 -06:00
|
|
|
* Volumetric Extrusion:
|
|
|
|
|
* 404 M200 D volumetric_enabled (bool)
|
|
|
|
|
* 405 M200 T D filament_size (float x4) (T0..3)
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
2016-02-17 15:05:12 -06:00
|
|
|
* 421 This Slot is Available!
|
2015-03-24 12:06:44 -05:00
|
|
|
*
|
2015-01-28 03:08:48 -06:00
|
|
|
*/
|
2012-11-07 16:16:43 -06:00
|
|
|
#include "Marlin.h"
|
2015-01-28 23:19:51 -06:00
|
|
|
#include "language.h"
|
2012-11-07 16:16:43 -06:00
|
|
|
#include "planner.h"
|
|
|
|
|
#include "temperature.h"
|
|
|
|
|
#include "ultralcd.h"
|
2015-04-25 23:04:54 -05:00
|
|
|
#include "configuration_store.h"
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2015-04-27 21:48:34 -05:00
|
|
|
#include "mesh_bed_leveling.h"
|
|
|
|
|
#endif
|
2015-03-15 17:18:11 -05:00
|
|
|
|
2015-01-28 03:08:48 -06:00
|
|
|
void _EEPROM_writeData(int &pos, uint8_t* value, uint8_t size) {
|
2015-01-28 23:19:51 -06:00
|
|
|
uint8_t c;
|
2015-10-03 01:08:58 -05:00
|
|
|
while (size--) {
|
2015-01-28 03:08:48 -06:00
|
|
|
eeprom_write_byte((unsigned char*)pos, *value);
|
2015-01-29 00:27:15 -06:00
|
|
|
c = eeprom_read_byte((unsigned char*)pos);
|
|
|
|
|
if (c != *value) {
|
2015-01-28 23:19:51 -06:00
|
|
|
SERIAL_ECHO_START;
|
|
|
|
|
SERIAL_ECHOLNPGM(MSG_ERR_EEPROM_WRITE);
|
|
|
|
|
}
|
2015-01-28 03:08:48 -06:00
|
|
|
pos++;
|
|
|
|
|
value++;
|
2015-01-28 23:19:51 -06:00
|
|
|
};
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
}
|
2015-01-28 03:08:48 -06:00
|
|
|
void _EEPROM_readData(int &pos, uint8_t* value, uint8_t size) {
|
|
|
|
|
do {
|
|
|
|
|
*value = eeprom_read_byte((unsigned char*)pos);
|
|
|
|
|
pos++;
|
|
|
|
|
value++;
|
|
|
|
|
} while (--size);
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
}
|
2015-01-28 03:08:48 -06:00
|
|
|
#define EEPROM_WRITE_VAR(pos, value) _EEPROM_writeData(pos, (uint8_t*)&value, sizeof(value))
|
2012-11-07 16:16:43 -06:00
|
|
|
#define EEPROM_READ_VAR(pos, value) _EEPROM_readData(pos, (uint8_t*)&value, sizeof(value))
|
|
|
|
|
|
2015-04-26 20:44:01 -05:00
|
|
|
/**
|
|
|
|
|
* Store Configuration Settings - M500
|
|
|
|
|
*/
|
2012-11-07 16:16:43 -06:00
|
|
|
|
2015-01-28 03:08:48 -06:00
|
|
|
#define DUMMY_PID_VALUE 3000.0f
|
2012-11-07 16:16:43 -06:00
|
|
|
|
|
|
|
|
#define EEPROM_OFFSET 100
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(EEPROM_SETTINGS)
|
2015-01-28 03:08:48 -06:00
|
|
|
|
2016-02-17 15:05:12 -06:00
|
|
|
/**
|
|
|
|
|
* Store Configuration Settings - M500
|
|
|
|
|
*/
|
|
|
|
|
|
2015-01-28 03:08:48 -06:00
|
|
|
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);
|
2015-03-11 11:19:02 -05:00
|
|
|
EEPROM_WRITE_VAR(i, travel_acceleration);
|
2015-01-28 03:08:48 -06:00
|
|
|
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);
|
2015-03-21 18:30:02 -05:00
|
|
|
EEPROM_WRITE_VAR(i, home_offset);
|
2015-01-28 03:08:48 -06:00
|
|
|
|
2015-03-18 15:00:31 -05:00
|
|
|
uint8_t mesh_num_x = 3;
|
|
|
|
|
uint8_t mesh_num_y = 3;
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2015-03-18 15:00:31 -05:00
|
|
|
// Compile time test that sizeof(mbl.z_values) is as expected
|
2015-10-03 01:08:58 -05:00
|
|
|
typedef char c_assert[(sizeof(mbl.z_values) == MESH_NUM_X_POINTS * MESH_NUM_Y_POINTS * sizeof(dummy)) ? 1 : -1];
|
2015-03-18 15:00:31 -05:00
|
|
|
mesh_num_x = MESH_NUM_X_POINTS;
|
|
|
|
|
mesh_num_y = MESH_NUM_Y_POINTS;
|
2015-03-15 17:18:11 -05:00
|
|
|
EEPROM_WRITE_VAR(i, mbl.active);
|
2015-03-18 15:00:31 -05:00
|
|
|
EEPROM_WRITE_VAR(i, mesh_num_x);
|
|
|
|
|
EEPROM_WRITE_VAR(i, mesh_num_y);
|
2015-03-15 17:18:11 -05:00
|
|
|
EEPROM_WRITE_VAR(i, mbl.z_values);
|
2015-03-18 15:00:31 -05:00
|
|
|
#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;
|
2015-10-03 01:08:58 -05:00
|
|
|
for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_WRITE_VAR(i, dummy);
|
2015-03-25 23:14:00 -05:00
|
|
|
#endif // MESH_BED_LEVELING
|
|
|
|
|
|
2015-08-05 07:12:26 -05:00
|
|
|
#if DISABLED(AUTO_BED_LEVELING_FEATURE)
|
2015-03-25 23:14:00 -05:00
|
|
|
float zprobe_zoffset = 0;
|
|
|
|
|
#endif
|
|
|
|
|
EEPROM_WRITE_VAR(i, zprobe_zoffset);
|
2015-03-15 17:18:11 -05:00
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(DELTA)
|
2015-01-28 03:08:48 -06:00
|
|
|
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
|
2015-07-31 00:31:45 -05:00
|
|
|
#elif ENABLED(Z_DUAL_ENDSTOPS)
|
2015-03-24 12:06:44 -05:00
|
|
|
EEPROM_WRITE_VAR(i, z_endstop_adj); // 1 floats
|
|
|
|
|
dummy = 0.0f;
|
2016-02-17 15:05:12 -06:00
|
|
|
for (uint8_t q = 5; q--;) EEPROM_WRITE_VAR(i, dummy);
|
2015-01-28 03:08:48 -06:00
|
|
|
#else
|
|
|
|
|
dummy = 0.0f;
|
2016-02-17 15:05:12 -06:00
|
|
|
for (uint8_t q = 6; q--;) EEPROM_WRITE_VAR(i, dummy);
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if DISABLED(ULTIPANEL)
|
2015-01-28 03:08:48 -06:00
|
|
|
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);
|
2015-03-25 23:14:00 -05:00
|
|
|
|
2016-02-17 15:05:12 -06:00
|
|
|
for (uint8_t e = 0; e < 4; e++) {
|
2015-01-28 03:08:48 -06:00
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(PIDTEMP)
|
2015-01-28 03:08:48 -06:00
|
|
|
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));
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(PID_ADD_EXTRUSION_RATE)
|
2015-01-28 03:08:48 -06:00
|
|
|
EEPROM_WRITE_VAR(i, PID_PARAM(Kc, e));
|
|
|
|
|
#else
|
|
|
|
|
dummy = 1.0f; // 1.0 = default kc
|
2015-02-06 16:43:58 -06:00
|
|
|
EEPROM_WRITE_VAR(i, dummy);
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif
|
|
|
|
|
}
|
2015-04-03 18:38:05 -05:00
|
|
|
else
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif // !PIDTEMP
|
2015-04-03 18:38:05 -05:00
|
|
|
{
|
|
|
|
|
dummy = DUMMY_PID_VALUE; // When read, will not change the existing value
|
2015-01-28 22:48:32 -06:00
|
|
|
EEPROM_WRITE_VAR(i, dummy);
|
|
|
|
|
dummy = 0.0f;
|
2016-02-17 15:05:12 -06:00
|
|
|
for (uint8_t q = 3; q--;) EEPROM_WRITE_VAR(i, dummy);
|
2015-01-28 22:48:32 -06:00
|
|
|
}
|
|
|
|
|
|
2015-01-28 03:08:48 -06:00
|
|
|
} // Extruders Loop
|
|
|
|
|
|
2015-08-30 21:04:30 -05:00
|
|
|
#if DISABLED(PID_ADD_EXTRUSION_RATE)
|
|
|
|
|
int lpq_len = 20;
|
|
|
|
|
#endif
|
|
|
|
|
EEPROM_WRITE_VAR(i, lpq_len);
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if DISABLED(PIDTEMPBED)
|
2015-04-03 18:38:05 -05:00
|
|
|
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);
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if DISABLED(HAS_LCD_CONTRAST)
|
|
|
|
|
const int lcd_contrast = 32;
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif
|
|
|
|
|
EEPROM_WRITE_VAR(i, lcd_contrast);
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(SCARA)
|
2015-01-28 03:08:48 -06:00
|
|
|
EEPROM_WRITE_VAR(i, axis_scaling); // 3 floats
|
|
|
|
|
#else
|
|
|
|
|
dummy = 1.0f;
|
|
|
|
|
EEPROM_WRITE_VAR(i, dummy);
|
|
|
|
|
#endif
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(FWRETRACT)
|
2015-01-28 03:08:48 -06:00
|
|
|
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
|
2014-12-28 19:43:14 -06:00
|
|
|
|
|
|
|
|
EEPROM_WRITE_VAR(i, volumetric_enabled);
|
2015-01-28 03:08:48 -06:00
|
|
|
|
|
|
|
|
// Save filament sizes
|
2016-02-17 15:05:12 -06:00
|
|
|
for (uint8_t q = 0; q < 4; q++) {
|
2015-01-28 03:08:48 -06:00
|
|
|
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
|
2012-11-07 16:16:43 -06:00
|
|
|
SERIAL_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
SERIAL_ECHOPAIR("Settings Stored (", (unsigned long)i);
|
|
|
|
|
SERIAL_ECHOLNPGM(" bytes)");
|
2012-11-07 16:16:43 -06:00
|
|
|
}
|
|
|
|
|
|
2015-04-26 20:44:01 -05:00
|
|
|
/**
|
|
|
|
|
* Retrieve Configuration Settings - M501
|
|
|
|
|
*/
|
|
|
|
|
|
2015-01-28 03:08:48 -06:00
|
|
|
void Config_RetrieveSettings() {
|
2012-11-07 16:16:43 -06:00
|
|
|
|
2015-01-28 03:08:48 -06:00
|
|
|
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);
|
|
|
|
|
|
2015-03-15 17:18:11 -05:00
|
|
|
// 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)
|
2015-01-28 03:08:48 -06:00
|
|
|
reset_acceleration_rates();
|
|
|
|
|
|
|
|
|
|
EEPROM_READ_VAR(i, acceleration);
|
|
|
|
|
EEPROM_READ_VAR(i, retract_acceleration);
|
2015-03-11 11:19:02 -05:00
|
|
|
EEPROM_READ_VAR(i, travel_acceleration);
|
2015-01-28 03:08:48 -06:00
|
|
|
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);
|
2015-03-21 18:30:02 -05:00
|
|
|
EEPROM_READ_VAR(i, home_offset);
|
2015-01-28 03:08:48 -06:00
|
|
|
|
2015-04-26 23:06:04 -05:00
|
|
|
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);
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2015-04-26 23:06:04 -05:00
|
|
|
mbl.active = dummy_uint8;
|
|
|
|
|
if (mesh_num_x == MESH_NUM_X_POINTS && mesh_num_y == MESH_NUM_Y_POINTS) {
|
2015-03-18 15:00:31 -05:00
|
|
|
EEPROM_READ_VAR(i, mbl.z_values);
|
2015-04-26 23:06:04 -05:00
|
|
|
} else {
|
|
|
|
|
mbl.reset();
|
2016-02-17 15:05:12 -06:00
|
|
|
for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_READ_VAR(i, dummy);
|
2015-03-18 15:00:31 -05:00
|
|
|
}
|
|
|
|
|
#else
|
2016-02-17 15:05:12 -06:00
|
|
|
for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_READ_VAR(i, dummy);
|
2015-04-26 23:06:04 -05:00
|
|
|
#endif // MESH_BED_LEVELING
|
2015-03-15 17:18:11 -05:00
|
|
|
|
2015-08-05 07:12:26 -05:00
|
|
|
#if DISABLED(AUTO_BED_LEVELING_FEATURE)
|
2015-03-25 23:14:00 -05:00
|
|
|
float zprobe_zoffset = 0;
|
|
|
|
|
#endif
|
|
|
|
|
EEPROM_READ_VAR(i, zprobe_zoffset);
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(DELTA)
|
2015-01-28 03:08:48 -06:00
|
|
|
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
|
2015-07-31 00:31:45 -05:00
|
|
|
#elif ENABLED(Z_DUAL_ENDSTOPS)
|
2015-03-24 12:06:44 -05:00
|
|
|
EEPROM_READ_VAR(i, z_endstop_adj);
|
|
|
|
|
dummy = 0.0f;
|
2016-02-17 15:05:12 -06:00
|
|
|
for (uint8_t q=5; q--;) EEPROM_READ_VAR(i, dummy);
|
2015-01-28 03:08:48 -06:00
|
|
|
#else
|
2015-03-24 12:06:44 -05:00
|
|
|
dummy = 0.0f;
|
2016-02-17 15:05:12 -06:00
|
|
|
for (uint8_t q=6; q--;) EEPROM_READ_VAR(i, dummy);
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if DISABLED(ULTIPANEL)
|
2015-01-28 03:08:48 -06:00
|
|
|
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);
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(PIDTEMP)
|
2016-02-17 15:05:12 -06:00
|
|
|
for (uint8_t e = 0; e < 4; e++) { // 4 = max extruders currently supported by Marlin
|
2015-04-03 18:38:05 -05:00
|
|
|
EEPROM_READ_VAR(i, dummy); // Kp
|
2015-01-28 03:08:48 -06:00
|
|
|
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));
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(PID_ADD_EXTRUSION_RATE)
|
2015-01-28 03:08:48 -06:00
|
|
|
EEPROM_READ_VAR(i, PID_PARAM(Kc, e));
|
|
|
|
|
#else
|
|
|
|
|
EEPROM_READ_VAR(i, dummy);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
else {
|
2016-02-17 15:05:12 -06:00
|
|
|
for (uint8_t q=3; q--;) EEPROM_READ_VAR(i, dummy); // Ki, Kd, Kc
|
2015-01-28 03:08:48 -06:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#else // !PIDTEMP
|
2015-01-28 22:48:32 -06:00
|
|
|
// 4 x 4 = 16 slots for PID parameters
|
2016-02-17 15:05:12 -06:00
|
|
|
for (uint8_t q=16; q--;) EEPROM_READ_VAR(i, dummy); // 4x Kp, Ki, Kd, Kc
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif // !PIDTEMP
|
|
|
|
|
|
2015-08-30 21:04:30 -05:00
|
|
|
#if DISABLED(PID_ADD_EXTRUSION_RATE)
|
|
|
|
|
int lpq_len;
|
|
|
|
|
#endif
|
|
|
|
|
EEPROM_READ_VAR(i, lpq_len);
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if DISABLED(PIDTEMPBED)
|
2015-04-03 18:38:05 -05:00
|
|
|
float bedKp, bedKi, bedKd;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
EEPROM_READ_VAR(i, dummy); // bedKp
|
|
|
|
|
if (dummy != DUMMY_PID_VALUE) {
|
2015-10-13 05:56:07 -05:00
|
|
|
bedKp = dummy; UNUSED(bedKp);
|
2015-04-03 18:38:05 -05:00
|
|
|
EEPROM_READ_VAR(i, bedKi);
|
|
|
|
|
EEPROM_READ_VAR(i, bedKd);
|
|
|
|
|
}
|
|
|
|
|
else {
|
2016-02-17 15:05:12 -06:00
|
|
|
for (uint8_t q=2; q--;) EEPROM_READ_VAR(i, dummy); // bedKi, bedKd
|
2015-04-03 18:38:05 -05:00
|
|
|
}
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if DISABLED(HAS_LCD_CONTRAST)
|
2015-01-28 03:08:48 -06:00
|
|
|
int lcd_contrast;
|
|
|
|
|
#endif
|
|
|
|
|
EEPROM_READ_VAR(i, lcd_contrast);
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(SCARA)
|
2015-01-28 03:08:48 -06:00
|
|
|
EEPROM_READ_VAR(i, axis_scaling); // 3 floats
|
|
|
|
|
#else
|
|
|
|
|
EEPROM_READ_VAR(i, dummy);
|
|
|
|
|
#endif
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(FWRETRACT)
|
2015-01-28 03:08:48 -06:00
|
|
|
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);
|
|
|
|
|
|
2016-02-17 15:05:12 -06:00
|
|
|
for (uint8_t q = 0; q < 4; q++) {
|
2015-01-28 03:08:48 -06:00
|
|
|
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
|
2012-11-07 16:16:43 -06:00
|
|
|
SERIAL_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
SERIAL_ECHO(ver);
|
|
|
|
|
SERIAL_ECHOPAIR(" stored settings retrieved (", (unsigned long)i);
|
|
|
|
|
SERIAL_ECHOLNPGM(" bytes)");
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(EEPROM_CHITCHAT)
|
2015-01-28 03:08:48 -06:00
|
|
|
Config_PrintSettings();
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif // EEPROM_SETTINGS
|
|
|
|
|
|
2015-04-26 20:44:01 -05:00
|
|
|
/**
|
|
|
|
|
* Reset Configuration Settings - M502
|
|
|
|
|
*/
|
|
|
|
|
|
2015-01-28 03:08:48 -06:00
|
|
|
void Config_ResetDefault() {
|
|
|
|
|
float tmp1[] = DEFAULT_AXIS_STEPS_PER_UNIT;
|
|
|
|
|
float tmp2[] = DEFAULT_MAX_FEEDRATE;
|
|
|
|
|
long tmp3[] = DEFAULT_MAX_ACCELERATION;
|
2015-08-11 11:38:26 -05:00
|
|
|
for (uint8_t i = 0; i < NUM_AXIS; i++) {
|
2015-01-28 03:08:48 -06:00
|
|
|
axis_steps_per_unit[i] = tmp1[i];
|
|
|
|
|
max_feedrate[i] = tmp2[i];
|
|
|
|
|
max_acceleration_units_per_sq_second[i] = tmp3[i];
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(SCARA)
|
2015-07-22 17:50:20 -05:00
|
|
|
if (i < COUNT(axis_scaling))
|
2015-01-28 03:08:48 -06:00
|
|
|
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;
|
2015-03-11 11:19:02 -05:00
|
|
|
travel_acceleration = DEFAULT_TRAVEL_ACCELERATION;
|
2015-01-28 03:08:48 -06:00
|
|
|
minimumfeedrate = DEFAULT_MINIMUMFEEDRATE;
|
|
|
|
|
minsegmenttime = DEFAULT_MINSEGMENTTIME;
|
|
|
|
|
mintravelfeedrate = DEFAULT_MINTRAVELFEEDRATE;
|
|
|
|
|
max_xy_jerk = DEFAULT_XYJERK;
|
|
|
|
|
max_z_jerk = DEFAULT_ZJERK;
|
|
|
|
|
max_e_jerk = DEFAULT_EJERK;
|
2015-03-21 18:30:02 -05:00
|
|
|
home_offset[X_AXIS] = home_offset[Y_AXIS] = home_offset[Z_AXIS] = 0;
|
2015-01-28 03:08:48 -06:00
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2015-03-15 17:18:11 -05:00
|
|
|
mbl.active = 0;
|
2015-03-26 01:06:33 -05:00
|
|
|
#endif
|
|
|
|
|
|
2015-08-05 07:12:26 -05:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_FEATURE)
|
2015-05-26 19:47:04 -05:00
|
|
|
zprobe_zoffset = Z_PROBE_OFFSET_FROM_EXTRUDER;
|
2015-03-26 01:06:33 -05:00
|
|
|
#endif
|
2015-03-15 17:18:11 -05:00
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(DELTA)
|
2015-01-28 03:08:48 -06:00
|
|
|
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);
|
2015-07-31 00:31:45 -05:00
|
|
|
#elif ENABLED(Z_DUAL_ENDSTOPS)
|
2015-03-24 12:06:44 -05:00
|
|
|
z_endstop_adj = 0;
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(ULTIPANEL)
|
2015-01-28 03:08:48 -06:00
|
|
|
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
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(HAS_LCD_CONTRAST)
|
2015-01-28 03:08:48 -06:00
|
|
|
lcd_contrast = DEFAULT_LCD_CONTRAST;
|
|
|
|
|
#endif
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(PIDTEMP)
|
|
|
|
|
#if ENABLED(PID_PARAMS_PER_EXTRUDER)
|
2016-02-17 15:05:12 -06:00
|
|
|
for (uint8_t e = 0; e < EXTRUDERS; e++)
|
2015-01-28 03:08:48 -06:00
|
|
|
#else
|
2015-10-13 05:56:07 -05:00
|
|
|
int e = 0; UNUSED(e); // only need to write once
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif
|
|
|
|
|
{
|
|
|
|
|
PID_PARAM(Kp, e) = DEFAULT_Kp;
|
|
|
|
|
PID_PARAM(Ki, e) = scalePID_i(DEFAULT_Ki);
|
|
|
|
|
PID_PARAM(Kd, e) = scalePID_d(DEFAULT_Kd);
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(PID_ADD_EXTRUSION_RATE)
|
2015-01-28 03:08:48 -06:00
|
|
|
PID_PARAM(Kc, e) = DEFAULT_Kc;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
2015-08-30 21:04:30 -05:00
|
|
|
#if ENABLED(PID_ADD_EXTRUSION_RATE)
|
|
|
|
|
lpq_len = 20; // default last-position-queue size
|
|
|
|
|
#endif
|
2015-01-28 03:08:48 -06:00
|
|
|
// call updatePID (similar to when we have processed M301)
|
|
|
|
|
updatePID();
|
|
|
|
|
#endif // PIDTEMP
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(PIDTEMPBED)
|
2015-04-03 18:38:05 -05:00
|
|
|
bedKp = DEFAULT_bedKp;
|
|
|
|
|
bedKi = scalePID_i(DEFAULT_bedKi);
|
|
|
|
|
bedKd = scalePID_d(DEFAULT_bedKd);
|
|
|
|
|
#endif
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(FWRETRACT)
|
2015-01-28 03:08:48 -06:00
|
|
|
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;
|
2015-10-03 01:08:58 -05:00
|
|
|
for (uint8_t q = 0; q < COUNT(filament_size); q++)
|
2015-07-23 20:08:06 -05:00
|
|
|
filament_size[q] = DEFAULT_NOMINAL_FILAMENT_DIA;
|
2015-01-28 03:08:48 -06:00
|
|
|
calculate_volumetric_multipliers();
|
|
|
|
|
|
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
|
SERIAL_ECHOLNPGM("Hardcoded Default Settings Loaded");
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if DISABLED(DISABLE_M503)
|
2015-01-28 03:08:48 -06:00
|
|
|
|
2015-04-26 20:44:01 -05:00
|
|
|
/**
|
|
|
|
|
* Print Configuration Settings - M503
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#define CONFIG_ECHO_START do{ if (!forReplay) SERIAL_ECHO_START; }while(0)
|
|
|
|
|
|
2015-01-28 03:08:48 -06:00
|
|
|
void Config_PrintSettings(bool forReplay) {
|
|
|
|
|
// Always have this function, even with EEPROM_SETTINGS disabled, the current values will be shown
|
|
|
|
|
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
|
|
|
|
|
if (!forReplay) {
|
2012-11-07 16:16:43 -06:00
|
|
|
SERIAL_ECHOLNPGM("Steps per unit:");
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
}
|
|
|
|
|
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]);
|
2015-01-28 23:19:51 -06:00
|
|
|
SERIAL_EOL;
|
2015-01-28 03:08:48 -06:00
|
|
|
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(SCARA)
|
2015-01-28 03:08:48 -06:00
|
|
|
if (!forReplay) {
|
|
|
|
|
SERIAL_ECHOLNPGM("Scaling factors:");
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
}
|
|
|
|
|
SERIAL_ECHOPAIR(" M365 X", axis_scaling[X_AXIS]);
|
|
|
|
|
SERIAL_ECHOPAIR(" Y", axis_scaling[Y_AXIS]);
|
|
|
|
|
SERIAL_ECHOPAIR(" Z", axis_scaling[Z_AXIS]);
|
2015-01-28 23:19:51 -06:00
|
|
|
SERIAL_EOL;
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif // SCARA
|
|
|
|
|
|
|
|
|
|
if (!forReplay) {
|
2012-11-07 16:16:43 -06:00
|
|
|
SERIAL_ECHOLNPGM("Maximum feedrates (mm/s):");
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
}
|
|
|
|
|
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]);
|
2015-01-28 23:19:51 -06:00
|
|
|
SERIAL_EOL;
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
if (!forReplay) {
|
2012-11-07 16:16:43 -06:00
|
|
|
SERIAL_ECHOLNPGM("Maximum Acceleration (mm/s2):");
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
}
|
2015-04-26 20:44:01 -05:00
|
|
|
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]);
|
2015-01-28 03:08:48 -06:00
|
|
|
SERIAL_ECHOPAIR(" E", max_acceleration_units_per_sq_second[E_AXIS]);
|
2015-01-28 23:19:51 -06:00
|
|
|
SERIAL_EOL;
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
if (!forReplay) {
|
2015-03-11 11:19:02 -05:00
|
|
|
SERIAL_ECHOLNPGM("Accelerations: P=printing, R=retract and T=travel");
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
}
|
2015-04-26 20:44:01 -05:00
|
|
|
SERIAL_ECHOPAIR(" M204 P", acceleration);
|
2015-03-11 11:19:02 -05:00
|
|
|
SERIAL_ECHOPAIR(" R", retract_acceleration);
|
|
|
|
|
SERIAL_ECHOPAIR(" T", travel_acceleration);
|
2015-01-28 23:19:51 -06:00
|
|
|
SERIAL_EOL;
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
if (!forReplay) {
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
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)");
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
}
|
2015-04-26 20:44:01 -05:00
|
|
|
SERIAL_ECHOPAIR(" M205 S", minimumfeedrate);
|
|
|
|
|
SERIAL_ECHOPAIR(" T", mintravelfeedrate);
|
|
|
|
|
SERIAL_ECHOPAIR(" B", minsegmenttime);
|
|
|
|
|
SERIAL_ECHOPAIR(" X", max_xy_jerk);
|
2015-01-28 03:08:48 -06:00
|
|
|
SERIAL_ECHOPAIR(" Z", max_z_jerk);
|
|
|
|
|
SERIAL_ECHOPAIR(" E", max_e_jerk);
|
2015-01-28 23:19:51 -06:00
|
|
|
SERIAL_EOL;
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
if (!forReplay) {
|
2012-11-07 16:16:43 -06:00
|
|
|
SERIAL_ECHOLNPGM("Home offset (mm):");
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
}
|
2015-04-26 20:44:01 -05:00
|
|
|
SERIAL_ECHOPAIR(" M206 X", home_offset[X_AXIS]);
|
|
|
|
|
SERIAL_ECHOPAIR(" Y", home_offset[Y_AXIS]);
|
|
|
|
|
SERIAL_ECHOPAIR(" Z", home_offset[Z_AXIS]);
|
2015-01-28 23:19:51 -06:00
|
|
|
SERIAL_EOL;
|
2015-01-28 03:08:48 -06:00
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2015-04-26 20:44:01 -05:00
|
|
|
if (!forReplay) {
|
|
|
|
|
SERIAL_ECHOLNPGM("Mesh bed leveling:");
|
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
|
}
|
2015-04-29 20:26:16 -05:00
|
|
|
SERIAL_ECHOPAIR(" M420 S", (unsigned long)mbl.active);
|
2015-05-01 23:15:26 -05:00
|
|
|
SERIAL_ECHOPAIR(" X", (unsigned long)MESH_NUM_X_POINTS);
|
|
|
|
|
SERIAL_ECHOPAIR(" Y", (unsigned long)MESH_NUM_Y_POINTS);
|
2015-04-26 20:44:01 -05:00
|
|
|
SERIAL_EOL;
|
2016-02-17 15:05:12 -06:00
|
|
|
for (uint8_t y = 0; y < MESH_NUM_Y_POINTS; y++) {
|
|
|
|
|
for (uint8_t x = 0; x < MESH_NUM_X_POINTS; x++) {
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-04-27 21:48:34 -05:00
|
|
|
SERIAL_ECHOPAIR(" M421 X", mbl.get_x(x));
|
|
|
|
|
SERIAL_ECHOPAIR(" Y", mbl.get_y(y));
|
2015-04-26 20:44:01 -05:00
|
|
|
SERIAL_ECHOPAIR(" Z", mbl.z_values[y][x]);
|
|
|
|
|
SERIAL_EOL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(DELTA)
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
if (!forReplay) {
|
2015-04-09 04:04:06 -05:00
|
|
|
SERIAL_ECHOLNPGM("Endstop adjustment (mm):");
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
}
|
2015-04-26 20:44:01 -05:00
|
|
|
SERIAL_ECHOPAIR(" M666 X", endstop_adj[X_AXIS]);
|
|
|
|
|
SERIAL_ECHOPAIR(" Y", endstop_adj[Y_AXIS]);
|
|
|
|
|
SERIAL_ECHOPAIR(" Z", endstop_adj[Z_AXIS]);
|
2015-01-28 23:19:51 -06:00
|
|
|
SERIAL_EOL;
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2016-02-17 15:05:12 -06:00
|
|
|
if (!forReplay) {
|
|
|
|
|
SERIAL_ECHOLNPGM("Delta settings: L=delta_diagonal_rod, R=delta_radius, S=delta_segments_per_second");
|
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
|
}
|
2015-04-26 20:44:01 -05:00
|
|
|
SERIAL_ECHOPAIR(" M665 L", delta_diagonal_rod);
|
|
|
|
|
SERIAL_ECHOPAIR(" R", delta_radius);
|
|
|
|
|
SERIAL_ECHOPAIR(" S", delta_segments_per_second);
|
2015-01-28 23:19:51 -06:00
|
|
|
SERIAL_EOL;
|
2015-07-31 00:31:45 -05:00
|
|
|
#elif ENABLED(Z_DUAL_ENDSTOPS)
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-03-24 12:06:44 -05:00
|
|
|
if (!forReplay) {
|
2015-04-09 04:04:06 -05:00
|
|
|
SERIAL_ECHOLNPGM("Z2 Endstop adjustment (mm):");
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-03-24 12:06:44 -05:00
|
|
|
}
|
2015-04-26 20:44:01 -05:00
|
|
|
SERIAL_ECHOPAIR(" M666 Z", z_endstop_adj);
|
2015-10-03 01:08:58 -05:00
|
|
|
SERIAL_EOL;
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif // DELTA
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(ULTIPANEL)
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
|
if (!forReplay) {
|
|
|
|
|
SERIAL_ECHOLNPGM("Material heatup parameters:");
|
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
|
}
|
2016-02-28 00:28:08 -06:00
|
|
|
SERIAL_ECHOPAIR(" M145 S0 H", (unsigned long)plaPreheatHotendTemp);
|
2015-04-26 20:44:01 -05:00
|
|
|
SERIAL_ECHOPAIR(" B", (unsigned long)plaPreheatHPBTemp);
|
|
|
|
|
SERIAL_ECHOPAIR(" F", (unsigned long)plaPreheatFanSpeed);
|
|
|
|
|
SERIAL_EOL;
|
|
|
|
|
CONFIG_ECHO_START;
|
2016-02-28 00:28:08 -06:00
|
|
|
SERIAL_ECHOPAIR(" M145 S1 H", (unsigned long)absPreheatHotendTemp);
|
2015-04-26 20:44:01 -05:00
|
|
|
SERIAL_ECHOPAIR(" B", (unsigned long)absPreheatHPBTemp);
|
|
|
|
|
SERIAL_ECHOPAIR(" F", (unsigned long)absPreheatFanSpeed);
|
|
|
|
|
SERIAL_EOL;
|
|
|
|
|
#endif // ULTIPANEL
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(PIDTEMP) || ENABLED(PIDTEMPBED)
|
2015-04-26 20:44:01 -05:00
|
|
|
|
|
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
if (!forReplay) {
|
|
|
|
|
SERIAL_ECHOLNPGM("PID settings:");
|
|
|
|
|
}
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(PIDTEMP)
|
2015-04-26 20:44:01 -05:00
|
|
|
#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)));
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(PID_ADD_EXTRUSION_RATE)
|
2015-04-26 20:44:01 -05:00
|
|
|
SERIAL_ECHOPAIR(" C", PID_PARAM(Kc, i));
|
2015-08-30 21:04:30 -05:00
|
|
|
if (i == 0) SERIAL_ECHOPAIR(" L", lpq_len);
|
|
|
|
|
#endif
|
2015-04-26 20:44:01 -05:00
|
|
|
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)));
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(PID_ADD_EXTRUSION_RATE)
|
2015-04-26 20:44:01 -05:00
|
|
|
SERIAL_ECHOPAIR(" C", PID_PARAM(Kc, 0));
|
2015-08-30 21:04:30 -05:00
|
|
|
SERIAL_ECHOPAIR(" L", lpq_len);
|
|
|
|
|
#endif
|
2015-04-26 20:44:01 -05:00
|
|
|
SERIAL_EOL;
|
|
|
|
|
}
|
|
|
|
|
#endif // PIDTEMP
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(PIDTEMPBED)
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
|
SERIAL_ECHOPAIR(" M304 P", bedKp);
|
2015-04-03 18:38:05 -05:00
|
|
|
SERIAL_ECHOPAIR(" I", unscalePID_i(bedKi));
|
|
|
|
|
SERIAL_ECHOPAIR(" D", unscalePID_d(bedKd));
|
|
|
|
|
SERIAL_EOL;
|
|
|
|
|
#endif
|
2015-04-26 20:44:01 -05:00
|
|
|
|
|
|
|
|
#endif // PIDTEMP || PIDTEMPBED
|
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(HAS_LCD_CONTRAST)
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
|
if (!forReplay) {
|
|
|
|
|
SERIAL_ECHOLNPGM("LCD Contrast:");
|
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
|
}
|
|
|
|
|
SERIAL_ECHOPAIR(" M250 C", (unsigned long)lcd_contrast);
|
|
|
|
|
SERIAL_EOL;
|
2015-04-03 18:38:05 -05:00
|
|
|
#endif
|
2015-01-28 03:08:48 -06:00
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(FWRETRACT)
|
2015-01-28 03:08:48 -06:00
|
|
|
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
if (!forReplay) {
|
|
|
|
|
SERIAL_ECHOLNPGM("Retract: S=Length (mm) F:Speed (mm/m) Z: ZLift (mm)");
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
}
|
2015-04-03 18:41:58 -05:00
|
|
|
SERIAL_ECHOPAIR(" M207 S", retract_length);
|
2015-04-26 20:44:01 -05:00
|
|
|
#if EXTRUDERS > 1
|
|
|
|
|
SERIAL_ECHOPAIR(" W", retract_length_swap);
|
|
|
|
|
#endif
|
2015-10-03 01:08:58 -05:00
|
|
|
SERIAL_ECHOPAIR(" F", retract_feedrate * 60);
|
2015-01-28 03:08:48 -06:00
|
|
|
SERIAL_ECHOPAIR(" Z", retract_zlift);
|
2015-01-28 23:19:51 -06:00
|
|
|
SERIAL_EOL;
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
if (!forReplay) {
|
|
|
|
|
SERIAL_ECHOLNPGM("Recover: S=Extra length (mm) F:Speed (mm/m)");
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
}
|
2015-04-03 18:41:58 -05:00
|
|
|
SERIAL_ECHOPAIR(" M208 S", retract_recover_length);
|
2015-04-26 20:44:01 -05:00
|
|
|
#if EXTRUDERS > 1
|
|
|
|
|
SERIAL_ECHOPAIR(" W", retract_recover_length_swap);
|
|
|
|
|
#endif
|
2015-10-03 01:08:58 -05:00
|
|
|
SERIAL_ECHOPAIR(" F", retract_recover_feedrate * 60);
|
2015-01-28 23:19:51 -06:00
|
|
|
SERIAL_EOL;
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
if (!forReplay) {
|
|
|
|
|
SERIAL_ECHOLNPGM("Auto-Retract: S=0 to disable, 1 to interpret extrude-only moves as retracts or recoveries");
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 03:08:48 -06:00
|
|
|
}
|
2015-04-03 18:41:58 -05:00
|
|
|
SERIAL_ECHOPAIR(" M209 S", (unsigned long)(autoretract_enabled ? 1 : 0));
|
2015-01-28 23:19:51 -06:00
|
|
|
SERIAL_EOL;
|
2015-01-28 03:08:48 -06:00
|
|
|
|
|
|
|
|
#endif // FWRETRACT
|
2012-11-07 16:16:43 -06:00
|
|
|
|
2015-07-23 19:20:02 -05:00
|
|
|
/**
|
|
|
|
|
* Volumetric extrusion M200
|
|
|
|
|
*/
|
|
|
|
|
if (!forReplay) {
|
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
|
SERIAL_ECHOPGM("Filament settings:");
|
|
|
|
|
if (volumetric_enabled)
|
|
|
|
|
SERIAL_EOL;
|
|
|
|
|
else
|
|
|
|
|
SERIAL_ECHOLNPGM(" Disabled");
|
|
|
|
|
}
|
2015-04-26 20:44:01 -05:00
|
|
|
|
2015-07-23 19:20:02 -05:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
|
SERIAL_ECHOPAIR(" M200 D", filament_size[0]);
|
|
|
|
|
SERIAL_EOL;
|
|
|
|
|
#if EXTRUDERS > 1
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-07-23 19:20:02 -05:00
|
|
|
SERIAL_ECHOPAIR(" M200 T1 D", filament_size[1]);
|
2015-01-28 23:19:51 -06:00
|
|
|
SERIAL_EOL;
|
2015-07-23 19:20:02 -05:00
|
|
|
#if EXTRUDERS > 2
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-07-23 19:20:02 -05:00
|
|
|
SERIAL_ECHOPAIR(" M200 T2 D", filament_size[2]);
|
2015-01-28 23:19:51 -06:00
|
|
|
SERIAL_EOL;
|
2015-07-23 19:20:02 -05:00
|
|
|
#if EXTRUDERS > 3
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-07-23 19:20:02 -05:00
|
|
|
SERIAL_ECHOPAIR(" M200 T3 D", filament_size[3]);
|
2015-01-28 23:19:51 -06:00
|
|
|
SERIAL_EOL;
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif
|
|
|
|
|
#endif
|
2015-07-23 19:20:02 -05:00
|
|
|
#endif
|
2015-01-28 03:08:48 -06:00
|
|
|
|
2015-07-23 19:20:02 -05:00
|
|
|
if (!volumetric_enabled) {
|
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
|
SERIAL_ECHOLNPGM(" M200 D0");
|
2015-01-28 03:08:48 -06:00
|
|
|
}
|
|
|
|
|
|
2015-07-23 19:20:02 -05:00
|
|
|
/**
|
|
|
|
|
* Auto Bed Leveling
|
|
|
|
|
*/
|
2015-08-05 07:12:26 -05:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_FEATURE)
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(CUSTOM_M_CODES)
|
2015-03-25 23:14:00 -05:00
|
|
|
if (!forReplay) {
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-03-25 23:14:00 -05:00
|
|
|
SERIAL_ECHOLNPGM("Z-Probe Offset (mm):");
|
|
|
|
|
}
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-06-07 16:36:23 -05:00
|
|
|
SERIAL_ECHOPAIR(" M" STRINGIFY(CUSTOM_M_CODE_SET_Z_PROBE_OFFSET) " Z", zprobe_zoffset);
|
2015-03-25 23:14:00 -05:00
|
|
|
#else
|
|
|
|
|
if (!forReplay) {
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2015-05-26 19:47:04 -05:00
|
|
|
SERIAL_ECHOPAIR("Z-Probe Offset (mm):", zprobe_zoffset);
|
2015-03-25 23:14:00 -05:00
|
|
|
}
|
|
|
|
|
#endif
|
2015-01-28 23:19:51 -06:00
|
|
|
SERIAL_EOL;
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif
|
2012-11-07 16:16:43 -06:00
|
|
|
}
|
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
|
|
|
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif // !DISABLE_M503
|
