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
|
|
|
*
|
2017-04-10 02:47:49 +00:00
|
|
|
* Settings and EEPROM storage
|
2015-01-28 09:08:48 +00:00
|
|
|
*
|
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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2017-04-16 03:18:10 +00:00
|
|
|
#define EEPROM_VERSION "V35"
|
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
|
|
|
/**
|
2017-02-21 12:49:31 +00:00
|
|
|
* V33 EEPROM Layout:
|
2015-01-28 09:08:48 +00:00
|
|
|
*
|
2017-04-06 21:46:52 +00:00
|
|
|
* 100 Version (char x4)
|
|
|
|
* 104 EEPROM Checksum (uint16_t)
|
2016-02-17 21:05:12 +00:00
|
|
|
*
|
2017-03-31 19:58:40 +00:00
|
|
|
* 106 E_STEPPERS (uint8_t)
|
2017-04-06 21:46:52 +00:00
|
|
|
* 107 M92 XYZE planner.axis_steps_per_mm (float x4 ... x8)
|
|
|
|
* 123 M203 XYZE planner.max_feedrate_mm_s (float x4 ... x8)
|
|
|
|
* 139 M201 XYZE planner.max_acceleration_mm_per_s2 (uint32_t x4 ... x8)
|
|
|
|
* 155 M204 P planner.acceleration (float)
|
|
|
|
* 159 M204 R planner.retract_acceleration (float)
|
|
|
|
* 163 M204 T planner.travel_acceleration (float)
|
|
|
|
* 167 M205 S planner.min_feedrate_mm_s (float)
|
2016-12-09 11:45:55 +00:00
|
|
|
* 171 M205 T planner.min_travel_feedrate_mm_s (float)
|
2017-04-06 21:46:52 +00:00
|
|
|
* 175 M205 B planner.min_segment_time (ulong)
|
|
|
|
* 179 M205 X planner.max_jerk[X_AXIS] (float)
|
|
|
|
* 183 M205 Y planner.max_jerk[Y_AXIS] (float)
|
|
|
|
* 187 M205 Z planner.max_jerk[Z_AXIS] (float)
|
|
|
|
* 191 M205 E planner.max_jerk[E_AXIS] (float)
|
|
|
|
* 195 M206 XYZ home_offset (float x3)
|
|
|
|
* 207 M218 XYZ hotend_offset (float x3 per additional hotend)
|
2015-01-28 09:08:48 +00:00
|
|
|
*
|
2017-02-21 12:49:31 +00:00
|
|
|
* Global Leveling:
|
|
|
|
* 219 z_fade_height (float)
|
|
|
|
*
|
2017-04-16 23:41:13 +00:00
|
|
|
* MESH_BED_LEVELING: 43 bytes
|
2017-02-21 12:49:31 +00:00
|
|
|
* 223 M420 S from mbl.status (bool)
|
|
|
|
* 224 mbl.z_offset (float)
|
|
|
|
* 228 GRID_MAX_POINTS_X (uint8_t)
|
|
|
|
* 229 GRID_MAX_POINTS_Y (uint8_t)
|
|
|
|
* 230 G29 S3 XYZ z_values[][] (float x9, up to float x 81) +288
|
2016-03-24 21:16:09 +00:00
|
|
|
*
|
2017-04-16 23:41:13 +00:00
|
|
|
* HAS_BED_PROBE: 4 bytes
|
2017-02-21 12:49:31 +00:00
|
|
|
* 266 M851 zprobe_zoffset (float)
|
2015-03-15 22:18:11 +00:00
|
|
|
*
|
2017-04-16 23:41:13 +00:00
|
|
|
* ABL_PLANAR: 36 bytes
|
2017-02-21 12:49:31 +00:00
|
|
|
* 270 planner.bed_level_matrix (matrix_3x3 = float x9)
|
2016-02-17 21:05:12 +00:00
|
|
|
*
|
2017-04-16 23:41:13 +00:00
|
|
|
* AUTO_BED_LEVELING_BILINEAR: 47 bytes
|
2017-02-21 12:49:31 +00:00
|
|
|
* 306 GRID_MAX_POINTS_X (uint8_t)
|
|
|
|
* 307 GRID_MAX_POINTS_Y (uint8_t)
|
|
|
|
* 308 bilinear_grid_spacing (int x2)
|
|
|
|
* 312 G29 L F bilinear_start (int x2)
|
|
|
|
* 316 bed_level_grid[][] (float x9, up to float x256) +988
|
2015-01-28 09:08:48 +00:00
|
|
|
*
|
2017-04-16 23:41:13 +00:00
|
|
|
* DELTA: 48 bytes
|
2017-03-07 23:42:04 +00:00
|
|
|
* 348 M666 XYZ endstop_adj (float x3)
|
|
|
|
* 360 M665 R delta_radius (float)
|
|
|
|
* 364 M665 L delta_diagonal_rod (float)
|
|
|
|
* 368 M665 S delta_segments_per_second (float)
|
|
|
|
* 372 M665 A delta_diagonal_rod_trim[A] (float)
|
|
|
|
* 376 M665 B delta_diagonal_rod_trim[B] (float)
|
|
|
|
* 380 M665 C delta_diagonal_rod_trim[C] (float)
|
|
|
|
* 384 M665 I delta_tower_angle_trim[A] (float)
|
|
|
|
* 388 M665 J delta_tower_angle_trim[B] (float)
|
|
|
|
* 392 M665 K delta_tower_angle_trim[C] (float)
|
2015-01-28 09:08:48 +00:00
|
|
|
*
|
2017-04-16 23:41:13 +00:00
|
|
|
* Z_DUAL_ENDSTOPS: 48 bytes
|
2017-04-06 21:46:52 +00:00
|
|
|
* 348 M666 Z z_endstop_adj (float)
|
|
|
|
* --- dummy data (float x11)
|
2015-01-28 09:08:48 +00:00
|
|
|
*
|
2017-04-06 21:46:52 +00:00
|
|
|
* ULTIPANEL: 6 bytes
|
|
|
|
* 396 M145 S0 H lcd_preheat_hotend_temp (int x2)
|
|
|
|
* 400 M145 S0 B lcd_preheat_bed_temp (int x2)
|
|
|
|
* 404 M145 S0 F lcd_preheat_fan_speed (int x2)
|
2016-12-10 06:17:49 +00:00
|
|
|
*
|
2017-04-06 21:46:52 +00:00
|
|
|
* PIDTEMP: 66 bytes
|
|
|
|
* 408 M301 E0 PIDC Kp[0], Ki[0], Kd[0], Kc[0] (float x4)
|
|
|
|
* 424 M301 E1 PIDC Kp[1], Ki[1], Kd[1], Kc[1] (float x4)
|
|
|
|
* 440 M301 E2 PIDC Kp[2], Ki[2], Kd[2], Kc[2] (float x4)
|
|
|
|
* 456 M301 E3 PIDC Kp[3], Ki[3], Kd[3], Kc[3] (float x4)
|
|
|
|
* 472 M301 E4 PIDC Kp[3], Ki[3], Kd[3], Kc[3] (float x4)
|
|
|
|
* 488 M301 L lpq_len (int)
|
2015-01-28 09:08:48 +00:00
|
|
|
*
|
2017-03-07 22:35:27 +00:00
|
|
|
* PIDTEMPBED: 12 bytes
|
2017-04-06 21:46:52 +00:00
|
|
|
* 490 M304 PID thermalManager.bedKp, .bedKi, .bedKd (float x3)
|
2015-04-03 23:38:05 +00:00
|
|
|
*
|
2016-12-10 06:17:49 +00:00
|
|
|
* DOGLCD: 2 bytes
|
2017-04-06 21:46:52 +00:00
|
|
|
* 502 M250 C lcd_contrast (int)
|
2015-01-28 09:08:48 +00:00
|
|
|
*
|
2016-12-10 06:17:49 +00:00
|
|
|
* FWRETRACT: 29 bytes
|
2017-04-06 21:46:52 +00:00
|
|
|
* 504 M209 S autoretract_enabled (bool)
|
|
|
|
* 505 M207 S retract_length (float)
|
|
|
|
* 509 M207 W retract_length_swap (float)
|
|
|
|
* 513 M207 F retract_feedrate_mm_s (float)
|
|
|
|
* 517 M207 Z retract_zlift (float)
|
|
|
|
* 521 M208 S retract_recover_length (float)
|
|
|
|
* 525 M208 W retract_recover_length_swap (float)
|
|
|
|
* 529 M208 F retract_recover_feedrate_mm_s (float)
|
2015-01-28 09:08:48 +00:00
|
|
|
*
|
2017-04-06 21:46:52 +00:00
|
|
|
* Volumetric Extrusion: 21 bytes
|
|
|
|
* 533 M200 D volumetric_enabled (bool)
|
|
|
|
* 534 M200 T D filament_size (float x5) (T0..3)
|
2015-01-28 09:08:48 +00:00
|
|
|
*
|
2017-04-16 23:41:13 +00:00
|
|
|
* HAVE_TMC2130: 20 bytes
|
2017-04-06 21:46:52 +00:00
|
|
|
* 554 M906 X stepperX current (uint16_t)
|
|
|
|
* 556 M906 Y stepperY current (uint16_t)
|
|
|
|
* 558 M906 Z stepperZ current (uint16_t)
|
|
|
|
* 560 M906 X2 stepperX2 current (uint16_t)
|
|
|
|
* 562 M906 Y2 stepperY2 current (uint16_t)
|
|
|
|
* 564 M906 Z2 stepperZ2 current (uint16_t)
|
|
|
|
* 566 M906 E0 stepperE0 current (uint16_t)
|
|
|
|
* 568 M906 E1 stepperE1 current (uint16_t)
|
|
|
|
* 570 M906 E2 stepperE2 current (uint16_t)
|
|
|
|
* 572 M906 E3 stepperE3 current (uint16_t)
|
2017-02-21 12:49:31 +00:00
|
|
|
* 576 M906 E4 stepperE4 current (uint16_t)
|
2017-03-07 05:00:43 +00:00
|
|
|
*
|
2017-04-16 03:18:10 +00:00
|
|
|
* LIN_ADVANCE: 8 bytes
|
2017-04-17 05:27:49 +00:00
|
|
|
* 580 M900 K extruder_advance_k (float)
|
|
|
|
* 584 M900 WHD advance_ed_ratio (float)
|
2017-04-16 03:18:10 +00:00
|
|
|
*
|
|
|
|
* 588 Minimum end-point
|
|
|
|
* 1909 (588 + 36 + 9 + 288 + 988) Maximum end-point
|
2015-01-28 09:08:48 +00:00
|
|
|
*/
|
2017-04-10 02:47:49 +00:00
|
|
|
#include "configuration_store.h"
|
|
|
|
|
|
|
|
MarlinSettings settings;
|
|
|
|
|
2012-11-07 22:16:43 +00:00
|
|
|
#include "Marlin.h"
|
2015-01-29 05:19:51 +00:00
|
|
|
#include "language.h"
|
2016-07-14 23:12:20 +00:00
|
|
|
#include "endstops.h"
|
2012-11-07 22:16:43 +00:00
|
|
|
#include "planner.h"
|
|
|
|
#include "temperature.h"
|
|
|
|
#include "ultralcd.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
|
|
|
|
2017-03-07 05:00:43 +00:00
|
|
|
#if ENABLED(HAVE_TMC2130)
|
|
|
|
#include "stepper_indirection.h"
|
|
|
|
#endif
|
|
|
|
|
2017-03-18 15:15:54 +00:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
2017-04-06 00:25:36 +00:00
|
|
|
#include "ubl.h"
|
2017-03-18 15:15:54 +00:00
|
|
|
#endif
|
|
|
|
|
2016-12-10 06:17:49 +00:00
|
|
|
#if ENABLED(ABL_BILINEAR_SUBDIVISION)
|
|
|
|
extern void bed_level_virt_interpolate();
|
|
|
|
#endif
|
|
|
|
|
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
|
|
|
*/
|
2017-04-10 02:47:49 +00:00
|
|
|
void MarlinSettings::postprocess() {
|
2016-06-30 01:19:26 +00:00
|
|
|
// steps per s2 needs to be updated to agree with units per s2
|
|
|
|
planner.reset_acceleration_rates();
|
|
|
|
|
2016-07-24 02:36:26 +00:00
|
|
|
// Make sure delta kinematics are updated before refreshing the
|
|
|
|
// planner position so the stepper counts will be set correctly.
|
2016-06-30 01:19:26 +00:00
|
|
|
#if ENABLED(DELTA)
|
|
|
|
recalc_delta_settings(delta_radius, delta_diagonal_rod);
|
|
|
|
#endif
|
2012-11-07 22:16:43 +00:00
|
|
|
|
2016-07-24 02:36:26 +00: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-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();
|
2016-08-19 06:00:46 +00:00
|
|
|
|
2017-04-15 02:41:21 +00:00
|
|
|
#if HAS_HOME_OFFSET || ENABLED(DUAL_X_CARRIAGE)
|
2017-03-05 00:01:33 +00:00
|
|
|
// Software endstops depend on home_offset
|
|
|
|
LOOP_XYZ(i) update_software_endstops((AxisEnum)i);
|
|
|
|
#endif
|
2017-02-21 12:49:31 +00:00
|
|
|
|
|
|
|
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
|
|
|
set_z_fade_height(
|
|
|
|
//#if ENABLED(AUTO_BED_LEVELING_UBL)
|
|
|
|
// ubl.state.g29_correction_fade_height
|
|
|
|
//#else
|
|
|
|
planner.z_fade_height
|
|
|
|
//#endif
|
|
|
|
);
|
|
|
|
#endif
|
2017-04-11 10:05:23 +00:00
|
|
|
|
|
|
|
#if HAS_BED_PROBE
|
|
|
|
refresh_zprobe_zoffset();
|
|
|
|
#endif
|
2016-06-30 01:19:26 +00:00
|
|
|
}
|
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-12-09 12:13:44 +00:00
|
|
|
const char version[4] = EEPROM_VERSION;
|
|
|
|
|
2017-04-10 02:47:49 +00:00
|
|
|
uint16_t MarlinSettings::eeprom_checksum;
|
|
|
|
|
|
|
|
bool MarlinSettings::eeprom_write_error,
|
|
|
|
MarlinSettings::eeprom_read_error;
|
2016-12-09 12:13:44 +00:00
|
|
|
|
2017-04-10 02:47:49 +00:00
|
|
|
void MarlinSettings::write_data(int &pos, const uint8_t* value, uint16_t size) {
|
2016-12-09 12:13:44 +00:00
|
|
|
if (eeprom_write_error) return;
|
|
|
|
while (size--) {
|
|
|
|
uint8_t * const p = (uint8_t * const)pos;
|
|
|
|
const uint8_t v = *value;
|
|
|
|
// EEPROM has only ~100,000 write cycles,
|
|
|
|
// so only write bytes that have changed!
|
|
|
|
if (v != eeprom_read_byte(p)) {
|
|
|
|
eeprom_write_byte(p, v);
|
|
|
|
if (eeprom_read_byte(p) != v) {
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPGM(MSG_ERR_EEPROM_WRITE);
|
|
|
|
eeprom_write_error = true;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
eeprom_checksum += v;
|
|
|
|
pos++;
|
|
|
|
value++;
|
|
|
|
};
|
|
|
|
}
|
2017-04-10 02:47:49 +00:00
|
|
|
void MarlinSettings::read_data(int &pos, uint8_t* value, uint16_t size) {
|
2016-12-09 12:13:44 +00:00
|
|
|
do {
|
|
|
|
uint8_t c = eeprom_read_byte((unsigned char*)pos);
|
2016-12-14 07:48:42 +00:00
|
|
|
if (!eeprom_read_error) *value = c;
|
2016-12-09 12:13:44 +00:00
|
|
|
eeprom_checksum += c;
|
|
|
|
pos++;
|
|
|
|
value++;
|
|
|
|
} while (--size);
|
|
|
|
}
|
|
|
|
|
2016-06-30 01:18:46 +00:00
|
|
|
#define DUMMY_PID_VALUE 3000.0f
|
2016-07-24 17:19:49 +00:00
|
|
|
#define EEPROM_START() int eeprom_index = EEPROM_OFFSET
|
|
|
|
#define EEPROM_SKIP(VAR) eeprom_index += sizeof(VAR)
|
2017-04-10 02:47:49 +00:00
|
|
|
#define EEPROM_WRITE(VAR) write_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR))
|
|
|
|
#define EEPROM_READ(VAR) read_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR))
|
|
|
|
#define EEPROM_ASSERT(TST,ERR) if (!(TST)) do{ SERIAL_ERROR_START; SERIAL_ERRORLNPGM(ERR); eeprom_read_error = true; }while(0)
|
2016-06-30 01:18:46 +00:00
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
/**
|
|
|
|
* M500 - Store Configuration
|
|
|
|
*/
|
2017-04-10 02:47:49 +00:00
|
|
|
bool MarlinSettings::save() {
|
2016-10-28 23:55:42 +00:00
|
|
|
float dummy = 0.0f;
|
|
|
|
char ver[4] = "000";
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
EEPROM_START();
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2016-12-09 11:45:04 +00:00
|
|
|
eeprom_write_error = false;
|
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
EEPROM_WRITE(ver); // invalidate data first
|
|
|
|
EEPROM_SKIP(eeprom_checksum); // Skip the checksum slot
|
2016-06-30 01:12:23 +00:00
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
eeprom_checksum = 0; // clear before first "real data"
|
2016-07-24 17:19:49 +00:00
|
|
|
|
2016-12-16 05:15:12 +00:00
|
|
|
const uint8_t esteppers = COUNT(planner.axis_steps_per_mm) - XYZ;
|
2016-12-09 11:45:55 +00:00
|
|
|
EEPROM_WRITE(esteppers);
|
2016-12-14 13:13:25 +00:00
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
EEPROM_WRITE(planner.axis_steps_per_mm);
|
|
|
|
EEPROM_WRITE(planner.max_feedrate_mm_s);
|
|
|
|
EEPROM_WRITE(planner.max_acceleration_mm_per_s2);
|
2016-12-09 11:45:55 +00:00
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
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);
|
|
|
|
EEPROM_WRITE(planner.max_jerk);
|
2017-04-15 02:41:21 +00:00
|
|
|
#if !HAS_HOME_OFFSET
|
2017-03-31 19:58:40 +00:00
|
|
|
const float home_offset[XYZ] = { 0 };
|
|
|
|
#endif
|
|
|
|
#if ENABLED(DELTA)
|
|
|
|
dummy = 0.0;
|
|
|
|
EEPROM_WRITE(dummy);
|
|
|
|
EEPROM_WRITE(dummy);
|
|
|
|
dummy = DELTA_HEIGHT + home_offset[Z_AXIS];
|
|
|
|
EEPROM_WRITE(dummy);
|
|
|
|
#else
|
|
|
|
EEPROM_WRITE(home_offset);
|
2017-03-05 00:01:33 +00:00
|
|
|
#endif
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2016-10-28 23:39:23 +00:00
|
|
|
#if HOTENDS > 1
|
|
|
|
// Skip hotend 0 which must be 0
|
|
|
|
for (uint8_t e = 1; e < HOTENDS; e++)
|
2016-10-28 23:55:42 +00:00
|
|
|
LOOP_XYZ(i) EEPROM_WRITE(hotend_offset[i][e]);
|
2016-10-28 23:39:23 +00:00
|
|
|
#endif
|
|
|
|
|
2017-02-21 12:49:31 +00:00
|
|
|
//
|
|
|
|
// General Leveling
|
|
|
|
//
|
|
|
|
|
|
|
|
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
|
|
|
EEPROM_WRITE(planner.z_fade_height);
|
|
|
|
#else
|
|
|
|
dummy = 10.0;
|
|
|
|
EEPROM_WRITE(dummy);
|
|
|
|
#endif
|
|
|
|
|
2016-12-10 06:17:49 +00:00
|
|
|
//
|
|
|
|
// Mesh Bed Leveling
|
|
|
|
//
|
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2016-10-28 23:55:42 +00:00
|
|
|
// Compile time test that sizeof(mbl.z_values) is as expected
|
2017-04-06 03:29:44 +00:00
|
|
|
typedef char c_assert[(sizeof(mbl.z_values) == (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y) * sizeof(dummy)) ? 1 : -1];
|
2016-12-14 07:44:39 +00:00
|
|
|
const bool leveling_is_on = TEST(mbl.status, MBL_STATUS_HAS_MESH_BIT);
|
2017-04-06 03:29:44 +00:00
|
|
|
const uint8_t mesh_num_x = GRID_MAX_POINTS_X, mesh_num_y = GRID_MAX_POINTS_Y;
|
2016-12-14 07:44:39 +00:00
|
|
|
EEPROM_WRITE(leveling_is_on);
|
2016-10-28 23:55:42 +00:00
|
|
|
EEPROM_WRITE(mbl.z_offset);
|
|
|
|
EEPROM_WRITE(mesh_num_x);
|
|
|
|
EEPROM_WRITE(mesh_num_y);
|
|
|
|
EEPROM_WRITE(mbl.z_values);
|
2015-03-18 20:00:31 +00:00
|
|
|
#else
|
2016-10-28 23:55:42 +00:00
|
|
|
// For disabled MBL write a default mesh
|
2016-12-14 07:44:39 +00:00
|
|
|
const bool leveling_is_on = false;
|
2016-10-28 23:55:42 +00:00
|
|
|
dummy = 0.0f;
|
2016-12-14 07:44:39 +00:00
|
|
|
const uint8_t mesh_num_x = 3, mesh_num_y = 3;
|
|
|
|
EEPROM_WRITE(leveling_is_on);
|
2016-12-10 06:17:49 +00:00
|
|
|
EEPROM_WRITE(dummy); // z_offset
|
2016-10-28 23:55:42 +00:00
|
|
|
EEPROM_WRITE(mesh_num_x);
|
|
|
|
EEPROM_WRITE(mesh_num_y);
|
2016-12-10 06:17:49 +00:00
|
|
|
for (uint8_t q = mesh_num_x * mesh_num_y; q--;) EEPROM_WRITE(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
|
2017-04-11 10:05:23 +00:00
|
|
|
const float zprobe_zoffset = 0;
|
2015-03-26 04:14:00 +00:00
|
|
|
#endif
|
2016-10-28 23:55:42 +00:00
|
|
|
EEPROM_WRITE(zprobe_zoffset);
|
2015-03-26 04:14:00 +00:00
|
|
|
|
2016-12-14 07:50:06 +00:00
|
|
|
//
|
|
|
|
// Planar Bed Leveling matrix
|
|
|
|
//
|
|
|
|
|
|
|
|
#if ABL_PLANAR
|
|
|
|
EEPROM_WRITE(planner.bed_level_matrix);
|
|
|
|
#else
|
|
|
|
dummy = 0.0;
|
|
|
|
for (uint8_t q = 9; q--;) EEPROM_WRITE(dummy);
|
|
|
|
#endif
|
|
|
|
|
2016-12-10 06:17:49 +00:00
|
|
|
//
|
|
|
|
// Bilinear Auto Bed Leveling
|
|
|
|
//
|
|
|
|
|
|
|
|
#if ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
|
|
|
// Compile time test that sizeof(bed_level_grid) is as expected
|
2017-04-06 03:29:44 +00:00
|
|
|
typedef char c_assert[(sizeof(bed_level_grid) == (GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y) * sizeof(dummy)) ? 1 : -1];
|
|
|
|
const uint8_t grid_max_x = GRID_MAX_POINTS_X, grid_max_y = GRID_MAX_POINTS_Y;
|
2016-12-10 06:17:49 +00:00
|
|
|
EEPROM_WRITE(grid_max_x); // 1 byte
|
|
|
|
EEPROM_WRITE(grid_max_y); // 1 byte
|
|
|
|
EEPROM_WRITE(bilinear_grid_spacing); // 2 ints
|
|
|
|
EEPROM_WRITE(bilinear_start); // 2 ints
|
|
|
|
EEPROM_WRITE(bed_level_grid); // 9-256 floats
|
|
|
|
#else
|
|
|
|
// For disabled Bilinear Grid write an empty 3x3 grid
|
|
|
|
const uint8_t grid_max_x = 3, grid_max_y = 3;
|
|
|
|
const int bilinear_start[2] = { 0 }, bilinear_grid_spacing[2] = { 0 };
|
|
|
|
dummy = 0.0f;
|
|
|
|
EEPROM_WRITE(grid_max_x);
|
|
|
|
EEPROM_WRITE(grid_max_y);
|
|
|
|
EEPROM_WRITE(bilinear_grid_spacing);
|
|
|
|
EEPROM_WRITE(bilinear_start);
|
|
|
|
for (uint16_t q = grid_max_x * grid_max_y; q--;) EEPROM_WRITE(dummy);
|
|
|
|
#endif // AUTO_BED_LEVELING_BILINEAR
|
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
// 9 floats for DELTA / Z_DUAL_ENDSTOPS
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(DELTA)
|
2016-10-28 23:55:42 +00: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
|
2017-03-07 23:42:04 +00:00
|
|
|
EEPROM_WRITE(delta_diagonal_rod_trim); // 3 floats
|
|
|
|
EEPROM_WRITE(delta_tower_angle_trim); // 3 floats
|
2015-07-31 05:31:45 +00:00
|
|
|
#elif ENABLED(Z_DUAL_ENDSTOPS)
|
2017-03-07 23:42:04 +00:00
|
|
|
EEPROM_WRITE(z_endstop_adj); // 1 float
|
2015-03-24 17:06:44 +00:00
|
|
|
dummy = 0.0f;
|
2017-03-07 22:35:27 +00:00
|
|
|
for (uint8_t q = 11; q--;) EEPROM_WRITE(dummy);
|
2015-01-28 09:08:48 +00:00
|
|
|
#else
|
2015-03-24 17:06:44 +00:00
|
|
|
dummy = 0.0f;
|
2017-03-07 22:35:27 +00:00
|
|
|
for (uint8_t q = 12; q--;) EEPROM_WRITE(dummy);
|
2015-01-28 09:08:48 +00:00
|
|
|
#endif
|
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if DISABLED(ULTIPANEL)
|
2016-10-27 07:40:37 +00:00
|
|
|
const int lcd_preheat_hotend_temp[2] = { PREHEAT_1_TEMP_HOTEND, PREHEAT_2_TEMP_HOTEND },
|
|
|
|
lcd_preheat_bed_temp[2] = { PREHEAT_1_TEMP_BED, PREHEAT_2_TEMP_BED },
|
|
|
|
lcd_preheat_fan_speed[2] = { PREHEAT_1_FAN_SPEED, PREHEAT_2_FAN_SPEED };
|
2016-10-28 23:55:42 +00:00
|
|
|
#endif // !ULTIPANEL
|
|
|
|
|
2016-10-27 07:40:37 +00:00
|
|
|
EEPROM_WRITE(lcd_preheat_hotend_temp);
|
|
|
|
EEPROM_WRITE(lcd_preheat_bed_temp);
|
|
|
|
EEPROM_WRITE(lcd_preheat_fan_speed);
|
2016-10-28 23:55:42 +00:00
|
|
|
|
|
|
|
for (uint8_t e = 0; e < MAX_EXTRUDERS; e++) {
|
|
|
|
|
|
|
|
#if ENABLED(PIDTEMP)
|
|
|
|
if (e < HOTENDS) {
|
|
|
|
EEPROM_WRITE(PID_PARAM(Kp, e));
|
|
|
|
EEPROM_WRITE(PID_PARAM(Ki, e));
|
|
|
|
EEPROM_WRITE(PID_PARAM(Kd, e));
|
2016-08-01 00:49:34 +00:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2016-10-28 23:55:42 +00:00
|
|
|
EEPROM_WRITE(PID_PARAM(Kc, e));
|
2015-01-28 09:08:48 +00:00
|
|
|
#else
|
2016-10-28 23:55:42 +00:00
|
|
|
dummy = 1.0f; // 1.0 = default kc
|
|
|
|
EEPROM_WRITE(dummy);
|
2015-01-28 09:08:48 +00:00
|
|
|
#endif
|
|
|
|
}
|
2016-10-28 23:55:42 +00:00
|
|
|
else
|
|
|
|
#endif // !PIDTEMP
|
|
|
|
{
|
|
|
|
dummy = DUMMY_PID_VALUE; // When read, will not change the existing value
|
|
|
|
EEPROM_WRITE(dummy); // Kp
|
|
|
|
dummy = 0.0f;
|
|
|
|
for (uint8_t q = 3; q--;) EEPROM_WRITE(dummy); // Ki, Kd, Kc
|
2015-01-28 09:08:48 +00:00
|
|
|
}
|
2016-10-28 23:55:42 +00:00
|
|
|
|
|
|
|
} // Hotends Loop
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2016-08-01 00:49:34 +00:00
|
|
|
#if DISABLED(PID_EXTRUSION_SCALING)
|
2016-10-28 23:55:42 +00:00
|
|
|
int lpq_len = 20;
|
2015-08-31 02:04:30 +00:00
|
|
|
#endif
|
2016-10-28 23:55:42 +00:00
|
|
|
EEPROM_WRITE(lpq_len);
|
|
|
|
|
|
|
|
#if DISABLED(PIDTEMPBED)
|
|
|
|
dummy = DUMMY_PID_VALUE;
|
|
|
|
for (uint8_t q = 3; q--;) EEPROM_WRITE(dummy);
|
2016-04-29 01:18:13 +00:00
|
|
|
#else
|
2016-10-28 23:55:42 +00:00
|
|
|
EEPROM_WRITE(thermalManager.bedKp);
|
|
|
|
EEPROM_WRITE(thermalManager.bedKi);
|
|
|
|
EEPROM_WRITE(thermalManager.bedKd);
|
2015-04-03 23:38:05 +00:00
|
|
|
#endif
|
|
|
|
|
2016-05-31 18:47:02 +00:00
|
|
|
#if !HAS_LCD_CONTRAST
|
2016-10-28 23:55:42 +00:00
|
|
|
const int lcd_contrast = 32;
|
2015-01-28 09:08:48 +00:00
|
|
|
#endif
|
2016-10-28 23:55:42 +00:00
|
|
|
EEPROM_WRITE(lcd_contrast);
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(FWRETRACT)
|
2016-10-28 23:55:42 +00:00
|
|
|
EEPROM_WRITE(autoretract_enabled);
|
|
|
|
EEPROM_WRITE(retract_length);
|
2015-01-28 09:08:48 +00:00
|
|
|
#if EXTRUDERS > 1
|
2016-10-28 23:55:42 +00:00
|
|
|
EEPROM_WRITE(retract_length_swap);
|
2015-01-28 09:08:48 +00:00
|
|
|
#else
|
2016-10-28 23:55:42 +00:00
|
|
|
dummy = 0.0f;
|
|
|
|
EEPROM_WRITE(dummy);
|
2015-01-28 09:08:48 +00:00
|
|
|
#endif
|
2016-10-28 23:55:42 +00:00
|
|
|
EEPROM_WRITE(retract_feedrate_mm_s);
|
|
|
|
EEPROM_WRITE(retract_zlift);
|
|
|
|
EEPROM_WRITE(retract_recover_length);
|
2015-01-28 09:08:48 +00:00
|
|
|
#if EXTRUDERS > 1
|
2016-10-28 23:55:42 +00:00
|
|
|
EEPROM_WRITE(retract_recover_length_swap);
|
2015-01-28 09:08:48 +00:00
|
|
|
#else
|
2016-10-28 23:55:42 +00:00
|
|
|
dummy = 0.0f;
|
|
|
|
EEPROM_WRITE(dummy);
|
2015-01-28 09:08:48 +00:00
|
|
|
#endif
|
2016-10-28 23:55:42 +00:00
|
|
|
EEPROM_WRITE(retract_recover_feedrate_mm_s);
|
2015-01-28 09:08:48 +00:00
|
|
|
#endif // FWRETRACT
|
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
EEPROM_WRITE(volumetric_enabled);
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
// Save filament sizes
|
2016-06-30 07:07:31 +00:00
|
|
|
for (uint8_t q = 0; q < MAX_EXTRUDERS; q++) {
|
2016-10-28 23:55:42 +00:00
|
|
|
if (q < COUNT(filament_size)) dummy = filament_size[q];
|
|
|
|
EEPROM_WRITE(dummy);
|
2015-01-28 09:08:48 +00:00
|
|
|
}
|
|
|
|
|
2017-03-31 19:58:40 +00:00
|
|
|
// Save TMC2130 Configuration, and placeholder values
|
2017-03-07 05:00:43 +00:00
|
|
|
uint16_t val;
|
|
|
|
#if ENABLED(HAVE_TMC2130)
|
|
|
|
#if ENABLED(X_IS_TMC2130)
|
|
|
|
val = stepperX.getCurrent();
|
|
|
|
#else
|
|
|
|
val = 0;
|
|
|
|
#endif
|
|
|
|
EEPROM_WRITE(val);
|
|
|
|
#if ENABLED(Y_IS_TMC2130)
|
|
|
|
val = stepperY.getCurrent();
|
|
|
|
#else
|
|
|
|
val = 0;
|
|
|
|
#endif
|
|
|
|
EEPROM_WRITE(val);
|
|
|
|
#if ENABLED(Z_IS_TMC2130)
|
|
|
|
val = stepperZ.getCurrent();
|
|
|
|
#else
|
|
|
|
val = 0;
|
|
|
|
#endif
|
|
|
|
EEPROM_WRITE(val);
|
|
|
|
#if ENABLED(X2_IS_TMC2130)
|
|
|
|
val = stepperX2.getCurrent();
|
|
|
|
#else
|
|
|
|
val = 0;
|
|
|
|
#endif
|
|
|
|
EEPROM_WRITE(val);
|
|
|
|
#if ENABLED(Y2_IS_TMC2130)
|
|
|
|
val = stepperY2.getCurrent();
|
|
|
|
#else
|
|
|
|
val = 0;
|
|
|
|
#endif
|
|
|
|
EEPROM_WRITE(val);
|
|
|
|
#if ENABLED(Z2_IS_TMC2130)
|
|
|
|
val = stepperZ2.getCurrent();
|
|
|
|
#else
|
|
|
|
val = 0;
|
|
|
|
#endif
|
|
|
|
EEPROM_WRITE(val);
|
|
|
|
#if ENABLED(E0_IS_TMC2130)
|
|
|
|
val = stepperE0.getCurrent();
|
|
|
|
#else
|
|
|
|
val = 0;
|
|
|
|
#endif
|
|
|
|
EEPROM_WRITE(val);
|
|
|
|
#if ENABLED(E1_IS_TMC2130)
|
|
|
|
val = stepperE1.getCurrent();
|
|
|
|
#else
|
|
|
|
val = 0;
|
|
|
|
#endif
|
|
|
|
EEPROM_WRITE(val);
|
|
|
|
#if ENABLED(E2_IS_TMC2130)
|
|
|
|
val = stepperE2.getCurrent();
|
|
|
|
#else
|
|
|
|
val = 0;
|
|
|
|
#endif
|
|
|
|
EEPROM_WRITE(val);
|
|
|
|
#if ENABLED(E3_IS_TMC2130)
|
|
|
|
val = stepperE3.getCurrent();
|
|
|
|
#else
|
|
|
|
val = 0;
|
|
|
|
#endif
|
|
|
|
EEPROM_WRITE(val);
|
2017-03-31 19:58:40 +00:00
|
|
|
#if ENABLED(E4_IS_TMC2130)
|
|
|
|
val = stepperE4.getCurrent();
|
|
|
|
#else
|
|
|
|
val = 0;
|
|
|
|
#endif
|
|
|
|
EEPROM_WRITE(val);
|
2017-03-07 05:00:43 +00:00
|
|
|
#else
|
|
|
|
val = 0;
|
2017-04-09 08:23:05 +00:00
|
|
|
for (uint8_t q = 0; q < 11; ++q) EEPROM_WRITE(val);
|
2017-03-07 05:00:43 +00:00
|
|
|
#endif
|
|
|
|
|
2017-04-16 03:18:10 +00:00
|
|
|
//
|
|
|
|
// Linear Advance
|
|
|
|
//
|
|
|
|
|
|
|
|
float extruder_advance_k = 0.0f, advance_ed_ratio = 0.0f;
|
|
|
|
|
|
|
|
#if ENABLED(LIN_ADVANCE)
|
|
|
|
extruder_advance_k = planner.get_extruder_advance_k();
|
|
|
|
advance_ed_ratio = planner.get_advance_ed_ratio();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
EEPROM_WRITE(extruder_advance_k);
|
|
|
|
EEPROM_WRITE(advance_ed_ratio);
|
|
|
|
|
2016-12-14 07:48:42 +00:00
|
|
|
if (!eeprom_write_error) {
|
2016-10-28 23:55:42 +00:00
|
|
|
|
2017-03-07 05:00:43 +00:00
|
|
|
const uint16_t final_checksum = eeprom_checksum,
|
|
|
|
eeprom_size = eeprom_index;
|
2016-10-28 23:55:42 +00:00
|
|
|
|
2016-12-14 07:48:42 +00:00
|
|
|
// Write the EEPROM header
|
|
|
|
eeprom_index = EEPROM_OFFSET;
|
|
|
|
EEPROM_WRITE(version);
|
|
|
|
EEPROM_WRITE(final_checksum);
|
2016-10-28 23:55:42 +00:00
|
|
|
|
2016-12-14 07:48:42 +00:00
|
|
|
// Report storage size
|
|
|
|
SERIAL_ECHO_START;
|
2016-12-14 13:13:25 +00:00
|
|
|
SERIAL_ECHOPAIR("Settings Stored (", eeprom_size - (EEPROM_OFFSET));
|
2016-12-14 07:48:42 +00:00
|
|
|
SERIAL_ECHOLNPGM(" bytes)");
|
|
|
|
}
|
2017-03-20 11:10:31 +00:00
|
|
|
|
2017-03-18 15:15:54 +00:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
2017-03-20 06:42:41 +00:00
|
|
|
ubl.store_state();
|
|
|
|
if (ubl.state.eeprom_storage_slot >= 0)
|
|
|
|
ubl.store_mesh(ubl.state.eeprom_storage_slot);
|
2017-03-18 15:15:54 +00:00
|
|
|
#endif
|
2017-03-20 11:10:31 +00:00
|
|
|
|
|
|
|
return !eeprom_write_error;
|
2016-10-28 23:55:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M501 - Retrieve Configuration
|
|
|
|
*/
|
2017-04-10 02:47:49 +00:00
|
|
|
bool MarlinSettings::load() {
|
2016-10-28 23:55:42 +00:00
|
|
|
|
|
|
|
EEPROM_START();
|
2016-12-14 07:48:42 +00:00
|
|
|
eeprom_read_error = false; // If set EEPROM_READ won't write into RAM
|
2016-10-28 23:55:42 +00:00
|
|
|
|
|
|
|
char stored_ver[4];
|
|
|
|
EEPROM_READ(stored_ver);
|
|
|
|
|
|
|
|
uint16_t stored_checksum;
|
|
|
|
EEPROM_READ(stored_checksum);
|
|
|
|
|
2016-12-09 11:45:55 +00:00
|
|
|
// Version has to match or defaults are used
|
2016-10-28 23:55:42 +00:00
|
|
|
if (strncmp(version, stored_ver, 3) != 0) {
|
2017-03-04 07:20:36 +00:00
|
|
|
if (stored_ver[0] != 'V') {
|
|
|
|
stored_ver[0] = '?';
|
|
|
|
stored_ver[1] = '\0';
|
|
|
|
}
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHOPGM("EEPROM version mismatch ");
|
|
|
|
SERIAL_ECHOPAIR("(EEPROM=", stored_ver);
|
|
|
|
SERIAL_ECHOLNPGM(" Marlin=" EEPROM_VERSION ")");
|
2017-04-10 02:47:49 +00:00
|
|
|
reset();
|
2016-06-30 01:12:23 +00:00
|
|
|
}
|
2016-10-28 23:55:42 +00:00
|
|
|
else {
|
|
|
|
float dummy = 0;
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
eeprom_checksum = 0; // clear before reading first "real data"
|
|
|
|
|
2016-12-09 11:45:55 +00:00
|
|
|
// Number of esteppers may change
|
|
|
|
uint8_t esteppers;
|
|
|
|
EEPROM_READ(esteppers);
|
|
|
|
|
|
|
|
// Get only the number of E stepper parameters previously stored
|
|
|
|
// Any steppers added later are set to their defaults
|
|
|
|
const float def1[] = DEFAULT_AXIS_STEPS_PER_UNIT, def2[] = DEFAULT_MAX_FEEDRATE;
|
2016-12-16 04:04:18 +00:00
|
|
|
const uint32_t def3[] = DEFAULT_MAX_ACCELERATION;
|
2016-12-09 11:45:55 +00:00
|
|
|
float tmp1[XYZ + esteppers], tmp2[XYZ + esteppers];
|
2016-12-16 04:04:18 +00:00
|
|
|
uint32_t tmp3[XYZ + esteppers];
|
2016-12-09 11:45:55 +00:00
|
|
|
EEPROM_READ(tmp1);
|
|
|
|
EEPROM_READ(tmp2);
|
|
|
|
EEPROM_READ(tmp3);
|
|
|
|
LOOP_XYZE_N(i) {
|
|
|
|
planner.axis_steps_per_mm[i] = i < XYZ + esteppers ? tmp1[i] : def1[i < COUNT(def1) ? i : COUNT(def1) - 1];
|
|
|
|
planner.max_feedrate_mm_s[i] = i < XYZ + esteppers ? tmp2[i] : def2[i < COUNT(def2) ? i : COUNT(def2) - 1];
|
|
|
|
planner.max_acceleration_mm_per_s2[i] = i < XYZ + esteppers ? tmp3[i] : def3[i < COUNT(def3) ? i : COUNT(def3) - 1];
|
|
|
|
}
|
2016-10-28 23:55:42 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
EEPROM_READ(planner.max_jerk);
|
2017-03-05 00:01:33 +00:00
|
|
|
|
2017-04-15 02:41:21 +00:00
|
|
|
#if !HAS_HOME_OFFSET
|
2017-03-05 00:01:33 +00:00
|
|
|
float home_offset[XYZ];
|
|
|
|
#endif
|
2016-10-28 23:55:42 +00:00
|
|
|
EEPROM_READ(home_offset);
|
|
|
|
|
2017-03-31 19:58:40 +00:00
|
|
|
#if ENABLED(DELTA)
|
|
|
|
home_offset[X_AXIS] = 0.0;
|
|
|
|
home_offset[Y_AXIS] = 0.0;
|
|
|
|
home_offset[Z_AXIS] -= DELTA_HEIGHT;
|
|
|
|
#endif
|
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
#if HOTENDS > 1
|
|
|
|
// Skip hotend 0 which must be 0
|
|
|
|
for (uint8_t e = 1; e < HOTENDS; e++)
|
|
|
|
LOOP_XYZ(i) EEPROM_READ(hotend_offset[i][e]);
|
|
|
|
#endif
|
|
|
|
|
2017-02-21 12:49:31 +00:00
|
|
|
//
|
|
|
|
// General Leveling
|
|
|
|
//
|
|
|
|
|
|
|
|
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
|
|
|
EEPROM_READ(planner.z_fade_height);
|
|
|
|
#else
|
|
|
|
EEPROM_READ(dummy);
|
|
|
|
#endif
|
|
|
|
|
2016-12-10 06:17:49 +00:00
|
|
|
//
|
|
|
|
// Mesh (Manual) Bed Leveling
|
|
|
|
//
|
|
|
|
|
2016-12-14 07:44:39 +00:00
|
|
|
bool leveling_is_on;
|
|
|
|
uint8_t mesh_num_x, mesh_num_y;
|
|
|
|
EEPROM_READ(leveling_is_on);
|
2016-10-28 23:55:42 +00:00
|
|
|
EEPROM_READ(dummy);
|
|
|
|
EEPROM_READ(mesh_num_x);
|
|
|
|
EEPROM_READ(mesh_num_y);
|
2016-12-14 07:44:39 +00:00
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2016-12-14 07:44:39 +00:00
|
|
|
mbl.status = leveling_is_on ? _BV(MBL_STATUS_HAS_MESH_BIT) : 0;
|
2016-10-28 23:55:42 +00:00
|
|
|
mbl.z_offset = dummy;
|
2017-04-06 03:29:44 +00:00
|
|
|
if (mesh_num_x == GRID_MAX_POINTS_X && mesh_num_y == GRID_MAX_POINTS_Y) {
|
2016-10-28 23:55:42 +00:00
|
|
|
// EEPROM data fits the current mesh
|
|
|
|
EEPROM_READ(mbl.z_values);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// EEPROM data is stale
|
|
|
|
mbl.reset();
|
2016-12-10 06:17:49 +00:00
|
|
|
for (uint16_t q = mesh_num_x * mesh_num_y; q--;) EEPROM_READ(dummy);
|
2016-10-28 23:55:42 +00:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
// MBL is disabled - skip the stored data
|
2016-12-10 06:17:49 +00:00
|
|
|
for (uint16_t q = mesh_num_x * mesh_num_y; q--;) EEPROM_READ(dummy);
|
2016-10-28 23:55:42 +00:00
|
|
|
#endif // MESH_BED_LEVELING
|
|
|
|
|
|
|
|
#if !HAS_BED_PROBE
|
2017-04-11 10:05:23 +00:00
|
|
|
float zprobe_zoffset;
|
2016-10-28 23:55:42 +00:00
|
|
|
#endif
|
|
|
|
EEPROM_READ(zprobe_zoffset);
|
|
|
|
|
2016-12-14 07:50:06 +00:00
|
|
|
//
|
|
|
|
// Planar Bed Leveling matrix
|
|
|
|
//
|
|
|
|
|
|
|
|
#if ABL_PLANAR
|
|
|
|
EEPROM_READ(planner.bed_level_matrix);
|
|
|
|
#else
|
|
|
|
for (uint8_t q = 9; q--;) EEPROM_READ(dummy);
|
|
|
|
#endif
|
|
|
|
|
2016-12-10 06:17:49 +00:00
|
|
|
//
|
|
|
|
// Bilinear Auto Bed Leveling
|
|
|
|
//
|
|
|
|
|
|
|
|
uint8_t grid_max_x, grid_max_y;
|
|
|
|
EEPROM_READ(grid_max_x); // 1 byte
|
|
|
|
EEPROM_READ(grid_max_y); // 1 byte
|
|
|
|
#if ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
2017-04-06 03:29:44 +00:00
|
|
|
if (grid_max_x == GRID_MAX_POINTS_X && grid_max_y == GRID_MAX_POINTS_Y) {
|
2016-12-10 06:17:49 +00:00
|
|
|
set_bed_leveling_enabled(false);
|
|
|
|
EEPROM_READ(bilinear_grid_spacing); // 2 ints
|
|
|
|
EEPROM_READ(bilinear_start); // 2 ints
|
|
|
|
EEPROM_READ(bed_level_grid); // 9 to 256 floats
|
|
|
|
#if ENABLED(ABL_BILINEAR_SUBDIVISION)
|
|
|
|
bed_level_virt_interpolate();
|
|
|
|
#endif
|
2016-12-14 07:50:06 +00:00
|
|
|
//set_bed_leveling_enabled(leveling_is_on);
|
2016-12-10 06:17:49 +00:00
|
|
|
}
|
|
|
|
else // EEPROM data is stale
|
|
|
|
#endif // AUTO_BED_LEVELING_BILINEAR
|
|
|
|
{
|
|
|
|
// Skip past disabled (or stale) Bilinear Grid data
|
|
|
|
int bgs[2], bs[2];
|
|
|
|
EEPROM_READ(bgs);
|
|
|
|
EEPROM_READ(bs);
|
|
|
|
for (uint16_t q = grid_max_x * grid_max_y; q--;) EEPROM_READ(dummy);
|
|
|
|
}
|
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
#if ENABLED(DELTA)
|
2017-03-07 23:42:04 +00: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); // 3 floats
|
|
|
|
EEPROM_READ(delta_tower_angle_trim); // 3 floats
|
2016-10-28 23:55:42 +00:00
|
|
|
#elif ENABLED(Z_DUAL_ENDSTOPS)
|
|
|
|
EEPROM_READ(z_endstop_adj);
|
|
|
|
dummy = 0.0f;
|
2017-03-07 22:35:27 +00:00
|
|
|
for (uint8_t q=11; q--;) EEPROM_READ(dummy);
|
2016-10-28 23:55:42 +00:00
|
|
|
#else
|
|
|
|
dummy = 0.0f;
|
2017-03-07 22:35:27 +00:00
|
|
|
for (uint8_t q=12; q--;) EEPROM_READ(dummy);
|
2016-10-28 23:55:42 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if DISABLED(ULTIPANEL)
|
2016-10-27 07:40:37 +00:00
|
|
|
int lcd_preheat_hotend_temp[2], lcd_preheat_bed_temp[2], lcd_preheat_fan_speed[2];
|
2016-10-28 23:55:42 +00:00
|
|
|
#endif
|
|
|
|
|
2016-10-27 07:40:37 +00:00
|
|
|
EEPROM_READ(lcd_preheat_hotend_temp);
|
|
|
|
EEPROM_READ(lcd_preheat_bed_temp);
|
|
|
|
EEPROM_READ(lcd_preheat_fan_speed);
|
2016-10-28 23:55:42 +00:00
|
|
|
|
2017-04-10 02:47:49 +00:00
|
|
|
//EEPROM_ASSERT(
|
|
|
|
// WITHIN(lcd_preheat_fan_speed, 0, 255),
|
|
|
|
// "lcd_preheat_fan_speed out of range"
|
|
|
|
//);
|
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
#if ENABLED(PIDTEMP)
|
|
|
|
for (uint8_t e = 0; e < MAX_EXTRUDERS; e++) {
|
|
|
|
EEPROM_READ(dummy); // Kp
|
|
|
|
if (e < HOTENDS && dummy != DUMMY_PID_VALUE) {
|
|
|
|
// do not need to scale PID values as the values in EEPROM are already scaled
|
|
|
|
PID_PARAM(Kp, e) = dummy;
|
|
|
|
EEPROM_READ(PID_PARAM(Ki, e));
|
|
|
|
EEPROM_READ(PID_PARAM(Kd, e));
|
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
|
|
|
EEPROM_READ(PID_PARAM(Kc, e));
|
|
|
|
#else
|
|
|
|
EEPROM_READ(dummy);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
for (uint8_t q=3; q--;) EEPROM_READ(dummy); // Ki, Kd, Kc
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else // !PIDTEMP
|
|
|
|
// 4 x 4 = 16 slots for PID parameters
|
|
|
|
for (uint8_t q = MAX_EXTRUDERS * 4; q--;) EEPROM_READ(dummy); // Kp, Ki, Kd, Kc
|
|
|
|
#endif // !PIDTEMP
|
|
|
|
|
|
|
|
#if DISABLED(PID_EXTRUSION_SCALING)
|
|
|
|
int lpq_len;
|
|
|
|
#endif
|
|
|
|
EEPROM_READ(lpq_len);
|
|
|
|
|
|
|
|
#if ENABLED(PIDTEMPBED)
|
|
|
|
EEPROM_READ(dummy); // bedKp
|
|
|
|
if (dummy != DUMMY_PID_VALUE) {
|
|
|
|
thermalManager.bedKp = dummy;
|
|
|
|
EEPROM_READ(thermalManager.bedKi);
|
|
|
|
EEPROM_READ(thermalManager.bedKd);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
for (uint8_t q=3; q--;) EEPROM_READ(dummy); // bedKp, bedKi, bedKd
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if !HAS_LCD_CONTRAST
|
|
|
|
int lcd_contrast;
|
|
|
|
#endif
|
|
|
|
EEPROM_READ(lcd_contrast);
|
|
|
|
|
|
|
|
#if ENABLED(FWRETRACT)
|
|
|
|
EEPROM_READ(autoretract_enabled);
|
|
|
|
EEPROM_READ(retract_length);
|
|
|
|
#if EXTRUDERS > 1
|
|
|
|
EEPROM_READ(retract_length_swap);
|
|
|
|
#else
|
|
|
|
EEPROM_READ(dummy);
|
|
|
|
#endif
|
|
|
|
EEPROM_READ(retract_feedrate_mm_s);
|
|
|
|
EEPROM_READ(retract_zlift);
|
|
|
|
EEPROM_READ(retract_recover_length);
|
|
|
|
#if EXTRUDERS > 1
|
|
|
|
EEPROM_READ(retract_recover_length_swap);
|
|
|
|
#else
|
|
|
|
EEPROM_READ(dummy);
|
|
|
|
#endif
|
|
|
|
EEPROM_READ(retract_recover_feedrate_mm_s);
|
|
|
|
#endif // FWRETRACT
|
|
|
|
|
|
|
|
EEPROM_READ(volumetric_enabled);
|
|
|
|
|
|
|
|
for (uint8_t q = 0; q < MAX_EXTRUDERS; q++) {
|
|
|
|
EEPROM_READ(dummy);
|
|
|
|
if (q < COUNT(filament_size)) filament_size[q] = dummy;
|
|
|
|
}
|
|
|
|
|
2017-03-07 05:00:43 +00:00
|
|
|
uint16_t val;
|
|
|
|
#if ENABLED(HAVE_TMC2130)
|
|
|
|
EEPROM_READ(val);
|
|
|
|
#if ENABLED(X_IS_TMC2130)
|
|
|
|
stepperX.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
|
|
|
|
#endif
|
|
|
|
EEPROM_READ(val);
|
|
|
|
#if ENABLED(Y_IS_TMC2130)
|
|
|
|
stepperY.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
|
|
|
|
#endif
|
|
|
|
EEPROM_READ(val);
|
|
|
|
#if ENABLED(Z_IS_TMC2130)
|
|
|
|
stepperZ.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
|
|
|
|
#endif
|
|
|
|
EEPROM_READ(val);
|
|
|
|
#if ENABLED(X2_IS_TMC2130)
|
|
|
|
stepperX2.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
|
|
|
|
#endif
|
|
|
|
EEPROM_READ(val);
|
|
|
|
#if ENABLED(Y2_IS_TMC2130)
|
|
|
|
stepperY2.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
|
|
|
|
#endif
|
|
|
|
EEPROM_READ(val);
|
|
|
|
#if ENABLED(Z2_IS_TMC2130)
|
|
|
|
stepperZ2.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
|
|
|
|
#endif
|
|
|
|
EEPROM_READ(val);
|
|
|
|
#if ENABLED(E0_IS_TMC2130)
|
|
|
|
stepperE0.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
|
|
|
|
#endif
|
|
|
|
EEPROM_READ(val);
|
|
|
|
#if ENABLED(E1_IS_TMC2130)
|
|
|
|
stepperE1.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
|
|
|
|
#endif
|
|
|
|
EEPROM_READ(val);
|
|
|
|
#if ENABLED(E2_IS_TMC2130)
|
|
|
|
stepperE2.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
|
|
|
|
#endif
|
|
|
|
EEPROM_READ(val);
|
|
|
|
#if ENABLED(E3_IS_TMC2130)
|
|
|
|
stepperE3.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
|
|
|
|
#endif
|
2017-04-09 08:23:05 +00:00
|
|
|
EEPROM_READ(val);
|
|
|
|
#if ENABLED(E4_IS_TMC2130)
|
|
|
|
stepperE4.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
|
|
|
|
#endif
|
2017-03-07 05:00:43 +00:00
|
|
|
#else
|
2017-04-09 08:23:05 +00:00
|
|
|
for (uint8_t q = 0; q < 11; q++) EEPROM_READ(val);
|
2017-03-07 05:00:43 +00:00
|
|
|
#endif
|
|
|
|
|
2017-04-16 03:18:10 +00:00
|
|
|
//
|
|
|
|
// Linear Advance
|
|
|
|
//
|
|
|
|
|
|
|
|
float extruder_advance_k, advance_ed_ratio;
|
|
|
|
EEPROM_READ(extruder_advance_k);
|
|
|
|
EEPROM_READ(advance_ed_ratio);
|
|
|
|
|
|
|
|
#if ENABLED(LIN_ADVANCE)
|
|
|
|
planner.set_extruder_advance_k(extruder_advance_k);
|
|
|
|
planner.set_advance_ed_ratio(advance_ed_ratio);
|
|
|
|
#endif
|
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
if (eeprom_checksum == stored_checksum) {
|
2016-12-14 07:48:42 +00:00
|
|
|
if (eeprom_read_error)
|
2017-04-10 02:47:49 +00:00
|
|
|
reset();
|
2016-12-14 07:48:42 +00:00
|
|
|
else {
|
2017-04-10 02:47:49 +00:00
|
|
|
postprocess();
|
2016-12-14 07:48:42 +00:00
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHO(version);
|
2016-12-14 13:13:25 +00:00
|
|
|
SERIAL_ECHOPAIR(" stored settings retrieved (", eeprom_index - (EEPROM_OFFSET));
|
2016-12-14 07:48:42 +00:00
|
|
|
SERIAL_ECHOLNPGM(" bytes)");
|
|
|
|
}
|
2016-10-28 23:55:42 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
SERIAL_ERROR_START;
|
|
|
|
SERIAL_ERRORLNPGM("EEPROM checksum mismatch");
|
2017-04-10 02:47:49 +00:00
|
|
|
reset();
|
2016-10-28 23:55:42 +00:00
|
|
|
}
|
|
|
|
|
2017-03-18 15:15:54 +00:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
2017-03-31 02:32:50 +00:00
|
|
|
ubl.eeprom_start = (eeprom_index + 32) & 0xFFF8; // Pad the end of configuration data so it
|
2017-03-24 05:53:37 +00:00
|
|
|
// can float up or down a little bit without
|
|
|
|
// disrupting the Unified Bed Leveling data
|
2017-03-20 06:42:41 +00:00
|
|
|
ubl.load_state();
|
2017-03-18 15:15:54 +00:00
|
|
|
|
|
|
|
SERIAL_ECHOPGM(" UBL ");
|
2017-03-20 06:42:41 +00:00
|
|
|
if (!ubl.state.active) SERIAL_ECHO("not ");
|
2017-03-18 15:15:54 +00:00
|
|
|
SERIAL_ECHOLNPGM("active!");
|
|
|
|
|
2017-03-20 06:42:41 +00:00
|
|
|
if (!ubl.sanity_check()) {
|
2017-03-18 15:15:54 +00:00
|
|
|
int tmp_mesh; // We want to preserve whether the UBL System is Active
|
|
|
|
bool tmp_active; // If it is, we want to preserve the Mesh that is being used.
|
2017-03-20 06:42:41 +00:00
|
|
|
tmp_mesh = ubl.state.eeprom_storage_slot;
|
|
|
|
tmp_active = ubl.state.active;
|
2017-03-18 15:15:54 +00:00
|
|
|
SERIAL_ECHOLNPGM("\nInitializing Bed Leveling State to current firmware settings.\n");
|
2017-03-20 06:42:41 +00:00
|
|
|
ubl.state = ubl.pre_initialized; // Initialize with the pre_initialized data structure
|
|
|
|
ubl.state.eeprom_storage_slot = tmp_mesh; // But then restore some data we don't want mangled
|
|
|
|
ubl.state.active = tmp_active;
|
2017-03-18 15:15:54 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
SERIAL_PROTOCOLPGM("?Unable to enable Unified Bed Leveling.\n");
|
2017-03-20 06:42:41 +00:00
|
|
|
ubl.state = ubl.pre_initialized;
|
|
|
|
ubl.reset();
|
|
|
|
ubl.store_state();
|
2017-03-18 15:15:54 +00:00
|
|
|
}
|
|
|
|
|
2017-03-20 06:42:41 +00:00
|
|
|
if (ubl.state.eeprom_storage_slot >= 0) {
|
|
|
|
ubl.load_mesh(ubl.state.eeprom_storage_slot);
|
|
|
|
SERIAL_ECHOPAIR("Mesh ", ubl.state.eeprom_storage_slot);
|
2017-03-18 15:15:54 +00:00
|
|
|
SERIAL_ECHOLNPGM(" loaded from storage.");
|
|
|
|
}
|
|
|
|
else {
|
2017-03-20 06:42:41 +00:00
|
|
|
ubl.reset();
|
2017-03-24 05:53:37 +00:00
|
|
|
SERIAL_ECHOLNPGM("UBL System reset()");
|
2017-03-18 15:15:54 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
2016-10-28 23:55:42 +00:00
|
|
|
#if ENABLED(EEPROM_CHITCHAT)
|
2017-04-10 02:47:49 +00:00
|
|
|
report();
|
2016-10-28 23:55:42 +00:00
|
|
|
#endif
|
2017-03-20 11:10:31 +00:00
|
|
|
|
|
|
|
return !eeprom_read_error;
|
2016-10-28 23:55:42 +00:00
|
|
|
}
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2016-10-28 23:53:48 +00:00
|
|
|
#else // !EEPROM_SETTINGS
|
|
|
|
|
2017-04-10 02:47:49 +00:00
|
|
|
bool MarlinSettings::save() {
|
2016-10-28 23:53:48 +00:00
|
|
|
SERIAL_ERROR_START;
|
|
|
|
SERIAL_ERRORLNPGM("EEPROM disabled");
|
2017-03-20 11:10:31 +00:00
|
|
|
return false;
|
2016-10-28 23:53:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif // !EEPROM_SETTINGS
|
2015-01-28 09:08:48 +00:00
|
|
|
|
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
|
|
|
*/
|
2017-04-10 02:47:49 +00:00
|
|
|
void MarlinSettings::reset() {
|
2016-10-28 23:39:23 +00:00
|
|
|
const float tmp1[] = DEFAULT_AXIS_STEPS_PER_UNIT, tmp2[] = DEFAULT_MAX_FEEDRATE;
|
2016-12-16 04:04:18 +00:00
|
|
|
const uint32_t tmp3[] = DEFAULT_MAX_ACCELERATION;
|
2016-12-04 04:02:27 +00:00
|
|
|
LOOP_XYZE_N(i) {
|
|
|
|
planner.axis_steps_per_mm[i] = tmp1[i < COUNT(tmp1) ? i : COUNT(tmp1) - 1];
|
|
|
|
planner.max_feedrate_mm_s[i] = tmp2[i < COUNT(tmp2) ? i : COUNT(tmp2) - 1];
|
|
|
|
planner.max_acceleration_mm_per_s2[i] = tmp3[i < COUNT(tmp3) ? i : COUNT(tmp3) - 1];
|
2015-01-28 09:08:48 +00:00
|
|
|
}
|
|
|
|
|
2016-04-28 01:06:32 +00:00
|
|
|
planner.acceleration = DEFAULT_ACCELERATION;
|
|
|
|
planner.retract_acceleration = DEFAULT_RETRACT_ACCELERATION;
|
|
|
|
planner.travel_acceleration = DEFAULT_TRAVEL_ACCELERATION;
|
2016-07-16 01:49:34 +00:00
|
|
|
planner.min_feedrate_mm_s = DEFAULT_MINIMUMFEEDRATE;
|
2016-04-28 01:06:32 +00:00
|
|
|
planner.min_segment_time = DEFAULT_MINSEGMENTTIME;
|
2016-07-16 01:49:34 +00:00
|
|
|
planner.min_travel_feedrate_mm_s = DEFAULT_MINTRAVELFEEDRATE;
|
2016-10-02 09:37:13 +00: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;
|
2017-02-21 12:49:31 +00:00
|
|
|
|
|
|
|
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
|
|
|
planner.z_fade_height = 0.0;
|
|
|
|
#endif
|
|
|
|
|
2017-04-15 02:41:21 +00:00
|
|
|
#if HAS_HOME_OFFSET
|
2017-03-05 00:01:33 +00:00
|
|
|
ZERO(home_offset);
|
|
|
|
#endif
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2016-10-28 23:39:23 +00:00
|
|
|
#if HOTENDS > 1
|
|
|
|
constexpr float tmp4[XYZ][HOTENDS] = {
|
|
|
|
HOTEND_OFFSET_X,
|
|
|
|
HOTEND_OFFSET_Y
|
|
|
|
#ifdef HOTEND_OFFSET_Z
|
|
|
|
, HOTEND_OFFSET_Z
|
|
|
|
#else
|
|
|
|
, { 0 }
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
static_assert(
|
|
|
|
tmp4[X_AXIS][0] == 0 && tmp4[Y_AXIS][0] == 0 && tmp4[Z_AXIS][0] == 0,
|
|
|
|
"Offsets for the first hotend must be 0.0."
|
|
|
|
);
|
|
|
|
LOOP_XYZ(i) HOTEND_LOOP() hotend_offset[i][e] = tmp4[i][e];
|
|
|
|
#endif
|
|
|
|
|
2016-12-14 07:44:39 +00:00
|
|
|
// Applies to all MBL and ABL
|
2016-12-10 06:17:49 +00:00
|
|
|
#if PLANNER_LEVELING
|
|
|
|
reset_bed_level();
|
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)
|
2017-03-07 23:42:04 +00:00
|
|
|
const float adj[ABC] = DELTA_ENDSTOP_ADJ,
|
|
|
|
drt[ABC] = { DELTA_DIAGONAL_ROD_TRIM_TOWER_1, DELTA_DIAGONAL_ROD_TRIM_TOWER_2, DELTA_DIAGONAL_ROD_TRIM_TOWER_3 },
|
|
|
|
dta[ABC] = { DELTA_TOWER_ANGLE_TRIM_1, DELTA_TOWER_ANGLE_TRIM_2, DELTA_TOWER_ANGLE_TRIM_3 };
|
|
|
|
COPY(endstop_adj, adj);
|
2016-12-10 06:17:49 +00:00
|
|
|
delta_radius = DELTA_RADIUS;
|
|
|
|
delta_diagonal_rod = DELTA_DIAGONAL_ROD;
|
|
|
|
delta_segments_per_second = DELTA_SEGMENTS_PER_SECOND;
|
2017-03-07 23:42:04 +00:00
|
|
|
COPY(delta_diagonal_rod_trim, drt);
|
|
|
|
COPY(delta_tower_angle_trim, dta);
|
2017-04-15 02:41:21 +00:00
|
|
|
home_offset[Z_AXIS] = 0;
|
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#elif ENABLED(Z_DUAL_ENDSTOPS)
|
2017-04-15 02:41:21 +00:00
|
|
|
|
2017-02-21 12:49:31 +00:00
|
|
|
float z_endstop_adj =
|
|
|
|
#ifdef Z_DUAL_ENDSTOPS_ADJUSTMENT
|
|
|
|
Z_DUAL_ENDSTOPS_ADJUSTMENT
|
|
|
|
#else
|
|
|
|
0
|
|
|
|
#endif
|
|
|
|
;
|
2017-04-15 02:41:21 +00:00
|
|
|
|
2015-01-28 09:08:48 +00:00
|
|
|
#endif
|
|
|
|
|
2015-07-31 05:31:45 +00:00
|
|
|
#if ENABLED(ULTIPANEL)
|
2016-10-27 07:40:37 +00:00
|
|
|
lcd_preheat_hotend_temp[0] = PREHEAT_1_TEMP_HOTEND;
|
|
|
|
lcd_preheat_hotend_temp[1] = PREHEAT_2_TEMP_HOTEND;
|
|
|
|
lcd_preheat_bed_temp[0] = PREHEAT_1_TEMP_BED;
|
|
|
|
lcd_preheat_bed_temp[1] = PREHEAT_2_TEMP_BED;
|
|
|
|
lcd_preheat_fan_speed[0] = PREHEAT_1_FAN_SPEED;
|
|
|
|
lcd_preheat_fan_speed[1] = PREHEAT_2_FAN_SPEED;
|
2015-01-28 09:08:48 +00:00
|
|
|
#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-07-13 13:11:23 +00:00
|
|
|
#if ENABLED(PID_PARAMS_PER_HOTEND) && HOTENDS > 1
|
2016-07-11 18:48:15 +00:00
|
|
|
HOTEND_LOOP()
|
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);
|
2016-08-01 00:49:34 +00:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2015-01-28 09:08:48 +00:00
|
|
|
PID_PARAM(Kc, e) = DEFAULT_Kc;
|
|
|
|
#endif
|
|
|
|
}
|
2016-08-01 00:49:34 +00:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2015-08-31 02:04:30 +00:00
|
|
|
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
|
2016-07-16 01:49:34 +00:00
|
|
|
retract_recover_feedrate_mm_s = RETRACT_RECOVER_FEEDRATE;
|
2015-01-28 09:08:48 +00:00
|
|
|
#endif
|
|
|
|
|
2017-01-02 03:10:50 +00:00
|
|
|
volumetric_enabled =
|
2017-02-21 12:49:31 +00:00
|
|
|
#if ENABLED(VOLUMETRIC_DEFAULT_ON)
|
|
|
|
true
|
|
|
|
#else
|
|
|
|
false
|
|
|
|
#endif
|
2017-01-02 03:10:50 +00:00
|
|
|
;
|
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
|
|
|
|
2016-07-14 23:12:20 +00:00
|
|
|
endstops.enable_globally(
|
|
|
|
#if ENABLED(ENDSTOPS_ALWAYS_ON_DEFAULT)
|
|
|
|
(true)
|
|
|
|
#else
|
|
|
|
(false)
|
|
|
|
#endif
|
|
|
|
);
|
|
|
|
|
2017-03-07 05:00:43 +00:00
|
|
|
#if ENABLED(HAVE_TMC2130)
|
|
|
|
#if ENABLED(X_IS_TMC2130)
|
2017-04-15 03:44:08 +00:00
|
|
|
stepperX.setCurrent(X_CURRENT, R_SENSE, HOLD_MULTIPLIER);
|
2017-03-07 05:00:43 +00:00
|
|
|
#endif
|
|
|
|
#if ENABLED(Y_IS_TMC2130)
|
2017-04-15 03:44:08 +00:00
|
|
|
stepperY.setCurrent(Y_CURRENT, R_SENSE, HOLD_MULTIPLIER);
|
2017-03-07 05:00:43 +00:00
|
|
|
#endif
|
|
|
|
#if ENABLED(Z_IS_TMC2130)
|
2017-04-15 03:44:08 +00:00
|
|
|
stepperZ.setCurrent(Z_CURRENT, R_SENSE, HOLD_MULTIPLIER);
|
2017-03-07 05:00:43 +00:00
|
|
|
#endif
|
|
|
|
#if ENABLED(X2_IS_TMC2130)
|
2017-04-15 03:44:08 +00:00
|
|
|
stepperX2.setCurrent(X2_CURRENT, R_SENSE, HOLD_MULTIPLIER);
|
2017-03-07 05:00:43 +00:00
|
|
|
#endif
|
|
|
|
#if ENABLED(Y2_IS_TMC2130)
|
2017-04-15 03:44:08 +00:00
|
|
|
stepperY2.setCurrent(Y2_CURRENT, R_SENSE, HOLD_MULTIPLIER);
|
2017-03-07 05:00:43 +00:00
|
|
|
#endif
|
|
|
|
#if ENABLED(Z2_IS_TMC2130)
|
2017-04-15 03:44:08 +00:00
|
|
|
stepperZ2.setCurrent(Z2_CURRENT, R_SENSE, HOLD_MULTIPLIER);
|
2017-03-07 05:00:43 +00:00
|
|
|
#endif
|
|
|
|
#if ENABLED(E0_IS_TMC2130)
|
2017-04-15 03:44:08 +00:00
|
|
|
stepperE0.setCurrent(E0_CURRENT, R_SENSE, HOLD_MULTIPLIER);
|
2017-03-07 05:00:43 +00:00
|
|
|
#endif
|
|
|
|
#if ENABLED(E1_IS_TMC2130)
|
2017-04-15 03:44:08 +00:00
|
|
|
stepperE1.setCurrent(E1_CURRENT, R_SENSE, HOLD_MULTIPLIER);
|
2017-03-07 05:00:43 +00:00
|
|
|
#endif
|
|
|
|
#if ENABLED(E2_IS_TMC2130)
|
2017-04-15 03:44:08 +00:00
|
|
|
stepperE2.setCurrent(E2_CURRENT, R_SENSE, HOLD_MULTIPLIER);
|
2017-03-07 05:00:43 +00:00
|
|
|
#endif
|
|
|
|
#if ENABLED(E3_IS_TMC2130)
|
2017-04-15 03:44:08 +00:00
|
|
|
stepperE3.setCurrent(E3_CURRENT, R_SENSE, HOLD_MULTIPLIER);
|
2017-03-07 05:00:43 +00:00
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2017-04-16 03:18:10 +00:00
|
|
|
#if ENABLED(LIN_ADVANCE)
|
|
|
|
planner.set_extruder_advance_k(LIN_ADVANCE_K);
|
|
|
|
planner.set_advance_ed_ratio(LIN_ADVANCE_E_D_RATIO);
|
|
|
|
#endif
|
|
|
|
|
2017-04-10 02:47:49 +00:00
|
|
|
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
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
#define CONFIG_ECHO_START do{ if (!forReplay) SERIAL_ECHO_START; }while(0)
|
2015-04-27 01:44:01 +00:00
|
|
|
|
2017-04-17 04:24:30 +00:00
|
|
|
#if ENABLED(INCH_MODE_SUPPORT)
|
|
|
|
extern float linear_unit_factor;
|
|
|
|
#define LINEAR_UNIT(N) ((N) / linear_unit_factor)
|
|
|
|
#else
|
|
|
|
#define LINEAR_UNIT(N) N
|
|
|
|
#endif
|
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
/**
|
2017-04-10 02:47:49 +00:00
|
|
|
* M503 - Report current settings in RAM
|
2017-03-31 19:58:40 +00:00
|
|
|
*
|
2017-04-10 02:47:49 +00:00
|
|
|
* Unless specifically disabled, M503 is available even without EEPROM
|
2016-10-28 23:55:42 +00:00
|
|
|
*/
|
2017-04-10 02:47:49 +00:00
|
|
|
void MarlinSettings::report(bool forReplay) {
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2017-04-17 04:24:30 +00:00
|
|
|
/**
|
|
|
|
* Announce current units, in case inches are being displayed
|
|
|
|
*/
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
#if ENABLED(INCH_MODE_SUPPORT)
|
|
|
|
extern float linear_unit_factor, volumetric_unit_factor;
|
|
|
|
#define LINEAR_UNIT(N) ((N) / linear_unit_factor)
|
|
|
|
#define VOLUMETRIC_UNIT(N) ((N) / (volumetric_enabled ? volumetric_unit_factor : linear_unit_factor))
|
|
|
|
serialprintPGM(linear_unit_factor == 1.0 ? PSTR(" G21 ; Units in mm\n") : PSTR(" G20 ; Units in inches\n"));
|
|
|
|
#else
|
|
|
|
#define LINEAR_UNIT(N) N
|
|
|
|
#define VOLUMETRIC_UNIT(N) N
|
|
|
|
SERIAL_ECHOLNPGM(" G21 ; Units in mm\n");
|
|
|
|
#endif
|
|
|
|
SERIAL_EOL;
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2017-04-17 04:24:30 +00:00
|
|
|
/**
|
|
|
|
* Volumetric extrusion M200
|
|
|
|
*/
|
2016-10-28 23:39:23 +00:00
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOPGM("Filament settings:");
|
|
|
|
if (volumetric_enabled)
|
|
|
|
SERIAL_EOL;
|
|
|
|
else
|
|
|
|
SERIAL_ECHOLNPGM(" Disabled");
|
2016-10-28 23:39:23 +00:00
|
|
|
}
|
2017-04-17 04:24:30 +00:00
|
|
|
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR(" M200 D", filament_size[0]);
|
|
|
|
SERIAL_EOL;
|
|
|
|
#if EXTRUDERS > 1
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR(" M200 T1 D", filament_size[1]);
|
|
|
|
SERIAL_EOL;
|
|
|
|
#if EXTRUDERS > 2
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR(" M200 T2 D", filament_size[2]);
|
|
|
|
SERIAL_EOL;
|
|
|
|
#if EXTRUDERS > 3
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR(" M200 T3 D", filament_size[3]);
|
|
|
|
SERIAL_EOL;
|
|
|
|
#if EXTRUDERS > 4
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR(" M200 T4 D", filament_size[4]);
|
|
|
|
SERIAL_EOL;
|
|
|
|
#endif // EXTRUDERS > 4
|
|
|
|
#endif // EXTRUDERS > 3
|
|
|
|
#endif // EXTRUDERS > 2
|
|
|
|
#endif // EXTRUDERS > 1
|
|
|
|
|
|
|
|
if (!volumetric_enabled) {
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPGM(" M200 D0");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPGM("Steps per unit:");
|
|
|
|
}
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR(" M92 X", LINEAR_UNIT(planner.axis_steps_per_mm[X_AXIS]));
|
|
|
|
SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(planner.axis_steps_per_mm[Y_AXIS]));
|
|
|
|
SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.axis_steps_per_mm[Z_AXIS]));
|
2016-12-12 01:37:29 +00:00
|
|
|
#if DISABLED(DISTINCT_E_FACTORS)
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOPAIR(" E", VOLUMETRIC_UNIT(planner.axis_steps_per_mm[E_AXIS]));
|
2016-12-04 04:02:27 +00:00
|
|
|
#endif
|
2016-10-28 23:55:42 +00:00
|
|
|
SERIAL_EOL;
|
2016-12-04 04:02:27 +00:00
|
|
|
#if ENABLED(DISTINCT_E_FACTORS)
|
2017-04-17 04:24:30 +00:00
|
|
|
CONFIG_ECHO_START;
|
2016-12-04 04:02:27 +00:00
|
|
|
for (uint8_t i = 0; i < E_STEPPERS; i++) {
|
|
|
|
SERIAL_ECHOPAIR(" M92 T", (int)i);
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPAIR(" E", VOLUMETRIC_UNIT(planner.axis_steps_per_mm[E_AXIS + i]));
|
2016-12-04 04:02:27 +00:00
|
|
|
}
|
|
|
|
#endif
|
2016-10-28 23:55:42 +00:00
|
|
|
|
2015-04-27 01:44:01 +00:00
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPGM("Maximum feedrates (units/s):");
|
2015-04-27 01:44:01 +00:00
|
|
|
}
|
2017-04-17 04:24:30 +00:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR(" M203 X", LINEAR_UNIT(planner.max_feedrate_mm_s[X_AXIS]));
|
|
|
|
SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(planner.max_feedrate_mm_s[Y_AXIS]));
|
|
|
|
SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.max_feedrate_mm_s[Z_AXIS]));
|
2016-12-12 01:37:29 +00:00
|
|
|
#if DISABLED(DISTINCT_E_FACTORS)
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOPAIR(" E", VOLUMETRIC_UNIT(planner.max_feedrate_mm_s[E_AXIS]));
|
2016-12-04 04:02:27 +00:00
|
|
|
#endif
|
2015-04-27 01:44:01 +00:00
|
|
|
SERIAL_EOL;
|
2016-12-04 04:02:27 +00:00
|
|
|
#if ENABLED(DISTINCT_E_FACTORS)
|
2017-04-17 04:24:30 +00:00
|
|
|
CONFIG_ECHO_START;
|
2016-12-04 04:02:27 +00:00
|
|
|
for (uint8_t i = 0; i < E_STEPPERS; i++) {
|
|
|
|
SERIAL_ECHOPAIR(" M203 T", (int)i);
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPAIR(" E", VOLUMETRIC_UNIT(planner.max_feedrate_mm_s[E_AXIS + i]));
|
2016-12-04 04:02:27 +00:00
|
|
|
}
|
|
|
|
#endif
|
2015-04-27 01:44:01 +00:00
|
|
|
|
2015-01-28 09:08:48 +00:00
|
|
|
if (!forReplay) {
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPGM("Maximum Acceleration (units/s2):");
|
2015-01-28 09:08:48 +00:00
|
|
|
}
|
2017-04-17 04:24:30 +00:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR(" M201 X", LINEAR_UNIT(planner.max_acceleration_mm_per_s2[X_AXIS]));
|
|
|
|
SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(planner.max_acceleration_mm_per_s2[Y_AXIS]));
|
|
|
|
SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.max_acceleration_mm_per_s2[Z_AXIS]));
|
2016-12-12 01:37:29 +00:00
|
|
|
#if DISABLED(DISTINCT_E_FACTORS)
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOPAIR(" E", VOLUMETRIC_UNIT(planner.max_acceleration_mm_per_s2[E_AXIS]));
|
2016-12-04 04:02:27 +00:00
|
|
|
#endif
|
2015-01-29 05:19:51 +00:00
|
|
|
SERIAL_EOL;
|
2016-12-04 04:02:27 +00:00
|
|
|
#if ENABLED(DISTINCT_E_FACTORS)
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHO_START;
|
2016-12-04 04:02:27 +00:00
|
|
|
for (uint8_t i = 0; i < E_STEPPERS; i++) {
|
|
|
|
SERIAL_ECHOPAIR(" M201 T", (int)i);
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPAIR(" E", VOLUMETRIC_UNIT(planner.max_acceleration_mm_per_s2[E_AXIS + i]));
|
2016-12-04 04:02:27 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2016-02-17 21:05:12 +00:00
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPGM("Acceleration (units/s2): P<print_accel> R<retract_accel> T<travel_accel>");
|
2016-02-17 21:05:12 +00:00
|
|
|
}
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOPAIR(" M204 P", LINEAR_UNIT(planner.acceleration));
|
|
|
|
SERIAL_ECHOPAIR(" R", LINEAR_UNIT(planner.retract_acceleration));
|
|
|
|
SERIAL_ECHOLNPAIR(" T", LINEAR_UNIT(planner.travel_acceleration));
|
|
|
|
|
2015-03-24 17:06:44 +00:00
|
|
|
if (!forReplay) {
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPGM("Advanced: S<min_feedrate> T<min_travel_feedrate> B<min_segment_time_ms> X<max_xy_jerk> Z<max_z_jerk> E<max_e_jerk>");
|
2015-03-24 17:06:44 +00:00
|
|
|
}
|
2017-04-17 04:24:30 +00:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR(" M205 S", LINEAR_UNIT(planner.min_feedrate_mm_s));
|
|
|
|
SERIAL_ECHOPAIR(" T", LINEAR_UNIT(planner.min_travel_feedrate_mm_s));
|
2016-10-28 23:55:42 +00:00
|
|
|
SERIAL_ECHOPAIR(" B", planner.min_segment_time);
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOPAIR(" X", LINEAR_UNIT(planner.max_jerk[X_AXIS]));
|
|
|
|
SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(planner.max_jerk[Y_AXIS]));
|
|
|
|
SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.max_jerk[Z_AXIS]));
|
|
|
|
SERIAL_ECHOLNPAIR(" E", LINEAR_UNIT(planner.max_jerk[E_AXIS]));
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2017-04-15 02:41:21 +00:00
|
|
|
#if HAS_M206_COMMAND
|
2017-03-05 00:01:33 +00:00
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPGM("Home offset:");
|
2017-03-05 00:01:33 +00:00
|
|
|
}
|
2017-04-17 04:24:30 +00:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR(" M206 X", LINEAR_UNIT(home_offset[X_AXIS]));
|
|
|
|
SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(home_offset[Y_AXIS]));
|
|
|
|
SERIAL_ECHOLNPAIR(" Z", LINEAR_UNIT(home_offset[Z_AXIS]));
|
2017-03-05 00:01:33 +00:00
|
|
|
#endif
|
2015-04-27 01:44:01 +00:00
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
#if HOTENDS > 1
|
|
|
|
if (!forReplay) {
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPGM("Hotend offsets:");
|
2016-10-28 23:55:42 +00:00
|
|
|
}
|
2017-04-17 04:24:30 +00:00
|
|
|
CONFIG_ECHO_START;
|
2016-10-28 23:55:42 +00:00
|
|
|
for (uint8_t e = 1; e < HOTENDS; e++) {
|
|
|
|
SERIAL_ECHOPAIR(" M218 T", (int)e);
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOPAIR(" X", LINEAR_UNIT(hotend_offset[X_AXIS][e]));
|
|
|
|
SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(hotend_offset[Y_AXIS][e]));
|
2016-10-28 23:55:42 +00:00
|
|
|
#if ENABLED(DUAL_X_CARRIAGE) || ENABLED(SWITCHING_EXTRUDER)
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(hotend_offset[Z_AXIS][e]));
|
2015-08-31 02:04:30 +00:00
|
|
|
#endif
|
2015-04-27 01:44:01 +00:00
|
|
|
SERIAL_EOL;
|
|
|
|
}
|
2016-10-28 23:55:42 +00:00
|
|
|
#endif
|
2015-04-27 01:44:01 +00:00
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2017-03-24 05:53:37 +00:00
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPGM("Mesh Bed Leveling:");
|
2016-10-28 23:55:42 +00:00
|
|
|
}
|
2017-04-17 04:24:30 +00:00
|
|
|
CONFIG_ECHO_START;
|
2017-02-21 12:49:31 +00:00
|
|
|
SERIAL_ECHOPAIR(" M420 S", mbl.has_mesh() ? 1 : 0);
|
|
|
|
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.z_fade_height));
|
2017-02-21 12:49:31 +00:00
|
|
|
#endif
|
|
|
|
SERIAL_EOL;
|
2017-04-12 22:24:05 +00:00
|
|
|
for (uint8_t py = 0; py < GRID_MAX_POINTS_Y; py++) {
|
|
|
|
for (uint8_t px = 0; px < GRID_MAX_POINTS_X; px++) {
|
2016-10-28 23:55:42 +00:00
|
|
|
CONFIG_ECHO_START;
|
2017-04-12 22:24:05 +00:00
|
|
|
SERIAL_ECHOPAIR(" G29 S3 X", (int)px + 1);
|
|
|
|
SERIAL_ECHOPAIR(" Y", (int)py + 1);
|
2016-10-28 23:55:42 +00:00
|
|
|
SERIAL_ECHOPGM(" Z");
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_PROTOCOL_F(LINEAR_UNIT(mbl.z_values[px][py]), 5);
|
2016-10-28 23:55:42 +00:00
|
|
|
SERIAL_EOL;
|
|
|
|
}
|
|
|
|
}
|
2017-03-24 05:53:37 +00:00
|
|
|
|
|
|
|
#elif ENABLED(AUTO_BED_LEVELING_UBL)
|
|
|
|
|
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPGM("Unified Bed Leveling:");
|
2017-03-24 05:53:37 +00:00
|
|
|
}
|
2017-04-17 04:24:30 +00:00
|
|
|
CONFIG_ECHO_START;
|
2017-02-21 12:49:31 +00:00
|
|
|
SERIAL_ECHOPAIR(" M420 S", ubl.state.active ? 1 : 0);
|
|
|
|
//#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
2017-04-17 04:24:30 +00:00
|
|
|
// SERIAL_ECHOPAIR(" Z", ubl.state.g29_correction_fade_height);
|
2017-02-21 12:49:31 +00:00
|
|
|
//#endif
|
|
|
|
SERIAL_EOL;
|
2017-03-24 05:53:37 +00:00
|
|
|
|
|
|
|
if (!forReplay) {
|
|
|
|
SERIAL_ECHOPGM("\nUBL is ");
|
|
|
|
ubl.state.active ? SERIAL_CHAR('A') : SERIAL_ECHOPGM("Ina");
|
|
|
|
SERIAL_ECHOLNPAIR("ctive\n\nActive Mesh Slot: ", ubl.state.eeprom_storage_slot);
|
|
|
|
|
|
|
|
SERIAL_ECHOPGM("z_offset: ");
|
|
|
|
SERIAL_ECHO_F(ubl.state.z_offset, 6);
|
|
|
|
SERIAL_EOL;
|
|
|
|
|
2017-03-31 02:32:50 +00:00
|
|
|
SERIAL_ECHOPAIR("EEPROM can hold ", (int)((UBL_LAST_EEPROM_INDEX - ubl.eeprom_start) / sizeof(ubl.z_values)));
|
2017-03-24 05:53:37 +00:00
|
|
|
SERIAL_ECHOLNPGM(" meshes.\n");
|
|
|
|
|
2017-04-16 00:14:40 +00:00
|
|
|
SERIAL_ECHOLNPAIR("GRID_MAX_POINTS_X ", GRID_MAX_POINTS_X);
|
|
|
|
SERIAL_ECHOLNPAIR("GRID_MAX_POINTS_Y ", GRID_MAX_POINTS_Y);
|
2017-03-24 05:53:37 +00:00
|
|
|
|
2017-04-16 00:14:40 +00:00
|
|
|
SERIAL_ECHOPGM("UBL_MESH_MIN_X " STRINGIFY(UBL_MESH_MIN_X));
|
|
|
|
SERIAL_ECHOLNPAIR("=", UBL_MESH_MIN_X );
|
|
|
|
SERIAL_ECHOPGM("UBL_MESH_MIN_Y " STRINGIFY(UBL_MESH_MIN_Y));
|
|
|
|
SERIAL_ECHOLNPAIR("=", UBL_MESH_MIN_Y );
|
2017-03-24 05:53:37 +00:00
|
|
|
|
2017-04-16 00:14:40 +00:00
|
|
|
SERIAL_ECHOPGM("UBL_MESH_MAX_X " STRINGIFY(UBL_MESH_MAX_X));
|
|
|
|
SERIAL_ECHOLNPAIR("=", UBL_MESH_MAX_X);
|
|
|
|
SERIAL_ECHOPGM("UBL_MESH_MAX_Y " STRINGIFY(UBL_MESH_MAX_Y));
|
|
|
|
SERIAL_ECHOLNPAIR("=", UBL_MESH_MAX_Y);
|
2017-03-24 05:53:37 +00:00
|
|
|
|
2017-04-16 00:14:40 +00:00
|
|
|
SERIAL_ECHOLNPAIR("MESH_X_DIST ", MESH_X_DIST);
|
|
|
|
SERIAL_ECHOLNPAIR("MESH_Y_DIST ", MESH_Y_DIST);
|
2017-03-24 05:53:37 +00:00
|
|
|
SERIAL_EOL;
|
|
|
|
}
|
|
|
|
|
2016-12-10 06:17:49 +00:00
|
|
|
#elif HAS_ABL
|
2017-03-24 05:53:37 +00:00
|
|
|
|
2016-12-10 06:17:49 +00:00
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPGM("Auto Bed Leveling:");
|
2016-12-10 06:17:49 +00:00
|
|
|
}
|
2017-04-17 04:24:30 +00:00
|
|
|
CONFIG_ECHO_START;
|
2017-02-21 12:49:31 +00:00
|
|
|
SERIAL_ECHOPAIR(" M420 S", planner.abl_enabled ? 1 : 0);
|
|
|
|
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.z_fade_height));
|
2017-02-21 12:49:31 +00:00
|
|
|
#endif
|
|
|
|
SERIAL_EOL;
|
2017-03-24 05:53:37 +00:00
|
|
|
|
2015-04-03 23:38:05 +00:00
|
|
|
#endif
|
2015-04-27 01:44:01 +00:00
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
#if ENABLED(DELTA)
|
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPGM("Endstop adjustment:");
|
2016-10-28 23:55:42 +00:00
|
|
|
}
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOPAIR(" M666 X", LINEAR_UNIT(endstop_adj[X_AXIS]));
|
|
|
|
SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(endstop_adj[Y_AXIS]));
|
|
|
|
SERIAL_ECHOLNPAIR(" Z", LINEAR_UNIT(endstop_adj[Z_AXIS]));
|
2016-10-28 23:55:42 +00:00
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPGM("Delta settings: L<diagonal_rod> R<radius> H<height> S<segments_per_s> ABC<diagonal_rod_[123]_trim>");
|
2016-10-28 23:55:42 +00:00
|
|
|
}
|
2017-04-17 04:24:30 +00:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR(" M665 L", LINEAR_UNIT(delta_diagonal_rod));
|
|
|
|
SERIAL_ECHOPAIR(" R", LINEAR_UNIT(delta_radius));
|
|
|
|
SERIAL_ECHOPAIR(" H", LINEAR_UNIT(DELTA_HEIGHT + home_offset[Z_AXIS]));
|
2016-10-28 23:55:42 +00:00
|
|
|
SERIAL_ECHOPAIR(" S", delta_segments_per_second);
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOPAIR(" A", LINEAR_UNIT(delta_diagonal_rod_trim[A_AXIS]));
|
|
|
|
SERIAL_ECHOPAIR(" B", LINEAR_UNIT(delta_diagonal_rod_trim[B_AXIS]));
|
|
|
|
SERIAL_ECHOPAIR(" C", LINEAR_UNIT(delta_diagonal_rod_trim[C_AXIS]));
|
|
|
|
SERIAL_ECHOPAIR(" I", LINEAR_UNIT(delta_tower_angle_trim[A_AXIS]));
|
|
|
|
SERIAL_ECHOPAIR(" J", LINEAR_UNIT(delta_tower_angle_trim[B_AXIS]));
|
|
|
|
SERIAL_ECHOLNPAIR(" K", LINEAR_UNIT(delta_tower_angle_trim[C_AXIS]));
|
2016-10-28 23:55:42 +00:00
|
|
|
#elif ENABLED(Z_DUAL_ENDSTOPS)
|
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPGM("Z2 Endstop adjustment:");
|
2016-10-28 23:55:42 +00:00
|
|
|
}
|
2017-04-17 04:24:30 +00:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPAIR(" M666 Z", LINEAR_UNIT(z_endstop_adj));
|
2016-10-28 23:55:42 +00:00
|
|
|
#endif // DELTA
|
2015-04-27 01:44:01 +00:00
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
#if ENABLED(ULTIPANEL)
|
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPGM("Material heatup parameters:");
|
2016-10-28 23:55:42 +00:00
|
|
|
}
|
2017-04-17 04:24:30 +00:00
|
|
|
CONFIG_ECHO_START;
|
2016-10-27 07:40:37 +00:00
|
|
|
for (uint8_t i = 0; i < COUNT(lcd_preheat_hotend_temp); i++) {
|
|
|
|
SERIAL_ECHOPAIR(" M145 S", (int)i);
|
|
|
|
SERIAL_ECHOPAIR(" H", lcd_preheat_hotend_temp[i]);
|
|
|
|
SERIAL_ECHOPAIR(" B", lcd_preheat_bed_temp[i]);
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPAIR(" F", lcd_preheat_fan_speed[i]);
|
2016-10-27 07:40:37 +00:00
|
|
|
}
|
2016-10-28 23:55:42 +00:00
|
|
|
#endif // ULTIPANEL
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
#if HAS_PID_HEATING
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
if (!forReplay) {
|
2017-04-17 04:24:30 +00:00
|
|
|
CONFIG_ECHO_START;
|
2016-10-28 23:55:42 +00:00
|
|
|
SERIAL_ECHOLNPGM("PID settings:");
|
|
|
|
}
|
|
|
|
#if ENABLED(PIDTEMP)
|
|
|
|
#if HOTENDS > 1
|
|
|
|
if (forReplay) {
|
|
|
|
HOTEND_LOOP() {
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
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)));
|
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
|
|
|
SERIAL_ECHOPAIR(" C", PID_PARAM(Kc, e));
|
|
|
|
if (e == 0) SERIAL_ECHOPAIR(" L", lpq_len);
|
|
|
|
#endif
|
|
|
|
SERIAL_EOL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
#endif // HOTENDS > 1
|
|
|
|
// !forReplay || HOTENDS == 1
|
|
|
|
{
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR(" M301 P", PID_PARAM(Kp, 0)); // for compatibility with hosts, only echo values for E0
|
|
|
|
SERIAL_ECHOPAIR(" I", unscalePID_i(PID_PARAM(Ki, 0)));
|
|
|
|
SERIAL_ECHOPAIR(" D", unscalePID_d(PID_PARAM(Kd, 0)));
|
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
|
|
|
SERIAL_ECHOPAIR(" C", PID_PARAM(Kc, 0));
|
|
|
|
SERIAL_ECHOPAIR(" L", lpq_len);
|
|
|
|
#endif
|
|
|
|
SERIAL_EOL;
|
|
|
|
}
|
|
|
|
#endif // PIDTEMP
|
|
|
|
|
|
|
|
#if ENABLED(PIDTEMPBED)
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR(" M304 P", thermalManager.bedKp);
|
|
|
|
SERIAL_ECHOPAIR(" I", unscalePID_i(thermalManager.bedKi));
|
|
|
|
SERIAL_ECHOPAIR(" D", unscalePID_d(thermalManager.bedKd));
|
|
|
|
SERIAL_EOL;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif // PIDTEMP || PIDTEMPBED
|
|
|
|
|
|
|
|
#if HAS_LCD_CONTRAST
|
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPGM("LCD Contrast:");
|
2016-10-28 23:55:42 +00:00
|
|
|
}
|
2017-04-17 04:24:30 +00:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPAIR(" M250 C", lcd_contrast);
|
2015-04-27 01:44:01 +00:00
|
|
|
#endif
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
#if ENABLED(FWRETRACT)
|
2012-11-07 22:16:43 +00:00
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPGM("Retract: S<length> F<units/m> Z<lift>");
|
2016-10-28 23:55:42 +00:00
|
|
|
}
|
2017-04-17 04:24:30 +00:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR(" M207 S", LINEAR_UNIT(retract_length));
|
2016-10-28 23:55:42 +00:00
|
|
|
#if EXTRUDERS > 1
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOPAIR(" W", LINEAR_UNIT(retract_length_swap));
|
2016-10-28 23:55:42 +00:00
|
|
|
#endif
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOPAIR(" F", MMS_TO_MMM(LINEAR_UNIT(retract_feedrate_mm_s)));
|
|
|
|
SERIAL_ECHOLNPAIR(" Z", LINEAR_UNIT(retract_zlift));
|
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPGM("Recover: S<length> F<units/m>");
|
2016-10-28 23:55:42 +00:00
|
|
|
}
|
2017-04-17 04:24:30 +00:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR(" M208 S", LINEAR_UNIT(retract_recover_length));
|
2016-10-28 23:55:42 +00:00
|
|
|
#if EXTRUDERS > 1
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOPAIR(" W", LINEAR_UNIT(retract_recover_length_swap));
|
2016-10-28 23:55:42 +00:00
|
|
|
#endif
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPAIR(" F", MMS_TO_MMM(LINEAR_UNIT(retract_recover_feedrate_mm_s)));
|
|
|
|
|
2016-10-28 23:55:42 +00:00
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPGM("Auto-Retract: S=0 to disable, 1 to interpret extrude-only moves as retracts or recoveries");
|
2016-10-28 23:55:42 +00:00
|
|
|
}
|
2015-04-27 01:44:01 +00:00
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPAIR(" M209 S", autoretract_enabled ? 1 : 0);
|
2015-01-28 09:08:48 +00:00
|
|
|
|
2017-04-17 04:24:30 +00:00
|
|
|
#endif // FWRETRACT
|
2016-10-28 23:55:42 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Auto Bed Leveling
|
|
|
|
*/
|
|
|
|
#if HAS_BED_PROBE
|
|
|
|
if (!forReplay) {
|
2017-03-07 05:00:43 +00:00
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPGM("Z-Probe Offset (mm):");
|
2016-10-28 23:55:42 +00:00
|
|
|
}
|
2017-04-17 04:24:30 +00:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPAIR(" M851 Z", LINEAR_UNIT(zprobe_zoffset));
|
2016-10-28 23:55:42 +00:00
|
|
|
#endif
|
2017-03-07 05:00:43 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* TMC2130 stepper driver current
|
|
|
|
*/
|
|
|
|
#if ENABLED(HAVE_TMC2130)
|
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 04:24:30 +00:00
|
|
|
SERIAL_ECHOLNPGM("Stepper driver current:");
|
2017-03-07 05:00:43 +00:00
|
|
|
}
|
2017-04-17 04:24:30 +00:00
|
|
|
CONFIG_ECHO_START;
|
2017-03-07 05:00:43 +00:00
|
|
|
SERIAL_ECHO(" M906");
|
|
|
|
#if ENABLED(X_IS_TMC2130)
|
|
|
|
SERIAL_ECHOPAIR(" X", stepperX.getCurrent());
|
|
|
|
#endif
|
|
|
|
#if ENABLED(Y_IS_TMC2130)
|
|
|
|
SERIAL_ECHOPAIR(" Y", stepperY.getCurrent());
|
|
|
|
#endif
|
|
|
|
#if ENABLED(Z_IS_TMC2130)
|
|
|
|
SERIAL_ECHOPAIR(" Z", stepperZ.getCurrent());
|
|
|
|
#endif
|
|
|
|
#if ENABLED(X2_IS_TMC2130)
|
|
|
|
SERIAL_ECHOPAIR(" X2", stepperX2.getCurrent());
|
|
|
|
#endif
|
|
|
|
#if ENABLED(Y2_IS_TMC2130)
|
|
|
|
SERIAL_ECHOPAIR(" Y2", stepperY2.getCurrent());
|
|
|
|
#endif
|
|
|
|
#if ENABLED(Z2_IS_TMC2130)
|
|
|
|
SERIAL_ECHOPAIR(" Z2", stepperZ2.getCurrent());
|
|
|
|
#endif
|
|
|
|
#if ENABLED(E0_IS_TMC2130)
|
|
|
|
SERIAL_ECHOPAIR(" E0", stepperE0.getCurrent());
|
|
|
|
#endif
|
|
|
|
#if ENABLED(E1_IS_TMC2130)
|
|
|
|
SERIAL_ECHOPAIR(" E1", stepperE1.getCurrent());
|
|
|
|
#endif
|
|
|
|
#if ENABLED(E2_IS_TMC2130)
|
|
|
|
SERIAL_ECHOPAIR(" E2", stepperE2.getCurrent());
|
|
|
|
#endif
|
|
|
|
#if ENABLED(E3_IS_TMC2130)
|
|
|
|
SERIAL_ECHOPAIR(" E3", stepperE3.getCurrent());
|
|
|
|
#endif
|
|
|
|
SERIAL_EOL;
|
|
|
|
#endif
|
2017-04-16 03:18:10 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Linear Advance
|
|
|
|
*/
|
|
|
|
#if ENABLED(LIN_ADVANCE)
|
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPGM("Linear Advance:");
|
|
|
|
}
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 05:27:49 +00:00
|
|
|
SERIAL_ECHOPAIR(" M900 K", planner.get_extruder_advance_k());
|
2017-04-16 03:18:10 +00:00
|
|
|
SERIAL_ECHOLNPAIR(" R", planner.get_advance_ed_ratio());
|
|
|
|
#endif
|
2016-10-28 23:55:42 +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
|