2016-03-25 01:19:46 -05:00
|
|
|
/**
|
2016-03-24 13:01:20 -05:00
|
|
|
* Marlin 3D Printer Firmware
|
|
|
|
* Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
|
|
|
*
|
|
|
|
* Based on Sprinter and grbl.
|
|
|
|
* Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
|
|
|
|
*
|
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2016-03-25 01:19:46 -05: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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2016-03-24 16:16:09 -05:00
|
|
|
#define EEPROM_VERSION "V23"
|
2015-04-03 18:38:05 -05:00
|
|
|
|
|
|
|
/**
|
2016-03-24 16:16:09 -05:00
|
|
|
* V23 EEPROM Layout:
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
2016-02-17 15:05:12 -06:00
|
|
|
* 100 Version (char x4)
|
|
|
|
*
|
2016-04-27 20:06:32 -05:00
|
|
|
* 104 M92 XYZE planner.axis_steps_per_unit (float x4)
|
|
|
|
* 120 M203 XYZE planner.max_feedrate (float x4)
|
|
|
|
* 136 M201 XYZE planner.max_acceleration_units_per_sq_second (uint32_t x4)
|
|
|
|
* 152 M204 P planner.acceleration (float)
|
|
|
|
* 156 M204 R planner.retract_acceleration (float)
|
|
|
|
* 160 M204 T planner.travel_acceleration (float)
|
|
|
|
* 164 M205 S planner.min_feedrate (float)
|
|
|
|
* 168 M205 T planner.min_travel_feedrate (float)
|
|
|
|
* 172 M205 B planner.min_segment_time (ulong)
|
|
|
|
* 176 M205 X planner.max_xy_jerk (float)
|
|
|
|
* 180 M205 Z planner.max_z_jerk (float)
|
|
|
|
* 184 M205 E planner.max_e_jerk (float)
|
2016-02-17 15:05:12 -06:00
|
|
|
* 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-06-03 23:31:38 -05:00
|
|
|
* 200 M420 S status (uint8)
|
|
|
|
* 201 z_offset (float)
|
2016-03-24 16:16:09 -05:00
|
|
|
* 205 mesh_num_x (uint8 as set in firmware)
|
|
|
|
* 206 mesh_num_y (uint8 as set in firmware)
|
2016-05-23 15:49:29 -05:00
|
|
|
* 207 G29 S3 XYZ z_values[][] (float x9, by default)
|
2016-03-24 16:16:09 -05:00
|
|
|
*
|
|
|
|
* AUTO BED LEVELING
|
|
|
|
* 243 M851 zprobe_zoffset (float)
|
2015-03-15 17:18:11 -05:00
|
|
|
*
|
2015-01-28 03:08:48 -06:00
|
|
|
* DELTA:
|
2016-03-24 16:16:09 -05:00
|
|
|
* 247 M666 XYZ endstop_adj (float x3)
|
|
|
|
* 259 M665 R delta_radius (float)
|
|
|
|
* 263 M665 L delta_diagonal_rod (float)
|
|
|
|
* 267 M665 S delta_segments_per_second (float)
|
|
|
|
* 271 M665 A delta_diagonal_rod_trim_tower_1 (float)
|
|
|
|
* 275 M665 B delta_diagonal_rod_trim_tower_2 (float)
|
|
|
|
* 279 M665 C delta_diagonal_rod_trim_tower_3 (float)
|
2016-02-17 15:05:12 -06:00
|
|
|
*
|
|
|
|
* Z_DUAL_ENDSTOPS:
|
2016-03-24 16:16:09 -05:00
|
|
|
* 283 M666 Z z_endstop_adj (float)
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
|
|
|
* ULTIPANEL:
|
2016-03-24 16:16:09 -05:00
|
|
|
* 287 M145 S0 H plaPreheatHotendTemp (int)
|
|
|
|
* 289 M145 S0 B plaPreheatHPBTemp (int)
|
|
|
|
* 291 M145 S0 F plaPreheatFanSpeed (int)
|
|
|
|
* 293 M145 S1 H absPreheatHotendTemp (int)
|
|
|
|
* 295 M145 S1 B absPreheatHPBTemp (int)
|
|
|
|
* 297 M145 S1 F absPreheatFanSpeed (int)
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
|
|
|
* PIDTEMP:
|
2016-03-24 16:16:09 -05:00
|
|
|
* 299 M301 E0 PIDC Kp[0], Ki[0], Kd[0], Kc[0] (float x4)
|
|
|
|
* 315 M301 E1 PIDC Kp[1], Ki[1], Kd[1], Kc[1] (float x4)
|
|
|
|
* 331 M301 E2 PIDC Kp[2], Ki[2], Kd[2], Kc[2] (float x4)
|
|
|
|
* 347 M301 E3 PIDC Kp[3], Ki[3], Kd[3], Kc[3] (float x4)
|
|
|
|
* 363 M301 L lpq_len (int)
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
2015-04-03 18:38:05 -05:00
|
|
|
* PIDTEMPBED:
|
2016-04-28 20:18:13 -05:00
|
|
|
* 365 M304 PID thermalManager.bedKp, thermalManager.bedKi, thermalManager.bedKd (float x3)
|
2015-04-03 18:38:05 -05:00
|
|
|
*
|
2015-01-28 03:08:48 -06:00
|
|
|
* DOGLCD:
|
2016-03-24 16:16:09 -05:00
|
|
|
* 377 M250 C lcd_contrast (int)
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
|
|
|
* SCARA:
|
2016-03-24 16:16:09 -05:00
|
|
|
* 379 M365 XYZ axis_scaling (float x3)
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
|
|
|
* FWRETRACT:
|
2016-03-24 16:16:09 -05:00
|
|
|
* 391 M209 S autoretract_enabled (bool)
|
|
|
|
* 392 M207 S retract_length (float)
|
|
|
|
* 396 M207 W retract_length_swap (float)
|
|
|
|
* 400 M207 F retract_feedrate (float)
|
|
|
|
* 404 M207 Z retract_zlift (float)
|
|
|
|
* 408 M208 S retract_recover_length (float)
|
|
|
|
* 412 M208 W retract_recover_length_swap (float)
|
|
|
|
* 416 M208 F retract_recover_feedrate (float)
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
2016-02-17 15:05:12 -06:00
|
|
|
* Volumetric Extrusion:
|
2016-03-24 16:16:09 -05:00
|
|
|
* 420 M200 D volumetric_enabled (bool)
|
|
|
|
* 421 M200 T D filament_size (float x4) (T0..3)
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
2016-03-24 16:16:09 -05:00
|
|
|
* 437 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
|
2016-04-27 20:06:32 -05:00
|
|
|
EEPROM_WRITE_VAR(i, planner.axis_steps_per_unit);
|
|
|
|
EEPROM_WRITE_VAR(i, planner.max_feedrate);
|
|
|
|
EEPROM_WRITE_VAR(i, planner.max_acceleration_units_per_sq_second);
|
|
|
|
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);
|
2015-03-21 18:30:02 -05:00
|
|
|
EEPROM_WRITE_VAR(i, home_offset);
|
2015-01-28 03:08:48 -06:00
|
|
|
|
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
|
2016-03-13 00:38:55 -06:00
|
|
|
typedef char c_assert[(sizeof(mbl.z_values) == (MESH_NUM_X_POINTS) * (MESH_NUM_Y_POINTS) * sizeof(dummy)) ? 1 : -1];
|
2016-06-03 23:31:38 -05:00
|
|
|
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);
|
2016-05-24 15:53:15 -05:00
|
|
|
EEPROM_WRITE_VAR(i, dummy_uint8);
|
2016-03-24 16:16:09 -05:00
|
|
|
EEPROM_WRITE_VAR(i, mbl.z_offset);
|
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
|
2016-06-03 23:31:38 -05:00
|
|
|
uint8_t mesh_num_x = 3,
|
|
|
|
mesh_num_y = 3,
|
|
|
|
dummy_uint8 = 0;
|
2016-03-24 16:16:09 -05:00
|
|
|
dummy = 0.0f;
|
2015-03-18 15:00:31 -05:00
|
|
|
EEPROM_WRITE_VAR(i, dummy_uint8);
|
2016-03-24 16:16:09 -05:00
|
|
|
EEPROM_WRITE_VAR(i, dummy);
|
2015-03-18 15:00:31 -05:00
|
|
|
EEPROM_WRITE_VAR(i, mesh_num_x);
|
|
|
|
EEPROM_WRITE_VAR(i, mesh_num_y);
|
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
|
2016-03-19 07:43:50 -05:00
|
|
|
EEPROM_WRITE_VAR(i, delta_diagonal_rod_trim_tower_1); // 1 float
|
|
|
|
EEPROM_WRITE_VAR(i, delta_diagonal_rod_trim_tower_2); // 1 float
|
|
|
|
EEPROM_WRITE_VAR(i, delta_diagonal_rod_trim_tower_3); // 1 float
|
2015-07-31 00:31:45 -05:00
|
|
|
#elif ENABLED(Z_DUAL_ENDSTOPS)
|
2016-03-19 07:43:50 -05:00
|
|
|
EEPROM_WRITE_VAR(i, z_endstop_adj); // 1 float
|
2015-03-24 12:06:44 -05:00
|
|
|
dummy = 0.0f;
|
2016-03-19 07:43:50 -05:00
|
|
|
for (uint8_t q = 8; q--;) EEPROM_WRITE_VAR(i, dummy);
|
2015-01-28 03:08:48 -06:00
|
|
|
#else
|
|
|
|
dummy = 0.0f;
|
2016-03-19 07:43:50 -05:00
|
|
|
for (uint8_t q = 9; 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
|
2016-04-28 20:18:13 -05:00
|
|
|
EEPROM_WRITE_VAR(i, dummy); // Kp
|
2015-01-28 22:48:32 -06:00
|
|
|
dummy = 0.0f;
|
2016-04-28 20:18:13 -05:00
|
|
|
for (uint8_t q = 3; q--;) EEPROM_WRITE_VAR(i, dummy); // Ki, Kd, Kc
|
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)
|
2016-04-28 20:18:13 -05:00
|
|
|
dummy = DUMMY_PID_VALUE;
|
|
|
|
for (uint8_t q = 3; q--;) EEPROM_WRITE_VAR(i, dummy);
|
|
|
|
#else
|
|
|
|
EEPROM_WRITE_VAR(i, thermalManager.bedKp);
|
|
|
|
EEPROM_WRITE_VAR(i, thermalManager.bedKi);
|
|
|
|
EEPROM_WRITE_VAR(i, thermalManager.bedKd);
|
2015-04-03 18:38:05 -05:00
|
|
|
#endif
|
|
|
|
|
2016-05-31 13:47:02 -05:00
|
|
|
#if !HAS_LCD_CONTRAST
|
2015-07-31 00:31:45 -05:00
|
|
|
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;
|
2016-04-07 00:40:45 -05:00
|
|
|
SERIAL_ECHOPAIR("Settings Stored (", i);
|
2015-01-28 03:08:48 -06:00
|
|
|
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
|
2016-04-27 20:06:32 -05:00
|
|
|
EEPROM_READ_VAR(i, planner.axis_steps_per_unit);
|
|
|
|
EEPROM_READ_VAR(i, planner.max_feedrate);
|
|
|
|
EEPROM_READ_VAR(i, planner.max_acceleration_units_per_sq_second);
|
2015-01-28 03:08:48 -06:00
|
|
|
|
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)
|
2016-04-27 20:06:32 -05:00
|
|
|
planner.reset_acceleration_rates();
|
|
|
|
|
|
|
|
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);
|
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);
|
2016-03-24 16:16:09 -05:00
|
|
|
EEPROM_READ_VAR(i, dummy);
|
2015-04-26 23:06:04 -05:00
|
|
|
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)
|
2016-05-24 15:53:15 -05:00
|
|
|
mbl.status = dummy_uint8;
|
2016-03-24 16:16:09 -05:00
|
|
|
mbl.z_offset = dummy;
|
2015-04-26 23:06:04 -05:00
|
|
|
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
|
2016-03-19 07:43:50 -05:00
|
|
|
EEPROM_READ_VAR(i, delta_diagonal_rod_trim_tower_1); // 1 float
|
|
|
|
EEPROM_READ_VAR(i, delta_diagonal_rod_trim_tower_2); // 1 float
|
|
|
|
EEPROM_READ_VAR(i, delta_diagonal_rod_trim_tower_3); // 1 float
|
2016-04-15 16:51:02 -05:00
|
|
|
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
|
|
|
EEPROM_READ_VAR(i, z_endstop_adj);
|
|
|
|
dummy = 0.0f;
|
2016-03-19 07:43:50 -05:00
|
|
|
for (uint8_t q=8; 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-03-19 07:43:50 -05:00
|
|
|
for (uint8_t q=9; 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);
|
|
|
|
|
2016-04-28 20:18:13 -05:00
|
|
|
#if ENABLED(PIDTEMPBED)
|
|
|
|
EEPROM_READ_VAR(i, dummy); // bedKp
|
|
|
|
if (dummy != DUMMY_PID_VALUE) {
|
|
|
|
thermalManager.bedKp = dummy;
|
|
|
|
EEPROM_READ_VAR(i, thermalManager.bedKi);
|
|
|
|
EEPROM_READ_VAR(i, thermalManager.bedKd);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
for (uint8_t q=3; q--;) EEPROM_READ_VAR(i, dummy); // bedKp, bedKi, bedKd
|
2015-04-03 18:38:05 -05:00
|
|
|
#endif
|
|
|
|
|
2016-05-31 13:47:02 -05:00
|
|
|
#if !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();
|
2016-04-28 20:18:13 -05:00
|
|
|
// Call thermalManager.updatePID (similar to when we have processed M301)
|
|
|
|
thermalManager.updatePID();
|
2015-01-28 03:08:48 -06:00
|
|
|
|
|
|
|
// 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);
|
2016-04-07 00:40:45 -05:00
|
|
|
SERIAL_ECHOPAIR(" stored settings retrieved (", i);
|
2015-01-28 03:08:48 -06:00
|
|
|
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++) {
|
2016-04-27 20:06:32 -05:00
|
|
|
planner.axis_steps_per_unit[i] = tmp1[i];
|
|
|
|
planner.max_feedrate[i] = tmp2[i];
|
|
|
|
planner.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
|
2016-04-27 20:06:32 -05:00
|
|
|
planner.reset_acceleration_rates();
|
|
|
|
|
|
|
|
planner.acceleration = DEFAULT_ACCELERATION;
|
|
|
|
planner.retract_acceleration = DEFAULT_RETRACT_ACCELERATION;
|
|
|
|
planner.travel_acceleration = DEFAULT_TRAVEL_ACCELERATION;
|
|
|
|
planner.min_feedrate = DEFAULT_MINIMUMFEEDRATE;
|
|
|
|
planner.min_segment_time = DEFAULT_MINSEGMENTTIME;
|
|
|
|
planner.min_travel_feedrate = DEFAULT_MINTRAVELFEEDRATE;
|
|
|
|
planner.max_xy_jerk = DEFAULT_XYJERK;
|
|
|
|
planner.max_z_jerk = DEFAULT_ZJERK;
|
|
|
|
planner.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)
|
2016-05-24 15:53:15 -05:00
|
|
|
mbl.reset();
|
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;
|
2016-03-19 07:43:50 -05:00
|
|
|
delta_diagonal_rod_trim_tower_1 = DELTA_DIAGONAL_ROD_TRIM_TOWER_1;
|
|
|
|
delta_diagonal_rod_trim_tower_2 = DELTA_DIAGONAL_ROD_TRIM_TOWER_2;
|
|
|
|
delta_diagonal_rod_trim_tower_3 = DELTA_DIAGONAL_ROD_TRIM_TOWER_3;
|
2015-01-28 03:08:48 -06:00
|
|
|
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
|
|
|
|
|
2016-05-31 13:47:02 -05:00
|
|
|
#if 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
|
2016-04-28 20:18:13 -05:00
|
|
|
// call thermalManager.updatePID (similar to when we have processed M301)
|
|
|
|
thermalManager.updatePID();
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif // PIDTEMP
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(PIDTEMPBED)
|
2016-04-28 20:18:13 -05:00
|
|
|
thermalManager.bedKp = DEFAULT_bedKp;
|
|
|
|
thermalManager.bedKi = scalePID_i(DEFAULT_bedKi);
|
|
|
|
thermalManager.bedKd = scalePID_d(DEFAULT_bedKd);
|
2015-04-03 18:38:05 -05:00
|
|
|
#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
|
|
|
}
|
2016-04-27 20:06:32 -05:00
|
|
|
SERIAL_ECHOPAIR(" M92 X", planner.axis_steps_per_unit[X_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" Y", planner.axis_steps_per_unit[Y_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" Z", planner.axis_steps_per_unit[Z_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" E", planner.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
|
|
|
}
|
2016-04-27 20:06:32 -05:00
|
|
|
SERIAL_ECHOPAIR(" M203 X", planner.max_feedrate[X_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" Y", planner.max_feedrate[Y_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" Z", planner.max_feedrate[Z_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" E", planner.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
|
|
|
}
|
2016-04-27 20:06:32 -05:00
|
|
|
SERIAL_ECHOPAIR(" M201 X", planner.max_acceleration_units_per_sq_second[X_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" Y", planner.max_acceleration_units_per_sq_second[Y_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" Z", planner.max_acceleration_units_per_sq_second[Z_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" E", planner.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
|
|
|
}
|
2016-04-27 20:06:32 -05:00
|
|
|
SERIAL_ECHOPAIR(" M204 P", planner.acceleration);
|
|
|
|
SERIAL_ECHOPAIR(" R", planner.retract_acceleration);
|
|
|
|
SERIAL_ECHOPAIR(" T", planner.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
|
|
|
}
|
2016-04-27 20:06:32 -05:00
|
|
|
SERIAL_ECHOPAIR(" M205 S", planner.min_feedrate);
|
|
|
|
SERIAL_ECHOPAIR(" T", planner.min_travel_feedrate);
|
|
|
|
SERIAL_ECHOPAIR(" B", planner.min_segment_time);
|
|
|
|
SERIAL_ECHOPAIR(" X", planner.max_xy_jerk);
|
|
|
|
SERIAL_ECHOPAIR(" Z", planner.max_z_jerk);
|
|
|
|
SERIAL_ECHOPAIR(" E", planner.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;
|
|
|
|
}
|
2016-05-24 15:53:15 -05:00
|
|
|
SERIAL_ECHOPAIR(" M420 S", mbl.has_mesh() ? 1 : 0);
|
2016-04-07 00:40:45 -05:00
|
|
|
SERIAL_ECHOPAIR(" X", MESH_NUM_X_POINTS);
|
|
|
|
SERIAL_ECHOPAIR(" Y", MESH_NUM_Y_POINTS);
|
2015-04-26 20:44:01 -05:00
|
|
|
SERIAL_EOL;
|
2016-05-23 15:49:29 -05:00
|
|
|
for (uint8_t py = 1; py <= MESH_NUM_Y_POINTS; py++) {
|
|
|
|
for (uint8_t px = 1; px <= MESH_NUM_X_POINTS; px++) {
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2016-05-23 15:49:29 -05:00
|
|
|
SERIAL_ECHOPAIR(" G29 S3 X", px);
|
|
|
|
SERIAL_ECHOPAIR(" Y", py);
|
2016-05-14 18:19:37 -05:00
|
|
|
SERIAL_ECHOPGM(" Z");
|
2016-05-23 15:49:29 -05:00
|
|
|
SERIAL_PROTOCOL_F(mbl.z_values[py-1][px-1], 5);
|
2015-04-26 20:44:01 -05:00
|
|
|
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) {
|
2016-03-19 07:43:50 -05:00
|
|
|
SERIAL_ECHOLNPGM("Delta settings: L=diagonal_rod, R=radius, S=segments_per_second, ABC=diagonal_rod_trim_tower_[123]");
|
2016-02-17 15:05:12 -06:00
|
|
|
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);
|
2016-03-19 07:43:50 -05:00
|
|
|
SERIAL_ECHOPAIR(" A", delta_diagonal_rod_trim_tower_1);
|
|
|
|
SERIAL_ECHOPAIR(" B", delta_diagonal_rod_trim_tower_2);
|
|
|
|
SERIAL_ECHOPAIR(" C", delta_diagonal_rod_trim_tower_3);
|
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-04-07 00:40:45 -05:00
|
|
|
SERIAL_ECHOPAIR(" M145 S0 H", plaPreheatHotendTemp);
|
|
|
|
SERIAL_ECHOPAIR(" B", plaPreheatHPBTemp);
|
|
|
|
SERIAL_ECHOPAIR(" F", plaPreheatFanSpeed);
|
2015-04-26 20:44:01 -05:00
|
|
|
SERIAL_EOL;
|
|
|
|
CONFIG_ECHO_START;
|
2016-04-07 00:40:45 -05:00
|
|
|
SERIAL_ECHOPAIR(" M145 S1 H", absPreheatHotendTemp);
|
|
|
|
SERIAL_ECHOPAIR(" B", absPreheatHPBTemp);
|
|
|
|
SERIAL_ECHOPAIR(" F", absPreheatFanSpeed);
|
2015-04-26 20:44:01 -05:00
|
|
|
SERIAL_EOL;
|
|
|
|
#endif // ULTIPANEL
|
|
|
|
|
2016-04-19 20:09:29 -05:00
|
|
|
#if HAS_PID_HEATING
|
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;
|
2016-04-07 00:40:45 -05:00
|
|
|
SERIAL_ECHOPAIR(" M301 E", i);
|
2015-04-26 20:44:01 -05:00
|
|
|
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;
|
2016-04-28 20:18:13 -05:00
|
|
|
SERIAL_ECHOPAIR(" M304 P", thermalManager.bedKp);
|
|
|
|
SERIAL_ECHOPAIR(" I", unscalePID_i(thermalManager.bedKi));
|
|
|
|
SERIAL_ECHOPAIR(" D", unscalePID_d(thermalManager.bedKd));
|
2015-04-03 18:38:05 -05:00
|
|
|
SERIAL_EOL;
|
|
|
|
#endif
|
2015-04-26 20:44:01 -05:00
|
|
|
|
|
|
|
#endif // PIDTEMP || PIDTEMPBED
|
|
|
|
|
2016-05-31 13:47:02 -05:00
|
|
|
#if HAS_LCD_CONTRAST
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
if (!forReplay) {
|
|
|
|
SERIAL_ECHOLNPGM("LCD Contrast:");
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
}
|
2016-04-07 00:40:45 -05:00
|
|
|
SERIAL_ECHOPAIR(" M250 C", lcd_contrast);
|
2015-04-26 20:44:01 -05:00
|
|
|
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
|
|
|
}
|
2016-04-07 00:40:45 -05:00
|
|
|
SERIAL_ECHOPAIR(" M209 S", (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
|