2016-03-25 06:19:46 +00:00
|
|
|
/**
|
2016-03-24 18:01:20 +00: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 06:19:46 +00:00
|
|
|
/**
|
2015-04-26 04:04:54 +00:00
|
|
|
* configuration_store.cpp
|
2015-01-28 09:08:48 +00:00
|
|
|
*
|
|
|
|
* Configuration and EEPROM storage
|
|
|
|
*
|
2015-04-03 23:38:05 +00: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-06-30 01:12:23 +00:00
|
|
|
#define EEPROM_VERSION "V24"
|
2015-04-03 23:38:05 +00:00
|
|
|
|
2016-06-30 01:18:46 +00:00
|
|
|
// Change EEPROM version if these are changed:
|
|
|
|
#define EEPROM_OFFSET 100
|
|
|
|
|
2015-04-03 23:38:05 +00:00
|
|
|
/**
|
2016-06-30 01:12:23 +00:00
|
|
|
* V24 EEPROM Layout:
|
2015-01-28 09:08:48 +00:00
|
|
|
*
|
2016-02-17 21:05:12 +00:00
|
|
|
* 100 Version (char x4)
|
2016-06-30 01:12:23 +00:00
|
|
|
* 104 EEPROM Checksum (uint16_t)
|
2016-02-17 21:05:12 +00:00
|
|
|
*
|
2016-06-30 01:12:23 +00:00
|
|
|
* 106 M92 XYZE planner.axis_steps_per_mm (float x4)
|
|
|
|
* 122 M203 XYZE planner.max_feedrate (float x4)
|
|
|
|
* 138 M201 XYZE planner.max_acceleration_mm_per_s2 (uint32_t x4)
|
|
|
|
* 154 M204 P planner.acceleration (float)
|
|
|
|
* 158 M204 R planner.retract_acceleration (float)
|
|
|
|
* 162 M204 T planner.travel_acceleration (float)
|
|
|
|
* 166 M205 S planner.min_feedrate (float)
|
|
|
|
* 170 M205 T planner.min_travel_feedrate (float)
|
|
|
|
* 174 M205 B planner.min_segment_time (ulong)
|
|
|
|
* 178 M205 X planner.max_xy_jerk (float)
|
|
|
|
* 182 M205 Z planner.max_z_jerk (float)
|
|
|
|
* 186 M205 E planner.max_e_jerk (float)
|
|
|
|
* 190 M206 XYZ home_offset (float x3)
|
2015-01-28 09:08:48 +00:00
|
|
|
*
|
2015-03-15 22:18:11 +00:00
|
|
|
* Mesh bed leveling:
|
2016-06-30 01:12:23 +00:00
|
|
|
* 202 M420 S status (uint8)
|
|
|
|
* 203 z_offset (float)
|
|
|
|
* 207 mesh_num_x (uint8 as set in firmware)
|
|
|
|
* 208 mesh_num_y (uint8 as set in firmware)
|
|
|
|
* 209 G29 S3 XYZ z_values[][] (float x9, by default)
|
2016-03-24 21:16:09 +00:00
|
|
|
*
|
|
|
|
* AUTO BED LEVELING
|
2016-06-30 01:12:23 +00:00
|
|
|
* 245 M851 zprobe_zoffset (float)
|
2015-03-15 22:18:11 +00:00
|
|
|
*
|
2015-01-28 09:08:48 +00:00
|
|
|
* DELTA:
|
2016-06-30 01:12:23 +00:00
|
|
|
* 249 M666 XYZ endstop_adj (float x3)
|
|
|
|
* 261 M665 R delta_radius (float)
|
|
|
|
* 265 M665 L delta_diagonal_rod (float)
|
|
|
|
* 269 M665 S delta_segments_per_second (float)
|
|
|
|
* 273 M665 A delta_diagonal_rod_trim_tower_1 (float)
|
|
|
|
* 277 M665 B delta_diagonal_rod_trim_tower_2 (float)
|
|
|
|
* 281 M665 C delta_diagonal_rod_trim_tower_3 (float)
|
2016-02-17 21:05:12 +00:00
|
|
|
*
|
|
|
|
* Z_DUAL_ENDSTOPS:
|
2016-06-30 01:12:23 +00:00
|
|
|
* 285 M666 Z z_endstop_adj (float)
|
2015-01-28 09:08:48 +00:00
|
|
|
*
|
|
|
|
* ULTIPANEL:
|
2016-06-30 01:12:23 +00:00
|
|
|
* 289 M145 S0 H plaPreheatHotendTemp (int)
|
|
|
|
* 291 M145 S0 B plaPreheatHPBTemp (int)
|
|
|
|
* 293 M145 S0 F plaPreheatFanSpeed (int)
|
|
|
|
* 295 M145 S1 H absPreheatHotendTemp (int)
|
|
|
|
* 297 M145 S1 B absPreheatHPBTemp (int)
|
|
|
|
* 299 M145 S1 F absPreheatFanSpeed (int)
|
2015-01-28 09:08:48 +00:00
|
|
|
*
|
|
|
|
* PIDTEMP:
|
2016-06-30 01:12:23 +00:00
|
|
|
* 301 M301 E0 PIDC Kp[0], Ki[0], Kd[0], Kc[0] (float x4)
|
|
|
|
* 317 M301 E1 PIDC Kp[1], Ki[1], Kd[1], Kc[1] (float x4)
|
|
|
|
* 333 M301 E2 PIDC Kp[2], Ki[2], Kd[2], Kc[2] (float x4)
|
|
|
|
* 349 M301 E3 PIDC Kp[3], Ki[3], Kd[3], Kc[3] (float x4)
|
|
|
|
* 365 M301 L lpq_len (int)
|
2015-01-28 09:08:48 +00:00
|
|
|
*
|
2015-04-03 23:38:05 +00:00
|
|
|
* PIDTEMPBED:
|
2016-06-30 01:12:23 +00:00
|
|
|
* 367 M304 PID thermalManager.bedKp, thermalManager.bedKi, thermalManager.bedKd (float x3)
|
2015-04-03 23:38:05 +00:00
|
|
|
*
|
2015-01-28 09:08:48 +00:00
|
|
|
* DOGLCD:
|
2016-06-30 01:12:23 +00:00
|
|
|
* 379 M250 C lcd_contrast (int)
|
2015-01-28 09:08:48 +00:00
|
|
|
*
|
|
|
|
* SCARA:
|
2016-06-30 01:12:23 +00:00
|
|
|
* 381 M365 XYZ axis_scaling (float x3)
|
2015-01-28 09:08:48 +00:00
|
|
|
*
|
|
|
|
* FWRETRACT:
|
2016-06-30 01:12:23 +00:00
|
|
|
* 393 M209 S autoretract_enabled (bool)
|
|
|
|
* 394 M207 S retract_length (float)
|
|
|
|
* 398 M207 W retract_length_swap (float)
|
|
|
|
* 402 M207 F retract_feedrate_mm_s (float)
|
|
|
|
* 406 M207 Z retract_zlift (float)
|
|
|
|
* 410 M208 S retract_recover_length (float)
|
|
|
|
* 414 M208 W retract_recover_length_swap (float)
|
|
|
|
* 418 M208 F retract_recover_feedrate (float)
|
2015-01-28 09:08:48 +00:00
|
|
|
*
|
2016-02-17 21:05:12 +00:00
|
|
|
* Volumetric Extrusion:
|
2016-06-30 01:12:23 +00:00
|
|
|
* 422 M200 D volumetric_enabled (bool)
|
|
|
|
* 423 M200 T D filament_size (float x4) (T0..3)
|
2015-01-28 09:08:48 +00:00
|
|
|
*
|
2016-06-30 01:12:23 +00:00
|
|
|
* 439 This Slot is Available!
|
2015-03-24 17:06:44 +00:00
|
|
|
*
|
2015-01-28 09:08:48 +00:00
|
|
|
*/
|
2012-11-07 22:16:43 +00:00
|
|
|
#include "Marlin.h"
|
2015-01-29 05:19:51 +00:00
|
|
|
#include "language.h"
|
2012-11-07 22:16:43 +00:00
|
|
|
#include "planner.h"
|
|
|
|
#include "temperature.h"
|
|
|
|
#include "ultralcd.h"
|
2015-04-26 04:04:54 +00: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 14:05:11 +00:00
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2015-04-28 02:48:34 +00:00
|
|
|
#include "mesh_bed_leveling.h"
|
|
|
|
#endif
|
2015-03-15 22:18:11 +00:00
|
|
|
|
2016-06-30 01:12:23 +00:00
|
|
|
uint16_t eeprom_checksum;
|
|
|
|
const char version[4] = EEPROM_VERSION;
|
|
|
|
|
2015-01-28 09:08:48 +00:00
|
|
|
void _EEPROM_writeData(int &pos, uint8_t* value, uint8_t size) {
|
2015-01-29 05:19:51 +00:00
|
|
|
uint8_t c;
|
2015-10-03 06:08:58 +00:00
|
|
|
while (size--) {
|
2015-01-28 09:08:48 +00:00
|
|
|
eeprom_write_byte((unsigned char*)pos, *value);
|
2015-01-29 06:27:15 +00:00
|
|
|
c = eeprom_read_byte((unsigned char*)pos);
|
|
|
|
if (c != *value) {
|
2015-01-29 05:19:51 +00:00
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPGM(MSG_ERR_EEPROM_WRITE);
|
|
|
|
}
|
2016-06-30 01:12:23 +00:00
|
|
|
eeprom_checksum += c;
|
2015-01-28 09:08:48 +00:00
|
|
|
pos++;
|
|
|
|
value++;
|
2015-01-29 05:19:51 +00: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 14:05:11 +00:00
|
|
|
}
|
2015-01-28 09:08:48 +00:00
|
|
|
void _EEPROM_readData(int &pos, uint8_t* value, uint8_t size) {
|
|
|
|
do {
|
2016-06-30 01:12:23 +00:00
|
|
|
uint8_t c = eeprom_read_byte((unsigned char*)pos);
|
|
|
|
*value = c;
|
|
|
|
eeprom_checksum += c;
|
2015-01-28 09:08:48 +00:00
|
|
|
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 14:05:11 +00:00
|
|
|
}
|
2012-11-07 22:16:43 +00:00
|
|
|
|
2015-04-27 01:44:01 +00:00
|
|
|
/**
|
2016-06-30 01:19:26 +00:00
|
|
|
* Post-process after Retrieve or Reset
|
2015-04-27 01:44:01 +00:00
|
|
|
*/
|
2016-06-30 01:19:26 +00:00
|
|
|
void Config_Postprocess() {
|
|
|
|
// steps per s2 needs to be updated to agree with units per s2
|
|
|
|
planner.reset_acceleration_rates();
|
|
|
|
|
|
|
|
#if ENABLED(DELTA)
|
|
|
|
recalc_delta_settings(delta_radius, delta_diagonal_rod);
|
|
|
|
#endif
|
2012-11-07 22:16:43 +00:00
|
|
|
|
2016-06-30 01:19:26 +00:00
|
|
|
#if ENABLED(PIDTEMP)
|
|
|
|
thermalManager.updatePID();
|
|
|
|
#endif
|
2012-11-07 22:16:43 +00:00
|
|
|
|
2016-06-30 01:19:26 +00:00
|
|
|
calculate_volumetric_multipliers();
|
|
|
|
}
|
2012-11-07 22:16:43 +00:00
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(EEPROM_SETTINGS)
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2016-06-30 01:18:46 +00:00
|
|
|
#define DUMMY_PID_VALUE 3000.0f
|
|
|
|
#define EEPROM_WRITE_VAR(pos, value) _EEPROM_writeData(pos, (uint8_t*)&value, sizeof(value))
|
|
|
|
#define EEPROM_READ_VAR(pos, value) _EEPROM_readData(pos, (uint8_t*)&value, sizeof(value))
|
|
|
|
|
2016-02-17 21:05:12 +00:00
|
|
|
/**
|
2016-06-30 01:18:46 +00:00
|
|
|
* M500 - Store Configuration
|
2016-02-17 21:05:12 +00:00
|
|
|
*/
|
2015-01-28 09:08:48 +00:00
|
|
|
void Config_StoreSettings() {
|
|
|
|
float dummy = 0.0f;
|
|
|
|
char ver[4] = "000";
|
|
|
|
int i = EEPROM_OFFSET;
|
2016-06-30 01:12:23 +00:00
|
|
|
|
|
|
|
EEPROM_WRITE_VAR(i, ver); // invalidate data first
|
|
|
|
i += sizeof(eeprom_checksum); // Skip the checksum slot
|
|
|
|
|
|
|
|
eeprom_checksum = 0; // clear before first "real data"
|
|
|
|
|
2016-06-09 23:53:21 +00:00
|
|
|
EEPROM_WRITE_VAR(i, planner.axis_steps_per_mm);
|
2016-04-28 01:06:32 +00:00
|
|
|
EEPROM_WRITE_VAR(i, planner.max_feedrate);
|
2016-06-09 22:20:44 +00:00
|
|
|
EEPROM_WRITE_VAR(i, planner.max_acceleration_mm_per_s2);
|
2016-04-28 01:06:32 +00:00
|
|
|
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 23:30:02 +00:00
|
|
|
EEPROM_WRITE_VAR(i, home_offset);
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2015-03-18 20:00:31 +00:00
|
|
|
// Compile time test that sizeof(mbl.z_values) is as expected
|
2016-03-13 06:38:55 +00:00
|
|
|
typedef char c_assert[(sizeof(mbl.z_values) == (MESH_NUM_X_POINTS) * (MESH_NUM_Y_POINTS) * sizeof(dummy)) ? 1 : -1];
|
2016-06-04 04:31:38 +00: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 20:53:15 +00:00
|
|
|
EEPROM_WRITE_VAR(i, dummy_uint8);
|
2016-03-24 21:16:09 +00:00
|
|
|
EEPROM_WRITE_VAR(i, mbl.z_offset);
|
2015-03-18 20:00:31 +00:00
|
|
|
EEPROM_WRITE_VAR(i, mesh_num_x);
|
|
|
|
EEPROM_WRITE_VAR(i, mesh_num_y);
|
2015-03-15 22:18:11 +00:00
|
|
|
EEPROM_WRITE_VAR(i, mbl.z_values);
|
2015-03-18 20:00:31 +00:00
|
|
|
#else
|
2016-06-04 04:31:38 +00:00
|
|
|
uint8_t mesh_num_x = 3,
|
|
|
|
mesh_num_y = 3,
|
|
|
|
dummy_uint8 = 0;
|
2016-03-24 21:16:09 +00:00
|
|
|
dummy = 0.0f;
|
2015-03-18 20:00:31 +00:00
|
|
|
EEPROM_WRITE_VAR(i, dummy_uint8);
|
2016-03-24 21:16:09 +00:00
|
|
|
EEPROM_WRITE_VAR(i, dummy);
|
2015-03-18 20:00:31 +00:00
|
|
|
EEPROM_WRITE_VAR(i, mesh_num_x);
|
|
|
|
EEPROM_WRITE_VAR(i, mesh_num_y);
|
2015-10-03 06:08:58 +00:00
|
|
|
for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_WRITE_VAR(i, dummy);
|
2015-03-26 04:14:00 +00:00
|
|
|
#endif // MESH_BED_LEVELING
|
|
|
|
|
2016-06-15 01:05:20 +00:00
|
|
|
#if !HAS_BED_PROBE
|
2015-03-26 04:14:00 +00:00
|
|
|
float zprobe_zoffset = 0;
|
|
|
|
#endif
|
|
|
|
EEPROM_WRITE_VAR(i, zprobe_zoffset);
|
2015-03-15 22:18:11 +00:00
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(DELTA)
|
2015-01-28 09:08:48 +00: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 12:43:50 +00: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 05:31:45 +00:00
|
|
|
#elif ENABLED(Z_DUAL_ENDSTOPS)
|
2016-03-19 12:43:50 +00:00
|
|
|
EEPROM_WRITE_VAR(i, z_endstop_adj); // 1 float
|
2015-03-24 17:06:44 +00:00
|
|
|
dummy = 0.0f;
|
2016-03-19 12:43:50 +00:00
|
|
|
for (uint8_t q = 8; q--;) EEPROM_WRITE_VAR(i, dummy);
|
2015-01-28 09:08:48 +00:00
|
|
|
#else
|
|
|
|
dummy = 0.0f;
|
2016-03-19 12:43:50 +00:00
|
|
|
for (uint8_t q = 9; q--;) EEPROM_WRITE_VAR(i, dummy);
|
2015-01-28 09:08:48 +00:00
|
|
|
#endif
|
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if DISABLED(ULTIPANEL)
|
2015-01-28 09:08:48 +00: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-26 04:14:00 +00:00
|
|
|
|
2016-02-17 21:05:12 +00:00
|
|
|
for (uint8_t e = 0; e < 4; e++) {
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(PIDTEMP)
|
2016-05-27 00:43:20 +00:00
|
|
|
if (e < HOTENDS) {
|
2015-01-28 09:08:48 +00:00
|
|
|
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 05:31:45 +00:00
|
|
|
#if ENABLED(PID_ADD_EXTRUSION_RATE)
|
2015-01-28 09:08:48 +00:00
|
|
|
EEPROM_WRITE_VAR(i, PID_PARAM(Kc, e));
|
|
|
|
#else
|
|
|
|
dummy = 1.0f; // 1.0 = default kc
|
2015-02-06 22:43:58 +00:00
|
|
|
EEPROM_WRITE_VAR(i, dummy);
|
2015-01-28 09:08:48 +00:00
|
|
|
#endif
|
|
|
|
}
|
2015-04-03 23:38:05 +00:00
|
|
|
else
|
2015-01-28 09:08:48 +00:00
|
|
|
#endif // !PIDTEMP
|
2015-04-03 23:38:05 +00:00
|
|
|
{
|
|
|
|
dummy = DUMMY_PID_VALUE; // When read, will not change the existing value
|
2016-04-29 01:18:13 +00:00
|
|
|
EEPROM_WRITE_VAR(i, dummy); // Kp
|
2015-01-29 04:48:32 +00:00
|
|
|
dummy = 0.0f;
|
2016-04-29 01:18:13 +00:00
|
|
|
for (uint8_t q = 3; q--;) EEPROM_WRITE_VAR(i, dummy); // Ki, Kd, Kc
|
2015-01-29 04:48:32 +00:00
|
|
|
}
|
|
|
|
|
2016-05-27 00:43:20 +00:00
|
|
|
} // Hotends Loop
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2015-08-31 02:04:30 +00:00
|
|
|
#if DISABLED(PID_ADD_EXTRUSION_RATE)
|
|
|
|
int lpq_len = 20;
|
|
|
|
#endif
|
|
|
|
EEPROM_WRITE_VAR(i, lpq_len);
|
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if DISABLED(PIDTEMPBED)
|
2016-04-29 01:18:13 +00: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 23:38:05 +00:00
|
|
|
#endif
|
|
|
|
|
2016-05-31 18:47:02 +00:00
|
|
|
#if !HAS_LCD_CONTRAST
|
2015-07-31 05:31:45 +00:00
|
|
|
const int lcd_contrast = 32;
|
2015-01-28 09:08:48 +00:00
|
|
|
#endif
|
|
|
|
EEPROM_WRITE_VAR(i, lcd_contrast);
|
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(SCARA)
|
2015-01-28 09:08:48 +00:00
|
|
|
EEPROM_WRITE_VAR(i, axis_scaling); // 3 floats
|
|
|
|
#else
|
|
|
|
dummy = 1.0f;
|
|
|
|
EEPROM_WRITE_VAR(i, dummy);
|
|
|
|
#endif
|
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(FWRETRACT)
|
2015-01-28 09:08:48 +00: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
|
2016-06-22 10:27:31 +00:00
|
|
|
EEPROM_WRITE_VAR(i, retract_feedrate_mm_s);
|
2015-01-28 09:08:48 +00:00
|
|
|
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-29 01:43:14 +00:00
|
|
|
|
|
|
|
EEPROM_WRITE_VAR(i, volumetric_enabled);
|
2015-01-28 09:08:48 +00:00
|
|
|
|
|
|
|
// Save filament sizes
|
2016-02-17 21:05:12 +00:00
|
|
|
for (uint8_t q = 0; q < 4; q++) {
|
2015-01-28 09:08:48 +00:00
|
|
|
if (q < EXTRUDERS) dummy = filament_size[q];
|
|
|
|
EEPROM_WRITE_VAR(i, dummy);
|
|
|
|
}
|
|
|
|
|
2016-06-30 01:12:23 +00:00
|
|
|
uint16_t final_checksum = eeprom_checksum;
|
|
|
|
|
2015-01-28 09:08:48 +00:00
|
|
|
int j = EEPROM_OFFSET;
|
2016-06-30 01:12:23 +00:00
|
|
|
EEPROM_WRITE_VAR(j, version);
|
|
|
|
EEPROM_WRITE_VAR(j, final_checksum);
|
2015-01-28 09:08:48 +00:00
|
|
|
|
|
|
|
// Report storage size
|
2012-11-07 22:16:43 +00:00
|
|
|
SERIAL_ECHO_START;
|
2016-04-07 05:40:45 +00:00
|
|
|
SERIAL_ECHOPAIR("Settings Stored (", i);
|
2015-01-28 09:08:48 +00:00
|
|
|
SERIAL_ECHOLNPGM(" bytes)");
|
2012-11-07 22:16:43 +00:00
|
|
|
}
|
|
|
|
|
2015-04-27 01:44:01 +00:00
|
|
|
/**
|
2016-06-30 01:18:46 +00:00
|
|
|
* M501 - Retrieve Configuration
|
2015-04-27 01:44:01 +00:00
|
|
|
*/
|
2015-01-28 09:08:48 +00:00
|
|
|
void Config_RetrieveSettings() {
|
|
|
|
int i = EEPROM_OFFSET;
|
|
|
|
char stored_ver[4];
|
2016-06-30 01:12:23 +00:00
|
|
|
uint16_t stored_checksum;
|
|
|
|
EEPROM_READ_VAR(i, stored_ver);
|
|
|
|
EEPROM_READ_VAR(i, stored_checksum);
|
2016-06-28 02:33:37 +00:00
|
|
|
// SERIAL_ECHOPAIR("Version: [", ver);
|
|
|
|
// SERIAL_ECHOPAIR("] Stored version: [", stored_ver);
|
|
|
|
// SERIAL_ECHOLNPGM("]");
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2016-06-30 01:12:23 +00:00
|
|
|
if (strncmp(version, stored_ver, 3) != 0) {
|
2015-01-28 09:08:48 +00:00
|
|
|
Config_ResetDefault();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
float dummy = 0;
|
|
|
|
|
2016-06-30 01:12:23 +00:00
|
|
|
eeprom_checksum = 0; // clear before reading first "real data"
|
|
|
|
|
2015-01-28 09:08:48 +00:00
|
|
|
// version number match
|
2016-06-09 23:53:21 +00:00
|
|
|
EEPROM_READ_VAR(i, planner.axis_steps_per_mm);
|
2016-04-28 01:06:32 +00:00
|
|
|
EEPROM_READ_VAR(i, planner.max_feedrate);
|
2016-06-09 22:20:44 +00:00
|
|
|
EEPROM_READ_VAR(i, planner.max_acceleration_mm_per_s2);
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2016-04-28 01:06:32 +00:00
|
|
|
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 23:30:02 +00:00
|
|
|
EEPROM_READ_VAR(i, home_offset);
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2015-04-27 04:06:04 +00:00
|
|
|
uint8_t dummy_uint8 = 0, mesh_num_x = 0, mesh_num_y = 0;
|
|
|
|
EEPROM_READ_VAR(i, dummy_uint8);
|
2016-03-24 21:16:09 +00:00
|
|
|
EEPROM_READ_VAR(i, dummy);
|
2015-04-27 04:06:04 +00:00
|
|
|
EEPROM_READ_VAR(i, mesh_num_x);
|
|
|
|
EEPROM_READ_VAR(i, mesh_num_y);
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2016-05-24 20:53:15 +00:00
|
|
|
mbl.status = dummy_uint8;
|
2016-03-24 21:16:09 +00:00
|
|
|
mbl.z_offset = dummy;
|
2015-04-27 04:06:04 +00:00
|
|
|
if (mesh_num_x == MESH_NUM_X_POINTS && mesh_num_y == MESH_NUM_Y_POINTS) {
|
2015-03-18 20:00:31 +00:00
|
|
|
EEPROM_READ_VAR(i, mbl.z_values);
|
2015-04-27 04:06:04 +00:00
|
|
|
} else {
|
|
|
|
mbl.reset();
|
2016-02-17 21:05:12 +00:00
|
|
|
for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_READ_VAR(i, dummy);
|
2015-03-18 20:00:31 +00:00
|
|
|
}
|
|
|
|
#else
|
2016-02-17 21:05:12 +00:00
|
|
|
for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_READ_VAR(i, dummy);
|
2015-04-27 04:06:04 +00:00
|
|
|
#endif // MESH_BED_LEVELING
|
2015-03-15 22:18:11 +00:00
|
|
|
|
2016-06-15 01:05:20 +00:00
|
|
|
#if !HAS_BED_PROBE
|
2015-03-26 04:14:00 +00:00
|
|
|
float zprobe_zoffset = 0;
|
|
|
|
#endif
|
|
|
|
EEPROM_READ_VAR(i, zprobe_zoffset);
|
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(DELTA)
|
2015-01-28 09:08:48 +00: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 12:43:50 +00: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
|
2015-07-31 05:31:45 +00:00
|
|
|
#elif ENABLED(Z_DUAL_ENDSTOPS)
|
2015-03-24 17:06:44 +00:00
|
|
|
EEPROM_READ_VAR(i, z_endstop_adj);
|
|
|
|
dummy = 0.0f;
|
2016-03-19 12:43:50 +00:00
|
|
|
for (uint8_t q=8; q--;) EEPROM_READ_VAR(i, dummy);
|
2015-01-28 09:08:48 +00:00
|
|
|
#else
|
2015-03-24 17:06:44 +00:00
|
|
|
dummy = 0.0f;
|
2016-03-19 12:43:50 +00:00
|
|
|
for (uint8_t q=9; q--;) EEPROM_READ_VAR(i, dummy);
|
2015-01-28 09:08:48 +00:00
|
|
|
#endif
|
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if DISABLED(ULTIPANEL)
|
2015-01-28 09:08:48 +00: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 05:31:45 +00:00
|
|
|
#if ENABLED(PIDTEMP)
|
2016-02-17 21:05:12 +00:00
|
|
|
for (uint8_t e = 0; e < 4; e++) { // 4 = max extruders currently supported by Marlin
|
2015-04-03 23:38:05 +00:00
|
|
|
EEPROM_READ_VAR(i, dummy); // Kp
|
2016-05-27 00:43:20 +00:00
|
|
|
if (e < HOTENDS && dummy != DUMMY_PID_VALUE) {
|
2015-01-28 09:08:48 +00:00
|
|
|
// 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 05:31:45 +00:00
|
|
|
#if ENABLED(PID_ADD_EXTRUSION_RATE)
|
2015-01-28 09:08:48 +00:00
|
|
|
EEPROM_READ_VAR(i, PID_PARAM(Kc, e));
|
|
|
|
#else
|
|
|
|
EEPROM_READ_VAR(i, dummy);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
else {
|
2016-02-17 21:05:12 +00:00
|
|
|
for (uint8_t q=3; q--;) EEPROM_READ_VAR(i, dummy); // Ki, Kd, Kc
|
2015-01-28 09:08:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#else // !PIDTEMP
|
2015-01-29 04:48:32 +00:00
|
|
|
// 4 x 4 = 16 slots for PID parameters
|
2016-02-17 21:05:12 +00:00
|
|
|
for (uint8_t q=16; q--;) EEPROM_READ_VAR(i, dummy); // 4x Kp, Ki, Kd, Kc
|
2015-01-28 09:08:48 +00:00
|
|
|
#endif // !PIDTEMP
|
|
|
|
|
2015-08-31 02:04:30 +00:00
|
|
|
#if DISABLED(PID_ADD_EXTRUSION_RATE)
|
|
|
|
int lpq_len;
|
|
|
|
#endif
|
|
|
|
EEPROM_READ_VAR(i, lpq_len);
|
|
|
|
|
2016-04-29 01:18:13 +00: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 23:38:05 +00:00
|
|
|
#endif
|
|
|
|
|
2016-05-31 18:47:02 +00:00
|
|
|
#if !HAS_LCD_CONTRAST
|
2015-01-28 09:08:48 +00:00
|
|
|
int lcd_contrast;
|
|
|
|
#endif
|
|
|
|
EEPROM_READ_VAR(i, lcd_contrast);
|
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(SCARA)
|
2015-01-28 09:08:48 +00:00
|
|
|
EEPROM_READ_VAR(i, axis_scaling); // 3 floats
|
|
|
|
#else
|
|
|
|
EEPROM_READ_VAR(i, dummy);
|
|
|
|
#endif
|
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(FWRETRACT)
|
2015-01-28 09:08:48 +00: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
|
2016-06-22 10:27:31 +00:00
|
|
|
EEPROM_READ_VAR(i, retract_feedrate_mm_s);
|
2015-01-28 09:08:48 +00:00
|
|
|
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 21:05:12 +00:00
|
|
|
for (uint8_t q = 0; q < 4; q++) {
|
2015-01-28 09:08:48 +00:00
|
|
|
EEPROM_READ_VAR(i, dummy);
|
|
|
|
if (q < EXTRUDERS) filament_size[q] = dummy;
|
|
|
|
}
|
|
|
|
|
2016-06-30 01:12:23 +00:00
|
|
|
if (eeprom_checksum == stored_checksum) {
|
|
|
|
Config_Postprocess();
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHO(version);
|
|
|
|
SERIAL_ECHOPAIR(" stored settings retrieved (", i);
|
|
|
|
SERIAL_ECHOLNPGM(" bytes)");
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
SERIAL_ERROR_START;
|
|
|
|
SERIAL_ERRORLNPGM("EEPROM checksum mismatch");
|
|
|
|
Config_ResetDefault();
|
|
|
|
}
|
|
|
|
}
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(EEPROM_CHITCHAT)
|
2015-01-28 09:08:48 +00:00
|
|
|
Config_PrintSettings();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // EEPROM_SETTINGS
|
|
|
|
|
2015-04-27 01:44:01 +00:00
|
|
|
/**
|
2016-06-30 01:18:46 +00:00
|
|
|
* M502 - Reset Configuration
|
2015-04-27 01:44:01 +00:00
|
|
|
*/
|
2015-01-28 09:08:48 +00:00
|
|
|
void Config_ResetDefault() {
|
|
|
|
float tmp1[] = DEFAULT_AXIS_STEPS_PER_UNIT;
|
|
|
|
float tmp2[] = DEFAULT_MAX_FEEDRATE;
|
|
|
|
long tmp3[] = DEFAULT_MAX_ACCELERATION;
|
2015-08-11 16:38:26 +00:00
|
|
|
for (uint8_t i = 0; i < NUM_AXIS; i++) {
|
2016-06-09 23:53:21 +00:00
|
|
|
planner.axis_steps_per_mm[i] = tmp1[i];
|
2016-04-28 01:06:32 +00:00
|
|
|
planner.max_feedrate[i] = tmp2[i];
|
2016-06-09 22:20:44 +00:00
|
|
|
planner.max_acceleration_mm_per_s2[i] = tmp3[i];
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(SCARA)
|
2015-07-22 22:50:20 +00:00
|
|
|
if (i < COUNT(axis_scaling))
|
2015-01-28 09:08:48 +00:00
|
|
|
axis_scaling[i] = 1;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2016-04-28 01:06:32 +00:00
|
|
|
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 23:30:02 +00:00
|
|
|
home_offset[X_AXIS] = home_offset[Y_AXIS] = home_offset[Z_AXIS] = 0;
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2016-05-24 20:53:15 +00:00
|
|
|
mbl.reset();
|
2015-03-26 06:06:33 +00:00
|
|
|
#endif
|
|
|
|
|
2016-06-15 01:05:20 +00:00
|
|
|
#if HAS_BED_PROBE
|
2015-05-27 00:47:04 +00:00
|
|
|
zprobe_zoffset = Z_PROBE_OFFSET_FROM_EXTRUDER;
|
2015-03-26 06:06:33 +00:00
|
|
|
#endif
|
2015-03-15 22:18:11 +00:00
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(DELTA)
|
2015-01-28 09:08:48 +00: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 12:43:50 +00: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-07-31 05:31:45 +00:00
|
|
|
#elif ENABLED(Z_DUAL_ENDSTOPS)
|
2015-03-24 17:06:44 +00:00
|
|
|
z_endstop_adj = 0;
|
2015-01-28 09:08:48 +00:00
|
|
|
#endif
|
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(ULTIPANEL)
|
2015-01-28 09:08:48 +00: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 18:47:02 +00:00
|
|
|
#if HAS_LCD_CONTRAST
|
2015-01-28 09:08:48 +00:00
|
|
|
lcd_contrast = DEFAULT_LCD_CONTRAST;
|
|
|
|
#endif
|
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(PIDTEMP)
|
2016-05-27 00:43:20 +00:00
|
|
|
#if ENABLED(PID_PARAMS_PER_HOTEND)
|
|
|
|
for (uint8_t e = 0; e < HOTENDS; e++)
|
2015-01-28 09:08:48 +00:00
|
|
|
#else
|
2015-10-13 10:56:07 +00:00
|
|
|
int e = 0; UNUSED(e); // only need to write once
|
2015-01-28 09:08:48 +00: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 05:31:45 +00:00
|
|
|
#if ENABLED(PID_ADD_EXTRUSION_RATE)
|
2015-01-28 09:08:48 +00:00
|
|
|
PID_PARAM(Kc, e) = DEFAULT_Kc;
|
|
|
|
#endif
|
|
|
|
}
|
2015-08-31 02:04:30 +00:00
|
|
|
#if ENABLED(PID_ADD_EXTRUSION_RATE)
|
|
|
|
lpq_len = 20; // default last-position-queue size
|
|
|
|
#endif
|
2015-01-28 09:08:48 +00:00
|
|
|
#endif // PIDTEMP
|
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(PIDTEMPBED)
|
2016-04-29 01:18:13 +00:00
|
|
|
thermalManager.bedKp = DEFAULT_bedKp;
|
|
|
|
thermalManager.bedKi = scalePID_i(DEFAULT_bedKi);
|
|
|
|
thermalManager.bedKd = scalePID_d(DEFAULT_bedKd);
|
2015-04-03 23:38:05 +00:00
|
|
|
#endif
|
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(FWRETRACT)
|
2015-01-28 09:08:48 +00:00
|
|
|
autoretract_enabled = false;
|
|
|
|
retract_length = RETRACT_LENGTH;
|
|
|
|
#if EXTRUDERS > 1
|
|
|
|
retract_length_swap = RETRACT_LENGTH_SWAP;
|
|
|
|
#endif
|
2016-06-22 10:27:31 +00:00
|
|
|
retract_feedrate_mm_s = RETRACT_FEEDRATE;
|
2015-01-28 09:08:48 +00:00
|
|
|
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 06:08:58 +00:00
|
|
|
for (uint8_t q = 0; q < COUNT(filament_size); q++)
|
2015-07-24 01:08:06 +00:00
|
|
|
filament_size[q] = DEFAULT_NOMINAL_FILAMENT_DIA;
|
2016-06-30 01:19:26 +00:00
|
|
|
|
|
|
|
Config_Postprocess();
|
2015-01-28 09:08:48 +00:00
|
|
|
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPGM("Hardcoded Default Settings Loaded");
|
|
|
|
}
|
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if DISABLED(DISABLE_M503)
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2015-04-27 01:44:01 +00:00
|
|
|
#define CONFIG_ECHO_START do{ if (!forReplay) SERIAL_ECHO_START; }while(0)
|
|
|
|
|
2016-06-30 01:18:46 +00:00
|
|
|
/**
|
|
|
|
* M503 - Print Configuration
|
|
|
|
*/
|
2015-01-28 09:08:48 +00:00
|
|
|
void Config_PrintSettings(bool forReplay) {
|
|
|
|
// Always have this function, even with EEPROM_SETTINGS disabled, the current values will be shown
|
|
|
|
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00:00
|
|
|
|
|
|
|
if (!forReplay) {
|
2012-11-07 22:16:43 +00:00
|
|
|
SERIAL_ECHOLNPGM("Steps per unit:");
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00:00
|
|
|
}
|
2016-06-09 23:53:21 +00:00
|
|
|
SERIAL_ECHOPAIR(" M92 X", planner.axis_steps_per_mm[X_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" Y", planner.axis_steps_per_mm[Y_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" Z", planner.axis_steps_per_mm[Z_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" E", planner.axis_steps_per_mm[E_AXIS]);
|
2015-01-29 05:19:51 +00:00
|
|
|
SERIAL_EOL;
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(SCARA)
|
2015-01-28 09:08:48 +00:00
|
|
|
if (!forReplay) {
|
|
|
|
SERIAL_ECHOLNPGM("Scaling factors:");
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00: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-29 05:19:51 +00:00
|
|
|
SERIAL_EOL;
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00:00
|
|
|
#endif // SCARA
|
|
|
|
|
|
|
|
if (!forReplay) {
|
2012-11-07 22:16:43 +00:00
|
|
|
SERIAL_ECHOLNPGM("Maximum feedrates (mm/s):");
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00:00
|
|
|
}
|
2016-04-28 01:06:32 +00: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-29 05:19:51 +00: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 14:05:11 +00:00
|
|
|
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00:00
|
|
|
if (!forReplay) {
|
2012-11-07 22:16:43 +00:00
|
|
|
SERIAL_ECHOLNPGM("Maximum Acceleration (mm/s2):");
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00:00
|
|
|
}
|
2016-06-09 22:20:44 +00:00
|
|
|
SERIAL_ECHOPAIR(" M201 X", planner.max_acceleration_mm_per_s2[X_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" Y", planner.max_acceleration_mm_per_s2[Y_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" Z", planner.max_acceleration_mm_per_s2[Z_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" E", planner.max_acceleration_mm_per_s2[E_AXIS]);
|
2015-01-29 05:19:51 +00:00
|
|
|
SERIAL_EOL;
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00:00
|
|
|
if (!forReplay) {
|
2015-03-11 16:19:02 +00:00
|
|
|
SERIAL_ECHOLNPGM("Accelerations: P=printing, R=retract and T=travel");
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00:00
|
|
|
}
|
2016-04-28 01:06:32 +00:00
|
|
|
SERIAL_ECHOPAIR(" M204 P", planner.acceleration);
|
|
|
|
SERIAL_ECHOPAIR(" R", planner.retract_acceleration);
|
|
|
|
SERIAL_ECHOPAIR(" T", planner.travel_acceleration);
|
2015-01-29 05:19:51 +00: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 14:05:11 +00:00
|
|
|
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00: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 14:05:11 +00: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-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00:00
|
|
|
}
|
2016-04-28 01:06:32 +00: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-29 05:19:51 +00: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 14:05:11 +00:00
|
|
|
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00:00
|
|
|
if (!forReplay) {
|
2016-06-27 23:29:35 +00:00
|
|
|
SERIAL_ECHOLNPGM("Home offset (mm)");
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00:00
|
|
|
}
|
2015-04-27 01:44:01 +00: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-29 05:19:51 +00:00
|
|
|
SERIAL_EOL;
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2015-04-27 01:44:01 +00:00
|
|
|
if (!forReplay) {
|
|
|
|
SERIAL_ECHOLNPGM("Mesh bed leveling:");
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
}
|
2016-05-24 20:53:15 +00:00
|
|
|
SERIAL_ECHOPAIR(" M420 S", mbl.has_mesh() ? 1 : 0);
|
2016-04-07 05:40:45 +00:00
|
|
|
SERIAL_ECHOPAIR(" X", MESH_NUM_X_POINTS);
|
|
|
|
SERIAL_ECHOPAIR(" Y", MESH_NUM_Y_POINTS);
|
2015-04-27 01:44:01 +00:00
|
|
|
SERIAL_EOL;
|
2016-05-23 20:49:29 +00: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-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2016-05-23 20:49:29 +00:00
|
|
|
SERIAL_ECHOPAIR(" G29 S3 X", px);
|
|
|
|
SERIAL_ECHOPAIR(" Y", py);
|
2016-05-14 23:19:37 +00:00
|
|
|
SERIAL_ECHOPGM(" Z");
|
2016-05-23 20:49:29 +00:00
|
|
|
SERIAL_PROTOCOL_F(mbl.z_values[py-1][px-1], 5);
|
2015-04-27 01:44:01 +00:00
|
|
|
SERIAL_EOL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(DELTA)
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00:00
|
|
|
if (!forReplay) {
|
2015-04-09 09:04:06 +00:00
|
|
|
SERIAL_ECHOLNPGM("Endstop adjustment (mm):");
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00:00
|
|
|
}
|
2015-04-27 01:44:01 +00: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-29 05:19:51 +00:00
|
|
|
SERIAL_EOL;
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2016-02-17 21:05:12 +00:00
|
|
|
if (!forReplay) {
|
2016-03-19 12:43:50 +00:00
|
|
|
SERIAL_ECHOLNPGM("Delta settings: L=diagonal_rod, R=radius, S=segments_per_second, ABC=diagonal_rod_trim_tower_[123]");
|
2016-02-17 21:05:12 +00:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
}
|
2015-04-27 01:44:01 +00:00
|
|
|
SERIAL_ECHOPAIR(" M665 L", delta_diagonal_rod);
|
|
|
|
SERIAL_ECHOPAIR(" R", delta_radius);
|
|
|
|
SERIAL_ECHOPAIR(" S", delta_segments_per_second);
|
2016-03-19 12:43:50 +00: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-29 05:19:51 +00:00
|
|
|
SERIAL_EOL;
|
2015-07-31 05:31:45 +00:00
|
|
|
#elif ENABLED(Z_DUAL_ENDSTOPS)
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-03-24 17:06:44 +00:00
|
|
|
if (!forReplay) {
|
2015-04-09 09:04:06 +00:00
|
|
|
SERIAL_ECHOLNPGM("Z2 Endstop adjustment (mm):");
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-03-24 17:06:44 +00:00
|
|
|
}
|
2015-04-27 01:44:01 +00:00
|
|
|
SERIAL_ECHOPAIR(" M666 Z", z_endstop_adj);
|
2015-10-03 06:08:58 +00:00
|
|
|
SERIAL_EOL;
|
2015-01-28 09:08:48 +00:00
|
|
|
#endif // DELTA
|
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(ULTIPANEL)
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
if (!forReplay) {
|
|
|
|
SERIAL_ECHOLNPGM("Material heatup parameters:");
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
}
|
2016-04-07 05:40:45 +00:00
|
|
|
SERIAL_ECHOPAIR(" M145 S0 H", plaPreheatHotendTemp);
|
|
|
|
SERIAL_ECHOPAIR(" B", plaPreheatHPBTemp);
|
|
|
|
SERIAL_ECHOPAIR(" F", plaPreheatFanSpeed);
|
2015-04-27 01:44:01 +00:00
|
|
|
SERIAL_EOL;
|
|
|
|
CONFIG_ECHO_START;
|
2016-04-07 05:40:45 +00:00
|
|
|
SERIAL_ECHOPAIR(" M145 S1 H", absPreheatHotendTemp);
|
|
|
|
SERIAL_ECHOPAIR(" B", absPreheatHPBTemp);
|
|
|
|
SERIAL_ECHOPAIR(" F", absPreheatFanSpeed);
|
2015-04-27 01:44:01 +00:00
|
|
|
SERIAL_EOL;
|
|
|
|
#endif // ULTIPANEL
|
|
|
|
|
2016-04-20 01:09:29 +00:00
|
|
|
#if HAS_PID_HEATING
|
2015-04-27 01:44:01 +00:00
|
|
|
|
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00:00
|
|
|
if (!forReplay) {
|
|
|
|
SERIAL_ECHOLNPGM("PID settings:");
|
|
|
|
}
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(PIDTEMP)
|
2016-05-27 00:43:20 +00:00
|
|
|
#if HOTENDS > 1
|
2015-04-27 01:44:01 +00:00
|
|
|
if (forReplay) {
|
2016-05-27 00:43:20 +00:00
|
|
|
for (uint8_t i = 0; i < HOTENDS; i++) {
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2016-04-07 05:40:45 +00:00
|
|
|
SERIAL_ECHOPAIR(" M301 E", i);
|
2015-04-27 01:44:01 +00: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 05:31:45 +00:00
|
|
|
#if ENABLED(PID_ADD_EXTRUSION_RATE)
|
2015-04-27 01:44:01 +00:00
|
|
|
SERIAL_ECHOPAIR(" C", PID_PARAM(Kc, i));
|
2015-08-31 02:04:30 +00:00
|
|
|
if (i == 0) SERIAL_ECHOPAIR(" L", lpq_len);
|
|
|
|
#endif
|
2015-04-27 01:44:01 +00:00
|
|
|
SERIAL_EOL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2016-05-27 00:43:20 +00:00
|
|
|
#endif // HOTENDS > 1
|
|
|
|
// !forReplay || HOTENDS == 1
|
2015-04-27 01:44:01 +00:00
|
|
|
{
|
|
|
|
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 05:31:45 +00:00
|
|
|
#if ENABLED(PID_ADD_EXTRUSION_RATE)
|
2015-04-27 01:44:01 +00:00
|
|
|
SERIAL_ECHOPAIR(" C", PID_PARAM(Kc, 0));
|
2015-08-31 02:04:30 +00:00
|
|
|
SERIAL_ECHOPAIR(" L", lpq_len);
|
|
|
|
#endif
|
2015-04-27 01:44:01 +00:00
|
|
|
SERIAL_EOL;
|
|
|
|
}
|
|
|
|
#endif // PIDTEMP
|
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(PIDTEMPBED)
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2016-04-29 01:18:13 +00:00
|
|
|
SERIAL_ECHOPAIR(" M304 P", thermalManager.bedKp);
|
|
|
|
SERIAL_ECHOPAIR(" I", unscalePID_i(thermalManager.bedKi));
|
|
|
|
SERIAL_ECHOPAIR(" D", unscalePID_d(thermalManager.bedKd));
|
2015-04-03 23:38:05 +00:00
|
|
|
SERIAL_EOL;
|
|
|
|
#endif
|
2015-04-27 01:44:01 +00:00
|
|
|
|
|
|
|
#endif // PIDTEMP || PIDTEMPBED
|
|
|
|
|
2016-05-31 18:47:02 +00:00
|
|
|
#if HAS_LCD_CONTRAST
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
if (!forReplay) {
|
|
|
|
SERIAL_ECHOLNPGM("LCD Contrast:");
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
}
|
2016-04-07 05:40:45 +00:00
|
|
|
SERIAL_ECHOPAIR(" M250 C", lcd_contrast);
|
2015-04-27 01:44:01 +00:00
|
|
|
SERIAL_EOL;
|
2015-04-03 23:38:05 +00:00
|
|
|
#endif
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(FWRETRACT)
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00:00
|
|
|
if (!forReplay) {
|
|
|
|
SERIAL_ECHOLNPGM("Retract: S=Length (mm) F:Speed (mm/m) Z: ZLift (mm)");
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00:00
|
|
|
}
|
2015-04-03 23:41:58 +00:00
|
|
|
SERIAL_ECHOPAIR(" M207 S", retract_length);
|
2015-04-27 01:44:01 +00:00
|
|
|
#if EXTRUDERS > 1
|
|
|
|
SERIAL_ECHOPAIR(" W", retract_length_swap);
|
|
|
|
#endif
|
2016-06-22 10:27:31 +00:00
|
|
|
SERIAL_ECHOPAIR(" F", retract_feedrate_mm_s * 60);
|
2015-01-28 09:08:48 +00:00
|
|
|
SERIAL_ECHOPAIR(" Z", retract_zlift);
|
2015-01-29 05:19:51 +00:00
|
|
|
SERIAL_EOL;
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00:00
|
|
|
if (!forReplay) {
|
|
|
|
SERIAL_ECHOLNPGM("Recover: S=Extra length (mm) F:Speed (mm/m)");
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00:00
|
|
|
}
|
2015-04-03 23:41:58 +00:00
|
|
|
SERIAL_ECHOPAIR(" M208 S", retract_recover_length);
|
2015-04-27 01:44:01 +00:00
|
|
|
#if EXTRUDERS > 1
|
|
|
|
SERIAL_ECHOPAIR(" W", retract_recover_length_swap);
|
|
|
|
#endif
|
2015-10-03 06:08:58 +00:00
|
|
|
SERIAL_ECHOPAIR(" F", retract_recover_feedrate * 60);
|
2015-01-29 05:19:51 +00:00
|
|
|
SERIAL_EOL;
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00:00
|
|
|
if (!forReplay) {
|
|
|
|
SERIAL_ECHOLNPGM("Auto-Retract: S=0 to disable, 1 to interpret extrude-only moves as retracts or recoveries");
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-01-28 09:08:48 +00:00
|
|
|
}
|
2016-06-27 23:29:35 +00:00
|
|
|
SERIAL_ECHOPAIR(" M209 S", autoretract_enabled ? 1 : 0);
|
2015-01-29 05:19:51 +00:00
|
|
|
SERIAL_EOL;
|
2015-01-28 09:08:48 +00:00
|
|
|
|
|
|
|
#endif // FWRETRACT
|
2012-11-07 22:16:43 +00:00
|
|
|
|
2015-07-24 00:20:02 +00:00
|
|
|
/**
|
|
|
|
* Volumetric extrusion M200
|
|
|
|
*/
|
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPGM("Filament settings:");
|
|
|
|
if (volumetric_enabled)
|
|
|
|
SERIAL_EOL;
|
|
|
|
else
|
|
|
|
SERIAL_ECHOLNPGM(" Disabled");
|
|
|
|
}
|
2015-04-27 01:44:01 +00:00
|
|
|
|
2015-07-24 00:20:02 +00:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR(" M200 D", filament_size[0]);
|
|
|
|
SERIAL_EOL;
|
|
|
|
#if EXTRUDERS > 1
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-07-24 00:20:02 +00:00
|
|
|
SERIAL_ECHOPAIR(" M200 T1 D", filament_size[1]);
|
2015-01-29 05:19:51 +00:00
|
|
|
SERIAL_EOL;
|
2015-07-24 00:20:02 +00:00
|
|
|
#if EXTRUDERS > 2
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-07-24 00:20:02 +00:00
|
|
|
SERIAL_ECHOPAIR(" M200 T2 D", filament_size[2]);
|
2015-01-29 05:19:51 +00:00
|
|
|
SERIAL_EOL;
|
2015-07-24 00:20:02 +00:00
|
|
|
#if EXTRUDERS > 3
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2015-07-24 00:20:02 +00:00
|
|
|
SERIAL_ECHOPAIR(" M200 T3 D", filament_size[3]);
|
2015-01-29 05:19:51 +00:00
|
|
|
SERIAL_EOL;
|
2015-01-28 09:08:48 +00:00
|
|
|
#endif
|
|
|
|
#endif
|
2015-07-24 00:20:02 +00:00
|
|
|
#endif
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2015-07-24 00:20:02 +00:00
|
|
|
if (!volumetric_enabled) {
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPGM(" M200 D0");
|
2015-01-28 09:08:48 +00:00
|
|
|
}
|
|
|
|
|
2015-07-24 00:20:02 +00:00
|
|
|
/**
|
|
|
|
* Auto Bed Leveling
|
|
|
|
*/
|
2016-06-15 01:05:20 +00:00
|
|
|
#if HAS_BED_PROBE
|
|
|
|
if (!forReplay) {
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2016-06-15 01:05:20 +00:00
|
|
|
SERIAL_ECHOLNPGM("Z-Probe Offset (mm):");
|
|
|
|
}
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR(" M851 Z", zprobe_zoffset);
|
2015-01-29 05:19:51 +00:00
|
|
|
SERIAL_EOL;
|
2015-01-28 09:08:48 +00:00
|
|
|
#endif
|
2012-11-07 22:16:43 +00: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 14:05:11 +00:00
|
|
|
|
2015-01-28 09:08:48 +00:00
|
|
|
#endif // !DISABLE_M503
|