motion.h File Reference

#include "../inc/MarlinConfig.h"

Go to the source code of this file.

Classes
struct	axis_limits_t

Macros
#define	XY_PROBE_FEEDRATE_MM_S   xy_probe_feedrate_mm_s
#define	XYZ_DEFS(T, NAME, OPT)
#define	update_workspace_offset(x)   NOOP
#define	MOTION_CONDITIONS   IsRunning()
#define	NATIVE_TO_LOGICAL(POS, AXIS)   (POS)
#define	LOGICAL_TO_NATIVE(POS, AXIS)   (POS)
#define	LOGICAL_X_POSITION(POS)   NATIVE_TO_LOGICAL(POS, X_AXIS)
#define	LOGICAL_Y_POSITION(POS)   NATIVE_TO_LOGICAL(POS, Y_AXIS)
#define	LOGICAL_Z_POSITION(POS)   NATIVE_TO_LOGICAL(POS, Z_AXIS)
#define	RAW_X_POSITION(POS)   LOGICAL_TO_NATIVE(POS, X_AXIS)
#define	RAW_Y_POSITION(POS)   LOGICAL_TO_NATIVE(POS, Y_AXIS)
#define	RAW_Z_POSITION(POS)   LOGICAL_TO_NATIVE(POS, Z_AXIS)

Functions
FORCE_INLINE bool	all_axes_homed ()
FORCE_INLINE bool	all_axes_known ()
FORCE_INLINE void	set_all_unhomed ()
FORCE_INLINE void	set_all_unknown ()
FORCE_INLINE bool	homing_needed ()
FORCE_INLINE feedRate_t	homing_feedrate (const AxisEnum a)
feedRate_t	get_homing_bump_feedrate (const AxisEnum axis)
FORCE_INLINE float	pgm_read_any (const float *p)
FORCE_INLINE signed char	pgm_read_any (const signed char *p)
	XYZ_DEFS (float, base_min_pos, MIN_POS)
	XYZ_DEFS (float, base_max_pos, MAX_POS)
	XYZ_DEFS (float, base_home_pos, HOME_POS)
	XYZ_DEFS (float, max_length, MAX_LENGTH)
	XYZ_DEFS (float, home_bump_mm, HOME_BUMP_MM)
	XYZ_DEFS (signed char, home_dir, HOME_DIR)
void	apply_motion_limits (xyz_pos_t &target)
void	update_software_endstops (const AxisEnum axis)
void	report_current_position ()
void	get_cartesian_from_steppers ()
void	set_current_from_steppers_for_axis (const AxisEnum axis)
void	sync_plan_position ()
void	sync_plan_position_e ()
void	line_to_current_position (const feedRate_t &fr_mm_s=feedrate_mm_s)
void	prepare_move_to_destination ()
void	_internal_move_to_destination (const feedRate_t &fr_mm_s=0.0f)
void	prepare_internal_move_to_destination (const feedRate_t &fr_mm_s=0.0f)
void	do_blocking_move_to (const float rx, const float ry, const float rz, const feedRate_t &fr_mm_s=0.0f)
void	do_blocking_move_to (const xy_pos_t &raw, const feedRate_t &fr_mm_s=0.0f)
void	do_blocking_move_to (const xyz_pos_t &raw, const feedRate_t &fr_mm_s=0.0f)
void	do_blocking_move_to (const xyze_pos_t &raw, const feedRate_t &fr_mm_s=0.0f)
void	do_blocking_move_to_x (const float &rx, const feedRate_t &fr_mm_s=0.0f)
void	do_blocking_move_to_y (const float &ry, const feedRate_t &fr_mm_s=0.0f)
void	do_blocking_move_to_z (const float &rz, const feedRate_t &fr_mm_s=0.0f)
void	do_blocking_move_to_xy (const float &rx, const float &ry, const feedRate_t &fr_mm_s=0.0f)
void	do_blocking_move_to_xy (const xy_pos_t &raw, const feedRate_t &fr_mm_s=0.0f)
FORCE_INLINE void	do_blocking_move_to_xy (const xyz_pos_t &raw, const feedRate_t &fr_mm_s=0.0f)
FORCE_INLINE void	do_blocking_move_to_xy (const xyze_pos_t &raw, const feedRate_t &fr_mm_s=0.0f)
void	do_blocking_move_to_xy_z (const xy_pos_t &raw, const float &z, const feedRate_t &fr_mm_s=0.0f)
FORCE_INLINE void	do_blocking_move_to_xy_z (const xyz_pos_t &raw, const float &z, const feedRate_t &fr_mm_s=0.0f)
FORCE_INLINE void	do_blocking_move_to_xy_z (const xyze_pos_t &raw, const float &z, const feedRate_t &fr_mm_s=0.0f)
void	remember_feedrate_and_scaling ()
void	remember_feedrate_scaling_off ()
void	restore_feedrate_and_scaling ()
uint8_t	axes_need_homing (uint8_t axis_bits=0x07)
bool	axis_unhomed_error (uint8_t axis_bits=0x07)
void	set_axis_is_at_home (const AxisEnum axis)
void	set_axis_is_not_at_home (const AxisEnum axis)
void	homeaxis (const AxisEnum axis)
FORCE_INLINE void	toLogical (xy_pos_t &)
FORCE_INLINE void	toLogical (xyz_pos_t &)
FORCE_INLINE void	toLogical (xyze_pos_t &)
FORCE_INLINE void	toNative (xy_pos_t &)
FORCE_INLINE void	toNative (xyz_pos_t &)
FORCE_INLINE void	toNative (xyze_pos_t &)
bool	position_is_reachable (const float &rx, const float &ry)
bool	position_is_reachable (const xy_pos_t &pos)
FORCE_INLINE bool	position_is_reachable_by_probe (const xy_int_t &pos)
FORCE_INLINE bool	position_is_reachable_by_probe (const xy_pos_t &pos)

Variables
uint8_t	axis_homed
uint8_t	axis_known_position
constexpr uint8_t	xyz_bits = _BV(X_AXIS) | _BV(Y_AXIS) | _BV(Z_AXIS)
constexpr float	slop = 0.0001
bool	relative_mode
xyze_pos_t	current_position
xyze_pos_t	destination
xyz_pos_t	cartes
float	xy_probe_feedrate_mm_s
const feedRate_t	homing_feedrate_mm_s [XYZ]
feedRate_t	feedrate_mm_s
int16_t	feedrate_percentage
constexpr uint8_t	active_extruder = 0
constexpr xyz_pos_t	hotend_offset [1] = { { 0 } }
bool	soft_endstops_enabled
axis_limits_t	soft_endstop
bool	extruder_duplication_enabled
bool	mirrored_duplication_mode

Macro Definition Documentation

XY_PROBE_FEEDRATE_MM_S

#define XY_PROBE_FEEDRATE_MM_S   xy_probe_feedrate_mm_s

XYZ_DEFS

#define XYZ_DEFS	(		T,
			NAME,
			OPT
	)

Value:

extern const XYZval<T> NAME##_P; \
  FORCE_INLINE T NAME(AxisEnum axis) { return pgm_read_any(&NAME##_P[axis]); }

update_workspace_offset

#define update_workspace_offset

(

x

)

NOOP

MOTION_CONDITIONS

#define MOTION_CONDITIONS   IsRunning()

NATIVE_TO_LOGICAL

#define NATIVE_TO_LOGICAL	(		POS,
			AXIS
	)		(POS)

Workspace offsets

LOGICAL_TO_NATIVE

#define LOGICAL_TO_NATIVE	(		POS,
			AXIS
	)		(POS)

LOGICAL_X_POSITION

#define LOGICAL_X_POSITION

(

POS

)

NATIVE_TO_LOGICAL(POS, X_AXIS)

LOGICAL_Y_POSITION

#define LOGICAL_Y_POSITION

(

POS

)

NATIVE_TO_LOGICAL(POS, Y_AXIS)

LOGICAL_Z_POSITION

#define LOGICAL_Z_POSITION

(

POS

)

NATIVE_TO_LOGICAL(POS, Z_AXIS)

RAW_X_POSITION

#define RAW_X_POSITION

(

POS

)

LOGICAL_TO_NATIVE(POS, X_AXIS)

RAW_Y_POSITION

#define RAW_Y_POSITION

(

POS

)

LOGICAL_TO_NATIVE(POS, Y_AXIS)

RAW_Z_POSITION

#define RAW_Z_POSITION

(

POS

)

LOGICAL_TO_NATIVE(POS, Z_AXIS)

Function Documentation

all_axes_homed()

FORCE_INLINE bool all_axes_homed

(

)

{ return (axis_homed & xyz_bits) == xyz_bits; }

Here is the caller graph for this function:

all_axes_known()

FORCE_INLINE bool all_axes_known

(

)

{ return (axis_known_position & xyz_bits) == xyz_bits; }

Here is the caller graph for this function:

set_all_unhomed()

FORCE_INLINE void set_all_unhomed

(

)

{ axis_homed = 0; }

set_all_unknown()

FORCE_INLINE void set_all_unknown

(

)

{ axis_known_position = 0; }

homing_needed()

FORCE_INLINE bool homing_needed

(

)

                                  {
  return !(
    #if ENABLED(HOME_AFTER_DEACTIVATE)
      all_axes_known()
    #else
      all_axes_homed()
    #endif
  );
}

Here is the call graph for this function:

homing_feedrate()

FORCE_INLINE feedRate_t homing_feedrate

(

const AxisEnum

a

)

{ return pgm_read_float(&homing_feedrate_mm_s[a]); }

Here is the caller 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:

pgm_read_any() [1/2]

FORCE_INLINE float pgm_read_any

(

const float *

p

)

{ return pgm_read_float(p); }

pgm_read_any() [2/2]

FORCE_INLINE signed char pgm_read_any

(

const signed char *

p

)

{ return pgm_read_byte(p); }

XYZ_DEFS() [1/6]

XYZ_DEFS	(	float	,
		base_min_pos	,
		MIN_POS
	)

XYZ_DEFS() [2/6]

XYZ_DEFS	(	float	,
		base_max_pos	,
		MAX_POS
	)

XYZ_DEFS() [3/6]

XYZ_DEFS	(	float	,
		base_home_pos	,
		HOME_POS
	)

XYZ_DEFS() [4/6]

XYZ_DEFS	(	float	,
		max_length	,
		MAX_LENGTH
	)

XYZ_DEFS() [5/6]

XYZ_DEFS	(	float	,
		home_bump_mm	,
		HOME_BUMP_MM
	)

XYZ_DEFS() [6/6]

XYZ_DEFS	(	signed char	,
		home_dir	,
		HOME_DIR
	)

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:

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:

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:

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:

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:

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:

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:

_internal_move_to_destination()

void _internal_move_to_destination

(

const feedRate_t &

fr_mm_s = 0.0f

)

  {
  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:

prepare_internal_move_to_destination()

void prepare_internal_move_to_destination

(

const feedRate_t &

fr_mm_s = 0.0f

)

                                                                                 {
  _internal_move_to_destination(fr_mm_s);
}

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
	)

Blocking movement and shorthand functions

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 = 0.0f
	)

                                                                          {
  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 = 0.0f
	)

                                                                           {
  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 = 0.0f
	)

                                                                            {
  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 = 0.0f
	)

                                                                        {
  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 = 0.0f
	)

                                                                        {
  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 = 0.0f
	)

                                                                        {
  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/4]

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

                                                                                          {
  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/4]

void do_blocking_move_to_xy	(	const xy_pos_t &	raw,
		const feedRate_t &	fr_mm_s = 0.0f
	)

                                                                             {
  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() [3/4]

FORCE_INLINE void do_blocking_move_to_xy	(	const xyz_pos_t &	raw,
		const feedRate_t &	fr_mm_s = 0.0f
	)

{ do_blocking_move_to_xy(xy_pos_t(raw), fr_mm_s); }

Here is the call graph for this function:

do_blocking_move_to_xy() [4/4]

FORCE_INLINE void do_blocking_move_to_xy	(	const xyze_pos_t &	raw,
		const feedRate_t &	fr_mm_s = 0.0f
	)

{ do_blocking_move_to_xy(xy_pos_t(raw), fr_mm_s); }

Here is the call graph for this function:

do_blocking_move_to_xy_z() [1/3]

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

                                                                                               {
  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:

do_blocking_move_to_xy_z() [2/3]

FORCE_INLINE void do_blocking_move_to_xy_z	(	const xyz_pos_t &	raw,
		const float &	z,
		const feedRate_t &	fr_mm_s = 0.0f
	)

{ do_blocking_move_to_xy_z(xy_pos_t(raw), z, fr_mm_s); }

Here is the call graph for this function:

do_blocking_move_to_xy_z() [3/3]

FORCE_INLINE void do_blocking_move_to_xy_z	(	const xyze_pos_t &	raw,
		const float &	z,
		const feedRate_t &	fr_mm_s = 0.0f
	)

{ do_blocking_move_to_xy_z(xy_pos_t(raw), z, fr_mm_s); }

Here is the call 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;
}

axes_need_homing()

uint8_t axes_need_homing

(

uint8_t

axis_bits = 0x07

)

                                             {
  #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 = 0x07

)

                                            {
  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:

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:

toLogical() [1/3]

FORCE_INLINE void toLogical

(

xy_pos_t &

)

{}

Here is the caller graph for this function:

toLogical() [2/3]

FORCE_INLINE void toLogical

(

xyz_pos_t &

)

{}

toLogical() [3/3]

FORCE_INLINE void toLogical

(

xyze_pos_t &

)

{}

toNative() [1/3]

FORCE_INLINE void toNative

(

xy_pos_t &

)

{}

Here is the caller graph for this function:

toNative() [2/3]

FORCE_INLINE void toNative

(

xyz_pos_t &

)

{}

toNative() [3/3]

FORCE_INLINE void toNative

(

xyze_pos_t &

)

{}

position_is_reachable() [1/2]

bool position_is_reachable	(	const float &	rx,
		const float &	ry
	)

position_is_reachable family of functions

                                                                      {
    if (!WITHIN(ry, Y_MIN_POS - slop, Y_MAX_POS + slop)) return false;
    #if ENABLED(DUAL_X_CARRIAGE)
      if (active_extruder)
        return WITHIN(rx, X2_MIN_POS - slop, X2_MAX_POS + slop);
      else
        return WITHIN(rx, X1_MIN_POS - slop, X1_MAX_POS + slop);
    #else
      return WITHIN(rx, X_MIN_POS - slop, X_MAX_POS + slop);
    #endif
  }

Here is the caller graph for this function:

position_is_reachable() [2/2]

bool position_is_reachable

(

const xy_pos_t &

pos

)

{ return position_is_reachable(pos.x, pos.y); }

Here is the call graph for this function:

position_is_reachable_by_probe() [1/2]

FORCE_INLINE bool position_is_reachable_by_probe

(

const xy_int_t &

pos

)

{ return position_is_reachable_by_probe(pos.x, pos.y); }

Here is the caller graph for this function:

position_is_reachable_by_probe() [2/2]

FORCE_INLINE bool position_is_reachable_by_probe

(

const xy_pos_t &

pos

)

{ return position_is_reachable_by_probe(pos.x, pos.y); }

Here is the call graph for this function:

Variable Documentation

axis_homed

uint8_t axis_homed

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.h

High-level motion commands to feed the planner Some of these methods may migrate to the planner class.

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

xyz_bits

constexpr uint8_t xyz_bits = _BV(X_AXIS) | _BV(Y_AXIS) | _BV(Z_AXIS)

constexpr

slop

constexpr float slop = 0.0001

constexpr

relative_mode

bool relative_mode

current_position

xyze_pos_t current_position

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'

cartes

xyz_pos_t cartes

xy_probe_feedrate_mm_s

float xy_probe_feedrate_mm_s

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

homing_feedrate_mm_s

const feedRate_t homing_feedrate_mm_s[XYZ]

Feed rates are often configured with mm/m but the planner and stepper like mm/s units.

feedrate_mm_s

feedRate_t feedrate_mm_s

feedrate_percentage

int16_t feedrate_percentage

Feedrate scaling

active_extruder

constexpr uint8_t active_extruder = 0

constexpr

hotend_offset

constexpr xyz_pos_t hotend_offset[1] = { { 0 } }

constexpr

soft_endstops_enabled

bool soft_endstops_enabled

soft_endstop

axis_limits_t soft_endstop

extruder_duplication_enabled

bool extruder_duplication_enabled

Duplication mode

mirrored_duplication_mode

bool mirrored_duplication_mode