motion.cpp File Reference

#include "motion.h"
#include "endstops.h"
#include "stepper.h"
#include "planner.h"
#include "temperature.h"
#include "../gcode/gcode.h"
#include "../inc/MarlinConfig.h"
#include "../feature/bedlevel/bedlevel.h"
#include "../core/debug_out.h"

Macros
#define	DEBUG_OUT   ENABLED(DEBUG_LEVELING_FEATURE)
#define	XYZ_CONSTS(T, NAME, OPT)   const PROGMEM XYZval<T> NAME##_P = { X_##OPT, Y_##OPT, Z_##OPT }
#define	HOMED_FLAGS   axis_homed
#define	_CAN_HOME(A)   (axis == _AXIS(A) && ((A##_MIN_PIN > -1 && A##_HOME_DIR < 0) || (A##_MAX_PIN > -1 && A##_HOME_DIR > 0)))
#define	CAN_HOME_X   _CAN_HOME(X)
#define	CAN_HOME_Y   _CAN_HOME(Y)
#define	CAN_HOME_Z   _CAN_HOME(Z)

Functions
	XYZ_CONSTS (float, base_min_pos, MIN_POS)
	XYZ_CONSTS (float, base_max_pos, MAX_POS)
	XYZ_CONSTS (float, base_home_pos, HOME_POS)
	XYZ_CONSTS (float, max_length, MAX_LENGTH)
	XYZ_CONSTS (float, home_bump_mm, HOME_BUMP_MM)
	XYZ_CONSTS (signed char, home_dir, HOME_DIR)
void	report_current_position ()
void	sync_plan_position ()
void	sync_plan_position_e ()
void	get_cartesian_from_steppers ()
void	set_current_from_steppers_for_axis (const AxisEnum axis)
void	line_to_current_position (const feedRate_t &fr_mm_s)
void	_internal_move_to_destination (const feedRate_t &fr_mm_s)
void	do_blocking_move_to (const float rx, const float ry, const float rz, const feedRate_t &fr_mm_s)
void	do_blocking_move_to (const xy_pos_t &raw, const feedRate_t &fr_mm_s)
void	do_blocking_move_to (const xyz_pos_t &raw, const feedRate_t &fr_mm_s)
void	do_blocking_move_to (const xyze_pos_t &raw, const feedRate_t &fr_mm_s)
void	do_blocking_move_to_x (const float &rx, const feedRate_t &fr_mm_s)
void	do_blocking_move_to_y (const float &ry, const feedRate_t &fr_mm_s)
void	do_blocking_move_to_z (const float &rz, const feedRate_t &fr_mm_s)
void	do_blocking_move_to_xy (const float &rx, const float &ry, const feedRate_t &fr_mm_s)
void	do_blocking_move_to_xy (const xy_pos_t &raw, const feedRate_t &fr_mm_s)
void	do_blocking_move_to_xy_z (const xy_pos_t &raw, const float &z, const feedRate_t &fr_mm_s)
void	remember_feedrate_and_scaling ()
void	remember_feedrate_scaling_off ()
void	restore_feedrate_and_scaling ()
void	update_software_endstops (const AxisEnum axis)
void	apply_motion_limits (xyz_pos_t &target)
bool	prepare_move_to_destination_cartesian ()
void	prepare_move_to_destination ()
uint8_t	axes_need_homing (uint8_t axis_bits)
bool	axis_unhomed_error (uint8_t axis_bits)
feedRate_t	get_homing_bump_feedrate (const AxisEnum axis)
void	do_homing_move (const AxisEnum axis, const float distance, const feedRate_t fr_mm_s=0.0)
void	set_axis_is_at_home (const AxisEnum axis)
void	set_axis_is_not_at_home (const AxisEnum axis)
void	homeaxis (const AxisEnum axis)

Variables
uint8_t	axis_homed
uint8_t	axis_known_position
bool	relative_mode
xyze_pos_t	current_position = { X_HOME_POS, Y_HOME_POS, Z_HOME_POS }
xyze_pos_t	destination
feedRate_t	feedrate_mm_s = MMM_TO_MMS(1500)
int16_t	feedrate_percentage = 100
const feedRate_t homing_feedrate_mm_s[XYZ]	PROGMEM
xyz_pos_t	cartes
float	xy_probe_feedrate_mm_s = MMM_TO_MMS(XY_PROBE_SPEED)
static float	saved_feedrate_mm_s
static int16_t	saved_feedrate_percentage
bool	soft_endstops_enabled = true
axis_limits_t	soft_endstop
bool	extruder_duplication_enabled
bool	mirrored_duplication_mode

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/. motion.cpp

XYZ_CONSTS

#define XYZ_CONSTS	(		T,
			NAME,
			OPT
	)		const PROGMEM XYZval<T> NAME##_P = { X_##OPT, Y_##OPT, Z_##OPT }

HOMED_FLAGS

#define HOMED_FLAGS   axis_homed

_CAN_HOME

#define _CAN_HOME

(

A

)

(axis == _AXIS(A) && ((A##_MIN_PIN > -1 && A##_HOME_DIR < 0) || (A##_MAX_PIN > -1 && A##_HOME_DIR > 0)))

CAN_HOME_X

#define CAN_HOME_X   _CAN_HOME(X)

CAN_HOME_Y

#define CAN_HOME_Y   _CAN_HOME(Y)

CAN_HOME_Z

#define CAN_HOME_Z   _CAN_HOME(Z)

Function Documentation

XYZ_CONSTS() [1/6]

XYZ_CONSTS	(	float	,
		base_min_pos	,
		MIN_POS
	)

XYZ_CONSTS() [2/6]

XYZ_CONSTS	(	float	,
		base_max_pos	,
		MAX_POS
	)

XYZ_CONSTS() [3/6]

XYZ_CONSTS	(	float	,
		base_home_pos	,
		HOME_POS
	)

XYZ_CONSTS() [4/6]

XYZ_CONSTS	(	float	,
		max_length	,
		MAX_LENGTH
	)

XYZ_CONSTS() [5/6]

XYZ_CONSTS	(	float	,
		home_bump_mm	,
		HOME_BUMP_MM
	)

XYZ_CONSTS() [6/6]

XYZ_CONSTS	(	signed char	,
		home_dir	,
		HOME_DIR
	)

report_current_position()

void report_current_position

(

)

Output the current position to serial

                               {
  const xyz_pos_t lpos = current_position.asLogical();
  SERIAL_ECHOPAIR("X:", lpos.x, " Y:", lpos.y, " Z:", lpos.z, " E:", current_position.e);
 
  stepper.report_positions();
 
  #if IS_SCARA
    scara_report_positions();
  #endif
}

Here is the call graph for this function:

sync_plan_position()

void sync_plan_position

(

)

sync_plan_position

Set the planner/stepper positions directly from current_position with no kinematic translation. Used for homing axes and cartesian/core syncing.

                          {
  if (DEBUGGING(LEVELING)) DEBUG_POS("sync_plan_position", current_position);
  planner.set_position_mm(current_position);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sync_plan_position_e()

void sync_plan_position_e

(

)

{ planner.set_e_position_mm(current_position.e); }

Here is the call graph for this function:

get_cartesian_from_steppers()

void get_cartesian_from_steppers

(

)

Get the stepper positions in the cartes[] array. Forward kinematics are applied for DELTA and SCARA.

The result is in the current coordinate space with leveling applied. The coordinates need to be run through unapply_leveling to obtain the "ideal" coordinates suitable for current_position, etc.

                                   {
  #if ENABLED(DELTA)
    forward_kinematics_DELTA(
      planner.get_axis_position_mm(A_AXIS),
      planner.get_axis_position_mm(B_AXIS),
      planner.get_axis_position_mm(C_AXIS)
    );
  #else
    #if IS_SCARA
      forward_kinematics_SCARA(
        planner.get_axis_position_degrees(A_AXIS),
        planner.get_axis_position_degrees(B_AXIS)
      );
    #else
      cartes.set(planner.get_axis_position_mm(X_AXIS), planner.get_axis_position_mm(Y_AXIS));
    #endif
    cartes.z = planner.get_axis_position_mm(Z_AXIS);
  #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_current_from_steppers_for_axis()

void set_current_from_steppers_for_axis

(

const AxisEnum

axis

)

Set the current_position for an axis based on the stepper positions, removing any leveling that may have been applied.

To prevent small shifts in axis position always call sync_plan_position after updating axes with this.

To keep hosts in sync, always call report_current_position after updating the current_position.

                                                             {
  get_cartesian_from_steppers();
 
  #if HAS_POSITION_MODIFIERS
    xyze_pos_t pos = { cartes.x, cartes.y, cartes.z, current_position.e };
    planner.unapply_modifiers(pos
      #if HAS_LEVELING
        , true
      #endif
    );
    xyze_pos_t &cartes = pos;
  #endif
  if (axis == ALL_AXES)
    current_position = cartes;
  else
    current_position[axis] = cartes[axis];
}

Here is the call graph for this function:

Here is the caller graph for this function:

line_to_current_position()

void line_to_current_position

(

const feedRate_t &

fr_mm_s

)

Move the planner to the current position from wherever it last moved (or from wherever it has been told it is located).

                                                          {
  planner.buffer_line(current_position, fr_mm_s, active_extruder);
}

Here is the call graph for this function:

Here is the caller graph for this function:

_internal_move_to_destination()

void _internal_move_to_destination

(

const feedRate_t &

fr_mm_s

)

  {
  const feedRate_t old_feedrate = feedrate_mm_s;
  if (fr_mm_s) feedrate_mm_s = fr_mm_s;
 
  const uint16_t old_pct = feedrate_percentage;
  feedrate_percentage = 100;
 
  #if EXTRUDERS
     const float old_fac = planner.e_factor[active_extruder];
     planner.e_factor[active_extruder] = 1.0f;
  #endif
 
  #if IS_KINEMATIC
    if (is_fast)
      prepare_fast_move_to_destination();
    else
  #endif
      prepare_move_to_destination();
 
  feedrate_mm_s = old_feedrate;
  feedrate_percentage = old_pct;
  #if EXTRUDERS
    planner.e_factor[active_extruder] = old_fac;
  #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_blocking_move_to() [1/4]

void do_blocking_move_to	(	const float	rx,
		const float	ry,
		const float	rz,
		const feedRate_t &	fr_mm_s
	)

Plan a move to (X, Y, Z) and set the current_position

                                                                                                     {
  if (DEBUGGING(LEVELING)) DEBUG_XYZ(">>> do_blocking_move_to", rx, ry, rz);
 
  const feedRate_t z_feedrate = fr_mm_s ?: homing_feedrate(Z_AXIS),
                  xy_feedrate = fr_mm_s ?: feedRate_t(XY_PROBE_FEEDRATE_MM_S);
 
  #if ENABLED(DELTA)
 
    if (!position_is_reachable(rx, ry)) return;
 
    REMEMBER(fr, feedrate_mm_s, xy_feedrate);
 
    destination = current_position;          // sync destination at the start
 
    if (DEBUGGING(LEVELING)) DEBUG_POS("destination = current_position", destination);
 
    // when in the danger zone
    if (current_position.z > delta_clip_start_height) {
      if (rz > delta_clip_start_height) {   // staying in the danger zone
        destination.set(rx, ry, rz);        // move directly (uninterpolated)
        prepare_internal_fast_move_to_destination();          // set current_position from destination
        if (DEBUGGING(LEVELING)) DEBUG_POS("danger zone move", current_position);
        return;
      }
      destination.z = delta_clip_start_height;
      prepare_internal_fast_move_to_destination();            // set current_position from destination
      if (DEBUGGING(LEVELING)) DEBUG_POS("zone border move", current_position);
    }
 
    if (rz > current_position.z) {                            // raising?
      destination.z = rz;
      prepare_internal_fast_move_to_destination(z_feedrate);  // set current_position from destination
      if (DEBUGGING(LEVELING)) DEBUG_POS("z raise move", current_position);
    }
 
    destination.set(rx, ry);
    prepare_internal_move_to_destination();                   // set current_position from destination
    if (DEBUGGING(LEVELING)) DEBUG_POS("xy move", current_position);
 
    if (rz < current_position.z) {                            // lowering?
      destination.z = rz;
      prepare_internal_fast_move_to_destination(z_feedrate);  // set current_position from destination
      if (DEBUGGING(LEVELING)) DEBUG_POS("z lower move", current_position);
    }
 
  #elif IS_SCARA
 
    if (!position_is_reachable(rx, ry)) return;
 
    destination = current_position;
 
    // If Z needs to raise, do it before moving XY
    if (destination.z < rz) {
      destination.z = rz;
      prepare_internal_fast_move_to_destination(z_feedrate);
    }
 
    destination.set(rx, ry);
    prepare_internal_fast_move_to_destination(xy_feedrate);
 
    // If Z needs to lower, do it after moving XY
    if (destination.z > rz) {
      destination.z = rz;
      prepare_internal_fast_move_to_destination(z_feedrate);
    }
 
  #else
 
    // If Z needs to raise, do it before moving XY
    if (current_position.z < rz) {
      current_position.z = rz;
      line_to_current_position(z_feedrate);
    }
 
    current_position.set(rx, ry);
    line_to_current_position(xy_feedrate);
 
    // If Z needs to lower, do it after moving XY
    if (current_position.z > rz) {
      current_position.z = rz;
      line_to_current_position(z_feedrate);
    }
 
  #endif
 
  if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("<<< do_blocking_move_to");
 
  planner.synchronize();
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_blocking_move_to() [2/4]

void do_blocking_move_to	(	const xy_pos_t &	raw,
		const feedRate_t &	fr_mm_s
	)

                                                                          {
  do_blocking_move_to(raw.x, raw.y, current_position.z, fr_mm_s);
}

Here is the call graph for this function:

do_blocking_move_to() [3/4]

void do_blocking_move_to	(	const xyz_pos_t &	raw,
		const feedRate_t &	fr_mm_s
	)

                                                                           {
  do_blocking_move_to(raw.x, raw.y, raw.z, fr_mm_s);
}

Here is the call graph for this function:

do_blocking_move_to() [4/4]

void do_blocking_move_to	(	const xyze_pos_t &	raw,
		const feedRate_t &	fr_mm_s
	)

                                                                            {
  do_blocking_move_to(raw.x, raw.y, raw.z, fr_mm_s);
}

Here is the call graph for this function:

do_blocking_move_to_x()

void do_blocking_move_to_x	(	const float &	rx,
		const feedRate_t &	fr_mm_s
	)

                                                                        {
  do_blocking_move_to(rx, current_position.y, current_position.z, fr_mm_s);
}

Here is the call graph for this function:

do_blocking_move_to_y()

void do_blocking_move_to_y	(	const float &	ry,
		const feedRate_t &	fr_mm_s
	)

                                                                        {
  do_blocking_move_to(current_position.x, ry, current_position.z, fr_mm_s);
}

Here is the call graph for this function:

do_blocking_move_to_z()

void do_blocking_move_to_z	(	const float &	rz,
		const feedRate_t &	fr_mm_s
	)

                                                                        {
  do_blocking_move_to_xy_z(current_position, rz, fr_mm_s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_blocking_move_to_xy() [1/2]

void do_blocking_move_to_xy	(	const float &	rx,
		const float &	ry,
		const feedRate_t &	fr_mm_s
	)

                                                                                          {
  do_blocking_move_to(rx, ry, current_position.z, fr_mm_s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_blocking_move_to_xy() [2/2]

void do_blocking_move_to_xy	(	const xy_pos_t &	raw,
		const feedRate_t &	fr_mm_s
	)

                                                                             {
  do_blocking_move_to_xy(raw.x, raw.y, fr_mm_s);
}

Here is the call graph for this function:

do_blocking_move_to_xy_z()

void do_blocking_move_to_xy_z	(	const xy_pos_t &	raw,
		const float &	z,
		const feedRate_t &	fr_mm_s
	)

                                                                                               {
  do_blocking_move_to(raw.x, raw.y, z, fr_mm_s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

remember_feedrate_and_scaling()

void remember_feedrate_and_scaling

(

)

                                     {
  saved_feedrate_mm_s = feedrate_mm_s;
  saved_feedrate_percentage = feedrate_percentage;
}

Here is the caller graph for this function:

remember_feedrate_scaling_off()

void remember_feedrate_scaling_off

(

)

                                     {
  remember_feedrate_and_scaling();
  feedrate_percentage = 100;
}

Here is the call graph for this function:

restore_feedrate_and_scaling()

void restore_feedrate_and_scaling

(

)

                                    {
  feedrate_mm_s = saved_feedrate_mm_s;
  feedrate_percentage = saved_feedrate_percentage;
}

update_software_endstops()

void update_software_endstops

(

const AxisEnum

axis

)

Software endstops can be used to monitor the open end of an axis that has a hardware endstop on the other end. Or they can prevent axes from moving past endstops and grinding.

To keep doing their job as the coordinate system changes, the software endstop positions must be refreshed to remain at the same positions relative to the machine.

    {
 
    #if ENABLED(DUAL_X_CARRIAGE)
 
      if (axis == X_AXIS) {
 
        // In Dual X mode hotend_offset[X] is T1's home position
        const float dual_max_x = _MAX(hotend_offset[1].x, X2_MAX_POS);
 
        if (new_tool_index != 0) {
          // T1 can move from X2_MIN_POS to X2_MAX_POS or X2 home position (whichever is larger)
          soft_endstop.min.x = X2_MIN_POS;
          soft_endstop.max.x = dual_max_x;
        }
        else if (dxc_is_duplicating()) {
          // In Duplication Mode, T0 can move as far left as X1_MIN_POS
          // but not so far to the right that T1 would move past the end
          soft_endstop.min.x = X1_MIN_POS;
          soft_endstop.max.x = _MIN(X1_MAX_POS, dual_max_x - duplicate_extruder_x_offset);
        }
        else {
          // In other modes, T0 can move from X1_MIN_POS to X1_MAX_POS
          soft_endstop.min.x = X1_MIN_POS;
          soft_endstop.max.x = X1_MAX_POS;
        }
 
      }
 
    #elif ENABLED(DELTA)
 
      soft_endstop.min[axis] = base_min_pos(axis);
      soft_endstop.max[axis] = (axis == Z_AXIS ? delta_height
      #if HAS_BED_PROBE
        - probe_offset.z
      #endif
      : base_max_pos(axis));
 
      switch (axis) {
        case X_AXIS:
        case Y_AXIS:
          // Get a minimum radius for clamping
          delta_max_radius = _MIN(ABS(_MAX(soft_endstop.min.x, soft_endstop.min.y)), soft_endstop.max.x, soft_endstop.max.y);
          delta_max_radius_2 = sq(delta_max_radius);
          break;
        case Z_AXIS:
          delta_clip_start_height = soft_endstop.max[axis] - delta_safe_distance_from_top();
        default: break;
      }
 
    #elif HAS_HOTEND_OFFSET
 
      // Software endstops are relative to the tool 0 workspace, so
      // the movement limits must be shifted by the tool offset to
      // retain the same physical limit when other tools are selected.
      if (old_tool_index != new_tool_index) {
        const float offs = hotend_offset[new_tool_index][axis] - hotend_offset[old_tool_index][axis];
        soft_endstop.min[axis] += offs;
        soft_endstop.max[axis] += offs;
      }
      else {
        const float offs = hotend_offset[active_extruder][axis];
        soft_endstop.min[axis] = base_min_pos(axis) + offs;
        soft_endstop.max[axis] = base_max_pos(axis) + offs;
      }
 
    #else
 
      soft_endstop.min[axis] = base_min_pos(axis);
      soft_endstop.max[axis] = base_max_pos(axis);
 
    #endif
 
  if (DEBUGGING(LEVELING))
    SERIAL_ECHOLNPAIR("Axis ", axis_codes[axis], " min:", soft_endstop.min[axis], " max:", soft_endstop.max[axis]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

apply_motion_limits()

void apply_motion_limits

(

xyz_pos_t &

target

)

Constrain the given coordinates to the software endstops.

For DELTA/SCARA the XY constraint is based on the smallest radius within the set software endstops.

                                              {
 
    if (!soft_endstops_enabled || !all_axes_homed()) return;
 
    #if IS_KINEMATIC
 
      #if HAS_HOTEND_OFFSET && ENABLED(DELTA)
        // The effector center position will be the target minus the hotend offset.
        const xy_pos_t offs = hotend_offset[active_extruder];
      #else
        // SCARA needs to consider the angle of the arm through the entire move, so for now use no tool offset.
        constexpr xy_pos_t offs{0};
      #endif
 
      const float dist_2 = HYPOT2(target.x - offs.x, target.y - offs.y);
      if (dist_2 > delta_max_radius_2)
        target *= delta_max_radius / SQRT(dist_2); // 200 / 300 = 0.66
 
    #else
 
      #if !HAS_SOFTWARE_ENDSTOPS || ENABLED(MIN_SOFTWARE_ENDSTOP_X)
        NOLESS(target.x, soft_endstop.min.x);
      #endif
      #if !HAS_SOFTWARE_ENDSTOPS || ENABLED(MAX_SOFTWARE_ENDSTOP_X)
        NOMORE(target.x, soft_endstop.max.x);
      #endif
      #if !HAS_SOFTWARE_ENDSTOPS || ENABLED(MIN_SOFTWARE_ENDSTOP_Y)
        NOLESS(target.y, soft_endstop.min.y);
      #endif
      #if !HAS_SOFTWARE_ENDSTOPS || ENABLED(MAX_SOFTWARE_ENDSTOP_Y)
        NOMORE(target.y, soft_endstop.max.y);
      #endif
 
    #endif
 
    #if !HAS_SOFTWARE_ENDSTOPS || ENABLED(MIN_SOFTWARE_ENDSTOP_Z)
      NOLESS(target.z, soft_endstop.min.z);
    #endif
    #if !HAS_SOFTWARE_ENDSTOPS || ENABLED(MAX_SOFTWARE_ENDSTOP_Z)
      NOMORE(target.z, soft_endstop.max.z);
    #endif
  }

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_move_to_destination_cartesian()

bool prepare_move_to_destination_cartesian

(

)

Prepare a linear move in a Cartesian setup.

When a mesh-based leveling system is active, moves are segmented according to the configuration of the leveling system.

Return true if 'current_position' was set to 'destination'

For MBL and ABL-BILINEAR only segment moves when X or Y are involved. Otherwise fall through to do a direct single move.

                                                      {
    const float scaled_fr_mm_s = MMS_SCALED(feedrate_mm_s);
    #if HAS_MESH
      if (planner.leveling_active && planner.leveling_active_at_z(destination.z)) {
        #if ENABLED(AUTO_BED_LEVELING_UBL)
          ubl.line_to_destination_cartesian(scaled_fr_mm_s, active_extruder); // UBL's motion routine needs to know about
          return true;                                                        // all moves, including Z-only moves.
        #elif ENABLED(SEGMENT_LEVELED_MOVES)
          segmented_line_to_destination(scaled_fr_mm_s);
          return false; // caller will update current_position
        #else
          /**
           * For MBL and ABL-BILINEAR only segment moves when X or Y are involved.
           * Otherwise fall through to do a direct single move.
           */
          if (xy_pos_t(current_position) != xy_pos_t(destination)) {
            #if ENABLED(MESH_BED_LEVELING)
              mbl.line_to_destination(scaled_fr_mm_s);
            #elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
              bilinear_line_to_destination(scaled_fr_mm_s);
            #endif
            return true;
          }
        #endif
      }
    #endif // HAS_MESH
 
    planner.buffer_line(destination, scaled_fr_mm_s, active_extruder);
    return false; // caller will update current_position
  }

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_move_to_destination()

void prepare_move_to_destination

(

)

Prepare a single move and get ready for the next one

This may result in several calls to planner.buffer_line to do smaller moves for DELTA, SCARA, mesh moves, etc.

Make sure current_position.e and destination.e are good before calling or cold/lengthy extrusion may get missed.

Before exit, current_position is set to destination.

                                   {
  apply_motion_limits(destination);
 
  #if EITHER(PREVENT_COLD_EXTRUSION, PREVENT_LENGTHY_EXTRUDE)
 
    if (!DEBUGGING(DRYRUN)) {
      if (destination.e != current_position.e) {
        #if ENABLED(PREVENT_COLD_EXTRUSION)
          if (thermalManager.tooColdToExtrude(active_extruder)) {
            current_position.e = destination.e; // Behave as if the move really took place, but ignore E part
            SERIAL_ECHO_MSG(MSG_ERR_COLD_EXTRUDE_STOP);
          }
        #endif // PREVENT_COLD_EXTRUSION
        #if ENABLED(PREVENT_LENGTHY_EXTRUDE)
          const float e_delta = ABS(destination.e - current_position.e) * planner.e_factor[active_extruder];
          if (e_delta > (EXTRUDE_MAXLENGTH)) {
            #if ENABLED(MIXING_EXTRUDER)
              bool ignore_e = false;
              float collector[MIXING_STEPPERS];
              mixer.refresh_collector(1.0, mixer.get_current_vtool(), collector);
              MIXER_STEPPER_LOOP(e)
                if (e_delta * collector[e] > (EXTRUDE_MAXLENGTH)) { ignore_e = true; break; }
            #else
              constexpr bool ignore_e = true;
            #endif
            if (ignore_e) {
              current_position.e = destination.e; // Behave as if the move really took place, but ignore E part
              SERIAL_ECHO_MSG(MSG_ERR_LONG_EXTRUDE_STOP);
            }
          }
        #endif // PREVENT_LENGTHY_EXTRUDE
      }
    }
 
  #endif // PREVENT_COLD_EXTRUSION || PREVENT_LENGTHY_EXTRUDE
 
  #if ENABLED(DUAL_X_CARRIAGE)
    if (dual_x_carriage_unpark()) return;
  #endif
 
  if (
    #if UBL_SEGMENTED
      #if IS_KINEMATIC // UBL using Kinematic / Cartesian cases as a workaround for now.
        ubl.line_to_destination_segmented(MMS_SCALED(feedrate_mm_s))
      #else
        prepare_move_to_destination_cartesian()
      #endif
    #elif IS_KINEMATIC
      line_to_destination_kinematic()
    #else
      prepare_move_to_destination_cartesian()
    #endif
  ) return;
 
  current_position = destination;
}

Here is the call graph for this function:

Here is the caller graph for this function:

axes_need_homing()

uint8_t axes_need_homing

(

uint8_t

axis_bits

)

                                             {
  #if ENABLED(HOME_AFTER_DEACTIVATE)
    #define HOMED_FLAGS axis_known_position
  #else
    #define HOMED_FLAGS axis_homed
  #endif
  // Clear test bits that are homed
  if (TEST(axis_bits, X_AXIS) && TEST(HOMED_FLAGS, X_AXIS)) CBI(axis_bits, X_AXIS);
  if (TEST(axis_bits, Y_AXIS) && TEST(HOMED_FLAGS, Y_AXIS)) CBI(axis_bits, Y_AXIS);
  if (TEST(axis_bits, Z_AXIS) && TEST(HOMED_FLAGS, Z_AXIS)) CBI(axis_bits, Z_AXIS);
  return axis_bits;
}

Here is the caller graph for this function:

axis_unhomed_error()

bool axis_unhomed_error

(

uint8_t

axis_bits

)

                                            {
  if ((axis_bits = axes_need_homing(axis_bits))) {
    PGM_P home_first = GET_TEXT(MSG_HOME_FIRST);
    char msg[strlen_P(home_first)+1];
    sprintf_P(msg, home_first,
      TEST(axis_bits, X_AXIS) ? "X" : "",
      TEST(axis_bits, Y_AXIS) ? "Y" : "",
      TEST(axis_bits, Z_AXIS) ? "Z" : ""
    );
    SERIAL_ECHO_START();
    SERIAL_ECHOLN(msg);
    #if HAS_DISPLAY
      ui.set_status(msg);
    #endif
    return true;
  }
  return false;
}

Here is the call graph for this function:

get_homing_bump_feedrate()

feedRate_t get_homing_bump_feedrate

(

const AxisEnum

axis

)

Homing bump feedrate (mm/s)

                                                         {
  #if HOMING_Z_WITH_PROBE
    if (axis == Z_AXIS) return MMM_TO_MMS(Z_PROBE_SPEED_SLOW);
  #endif
  static const uint8_t homing_bump_divisor[] PROGMEM = HOMING_BUMP_DIVISOR;
  uint8_t hbd = pgm_read_byte(&homing_bump_divisor[axis]);
  if (hbd < 1) {
    hbd = 10;
    SERIAL_ECHO_MSG("Warning: Homing Bump Divisor < 1");
  }
  return homing_feedrate(axis) / float(hbd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_homing_move()

void do_homing_move	(	const AxisEnum	axis,
		const float	distance,
		const feedRate_t	fr_mm_s = 0.0
	)

Home an individual linear axis

                                                                                             {
 
  if (DEBUGGING(LEVELING)) {
    DEBUG_ECHOPAIR(">>> do_homing_move(", axis_codes[axis], ", ", distance, ", ");
    if (fr_mm_s)
      DEBUG_ECHO(fr_mm_s);
    else
      DEBUG_ECHOPAIR("[", homing_feedrate(axis), "]");
    DEBUG_ECHOLNPGM(")");
  }
 
  #if HOMING_Z_WITH_PROBE && HAS_HEATED_BED && ENABLED(WAIT_FOR_BED_HEATER)
    // Wait for bed to heat back up between probing points
    if (axis == Z_AXIS && distance < 0 && thermalManager.isHeatingBed()) {
      serialprintPGM(msg_wait_for_bed_heating);
      LCD_MESSAGEPGM(MSG_BED_HEATING);
      thermalManager.wait_for_bed();
      ui.reset_status();
    }
  #endif
 
  // Only do some things when moving towards an endstop
  const int8_t axis_home_dir =
    #if ENABLED(DUAL_X_CARRIAGE)
      (axis == X_AXIS) ? x_home_dir(active_extruder) :
    #endif
    home_dir(axis);
  const bool is_home_dir = (axis_home_dir > 0) == (distance > 0);
 
  #if ENABLED(SENSORLESS_HOMING)
    sensorless_t stealth_states;
  #endif
 
  if (is_home_dir) {
 
    #if HOMING_Z_WITH_PROBE && QUIET_PROBING
      if (axis == Z_AXIS) probing_pause(true);
    #endif
 
    // Disable stealthChop if used. Enable diag1 pin on driver.
    #if ENABLED(SENSORLESS_HOMING)
      stealth_states = start_sensorless_homing_per_axis(axis);
    #endif
  }
 
  const feedRate_t real_fr_mm_s = fr_mm_s ?: homing_feedrate(axis);
 
  if ((axis == X_AXIS) || (axis == Y_AXIS))
  {
    abce_pos_t target = { planner.get_axis_position_mm(A_AXIS), planner.get_axis_position_mm(B_AXIS), planner.get_axis_position_mm(C_AXIS), planner.get_axis_position_mm(E_AXIS) };
    target[axis] = 0;
    planner.set_machine_position_mm(target);
    float dist = (distance > 0)?-1.92F:1.92F;
    target[axis] = dist;
#if IS_KINEMATIC && DISABLED(CLASSIC_JERK)
    const xyze_float_t delta_mm_cart{0};
#endif
    // Set delta/cartesian axes directly
    planner.buffer_segment(target
#if IS_KINEMATIC && DISABLED(CLASSIC_JERK)
      , delta_mm_cart
#endif
      , real_fr_mm_s / 4, active_extruder
    );
    planner.synchronize();
  }
 
  #if IS_SCARA
    // Tell the planner the axis is at 0
    current_position[axis] = 0;
    sync_plan_position();
    current_position[axis] = distance;
    line_to_current_position(real_fr_mm_s);
  #else
    abce_pos_t target = { planner.get_axis_position_mm(A_AXIS), planner.get_axis_position_mm(B_AXIS), planner.get_axis_position_mm(C_AXIS), planner.get_axis_position_mm(E_AXIS) };
    target[axis] = 0;
    planner.set_machine_position_mm(target);
    target[axis] = distance;
 
    #if IS_KINEMATIC && DISABLED(CLASSIC_JERK)
      const xyze_float_t delta_mm_cart{0};
    #endif
 
    // Set delta/cartesian axes directly
    planner.buffer_segment(target
      #if IS_KINEMATIC && DISABLED(CLASSIC_JERK)
        , delta_mm_cart
      #endif
      , real_fr_mm_s, active_extruder
    );
  #endif
 
  planner.synchronize();
 
  if (is_home_dir) {
 
    #if HOMING_Z_WITH_PROBE && QUIET_PROBING
      if (axis == Z_AXIS) probing_pause(false);
    #endif
 
    endstops.validate_homing_move();
 
    // Re-enable stealthChop if used. Disable diag1 pin on driver.
    #if ENABLED(SENSORLESS_HOMING)
      end_sensorless_homing_per_axis(axis, stealth_states);
    #endif
  }
 
  if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPAIR("<<< do_homing_move(", axis_codes[axis], ")");
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_axis_is_at_home()

void set_axis_is_at_home

(

const AxisEnum

axis

)

Set an axis' current position to its home position (after homing).

For Core and Cartesian robots this applies one-to-one when an individual axis has been homed.

DELTA should wait until all homing is done before setting the XYZ current_position to home, because homing is a single operation. In the case where the axis positions are already known and previously homed, DELTA could home to X or Y individually by moving either one to the center. However, homing Z always homes XY and Z.

SCARA should wait until all XY homing is done before setting the XY current_position to home, because neither X nor Y is at home until both are at home. Z can however be homed individually.

Callers must sync the planner position after calling this!

Z Probe Z Homing? Account for the probe's Z offset.

                                              {
  if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPAIR(">>> set_axis_is_at_home(", axis_codes[axis], ")");
 
  SBI(axis_known_position, axis);
  SBI(axis_homed, axis);
 
  #if ENABLED(DUAL_X_CARRIAGE)
    if (axis == X_AXIS && (active_extruder == 1 || dual_x_carriage_mode == DXC_DUPLICATION_MODE)) {
      current_position.x = x_home_pos(active_extruder);
      return;
    }
  #endif
 
  #if ENABLED(MORGAN_SCARA)
    scara_set_axis_is_at_home(axis);
  #elif ENABLED(DELTA)
    current_position[axis] = (axis == Z_AXIS ? delta_height
    #if HAS_BED_PROBE
      - probe_offset.z
    #endif
    : base_home_pos(axis));
  #else
    current_position[axis] = base_home_pos(axis);
  #endif
 
  /**
   * Z Probe Z Homing? Account for the probe's Z offset.
   */
  #if HAS_BED_PROBE && Z_HOME_DIR < 0
    if (axis == Z_AXIS) {
      #if HOMING_Z_WITH_PROBE
 
        current_position.z -= probe_offset.z;
 
        if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPAIR("*** Z HOMED WITH PROBE (Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN) ***\n> probe_offset.z = ", probe_offset.z);
 
      #else
 
        if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("*** Z HOMED TO ENDSTOP ***");
 
      #endif
    }
  #endif
 
  #if ENABLED(I2C_POSITION_ENCODERS)
    I2CPEM.homed(axis);
  #endif
 
  #if ENABLED(BABYSTEP_DISPLAY_TOTAL)
    babystep.reset_total(axis);
  #endif
 
  if (DEBUGGING(LEVELING)) {
    #if HAS_HOME_OFFSET
      DEBUG_ECHOLNPAIR("> home_offset[", axis_codes[axis], "] = ", home_offset[axis]);
    #endif
    DEBUG_POS("", current_position);
    DEBUG_ECHOLNPAIR("<<< set_axis_is_at_home(", axis_codes[axis], ")");
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_axis_is_not_at_home()

void set_axis_is_not_at_home

(

const AxisEnum

axis

)

Set an axis' to be unhomed.

                                                  {
  if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPAIR(">>> set_axis_is_not_at_home(", axis_codes[axis], ")");
 
  CBI(axis_known_position, axis);
  CBI(axis_homed, axis);
 
  if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPAIR("<<< set_axis_is_not_at_home(", axis_codes[axis], ")");
 
  #if ENABLED(I2C_POSITION_ENCODERS)
    I2CPEM.unhomed(axis);
  #endif
}

Here is the call graph for this function:

homeaxis()

void homeaxis

(

const AxisEnum

axis

)

Home an individual "raw axis" to its endstop. This applies to XYZ on Cartesian and Core robots, and to the individual ABC steppers on DELTA and SCARA.

At the end of the procedure the axis is marked as homed and the current position of that axis is updated. Kinematic robots should wait till all axes are homed before updating the current position.

                                   {
 
  #if IS_SCARA
    // Only Z homing (with probe) is permitted
    if (axis != Z_AXIS) { BUZZ(100, 880); return; }
  #else
    #define _CAN_HOME(A) \
      (axis == _AXIS(A) && ((A##_MIN_PIN > -1 && A##_HOME_DIR < 0) || (A##_MAX_PIN > -1 && A##_HOME_DIR > 0)))
    #if X_SPI_SENSORLESS
      #define CAN_HOME_X true
    #else
      #define CAN_HOME_X _CAN_HOME(X)
    #endif
    #if Y_SPI_SENSORLESS
      #define CAN_HOME_Y true
    #else
      #define CAN_HOME_Y _CAN_HOME(Y)
    #endif
    #if Z_SPI_SENSORLESS
      #define CAN_HOME_Z true
    #else
      #define CAN_HOME_Z _CAN_HOME(Z)
    #endif
    if (!CAN_HOME_X && !CAN_HOME_Y && !CAN_HOME_Z) return;
  #endif
 
  if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPAIR(">>> homeaxis(", axis_codes[axis], ")");
 
  const int axis_home_dir = (
    #if ENABLED(DUAL_X_CARRIAGE)
      axis == X_AXIS ? x_home_dir(active_extruder) :
    #endif
    home_dir(axis)
  );
 
  // Homing Z towards the bed? Deploy the Z probe or endstop.
  #if HOMING_Z_WITH_PROBE
    if (axis == Z_AXIS && DEPLOY_PROBE()) return;
  #endif
 
  // Set flags for X, Y, Z motor locking
  #if HAS_EXTRA_ENDSTOPS
    switch (axis) {
      #if ENABLED(X_DUAL_ENDSTOPS)
        case X_AXIS:
      #endif
      #if ENABLED(Y_DUAL_ENDSTOPS)
        case Y_AXIS:
      #endif
      #if Z_MULTI_ENDSTOPS
        case Z_AXIS:
      #endif
      stepper.set_separate_multi_axis(true);
      default: break;
    }
  #endif
 
  // Fast move towards endstop until triggered
  if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("Home 1 Fast:");
 
  #if HOMING_Z_WITH_PROBE && ENABLED(BLTOUCH)
    if (axis == Z_AXIS && bltouch.deploy()) return; // The initial DEPLOY
  #endif
 
  do_homing_move(axis, 1.5f * max_length(
    #if ENABLED(DELTA)
      Z_AXIS
    #else
      axis
    #endif
    ) * axis_home_dir
  );
 
  #if HOMING_Z_WITH_PROBE && ENABLED(BLTOUCH) && DISABLED(BLTOUCH_HS_MODE)
    if (axis == Z_AXIS) bltouch.stow(); // Intermediate STOW (in LOW SPEED MODE)
  #endif
 
  // When homing Z with probe respect probe clearance
  const float bump = axis_home_dir * (
    #if HOMING_Z_WITH_PROBE
      (axis == Z_AXIS && (Z_HOME_BUMP_MM)) ? _MAX(Z_CLEARANCE_BETWEEN_PROBES, Z_HOME_BUMP_MM) :
    #endif
    home_bump_mm(axis)
  );
 
  // If a second homing move is configured...
  if (bump) {
    // Move away from the endstop by the axis HOME_BUMP_MM
    if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("Move Away:");
    do_homing_move(axis, -bump
      #if HOMING_Z_WITH_PROBE
        , MMM_TO_MMS(axis == Z_AXIS ? Z_PROBE_SPEED_FAST : 0)
      #endif
    );
 
    // Slow move towards endstop until triggered
    if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("Home 2 Slow:");
 
    #if HOMING_Z_WITH_PROBE && ENABLED(BLTOUCH) && DISABLED(BLTOUCH_HS_MODE)
      if (axis == Z_AXIS && bltouch.deploy()) return; // Intermediate DEPLOY (in LOW SPEED MODE)
    #endif
 
    do_homing_move(axis, 2 * bump, get_homing_bump_feedrate(axis));
 
    #if HOMING_Z_WITH_PROBE && ENABLED(BLTOUCH)
      if (axis == Z_AXIS) bltouch.stow(); // The final STOW
    #endif
  }
 
  #if HAS_EXTRA_ENDSTOPS
    const bool pos_dir = axis_home_dir > 0;
    #if ENABLED(X_DUAL_ENDSTOPS)
      if (axis == X_AXIS) {
        const float adj = ABS(endstops.x2_endstop_adj);
        if (adj) {
          if (pos_dir ? (endstops.x2_endstop_adj > 0) : (endstops.x2_endstop_adj < 0)) stepper.set_x_lock(true); else stepper.set_x2_lock(true);
          do_homing_move(axis, pos_dir ? -adj : adj);
          stepper.set_x_lock(false);
          stepper.set_x2_lock(false);
        }
      }
    #endif
    #if ENABLED(Y_DUAL_ENDSTOPS)
      if (axis == Y_AXIS) {
        const float adj = ABS(endstops.y2_endstop_adj);
        if (adj) {
          if (pos_dir ? (endstops.y2_endstop_adj > 0) : (endstops.y2_endstop_adj < 0)) stepper.set_y_lock(true); else stepper.set_y2_lock(true);
          do_homing_move(axis, pos_dir ? -adj : adj);
          stepper.set_y_lock(false);
          stepper.set_y2_lock(false);
        }
      }
    #endif
    #if ENABLED(Z_DUAL_ENDSTOPS)
      if (axis == Z_AXIS) {
        const float adj = ABS(endstops.z2_endstop_adj);
        if (adj) {
          if (pos_dir ? (endstops.z2_endstop_adj > 0) : (endstops.z2_endstop_adj < 0)) stepper.set_z_lock(true); else stepper.set_z2_lock(true);
          do_homing_move(axis, pos_dir ? -adj : adj);
          stepper.set_z_lock(false);
          stepper.set_z2_lock(false);
        }
      }
    #endif
    #if ENABLED(Z_TRIPLE_ENDSTOPS)
      if (axis == Z_AXIS) {
        // we push the function pointers for the stepper lock function into an array
        void (*lock[3]) (bool)= {&stepper.set_z_lock, &stepper.set_z2_lock, &stepper.set_z3_lock};
        float adj[3] = {0, endstops.z2_endstop_adj, endstops.z3_endstop_adj};
 
        void (*tempLock) (bool);
        float tempAdj;
 
        // manual bubble sort by adjust value
        if (adj[1] < adj[0]) {
          tempLock = lock[0], tempAdj = adj[0];
          lock[0] = lock[1], adj[0] = adj[1];
          lock[1] = tempLock, adj[1] = tempAdj;
        }
        if (adj[2] < adj[1]) {
          tempLock = lock[1], tempAdj = adj[1];
          lock[1] = lock[2], adj[1] = adj[2];
          lock[2] = tempLock, adj[2] = tempAdj;
        }
        if (adj[1] < adj[0]) {
          tempLock = lock[0], tempAdj = adj[0];
          lock[0] = lock[1], adj[0] = adj[1];
          lock[1] = tempLock, adj[1] = tempAdj;
        }
 
        if (pos_dir) {
          // normalize adj to smallest value and do the first move
          (*lock[0])(true);
          do_homing_move(axis, adj[1] - adj[0]);
          // lock the second stepper for the final correction
          (*lock[1])(true);
          do_homing_move(axis, adj[2] - adj[1]);
        }
        else {
          (*lock[2])(true);
          do_homing_move(axis, adj[1] - adj[2]);
          (*lock[1])(true);
          do_homing_move(axis, adj[0] - adj[1]);
        }
 
        stepper.set_z_lock(false);
        stepper.set_z2_lock(false);
        stepper.set_z3_lock(false);
      }
    #endif
 
    // Reset flags for X, Y, Z motor locking
    switch (axis) {
      #if ENABLED(X_DUAL_ENDSTOPS)
        case X_AXIS:
      #endif
      #if ENABLED(Y_DUAL_ENDSTOPS)
        case Y_AXIS:
      #endif
      #if Z_MULTI_ENDSTOPS
        case Z_AXIS:
      #endif
      stepper.set_separate_multi_axis(false);
      default: break;
    }
  #endif
 
  #if IS_SCARA
 
    set_axis_is_at_home(axis);
    sync_plan_position();
 
  #elif ENABLED(DELTA)
 
    // Delta has already moved all three towers up in G28
    // so here it re-homes each tower in turn.
    // Delta homing treats the axes as normal linear axes.
 
    // retrace by the amount specified in delta_endstop_adj + additional dist in order to have minimum steps
    if (delta_endstop_adj[axis] * Z_HOME_DIR <= 0) {
      if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("delta_endstop_adj:");
      do_homing_move(axis, delta_endstop_adj[axis] - (MIN_STEPS_PER_SEGMENT + 1) * planner.steps_to_mm[axis] * Z_HOME_DIR);
    }
 
  #else // CARTESIAN / CORE
 
    set_axis_is_at_home(axis);
    sync_plan_position();
 
    destination[axis] = current_position[axis];
 
    if (DEBUGGING(LEVELING)) DEBUG_POS("> AFTER set_axis_is_at_home", current_position);
 
  #endif
 
  // Put away the Z probe
  #if HOMING_Z_WITH_PROBE
    if (axis == Z_AXIS && STOW_PROBE()) return;
  #endif
 
  #ifdef HOMING_BACKOFF_MM
    constexpr xyz_float_t endstop_backoff = HOMING_BACKOFF_MM;
    const float backoff_mm = endstop_backoff[
      #if ENABLED(DELTA)
        Z_AXIS
      #else
        axis
      #endif
    ];
    if (backoff_mm) {
      current_position[axis] -= ABS(backoff_mm) * axis_home_dir;
      line_to_current_position(
        #if HOMING_Z_WITH_PROBE
          (axis == Z_AXIS) ? MMM_TO_MMS(Z_PROBE_SPEED_FAST) :
        #endif
        homing_feedrate(axis)
      );
    }
  #endif
 
  // Clear retracted status if homing the Z axis
  #if ENABLED(FWRETRACT)
    if (axis == Z_AXIS) fwretract.current_hop = 0.0;
  #endif
 
  if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPAIR("<<< homeaxis(", axis_codes[axis], ")");
 
} // homeaxis()

Here is the call graph for this function:

Variable Documentation

axis_homed

uint8_t axis_homed

axis_homed Flags that each linear axis was homed. XYZ on cartesian, ABC on delta, ABZ on SCARA.

axis_known_position Flags that the position is known in each linear axis. Set when homed. Cleared whenever a stepper powers off, potentially losing its position.

axis_known_position

uint8_t axis_known_position

relative_mode

bool relative_mode

current_position

xyze_pos_t current_position = { X_HOME_POS, Y_HOME_POS, Z_HOME_POS }

Cartesian Current Position Used to track the native machine position as moves are queued. Used by 'line_to_current_position' to do a move after changing it. Used by 'sync_plan_position' to update 'planner.position'.

destination

xyze_pos_t destination

Cartesian Destination The destination for a move, filled in by G-code movement commands, and expected by functions like 'prepare_move_to_destination'. G-codes can set destination using 'get_destination_from_command'

feedrate_mm_s

feedRate_t feedrate_mm_s = MMM_TO_MMS(1500)

feedrate_percentage

int16_t feedrate_percentage = 100

Feedrate scaling

PROGMEM

const feedRate_t homing_feedrate_mm_s [XYZ] PROGMEM

Initial value:

= {
 
 
 
    MMM_TO_MMS(HOMING_FEEDRATE_XY), MMM_TO_MMS(HOMING_FEEDRATE_XY),
 
 
}

cartes

xyz_pos_t cartes

xy_probe_feedrate_mm_s

float xy_probe_feedrate_mm_s = MMM_TO_MMS(XY_PROBE_SPEED)

The workspace can be offset by some commands, or these offsets may be omitted to save on computation.

saved_feedrate_mm_s

float saved_feedrate_mm_s

static

saved_feedrate_percentage

int16_t saved_feedrate_percentage

static

soft_endstops_enabled

bool soft_endstops_enabled = true

soft_endstop

axis_limits_t soft_endstop

Initial value:

= {
    { X_MIN_POS, Y_MIN_POS, Z_MIN_POS },
    { X_MAX_POS, Y_MAX_POS, Z_MAX_POS }
  }

extruder_duplication_enabled

bool extruder_duplication_enabled

Duplication mode

mirrored_duplication_mode

bool mirrored_duplication_mode