tool_change.cpp File Reference

#include "../inc/MarlinConfigPre.h"
#include "tool_change.h"
#include "probe.h"
#include "motion.h"
#include "planner.h"
#include "temperature.h"
#include "../Marlin.h"
#include "../core/debug_out.h"
#include "servo.h"
#include "../feature/bedlevel/bedlevel.h"

Macros
#define	DEBUG_OUT   ENABLED(DEBUG_LEVELING_FEATURE)

Functions
void	_line_to_current (const AxisEnum fr_axis, const float fscale=1)
void	slow_line_to_current (const AxisEnum fr_axis)
void	fast_line_to_current (const AxisEnum fr_axis)
void	tool_change (const uint8_t new_tool, bool no_move)

Macro Definition Documentation

DEBUG_OUT

#define DEBUG_OUT   ENABLED(DEBUG_LEVELING_FEATURE)

Marlin 3D Printer Firmware Copyright (c) 2019 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/.

Function Documentation

_line_to_current()

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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

slow_line_to_current()

void slow_line_to_current

(

const AxisEnum

fr_axis

)

{ _line_to_current(fr_axis, 0.5f); }

Here is the call graph for this function:

fast_line_to_current()

void fast_line_to_current

(

const AxisEnum

fr_axis

)

{ _line_to_current(fr_axis); }

Here is the call graph for this function:

Here is the caller graph for this function:

tool_change()

void tool_change	(	const uint8_t	new_tool,
		bool	no_move
	)

Perform a tool-change, which may result in moving the previous tool out of the way and the new tool into place.

                                                        {
 
  #if ENABLED(MAGNETIC_SWITCHING_TOOLHEAD)
    if (new_tool == active_extruder) return;
  #endif
 
  #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 ENABLED(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;
 
  #else // EXTRUDERS > 1
 
    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 && dxc_is_duplicating())
         return invalid_extruder_error(new_tool);
    #endif
 
    if (new_tool >= EXTRUDERS)
      return invalid_extruder_error(new_tool);
 
    if (!no_move && !all_axes_homed()) {
      no_move = true;
      if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("No move (not homed)");
    }
 
    #if HAS_LCD_MENU
      ui.return_to_status();
    #endif
 
    #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 ENABLED(TOOLCHANGE_FILAMENT_SWAP)
      const bool should_swap = can_move_away && toolchange_settings.swap_length;
      #if ENABLED(PREVENT_COLD_EXTRUSION)
        const bool too_cold = !DEBUGGING(DRYRUN) && (thermalManager.targetTooColdToExtrude(old_tool) || thermalManager.targetTooColdToExtrude(new_tool));
      #else
        constexpr bool too_cold = false;
      #endif
      if (should_swap) {
        if (too_cold) {
          SERIAL_ECHO_MSG(MSG_ERR_HOTEND_TOO_COLD);
          #if ENABLED(SINGLENOZZLE)
            active_extruder = new_tool;
            return;
          #endif
        }
        else {
          #if ENABLED(ADVANCED_PAUSE_FEATURE)
            do_pause_e_move(-toolchange_settings.swap_length, MMM_TO_MMS(toolchange_settings.retract_speed));
          #else
            current_position.e -= toolchange_settings.swap_length / planner.e_factor[old_tool];
            planner.buffer_line(current_position, MMM_TO_MMS(toolchange_settings.retract_speed), old_tool);
            planner.synchronize();
          #endif
        }
      }
    #endif // TOOLCHANGE_FILAMENT_SWAP
 
    #if HAS_LEVELING
      // Set current position to the physical position
      TEMPORARY_BED_LEVELING_STATE(false);
    #endif
 
    if (new_tool != old_tool) {
 
      #if SWITCHING_NOZZLE_TWO_SERVOS
        raise_nozzle(old_tool);
      #endif
 
      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
 
      destination = current_position;
 
      #if DISABLED(SWITCHING_NOZZLE)
        if (can_move_away) {
          // 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);
          #if ENABLED(TOOLCHANGE_PARK)
            current_position = toolchange_settings.change_point;
          #endif
          planner.buffer_line(current_position, feedrate_mm_s, old_tool);
          planner.synchronize();
        }
      #endif
 
      #if HAS_HOTEND_OFFSET
        xyz_pos_t diff = hotend_offset[new_tool] - hotend_offset[old_tool];
        #if ENABLED(DUAL_X_CARRIAGE)
          diff.x = 0;
        #endif
      #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.
        current_position.z += _MAX(-diff.z, 0.0) + toolchange_settings.z_raise;
        #if HAS_SOFTWARE_ENDSTOPS
          NOMORE(current_position.z, soft_endstop.max.z);
        #endif
        if (!no_move) fast_line_to_current(Z_AXIS);
        move_nozzle_servo(new_tool);
      #endif
 
      #if DISABLED(DUAL_X_CARRIAGE)
        active_extruder = new_tool; // Set the new active extruder
      #endif
 
      // The newly-selected extruder XYZ is actually at...
      if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPAIR("Offset Tool XY 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
      if (safe_to_move && !no_move && IsRunning()) {
 
        #if ENABLED(SINGLENOZZLE)
          #if FAN_COUNT > 0
            singlenozzle_fan_speed[old_tool] = thermalManager.fan_speed[0];
            thermalManager.fan_speed[0] = singlenozzle_fan_speed[new_tool];
          #endif
 
          singlenozzle_temp[old_tool] = thermalManager.temp_hotend[0].target;
          if (singlenozzle_temp[new_tool] && singlenozzle_temp[new_tool] != singlenozzle_temp[old_tool]) {
            thermalManager.setTargetHotend(singlenozzle_temp[new_tool], 0);
            #if HAS_DISPLAY
              thermalManager.set_heating_message(0);
            #endif
            (void)thermalManager.wait_for_hotend(0, false);  // Wait for heating or cooling
          }
        #endif
 
        #if ENABLED(TOOLCHANGE_FILAMENT_SWAP)
          if (should_swap && !too_cold) {
            #if ENABLED(ADVANCED_PAUSE_FEATURE)
              do_pause_e_move(toolchange_settings.swap_length, MMM_TO_MMS(toolchange_settings.prime_speed));
              do_pause_e_move(toolchange_settings.extra_prime, ADVANCED_PAUSE_PURGE_FEEDRATE);
            #else
              current_position.e += toolchange_settings.swap_length / planner.e_factor[new_tool];
              planner.buffer_line(current_position, MMM_TO_MMS(toolchange_settings.prime_speed), new_tool);
              current_position.e += toolchange_settings.extra_prime / planner.e_factor[new_tool];
              planner.buffer_line(current_position, MMM_TO_MMS(toolchange_settings.prime_speed * 0.2f), new_tool);
            #endif
            planner.synchronize();
            planner.set_e_position_mm((destination.e = current_position.e = current_position.e - (TOOLCHANGE_FIL_EXTRA_PRIME)));
          }
        #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
            if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("Move back Z only");
            do_blocking_move_to_z(destination.z, planner.settings.max_feedrate_mm_s[Z_AXIS]);
          #else
            // Move back to the original (or adjusted) position
            if (DEBUGGING(LEVELING)) DEBUG_POS("Move back", destination);
            do_blocking_move_to(destination);
          #endif
        }
        else if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("Move back skipped");
 
        #if ENABLED(DUAL_X_CARRIAGE)
          active_extruder_parked = false;
        #endif
      }
      #if ENABLED(SWITCHING_NOZZLE)
        else {
          // Move back down. (Including when the new tool is higher.)
          do_blocking_move_to_z(destination.z, planner.settings.max_feedrate_mm_s[Z_AXIS]);
        }
      #endif
 
      #if ENABLED(PRUSA_MMU2)
        mmu2.tool_change(new_tool);
      #endif
 
      #if SWITCHING_NOZZLE_TWO_SERVOS
        lower_nozzle(new_tool);
      #endif
 
    } // (new_tool != old_tool)
 
    planner.synchronize();
 
    #if ENABLED(EXT_SOLENOID) && DISABLED(PARKING_EXTRUDER)
      disable_all_solenoids();
      enable_solenoid_on_active_extruder();
    #endif
 
    #if ENABLED(MK2_MULTIPLEXER)
      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
 
    #if HAS_FANMUX
      fanmux_switch(active_extruder);
    #endif
 
    SERIAL_ECHO_START();
    SERIAL_ECHOLNPAIR(MSG_ACTIVE_EXTRUDER, int(active_extruder));
 
  #endif // EXTRUDERS > 1
}

Here is the call graph for this function: