2016-03-25 07:19:46 +01:00
|
|
|
/**
|
2016-03-24 19:01:20 +01: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 07:19:46 +01:00
|
|
|
/**
|
2015-04-26 06:04:54 +02:00
|
|
|
* configuration_store.cpp
|
2015-01-28 10:08:48 +01:00
|
|
|
*
|
2017-04-10 04:47:49 +02:00
|
|
|
* Settings and EEPROM storage
|
2015-01-28 10:08:48 +01:00
|
|
|
*
|
2015-04-04 01:38:05 +02: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-11-09 06:21:02 +01:00
|
|
|
#define EEPROM_VERSION "V45"
|
2015-04-04 01:38:05 +02:00
|
|
|
|
2016-06-30 03:18:46 +02:00
|
|
|
// Change EEPROM version if these are changed:
|
|
|
|
#define EEPROM_OFFSET 100
|
|
|
|
|
2015-04-04 01:38:05 +02:00
|
|
|
/**
|
2017-12-01 05:22:15 +01:00
|
|
|
* V45 EEPROM Layout:
|
2015-01-28 10:08:48 +01:00
|
|
|
*
|
2017-04-06 23:46:52 +02:00
|
|
|
* 100 Version (char x4)
|
2017-05-07 03:00:56 +02:00
|
|
|
* 104 EEPROM CRC16 (uint16_t)
|
2016-02-17 22:05:12 +01:00
|
|
|
*
|
2017-03-31 21:58:40 +02:00
|
|
|
* 106 E_STEPPERS (uint8_t)
|
2017-12-01 05:22:15 +01:00
|
|
|
* 107 M92 XYZE planner.axis_steps_per_mm (float x4 ... x8) + 64
|
|
|
|
* 123 M203 XYZE planner.max_feedrate_mm_s (float x4 ... x8) + 64
|
|
|
|
* 139 M201 XYZE planner.max_acceleration_mm_per_s2 (uint32_t x4 ... x8) + 64
|
2017-04-06 23:46:52 +02:00
|
|
|
* 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 12:45:55 +01:00
|
|
|
* 171 M205 T planner.min_travel_feedrate_mm_s (float)
|
2017-10-14 22:47:53 +02:00
|
|
|
* 175 M205 B planner.min_segment_time_us (ulong)
|
2017-04-06 23:46:52 +02:00
|
|
|
* 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)
|
2017-12-01 05:22:15 +01:00
|
|
|
* 207 M218 XYZ hotend_offset (float x3 per additional hotend) +16
|
2015-01-28 10:08:48 +01:00
|
|
|
*
|
2017-10-13 02:26:06 +02:00
|
|
|
* Global Leveling: 4 bytes
|
2017-02-21 13:49:31 +01:00
|
|
|
* 219 z_fade_height (float)
|
|
|
|
*
|
2017-04-17 01:41:13 +02:00
|
|
|
* MESH_BED_LEVELING: 43 bytes
|
2017-10-13 23:16:32 +02:00
|
|
|
* 223 M420 S planner.leveling_active (bool)
|
2017-02-21 13:49:31 +01:00
|
|
|
* 224 mbl.z_offset (float)
|
|
|
|
* 228 GRID_MAX_POINTS_X (uint8_t)
|
|
|
|
* 229 GRID_MAX_POINTS_Y (uint8_t)
|
2017-04-22 23:04:28 +02:00
|
|
|
* 230 G29 S3 XYZ z_values[][] (float x9, up to float x81) +288
|
2016-03-24 22:16:09 +01:00
|
|
|
*
|
2017-04-17 01:41:13 +02:00
|
|
|
* HAS_BED_PROBE: 4 bytes
|
2017-02-21 13:49:31 +01:00
|
|
|
* 266 M851 zprobe_zoffset (float)
|
2015-03-15 23:18:11 +01:00
|
|
|
*
|
2017-04-17 01:41:13 +02:00
|
|
|
* ABL_PLANAR: 36 bytes
|
2017-02-21 13:49:31 +01:00
|
|
|
* 270 planner.bed_level_matrix (matrix_3x3 = float x9)
|
2016-02-17 22:05:12 +01:00
|
|
|
*
|
2017-10-13 02:26:06 +02:00
|
|
|
* AUTO_BED_LEVELING_BILINEAR: 46 bytes
|
2017-02-21 13:49:31 +01: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)
|
2017-04-22 05:46:19 +02:00
|
|
|
* 316 z_values[][] (float x9, up to float x256) +988
|
2015-01-28 10:08:48 +01:00
|
|
|
*
|
2017-10-27 23:24:34 +02:00
|
|
|
* AUTO_BED_LEVELING_UBL: 2 bytes
|
2017-12-01 05:22:15 +01:00
|
|
|
* 352 G29 A planner.leveling_active (bool)
|
|
|
|
* 353 G29 S ubl.storage_slot (int8_t)
|
2017-04-22 23:04:28 +02:00
|
|
|
*
|
2017-11-09 06:21:02 +01:00
|
|
|
* DELTA: 44 bytes
|
2017-12-01 05:22:15 +01:00
|
|
|
* 354 M666 H delta_height (float)
|
|
|
|
* 358 M666 XYZ delta_endstop_adj (float x3)
|
|
|
|
* 370 M665 R delta_radius (float)
|
|
|
|
* 374 M665 L delta_diagonal_rod (float)
|
|
|
|
* 378 M665 S delta_segments_per_second (float)
|
|
|
|
* 382 M665 B delta_calibration_radius (float)
|
|
|
|
* 386 M665 X delta_tower_angle_trim[A] (float)
|
|
|
|
* 390 M665 Y delta_tower_angle_trim[B] (float)
|
|
|
|
* 394 M665 Z delta_tower_angle_trim[C] (float)
|
2015-01-28 10:08:48 +01:00
|
|
|
*
|
2017-10-27 23:24:34 +02:00
|
|
|
* [XYZ]_DUAL_ENDSTOPS: 12 bytes
|
2017-12-01 05:22:15 +01:00
|
|
|
* 354 M666 X x_endstop_adj (float)
|
|
|
|
* 358 M666 Y y_endstop_adj (float)
|
|
|
|
* 362 M666 Z z_endstop_adj (float)
|
2015-01-28 10:08:48 +01:00
|
|
|
*
|
2017-04-06 23:46:52 +02:00
|
|
|
* ULTIPANEL: 6 bytes
|
2017-12-01 05:22:15 +01:00
|
|
|
* 398 M145 S0 H lcd_preheat_hotend_temp (int x2)
|
|
|
|
* 402 M145 S0 B lcd_preheat_bed_temp (int x2)
|
|
|
|
* 406 M145 S0 F lcd_preheat_fan_speed (int x2)
|
2016-12-10 07:17:49 +01:00
|
|
|
*
|
2017-10-27 23:24:34 +02:00
|
|
|
* PIDTEMP: 82 bytes
|
2017-12-01 05:22:15 +01:00
|
|
|
* 410 M301 E0 PIDC Kp[0], Ki[0], Kd[0], Kc[0] (float x4)
|
|
|
|
* 426 M301 E1 PIDC Kp[1], Ki[1], Kd[1], Kc[1] (float x4)
|
|
|
|
* 442 M301 E2 PIDC Kp[2], Ki[2], Kd[2], Kc[2] (float x4)
|
|
|
|
* 458 M301 E3 PIDC Kp[3], Ki[3], Kd[3], Kc[3] (float x4)
|
|
|
|
* 474 M301 E4 PIDC Kp[3], Ki[3], Kd[3], Kc[3] (float x4)
|
|
|
|
* 490 M301 L lpq_len (int)
|
2015-01-28 10:08:48 +01:00
|
|
|
*
|
2017-03-07 23:35:27 +01:00
|
|
|
* PIDTEMPBED: 12 bytes
|
2017-12-01 05:22:15 +01:00
|
|
|
* 492 M304 PID bedKp, .bedKi, .bedKd (float x3)
|
2015-04-04 01:38:05 +02:00
|
|
|
*
|
2016-12-10 07:17:49 +01:00
|
|
|
* DOGLCD: 2 bytes
|
2017-12-01 05:22:15 +01:00
|
|
|
* 504 M250 C lcd_contrast (uint16_t)
|
2015-01-28 10:08:48 +01:00
|
|
|
*
|
2017-07-18 05:01:41 +02:00
|
|
|
* FWRETRACT: 33 bytes
|
2017-12-01 05:22:15 +01:00
|
|
|
* 506 M209 S autoretract_enabled (bool)
|
|
|
|
* 507 M207 S retract_length (float)
|
|
|
|
* 511 M207 F retract_feedrate_mm_s (float)
|
|
|
|
* 515 M207 Z retract_zlift (float)
|
|
|
|
* 519 M208 S retract_recover_length (float)
|
|
|
|
* 523 M208 F retract_recover_feedrate_mm_s (float)
|
|
|
|
* 527 M207 W swap_retract_length (float)
|
|
|
|
* 531 M208 W swap_retract_recover_length (float)
|
|
|
|
* 535 M208 R swap_retract_recover_feedrate_mm_s (float)
|
2015-01-28 10:08:48 +01:00
|
|
|
*
|
2017-04-06 23:46:52 +02:00
|
|
|
* Volumetric Extrusion: 21 bytes
|
2017-12-01 05:22:15 +01:00
|
|
|
* 539 M200 D parser.volumetric_enabled (bool)
|
|
|
|
* 540 M200 T D planner.filament_size (float x5) (T0..3)
|
2015-01-28 10:08:48 +01:00
|
|
|
*
|
2017-10-27 23:24:34 +02:00
|
|
|
* HAVE_TMC2130: 22 bytes
|
2017-12-01 05:22:15 +01:00
|
|
|
* 560 M906 X Stepper X current (uint16_t)
|
|
|
|
* 562 M906 Y Stepper Y current (uint16_t)
|
|
|
|
* 564 M906 Z Stepper Z current (uint16_t)
|
|
|
|
* 566 M906 X2 Stepper X2 current (uint16_t)
|
|
|
|
* 568 M906 Y2 Stepper Y2 current (uint16_t)
|
|
|
|
* 570 M906 Z2 Stepper Z2 current (uint16_t)
|
|
|
|
* 572 M906 E0 Stepper E0 current (uint16_t)
|
|
|
|
* 574 M906 E1 Stepper E1 current (uint16_t)
|
|
|
|
* 576 M906 E2 Stepper E2 current (uint16_t)
|
|
|
|
* 578 M906 E3 Stepper E3 current (uint16_t)
|
|
|
|
* 580 M906 E4 Stepper E4 current (uint16_t)
|
2017-03-07 06:00:43 +01:00
|
|
|
*
|
2017-04-16 05:18:10 +02:00
|
|
|
* LIN_ADVANCE: 8 bytes
|
2017-12-01 05:22:15 +01:00
|
|
|
* 582 M900 K extruder_advance_k (float)
|
|
|
|
* 586 M900 WHD advance_ed_ratio (float)
|
2017-04-16 05:18:10 +02:00
|
|
|
*
|
2017-06-03 07:38:07 +02:00
|
|
|
* HAS_MOTOR_CURRENT_PWM:
|
2017-12-01 05:22:15 +01:00
|
|
|
* 590 M907 X Stepper XY current (uint32_t)
|
|
|
|
* 594 M907 Z Stepper Z current (uint32_t)
|
|
|
|
* 598 M907 E Stepper E current (uint32_t)
|
2017-06-03 07:38:07 +02:00
|
|
|
*
|
2017-11-01 19:08:46 +01:00
|
|
|
* CNC_COORDINATE_SYSTEMS 108 bytes
|
2017-12-01 05:22:15 +01:00
|
|
|
* 602 G54-G59.3 coordinate_system (float x 27)
|
2017-11-01 19:08:46 +01:00
|
|
|
*
|
2017-12-01 05:22:15 +01:00
|
|
|
* 710 Minimum end-point
|
|
|
|
* 2239 (710 + 208 + 36 + 9 + 288 + 988) Maximum end-point
|
2017-05-07 03:00:56 +02:00
|
|
|
*
|
|
|
|
* ========================================================================
|
|
|
|
* meshes_begin (between max and min end-point, directly above)
|
|
|
|
* -- MESHES --
|
|
|
|
* meshes_end
|
|
|
|
* -- MAT (Mesh Allocation Table) -- 128 bytes (placeholder size)
|
|
|
|
* mat_end = E2END (0xFFF)
|
|
|
|
*
|
2015-01-28 10:08:48 +01:00
|
|
|
*/
|
2017-04-10 04:47:49 +02:00
|
|
|
#include "configuration_store.h"
|
|
|
|
|
|
|
|
MarlinSettings settings;
|
|
|
|
|
2012-11-07 23:16:43 +01:00
|
|
|
#include "Marlin.h"
|
2015-01-29 06:19:51 +01:00
|
|
|
#include "language.h"
|
2016-07-15 01:12:20 +02:00
|
|
|
#include "endstops.h"
|
2012-11-07 23:16:43 +01:00
|
|
|
#include "planner.h"
|
|
|
|
#include "temperature.h"
|
|
|
|
#include "ultralcd.h"
|
2017-06-03 07:38:07 +02:00
|
|
|
#include "stepper.h"
|
2017-11-10 09:38:53 +01:00
|
|
|
#include "gcode.h"
|
2017-05-20 10:03:08 +02:00
|
|
|
|
2015-07-31 07:31:45 +02:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2015-04-28 04:48:34 +02:00
|
|
|
#include "mesh_bed_leveling.h"
|
|
|
|
#endif
|
2015-03-15 23:18:11 +01:00
|
|
|
|
2017-03-07 06:00:43 +01:00
|
|
|
#if ENABLED(HAVE_TMC2130)
|
|
|
|
#include "stepper_indirection.h"
|
|
|
|
#endif
|
|
|
|
|
2017-03-18 16:15:54 +01:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
2017-04-06 02:25:36 +02:00
|
|
|
#include "ubl.h"
|
2017-03-18 16:15:54 +01:00
|
|
|
#endif
|
|
|
|
|
2017-04-22 05:45:02 +02:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
|
|
|
extern void refresh_bed_level();
|
2016-12-10 07:17:49 +01:00
|
|
|
#endif
|
|
|
|
|
2017-10-13 23:16:32 +02:00
|
|
|
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
|
|
|
float new_z_fade_height;
|
|
|
|
#endif
|
|
|
|
|
2017-11-01 19:08:46 +01:00
|
|
|
#if ENABLED(CNC_COORDINATE_SYSTEMS)
|
|
|
|
bool position_changed;
|
|
|
|
#endif
|
|
|
|
|
2015-04-27 03:44:01 +02:00
|
|
|
/**
|
2017-11-16 07:23:21 +01:00
|
|
|
* Post-process after Retrieve or Reset
|
|
|
|
*/
|
2017-04-10 04:47:49 +02:00
|
|
|
void MarlinSettings::postprocess() {
|
2016-06-30 03:19:26 +02:00
|
|
|
// steps per s2 needs to be updated to agree with units per s2
|
|
|
|
planner.reset_acceleration_rates();
|
|
|
|
|
2016-07-24 04:36:26 +02:00
|
|
|
// Make sure delta kinematics are updated before refreshing the
|
|
|
|
// planner position so the stepper counts will be set correctly.
|
2016-06-30 03:19:26 +02:00
|
|
|
#if ENABLED(DELTA)
|
2017-11-08 09:43:29 +01:00
|
|
|
recalc_delta_settings();
|
2016-06-30 03:19:26 +02:00
|
|
|
#endif
|
2012-11-07 23:16:43 +01:00
|
|
|
|
2016-07-24 04:36:26 +02: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 03:19:26 +02:00
|
|
|
#if ENABLED(PIDTEMP)
|
|
|
|
thermalManager.updatePID();
|
|
|
|
#endif
|
2012-11-07 23:16:43 +01:00
|
|
|
|
2017-11-10 09:38:53 +01:00
|
|
|
planner.calculate_volumetric_multipliers();
|
2016-08-19 08:00:46 +02:00
|
|
|
|
2017-04-15 04:41:21 +02:00
|
|
|
#if HAS_HOME_OFFSET || ENABLED(DUAL_X_CARRIAGE)
|
2017-03-05 01:01:33 +01:00
|
|
|
// Software endstops depend on home_offset
|
|
|
|
LOOP_XYZ(i) update_software_endstops((AxisEnum)i);
|
|
|
|
#endif
|
2017-02-21 13:49:31 +01:00
|
|
|
|
|
|
|
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
2017-10-13 23:16:32 +02:00
|
|
|
set_z_fade_height(new_z_fade_height);
|
2017-02-21 13:49:31 +01:00
|
|
|
#endif
|
2017-04-11 12:05:23 +02:00
|
|
|
|
2017-04-22 05:45:02 +02:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
|
|
|
refresh_bed_level();
|
|
|
|
//set_bed_leveling_enabled(leveling_is_on);
|
|
|
|
#endif
|
2017-06-03 07:38:07 +02:00
|
|
|
|
|
|
|
#if HAS_MOTOR_CURRENT_PWM
|
|
|
|
stepper.refresh_motor_power();
|
|
|
|
#endif
|
2017-11-01 19:08:46 +01:00
|
|
|
|
|
|
|
#if ENABLED(CNC_COORDINATE_SYSTEMS)
|
|
|
|
if (position_changed) {
|
|
|
|
report_current_position();
|
|
|
|
position_changed = false;
|
|
|
|
}
|
|
|
|
#endif
|
2016-06-30 03:19:26 +02:00
|
|
|
}
|
2012-11-07 23:16:43 +01:00
|
|
|
|
2015-07-31 07:31:45 +02:00
|
|
|
#if ENABLED(EEPROM_SETTINGS)
|
2015-01-28 10:08:48 +01:00
|
|
|
|
2017-05-07 03:00:56 +02:00
|
|
|
#define DUMMY_PID_VALUE 3000.0f
|
|
|
|
#define EEPROM_START() int eeprom_index = EEPROM_OFFSET
|
|
|
|
#define EEPROM_SKIP(VAR) eeprom_index += sizeof(VAR)
|
|
|
|
#define EEPROM_WRITE(VAR) write_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR), &working_crc)
|
|
|
|
#define EEPROM_READ(VAR) read_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR), &working_crc)
|
2017-06-09 17:51:23 +02:00
|
|
|
#define EEPROM_ASSERT(TST,ERR) if (!(TST)) do{ SERIAL_ERROR_START(); SERIAL_ERRORLNPGM(ERR); eeprom_read_error = true; }while(0)
|
2017-05-07 03:00:56 +02:00
|
|
|
|
2016-12-09 13:13:44 +01:00
|
|
|
const char version[4] = EEPROM_VERSION;
|
|
|
|
|
2017-05-07 03:00:56 +02:00
|
|
|
bool MarlinSettings::eeprom_error;
|
2017-04-10 04:47:49 +02:00
|
|
|
|
2017-05-07 03:00:56 +02:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
|
|
|
int MarlinSettings::meshes_begin;
|
|
|
|
#endif
|
2016-12-09 13:13:44 +01:00
|
|
|
|
2017-05-07 03:00:56 +02:00
|
|
|
void MarlinSettings::write_data(int &pos, const uint8_t *value, uint16_t size, uint16_t *crc) {
|
|
|
|
if (eeprom_error) return;
|
2016-12-09 13:13:44 +01:00
|
|
|
while (size--) {
|
|
|
|
uint8_t * const p = (uint8_t * const)pos;
|
2017-05-07 03:00:56 +02:00
|
|
|
uint8_t v = *value;
|
2016-12-09 13:13:44 +01:00
|
|
|
// 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) {
|
2017-06-09 17:51:23 +02:00
|
|
|
SERIAL_ECHO_START();
|
2016-12-09 13:13:44 +01:00
|
|
|
SERIAL_ECHOLNPGM(MSG_ERR_EEPROM_WRITE);
|
2017-05-07 03:00:56 +02:00
|
|
|
eeprom_error = true;
|
2016-12-09 13:13:44 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2017-05-07 03:00:56 +02:00
|
|
|
crc16(crc, &v, 1);
|
2016-12-09 13:13:44 +01:00
|
|
|
pos++;
|
|
|
|
value++;
|
|
|
|
};
|
|
|
|
}
|
2017-05-07 03:00:56 +02:00
|
|
|
|
|
|
|
void MarlinSettings::read_data(int &pos, uint8_t* value, uint16_t size, uint16_t *crc) {
|
|
|
|
if (eeprom_error) return;
|
2016-12-09 13:13:44 +01:00
|
|
|
do {
|
|
|
|
uint8_t c = eeprom_read_byte((unsigned char*)pos);
|
2017-05-07 03:00:56 +02:00
|
|
|
*value = c;
|
|
|
|
crc16(crc, &c, 1);
|
2016-12-09 13:13:44 +01:00
|
|
|
pos++;
|
|
|
|
value++;
|
|
|
|
} while (--size);
|
|
|
|
}
|
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
/**
|
|
|
|
* M500 - Store Configuration
|
|
|
|
*/
|
2017-04-10 04:47:49 +02:00
|
|
|
bool MarlinSettings::save() {
|
2016-10-29 01:55:42 +02:00
|
|
|
float dummy = 0.0f;
|
|
|
|
char ver[4] = "000";
|
2015-01-28 10:08:48 +01:00
|
|
|
|
2017-05-07 03:00:56 +02:00
|
|
|
uint16_t working_crc = 0;
|
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
EEPROM_START();
|
2015-01-28 10:08:48 +01:00
|
|
|
|
2017-05-07 03:00:56 +02:00
|
|
|
eeprom_error = false;
|
2016-12-09 12:45:04 +01:00
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
EEPROM_WRITE(ver); // invalidate data first
|
2017-05-07 03:00:56 +02:00
|
|
|
EEPROM_SKIP(working_crc); // Skip the checksum slot
|
2016-06-30 03:12:23 +02:00
|
|
|
|
2017-05-07 03:00:56 +02:00
|
|
|
working_crc = 0; // clear before first "real data"
|
2016-07-24 19:19:49 +02:00
|
|
|
|
2016-12-16 06:15:12 +01:00
|
|
|
const uint8_t esteppers = COUNT(planner.axis_steps_per_mm) - XYZ;
|
2016-12-09 12:45:55 +01:00
|
|
|
EEPROM_WRITE(esteppers);
|
2016-12-14 14:13:25 +01:00
|
|
|
|
2016-10-29 01:55:42 +02: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 12:45:55 +01:00
|
|
|
|
2016-10-29 01:55:42 +02: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);
|
2017-10-14 22:47:53 +02:00
|
|
|
EEPROM_WRITE(planner.min_segment_time_us);
|
2016-10-29 01:55:42 +02:00
|
|
|
EEPROM_WRITE(planner.max_jerk);
|
2017-04-15 04:41:21 +02:00
|
|
|
#if !HAS_HOME_OFFSET
|
2017-03-31 21:58:40 +02:00
|
|
|
const float home_offset[XYZ] = { 0 };
|
|
|
|
#endif
|
2017-11-09 06:21:02 +01:00
|
|
|
EEPROM_WRITE(home_offset);
|
2015-01-28 10:08:48 +01:00
|
|
|
|
2016-10-29 01:39:23 +02:00
|
|
|
#if HOTENDS > 1
|
|
|
|
// Skip hotend 0 which must be 0
|
|
|
|
for (uint8_t e = 1; e < HOTENDS; e++)
|
2016-10-29 01:55:42 +02:00
|
|
|
LOOP_XYZ(i) EEPROM_WRITE(hotend_offset[i][e]);
|
2016-10-29 01:39:23 +02:00
|
|
|
#endif
|
|
|
|
|
2017-02-21 13:49:31 +01:00
|
|
|
//
|
2017-04-22 23:04:28 +02:00
|
|
|
// Global Leveling
|
2017-02-21 13:49:31 +01:00
|
|
|
//
|
|
|
|
|
|
|
|
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
2017-04-22 23:04:28 +02:00
|
|
|
const float zfh = planner.z_fade_height;
|
2017-02-21 13:49:31 +01:00
|
|
|
#else
|
2017-04-22 23:04:28 +02:00
|
|
|
const float zfh = 10.0;
|
2017-02-21 13:49:31 +01:00
|
|
|
#endif
|
2017-04-22 23:04:28 +02:00
|
|
|
EEPROM_WRITE(zfh);
|
2017-02-21 13:49:31 +01:00
|
|
|
|
2016-12-10 07:17:49 +01:00
|
|
|
//
|
|
|
|
// Mesh Bed Leveling
|
|
|
|
//
|
|
|
|
|
2015-07-31 07:31:45 +02:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2016-10-29 01:55:42 +02:00
|
|
|
// Compile time test that sizeof(mbl.z_values) is as expected
|
2017-04-18 22:26:27 +02:00
|
|
|
static_assert(
|
2017-05-12 06:22:35 +02:00
|
|
|
sizeof(mbl.z_values) == GRID_MAX_POINTS * sizeof(mbl.z_values[0][0]),
|
2017-04-18 22:26:27 +02:00
|
|
|
"MBL Z array is the wrong size."
|
|
|
|
);
|
2017-10-13 23:16:32 +02:00
|
|
|
const bool leveling_is_on = mbl.has_mesh;
|
2017-04-06 05:29:44 +02:00
|
|
|
const uint8_t mesh_num_x = GRID_MAX_POINTS_X, mesh_num_y = GRID_MAX_POINTS_Y;
|
2016-12-14 08:44:39 +01:00
|
|
|
EEPROM_WRITE(leveling_is_on);
|
2016-10-29 01:55:42 +02:00
|
|
|
EEPROM_WRITE(mbl.z_offset);
|
|
|
|
EEPROM_WRITE(mesh_num_x);
|
|
|
|
EEPROM_WRITE(mesh_num_y);
|
|
|
|
EEPROM_WRITE(mbl.z_values);
|
2017-04-22 23:04:28 +02:00
|
|
|
#else // For disabled MBL write a default mesh
|
2016-12-14 08:44:39 +01:00
|
|
|
const bool leveling_is_on = false;
|
2016-10-29 01:55:42 +02:00
|
|
|
dummy = 0.0f;
|
2016-12-14 08:44:39 +01:00
|
|
|
const uint8_t mesh_num_x = 3, mesh_num_y = 3;
|
|
|
|
EEPROM_WRITE(leveling_is_on);
|
2016-12-10 07:17:49 +01:00
|
|
|
EEPROM_WRITE(dummy); // z_offset
|
2016-10-29 01:55:42 +02:00
|
|
|
EEPROM_WRITE(mesh_num_x);
|
|
|
|
EEPROM_WRITE(mesh_num_y);
|
2016-12-10 07:17:49 +01:00
|
|
|
for (uint8_t q = mesh_num_x * mesh_num_y; q--;) EEPROM_WRITE(dummy);
|
2015-04-27 06:06:04 +02:00
|
|
|
#endif // MESH_BED_LEVELING
|
2015-03-15 23:18:11 +01:00
|
|
|
|
2016-06-15 03:05:20 +02:00
|
|
|
#if !HAS_BED_PROBE
|
2017-04-11 12:05:23 +02:00
|
|
|
const float zprobe_zoffset = 0;
|
2015-03-26 05:14:00 +01:00
|
|
|
#endif
|
2016-10-29 01:55:42 +02:00
|
|
|
EEPROM_WRITE(zprobe_zoffset);
|
2015-03-26 05:14:00 +01:00
|
|
|
|
2016-12-14 08:50:06 +01: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 07:17:49 +01:00
|
|
|
//
|
|
|
|
// Bilinear Auto Bed Leveling
|
|
|
|
//
|
|
|
|
|
|
|
|
#if ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
2017-04-22 05:46:19 +02:00
|
|
|
// Compile time test that sizeof(z_values) is as expected
|
2017-04-18 22:26:27 +02:00
|
|
|
static_assert(
|
2017-05-12 06:22:35 +02:00
|
|
|
sizeof(z_values) == GRID_MAX_POINTS * sizeof(z_values[0][0]),
|
2017-04-18 22:26:27 +02:00
|
|
|
"Bilinear Z array is the wrong size."
|
|
|
|
);
|
2017-04-06 05:29:44 +02:00
|
|
|
const uint8_t grid_max_x = GRID_MAX_POINTS_X, grid_max_y = GRID_MAX_POINTS_Y;
|
2016-12-10 07:17:49 +01: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
|
2017-04-22 05:46:19 +02:00
|
|
|
EEPROM_WRITE(z_values); // 9-256 floats
|
2016-12-10 07:17:49 +01:00
|
|
|
#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
|
|
|
|
|
2017-04-22 23:04:28 +02:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
2017-10-13 23:16:32 +02:00
|
|
|
EEPROM_WRITE(planner.leveling_active);
|
2017-10-14 04:58:45 +02:00
|
|
|
EEPROM_WRITE(ubl.storage_slot);
|
2017-04-22 23:04:28 +02:00
|
|
|
#else
|
2017-05-16 09:34:36 +02:00
|
|
|
const bool ubl_active = false;
|
2017-05-07 03:00:56 +02:00
|
|
|
const int8_t storage_slot = -1;
|
2017-04-22 23:04:28 +02:00
|
|
|
EEPROM_WRITE(ubl_active);
|
2017-05-07 03:00:56 +02:00
|
|
|
EEPROM_WRITE(storage_slot);
|
2017-05-09 19:35:43 +02:00
|
|
|
#endif // AUTO_BED_LEVELING_UBL
|
2017-04-22 23:04:28 +02:00
|
|
|
|
2017-12-01 05:22:15 +01:00
|
|
|
// 11 floats for DELTA / [XYZ]_DUAL_ENDSTOPS
|
2015-07-31 07:31:45 +02:00
|
|
|
#if ENABLED(DELTA)
|
2017-11-09 06:21:02 +01:00
|
|
|
EEPROM_WRITE(delta_height); // 1 float
|
2017-10-27 06:49:20 +02:00
|
|
|
EEPROM_WRITE(delta_endstop_adj); // 3 floats
|
2016-10-29 01:55:42 +02:00
|
|
|
EEPROM_WRITE(delta_radius); // 1 float
|
|
|
|
EEPROM_WRITE(delta_diagonal_rod); // 1 float
|
|
|
|
EEPROM_WRITE(delta_segments_per_second); // 1 float
|
2017-04-29 16:36:33 +02:00
|
|
|
EEPROM_WRITE(delta_calibration_radius); // 1 float
|
2017-09-24 08:45:31 +02:00
|
|
|
EEPROM_WRITE(delta_tower_angle_trim); // 3 floats
|
2017-10-27 23:24:34 +02:00
|
|
|
|
|
|
|
#elif ENABLED(X_DUAL_ENDSTOPS) || ENABLED(Y_DUAL_ENDSTOPS) || ENABLED(Z_DUAL_ENDSTOPS)
|
|
|
|
// Write dual endstops in X, Y, Z order. Unused = 0.0
|
2017-04-29 16:36:33 +02:00
|
|
|
dummy = 0.0f;
|
2017-10-27 23:24:34 +02:00
|
|
|
#if ENABLED(X_DUAL_ENDSTOPS)
|
|
|
|
EEPROM_WRITE(x_endstop_adj); // 1 float
|
|
|
|
#else
|
|
|
|
EEPROM_WRITE(dummy);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(Y_DUAL_ENDSTOPS)
|
|
|
|
EEPROM_WRITE(y_endstop_adj); // 1 float
|
|
|
|
#else
|
|
|
|
EEPROM_WRITE(dummy);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(Z_DUAL_ENDSTOPS)
|
|
|
|
EEPROM_WRITE(z_endstop_adj); // 1 float
|
|
|
|
#else
|
|
|
|
EEPROM_WRITE(dummy);
|
|
|
|
#endif
|
|
|
|
|
2017-12-01 05:22:15 +01:00
|
|
|
for (uint8_t q = 8; q--;) EEPROM_WRITE(dummy);
|
2017-10-27 23:24:34 +02:00
|
|
|
|
2015-01-28 10:08:48 +01:00
|
|
|
#else
|
2015-03-24 18:06:44 +01:00
|
|
|
dummy = 0.0f;
|
2017-12-01 05:22:15 +01:00
|
|
|
for (uint8_t q = 11; q--;) EEPROM_WRITE(dummy);
|
2015-01-28 10:08:48 +01:00
|
|
|
#endif
|
|
|
|
|
2015-07-31 07:31:45 +02:00
|
|
|
#if DISABLED(ULTIPANEL)
|
2017-06-06 00:41:38 +02:00
|
|
|
constexpr 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 };
|
|
|
|
#endif
|
2016-10-29 01:55:42 +02:00
|
|
|
|
2016-10-27 09:40:37 +02:00
|
|
|
EEPROM_WRITE(lcd_preheat_hotend_temp);
|
|
|
|
EEPROM_WRITE(lcd_preheat_bed_temp);
|
|
|
|
EEPROM_WRITE(lcd_preheat_fan_speed);
|
2016-10-29 01:55:42 +02: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 02:49:34 +02:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2016-10-29 01:55:42 +02:00
|
|
|
EEPROM_WRITE(PID_PARAM(Kc, e));
|
2015-01-28 10:08:48 +01:00
|
|
|
#else
|
2016-10-29 01:55:42 +02:00
|
|
|
dummy = 1.0f; // 1.0 = default kc
|
|
|
|
EEPROM_WRITE(dummy);
|
2015-01-28 10:08:48 +01:00
|
|
|
#endif
|
|
|
|
}
|
2016-10-29 01:55:42 +02: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 10:08:48 +01:00
|
|
|
}
|
2016-10-29 01:55:42 +02:00
|
|
|
|
|
|
|
} // Hotends Loop
|
2015-01-28 10:08:48 +01:00
|
|
|
|
2016-08-01 02:49:34 +02:00
|
|
|
#if DISABLED(PID_EXTRUSION_SCALING)
|
2016-10-29 01:55:42 +02:00
|
|
|
int lpq_len = 20;
|
2015-08-31 04:04:30 +02:00
|
|
|
#endif
|
2016-10-29 01:55:42 +02:00
|
|
|
EEPROM_WRITE(lpq_len);
|
|
|
|
|
|
|
|
#if DISABLED(PIDTEMPBED)
|
|
|
|
dummy = DUMMY_PID_VALUE;
|
|
|
|
for (uint8_t q = 3; q--;) EEPROM_WRITE(dummy);
|
2016-04-29 03:18:13 +02:00
|
|
|
#else
|
2016-10-29 01:55:42 +02:00
|
|
|
EEPROM_WRITE(thermalManager.bedKp);
|
|
|
|
EEPROM_WRITE(thermalManager.bedKi);
|
|
|
|
EEPROM_WRITE(thermalManager.bedKd);
|
2015-04-04 01:38:05 +02:00
|
|
|
#endif
|
|
|
|
|
2016-05-31 20:47:02 +02:00
|
|
|
#if !HAS_LCD_CONTRAST
|
2017-05-21 02:54:23 +02:00
|
|
|
const uint16_t lcd_contrast = 32;
|
2015-01-28 10:08:48 +01:00
|
|
|
#endif
|
2016-10-29 01:55:42 +02:00
|
|
|
EEPROM_WRITE(lcd_contrast);
|
2015-01-28 10:08:48 +01:00
|
|
|
|
2017-07-18 05:01:41 +02:00
|
|
|
#if DISABLED(FWRETRACT)
|
|
|
|
const bool autoretract_enabled = false;
|
|
|
|
const float retract_length = 3,
|
|
|
|
retract_feedrate_mm_s = 45,
|
|
|
|
retract_zlift = 0,
|
|
|
|
retract_recover_length = 0,
|
|
|
|
retract_recover_feedrate_mm_s = 0,
|
2017-07-27 05:11:22 +02:00
|
|
|
swap_retract_length = 13,
|
|
|
|
swap_retract_recover_length = 0,
|
2017-07-18 05:01:41 +02:00
|
|
|
swap_retract_recover_feedrate_mm_s = 8;
|
|
|
|
#endif
|
|
|
|
EEPROM_WRITE(autoretract_enabled);
|
|
|
|
EEPROM_WRITE(retract_length);
|
|
|
|
EEPROM_WRITE(retract_feedrate_mm_s);
|
|
|
|
EEPROM_WRITE(retract_zlift);
|
|
|
|
EEPROM_WRITE(retract_recover_length);
|
|
|
|
EEPROM_WRITE(retract_recover_feedrate_mm_s);
|
2017-07-27 05:11:22 +02:00
|
|
|
EEPROM_WRITE(swap_retract_length);
|
|
|
|
EEPROM_WRITE(swap_retract_recover_length);
|
2017-07-18 05:01:41 +02:00
|
|
|
EEPROM_WRITE(swap_retract_recover_feedrate_mm_s);
|
2015-01-28 10:08:48 +01:00
|
|
|
|
2017-11-10 09:38:53 +01:00
|
|
|
EEPROM_WRITE(parser.volumetric_enabled);
|
2015-01-28 10:08:48 +01:00
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
// Save filament sizes
|
2016-06-30 09:07:31 +02:00
|
|
|
for (uint8_t q = 0; q < MAX_EXTRUDERS; q++) {
|
2017-11-10 09:38:53 +01:00
|
|
|
if (q < COUNT(planner.filament_size)) dummy = planner.filament_size[q];
|
2016-10-29 01:55:42 +02:00
|
|
|
EEPROM_WRITE(dummy);
|
2015-01-28 10:08:48 +01:00
|
|
|
}
|
|
|
|
|
2017-03-31 21:58:40 +02:00
|
|
|
// Save TMC2130 Configuration, and placeholder values
|
2017-03-07 06:00:43 +01: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 21:58:40 +02:00
|
|
|
#if ENABLED(E4_IS_TMC2130)
|
|
|
|
val = stepperE4.getCurrent();
|
|
|
|
#else
|
|
|
|
val = 0;
|
|
|
|
#endif
|
|
|
|
EEPROM_WRITE(val);
|
2017-03-07 06:00:43 +01:00
|
|
|
#else
|
|
|
|
val = 0;
|
2017-07-18 05:01:41 +02:00
|
|
|
for (uint8_t q = 11; q--;) EEPROM_WRITE(val);
|
2017-03-07 06:00:43 +01:00
|
|
|
#endif
|
|
|
|
|
2017-04-16 05:18:10 +02:00
|
|
|
//
|
|
|
|
// Linear Advance
|
|
|
|
//
|
|
|
|
|
|
|
|
#if ENABLED(LIN_ADVANCE)
|
2017-04-22 05:30:36 +02:00
|
|
|
EEPROM_WRITE(planner.extruder_advance_k);
|
|
|
|
EEPROM_WRITE(planner.advance_ed_ratio);
|
|
|
|
#else
|
|
|
|
dummy = 0.0f;
|
|
|
|
EEPROM_WRITE(dummy);
|
|
|
|
EEPROM_WRITE(dummy);
|
2017-04-16 05:18:10 +02:00
|
|
|
#endif
|
|
|
|
|
2017-06-03 07:38:07 +02:00
|
|
|
#if HAS_MOTOR_CURRENT_PWM
|
|
|
|
for (uint8_t q = 3; q--;) EEPROM_WRITE(stepper.motor_current_setting[q]);
|
|
|
|
#else
|
|
|
|
const uint32_t dummyui32 = 0;
|
|
|
|
for (uint8_t q = 3; q--;) EEPROM_WRITE(dummyui32);
|
|
|
|
#endif
|
|
|
|
|
2017-11-01 19:08:46 +01:00
|
|
|
#if ENABLED(CNC_COORDINATE_SYSTEMS)
|
|
|
|
EEPROM_WRITE(coordinate_system); // 27 floats
|
|
|
|
#else
|
|
|
|
dummy = 0.0f;
|
|
|
|
for (uint8_t q = 27; q--;) EEPROM_WRITE(dummy);
|
|
|
|
#endif
|
|
|
|
|
2017-05-07 03:00:56 +02:00
|
|
|
if (!eeprom_error) {
|
|
|
|
const int eeprom_size = eeprom_index;
|
2016-10-29 01:55:42 +02:00
|
|
|
|
2017-05-17 23:16:38 +02:00
|
|
|
const uint16_t final_crc = working_crc;
|
2017-05-11 16:48:16 +02:00
|
|
|
|
2016-12-14 08:48:42 +01:00
|
|
|
// Write the EEPROM header
|
|
|
|
eeprom_index = EEPROM_OFFSET;
|
2017-05-11 16:48:16 +02:00
|
|
|
|
2016-12-14 08:48:42 +01:00
|
|
|
EEPROM_WRITE(version);
|
2017-05-17 23:16:38 +02:00
|
|
|
EEPROM_WRITE(final_crc);
|
2016-10-29 01:55:42 +02:00
|
|
|
|
2016-12-14 08:48:42 +01:00
|
|
|
// Report storage size
|
2017-07-02 04:48:18 +02:00
|
|
|
#if ENABLED(EEPROM_CHITCHAT)
|
|
|
|
SERIAL_ECHO_START();
|
|
|
|
SERIAL_ECHOPAIR("Settings Stored (", eeprom_size - (EEPROM_OFFSET));
|
2017-08-21 23:30:08 +02:00
|
|
|
SERIAL_ECHOPAIR(" bytes; crc ", (uint32_t)final_crc);
|
2017-07-02 04:48:18 +02:00
|
|
|
SERIAL_ECHOLNPGM(")");
|
|
|
|
#endif
|
2016-12-14 08:48:42 +01:00
|
|
|
}
|
2017-03-20 12:10:31 +01:00
|
|
|
|
2017-04-22 23:04:28 +02:00
|
|
|
#if ENABLED(UBL_SAVE_ACTIVE_ON_M500)
|
2017-10-14 04:58:45 +02:00
|
|
|
if (ubl.storage_slot >= 0)
|
|
|
|
store_mesh(ubl.storage_slot);
|
2017-03-18 16:15:54 +01:00
|
|
|
#endif
|
2017-03-20 12:10:31 +01:00
|
|
|
|
2017-05-07 03:00:56 +02:00
|
|
|
return !eeprom_error;
|
2016-10-29 01:55:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M501 - Retrieve Configuration
|
|
|
|
*/
|
2017-04-10 04:47:49 +02:00
|
|
|
bool MarlinSettings::load() {
|
2017-05-07 03:00:56 +02:00
|
|
|
uint16_t working_crc = 0;
|
2016-10-29 01:55:42 +02:00
|
|
|
|
|
|
|
EEPROM_START();
|
|
|
|
|
|
|
|
char stored_ver[4];
|
|
|
|
EEPROM_READ(stored_ver);
|
|
|
|
|
2017-05-07 03:00:56 +02:00
|
|
|
uint16_t stored_crc;
|
|
|
|
EEPROM_READ(stored_crc);
|
2016-10-29 01:55:42 +02:00
|
|
|
|
2016-12-09 12:45:55 +01:00
|
|
|
// Version has to match or defaults are used
|
2016-10-29 01:55:42 +02:00
|
|
|
if (strncmp(version, stored_ver, 3) != 0) {
|
2017-03-04 08:20:36 +01:00
|
|
|
if (stored_ver[0] != 'V') {
|
|
|
|
stored_ver[0] = '?';
|
|
|
|
stored_ver[1] = '\0';
|
|
|
|
}
|
2017-07-02 04:48:18 +02:00
|
|
|
#if ENABLED(EEPROM_CHITCHAT)
|
|
|
|
SERIAL_ECHO_START();
|
|
|
|
SERIAL_ECHOPGM("EEPROM version mismatch ");
|
|
|
|
SERIAL_ECHOPAIR("(EEPROM=", stored_ver);
|
|
|
|
SERIAL_ECHOLNPGM(" Marlin=" EEPROM_VERSION ")");
|
|
|
|
#endif
|
2017-04-10 04:47:49 +02:00
|
|
|
reset();
|
2016-06-30 03:12:23 +02:00
|
|
|
}
|
2016-10-29 01:55:42 +02:00
|
|
|
else {
|
|
|
|
float dummy = 0;
|
2017-07-18 05:01:41 +02:00
|
|
|
bool dummyb;
|
2015-01-28 10:08:48 +01:00
|
|
|
|
2017-11-01 20:51:57 +01:00
|
|
|
working_crc = 0; // Init to 0. Accumulated by EEPROM_READ
|
2016-10-29 01:55:42 +02:00
|
|
|
|
2016-12-09 12:45:55 +01:00
|
|
|
// Number of esteppers may change
|
|
|
|
uint8_t esteppers;
|
|
|
|
EEPROM_READ(esteppers);
|
|
|
|
|
2017-11-01 20:51:57 +01:00
|
|
|
//
|
|
|
|
// Planner Motion
|
|
|
|
//
|
|
|
|
|
2016-12-09 12:45:55 +01:00
|
|
|
// 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 05:04:18 +01:00
|
|
|
const uint32_t def3[] = DEFAULT_MAX_ACCELERATION;
|
2016-12-09 12:45:55 +01:00
|
|
|
float tmp1[XYZ + esteppers], tmp2[XYZ + esteppers];
|
2016-12-16 05:04:18 +01:00
|
|
|
uint32_t tmp3[XYZ + esteppers];
|
2016-12-09 12:45:55 +01: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-29 01:55:42 +02: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);
|
2017-10-14 22:47:53 +02:00
|
|
|
EEPROM_READ(planner.min_segment_time_us);
|
2016-10-29 01:55:42 +02:00
|
|
|
EEPROM_READ(planner.max_jerk);
|
2017-03-05 01:01:33 +01:00
|
|
|
|
2017-11-01 20:51:57 +01:00
|
|
|
//
|
|
|
|
// Home Offset (M206)
|
|
|
|
//
|
|
|
|
|
2017-04-15 04:41:21 +02:00
|
|
|
#if !HAS_HOME_OFFSET
|
2017-03-05 01:01:33 +01:00
|
|
|
float home_offset[XYZ];
|
|
|
|
#endif
|
2016-10-29 01:55:42 +02:00
|
|
|
EEPROM_READ(home_offset);
|
|
|
|
|
2017-11-01 20:51:57 +01:00
|
|
|
//
|
|
|
|
// Hotend Offsets, if any
|
|
|
|
//
|
|
|
|
|
2016-10-29 01:55:42 +02: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 13:49:31 +01:00
|
|
|
//
|
2017-04-22 23:04:28 +02:00
|
|
|
// Global Leveling
|
2017-02-21 13:49:31 +01:00
|
|
|
//
|
|
|
|
|
|
|
|
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
2017-10-13 23:16:32 +02:00
|
|
|
EEPROM_READ(new_z_fade_height);
|
2017-02-21 13:49:31 +01:00
|
|
|
#else
|
|
|
|
EEPROM_READ(dummy);
|
|
|
|
#endif
|
|
|
|
|
2016-12-10 07:17:49 +01:00
|
|
|
//
|
|
|
|
// Mesh (Manual) Bed Leveling
|
|
|
|
//
|
|
|
|
|
2016-12-14 08:44:39 +01:00
|
|
|
bool leveling_is_on;
|
|
|
|
uint8_t mesh_num_x, mesh_num_y;
|
|
|
|
EEPROM_READ(leveling_is_on);
|
2016-10-29 01:55:42 +02:00
|
|
|
EEPROM_READ(dummy);
|
|
|
|
EEPROM_READ(mesh_num_x);
|
|
|
|
EEPROM_READ(mesh_num_y);
|
2016-12-14 08:44:39 +01:00
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2017-10-13 23:16:32 +02:00
|
|
|
mbl.has_mesh = leveling_is_on;
|
2016-10-29 01:55:42 +02:00
|
|
|
mbl.z_offset = dummy;
|
2017-04-06 05:29:44 +02:00
|
|
|
if (mesh_num_x == GRID_MAX_POINTS_X && mesh_num_y == GRID_MAX_POINTS_Y) {
|
2016-10-29 01:55:42 +02:00
|
|
|
// EEPROM data fits the current mesh
|
|
|
|
EEPROM_READ(mbl.z_values);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// EEPROM data is stale
|
|
|
|
mbl.reset();
|
2016-12-10 07:17:49 +01:00
|
|
|
for (uint16_t q = mesh_num_x * mesh_num_y; q--;) EEPROM_READ(dummy);
|
2016-10-29 01:55:42 +02:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
// MBL is disabled - skip the stored data
|
2016-12-10 07:17:49 +01:00
|
|
|
for (uint16_t q = mesh_num_x * mesh_num_y; q--;) EEPROM_READ(dummy);
|
2016-10-29 01:55:42 +02:00
|
|
|
#endif // MESH_BED_LEVELING
|
|
|
|
|
|
|
|
#if !HAS_BED_PROBE
|
2017-04-11 12:05:23 +02:00
|
|
|
float zprobe_zoffset;
|
2016-10-29 01:55:42 +02:00
|
|
|
#endif
|
|
|
|
EEPROM_READ(zprobe_zoffset);
|
|
|
|
|
2016-12-14 08:50:06 +01: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 07:17:49 +01: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 05:29:44 +02:00
|
|
|
if (grid_max_x == GRID_MAX_POINTS_X && grid_max_y == GRID_MAX_POINTS_Y) {
|
2016-12-10 07:17:49 +01:00
|
|
|
set_bed_leveling_enabled(false);
|
|
|
|
EEPROM_READ(bilinear_grid_spacing); // 2 ints
|
|
|
|
EEPROM_READ(bilinear_start); // 2 ints
|
2017-04-22 05:46:19 +02:00
|
|
|
EEPROM_READ(z_values); // 9 to 256 floats
|
2016-12-10 07:17:49 +01: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);
|
|
|
|
}
|
|
|
|
|
2017-11-01 20:51:57 +01:00
|
|
|
//
|
|
|
|
// Unified Bed Leveling active state
|
|
|
|
//
|
|
|
|
|
2017-04-22 23:04:28 +02:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
2017-10-13 23:16:32 +02:00
|
|
|
EEPROM_READ(planner.leveling_active);
|
2017-10-14 04:58:45 +02:00
|
|
|
EEPROM_READ(ubl.storage_slot);
|
2017-04-22 23:04:28 +02:00
|
|
|
#else
|
|
|
|
uint8_t dummyui8;
|
|
|
|
EEPROM_READ(dummyb);
|
|
|
|
EEPROM_READ(dummyui8);
|
2017-05-09 19:35:43 +02:00
|
|
|
#endif // AUTO_BED_LEVELING_UBL
|
2017-04-22 23:04:28 +02:00
|
|
|
|
2017-11-01 20:51:57 +01:00
|
|
|
//
|
|
|
|
// DELTA Geometry or Dual Endstops offsets
|
|
|
|
//
|
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
#if ENABLED(DELTA)
|
2017-11-09 06:21:02 +01:00
|
|
|
EEPROM_READ(delta_height); // 1 float
|
2017-10-27 06:49:20 +02:00
|
|
|
EEPROM_READ(delta_endstop_adj); // 3 floats
|
2017-03-08 00:42:04 +01:00
|
|
|
EEPROM_READ(delta_radius); // 1 float
|
|
|
|
EEPROM_READ(delta_diagonal_rod); // 1 float
|
|
|
|
EEPROM_READ(delta_segments_per_second); // 1 float
|
2017-04-29 16:36:33 +02:00
|
|
|
EEPROM_READ(delta_calibration_radius); // 1 float
|
2017-09-24 08:45:31 +02:00
|
|
|
EEPROM_READ(delta_tower_angle_trim); // 3 floats
|
2017-10-27 23:24:34 +02:00
|
|
|
|
|
|
|
#elif ENABLED(X_DUAL_ENDSTOPS) || ENABLED(Y_DUAL_ENDSTOPS) || ENABLED(Z_DUAL_ENDSTOPS)
|
|
|
|
|
|
|
|
#if ENABLED(X_DUAL_ENDSTOPS)
|
|
|
|
EEPROM_READ(x_endstop_adj); // 1 float
|
|
|
|
#else
|
|
|
|
EEPROM_READ(dummy);
|
|
|
|
#endif
|
|
|
|
#if ENABLED(Y_DUAL_ENDSTOPS)
|
|
|
|
EEPROM_READ(y_endstop_adj); // 1 float
|
|
|
|
#else
|
|
|
|
EEPROM_READ(dummy);
|
|
|
|
#endif
|
|
|
|
#if ENABLED(Z_DUAL_ENDSTOPS)
|
|
|
|
EEPROM_READ(z_endstop_adj); // 1 float
|
|
|
|
#else
|
|
|
|
EEPROM_READ(dummy);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
for (uint8_t q=7; q--;) EEPROM_READ(dummy);
|
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
#else
|
2017-10-27 23:24:34 +02:00
|
|
|
|
|
|
|
for (uint8_t q=10; q--;) EEPROM_READ(dummy);
|
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
#endif
|
|
|
|
|
2017-11-01 20:51:57 +01:00
|
|
|
//
|
|
|
|
// LCD Preheat settings
|
|
|
|
//
|
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
#if DISABLED(ULTIPANEL)
|
2016-10-27 09:40:37 +02:00
|
|
|
int lcd_preheat_hotend_temp[2], lcd_preheat_bed_temp[2], lcd_preheat_fan_speed[2];
|
2016-10-29 01:55:42 +02:00
|
|
|
#endif
|
2017-11-01 20:51:57 +01:00
|
|
|
EEPROM_READ(lcd_preheat_hotend_temp); // 2 floats
|
|
|
|
EEPROM_READ(lcd_preheat_bed_temp); // 2 floats
|
|
|
|
EEPROM_READ(lcd_preheat_fan_speed); // 2 floats
|
2016-10-29 01:55:42 +02:00
|
|
|
|
2017-04-10 04:47:49 +02:00
|
|
|
//EEPROM_ASSERT(
|
|
|
|
// WITHIN(lcd_preheat_fan_speed, 0, 255),
|
|
|
|
// "lcd_preheat_fan_speed out of range"
|
|
|
|
//);
|
|
|
|
|
2017-11-01 20:51:57 +01:00
|
|
|
//
|
|
|
|
// Hotend PID
|
|
|
|
//
|
|
|
|
|
2016-10-29 01:55:42 +02: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
|
|
|
|
|
2017-11-01 20:51:57 +01:00
|
|
|
//
|
|
|
|
// PID Extrusion Scaling
|
|
|
|
//
|
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
#if DISABLED(PID_EXTRUSION_SCALING)
|
|
|
|
int lpq_len;
|
|
|
|
#endif
|
|
|
|
EEPROM_READ(lpq_len);
|
|
|
|
|
2017-11-01 20:51:57 +01:00
|
|
|
//
|
|
|
|
// Heated Bed PID
|
|
|
|
//
|
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
#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
|
|
|
|
|
2017-11-01 20:51:57 +01:00
|
|
|
//
|
|
|
|
// LCD Contrast
|
|
|
|
//
|
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
#if !HAS_LCD_CONTRAST
|
2017-05-21 02:54:23 +02:00
|
|
|
uint16_t lcd_contrast;
|
2016-10-29 01:55:42 +02:00
|
|
|
#endif
|
|
|
|
EEPROM_READ(lcd_contrast);
|
|
|
|
|
2017-11-01 20:51:57 +01:00
|
|
|
//
|
|
|
|
// Firmware Retraction
|
|
|
|
//
|
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
#if ENABLED(FWRETRACT)
|
|
|
|
EEPROM_READ(autoretract_enabled);
|
|
|
|
EEPROM_READ(retract_length);
|
|
|
|
EEPROM_READ(retract_feedrate_mm_s);
|
|
|
|
EEPROM_READ(retract_zlift);
|
|
|
|
EEPROM_READ(retract_recover_length);
|
|
|
|
EEPROM_READ(retract_recover_feedrate_mm_s);
|
2017-07-27 05:11:22 +02:00
|
|
|
EEPROM_READ(swap_retract_length);
|
|
|
|
EEPROM_READ(swap_retract_recover_length);
|
2017-07-18 05:01:41 +02:00
|
|
|
EEPROM_READ(swap_retract_recover_feedrate_mm_s);
|
|
|
|
#else
|
|
|
|
EEPROM_READ(dummyb);
|
|
|
|
for (uint8_t q=8; q--;) EEPROM_READ(dummy);
|
|
|
|
#endif
|
2016-10-29 01:55:42 +02:00
|
|
|
|
2017-11-01 20:51:57 +01:00
|
|
|
//
|
|
|
|
// Volumetric & Filament Size
|
|
|
|
//
|
2016-10-29 01:55:42 +02:00
|
|
|
|
2017-11-10 09:38:53 +01:00
|
|
|
EEPROM_READ(parser.volumetric_enabled);
|
2016-10-29 01:55:42 +02:00
|
|
|
for (uint8_t q = 0; q < MAX_EXTRUDERS; q++) {
|
|
|
|
EEPROM_READ(dummy);
|
2017-11-10 09:38:53 +01:00
|
|
|
if (q < COUNT(planner.filament_size)) planner.filament_size[q] = dummy;
|
2016-10-29 01:55:42 +02:00
|
|
|
}
|
|
|
|
|
2017-11-01 20:51:57 +01:00
|
|
|
//
|
|
|
|
// TMC2130 Stepper Current
|
|
|
|
//
|
|
|
|
|
2017-03-07 06:00:43 +01: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 10:23:05 +02:00
|
|
|
EEPROM_READ(val);
|
|
|
|
#if ENABLED(E4_IS_TMC2130)
|
|
|
|
stepperE4.setCurrent(val, R_SENSE, HOLD_MULTIPLIER);
|
|
|
|
#endif
|
2017-03-07 06:00:43 +01:00
|
|
|
#else
|
2017-11-07 03:16:57 +01:00
|
|
|
for (uint8_t q = 11; q--;) EEPROM_READ(val);
|
2017-03-07 06:00:43 +01:00
|
|
|
#endif
|
|
|
|
|
2017-04-16 05:18:10 +02:00
|
|
|
//
|
|
|
|
// Linear Advance
|
|
|
|
//
|
|
|
|
|
|
|
|
#if ENABLED(LIN_ADVANCE)
|
2017-04-22 05:30:36 +02:00
|
|
|
EEPROM_READ(planner.extruder_advance_k);
|
|
|
|
EEPROM_READ(planner.advance_ed_ratio);
|
|
|
|
#else
|
|
|
|
EEPROM_READ(dummy);
|
|
|
|
EEPROM_READ(dummy);
|
2017-04-16 05:18:10 +02:00
|
|
|
#endif
|
|
|
|
|
2017-11-01 20:51:57 +01:00
|
|
|
//
|
|
|
|
// Motor Current PWM
|
|
|
|
//
|
|
|
|
|
2017-06-03 07:38:07 +02:00
|
|
|
#if HAS_MOTOR_CURRENT_PWM
|
|
|
|
for (uint8_t q = 3; q--;) EEPROM_READ(stepper.motor_current_setting[q]);
|
|
|
|
#else
|
|
|
|
uint32_t dummyui32;
|
|
|
|
for (uint8_t q = 3; q--;) EEPROM_READ(dummyui32);
|
|
|
|
#endif
|
|
|
|
|
2017-11-01 19:08:46 +01:00
|
|
|
//
|
|
|
|
// CNC Coordinate System
|
|
|
|
//
|
|
|
|
|
|
|
|
#if ENABLED(CNC_COORDINATE_SYSTEMS)
|
|
|
|
position_changed = select_coordinate_system(-1); // Go back to machine space
|
|
|
|
EEPROM_READ(coordinate_system); // 27 floats
|
|
|
|
#else
|
|
|
|
for (uint8_t q = 27; q--;) EEPROM_READ(dummy);
|
|
|
|
#endif
|
|
|
|
|
2017-05-07 03:00:56 +02:00
|
|
|
if (working_crc == stored_crc) {
|
2017-07-02 04:48:18 +02:00
|
|
|
postprocess();
|
|
|
|
#if ENABLED(EEPROM_CHITCHAT)
|
2017-06-09 17:51:23 +02:00
|
|
|
SERIAL_ECHO_START();
|
2016-12-14 08:48:42 +01:00
|
|
|
SERIAL_ECHO(version);
|
2016-12-14 14:13:25 +01:00
|
|
|
SERIAL_ECHOPAIR(" stored settings retrieved (", eeprom_index - (EEPROM_OFFSET));
|
2017-08-21 23:30:08 +02:00
|
|
|
SERIAL_ECHOPAIR(" bytes; crc ", (uint32_t)working_crc);
|
2017-05-07 03:00:56 +02:00
|
|
|
SERIAL_ECHOLNPGM(")");
|
2017-07-02 04:48:18 +02:00
|
|
|
#endif
|
2016-10-29 01:55:42 +02:00
|
|
|
}
|
|
|
|
else {
|
2017-07-02 04:48:18 +02:00
|
|
|
#if ENABLED(EEPROM_CHITCHAT)
|
|
|
|
SERIAL_ERROR_START();
|
|
|
|
SERIAL_ERRORPGM("EEPROM CRC mismatch - (stored) ");
|
|
|
|
SERIAL_ERROR(stored_crc);
|
|
|
|
SERIAL_ERRORPGM(" != ");
|
|
|
|
SERIAL_ERROR(working_crc);
|
|
|
|
SERIAL_ERRORLNPGM(" (calculated)!");
|
|
|
|
#endif
|
2017-04-10 04:47:49 +02:00
|
|
|
reset();
|
2016-10-29 01:55:42 +02:00
|
|
|
}
|
|
|
|
|
2017-03-18 16:15:54 +01:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
2017-05-16 09:34:36 +02:00
|
|
|
meshes_begin = (eeprom_index + 32) & 0xFFF8; // Pad the end of configuration data so it
|
|
|
|
// can float up or down a little bit without
|
|
|
|
// disrupting the mesh data
|
|
|
|
ubl.report_state();
|
2017-03-18 16:15:54 +01:00
|
|
|
|
2017-03-20 07:42:41 +01:00
|
|
|
if (!ubl.sanity_check()) {
|
2017-06-09 17:51:23 +02:00
|
|
|
SERIAL_EOL();
|
2017-07-02 04:48:18 +02:00
|
|
|
#if ENABLED(EEPROM_CHITCHAT)
|
|
|
|
ubl.echo_name();
|
|
|
|
SERIAL_ECHOLNPGM(" initialized.\n");
|
|
|
|
#endif
|
2017-03-18 16:15:54 +01:00
|
|
|
}
|
|
|
|
else {
|
2017-07-02 04:48:18 +02:00
|
|
|
#if ENABLED(EEPROM_CHITCHAT)
|
|
|
|
SERIAL_PROTOCOLPGM("?Can't enable ");
|
|
|
|
ubl.echo_name();
|
|
|
|
SERIAL_PROTOCOLLNPGM(".");
|
|
|
|
#endif
|
2017-03-20 07:42:41 +01:00
|
|
|
ubl.reset();
|
2017-03-18 16:15:54 +01:00
|
|
|
}
|
|
|
|
|
2017-10-14 04:58:45 +02:00
|
|
|
if (ubl.storage_slot >= 0) {
|
|
|
|
load_mesh(ubl.storage_slot);
|
2017-07-02 04:48:18 +02:00
|
|
|
#if ENABLED(EEPROM_CHITCHAT)
|
2017-10-14 04:58:45 +02:00
|
|
|
SERIAL_ECHOPAIR("Mesh ", ubl.storage_slot);
|
2017-07-02 04:48:18 +02:00
|
|
|
SERIAL_ECHOLNPGM(" loaded from storage.");
|
|
|
|
#endif
|
2017-03-18 16:15:54 +01:00
|
|
|
}
|
|
|
|
else {
|
2017-03-20 07:42:41 +01:00
|
|
|
ubl.reset();
|
2017-07-02 04:48:18 +02:00
|
|
|
#if ENABLED(EEPROM_CHITCHAT)
|
|
|
|
SERIAL_ECHOLNPGM("UBL System reset()");
|
|
|
|
#endif
|
2017-03-18 16:15:54 +01:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
2017-04-22 23:04:28 +02:00
|
|
|
|
2017-07-02 04:30:46 +02:00
|
|
|
#if ENABLED(EEPROM_CHITCHAT) && DISABLED(DISABLE_M503)
|
2017-04-10 04:47:49 +02:00
|
|
|
report();
|
2016-10-29 01:55:42 +02:00
|
|
|
#endif
|
2017-03-20 12:10:31 +01:00
|
|
|
|
2017-05-07 03:00:56 +02:00
|
|
|
return !eeprom_error;
|
2016-10-29 01:55:42 +02:00
|
|
|
}
|
2015-01-28 10:08:48 +01:00
|
|
|
|
2017-05-07 03:00:56 +02:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
|
|
|
|
2017-07-02 04:48:18 +02:00
|
|
|
#if ENABLED(EEPROM_CHITCHAT)
|
|
|
|
void ubl_invalid_slot(const int s) {
|
|
|
|
SERIAL_PROTOCOLLNPGM("?Invalid slot.");
|
|
|
|
SERIAL_PROTOCOL(s);
|
|
|
|
SERIAL_PROTOCOLLNPGM(" mesh slots available.");
|
|
|
|
}
|
|
|
|
#endif
|
2017-05-16 09:34:36 +02:00
|
|
|
|
2017-05-07 03:00:56 +02:00
|
|
|
int MarlinSettings::calc_num_meshes() {
|
|
|
|
//obviously this will get more sophisticated once we've added an actual MAT
|
|
|
|
|
|
|
|
if (meshes_begin <= 0) return 0;
|
|
|
|
|
|
|
|
return (meshes_end - meshes_begin) / sizeof(ubl.z_values);
|
|
|
|
}
|
|
|
|
|
|
|
|
void MarlinSettings::store_mesh(int8_t slot) {
|
|
|
|
|
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
|
|
|
const int a = calc_num_meshes();
|
|
|
|
if (!WITHIN(slot, 0, a - 1)) {
|
2017-07-02 04:48:18 +02:00
|
|
|
#if ENABLED(EEPROM_CHITCHAT)
|
|
|
|
ubl_invalid_slot(a);
|
|
|
|
SERIAL_PROTOCOLPAIR("E2END=", E2END);
|
|
|
|
SERIAL_PROTOCOLPAIR(" meshes_end=", meshes_end);
|
|
|
|
SERIAL_PROTOCOLLNPAIR(" slot=", slot);
|
|
|
|
SERIAL_EOL();
|
|
|
|
#endif
|
2017-05-07 03:00:56 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint16_t crc = 0;
|
|
|
|
int pos = meshes_end - (slot + 1) * sizeof(ubl.z_values);
|
|
|
|
|
|
|
|
write_data(pos, (uint8_t *)&ubl.z_values, sizeof(ubl.z_values), &crc);
|
|
|
|
|
|
|
|
// Write crc to MAT along with other data, or just tack on to the beginning or end
|
|
|
|
|
2017-07-02 04:48:18 +02:00
|
|
|
#if ENABLED(EEPROM_CHITCHAT)
|
|
|
|
SERIAL_PROTOCOLLNPAIR("Mesh saved in slot ", slot);
|
|
|
|
#endif
|
2017-05-07 03:00:56 +02:00
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
// Other mesh types
|
|
|
|
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void MarlinSettings::load_mesh(int8_t slot, void *into /* = 0 */) {
|
|
|
|
|
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
|
|
|
|
|
|
|
const int16_t a = settings.calc_num_meshes();
|
|
|
|
|
|
|
|
if (!WITHIN(slot, 0, a - 1)) {
|
2017-07-02 04:48:18 +02:00
|
|
|
#if ENABLED(EEPROM_CHITCHAT)
|
|
|
|
ubl_invalid_slot(a);
|
|
|
|
#endif
|
2017-05-07 03:00:56 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint16_t crc = 0;
|
|
|
|
int pos = meshes_end - (slot + 1) * sizeof(ubl.z_values);
|
|
|
|
uint8_t * const dest = into ? (uint8_t*)into : (uint8_t*)&ubl.z_values;
|
|
|
|
read_data(pos, dest, sizeof(ubl.z_values), &crc);
|
|
|
|
|
|
|
|
// Compare crc with crc from MAT, or read from end
|
|
|
|
|
2017-07-02 04:48:18 +02:00
|
|
|
#if ENABLED(EEPROM_CHITCHAT)
|
|
|
|
SERIAL_PROTOCOLLNPAIR("Mesh loaded from slot ", slot);
|
|
|
|
#endif
|
2017-05-07 03:00:56 +02:00
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
// Other mesh types
|
|
|
|
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
//void MarlinSettings::delete_mesh() { return; }
|
|
|
|
//void MarlinSettings::defrag_meshes() { return; }
|
|
|
|
|
|
|
|
#endif // AUTO_BED_LEVELING_UBL
|
|
|
|
|
2016-10-29 01:53:48 +02:00
|
|
|
#else // !EEPROM_SETTINGS
|
|
|
|
|
2017-04-10 04:47:49 +02:00
|
|
|
bool MarlinSettings::save() {
|
2017-06-09 17:51:23 +02:00
|
|
|
SERIAL_ERROR_START();
|
2016-10-29 01:53:48 +02:00
|
|
|
SERIAL_ERRORLNPGM("EEPROM disabled");
|
2017-03-20 12:10:31 +01:00
|
|
|
return false;
|
2016-10-29 01:53:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif // !EEPROM_SETTINGS
|
2015-01-28 10:08:48 +01:00
|
|
|
|
2015-04-27 03:44:01 +02:00
|
|
|
/**
|
2016-06-30 03:18:46 +02:00
|
|
|
* M502 - Reset Configuration
|
2015-04-27 03:44:01 +02:00
|
|
|
*/
|
2017-04-10 04:47:49 +02:00
|
|
|
void MarlinSettings::reset() {
|
2017-06-06 11:03:01 +02:00
|
|
|
static const float tmp1[] PROGMEM = DEFAULT_AXIS_STEPS_PER_UNIT, tmp2[] PROGMEM = DEFAULT_MAX_FEEDRATE;
|
|
|
|
static const uint32_t tmp3[] PROGMEM = DEFAULT_MAX_ACCELERATION;
|
2016-12-04 05:02:27 +01:00
|
|
|
LOOP_XYZE_N(i) {
|
2017-06-06 11:03:01 +02:00
|
|
|
planner.axis_steps_per_mm[i] = pgm_read_float(&tmp1[i < COUNT(tmp1) ? i : COUNT(tmp1) - 1]);
|
|
|
|
planner.max_feedrate_mm_s[i] = pgm_read_float(&tmp2[i < COUNT(tmp2) ? i : COUNT(tmp2) - 1]);
|
2017-06-08 23:15:02 +02:00
|
|
|
planner.max_acceleration_mm_per_s2[i] = pgm_read_dword_near(&tmp3[i < COUNT(tmp3) ? i : COUNT(tmp3) - 1]);
|
2015-01-28 10:08:48 +01:00
|
|
|
}
|
|
|
|
|
2016-04-28 03:06:32 +02:00
|
|
|
planner.acceleration = DEFAULT_ACCELERATION;
|
|
|
|
planner.retract_acceleration = DEFAULT_RETRACT_ACCELERATION;
|
|
|
|
planner.travel_acceleration = DEFAULT_TRAVEL_ACCELERATION;
|
2016-07-16 03:49:34 +02:00
|
|
|
planner.min_feedrate_mm_s = DEFAULT_MINIMUMFEEDRATE;
|
2017-10-14 22:47:53 +02:00
|
|
|
planner.min_segment_time_us = DEFAULT_MINSEGMENTTIME;
|
2016-07-16 03:49:34 +02:00
|
|
|
planner.min_travel_feedrate_mm_s = DEFAULT_MINTRAVELFEEDRATE;
|
2016-10-02 11:37:13 +02: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 13:49:31 +01:00
|
|
|
|
|
|
|
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
2017-10-13 23:16:32 +02:00
|
|
|
new_z_fade_height = 10.0;
|
2017-02-21 13:49:31 +01:00
|
|
|
#endif
|
|
|
|
|
2017-04-15 04:41:21 +02:00
|
|
|
#if HAS_HOME_OFFSET
|
2017-03-05 01:01:33 +01:00
|
|
|
ZERO(home_offset);
|
|
|
|
#endif
|
2015-01-28 10:08:48 +01:00
|
|
|
|
2016-10-29 01:39:23 +02: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 08:44:39 +01:00
|
|
|
// Applies to all MBL and ABL
|
2017-05-01 23:13:09 +02:00
|
|
|
#if HAS_LEVELING
|
2016-12-10 07:17:49 +01:00
|
|
|
reset_bed_level();
|
2015-03-26 07:06:33 +01:00
|
|
|
#endif
|
|
|
|
|
2016-06-15 03:05:20 +02:00
|
|
|
#if HAS_BED_PROBE
|
2015-05-27 02:47:04 +02:00
|
|
|
zprobe_zoffset = Z_PROBE_OFFSET_FROM_EXTRUDER;
|
2015-03-26 07:06:33 +01:00
|
|
|
#endif
|
2015-03-15 23:18:11 +01:00
|
|
|
|
2015-07-31 07:31:45 +02:00
|
|
|
#if ENABLED(DELTA)
|
2017-03-08 00:42:04 +01:00
|
|
|
const float adj[ABC] = DELTA_ENDSTOP_ADJ,
|
2017-04-29 16:36:33 +02:00
|
|
|
dta[ABC] = DELTA_TOWER_ANGLE_TRIM;
|
2017-11-09 06:21:02 +01:00
|
|
|
delta_height = DELTA_HEIGHT;
|
2017-10-27 06:49:20 +02:00
|
|
|
COPY(delta_endstop_adj, adj);
|
2016-12-10 07:17:49 +01:00
|
|
|
delta_radius = DELTA_RADIUS;
|
|
|
|
delta_diagonal_rod = DELTA_DIAGONAL_ROD;
|
|
|
|
delta_segments_per_second = DELTA_SEGMENTS_PER_SECOND;
|
2017-04-18 14:43:25 +02:00
|
|
|
delta_calibration_radius = DELTA_CALIBRATION_RADIUS;
|
2017-09-24 08:45:31 +02:00
|
|
|
COPY(delta_tower_angle_trim, dta);
|
2017-04-15 04:41:21 +02:00
|
|
|
|
2017-10-27 23:24:34 +02:00
|
|
|
#elif ENABLED(X_DUAL_ENDSTOPS) || ENABLED(Y_DUAL_ENDSTOPS) || ENABLED(Z_DUAL_ENDSTOPS)
|
2017-04-15 04:41:21 +02:00
|
|
|
|
2017-10-27 23:24:34 +02:00
|
|
|
#if ENABLED(X_DUAL_ENDSTOPS)
|
|
|
|
x_endstop_adj = (
|
|
|
|
#ifdef X_DUAL_ENDSTOPS_ADJUSTMENT
|
|
|
|
X_DUAL_ENDSTOPS_ADJUSTMENT
|
|
|
|
#else
|
|
|
|
0
|
|
|
|
#endif
|
|
|
|
);
|
|
|
|
#endif
|
|
|
|
#if ENABLED(Y_DUAL_ENDSTOPS)
|
|
|
|
y_endstop_adj = (
|
|
|
|
#ifdef Y_DUAL_ENDSTOPS_ADJUSTMENT
|
|
|
|
Y_DUAL_ENDSTOPS_ADJUSTMENT
|
|
|
|
#else
|
|
|
|
0
|
|
|
|
#endif
|
|
|
|
);
|
|
|
|
#endif
|
|
|
|
#if ENABLED(Z_DUAL_ENDSTOPS)
|
|
|
|
z_endstop_adj = (
|
|
|
|
#ifdef Z_DUAL_ENDSTOPS_ADJUSTMENT
|
|
|
|
Z_DUAL_ENDSTOPS_ADJUSTMENT
|
|
|
|
#else
|
|
|
|
0
|
|
|
|
#endif
|
|
|
|
);
|
|
|
|
#endif
|
2017-04-15 04:41:21 +02:00
|
|
|
|
2015-01-28 10:08:48 +01:00
|
|
|
#endif
|
|
|
|
|
2015-07-31 07:31:45 +02:00
|
|
|
#if ENABLED(ULTIPANEL)
|
2016-10-27 09:40:37 +02: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 10:08:48 +01:00
|
|
|
#endif
|
|
|
|
|
2016-05-31 20:47:02 +02:00
|
|
|
#if HAS_LCD_CONTRAST
|
2015-01-28 10:08:48 +01:00
|
|
|
lcd_contrast = DEFAULT_LCD_CONTRAST;
|
|
|
|
#endif
|
|
|
|
|
2015-07-31 07:31:45 +02:00
|
|
|
#if ENABLED(PIDTEMP)
|
2016-07-13 15:11:23 +02:00
|
|
|
#if ENABLED(PID_PARAMS_PER_HOTEND) && HOTENDS > 1
|
2016-07-11 20:48:15 +02:00
|
|
|
HOTEND_LOOP()
|
2015-01-28 10:08:48 +01: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 02:49:34 +02:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2015-01-28 10:08:48 +01:00
|
|
|
PID_PARAM(Kc, e) = DEFAULT_Kc;
|
|
|
|
#endif
|
|
|
|
}
|
2016-08-01 02:49:34 +02:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2015-08-31 04:04:30 +02:00
|
|
|
lpq_len = 20; // default last-position-queue size
|
|
|
|
#endif
|
2015-01-28 10:08:48 +01:00
|
|
|
#endif // PIDTEMP
|
|
|
|
|
2015-07-31 07:31:45 +02:00
|
|
|
#if ENABLED(PIDTEMPBED)
|
2016-04-29 03:18:13 +02:00
|
|
|
thermalManager.bedKp = DEFAULT_bedKp;
|
|
|
|
thermalManager.bedKi = scalePID_i(DEFAULT_bedKi);
|
|
|
|
thermalManager.bedKd = scalePID_d(DEFAULT_bedKd);
|
2015-04-04 01:38:05 +02:00
|
|
|
#endif
|
|
|
|
|
2015-07-31 07:31:45 +02:00
|
|
|
#if ENABLED(FWRETRACT)
|
2015-01-28 10:08:48 +01:00
|
|
|
autoretract_enabled = false;
|
|
|
|
retract_length = RETRACT_LENGTH;
|
2016-06-22 12:27:31 +02:00
|
|
|
retract_feedrate_mm_s = RETRACT_FEEDRATE;
|
2015-01-28 10:08:48 +01:00
|
|
|
retract_zlift = RETRACT_ZLIFT;
|
|
|
|
retract_recover_length = RETRACT_RECOVER_LENGTH;
|
2016-07-16 03:49:34 +02:00
|
|
|
retract_recover_feedrate_mm_s = RETRACT_RECOVER_FEEDRATE;
|
2017-07-27 05:11:22 +02:00
|
|
|
swap_retract_length = RETRACT_LENGTH_SWAP;
|
|
|
|
swap_retract_recover_length = RETRACT_RECOVER_LENGTH_SWAP;
|
2017-07-18 05:01:41 +02:00
|
|
|
swap_retract_recover_feedrate_mm_s = RETRACT_RECOVER_FEEDRATE_SWAP;
|
|
|
|
#endif // FWRETRACT
|
2015-01-28 10:08:48 +01:00
|
|
|
|
2017-11-10 09:38:53 +01:00
|
|
|
parser.volumetric_enabled =
|
2017-02-21 13:49:31 +01:00
|
|
|
#if ENABLED(VOLUMETRIC_DEFAULT_ON)
|
|
|
|
true
|
|
|
|
#else
|
|
|
|
false
|
|
|
|
#endif
|
2017-01-02 04:10:50 +01:00
|
|
|
;
|
2017-11-10 09:38:53 +01:00
|
|
|
for (uint8_t q = 0; q < COUNT(planner.filament_size); q++)
|
|
|
|
planner.filament_size[q] = DEFAULT_NOMINAL_FILAMENT_DIA;
|
2016-06-30 03:19:26 +02:00
|
|
|
|
2016-07-15 01:12:20 +02:00
|
|
|
endstops.enable_globally(
|
|
|
|
#if ENABLED(ENDSTOPS_ALWAYS_ON_DEFAULT)
|
2017-06-06 11:03:01 +02:00
|
|
|
true
|
2016-07-15 01:12:20 +02:00
|
|
|
#else
|
2017-06-06 11:03:01 +02:00
|
|
|
false
|
2016-07-15 01:12:20 +02:00
|
|
|
#endif
|
|
|
|
);
|
|
|
|
|
2017-03-07 06:00:43 +01:00
|
|
|
#if ENABLED(HAVE_TMC2130)
|
|
|
|
#if ENABLED(X_IS_TMC2130)
|
2017-04-15 05:44:08 +02:00
|
|
|
stepperX.setCurrent(X_CURRENT, R_SENSE, HOLD_MULTIPLIER);
|
2017-03-07 06:00:43 +01:00
|
|
|
#endif
|
|
|
|
#if ENABLED(Y_IS_TMC2130)
|
2017-04-15 05:44:08 +02:00
|
|
|
stepperY.setCurrent(Y_CURRENT, R_SENSE, HOLD_MULTIPLIER);
|
2017-03-07 06:00:43 +01:00
|
|
|
#endif
|
|
|
|
#if ENABLED(Z_IS_TMC2130)
|
2017-04-15 05:44:08 +02:00
|
|
|
stepperZ.setCurrent(Z_CURRENT, R_SENSE, HOLD_MULTIPLIER);
|
2017-03-07 06:00:43 +01:00
|
|
|
#endif
|
|
|
|
#if ENABLED(X2_IS_TMC2130)
|
2017-04-15 05:44:08 +02:00
|
|
|
stepperX2.setCurrent(X2_CURRENT, R_SENSE, HOLD_MULTIPLIER);
|
2017-03-07 06:00:43 +01:00
|
|
|
#endif
|
|
|
|
#if ENABLED(Y2_IS_TMC2130)
|
2017-04-15 05:44:08 +02:00
|
|
|
stepperY2.setCurrent(Y2_CURRENT, R_SENSE, HOLD_MULTIPLIER);
|
2017-03-07 06:00:43 +01:00
|
|
|
#endif
|
|
|
|
#if ENABLED(Z2_IS_TMC2130)
|
2017-04-15 05:44:08 +02:00
|
|
|
stepperZ2.setCurrent(Z2_CURRENT, R_SENSE, HOLD_MULTIPLIER);
|
2017-03-07 06:00:43 +01:00
|
|
|
#endif
|
|
|
|
#if ENABLED(E0_IS_TMC2130)
|
2017-04-15 05:44:08 +02:00
|
|
|
stepperE0.setCurrent(E0_CURRENT, R_SENSE, HOLD_MULTIPLIER);
|
2017-03-07 06:00:43 +01:00
|
|
|
#endif
|
|
|
|
#if ENABLED(E1_IS_TMC2130)
|
2017-04-15 05:44:08 +02:00
|
|
|
stepperE1.setCurrent(E1_CURRENT, R_SENSE, HOLD_MULTIPLIER);
|
2017-03-07 06:00:43 +01:00
|
|
|
#endif
|
|
|
|
#if ENABLED(E2_IS_TMC2130)
|
2017-04-15 05:44:08 +02:00
|
|
|
stepperE2.setCurrent(E2_CURRENT, R_SENSE, HOLD_MULTIPLIER);
|
2017-03-07 06:00:43 +01:00
|
|
|
#endif
|
|
|
|
#if ENABLED(E3_IS_TMC2130)
|
2017-04-15 05:44:08 +02:00
|
|
|
stepperE3.setCurrent(E3_CURRENT, R_SENSE, HOLD_MULTIPLIER);
|
2017-03-07 06:00:43 +01:00
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2017-04-16 05:18:10 +02:00
|
|
|
#if ENABLED(LIN_ADVANCE)
|
2017-04-22 05:30:36 +02:00
|
|
|
planner.extruder_advance_k = LIN_ADVANCE_K;
|
|
|
|
planner.advance_ed_ratio = LIN_ADVANCE_E_D_RATIO;
|
2017-04-16 05:18:10 +02:00
|
|
|
#endif
|
|
|
|
|
2017-06-03 07:38:07 +02:00
|
|
|
#if HAS_MOTOR_CURRENT_PWM
|
|
|
|
uint32_t tmp_motor_current_setting[3] = PWM_MOTOR_CURRENT;
|
|
|
|
for (uint8_t q = 3; q--;)
|
|
|
|
stepper.digipot_current(q, (stepper.motor_current_setting[q] = tmp_motor_current_setting[q]));
|
|
|
|
#endif
|
|
|
|
|
2017-04-22 23:04:28 +02:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
|
|
|
ubl.reset();
|
|
|
|
#endif
|
|
|
|
|
2017-04-10 04:47:49 +02:00
|
|
|
postprocess();
|
2015-01-28 10:08:48 +01:00
|
|
|
|
2017-07-02 04:48:18 +02:00
|
|
|
#if ENABLED(EEPROM_CHITCHAT)
|
|
|
|
SERIAL_ECHO_START();
|
|
|
|
SERIAL_ECHOLNPGM("Hardcoded Default Settings Loaded");
|
|
|
|
#endif
|
2015-01-28 10:08:48 +01:00
|
|
|
}
|
|
|
|
|
2015-07-31 07:31:45 +02:00
|
|
|
#if DISABLED(DISABLE_M503)
|
2015-01-28 10:08:48 +01:00
|
|
|
|
2017-06-09 17:51:23 +02:00
|
|
|
#define CONFIG_ECHO_START do{ if (!forReplay) SERIAL_ECHO_START(); }while(0)
|
2015-04-27 03:44:01 +02:00
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
/**
|
2017-04-10 04:47:49 +02:00
|
|
|
* M503 - Report current settings in RAM
|
2017-03-31 21:58:40 +02:00
|
|
|
*
|
2017-04-10 04:47:49 +02:00
|
|
|
* Unless specifically disabled, M503 is available even without EEPROM
|
2016-10-29 01:55:42 +02:00
|
|
|
*/
|
2017-04-10 04:47:49 +02:00
|
|
|
void MarlinSettings::report(bool forReplay) {
|
2015-01-28 10:08:48 +01:00
|
|
|
|
2017-04-17 06:24:30 +02:00
|
|
|
/**
|
|
|
|
* Announce current units, in case inches are being displayed
|
|
|
|
*/
|
2015-04-27 03:44:01 +02:00
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 06:24:30 +02:00
|
|
|
#if ENABLED(INCH_MODE_SUPPORT)
|
2017-11-25 00:30:54 +01:00
|
|
|
#define LINEAR_UNIT(N) (float(N) / parser.linear_unit_factor)
|
|
|
|
#define VOLUMETRIC_UNIT(N) (float(N) / (parser.volumetric_enabled ? parser.volumetric_unit_factor : parser.linear_unit_factor))
|
2017-05-07 02:41:50 +02:00
|
|
|
SERIAL_ECHOPGM(" G2");
|
2017-05-20 10:03:08 +02:00
|
|
|
SERIAL_CHAR(parser.linear_unit_factor == 1.0 ? '1' : '0');
|
2017-05-07 02:41:50 +02:00
|
|
|
SERIAL_ECHOPGM(" ; Units in ");
|
2017-05-20 10:03:08 +02:00
|
|
|
serialprintPGM(parser.linear_unit_factor == 1.0 ? PSTR("mm\n") : PSTR("inches\n"));
|
2017-04-17 06:24:30 +02:00
|
|
|
#else
|
2017-11-25 00:30:54 +01:00
|
|
|
#define LINEAR_UNIT(N) (N)
|
|
|
|
#define VOLUMETRIC_UNIT(N) (N)
|
2017-05-26 01:02:29 +02:00
|
|
|
SERIAL_ECHOLNPGM(" G21 ; Units in mm");
|
2017-04-17 06:24:30 +02:00
|
|
|
#endif
|
2015-01-28 10:08:48 +01:00
|
|
|
|
2017-05-07 02:41:50 +02:00
|
|
|
#if ENABLED(ULTIPANEL)
|
|
|
|
|
|
|
|
// Temperature units - for Ultipanel temperature options
|
|
|
|
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
#if ENABLED(TEMPERATURE_UNITS_SUPPORT)
|
2017-05-20 10:03:08 +02:00
|
|
|
#define TEMP_UNIT(N) parser.to_temp_units(N)
|
2017-05-07 02:41:50 +02:00
|
|
|
SERIAL_ECHOPGM(" M149 ");
|
2017-05-20 10:03:08 +02:00
|
|
|
SERIAL_CHAR(parser.temp_units_code());
|
2017-05-07 02:41:50 +02:00
|
|
|
SERIAL_ECHOPGM(" ; Units in ");
|
2017-05-20 10:03:08 +02:00
|
|
|
serialprintPGM(parser.temp_units_name());
|
2017-05-07 02:41:50 +02:00
|
|
|
#else
|
2017-11-25 00:30:54 +01:00
|
|
|
#define TEMP_UNIT(N) (N)
|
2017-05-26 01:02:29 +02:00
|
|
|
SERIAL_ECHOLNPGM(" M149 C ; Units in Celsius");
|
2017-05-07 02:41:50 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2017-06-09 17:51:23 +02:00
|
|
|
SERIAL_EOL();
|
2017-05-26 01:02:29 +02:00
|
|
|
|
2017-04-17 06:24:30 +02:00
|
|
|
/**
|
|
|
|
* Volumetric extrusion M200
|
|
|
|
*/
|
2016-10-29 01:39:23 +02:00
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOPGM("Filament settings:");
|
2017-11-10 09:38:53 +01:00
|
|
|
if (parser.volumetric_enabled)
|
2017-06-09 17:51:23 +02:00
|
|
|
SERIAL_EOL();
|
2017-04-17 06:24:30 +02:00
|
|
|
else
|
|
|
|
SERIAL_ECHOLNPGM(" Disabled");
|
2016-10-29 01:39:23 +02:00
|
|
|
}
|
2017-04-17 06:24:30 +02:00
|
|
|
|
|
|
|
CONFIG_ECHO_START;
|
2017-11-25 00:30:54 +01:00
|
|
|
SERIAL_ECHOPAIR(" M200 D", LINEAR_UNIT(planner.filament_size[0]));
|
2017-06-09 17:51:23 +02:00
|
|
|
SERIAL_EOL();
|
2017-04-17 06:24:30 +02:00
|
|
|
#if EXTRUDERS > 1
|
|
|
|
CONFIG_ECHO_START;
|
2017-11-25 00:30:54 +01:00
|
|
|
SERIAL_ECHOPAIR(" M200 T1 D", LINEAR_UNIT(planner.filament_size[1]));
|
2017-06-09 17:51:23 +02:00
|
|
|
SERIAL_EOL();
|
2017-04-17 06:24:30 +02:00
|
|
|
#if EXTRUDERS > 2
|
|
|
|
CONFIG_ECHO_START;
|
2017-11-25 00:30:54 +01:00
|
|
|
SERIAL_ECHOPAIR(" M200 T2 D", LINEAR_UNIT(planner.filament_size[2]));
|
2017-06-09 17:51:23 +02:00
|
|
|
SERIAL_EOL();
|
2017-04-17 06:24:30 +02:00
|
|
|
#if EXTRUDERS > 3
|
|
|
|
CONFIG_ECHO_START;
|
2017-11-25 00:30:54 +01:00
|
|
|
SERIAL_ECHOPAIR(" M200 T3 D", LINEAR_UNIT(planner.filament_size[3]));
|
2017-06-09 17:51:23 +02:00
|
|
|
SERIAL_EOL();
|
2017-04-17 06:24:30 +02:00
|
|
|
#if EXTRUDERS > 4
|
|
|
|
CONFIG_ECHO_START;
|
2017-11-25 00:30:54 +01:00
|
|
|
SERIAL_ECHOPAIR(" M200 T4 D", LINEAR_UNIT(planner.filament_size[4]));
|
2017-06-09 17:51:23 +02:00
|
|
|
SERIAL_EOL();
|
2017-04-17 06:24:30 +02:00
|
|
|
#endif // EXTRUDERS > 4
|
|
|
|
#endif // EXTRUDERS > 3
|
|
|
|
#endif // EXTRUDERS > 2
|
|
|
|
#endif // EXTRUDERS > 1
|
|
|
|
|
2017-11-10 09:38:53 +01:00
|
|
|
if (!parser.volumetric_enabled) {
|
2017-04-17 06:24:30 +02:00
|
|
|
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 02:37:29 +01:00
|
|
|
#if DISABLED(DISTINCT_E_FACTORS)
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOPAIR(" E", VOLUMETRIC_UNIT(planner.axis_steps_per_mm[E_AXIS]));
|
2016-12-04 05:02:27 +01:00
|
|
|
#endif
|
2017-06-09 17:51:23 +02:00
|
|
|
SERIAL_EOL();
|
2016-12-04 05:02:27 +01:00
|
|
|
#if ENABLED(DISTINCT_E_FACTORS)
|
2017-04-17 06:24:30 +02:00
|
|
|
CONFIG_ECHO_START;
|
2016-12-04 05:02:27 +01:00
|
|
|
for (uint8_t i = 0; i < E_STEPPERS; i++) {
|
|
|
|
SERIAL_ECHOPAIR(" M92 T", (int)i);
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOLNPAIR(" E", VOLUMETRIC_UNIT(planner.axis_steps_per_mm[E_AXIS + i]));
|
2016-12-04 05:02:27 +01:00
|
|
|
}
|
|
|
|
#endif
|
2016-10-29 01:55:42 +02:00
|
|
|
|
2015-04-27 03:44:01 +02:00
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOLNPGM("Maximum feedrates (units/s):");
|
2015-04-27 03:44:01 +02:00
|
|
|
}
|
2017-04-17 06:24:30 +02: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 02:37:29 +01:00
|
|
|
#if DISABLED(DISTINCT_E_FACTORS)
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOPAIR(" E", VOLUMETRIC_UNIT(planner.max_feedrate_mm_s[E_AXIS]));
|
2016-12-04 05:02:27 +01:00
|
|
|
#endif
|
2017-06-09 17:51:23 +02:00
|
|
|
SERIAL_EOL();
|
2016-12-04 05:02:27 +01:00
|
|
|
#if ENABLED(DISTINCT_E_FACTORS)
|
2017-04-17 06:24:30 +02:00
|
|
|
CONFIG_ECHO_START;
|
2016-12-04 05:02:27 +01:00
|
|
|
for (uint8_t i = 0; i < E_STEPPERS; i++) {
|
|
|
|
SERIAL_ECHOPAIR(" M203 T", (int)i);
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOLNPAIR(" E", VOLUMETRIC_UNIT(planner.max_feedrate_mm_s[E_AXIS + i]));
|
2016-12-04 05:02:27 +01:00
|
|
|
}
|
|
|
|
#endif
|
2015-04-27 03:44:01 +02:00
|
|
|
|
2015-01-28 10:08:48 +01:00
|
|
|
if (!forReplay) {
|
2015-04-27 03:44:01 +02:00
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOLNPGM("Maximum Acceleration (units/s2):");
|
2015-01-28 10:08:48 +01:00
|
|
|
}
|
2017-04-17 06:24:30 +02: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 02:37:29 +01:00
|
|
|
#if DISABLED(DISTINCT_E_FACTORS)
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOPAIR(" E", VOLUMETRIC_UNIT(planner.max_acceleration_mm_per_s2[E_AXIS]));
|
2016-12-04 05:02:27 +01:00
|
|
|
#endif
|
2017-06-09 17:51:23 +02:00
|
|
|
SERIAL_EOL();
|
2016-12-04 05:02:27 +01:00
|
|
|
#if ENABLED(DISTINCT_E_FACTORS)
|
2017-05-24 23:56:36 +02:00
|
|
|
CONFIG_ECHO_START;
|
2016-12-04 05:02:27 +01:00
|
|
|
for (uint8_t i = 0; i < E_STEPPERS; i++) {
|
|
|
|
SERIAL_ECHOPAIR(" M201 T", (int)i);
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOLNPAIR(" E", VOLUMETRIC_UNIT(planner.max_acceleration_mm_per_s2[E_AXIS + i]));
|
2016-12-04 05:02:27 +01:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2016-02-17 22:05:12 +01:00
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOLNPGM("Acceleration (units/s2): P<print_accel> R<retract_accel> T<travel_accel>");
|
2016-02-17 22:05:12 +01:00
|
|
|
}
|
2015-04-27 03:44:01 +02:00
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 06:24:30 +02: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 18:06:44 +01:00
|
|
|
if (!forReplay) {
|
2015-04-27 03:44:01 +02:00
|
|
|
CONFIG_ECHO_START;
|
2017-10-14 22:47:53 +02:00
|
|
|
SERIAL_ECHOLNPGM("Advanced: S<min_feedrate> T<min_travel_feedrate> B<min_segment_time_us> X<max_xy_jerk> Z<max_z_jerk> E<max_e_jerk>");
|
2015-03-24 18:06:44 +01:00
|
|
|
}
|
2017-04-17 06:24:30 +02: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));
|
2017-10-14 22:47:53 +02:00
|
|
|
SERIAL_ECHOPAIR(" B", planner.min_segment_time_us);
|
2017-04-17 06:24:30 +02: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 10:08:48 +01:00
|
|
|
|
2017-04-15 04:41:21 +02:00
|
|
|
#if HAS_M206_COMMAND
|
2017-03-05 01:01:33 +01:00
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOLNPGM("Home offset:");
|
2017-03-05 01:01:33 +01:00
|
|
|
}
|
2017-04-17 06:24:30 +02: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 01:01:33 +01:00
|
|
|
#endif
|
2015-04-27 03:44:01 +02:00
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
#if HOTENDS > 1
|
|
|
|
if (!forReplay) {
|
2015-04-27 03:44:01 +02:00
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOLNPGM("Hotend offsets:");
|
2016-10-29 01:55:42 +02:00
|
|
|
}
|
2017-04-17 06:24:30 +02:00
|
|
|
CONFIG_ECHO_START;
|
2016-10-29 01:55:42 +02:00
|
|
|
for (uint8_t e = 1; e < HOTENDS; e++) {
|
|
|
|
SERIAL_ECHOPAIR(" M218 T", (int)e);
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOPAIR(" X", LINEAR_UNIT(hotend_offset[X_AXIS][e]));
|
|
|
|
SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(hotend_offset[Y_AXIS][e]));
|
2017-08-13 23:35:59 +02:00
|
|
|
#if ENABLED(DUAL_X_CARRIAGE) || ENABLED(SWITCHING_NOZZLE) ||ENABLED(PARKING_EXTRUDER)
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(hotend_offset[Z_AXIS][e]));
|
2015-08-31 04:04:30 +02:00
|
|
|
#endif
|
2017-06-09 17:51:23 +02:00
|
|
|
SERIAL_EOL();
|
2015-04-27 03:44:01 +02:00
|
|
|
}
|
2016-10-29 01:55:42 +02:00
|
|
|
#endif
|
2015-04-27 03:44:01 +02:00
|
|
|
|
2017-10-13 23:16:32 +02:00
|
|
|
/**
|
|
|
|
* Bed Leveling
|
|
|
|
*/
|
|
|
|
#if HAS_LEVELING
|
2017-03-24 06:53:37 +01:00
|
|
|
|
2017-10-13 23:16:32 +02:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
|
|
|
|
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPGM("Mesh Bed Leveling:");
|
|
|
|
}
|
2016-10-29 01:55:42 +02:00
|
|
|
CONFIG_ECHO_START;
|
2017-10-13 23:16:32 +02:00
|
|
|
|
|
|
|
#elif ENABLED(AUTO_BED_LEVELING_UBL)
|
|
|
|
|
|
|
|
if (!forReplay) {
|
2016-10-29 01:55:42 +02:00
|
|
|
CONFIG_ECHO_START;
|
2017-10-13 23:16:32 +02:00
|
|
|
ubl.echo_name();
|
|
|
|
SERIAL_ECHOLNPGM(":");
|
2016-10-29 01:55:42 +02:00
|
|
|
}
|
2017-10-13 23:16:32 +02:00
|
|
|
CONFIG_ECHO_START;
|
2017-03-24 06:53:37 +01:00
|
|
|
|
2017-10-13 23:16:32 +02:00
|
|
|
#elif HAS_ABL
|
2017-03-24 06:53:37 +01:00
|
|
|
|
2017-10-13 23:16:32 +02:00
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPGM("Auto Bed Leveling:");
|
|
|
|
}
|
2017-03-24 06:53:37 +01:00
|
|
|
CONFIG_ECHO_START;
|
2017-10-13 23:16:32 +02:00
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2017-04-17 06:24:30 +02:00
|
|
|
CONFIG_ECHO_START;
|
2017-10-13 23:16:32 +02:00
|
|
|
SERIAL_ECHOPAIR(" M420 S", planner.leveling_active ? 1 : 0);
|
2017-04-21 00:45:58 +02:00
|
|
|
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
2017-10-13 23:16:32 +02:00
|
|
|
SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.z_fade_height));
|
2017-04-21 00:45:58 +02:00
|
|
|
#endif
|
2017-06-09 17:51:23 +02:00
|
|
|
SERIAL_EOL();
|
2017-03-24 06:53:37 +01:00
|
|
|
|
2017-10-13 23:16:32 +02:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2017-03-24 06:53:37 +01:00
|
|
|
|
2017-10-13 23:16:32 +02:00
|
|
|
for (uint8_t py = 0; py < GRID_MAX_POINTS_Y; py++) {
|
|
|
|
for (uint8_t px = 0; px < GRID_MAX_POINTS_X; px++) {
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR(" G29 S3 X", (int)px + 1);
|
|
|
|
SERIAL_ECHOPAIR(" Y", (int)py + 1);
|
|
|
|
SERIAL_ECHOPGM(" Z");
|
|
|
|
SERIAL_PROTOCOL_F(LINEAR_UNIT(mbl.z_values[px][py]), 5);
|
|
|
|
SERIAL_EOL();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#elif ENABLED(AUTO_BED_LEVELING_UBL)
|
|
|
|
|
|
|
|
if (!forReplay) {
|
|
|
|
SERIAL_EOL();
|
|
|
|
ubl.report_state();
|
2017-10-14 04:58:45 +02:00
|
|
|
SERIAL_ECHOLNPAIR("\nActive Mesh Slot: ", ubl.storage_slot);
|
2017-10-13 23:16:32 +02:00
|
|
|
SERIAL_ECHOPAIR("EEPROM can hold ", calc_num_meshes());
|
|
|
|
SERIAL_ECHOLNPGM(" meshes.\n");
|
|
|
|
}
|
2017-03-24 06:53:37 +01:00
|
|
|
|
2017-02-21 13:49:31 +01:00
|
|
|
#endif
|
2017-03-24 06:53:37 +01:00
|
|
|
|
2017-10-13 23:16:32 +02:00
|
|
|
#endif // HAS_LEVELING
|
2015-04-27 03:44:01 +02:00
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
#if ENABLED(DELTA)
|
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOLNPGM("Endstop adjustment:");
|
2016-10-29 01:55:42 +02:00
|
|
|
}
|
|
|
|
CONFIG_ECHO_START;
|
2017-10-27 06:49:20 +02:00
|
|
|
SERIAL_ECHOPAIR(" M666 X", LINEAR_UNIT(delta_endstop_adj[X_AXIS]));
|
|
|
|
SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(delta_endstop_adj[Y_AXIS]));
|
|
|
|
SERIAL_ECHOLNPAIR(" Z", LINEAR_UNIT(delta_endstop_adj[Z_AXIS]));
|
2016-10-29 01:55:42 +02:00
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-18 14:43:25 +02:00
|
|
|
SERIAL_ECHOLNPGM("Delta settings: L<diagonal_rod> R<radius> H<height> S<segments_per_s> B<calibration radius> XYZ<tower angle corrections>");
|
2016-10-29 01:55:42 +02:00
|
|
|
}
|
2017-04-17 06:24:30 +02:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR(" M665 L", LINEAR_UNIT(delta_diagonal_rod));
|
|
|
|
SERIAL_ECHOPAIR(" R", LINEAR_UNIT(delta_radius));
|
2017-11-09 06:21:02 +01:00
|
|
|
SERIAL_ECHOPAIR(" H", LINEAR_UNIT(delta_height));
|
2016-10-29 01:55:42 +02:00
|
|
|
SERIAL_ECHOPAIR(" S", delta_segments_per_second);
|
2017-04-18 16:49:33 +02:00
|
|
|
SERIAL_ECHOPAIR(" B", LINEAR_UNIT(delta_calibration_radius));
|
2017-04-18 14:43:25 +02:00
|
|
|
SERIAL_ECHOPAIR(" X", LINEAR_UNIT(delta_tower_angle_trim[A_AXIS]));
|
|
|
|
SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(delta_tower_angle_trim[B_AXIS]));
|
2017-09-24 08:45:31 +02:00
|
|
|
SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(delta_tower_angle_trim[C_AXIS]));
|
2017-06-09 17:51:23 +02:00
|
|
|
SERIAL_EOL();
|
2017-10-27 23:24:34 +02:00
|
|
|
|
|
|
|
#elif ENABLED(X_DUAL_ENDSTOPS) || ENABLED(Y_DUAL_ENDSTOPS) || ENABLED(Z_DUAL_ENDSTOPS)
|
2016-10-29 01:55:42 +02:00
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-10-27 23:24:34 +02:00
|
|
|
SERIAL_ECHOLNPGM("Endstop adjustment:");
|
2016-10-29 01:55:42 +02:00
|
|
|
}
|
2017-04-17 06:24:30 +02:00
|
|
|
CONFIG_ECHO_START;
|
2017-10-27 23:24:34 +02:00
|
|
|
SERIAL_ECHOPGM(" M666");
|
|
|
|
#if ENABLED(X_DUAL_ENDSTOPS)
|
|
|
|
SERIAL_ECHOPAIR(" X", LINEAR_UNIT(x_endstop_adj));
|
|
|
|
#endif
|
|
|
|
#if ENABLED(Y_DUAL_ENDSTOPS)
|
|
|
|
SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(y_endstop_adj));
|
|
|
|
#endif
|
|
|
|
#if ENABLED(Z_DUAL_ENDSTOPS)
|
|
|
|
SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(z_endstop_adj));
|
|
|
|
#endif
|
|
|
|
SERIAL_EOL();
|
2016-10-29 01:55:42 +02:00
|
|
|
#endif // DELTA
|
2015-04-27 03:44:01 +02:00
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
#if ENABLED(ULTIPANEL)
|
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOLNPGM("Material heatup parameters:");
|
2016-10-29 01:55:42 +02:00
|
|
|
}
|
2016-10-27 09:40:37 +02:00
|
|
|
for (uint8_t i = 0; i < COUNT(lcd_preheat_hotend_temp); i++) {
|
2017-11-15 10:59:23 +01:00
|
|
|
CONFIG_ECHO_START;
|
2016-10-27 09:40:37 +02:00
|
|
|
SERIAL_ECHOPAIR(" M145 S", (int)i);
|
2017-05-07 02:41:50 +02:00
|
|
|
SERIAL_ECHOPAIR(" H", TEMP_UNIT(lcd_preheat_hotend_temp[i]));
|
|
|
|
SERIAL_ECHOPAIR(" B", TEMP_UNIT(lcd_preheat_bed_temp[i]));
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOLNPAIR(" F", lcd_preheat_fan_speed[i]);
|
2016-10-27 09:40:37 +02:00
|
|
|
}
|
2016-10-29 01:55:42 +02:00
|
|
|
#endif // ULTIPANEL
|
2015-01-28 10:08:48 +01:00
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
#if HAS_PID_HEATING
|
2015-01-28 10:08:48 +01:00
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
if (!forReplay) {
|
2017-04-17 06:24:30 +02:00
|
|
|
CONFIG_ECHO_START;
|
2016-10-29 01:55:42 +02: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
|
2017-06-09 17:51:23 +02:00
|
|
|
SERIAL_EOL();
|
2016-10-29 01:55:42 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
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
|
2017-06-09 17:51:23 +02:00
|
|
|
SERIAL_EOL();
|
2016-10-29 01:55:42 +02:00
|
|
|
}
|
|
|
|
#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));
|
2017-06-09 17:51:23 +02:00
|
|
|
SERIAL_EOL();
|
2016-10-29 01:55:42 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif // PIDTEMP || PIDTEMPBED
|
|
|
|
|
|
|
|
#if HAS_LCD_CONTRAST
|
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOLNPGM("LCD Contrast:");
|
2016-10-29 01:55:42 +02:00
|
|
|
}
|
2017-04-17 06:24:30 +02:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPAIR(" M250 C", lcd_contrast);
|
2015-04-27 03:44:01 +02:00
|
|
|
#endif
|
2015-01-28 10:08:48 +01:00
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
#if ENABLED(FWRETRACT)
|
2012-11-07 23:16:43 +01:00
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOLNPGM("Retract: S<length> F<units/m> Z<lift>");
|
2016-10-29 01:55:42 +02:00
|
|
|
}
|
2017-04-17 06:24:30 +02:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR(" M207 S", LINEAR_UNIT(retract_length));
|
2017-07-27 05:11:22 +02:00
|
|
|
SERIAL_ECHOPAIR(" W", LINEAR_UNIT(swap_retract_length));
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOPAIR(" F", MMS_TO_MMM(LINEAR_UNIT(retract_feedrate_mm_s)));
|
|
|
|
SERIAL_ECHOLNPAIR(" Z", LINEAR_UNIT(retract_zlift));
|
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOLNPGM("Recover: S<length> F<units/m>");
|
2016-10-29 01:55:42 +02:00
|
|
|
}
|
2017-04-17 06:24:30 +02:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR(" M208 S", LINEAR_UNIT(retract_recover_length));
|
2017-07-27 05:11:22 +02:00
|
|
|
SERIAL_ECHOPAIR(" W", LINEAR_UNIT(swap_retract_recover_length));
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOLNPAIR(" F", MMS_TO_MMM(LINEAR_UNIT(retract_recover_feedrate_mm_s)));
|
|
|
|
|
2016-10-29 01:55:42 +02:00
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-07-24 01:56:56 +02:00
|
|
|
SERIAL_ECHOLNPGM("Auto-Retract: S=0 to disable, 1 to interpret E-only moves as retract/recover");
|
2016-10-29 01:55:42 +02:00
|
|
|
}
|
2015-04-27 03:44:01 +02:00
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOLNPAIR(" M209 S", autoretract_enabled ? 1 : 0);
|
2015-01-28 10:08:48 +01:00
|
|
|
|
2017-04-17 06:24:30 +02:00
|
|
|
#endif // FWRETRACT
|
2016-10-29 01:55:42 +02:00
|
|
|
|
|
|
|
/**
|
2017-10-13 23:16:32 +02:00
|
|
|
* Probe Offset
|
2016-10-29 01:55:42 +02:00
|
|
|
*/
|
|
|
|
#if HAS_BED_PROBE
|
|
|
|
if (!forReplay) {
|
2017-03-07 06:00:43 +01:00
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOLNPGM("Z-Probe Offset (mm):");
|
2016-10-29 01:55:42 +02:00
|
|
|
}
|
2017-04-17 06:24:30 +02:00
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPAIR(" M851 Z", LINEAR_UNIT(zprobe_zoffset));
|
2016-10-29 01:55:42 +02:00
|
|
|
#endif
|
2017-03-07 06:00:43 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* TMC2130 stepper driver current
|
|
|
|
*/
|
|
|
|
#if ENABLED(HAVE_TMC2130)
|
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-17 06:24:30 +02:00
|
|
|
SERIAL_ECHOLNPGM("Stepper driver current:");
|
2017-03-07 06:00:43 +01:00
|
|
|
}
|
2017-04-17 06:24:30 +02:00
|
|
|
CONFIG_ECHO_START;
|
2017-03-07 06:00:43 +01: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
|
2017-06-09 17:51:23 +02:00
|
|
|
SERIAL_EOL();
|
2017-03-07 06:00:43 +01:00
|
|
|
#endif
|
2017-04-16 05:18:10 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Linear Advance
|
|
|
|
*/
|
|
|
|
#if ENABLED(LIN_ADVANCE)
|
|
|
|
if (!forReplay) {
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPGM("Linear Advance:");
|
|
|
|
}
|
|
|
|
CONFIG_ECHO_START;
|
2017-04-22 05:30:36 +02:00
|
|
|
SERIAL_ECHOPAIR(" M900 K", planner.extruder_advance_k);
|
|
|
|
SERIAL_ECHOLNPAIR(" R", planner.advance_ed_ratio);
|
2017-04-16 05:18:10 +02:00
|
|
|
#endif
|
2017-06-03 07:38:07 +02:00
|
|
|
|
|
|
|
#if HAS_MOTOR_CURRENT_PWM
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
if (!forReplay) {
|
|
|
|
SERIAL_ECHOLNPGM("Stepper motor currents:");
|
|
|
|
CONFIG_ECHO_START;
|
|
|
|
}
|
|
|
|
SERIAL_ECHOPAIR(" M907 X", stepper.motor_current_setting[0]);
|
|
|
|
SERIAL_ECHOPAIR(" Z", stepper.motor_current_setting[1]);
|
|
|
|
SERIAL_ECHOPAIR(" E", stepper.motor_current_setting[2]);
|
|
|
|
SERIAL_EOL();
|
|
|
|
#endif
|
2016-10-29 01:55:42 +02: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 15:05:11 +01:00
|
|
|
|
2015-01-28 10:08:48 +01:00
|
|
|
#endif // !DISABLE_M503
|