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-10-02 04:37:13 -05:00
|
|
|
#define EEPROM_VERSION "V26"
|
2015-04-03 18:38:05 -05:00
|
|
|
|
2016-06-29 20:18:46 -05:00
|
|
|
// Change EEPROM version if these are changed:
|
|
|
|
#define EEPROM_OFFSET 100
|
2016-06-30 02:07:31 -05:00
|
|
|
#define MAX_EXTRUDERS 4
|
2016-06-29 20:18:46 -05:00
|
|
|
|
2015-04-03 18:38:05 -05:00
|
|
|
/**
|
2016-06-29 20:12:23 -05:00
|
|
|
* V24 EEPROM Layout:
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
2016-02-17 15:05:12 -06:00
|
|
|
* 100 Version (char x4)
|
2016-06-29 20:12:23 -05:00
|
|
|
* 104 EEPROM Checksum (uint16_t)
|
2016-02-17 15:05:12 -06:00
|
|
|
*
|
2016-06-29 20:12:23 -05:00
|
|
|
* 106 M92 XYZE planner.axis_steps_per_mm (float x4)
|
2016-07-15 20:49:34 -05:00
|
|
|
* 122 M203 XYZE planner.max_feedrate_mm_s (float x4)
|
2016-06-29 20:12:23 -05:00
|
|
|
* 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)
|
2016-07-15 20:49:34 -05:00
|
|
|
* 166 M205 S planner.min_feedrate_mm_s (float)
|
|
|
|
* 170 M205 T planner.min_travel_feedrate_mm_s (float)
|
2016-06-29 20:12:23 -05:00
|
|
|
* 174 M205 B planner.min_segment_time (ulong)
|
2016-10-02 04:37:13 -05:00
|
|
|
* 178 M205 X planner.max_jerk[X_AXIS] (float)
|
|
|
|
* 182 M205 Y planner.max_jerk[Y_AXIS] (float)
|
|
|
|
* 186 M205 Z planner.max_jerk[Z_AXIS] (float)
|
|
|
|
* 190 M205 E planner.max_jerk[E_AXIS] (float)
|
|
|
|
* 194 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-10-02 04:37:13 -05:00
|
|
|
* 206 M420 S status (uint8)
|
|
|
|
* 207 z_offset (float)
|
|
|
|
* 211 mesh_num_x (uint8 as set in firmware)
|
|
|
|
* 212 mesh_num_y (uint8 as set in firmware)
|
|
|
|
* 213 G29 S3 XYZ z_values[][] (float x9, by default, up to float x 81)
|
2016-03-24 16:16:09 -05:00
|
|
|
*
|
|
|
|
* AUTO BED LEVELING
|
2016-10-02 04:37:13 -05:00
|
|
|
* 249 M851 zprobe_zoffset (float)
|
2015-03-15 17:18:11 -05:00
|
|
|
*
|
2015-01-28 03:08:48 -06:00
|
|
|
* DELTA:
|
2016-10-02 04:37:13 -05:00
|
|
|
* 253 M666 XYZ endstop_adj (float x3)
|
|
|
|
* 265 M665 R delta_radius (float)
|
|
|
|
* 269 M665 L delta_diagonal_rod (float)
|
|
|
|
* 273 M665 S delta_segments_per_second (float)
|
|
|
|
* 277 M665 A delta_diagonal_rod_trim_tower_1 (float)
|
|
|
|
* 281 M665 B delta_diagonal_rod_trim_tower_2 (float)
|
|
|
|
* 285 M665 C delta_diagonal_rod_trim_tower_3 (float)
|
2016-02-17 15:05:12 -06:00
|
|
|
*
|
|
|
|
* Z_DUAL_ENDSTOPS:
|
2016-10-02 04:37:13 -05:00
|
|
|
* 289 M666 Z z_endstop_adj (float)
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
|
|
|
* ULTIPANEL:
|
2016-10-02 04:37:13 -05:00
|
|
|
* 293 M145 S0 H preheatHotendTemp1 (int)
|
|
|
|
* 295 M145 S0 B preheatBedTemp1 (int)
|
|
|
|
* 297 M145 S0 F preheatFanSpeed1 (int)
|
|
|
|
* 299 M145 S1 H preheatHotendTemp2 (int)
|
|
|
|
* 301 M145 S1 B preheatBedTemp2 (int)
|
|
|
|
* 303 M145 S1 F preheatFanSpeed2 (int)
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
|
|
|
* PIDTEMP:
|
2016-10-02 04:37:13 -05:00
|
|
|
* 305 M301 E0 PIDC Kp[0], Ki[0], Kd[0], Kc[0] (float x4)
|
|
|
|
* 321 M301 E1 PIDC Kp[1], Ki[1], Kd[1], Kc[1] (float x4)
|
|
|
|
* 337 M301 E2 PIDC Kp[2], Ki[2], Kd[2], Kc[2] (float x4)
|
|
|
|
* 353 M301 E3 PIDC Kp[3], Ki[3], Kd[3], Kc[3] (float x4)
|
|
|
|
* 369 M301 L lpq_len (int)
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
2015-04-03 18:38:05 -05:00
|
|
|
* PIDTEMPBED:
|
2016-10-02 04:37:13 -05:00
|
|
|
* 371 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-10-02 04:37:13 -05:00
|
|
|
* 383 M250 C lcd_contrast (int)
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
|
|
|
* FWRETRACT:
|
2016-10-02 04:37:13 -05:00
|
|
|
* 385 M209 S autoretract_enabled (bool)
|
|
|
|
* 386 M207 S retract_length (float)
|
|
|
|
* 390 M207 W retract_length_swap (float)
|
|
|
|
* 394 M207 F retract_feedrate_mm_s (float)
|
|
|
|
* 399 M207 Z retract_zlift (float)
|
|
|
|
* 402 M208 S retract_recover_length (float)
|
|
|
|
* 406 M208 W retract_recover_length_swap (float)
|
|
|
|
* 410 M208 F retract_recover_feedrate_mm_s (float)
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
2016-02-17 15:05:12 -06:00
|
|
|
* Volumetric Extrusion:
|
2016-10-02 04:37:13 -05:00
|
|
|
* 414 M200 D volumetric_enabled (bool)
|
|
|
|
* 415 M200 T D filament_size (float x4) (T0..3)
|
2015-01-28 03:08:48 -06:00
|
|
|
*
|
2016-10-02 04:37:13 -05:00
|
|
|
* 431 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"
|
2016-07-14 18:12:20 -05:00
|
|
|
#include "endstops.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
|
|
|
|
2016-06-29 20:12:23 -05:00
|
|
|
uint16_t eeprom_checksum;
|
|
|
|
const char version[4] = EEPROM_VERSION;
|
|
|
|
|
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);
|
|
|
|
}
|
2016-06-29 20:12:23 -05:00
|
|
|
eeprom_checksum += c;
|
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 {
|
2016-06-29 20:12:23 -05:00
|
|
|
uint8_t c = eeprom_read_byte((unsigned char*)pos);
|
|
|
|
*value = c;
|
|
|
|
eeprom_checksum += c;
|
2015-01-28 03:08:48 -06: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 09:05:11 -05:00
|
|
|
}
|
2012-11-07 16:16:43 -06:00
|
|
|
|
2015-04-26 20:44:01 -05:00
|
|
|
/**
|
2016-06-29 20:19:26 -05:00
|
|
|
* Post-process after Retrieve or Reset
|
2015-04-26 20:44:01 -05:00
|
|
|
*/
|
2016-06-29 20:19:26 -05:00
|
|
|
void Config_Postprocess() {
|
|
|
|
// steps per s2 needs to be updated to agree with units per s2
|
|
|
|
planner.reset_acceleration_rates();
|
|
|
|
|
2016-07-23 21:36:26 -05:00
|
|
|
// Make sure delta kinematics are updated before refreshing the
|
|
|
|
// planner position so the stepper counts will be set correctly.
|
2016-06-29 20:19:26 -05:00
|
|
|
#if ENABLED(DELTA)
|
|
|
|
recalc_delta_settings(delta_radius, delta_diagonal_rod);
|
|
|
|
#endif
|
2012-11-07 16:16:43 -06:00
|
|
|
|
2016-07-23 21:36:26 -05:00
|
|
|
// Refresh steps_to_mm with the reciprocal of axis_steps_per_mm
|
|
|
|
// and init stepper.count[], planner.position[] with current_position
|
|
|
|
planner.refresh_positioning();
|
|
|
|
|
2016-06-29 20:19:26 -05:00
|
|
|
#if ENABLED(PIDTEMP)
|
|
|
|
thermalManager.updatePID();
|
|
|
|
#endif
|
2012-11-07 16:16:43 -06:00
|
|
|
|
2016-06-29 20:19:26 -05:00
|
|
|
calculate_volumetric_multipliers();
|
2016-08-19 01:00:46 -05:00
|
|
|
|
|
|
|
// Software endstops depend on home_offset
|
|
|
|
LOOP_XYZ(i) update_software_endstops((AxisEnum)i);
|
2016-06-29 20:19:26 -05:00
|
|
|
}
|
2012-11-07 16:16:43 -06:00
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(EEPROM_SETTINGS)
|
2015-01-28 03:08:48 -06:00
|
|
|
|
2016-06-29 20:18:46 -05:00
|
|
|
#define DUMMY_PID_VALUE 3000.0f
|
2016-07-24 12:19:49 -05:00
|
|
|
#define EEPROM_START() int eeprom_index = EEPROM_OFFSET
|
|
|
|
#define EEPROM_SKIP(VAR) eeprom_index += sizeof(VAR)
|
|
|
|
#define EEPROM_WRITE(VAR) _EEPROM_writeData(eeprom_index, (uint8_t*)&VAR, sizeof(VAR))
|
|
|
|
#define EEPROM_READ(VAR) _EEPROM_readData(eeprom_index, (uint8_t*)&VAR, sizeof(VAR))
|
2016-06-29 20:18:46 -05:00
|
|
|
|
2016-02-17 15:05:12 -06:00
|
|
|
/**
|
2016-06-29 20:18:46 -05:00
|
|
|
* M500 - Store Configuration
|
2016-02-17 15:05:12 -06:00
|
|
|
*/
|
2015-01-28 03:08:48 -06:00
|
|
|
void Config_StoreSettings() {
|
|
|
|
float dummy = 0.0f;
|
|
|
|
char ver[4] = "000";
|
2016-06-29 20:12:23 -05:00
|
|
|
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_START();
|
|
|
|
|
|
|
|
EEPROM_WRITE(ver); // invalidate data first
|
|
|
|
EEPROM_SKIP(eeprom_checksum); // Skip the checksum slot
|
2016-06-29 20:12:23 -05:00
|
|
|
|
|
|
|
eeprom_checksum = 0; // clear before first "real data"
|
|
|
|
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(planner.axis_steps_per_mm);
|
|
|
|
EEPROM_WRITE(planner.max_feedrate_mm_s);
|
|
|
|
EEPROM_WRITE(planner.max_acceleration_mm_per_s2);
|
|
|
|
EEPROM_WRITE(planner.acceleration);
|
|
|
|
EEPROM_WRITE(planner.retract_acceleration);
|
|
|
|
EEPROM_WRITE(planner.travel_acceleration);
|
|
|
|
EEPROM_WRITE(planner.min_feedrate_mm_s);
|
|
|
|
EEPROM_WRITE(planner.min_travel_feedrate_mm_s);
|
|
|
|
EEPROM_WRITE(planner.min_segment_time);
|
2016-10-02 04:37:13 -05:00
|
|
|
EEPROM_WRITE(planner.max_jerk);
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(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-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(dummy_uint8);
|
|
|
|
EEPROM_WRITE(mbl.z_offset);
|
|
|
|
EEPROM_WRITE(mesh_num_x);
|
|
|
|
EEPROM_WRITE(mesh_num_y);
|
|
|
|
EEPROM_WRITE(mbl.z_values);
|
2015-03-18 15:00:31 -05:00
|
|
|
#else
|
2016-06-30 02:29:16 -05:00
|
|
|
// For disabled MBL write a default mesh
|
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;
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(dummy_uint8);
|
|
|
|
EEPROM_WRITE(dummy);
|
|
|
|
EEPROM_WRITE(mesh_num_x);
|
|
|
|
EEPROM_WRITE(mesh_num_y);
|
|
|
|
for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_WRITE(dummy);
|
2015-03-25 23:14:00 -05:00
|
|
|
#endif // MESH_BED_LEVELING
|
|
|
|
|
2016-06-14 20:05:20 -05:00
|
|
|
#if !HAS_BED_PROBE
|
2015-03-25 23:14:00 -05:00
|
|
|
float zprobe_zoffset = 0;
|
|
|
|
#endif
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(zprobe_zoffset);
|
2015-03-15 17:18:11 -05:00
|
|
|
|
2016-06-30 02:29:16 -05:00
|
|
|
// 9 floats for DELTA / Z_DUAL_ENDSTOPS
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(DELTA)
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(endstop_adj); // 3 floats
|
|
|
|
EEPROM_WRITE(delta_radius); // 1 float
|
|
|
|
EEPROM_WRITE(delta_diagonal_rod); // 1 float
|
|
|
|
EEPROM_WRITE(delta_segments_per_second); // 1 float
|
|
|
|
EEPROM_WRITE(delta_diagonal_rod_trim_tower_1); // 1 float
|
|
|
|
EEPROM_WRITE(delta_diagonal_rod_trim_tower_2); // 1 float
|
|
|
|
EEPROM_WRITE(delta_diagonal_rod_trim_tower_3); // 1 float
|
2015-07-31 00:31:45 -05:00
|
|
|
#elif ENABLED(Z_DUAL_ENDSTOPS)
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(z_endstop_adj); // 1 float
|
2015-03-24 12:06:44 -05:00
|
|
|
dummy = 0.0f;
|
2016-07-24 12:19:49 -05:00
|
|
|
for (uint8_t q = 8; q--;) EEPROM_WRITE(dummy);
|
2015-01-28 03:08:48 -06:00
|
|
|
#else
|
|
|
|
dummy = 0.0f;
|
2016-07-24 12:19:49 -05:00
|
|
|
for (uint8_t q = 9; q--;) EEPROM_WRITE(dummy);
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if DISABLED(ULTIPANEL)
|
2016-07-09 17:20:12 -05:00
|
|
|
int preheatHotendTemp1 = PREHEAT_1_TEMP_HOTEND, preheatBedTemp1 = PREHEAT_1_TEMP_BED, preheatFanSpeed1 = PREHEAT_1_FAN_SPEED,
|
|
|
|
preheatHotendTemp2 = PREHEAT_2_TEMP_HOTEND, preheatBedTemp2 = PREHEAT_2_TEMP_BED, preheatFanSpeed2 = PREHEAT_2_FAN_SPEED;
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif // !ULTIPANEL
|
|
|
|
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(preheatHotendTemp1);
|
|
|
|
EEPROM_WRITE(preheatBedTemp1);
|
|
|
|
EEPROM_WRITE(preheatFanSpeed1);
|
|
|
|
EEPROM_WRITE(preheatHotendTemp2);
|
|
|
|
EEPROM_WRITE(preheatBedTemp2);
|
|
|
|
EEPROM_WRITE(preheatFanSpeed2);
|
2015-03-25 23:14:00 -05:00
|
|
|
|
2016-06-30 02:07:31 -05:00
|
|
|
for (uint8_t e = 0; e < MAX_EXTRUDERS; e++) {
|
2015-01-28 03:08:48 -06:00
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(PIDTEMP)
|
2016-05-26 19:43:20 -05:00
|
|
|
if (e < HOTENDS) {
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(PID_PARAM(Kp, e));
|
|
|
|
EEPROM_WRITE(PID_PARAM(Ki, e));
|
|
|
|
EEPROM_WRITE(PID_PARAM(Kd, e));
|
2016-07-31 19:49:34 -05:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(PID_PARAM(Kc, e));
|
2015-01-28 03:08:48 -06:00
|
|
|
#else
|
|
|
|
dummy = 1.0f; // 1.0 = default kc
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(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-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(dummy); // Kp
|
2015-01-28 22:48:32 -06:00
|
|
|
dummy = 0.0f;
|
2016-07-24 12:19:49 -05:00
|
|
|
for (uint8_t q = 3; q--;) EEPROM_WRITE(dummy); // Ki, Kd, Kc
|
2015-01-28 22:48:32 -06:00
|
|
|
}
|
|
|
|
|
2016-05-26 19:43:20 -05:00
|
|
|
} // Hotends Loop
|
2015-01-28 03:08:48 -06:00
|
|
|
|
2016-07-31 19:49:34 -05:00
|
|
|
#if DISABLED(PID_EXTRUSION_SCALING)
|
2015-08-30 21:04:30 -05:00
|
|
|
int lpq_len = 20;
|
|
|
|
#endif
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(lpq_len);
|
2015-08-30 21:04:30 -05:00
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if DISABLED(PIDTEMPBED)
|
2016-04-28 20:18:13 -05:00
|
|
|
dummy = DUMMY_PID_VALUE;
|
2016-07-24 12:19:49 -05:00
|
|
|
for (uint8_t q = 3; q--;) EEPROM_WRITE(dummy);
|
2016-04-28 20:18:13 -05:00
|
|
|
#else
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(thermalManager.bedKp);
|
|
|
|
EEPROM_WRITE(thermalManager.bedKi);
|
|
|
|
EEPROM_WRITE(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
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(lcd_contrast);
|
2015-01-28 03:08:48 -06:00
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(FWRETRACT)
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(autoretract_enabled);
|
|
|
|
EEPROM_WRITE(retract_length);
|
2015-01-28 03:08:48 -06:00
|
|
|
#if EXTRUDERS > 1
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(retract_length_swap);
|
2015-01-28 03:08:48 -06:00
|
|
|
#else
|
|
|
|
dummy = 0.0f;
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(dummy);
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(retract_feedrate_mm_s);
|
|
|
|
EEPROM_WRITE(retract_zlift);
|
|
|
|
EEPROM_WRITE(retract_recover_length);
|
2015-01-28 03:08:48 -06:00
|
|
|
#if EXTRUDERS > 1
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(retract_recover_length_swap);
|
2015-01-28 03:08:48 -06:00
|
|
|
#else
|
|
|
|
dummy = 0.0f;
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(dummy);
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(retract_recover_feedrate_mm_s);
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif // FWRETRACT
|
2014-12-28 19:43:14 -06:00
|
|
|
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(volumetric_enabled);
|
2015-01-28 03:08:48 -06:00
|
|
|
|
|
|
|
// Save filament sizes
|
2016-06-30 02:07:31 -05:00
|
|
|
for (uint8_t q = 0; q < MAX_EXTRUDERS; q++) {
|
2016-06-28 17:06:56 -05:00
|
|
|
if (q < COUNT(filament_size)) dummy = filament_size[q];
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_WRITE(dummy);
|
2015-01-28 03:08:48 -06:00
|
|
|
}
|
|
|
|
|
2016-07-24 12:19:49 -05:00
|
|
|
uint16_t final_checksum = eeprom_checksum,
|
|
|
|
eeprom_size = eeprom_index;
|
2016-06-29 20:12:23 -05:00
|
|
|
|
2016-07-24 12:19:49 -05:00
|
|
|
eeprom_index = EEPROM_OFFSET;
|
|
|
|
EEPROM_WRITE(version);
|
|
|
|
EEPROM_WRITE(final_checksum);
|
2015-01-28 03:08:48 -06:00
|
|
|
|
|
|
|
// Report storage size
|
2012-11-07 16:16:43 -06:00
|
|
|
SERIAL_ECHO_START;
|
2016-07-24 12:19:49 -05:00
|
|
|
SERIAL_ECHOPAIR("Settings Stored (", eeprom_size);
|
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
|
|
|
/**
|
2016-06-29 20:18:46 -05:00
|
|
|
* M501 - Retrieve Configuration
|
2015-04-26 20:44:01 -05:00
|
|
|
*/
|
2015-01-28 03:08:48 -06:00
|
|
|
void Config_RetrieveSettings() {
|
2016-07-24 12:19:49 -05:00
|
|
|
|
|
|
|
EEPROM_START();
|
|
|
|
|
2015-01-28 03:08:48 -06:00
|
|
|
char stored_ver[4];
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(stored_ver);
|
|
|
|
|
2016-06-29 20:12:23 -05:00
|
|
|
uint16_t stored_checksum;
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(stored_checksum);
|
|
|
|
|
2016-06-27 21:33:37 -05:00
|
|
|
// SERIAL_ECHOPAIR("Version: [", ver);
|
|
|
|
// SERIAL_ECHOPAIR("] Stored version: [", stored_ver);
|
|
|
|
// SERIAL_ECHOLNPGM("]");
|
2015-01-28 03:08:48 -06:00
|
|
|
|
2016-06-29 20:12:23 -05:00
|
|
|
if (strncmp(version, stored_ver, 3) != 0) {
|
2015-01-28 03:08:48 -06:00
|
|
|
Config_ResetDefault();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
float dummy = 0;
|
|
|
|
|
2016-06-29 20:12:23 -05:00
|
|
|
eeprom_checksum = 0; // clear before reading first "real data"
|
|
|
|
|
2015-01-28 03:08:48 -06:00
|
|
|
// version number match
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(planner.axis_steps_per_mm);
|
|
|
|
EEPROM_READ(planner.max_feedrate_mm_s);
|
|
|
|
EEPROM_READ(planner.max_acceleration_mm_per_s2);
|
|
|
|
|
|
|
|
EEPROM_READ(planner.acceleration);
|
|
|
|
EEPROM_READ(planner.retract_acceleration);
|
|
|
|
EEPROM_READ(planner.travel_acceleration);
|
|
|
|
EEPROM_READ(planner.min_feedrate_mm_s);
|
|
|
|
EEPROM_READ(planner.min_travel_feedrate_mm_s);
|
|
|
|
EEPROM_READ(planner.min_segment_time);
|
2016-10-02 04:37:13 -05:00
|
|
|
EEPROM_READ(planner.max_jerk);
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(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;
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(dummy_uint8);
|
|
|
|
EEPROM_READ(dummy);
|
|
|
|
EEPROM_READ(mesh_num_x);
|
|
|
|
EEPROM_READ(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) {
|
2016-06-30 02:29:16 -05:00
|
|
|
// EEPROM data fits the current mesh
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(mbl.z_values);
|
2016-06-30 02:29:16 -05:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
// EEPROM data is stale
|
2015-04-26 23:06:04 -05:00
|
|
|
mbl.reset();
|
2016-07-24 12:19:49 -05:00
|
|
|
for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_READ(dummy);
|
2015-03-18 15:00:31 -05:00
|
|
|
}
|
|
|
|
#else
|
2016-06-30 02:29:16 -05:00
|
|
|
// MBL is disabled - skip the stored data
|
2016-07-24 12:19:49 -05:00
|
|
|
for (uint8_t q = 0; q < mesh_num_x * mesh_num_y; q++) EEPROM_READ(dummy);
|
2015-04-26 23:06:04 -05:00
|
|
|
#endif // MESH_BED_LEVELING
|
2015-03-15 17:18:11 -05:00
|
|
|
|
2016-06-14 20:05:20 -05:00
|
|
|
#if !HAS_BED_PROBE
|
2015-03-25 23:14:00 -05:00
|
|
|
float zprobe_zoffset = 0;
|
|
|
|
#endif
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(zprobe_zoffset);
|
2015-03-25 23:14:00 -05:00
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(DELTA)
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(endstop_adj); // 3 floats
|
|
|
|
EEPROM_READ(delta_radius); // 1 float
|
|
|
|
EEPROM_READ(delta_diagonal_rod); // 1 float
|
|
|
|
EEPROM_READ(delta_segments_per_second); // 1 float
|
|
|
|
EEPROM_READ(delta_diagonal_rod_trim_tower_1); // 1 float
|
|
|
|
EEPROM_READ(delta_diagonal_rod_trim_tower_2); // 1 float
|
|
|
|
EEPROM_READ(delta_diagonal_rod_trim_tower_3); // 1 float
|
2015-07-31 00:31:45 -05:00
|
|
|
#elif ENABLED(Z_DUAL_ENDSTOPS)
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(z_endstop_adj);
|
2015-03-24 12:06:44 -05:00
|
|
|
dummy = 0.0f;
|
2016-07-24 12:19:49 -05:00
|
|
|
for (uint8_t q=8; q--;) EEPROM_READ(dummy);
|
2015-01-28 03:08:48 -06:00
|
|
|
#else
|
2015-03-24 12:06:44 -05:00
|
|
|
dummy = 0.0f;
|
2016-07-24 12:19:49 -05:00
|
|
|
for (uint8_t q=9; q--;) EEPROM_READ(dummy);
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif
|
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if DISABLED(ULTIPANEL)
|
2016-07-09 17:20:12 -05:00
|
|
|
int preheatHotendTemp1, preheatBedTemp1, preheatFanSpeed1,
|
|
|
|
preheatHotendTemp2, preheatBedTemp2, preheatFanSpeed2;
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif
|
|
|
|
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(preheatHotendTemp1);
|
|
|
|
EEPROM_READ(preheatBedTemp1);
|
|
|
|
EEPROM_READ(preheatFanSpeed1);
|
|
|
|
EEPROM_READ(preheatHotendTemp2);
|
|
|
|
EEPROM_READ(preheatBedTemp2);
|
|
|
|
EEPROM_READ(preheatFanSpeed2);
|
2015-01-28 03:08:48 -06:00
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(PIDTEMP)
|
2016-06-30 02:07:31 -05:00
|
|
|
for (uint8_t e = 0; e < MAX_EXTRUDERS; e++) {
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(dummy); // Kp
|
2016-05-26 19:43:20 -05:00
|
|
|
if (e < HOTENDS && dummy != DUMMY_PID_VALUE) {
|
2015-01-28 03:08:48 -06:00
|
|
|
// do not need to scale PID values as the values in EEPROM are already scaled
|
|
|
|
PID_PARAM(Kp, e) = dummy;
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(PID_PARAM(Ki, e));
|
|
|
|
EEPROM_READ(PID_PARAM(Kd, e));
|
2016-07-31 19:49:34 -05:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(PID_PARAM(Kc, e));
|
2015-01-28 03:08:48 -06:00
|
|
|
#else
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(dummy);
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
else {
|
2016-07-24 12:19:49 -05:00
|
|
|
for (uint8_t q=3; q--;) EEPROM_READ(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-07-24 12:19:49 -05:00
|
|
|
for (uint8_t q = MAX_EXTRUDERS * 4; q--;) EEPROM_READ(dummy); // Kp, Ki, Kd, Kc
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif // !PIDTEMP
|
|
|
|
|
2016-07-31 19:49:34 -05:00
|
|
|
#if DISABLED(PID_EXTRUSION_SCALING)
|
2015-08-30 21:04:30 -05:00
|
|
|
int lpq_len;
|
|
|
|
#endif
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(lpq_len);
|
2015-08-30 21:04:30 -05:00
|
|
|
|
2016-04-28 20:18:13 -05:00
|
|
|
#if ENABLED(PIDTEMPBED)
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(dummy); // bedKp
|
2016-04-28 20:18:13 -05:00
|
|
|
if (dummy != DUMMY_PID_VALUE) {
|
|
|
|
thermalManager.bedKp = dummy;
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(thermalManager.bedKi);
|
|
|
|
EEPROM_READ(thermalManager.bedKd);
|
2016-04-28 20:18:13 -05:00
|
|
|
}
|
|
|
|
#else
|
2016-07-24 12:19:49 -05:00
|
|
|
for (uint8_t q=3; q--;) EEPROM_READ(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
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(lcd_contrast);
|
2015-01-28 03:08:48 -06:00
|
|
|
|
2015-07-31 00:31:45 -05:00
|
|
|
#if ENABLED(FWRETRACT)
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(autoretract_enabled);
|
|
|
|
EEPROM_READ(retract_length);
|
2015-01-28 03:08:48 -06:00
|
|
|
#if EXTRUDERS > 1
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(retract_length_swap);
|
2015-01-28 03:08:48 -06:00
|
|
|
#else
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(dummy);
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(retract_feedrate_mm_s);
|
|
|
|
EEPROM_READ(retract_zlift);
|
|
|
|
EEPROM_READ(retract_recover_length);
|
2015-01-28 03:08:48 -06:00
|
|
|
#if EXTRUDERS > 1
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(retract_recover_length_swap);
|
2015-01-28 03:08:48 -06:00
|
|
|
#else
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(dummy);
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(retract_recover_feedrate_mm_s);
|
2015-01-28 03:08:48 -06:00
|
|
|
#endif // FWRETRACT
|
|
|
|
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(volumetric_enabled);
|
2015-01-28 03:08:48 -06:00
|
|
|
|
2016-06-30 02:07:31 -05:00
|
|
|
for (uint8_t q = 0; q < MAX_EXTRUDERS; q++) {
|
2016-07-24 12:19:49 -05:00
|
|
|
EEPROM_READ(dummy);
|
2016-06-28 17:06:56 -05:00
|
|
|
if (q < COUNT(filament_size)) filament_size[q] = dummy;
|
2015-01-28 03:08:48 -06:00
|
|
|
}
|
|
|
|
|
2016-06-29 20:12:23 -05:00
|
|
|
if (eeprom_checksum == stored_checksum) {
|
|
|
|
Config_Postprocess();
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHO(version);
|
2016-07-24 12:19:49 -05:00
|
|
|
SERIAL_ECHOPAIR(" stored settings retrieved (", eeprom_index);
|
2016-06-29 20:12:23 -05:00
|
|
|
SERIAL_ECHOLNPGM(" bytes)");
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
SERIAL_ERROR_START;
|
|
|
|
SERIAL_ERRORLNPGM("EEPROM checksum mismatch");
|
|
|
|
Config_ResetDefault();
|
|
|
|
}
|
|
|
|
}
|
2015-01-28 03:08:48 -06:00
|
|
|
|
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
|
|
|
/**
|
2016-06-29 20:18:46 -05:00
|
|
|
* M502 - Reset Configuration
|
2015-04-26 20:44:01 -05:00
|
|
|
*/
|
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;
|
2016-07-23 15:07:23 -05:00
|
|
|
LOOP_XYZE(i) {
|
2016-06-09 18:53:21 -05:00
|
|
|
planner.axis_steps_per_mm[i] = tmp1[i];
|
2016-07-15 20:49:34 -05:00
|
|
|
planner.max_feedrate_mm_s[i] = tmp2[i];
|
2016-06-09 17:20:44 -05:00
|
|
|
planner.max_acceleration_mm_per_s2[i] = tmp3[i];
|
2015-01-28 03:08:48 -06:00
|
|
|
}
|
|
|
|
|
2016-04-27 20:06:32 -05:00
|
|
|
planner.acceleration = DEFAULT_ACCELERATION;
|
|
|
|
planner.retract_acceleration = DEFAULT_RETRACT_ACCELERATION;
|
|
|
|
planner.travel_acceleration = DEFAULT_TRAVEL_ACCELERATION;
|
2016-07-15 20:49:34 -05:00
|
|
|
planner.min_feedrate_mm_s = DEFAULT_MINIMUMFEEDRATE;
|
2016-04-27 20:06:32 -05:00
|
|
|
planner.min_segment_time = DEFAULT_MINSEGMENTTIME;
|
2016-07-15 20:49:34 -05:00
|
|
|
planner.min_travel_feedrate_mm_s = DEFAULT_MINTRAVELFEEDRATE;
|
2016-10-02 04:37:13 -05:00
|
|
|
planner.max_jerk[X_AXIS] = DEFAULT_XJERK;
|
|
|
|
planner.max_jerk[Y_AXIS] = DEFAULT_YJERK;
|
|
|
|
planner.max_jerk[Z_AXIS] = DEFAULT_ZJERK;
|
|
|
|
planner.max_jerk[E_AXIS] = 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
|
|
|
|
|
2016-06-14 20:05:20 -05:00
|
|
|
#if HAS_BED_PROBE
|
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-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)
|
2016-07-09 17:20:12 -05:00
|
|
|
preheatHotendTemp1 = PREHEAT_1_TEMP_HOTEND;
|
|
|
|
preheatBedTemp1 = PREHEAT_1_TEMP_BED;
|
|
|
|
preheatFanSpeed1 = PREHEAT_1_FAN_SPEED;
|
|
|
|
preheatHotendTemp2 = PREHEAT_2_TEMP_HOTEND;
|
|
|
|
preheatBedTemp2 = PREHEAT_2_TEMP_BED;
|
|
|
|
preheatFanSpeed2 = PREHEAT_2_FAN_SPEED;
|
2015-01-28 03:08:48 -06:00
|
|
|
#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)
|
2016-07-13 08:11:23 -05:00
|
|
|
#if ENABLED(PID_PARAMS_PER_HOTEND) && HOTENDS > 1
|
2016-07-11 13:48:15 -05:00
|
|
|
HOTEND_LOOP()
|
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);
|
2016-07-31 19:49:34 -05:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2015-01-28 03:08:48 -06:00
|
|
|
PID_PARAM(Kc, e) = DEFAULT_Kc;
|
|
|
|
#endif
|
|
|
|
}
|
2016-07-31 19:49:34 -05:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2015-08-30 21:04:30 -05:00
|
|
|
lpq_len = 20; // default last-position-queue size
|
|
|
|
#endif
|
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
|
2016-06-22 05:27:31 -05:00
|
|
|
retract_feedrate_mm_s = RETRACT_FEEDRATE;
|
2015-01-28 03:08:48 -06:00
|
|
|
retract_zlift = RETRACT_ZLIFT;
|
|
|
|
retract_recover_length = RETRACT_RECOVER_LENGTH;
|
|
|
|
#if EXTRUDERS > 1
|
|
|
|
retract_recover_length_swap = RETRACT_RECOVER_LENGTH_SWAP;
|
|
|
|
#endif
|
2016-07-15 20:49:34 -05:00
|
|
|
retract_recover_feedrate_mm_s = RETRACT_RECOVER_FEEDRATE;
|
2015-01-28 03:08:48 -06:00
|
|
|
#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;
|
2016-06-29 20:19:26 -05:00
|
|
|
|
2016-07-14 18:12:20 -05:00
|
|
|
endstops.enable_globally(
|
|
|
|
#if ENABLED(ENDSTOPS_ALWAYS_ON_DEFAULT)
|
|
|
|
(true)
|
|
|
|
#else
|
|
|
|
(false)
|
|
|
|
#endif
|
|
|
|
);
|
|
|
|
|
2016-06-29 20:19:26 -05:00
|
|
|
Config_Postprocess();
|
2015-01-28 03:08:48 -06:00
|
|
|
|
|
|
|
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
|
|
|
#define CONFIG_ECHO_START do{ if (!forReplay) SERIAL_ECHO_START; }while(0)
|
|
|
|
|
2016-06-29 20:18:46 -05:00
|
|
|
/**
|
|
|
|
* M503 - Print Configuration
|
|
|
|
*/
|
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-06-09 18:53:21 -05: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-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
|
|
|
|
|
|
|
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-07-15 20:49:34 -05:00
|
|
|
SERIAL_ECHOPAIR(" M203 X", planner.max_feedrate_mm_s[X_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" Y", planner.max_feedrate_mm_s[Y_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" Z", planner.max_feedrate_mm_s[Z_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" E", planner.max_feedrate_mm_s[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-06-09 17:20:44 -05: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-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-07-15 20:49:34 -05:00
|
|
|
SERIAL_ECHOPAIR(" M205 S", planner.min_feedrate_mm_s);
|
|
|
|
SERIAL_ECHOPAIR(" T", planner.min_travel_feedrate_mm_s);
|
2016-04-27 20:06:32 -05:00
|
|
|
SERIAL_ECHOPAIR(" B", planner.min_segment_time);
|
2016-10-02 04:37:13 -05:00
|
|
|
SERIAL_ECHOPAIR(" X", planner.max_jerk[X_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" Y", planner.max_jerk[Y_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" Z", planner.max_jerk[Z_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" E", planner.max_jerk[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) {
|
2016-06-27 18:29:35 -05: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-07-09 17:20:12 -05:00
|
|
|
SERIAL_ECHOPAIR(" M145 S0 H", preheatHotendTemp1);
|
|
|
|
SERIAL_ECHOPAIR(" B", preheatBedTemp1);
|
|
|
|
SERIAL_ECHOPAIR(" F", preheatFanSpeed1);
|
2015-04-26 20:44:01 -05:00
|
|
|
SERIAL_EOL;
|
|
|
|
CONFIG_ECHO_START;
|
2016-07-09 17:20:12 -05:00
|
|
|
SERIAL_ECHOPAIR(" M145 S1 H", preheatHotendTemp2);
|
|
|
|
SERIAL_ECHOPAIR(" B", preheatBedTemp2);
|
|
|
|
SERIAL_ECHOPAIR(" F", preheatFanSpeed2);
|
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)
|
2016-05-26 19:43:20 -05:00
|
|
|
#if HOTENDS > 1
|
2015-04-26 20:44:01 -05:00
|
|
|
if (forReplay) {
|
2016-07-09 23:11:17 -05:00
|
|
|
HOTEND_LOOP() {
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2016-07-09 23:11:17 -05:00
|
|
|
SERIAL_ECHOPAIR(" M301 E", e);
|
|
|
|
SERIAL_ECHOPAIR(" P", PID_PARAM(Kp, e));
|
|
|
|
SERIAL_ECHOPAIR(" I", unscalePID_i(PID_PARAM(Ki, e)));
|
|
|
|
SERIAL_ECHOPAIR(" D", unscalePID_d(PID_PARAM(Kd, e)));
|
2016-07-31 19:49:34 -05:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2016-07-09 23:11:17 -05:00
|
|
|
SERIAL_ECHOPAIR(" C", PID_PARAM(Kc, e));
|
|
|
|
if (e == 0) SERIAL_ECHOPAIR(" L", lpq_len);
|
2015-08-30 21:04:30 -05:00
|
|
|
#endif
|
2015-04-26 20:44:01 -05:00
|
|
|
SERIAL_EOL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2016-05-26 19:43:20 -05:00
|
|
|
#endif // HOTENDS > 1
|
|
|
|
// !forReplay || HOTENDS == 1
|
2015-04-26 20:44:01 -05: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)));
|
2016-07-31 19:49:34 -05:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
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
|
2016-07-15 20:49:34 -05:00
|
|
|
SERIAL_ECHOPAIR(" F", MMS_TO_MMM(retract_feedrate_mm_s));
|
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
|
2016-07-15 20:49:34 -05:00
|
|
|
SERIAL_ECHOPAIR(" F", MMS_TO_MMM(retract_recover_feedrate_mm_s));
|
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-06-27 18:29:35 -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
|
|
|
|
*/
|
2016-06-14 20:05:20 -05:00
|
|
|
#if HAS_BED_PROBE
|
|
|
|
if (!forReplay) {
|
2015-04-26 20:44:01 -05:00
|
|
|
CONFIG_ECHO_START;
|
2016-06-14 20:05:20 -05:00
|
|
|
SERIAL_ECHOLNPGM("Z-Probe Offset (mm):");
|
|
|
|
}
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR(" M851 Z", zprobe_zoffset);
|
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
|