diff options
Diffstat (limited to 'Marlin/src/module/tool_change.cpp')
| -rw-r--r-- | Marlin/src/module/tool_change.cpp | 1296 |
1 files changed, 1296 insertions, 0 deletions
diff --git a/Marlin/src/module/tool_change.cpp b/Marlin/src/module/tool_change.cpp new file mode 100644 index 0000000..4278e6b --- /dev/null +++ b/Marlin/src/module/tool_change.cpp @@ -0,0 +1,1296 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2020 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 <https://www.gnu.org/licenses/>. + * + */ + +#include "../inc/MarlinConfigPre.h" + +#include "tool_change.h" + +#include "probe.h" +#include "motion.h" +#include "planner.h" +#include "temperature.h" + +#include "../MarlinCore.h" + +//#define DEBUG_TOOL_CHANGE + +#define DEBUG_OUT ENABLED(DEBUG_TOOL_CHANGE) +#include "../core/debug_out.h" + +#if HAS_MULTI_EXTRUDER + toolchange_settings_t toolchange_settings; // Initialized by settings.load() +#endif + +#if ENABLED(TOOLCHANGE_MIGRATION_FEATURE) + migration_settings_t migration = migration_defaults; + bool enable_first_prime; +#endif + +#if ENABLED(TOOLCHANGE_FS_INIT_BEFORE_SWAP) + bool toolchange_extruder_ready[EXTRUDERS]; +#endif + +#if ENABLED(MAGNETIC_PARKING_EXTRUDER) || defined(EVENT_GCODE_AFTER_TOOLCHANGE) || (ENABLED(PARKING_EXTRUDER) && PARKING_EXTRUDER_SOLENOIDS_DELAY > 0) + #include "../gcode/gcode.h" +#endif + +#if ENABLED(DUAL_X_CARRIAGE) + #include "stepper.h" +#endif + +#if ANY(SWITCHING_EXTRUDER, SWITCHING_NOZZLE, SWITCHING_TOOLHEAD) + #include "servo.h" +#endif + +#if ENABLED(EXT_SOLENOID) && DISABLED(PARKING_EXTRUDER) + #include "../feature/solenoid.h" +#endif + +#if ENABLED(MIXING_EXTRUDER) + #include "../feature/mixing.h" +#endif + +#if HAS_LEVELING + #include "../feature/bedlevel/bedlevel.h" +#endif + +#if HAS_FANMUX + #include "../feature/fanmux.h" +#endif + +#if HAS_PRUSA_MMU1 + #include "../feature/mmu/mmu.h" +#elif HAS_PRUSA_MMU2 + #include "../feature/mmu/mmu2.h" +#endif + +#if HAS_LCD_MENU + #include "../lcd/marlinui.h" +#endif + +#if ENABLED(ADVANCED_PAUSE_FEATURE) + #include "../feature/pause.h" +#endif + +#if ENABLED(TOOLCHANGE_FILAMENT_SWAP) + #include "../gcode/gcode.h" + #if TOOLCHANGE_FS_WIPE_RETRACT <= 0 + #undef TOOLCHANGE_FS_WIPE_RETRACT + #define TOOLCHANGE_FS_WIPE_RETRACT 0 + #endif +#endif + +#if DO_SWITCH_EXTRUDER + + #if EXTRUDERS > 3 + #define _SERVO_NR(E) ((E) < 2 ? SWITCHING_EXTRUDER_SERVO_NR : SWITCHING_EXTRUDER_E23_SERVO_NR) + #else + #define _SERVO_NR(E) SWITCHING_EXTRUDER_SERVO_NR + #endif + + void move_extruder_servo(const uint8_t e) { + planner.synchronize(); + #if EXTRUDERS & 1 + if (e < EXTRUDERS - 1) + #endif + { + MOVE_SERVO(_SERVO_NR(e), servo_angles[_SERVO_NR(e)][e & 1]); + safe_delay(500); + } + } + +#endif // DO_SWITCH_EXTRUDER + +#if ENABLED(SWITCHING_NOZZLE) + + #if SWITCHING_NOZZLE_TWO_SERVOS + + inline void _move_nozzle_servo(const uint8_t e, const uint8_t angle_index) { + constexpr int8_t sns_index[2] = { SWITCHING_NOZZLE_SERVO_NR, SWITCHING_NOZZLE_E1_SERVO_NR }; + constexpr int16_t sns_angles[2] = SWITCHING_NOZZLE_SERVO_ANGLES; + planner.synchronize(); + MOVE_SERVO(sns_index[e], sns_angles[angle_index]); + safe_delay(500); + } + + void lower_nozzle(const uint8_t e) { _move_nozzle_servo(e, 0); } + void raise_nozzle(const uint8_t e) { _move_nozzle_servo(e, 1); } + + #else + + void move_nozzle_servo(const uint8_t angle_index) { + planner.synchronize(); + MOVE_SERVO(SWITCHING_NOZZLE_SERVO_NR, servo_angles[SWITCHING_NOZZLE_SERVO_NR][angle_index]); + safe_delay(500); + } + + #endif + +#endif // SWITCHING_NOZZLE + +inline void _line_to_current(const AxisEnum fr_axis, const float fscale=1) { + line_to_current_position(planner.settings.max_feedrate_mm_s[fr_axis] * fscale); +} +inline void slow_line_to_current(const AxisEnum fr_axis) { _line_to_current(fr_axis, 0.5f); } +inline void fast_line_to_current(const AxisEnum fr_axis) { _line_to_current(fr_axis); } + +#if ENABLED(MAGNETIC_PARKING_EXTRUDER) + + float parkingposx[2], // M951 R L + parkinggrabdistance, // M951 I + parkingslowspeed, // M951 J + parkinghighspeed, // M951 H + parkingtraveldistance, // M951 D + compensationmultiplier; + + inline void magnetic_parking_extruder_tool_change(const uint8_t new_tool) { + + const float oldx = current_position.x, + grabpos = mpe_settings.parking_xpos[new_tool] + (new_tool ? mpe_settings.grab_distance : -mpe_settings.grab_distance), + offsetcompensation = TERN0(HAS_HOTEND_OFFSET, hotend_offset[active_extruder].x * mpe_settings.compensation_factor); + + if (homing_needed_error(_BV(X_AXIS))) return; + + /** + * Z Lift and Nozzle Offset shift ar defined in caller method to work equal with any Multi Hotend realization + * + * Steps: + * 1. Move high speed to park position of new extruder + * 2. Move to couple position of new extruder (this also discouple the old extruder) + * 3. Move to park position of new extruder + * 4. Move high speed to approach park position of old extruder + * 5. Move to park position of old extruder + * 6. Move to starting position + */ + + // STEP 1 + + current_position.x = mpe_settings.parking_xpos[new_tool] + offsetcompensation; + + DEBUG_ECHOPAIR("(1) Move extruder ", int(new_tool)); + DEBUG_POS(" to new extruder ParkPos", current_position); + + planner.buffer_line(current_position, mpe_settings.fast_feedrate, new_tool); + planner.synchronize(); + + // STEP 2 + + current_position.x = grabpos + offsetcompensation; + + DEBUG_ECHOPAIR("(2) Couple extruder ", int(new_tool)); + DEBUG_POS(" to new extruder GrabPos", current_position); + + planner.buffer_line(current_position, mpe_settings.slow_feedrate, new_tool); + planner.synchronize(); + + // Delay before moving tool, to allow magnetic coupling + gcode.dwell(150); + + // STEP 3 + + current_position.x = mpe_settings.parking_xpos[new_tool] + offsetcompensation; + + DEBUG_ECHOPAIR("(3) Move extruder ", int(new_tool)); + DEBUG_POS(" back to new extruder ParkPos", current_position); + + planner.buffer_line(current_position, mpe_settings.slow_feedrate, new_tool); + planner.synchronize(); + + // STEP 4 + + current_position.x = mpe_settings.parking_xpos[active_extruder] + (active_extruder == 0 ? MPE_TRAVEL_DISTANCE : -MPE_TRAVEL_DISTANCE) + offsetcompensation; + + DEBUG_ECHOPAIR("(4) Move extruder ", int(new_tool)); + DEBUG_POS(" close to old extruder ParkPos", current_position); + + planner.buffer_line(current_position, mpe_settings.fast_feedrate, new_tool); + planner.synchronize(); + + // STEP 5 + + current_position.x = mpe_settings.parking_xpos[active_extruder] + offsetcompensation; + + DEBUG_ECHOPAIR("(5) Park extruder ", int(new_tool)); + DEBUG_POS(" at old extruder ParkPos", current_position); + + planner.buffer_line(current_position, mpe_settings.slow_feedrate, new_tool); + planner.synchronize(); + + // STEP 6 + + current_position.x = oldx; + + DEBUG_ECHOPAIR("(6) Move extruder ", int(new_tool)); + DEBUG_POS(" to starting position", current_position); + + planner.buffer_line(current_position, mpe_settings.fast_feedrate, new_tool); + planner.synchronize(); + + DEBUG_ECHOLNPGM("Autopark done."); + } + +#elif ENABLED(PARKING_EXTRUDER) + + void pe_solenoid_init() { + LOOP_LE_N(n, 1) pe_solenoid_set_pin_state(n, !PARKING_EXTRUDER_SOLENOIDS_PINS_ACTIVE); + } + + void pe_solenoid_set_pin_state(const uint8_t extruder_num, const uint8_t state) { + switch (extruder_num) { + case 1: OUT_WRITE(SOL1_PIN, state); break; + default: OUT_WRITE(SOL0_PIN, state); break; + } + #if PARKING_EXTRUDER_SOLENOIDS_DELAY > 0 + gcode.dwell(PARKING_EXTRUDER_SOLENOIDS_DELAY); + #endif + } + + bool extruder_parked = true, do_solenoid_activation = true; + + // Modifies tool_change() behavior based on homing side + bool parking_extruder_unpark_after_homing(const uint8_t final_tool, bool homed_towards_final_tool) { + do_solenoid_activation = false; // Tell parking_extruder_tool_change to skip solenoid activation + + if (!extruder_parked) return false; // nothing to do + + if (homed_towards_final_tool) { + pe_solenoid_magnet_off(1 - final_tool); + DEBUG_ECHOLNPAIR("Disengage magnet", (int)(1 - final_tool)); + pe_solenoid_magnet_on(final_tool); + DEBUG_ECHOLNPAIR("Engage magnet", (int)final_tool); + parking_extruder_set_parked(false); + return false; + } + + return true; + } + + inline void parking_extruder_tool_change(const uint8_t new_tool, bool no_move) { + if (!no_move) { + + constexpr float parkingposx[] = PARKING_EXTRUDER_PARKING_X; + + #if HAS_HOTEND_OFFSET + const float x_offset = hotend_offset[active_extruder].x; + #else + constexpr float x_offset = 0; + #endif + + const float midpos = (parkingposx[0] + parkingposx[1]) * 0.5f + x_offset, + grabpos = parkingposx[new_tool] + (new_tool ? PARKING_EXTRUDER_GRAB_DISTANCE : -(PARKING_EXTRUDER_GRAB_DISTANCE)) + x_offset; + + /** + * 1. Move to park position of old extruder + * 2. Disengage magnetic field, wait for delay + * 3. Move near new extruder + * 4. Engage magnetic field for new extruder + * 5. Move to parking incl. offset of new extruder + * 6. Lower Z-Axis + */ + + // STEP 1 + + DEBUG_POS("Start PE Tool-Change", current_position); + + // Don't park the active_extruder unless unparked + if (!extruder_parked) { + current_position.x = parkingposx[active_extruder] + x_offset; + + DEBUG_ECHOLNPAIR("(1) Park extruder ", int(active_extruder)); + DEBUG_POS("Moving ParkPos", current_position); + + fast_line_to_current(X_AXIS); + + // STEP 2 + + planner.synchronize(); + DEBUG_ECHOLNPGM("(2) Disengage magnet"); + pe_solenoid_magnet_off(active_extruder); + + // STEP 3 + + current_position.x += active_extruder ? -10 : 10; // move 10mm away from parked extruder + + DEBUG_ECHOLNPGM("(3) Move near new extruder"); + DEBUG_POS("Move away from parked extruder", current_position); + + fast_line_to_current(X_AXIS); + } + + // STEP 4 + + planner.synchronize(); + DEBUG_ECHOLNPGM("(4) Engage magnetic field"); + + // Just save power for inverted magnets + TERN_(PARKING_EXTRUDER_SOLENOIDS_INVERT, pe_solenoid_magnet_on(active_extruder)); + pe_solenoid_magnet_on(new_tool); + + // STEP 5 + + current_position.x = grabpos + (new_tool ? -10 : 10); + fast_line_to_current(X_AXIS); + + current_position.x = grabpos; + + DEBUG_SYNCHRONIZE(); + DEBUG_POS("(5) Unpark extruder", current_position); + + slow_line_to_current(X_AXIS); + + // STEP 6 + + current_position.x = midpos - TERN0(HAS_HOTEND_OFFSET, hotend_offset[new_tool].x); + + DEBUG_SYNCHRONIZE(); + DEBUG_POS("(6) Move midway between hotends", current_position); + + fast_line_to_current(X_AXIS); + planner.synchronize(); // Always sync the final move + + DEBUG_POS("PE Tool-Change done.", current_position); + parking_extruder_set_parked(false); + } + else if (do_solenoid_activation) { // && nomove == true + // Deactivate current extruder solenoid + pe_solenoid_set_pin_state(active_extruder, !PARKING_EXTRUDER_SOLENOIDS_PINS_ACTIVE); + // Engage new extruder magnetic field + pe_solenoid_set_pin_state(new_tool, PARKING_EXTRUDER_SOLENOIDS_PINS_ACTIVE); + } + + do_solenoid_activation = true; // Activate solenoid for subsequent tool_change() + } + +#endif // PARKING_EXTRUDER + +#if ENABLED(SWITCHING_TOOLHEAD) + + inline void swt_lock(const bool locked=true) { + const uint16_t swt_angles[2] = SWITCHING_TOOLHEAD_SERVO_ANGLES; + MOVE_SERVO(SWITCHING_TOOLHEAD_SERVO_NR, swt_angles[locked ? 0 : 1]); + } + + void swt_init() { swt_lock(); } + + inline void switching_toolhead_tool_change(const uint8_t new_tool, bool no_move/*=false*/) { + if (no_move) return; + + constexpr float toolheadposx[] = SWITCHING_TOOLHEAD_X_POS; + const float placexpos = toolheadposx[active_extruder], + grabxpos = toolheadposx[new_tool]; + + /** + * 1. Move to switch position of current toolhead + * 2. Unlock tool and drop it in the dock + * 3. Move to the new toolhead + * 4. Grab and lock the new toolhead + */ + + // 1. Move to switch position of current toolhead + + DEBUG_POS("Start ST Tool-Change", current_position); + + current_position.x = placexpos; + + DEBUG_ECHOLNPAIR("(1) Place old tool ", int(active_extruder)); + DEBUG_POS("Move X SwitchPos", current_position); + + fast_line_to_current(X_AXIS); + + current_position.y = SWITCHING_TOOLHEAD_Y_POS - (SWITCHING_TOOLHEAD_Y_SECURITY); + + DEBUG_SYNCHRONIZE(); + DEBUG_POS("Move Y SwitchPos + Security", current_position); + + fast_line_to_current(Y_AXIS); + + // 2. Unlock tool and drop it in the dock + + planner.synchronize(); + DEBUG_ECHOLNPGM("(2) Unlock and Place Toolhead"); + swt_lock(false); + safe_delay(500); + + current_position.y = SWITCHING_TOOLHEAD_Y_POS; + DEBUG_POS("Move Y SwitchPos", current_position); + slow_line_to_current(Y_AXIS); + + // Wait for move to complete, then another 0.2s + planner.synchronize(); + safe_delay(200); + + current_position.y -= SWITCHING_TOOLHEAD_Y_CLEAR; + DEBUG_POS("Move back Y clear", current_position); + fast_line_to_current(Y_AXIS); // move away from docked toolhead + + // 3. Move to the new toolhead + + current_position.x = grabxpos; + + DEBUG_SYNCHRONIZE(); + DEBUG_ECHOLNPGM("(3) Move to new toolhead position"); + DEBUG_POS("Move to new toolhead X", current_position); + + fast_line_to_current(X_AXIS); + + current_position.y = SWITCHING_TOOLHEAD_Y_POS - (SWITCHING_TOOLHEAD_Y_SECURITY); + + DEBUG_SYNCHRONIZE(); + DEBUG_POS("Move Y SwitchPos + Security", current_position); + + fast_line_to_current(Y_AXIS); + + // 4. Grab and lock the new toolhead + + current_position.y = SWITCHING_TOOLHEAD_Y_POS; + + DEBUG_SYNCHRONIZE(); + DEBUG_ECHOLNPGM("(4) Grab and lock new toolhead"); + DEBUG_POS("Move Y SwitchPos", current_position); + + slow_line_to_current(Y_AXIS); + + // Wait for move to finish, pause 0.2s, move servo, pause 0.5s + planner.synchronize(); + safe_delay(200); + swt_lock(); + safe_delay(500); + + current_position.y -= SWITCHING_TOOLHEAD_Y_CLEAR; + DEBUG_POS("Move back Y clear", current_position); + fast_line_to_current(Y_AXIS); // Move away from docked toolhead + planner.synchronize(); // Always sync the final move + + DEBUG_POS("ST Tool-Change done.", current_position); + } + +#elif ENABLED(MAGNETIC_SWITCHING_TOOLHEAD) + + inline void magnetic_switching_toolhead_tool_change(const uint8_t new_tool, bool no_move/*=false*/) { + if (no_move) return; + + constexpr float toolheadposx[] = SWITCHING_TOOLHEAD_X_POS, + toolheadclearx[] = SWITCHING_TOOLHEAD_X_SECURITY; + + const float placexpos = toolheadposx[active_extruder], + placexclear = toolheadclearx[active_extruder], + grabxpos = toolheadposx[new_tool], + grabxclear = toolheadclearx[new_tool]; + + /** + * 1. Move to switch position of current toolhead + * 2. Release and place toolhead in the dock + * 3. Move to the new toolhead + * 4. Grab the new toolhead and move to security position + */ + + DEBUG_POS("Start MST Tool-Change", current_position); + + // 1. Move to switch position current toolhead + + current_position.y = SWITCHING_TOOLHEAD_Y_POS + SWITCHING_TOOLHEAD_Y_CLEAR; + + SERIAL_ECHOLNPAIR("(1) Place old tool ", int(active_extruder)); + DEBUG_POS("Move Y SwitchPos + Security", current_position); + + fast_line_to_current(Y_AXIS); + + current_position.x = placexclear; + + DEBUG_SYNCHRONIZE(); + DEBUG_POS("Move X SwitchPos + Security", current_position); + + fast_line_to_current(X_AXIS); + + current_position.y = SWITCHING_TOOLHEAD_Y_POS; + + DEBUG_SYNCHRONIZE(); + DEBUG_POS("Move Y SwitchPos", current_position); + + fast_line_to_current(Y_AXIS); + + current_position.x = placexpos; + + DEBUG_SYNCHRONIZE(); + DEBUG_POS("Move X SwitchPos", current_position); + + line_to_current_position(planner.settings.max_feedrate_mm_s[X_AXIS] * 0.25f); + + // 2. Release and place toolhead in the dock + + DEBUG_SYNCHRONIZE(); + DEBUG_ECHOLNPGM("(2) Release and Place Toolhead"); + + current_position.y = SWITCHING_TOOLHEAD_Y_POS + SWITCHING_TOOLHEAD_Y_RELEASE; + DEBUG_POS("Move Y SwitchPos + Release", current_position); + line_to_current_position(planner.settings.max_feedrate_mm_s[Y_AXIS] * 0.1f); + + current_position.y = SWITCHING_TOOLHEAD_Y_POS + SWITCHING_TOOLHEAD_Y_SECURITY; + + DEBUG_SYNCHRONIZE(); + DEBUG_POS("Move Y SwitchPos + Security", current_position); + + line_to_current_position(planner.settings.max_feedrate_mm_s[Y_AXIS]); + + // 3. Move to new toolhead position + + DEBUG_SYNCHRONIZE(); + DEBUG_ECHOLNPGM("(3) Move to new toolhead position"); + + current_position.x = grabxpos; + DEBUG_POS("Move to new toolhead X", current_position); + fast_line_to_current(X_AXIS); + + // 4. Grab the new toolhead and move to security position + + DEBUG_SYNCHRONIZE(); + DEBUG_ECHOLNPGM("(4) Grab new toolhead, move to security position"); + + current_position.y = SWITCHING_TOOLHEAD_Y_POS + SWITCHING_TOOLHEAD_Y_RELEASE; + DEBUG_POS("Move Y SwitchPos + Release", current_position); + line_to_current_position(planner.settings.max_feedrate_mm_s[Y_AXIS]); + + current_position.y = SWITCHING_TOOLHEAD_Y_POS; + + DEBUG_SYNCHRONIZE(); + DEBUG_POS("Move Y SwitchPos", current_position); + + _line_to_current(Y_AXIS, 0.2f); + + #if ENABLED(PRIME_BEFORE_REMOVE) && (SWITCHING_TOOLHEAD_PRIME_MM || SWITCHING_TOOLHEAD_RETRACT_MM) + #if SWITCHING_TOOLHEAD_PRIME_MM + current_position.e += SWITCHING_TOOLHEAD_PRIME_MM; + planner.buffer_line(current_position, MMM_TO_MMS(SWITCHING_TOOLHEAD_PRIME_FEEDRATE), new_tool); + #endif + #if SWITCHING_TOOLHEAD_RETRACT_MM + current_position.e -= SWITCHING_TOOLHEAD_RETRACT_MM; + planner.buffer_line(current_position, MMM_TO_MMS(SWITCHING_TOOLHEAD_RETRACT_FEEDRATE), new_tool); + #endif + #else + planner.synchronize(); + safe_delay(100); // Give switch time to settle + #endif + + current_position.x = grabxclear; + DEBUG_POS("Move to new toolhead X + Security", current_position); + _line_to_current(X_AXIS, 0.1f); + planner.synchronize(); + safe_delay(100); // Give switch time to settle + + current_position.y += SWITCHING_TOOLHEAD_Y_CLEAR; + DEBUG_POS("Move back Y clear", current_position); + fast_line_to_current(Y_AXIS); // move away from docked toolhead + planner.synchronize(); // Always sync last tool-change move + + DEBUG_POS("MST Tool-Change done.", current_position); + } + +#elif ENABLED(ELECTROMAGNETIC_SWITCHING_TOOLHEAD) + + inline void est_activate_solenoid() { OUT_WRITE(SOL0_PIN, HIGH); } + inline void est_deactivate_solenoid() { OUT_WRITE(SOL0_PIN, LOW); } + void est_init() { est_activate_solenoid(); } + + inline void em_switching_toolhead_tool_change(const uint8_t new_tool, bool no_move) { + if (no_move) return; + + constexpr float toolheadposx[] = SWITCHING_TOOLHEAD_X_POS; + const float placexpos = toolheadposx[active_extruder], + grabxpos = toolheadposx[new_tool]; + const xyz_pos_t &hoffs = hotend_offset[active_extruder]; + + /** + * 1. Raise Z-Axis to give enough clearance + * 2. Move to position near active extruder parking + * 3. Move gently to park position of active extruder + * 4. Disengage magnetic field, wait for delay + * 5. Leave extruder and move to position near new extruder parking + * 6. Move gently to park position of new extruder + * 7. Engage magnetic field for new extruder parking + * 8. Unpark extruder + * 9. Apply Z hotend offset to current position + */ + + DEBUG_POS("Start EMST Tool-Change", current_position); + + // 1. Raise Z-Axis to give enough clearance + + current_position.z += SWITCHING_TOOLHEAD_Z_HOP; + DEBUG_POS("(1) Raise Z-Axis ", current_position); + fast_line_to_current(Z_AXIS); + + // 2. Move to position near active extruder parking + + DEBUG_SYNCHRONIZE(); + DEBUG_ECHOLNPAIR("(2) Move near active extruder parking", active_extruder); + DEBUG_POS("Moving ParkPos", current_position); + + current_position.set(hoffs.x + placexpos, + hoffs.y + SWITCHING_TOOLHEAD_Y_POS + SWITCHING_TOOLHEAD_Y_CLEAR); + fast_line_to_current(X_AXIS); + + // 3. Move gently to park position of active extruder + + DEBUG_SYNCHRONIZE(); + SERIAL_ECHOLNPAIR("(3) Move gently to park position of active extruder", active_extruder); + DEBUG_POS("Moving ParkPos", current_position); + + current_position.y -= SWITCHING_TOOLHEAD_Y_CLEAR; + slow_line_to_current(Y_AXIS); + + // 4. Disengage magnetic field, wait for delay + + planner.synchronize(); + DEBUG_ECHOLNPGM("(4) Disengage magnet"); + est_deactivate_solenoid(); + + // 5. Leave extruder and move to position near new extruder parking + + DEBUG_ECHOLNPGM("(5) Move near new extruder parking"); + DEBUG_POS("Moving ParkPos", current_position); + + current_position.y += SWITCHING_TOOLHEAD_Y_CLEAR; + slow_line_to_current(Y_AXIS); + current_position.set(hoffs.x + grabxpos, + hoffs.y + SWITCHING_TOOLHEAD_Y_POS + SWITCHING_TOOLHEAD_Y_CLEAR); + fast_line_to_current(X_AXIS); + + // 6. Move gently to park position of new extruder + + current_position.y -= SWITCHING_TOOLHEAD_Y_CLEAR; + if (DEBUGGING(LEVELING)) { + planner.synchronize(); + DEBUG_ECHOLNPGM("(6) Move near new extruder"); + } + slow_line_to_current(Y_AXIS); + + // 7. Engage magnetic field for new extruder parking + + DEBUG_SYNCHRONIZE(); + DEBUG_ECHOLNPGM("(7) Engage magnetic field"); + est_activate_solenoid(); + + // 8. Unpark extruder + + current_position.y += SWITCHING_TOOLHEAD_Y_CLEAR; + DEBUG_ECHOLNPGM("(8) Unpark extruder"); + slow_line_to_current(X_AXIS); + planner.synchronize(); // Always sync the final move + + // 9. Apply Z hotend offset to current position + + DEBUG_POS("(9) Applying Z-offset", current_position); + current_position.z += hoffs.z - hotend_offset[new_tool].z; + + DEBUG_POS("EMST Tool-Change done.", current_position); + } + +#endif // ELECTROMAGNETIC_SWITCHING_TOOLHEAD + +#if EXTRUDERS + inline void invalid_extruder_error(const uint8_t e) { + SERIAL_ECHO_START(); + SERIAL_CHAR('T'); SERIAL_ECHO((int)e); + SERIAL_CHAR(' '); SERIAL_ECHOLNPGM(STR_INVALID_EXTRUDER); + } +#endif + +#if ENABLED(DUAL_X_CARRIAGE) + + /** + * @brief Dual X Tool Change + * @details Change tools, with extra behavior based on current mode + * + * @param new_tool Tool index to activate + * @param no_move Flag indicating no moves should take place + */ + inline void dualx_tool_change(const uint8_t new_tool, bool &no_move) { + + DEBUG_ECHOPGM("Dual X Carriage Mode "); + switch (dual_x_carriage_mode) { + case DXC_FULL_CONTROL_MODE: DEBUG_ECHOLNPGM("FULL_CONTROL"); break; + case DXC_AUTO_PARK_MODE: DEBUG_ECHOLNPGM("AUTO_PARK"); break; + case DXC_DUPLICATION_MODE: DEBUG_ECHOLNPGM("DUPLICATION"); break; + case DXC_MIRRORED_MODE: DEBUG_ECHOLNPGM("MIRRORED"); break; + } + + // Get the home position of the currently-active tool + const float xhome = x_home_pos(active_extruder); + + if (dual_x_carriage_mode == DXC_AUTO_PARK_MODE // If Auto-Park mode is enabled + && IsRunning() && !no_move // ...and movement is permitted + && (delayed_move_time || current_position.x != xhome) // ...and delayed_move_time is set OR not "already parked"... + ) { + DEBUG_ECHOLNPAIR("MoveX to ", xhome); + current_position.x = xhome; + line_to_current_position(planner.settings.max_feedrate_mm_s[X_AXIS]); // Park the current head + planner.synchronize(); + } + + // Activate the new extruder ahead of calling set_axis_is_at_home! + active_extruder = new_tool; + + // This function resets the max/min values - the current position may be overwritten below. + set_axis_is_at_home(X_AXIS); + + DEBUG_POS("New Extruder", current_position); + + switch (dual_x_carriage_mode) { + case DXC_FULL_CONTROL_MODE: + // New current position is the position of the activated extruder + current_position.x = inactive_extruder_x; + // Save the inactive extruder's position (from the old current_position) + inactive_extruder_x = destination.x; + DEBUG_ECHOLNPAIR("DXC Full Control curr.x=", current_position.x, " dest.x=", destination.x); + break; + case DXC_AUTO_PARK_MODE: + idex_set_parked(); + break; + default: + break; + } + + // Ensure X axis DIR pertains to the correct carriage + stepper.set_directions(); + + DEBUG_ECHOLNPAIR("Active extruder parked: ", active_extruder_parked ? "yes" : "no"); + DEBUG_POS("New extruder (parked)", current_position); + } + +#endif // DUAL_X_CARRIAGE + +/** + * Prime active tool using TOOLCHANGE_FILAMENT_SWAP settings + */ +#if ENABLED(TOOLCHANGE_FILAMENT_SWAP) + + void tool_change_prime() { + if (toolchange_settings.extra_prime > 0 + && TERN(PREVENT_COLD_EXTRUSION, !thermalManager.targetTooColdToExtrude(active_extruder), 1) + ) { + destination = current_position; // Remember the old position + + const bool ok = TERN1(TOOLCHANGE_PARK, all_axes_homed() && toolchange_settings.enable_park); + + #if HAS_FAN && TOOLCHANGE_FS_FAN >= 0 + // Store and stop fan. Restored on any exit. + REMEMBER(fan, thermalManager.fan_speed[TOOLCHANGE_FS_FAN], 0); + #endif + + // Z raise + if (ok) { + // Do a small lift to avoid the workpiece in the move back (below) + current_position.z += toolchange_settings.z_raise; + #if HAS_SOFTWARE_ENDSTOPS + NOMORE(current_position.z, soft_endstop.max.z); + #endif + fast_line_to_current(Z_AXIS); + planner.synchronize(); + } + + // Park + #if ENABLED(TOOLCHANGE_PARK) + if (ok) { + IF_DISABLED(TOOLCHANGE_PARK_Y_ONLY, current_position.x = toolchange_settings.change_point.x); + IF_DISABLED(TOOLCHANGE_PARK_X_ONLY, current_position.y = toolchange_settings.change_point.y); + planner.buffer_line(current_position, MMM_TO_MMS(TOOLCHANGE_PARK_XY_FEEDRATE), active_extruder); + planner.synchronize(); + } + #endif + + // Prime (All distances are added and slowed down to ensure secure priming in all circumstances) + unscaled_e_move(toolchange_settings.swap_length + toolchange_settings.extra_prime, MMM_TO_MMS(toolchange_settings.prime_speed)); + + // Cutting retraction + #if TOOLCHANGE_FS_WIPE_RETRACT + unscaled_e_move(-(TOOLCHANGE_FS_WIPE_RETRACT), MMM_TO_MMS(toolchange_settings.retract_speed)); + #endif + + // Cool down with fan + #if HAS_FAN && TOOLCHANGE_FS_FAN >= 0 + thermalManager.fan_speed[TOOLCHANGE_FS_FAN] = toolchange_settings.fan_speed; + gcode.dwell(SEC_TO_MS(toolchange_settings.fan_time)); + thermalManager.fan_speed[TOOLCHANGE_FS_FAN] = 0; + #endif + + // Move back + #if ENABLED(TOOLCHANGE_PARK) + if (ok) { + #if ENABLED(TOOLCHANGE_NO_RETURN) + do_blocking_move_to_z(destination.z, planner.settings.max_feedrate_mm_s[Z_AXIS]); + #else + do_blocking_move_to(destination, MMM_TO_MMS(TOOLCHANGE_PARK_XY_FEEDRATE)); + #endif + } + #endif + + // Cutting recover + unscaled_e_move(toolchange_settings.extra_resume + TOOLCHANGE_FS_WIPE_RETRACT, MMM_TO_MMS(toolchange_settings.unretract_speed)); + + planner.synchronize(); + current_position.e = destination.e; + sync_plan_position_e(); // Resume at the old E position + } + } + +#endif // TOOLCHANGE_FILAMENT_SWAP + +/** + * Perform a tool-change, which may result in moving the + * previous tool out of the way and the new tool into place. + */ +void tool_change(const uint8_t new_tool, bool no_move/*=false*/) { + + if (TERN0(MAGNETIC_SWITCHING_TOOLHEAD, new_tool == active_extruder)) + return; + + #if ENABLED(MIXING_EXTRUDER) + + UNUSED(no_move); + + if (new_tool >= MIXING_VIRTUAL_TOOLS) + return invalid_extruder_error(new_tool); + + #if MIXING_VIRTUAL_TOOLS > 1 + // T0-Tnnn: Switch virtual tool by changing the index to the mix + mixer.T(new_tool); + #endif + + #elif HAS_PRUSA_MMU2 + + UNUSED(no_move); + + mmu2.tool_change(new_tool); + + #elif EXTRUDERS == 0 + + // Nothing to do + UNUSED(new_tool); UNUSED(no_move); + + #elif EXTRUDERS < 2 + + UNUSED(no_move); + + if (new_tool) invalid_extruder_error(new_tool); + return; + + #elif HAS_MULTI_EXTRUDER + + planner.synchronize(); + + #if ENABLED(DUAL_X_CARRIAGE) // Only T0 allowed if the Printer is in DXC_DUPLICATION_MODE or DXC_MIRRORED_MODE + if (new_tool != 0 && idex_is_duplicating()) + return invalid_extruder_error(new_tool); + #endif + + if (new_tool >= EXTRUDERS) + return invalid_extruder_error(new_tool); + + if (!no_move && homing_needed()) { + no_move = true; + DEBUG_ECHOLNPGM("No move (not homed)"); + } + + TERN_(HAS_LCD_MENU, if (!no_move) ui.update()); + + #if ENABLED(DUAL_X_CARRIAGE) + const bool idex_full_control = dual_x_carriage_mode == DXC_FULL_CONTROL_MODE; + #else + constexpr bool idex_full_control = false; + #endif + + const uint8_t old_tool = active_extruder; + const bool can_move_away = !no_move && !idex_full_control; + + #if HAS_LEVELING + // Set current position to the physical position + TEMPORARY_BED_LEVELING_STATE(false); + #endif + + // First tool priming. To prime again, reboot the machine. + #if BOTH(TOOLCHANGE_FILAMENT_SWAP, TOOLCHANGE_FS_PRIME_FIRST_USED) + static bool first_tool_is_primed = false; + if (new_tool == old_tool && !first_tool_is_primed && enable_first_prime) { + tool_change_prime(); + first_tool_is_primed = true; + toolchange_extruder_ready[old_tool] = true; // Primed and initialized + } + #endif + + if (new_tool != old_tool || TERN0(PARKING_EXTRUDER, extruder_parked)) { // PARKING_EXTRUDER may need to attach old_tool when homing + destination = current_position; + + #if BOTH(TOOLCHANGE_FILAMENT_SWAP, HAS_FAN) && TOOLCHANGE_FS_FAN >= 0 + // Store and stop fan. Restored on any exit. + REMEMBER(fan, thermalManager.fan_speed[TOOLCHANGE_FS_FAN], 0); + #endif + + // Z raise before retraction + #if ENABLED(TOOLCHANGE_ZRAISE_BEFORE_RETRACT) && DISABLED(SWITCHING_NOZZLE) + if (can_move_away && TERN1(TOOLCHANGE_PARK, toolchange_settings.enable_park)) { + // Do a small lift to avoid the workpiece in the move back (below) + current_position.z += toolchange_settings.z_raise; + #if HAS_SOFTWARE_ENDSTOPS + NOMORE(current_position.z, soft_endstop.max.z); + #endif + fast_line_to_current(Z_AXIS); + planner.synchronize(); + } + #endif + + // Unload / Retract + #if ENABLED(TOOLCHANGE_FILAMENT_SWAP) + const bool should_swap = can_move_away && toolchange_settings.swap_length, + too_cold = TERN0(PREVENT_COLD_EXTRUSION, + !DEBUGGING(DRYRUN) && (thermalManager.targetTooColdToExtrude(old_tool) || thermalManager.targetTooColdToExtrude(new_tool)) + ); + if (should_swap) { + if (too_cold) { + SERIAL_ECHO_MSG(STR_ERR_HOTEND_TOO_COLD); + if (ENABLED(SINGLENOZZLE)) { active_extruder = new_tool; return; } + } + else { + #if ENABLED(TOOLCHANGE_FS_PRIME_FIRST_USED) + // For first new tool, change without unloading the old. 'Just prime/init the new' + if (first_tool_is_primed) + unscaled_e_move(-toolchange_settings.swap_length, MMM_TO_MMS(toolchange_settings.retract_speed)); + first_tool_is_primed = true; // The first new tool will be primed by toolchanging + #endif + } + } + #endif + + TERN_(SWITCHING_NOZZLE_TWO_SERVOS, raise_nozzle(old_tool)); + + REMEMBER(fr, feedrate_mm_s, XY_PROBE_FEEDRATE_MM_S); + + #if HAS_SOFTWARE_ENDSTOPS + #if HAS_HOTEND_OFFSET + #define _EXT_ARGS , old_tool, new_tool + #else + #define _EXT_ARGS + #endif + update_software_endstops(X_AXIS _EXT_ARGS); + #if DISABLED(DUAL_X_CARRIAGE) + update_software_endstops(Y_AXIS _EXT_ARGS); + update_software_endstops(Z_AXIS _EXT_ARGS); + #endif + #endif + + #if DISABLED(TOOLCHANGE_ZRAISE_BEFORE_RETRACT) && DISABLED(SWITCHING_NOZZLE) + if (can_move_away && TERN1(TOOLCHANGE_PARK, toolchange_settings.enable_park)) { + // Do a small lift to avoid the workpiece in the move back (below) + current_position.z += toolchange_settings.z_raise; + #if HAS_SOFTWARE_ENDSTOPS + NOMORE(current_position.z, soft_endstop.max.z); + #endif + fast_line_to_current(Z_AXIS); + } + #endif + + // Toolchange park + #if ENABLED(TOOLCHANGE_PARK) && DISABLED(SWITCHING_NOZZLE) + if (can_move_away && toolchange_settings.enable_park) { + IF_DISABLED(TOOLCHANGE_PARK_Y_ONLY, current_position.x = toolchange_settings.change_point.x); + IF_DISABLED(TOOLCHANGE_PARK_X_ONLY, current_position.y = toolchange_settings.change_point.y); + planner.buffer_line(current_position, MMM_TO_MMS(TOOLCHANGE_PARK_XY_FEEDRATE), old_tool); + planner.synchronize(); + } + #endif + + #if HAS_HOTEND_OFFSET + xyz_pos_t diff = hotend_offset[new_tool] - hotend_offset[old_tool]; + TERN_(DUAL_X_CARRIAGE, diff.x = 0); + #else + constexpr xyz_pos_t diff{0}; + #endif + + #if ENABLED(DUAL_X_CARRIAGE) + dualx_tool_change(new_tool, no_move); + #elif ENABLED(PARKING_EXTRUDER) // Dual Parking extruder + parking_extruder_tool_change(new_tool, no_move); + #elif ENABLED(MAGNETIC_PARKING_EXTRUDER) // Magnetic Parking extruder + magnetic_parking_extruder_tool_change(new_tool); + #elif ENABLED(SWITCHING_TOOLHEAD) // Switching Toolhead + switching_toolhead_tool_change(new_tool, no_move); + #elif ENABLED(MAGNETIC_SWITCHING_TOOLHEAD) // Magnetic Switching Toolhead + magnetic_switching_toolhead_tool_change(new_tool, no_move); + #elif ENABLED(ELECTROMAGNETIC_SWITCHING_TOOLHEAD) // Magnetic Switching ToolChanger + em_switching_toolhead_tool_change(new_tool, no_move); + #elif ENABLED(SWITCHING_NOZZLE) && !SWITCHING_NOZZLE_TWO_SERVOS // Switching Nozzle (single servo) + // Raise by a configured distance to avoid workpiece, except with + // SWITCHING_NOZZLE_TWO_SERVOS, as both nozzles will lift instead. + if (!no_move) { + const float newz = current_position.z + _MAX(-diff.z, 0.0); + + // Check if Z has space to compensate at least z_offset, and if not, just abort now + const float maxz = _MIN(TERN(HAS_SOFTWARE_ENDSTOPS, soft_endstop.max.z, Z_MAX_POS), Z_MAX_POS); + if (newz > maxz) return; + + current_position.z = _MIN(newz + toolchange_settings.z_raise, maxz); + fast_line_to_current(Z_AXIS); + } + move_nozzle_servo(new_tool); + #endif + + // Set the new active extruder + if (DISABLED(DUAL_X_CARRIAGE)) active_extruder = new_tool; + + // The newly-selected extruder XYZ is actually at... + DEBUG_ECHOLNPAIR("Offset Tool XYZ by { ", diff.x, ", ", diff.y, ", ", diff.z, " }"); + current_position += diff; + + // Tell the planner the new "current position" + sync_plan_position(); + + #if ENABLED(DELTA) + //LOOP_XYZ(i) update_software_endstops(i); // or modify the constrain function + const bool safe_to_move = current_position.z < delta_clip_start_height - 1; + #else + constexpr bool safe_to_move = true; + #endif + + // Return to position and lower again + const bool should_move = safe_to_move && !no_move && IsRunning(); + if (should_move) { + + TERN_(SINGLENOZZLE_STANDBY_TEMP, thermalManager.singlenozzle_change(old_tool, new_tool)); + + #if ENABLED(TOOLCHANGE_FILAMENT_SWAP) + if (should_swap && !too_cold) { + + float fr = toolchange_settings.unretract_speed; + + #if ENABLED(TOOLCHANGE_FS_INIT_BEFORE_SWAP) + if (!toolchange_extruder_ready[new_tool]) { + toolchange_extruder_ready[new_tool] = true; + fr = toolchange_settings.prime_speed; // Next move is a prime + unscaled_e_move(0, MMM_TO_MMS(fr)); // Init planner with 0 length move + } + #endif + + // Unretract (or Prime) + unscaled_e_move(toolchange_settings.swap_length, MMM_TO_MMS(fr)); + + // Extra Prime + unscaled_e_move(toolchange_settings.extra_prime, MMM_TO_MMS(toolchange_settings.prime_speed)); + + // Cutting retraction + #if TOOLCHANGE_FS_WIPE_RETRACT + unscaled_e_move(-(TOOLCHANGE_FS_WIPE_RETRACT), MMM_TO_MMS(toolchange_settings.retract_speed)); + #endif + + // Cool down with fan + #if HAS_FAN && TOOLCHANGE_FS_FAN >= 0 + thermalManager.fan_speed[TOOLCHANGE_FS_FAN] = toolchange_settings.fan_speed; + gcode.dwell(SEC_TO_MS(toolchange_settings.fan_time)); + thermalManager.fan_speed[TOOLCHANGE_FS_FAN] = 0; + #endif + } + #endif + + // Prevent a move outside physical bounds + #if ENABLED(MAGNETIC_SWITCHING_TOOLHEAD) + // If the original position is within tool store area, go to X origin at once + if (destination.y < SWITCHING_TOOLHEAD_Y_POS + SWITCHING_TOOLHEAD_Y_CLEAR) { + current_position.x = 0; + planner.buffer_line(current_position, planner.settings.max_feedrate_mm_s[X_AXIS], new_tool); + planner.synchronize(); + } + #else + apply_motion_limits(destination); + #endif + + // Should the nozzle move back to the old position? + if (can_move_away) { + #if ENABLED(TOOLCHANGE_NO_RETURN) + // Just move back down + DEBUG_ECHOLNPGM("Move back Z only"); + + if (TERN1(TOOLCHANGE_PARK, toolchange_settings.enable_park)) + do_blocking_move_to_z(destination.z, planner.settings.max_feedrate_mm_s[Z_AXIS]); + + #else + // Move back to the original (or adjusted) position + DEBUG_POS("Move back", destination); + + #if ENABLED(TOOLCHANGE_PARK) + if (toolchange_settings.enable_park) do_blocking_move_to_xy_z(destination, destination.z, MMM_TO_MMS(TOOLCHANGE_PARK_XY_FEEDRATE)); + #else + do_blocking_move_to_xy(destination, planner.settings.max_feedrate_mm_s[X_AXIS]); + do_blocking_move_to_z(destination.z, planner.settings.max_feedrate_mm_s[Z_AXIS]); + #endif + + #endif + } + + else DEBUG_ECHOLNPGM("Move back skipped"); + + #if ENABLED(TOOLCHANGE_FILAMENT_SWAP) + if (should_swap && !too_cold) { + // Cutting recover + unscaled_e_move(toolchange_settings.extra_resume + TOOLCHANGE_FS_WIPE_RETRACT, MMM_TO_MMS(toolchange_settings.unretract_speed)); + current_position.e = 0; + sync_plan_position_e(); // New extruder primed and set to 0 + + // Restart Fan + #if HAS_FAN && TOOLCHANGE_FS_FAN >= 0 + RESTORE(fan); + #endif + } + #endif + + TERN_(DUAL_X_CARRIAGE, idex_set_parked(false)); + } + + #if ENABLED(SWITCHING_NOZZLE) + // Move back down. (Including when the new tool is higher.) + if (!should_move) + do_blocking_move_to_z(destination.z, planner.settings.max_feedrate_mm_s[Z_AXIS]); + #endif + + TERN_(SWITCHING_NOZZLE_TWO_SERVOS, lower_nozzle(new_tool)); + + } // (new_tool != old_tool) + + planner.synchronize(); + + #if ENABLED(EXT_SOLENOID) && DISABLED(PARKING_EXTRUDER) + disable_all_solenoids(); + enable_solenoid_on_active_extruder(); + #endif + + #if HAS_PRUSA_MMU1 + if (new_tool >= E_STEPPERS) return invalid_extruder_error(new_tool); + select_multiplexed_stepper(new_tool); + #endif + + #if DO_SWITCH_EXTRUDER + planner.synchronize(); + move_extruder_servo(active_extruder); + #endif + + TERN_(HAS_FANMUX, fanmux_switch(active_extruder)); + + #ifdef EVENT_GCODE_AFTER_TOOLCHANGE + if (!no_move && TERN1(DUAL_X_CARRIAGE, dual_x_carriage_mode == DXC_AUTO_PARK_MODE)) + gcode.process_subcommands_now_P(PSTR(EVENT_GCODE_AFTER_TOOLCHANGE)); + #endif + + SERIAL_ECHO_START(); + SERIAL_ECHOLNPAIR(STR_ACTIVE_EXTRUDER, int(active_extruder)); + + #endif // HAS_MULTI_EXTRUDER +} + +#if ENABLED(TOOLCHANGE_MIGRATION_FEATURE) + + #define DEBUG_OUT ENABLED(DEBUG_TOOLCHANGE_MIGRATION_FEATURE) + #include "../core/debug_out.h" + + bool extruder_migration() { + + #if ENABLED(PREVENT_COLD_EXTRUSION) + if (thermalManager.targetTooColdToExtrude(active_extruder)) { + DEBUG_ECHOLNPGM("Migration Source Too Cold"); + return false; + } + #endif + + // No auto-migration or specified target? + if (!migration.target && active_extruder >= migration.last) { + DEBUG_ECHO_MSG("No Migration Target"); + DEBUG_ECHO_MSG("Target: ", migration.target, " Last: ", migration.last, " Active: ", active_extruder); + migration.automode = false; + return false; + } + + // Migrate to a target or the next extruder + + uint8_t migration_extruder = active_extruder; + + if (migration.target) { + DEBUG_ECHOLNPGM("Migration using fixed target"); + // Specified target ok? + const int16_t t = migration.target - 1; + if (t != active_extruder) migration_extruder = t; + } + else if (migration.automode && migration_extruder < migration.last && migration_extruder < EXTRUDERS - 1) + migration_extruder++; + + if (migration_extruder == active_extruder) { + DEBUG_ECHOLNPGM("Migration source matches active"); + return false; + } + + // Migration begins + DEBUG_ECHOLNPGM("Beginning migration"); + + migration.in_progress = true; // Prevent runout script + planner.synchronize(); + + // Remember position before migration + const float resume_current_e = current_position.e; + + // Migrate the flow + planner.set_flow(migration_extruder, planner.flow_percentage[active_extruder]); + + // Migrate the retracted state + #if ENABLED(FWRETRACT) + fwretract.retracted[migration_extruder] = fwretract.retracted[active_extruder]; + #endif + + // Migrate the temperature to the new hotend + #if HAS_MULTI_HOTEND + thermalManager.setTargetHotend(thermalManager.temp_hotend[active_extruder].target, migration_extruder); + TERN_(AUTOTEMP, planner.autotemp_update()); + TERN_(HAS_DISPLAY, thermalManager.set_heating_message(0)); + thermalManager.wait_for_hotend(active_extruder); + #endif + + // Migrate Linear Advance K factor to the new extruder + TERN_(LIN_ADVANCE, planner.extruder_advance_K[active_extruder] = planner.extruder_advance_K[migration_extruder]); + + // Perform the tool change + tool_change(migration_extruder); + + // Retract if previously retracted + #if ENABLED(FWRETRACT) + if (fwretract.retracted[active_extruder]) + unscaled_e_move(-fwretract.settings.retract_length, fwretract.settings.retract_feedrate_mm_s); + #endif + + // If no available extruder + if (EXTRUDERS < 2 || active_extruder >= EXTRUDERS - 2 || active_extruder == migration.last) + migration.automode = false; + + migration.in_progress = false; + + current_position.e = resume_current_e; + + planner.synchronize(); + planner.set_e_position_mm(current_position.e); // New extruder primed and ready + DEBUG_ECHOLNPGM("Migration Complete"); + return true; + } + +#endif // TOOLCHANGE_MIGRATION_FEATURE |