Stepper Class Reference

#include <stepper.h>

Collaboration diagram for Stepper:

Public Member Functions
	Stepper ()

Static Public Member Functions
static void	init ()
static void	isr ()
static void	stepper_pulse_phase_isr ()
static uint32_t	stepper_block_phase_isr ()
static bool	is_block_busy (const block_t *const block)
static int32_t	position (const AxisEnum axis)
static void	report_positions ()
static void	wake_up ()
static FORCE_INLINE void	quick_stop ()
static FORCE_INLINE bool	motor_direction (const AxisEnum axis)
static FORCE_INLINE bool	axis_is_moving (const AxisEnum axis)
static FORCE_INLINE uint8_t	movement_extruder ()
static void	endstop_triggered (const AxisEnum axis)
static int32_t	triggered_position (const AxisEnum axis)
static void	digitalPotWrite (const int16_t address, const int16_t value)
static void	digipot_current (const uint8_t driver, const int16_t current)
static void	microstep_ms (const uint8_t driver, const int8_t ms1, const int8_t ms2, const int8_t ms3)
static void	microstep_mode (const uint8_t driver, const uint8_t stepping)
static void	microstep_readings ()
static FORCE_INLINE void	set_separate_multi_axis (const bool state)
static FORCE_INLINE void	set_z_lock (const bool state)
static FORCE_INLINE void	set_z2_lock (const bool state)
static void	set_position (const int32_t &a, const int32_t &b, const int32_t &c, const int32_t &e)
static void	set_position (const xyze_long_t &abce)
static void	set_axis_position (const AxisEnum a, const int32_t &v)
static void	set_directions ()

Static Public Attributes
static bool	separate_multi_axis = false

Constructor & Destructor Documentation

Stepper()

Stepper::Stepper

(

)

{};

Member Function Documentation

init()

void Stepper::init ( )

static

                   {
 
  #if MB(ALLIGATOR)
    const float motor_current[] = MOTOR_CURRENT;
    unsigned int digipot_motor = 0;
    for (uint8_t i = 0; i < 3 + EXTRUDERS; i++) {
      digipot_motor = 255 * (motor_current[i] / 2.5);
      dac084s085::setValue(i, digipot_motor);
    }
  #endif//MB(ALLIGATOR)
 
  // Init Microstepping Pins
  #if HAS_MICROSTEPS
    microstep_init();
  #endif
 
  // Init Dir Pins
  #if HAS_X_DIR
    X_DIR_INIT;
  #endif
  #if HAS_X2_DIR
    X2_DIR_INIT;
  #endif
  #if HAS_Y_DIR
    Y_DIR_INIT;
    #if ENABLED(Y_DUAL_STEPPER_DRIVERS) && HAS_Y2_DIR
      Y2_DIR_INIT;
    #endif
  #endif
  #if HAS_Z_DIR
    Z_DIR_INIT;
    #if Z_MULTI_STEPPER_DRIVERS && HAS_Z2_DIR
      Z2_DIR_INIT;
    #endif
    #if ENABLED(Z_TRIPLE_STEPPER_DRIVERS) && HAS_Z3_DIR
      Z3_DIR_INIT;
    #endif
  #endif
  #if HAS_E0_DIR
    E0_DIR_INIT;
  #endif
  #if HAS_E1_DIR
    E1_DIR_INIT;
  #endif
  #if HAS_E2_DIR
    E2_DIR_INIT;
  #endif
  #if HAS_E3_DIR
    E3_DIR_INIT;
  #endif
  #if HAS_E4_DIR
    E4_DIR_INIT;
  #endif
  #if HAS_E5_DIR
    E5_DIR_INIT;
  #endif
 
  // Init Enable Pins - steppers default to disabled.
  #if HAS_X_ENABLE
    X_ENABLE_INIT;
    if (!X_ENABLE_ON) X_ENABLE_WRITE(HIGH);
    #if EITHER(DUAL_X_CARRIAGE, X_DUAL_STEPPER_DRIVERS) && HAS_X2_ENABLE
      X2_ENABLE_INIT;
      if (!X_ENABLE_ON) X2_ENABLE_WRITE(HIGH);
    #endif
  #endif
  #if HAS_Y_ENABLE
    Y_ENABLE_INIT;
    if (!Y_ENABLE_ON) Y_ENABLE_WRITE(HIGH);
    #if ENABLED(Y_DUAL_STEPPER_DRIVERS) && HAS_Y2_ENABLE
      Y2_ENABLE_INIT;
      if (!Y_ENABLE_ON) Y2_ENABLE_WRITE(HIGH);
    #endif
  #endif
  #if HAS_Z_ENABLE
    Z_ENABLE_INIT;
    if (!Z_ENABLE_ON) Z_ENABLE_WRITE(HIGH);
    #if Z_MULTI_STEPPER_DRIVERS && HAS_Z2_ENABLE
      Z2_ENABLE_INIT;
      if (!Z_ENABLE_ON) Z2_ENABLE_WRITE(HIGH);
    #endif
    #if ENABLED(Z_TRIPLE_STEPPER_DRIVERS) && HAS_Z3_ENABLE
      Z3_ENABLE_INIT;
      if (!Z_ENABLE_ON) Z3_ENABLE_WRITE(HIGH);
    #endif
  #endif
  #if HAS_E0_ENABLE
    E0_ENABLE_INIT;
    if (!E_ENABLE_ON) E0_ENABLE_WRITE(HIGH);
  #endif
  #if HAS_E1_ENABLE
    E1_ENABLE_INIT;
    if (!E_ENABLE_ON) E1_ENABLE_WRITE(HIGH);
  #endif
  #if HAS_E2_ENABLE
    E2_ENABLE_INIT;
    if (!E_ENABLE_ON) E2_ENABLE_WRITE(HIGH);
  #endif
  #if HAS_E3_ENABLE
    E3_ENABLE_INIT;
    if (!E_ENABLE_ON) E3_ENABLE_WRITE(HIGH);
  #endif
  #if HAS_E4_ENABLE
    E4_ENABLE_INIT;
    if (!E_ENABLE_ON) E4_ENABLE_WRITE(HIGH);
  #endif
  #if HAS_E5_ENABLE
    E5_ENABLE_INIT;
    if (!E_ENABLE_ON) E5_ENABLE_WRITE(HIGH);
  #endif
 
  #define _STEP_INIT(AXIS) AXIS ##_STEP_INIT
  #define _WRITE_STEP(AXIS, HIGHLOW) AXIS ##_STEP_WRITE(HIGHLOW)
  #define _DISABLE(AXIS) disable_## AXIS()
 
  #define AXIS_INIT(AXIS, PIN) \
    _STEP_INIT(AXIS); \
    _WRITE_STEP(AXIS, _INVERT_STEP_PIN(PIN)); \
    _DISABLE(AXIS)
 
  #define E_AXIS_INIT(NUM) AXIS_INIT(E## NUM, E)
 
  // Init Step Pins
  #if HAS_X_STEP
    #if EITHER(X_DUAL_STEPPER_DRIVERS, DUAL_X_CARRIAGE)
      X2_STEP_INIT;
      X2_STEP_WRITE(INVERT_X_STEP_PIN);
    #endif
    AXIS_INIT(X, X);
  #endif
 
  #if HAS_Y_STEP
    #if ENABLED(Y_DUAL_STEPPER_DRIVERS)
      Y2_STEP_INIT;
      Y2_STEP_WRITE(INVERT_Y_STEP_PIN);
    #endif
    AXIS_INIT(Y, Y);
  #endif
 
  #if HAS_Z_STEP
    #if Z_MULTI_STEPPER_DRIVERS
      Z2_STEP_INIT;
      Z2_STEP_WRITE(INVERT_Z_STEP_PIN);
    #endif
    #if ENABLED(Z_TRIPLE_STEPPER_DRIVERS)
      Z3_STEP_INIT;
      Z3_STEP_WRITE(INVERT_Z_STEP_PIN);
    #endif
    AXIS_INIT(Z, Z);
  #endif
 
  #if E_STEPPERS > 0 && HAS_E0_STEP
    E_AXIS_INIT(0);
  #endif
  #if E_STEPPERS > 1 && HAS_E1_STEP
    E_AXIS_INIT(1);
  #endif
  #if E_STEPPERS > 2 && HAS_E2_STEP
    E_AXIS_INIT(2);
  #endif
  #if E_STEPPERS > 3 && HAS_E3_STEP
    E_AXIS_INIT(3);
  #endif
  #if E_STEPPERS > 4 && HAS_E4_STEP
    E_AXIS_INIT(4);
  #endif
  #if E_STEPPERS > 5 && HAS_E5_STEP
    E_AXIS_INIT(5);
  #endif
 
  #if DISABLED(I2S_STEPPER_STREAM)
    HAL_timer_start(STEP_TIMER_NUM, 122); // Init Stepper ISR to 122 Hz for quick starting
    ENABLE_STEPPER_DRIVER_INTERRUPT();
    sei();
  #endif
 
  // Init direction bits for first moves
  last_direction_bits = 0
    | (INVERT_X_DIR ? _BV(X_AXIS) : 0)
    | (INVERT_Y_DIR ? _BV(Y_AXIS) : 0)
    | (INVERT_Z_DIR ? _BV(Z_AXIS) : 0);
 
  set_directions();
 
  #if HAS_DIGIPOTSS || HAS_MOTOR_CURRENT_PWM
    #if HAS_MOTOR_CURRENT_PWM
      initialized = true;
    #endif
    digipot_init();
  #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

isr()

void Stepper::isr ( )

static

This needs to avoid a race-condition caused by interleaving of interrupts required by both the LA and Stepper algorithms.

Assume the following tick times for stepper pulses: Stepper ISR (S): 1 1000 2000 3000 4000 Linear Adv. (E): 10 1010 2010 3010 4010

The current algorithm tries to interleave them, giving: 1:S 10:E 1000:S 1010:E 2000:S 2010:E 3000:S 3010:E 4000:S 4010:E

Ideal timing would yield these delta periods: 1:S 9:E 990:S 10:E 990:S 10:E 990:S 10:E 990:S 10:E

But, since each event must fire an ISR with a minimum duration, the minimum delta might be 900, so deltas under 900 get rounded up: 900:S d900:E d990:S d900:E d990:S d900:E d990:S d900:E d990:S d900:E

It works, but divides the speed of all motors by half, leading to a sudden reduction to 1/2 speed! Such jumps in speed lead to lost steps (not even accounting for double/quad stepping, which makes it even worse).

The following section must be done with global interrupts disabled. We want nothing to interrupt it, as that could mess the calculations we do for the next value to program in the period register of the stepper timer and lead to skipped ISRs (if the value we happen to program is less than the current count due to something preempting between the read and the write of the new period value).

Get the current tick value + margin Assuming at least 6µs between calls to this ISR... On AVR the ISR epilogue+prologue is estimated at 100 instructions - Give 8µs as margin On ARM the ISR epilogue+prologue is estimated at 20 instructions - Give 1µs as margin

NB: If for some reason the stepper monopolizes the MPU, eventually the timer will wrap around (and so will 'next_isr_ticks'). So, limit the loop to 10 iterations. Beyond that, there's no way to ensure correct pulse timing, since the MCU isn't fast enough.

                  {
  #ifndef __AVR__
    // Disable interrupts, to avoid ISR preemption while we reprogram the period
    // (AVR enters the ISR with global interrupts disabled, so no need to do it here)
    DISABLE_ISRS();
  #endif
 
  // Program timer compare for the maximum period, so it does NOT
  // flag an interrupt while this ISR is running - So changes from small
  // periods to big periods are respected and the timer does not reset to 0
  HAL_timer_set_compare(STEP_TIMER_NUM, hal_timer_t(HAL_TIMER_TYPE_MAX));
 
  // Count of ticks for the next ISR
  hal_timer_t next_isr_ticks = 0;
 
  // Limit the amount of iterations
  uint8_t max_loops = 10;
 
  // We need this variable here to be able to use it in the following loop
  hal_timer_t min_ticks;
  do {
    // Enable ISRs to reduce USART processing latency
    ENABLE_ISRS();
 
    // Run main stepping pulse phase ISR if we have to
    if (!nextMainISR) Stepper::stepper_pulse_phase_isr();
 
    #if ENABLED(LIN_ADVANCE)
      // Run linear advance stepper ISR if we have to
      if (!nextAdvanceISR) nextAdvanceISR = Stepper::advance_isr();
    #endif
 
    // ^== Time critical. NOTHING besides pulse generation should be above here!!!
 
    // Run main stepping block processing ISR if we have to
    if (!nextMainISR) nextMainISR = Stepper::stepper_block_phase_isr();
 
    uint32_t interval =
      #if ENABLED(LIN_ADVANCE)
        _MIN(nextAdvanceISR, nextMainISR)  // Nearest time interval
      #else
        nextMainISR                       // Remaining stepper ISR time
      #endif
    ;
 
    // Limit the value to the maximum possible value of the timer
    NOMORE(interval, uint32_t(HAL_TIMER_TYPE_MAX));
 
    // Compute the time remaining for the main isr
    nextMainISR -= interval;
 
    #if ENABLED(LIN_ADVANCE)
      // Compute the time remaining for the advance isr
      if (nextAdvanceISR != LA_ADV_NEVER) nextAdvanceISR -= interval;
    #endif
 
    /**
     * This needs to avoid a race-condition caused by interleaving
     * of interrupts required by both the LA and Stepper algorithms.
     *
     * Assume the following tick times for stepper pulses:
     *   Stepper ISR (S):  1 1000 2000 3000 4000
     *   Linear Adv. (E): 10 1010 2010 3010 4010
     *
     * The current algorithm tries to interleave them, giving:
     *  1:S 10:E 1000:S 1010:E 2000:S 2010:E 3000:S 3010:E 4000:S 4010:E
     *
     * Ideal timing would yield these delta periods:
     *  1:S  9:E  990:S   10:E  990:S   10:E  990:S   10:E  990:S   10:E
     *
     * But, since each event must fire an ISR with a minimum duration, the
     * minimum delta might be 900, so deltas under 900 get rounded up:
     *  900:S d900:E d990:S d900:E d990:S d900:E d990:S d900:E d990:S d900:E
     *
     * It works, but divides the speed of all motors by half, leading to a sudden
     * reduction to 1/2 speed! Such jumps in speed lead to lost steps (not even
     * accounting for double/quad stepping, which makes it even worse).
     */
 
    // Compute the tick count for the next ISR
    next_isr_ticks += interval;
 
    /**
     * The following section must be done with global interrupts disabled.
     * We want nothing to interrupt it, as that could mess the calculations
     * we do for the next value to program in the period register of the
     * stepper timer and lead to skipped ISRs (if the value we happen to program
     * is less than the current count due to something preempting between the
     * read and the write of the new period value).
     */
    DISABLE_ISRS();
 
    /**
     * Get the current tick value + margin
     * Assuming at least 6µs between calls to this ISR...
     * On AVR the ISR epilogue+prologue is estimated at 100 instructions - Give 8µs as margin
     * On ARM the ISR epilogue+prologue is estimated at 20 instructions - Give 1µs as margin
     */
    min_ticks = HAL_timer_get_count(STEP_TIMER_NUM) + hal_timer_t(
      #ifdef __AVR__
        8
      #else
        1
      #endif
      * (STEPPER_TIMER_TICKS_PER_US)
    );
 
    /**
     * NB: If for some reason the stepper monopolizes the MPU, eventually the
     * timer will wrap around (and so will 'next_isr_ticks'). So, limit the
     * loop to 10 iterations. Beyond that, there's no way to ensure correct pulse
     * timing, since the MCU isn't fast enough.
     */
    if (!--max_loops) next_isr_ticks = min_ticks;
 
    // Advance pulses if not enough time to wait for the next ISR
  } while (next_isr_ticks < min_ticks);
 
  // Now 'next_isr_ticks' contains the period to the next Stepper ISR - And we are
  // sure that the time has not arrived yet - Warrantied by the scheduler
 
  // Set the next ISR to fire at the proper time
  HAL_timer_set_compare(STEP_TIMER_NUM, hal_timer_t(next_isr_ticks));
 
  // Don't forget to finally reenable interrupts
  ENABLE_ISRS();
}

Here is the call graph for this function:

Here is the caller graph for this function:

stepper_pulse_phase_isr()

void Stepper::stepper_pulse_phase_isr ( )

static

This phase of the ISR should ONLY create the pulses for the steppers. This prevents jitter caused by the interval between the start of the interrupt and the start of the pulses. DON'T add any logic ahead of the call to this method that might cause variation in the timing. The aim is to keep pulse timing as regular as possible.

                                      {
 
  // If we must abort the current block, do so!
  if (abort_current_block) {
    abort_current_block = false;
    if (current_block) {
      axis_did_move = 0;
      current_block = nullptr;
      planner.discard_current_block();
    }
  }
 
  // If there is no current block, do nothing
  if (!current_block) return;
 
  // Count of pending loops and events for this iteration
  const uint32_t pending_events = step_event_count - step_events_completed;
  uint8_t events_to_do = _MIN(pending_events, steps_per_isr);
 
  // Just update the value we will get at the end of the loop
  step_events_completed += events_to_do;
 
  // Get the timer count and estimate the end of the pulse
  hal_timer_t pulse_end = HAL_timer_get_count(PULSE_TIMER_NUM) + hal_timer_t(MIN_PULSE_TICKS);
 
  const hal_timer_t added_step_ticks = hal_timer_t(ADDED_STEP_TICKS);
 
  // Take multiple steps per interrupt (For high speed moves)
  do {
 
    #define _APPLY_STEP(AXIS) AXIS ##_APPLY_STEP
    #define _INVERT_STEP_PIN(AXIS) INVERT_## AXIS ##_STEP_PIN
 
    // Start an active pulse, if Bresenham says so, and update position
    #define PULSE_START(AXIS) do{ \
      delta_error[_AXIS(AXIS)] += advance_dividend[_AXIS(AXIS)]; \
      if (delta_error[_AXIS(AXIS)] >= 0) { \
        _APPLY_STEP(AXIS)(!_INVERT_STEP_PIN(AXIS), 0); \
        count_position[_AXIS(AXIS)] += count_direction[_AXIS(AXIS)]; \
      } \
    }while(0)
 
    // Stop an active pulse, if any, and adjust error term
    #define PULSE_STOP(AXIS) do { \
      if (delta_error[_AXIS(AXIS)] >= 0) { \
        delta_error[_AXIS(AXIS)] -= advance_divisor; \
        _APPLY_STEP(AXIS)(_INVERT_STEP_PIN(AXIS), 0); \
      } \
    }while(0)
 
    // Pulse start
    #if HAS_X_STEP
      PULSE_START(X);
    #endif
    #if HAS_Y_STEP
      PULSE_START(Y);
    #endif
    #if HAS_Z_STEP
      PULSE_START(Z);
    #endif
 
    // Pulse Extruders
    // Tick the E axis, correct error term and update position
    #if EITHER(LIN_ADVANCE, MIXING_EXTRUDER)
      delta_error.e += advance_dividend.e;
      if (delta_error.e >= 0) {
        //count_position.e += count_direction.e;
        //temporary solution to get count_position[E_AXIS] with enabled LA
        //because with LA count_direction[E_AXIS] not set and is always =0
        //we use motor_direction(E_AXIS) instead of count_direction[E_AXIS]
        count_position[E_AXIS] += motor_direction(E_AXIS)?-1:1;
        #if ENABLED(LIN_ADVANCE)
          delta_error.e -= advance_divisor;
          // Don't step E here - But remember the number of steps to perform
          motor_direction(E_AXIS) ? --LA_steps : ++LA_steps;
        #else // !LIN_ADVANCE && MIXING_EXTRUDER
          // Don't adjust delta_error.e here!
          // Being positive is the criteria for ending the pulse.
          E_STEP_WRITE(mixer.get_next_stepper(), !INVERT_E_STEP_PIN);
        #endif
      }
    #else // !LIN_ADVANCE && !MIXING_EXTRUDER
      #if HAS_E0_STEP
        PULSE_START(E);
      #endif
    #endif
 
    #if ENABLED(I2S_STEPPER_STREAM)
      i2s_push_sample();
    #endif
 
    // TODO: need to deal with MINIMUM_STEPPER_PULSE over i2s
    #if MINIMUM_STEPPER_PULSE && DISABLED(I2S_STEPPER_STREAM)
      // Just wait for the requested pulse duration
      while (HAL_timer_get_count(PULSE_TIMER_NUM) < pulse_end) { /* nada */ }
    #endif
 
    // Add the delay needed to ensure the maximum driver rate is enforced
    if (signed(added_step_ticks) > 0) pulse_end += hal_timer_t(added_step_ticks);
 
    // Pulse stop
    #if HAS_X_STEP
      PULSE_STOP(X);
    #endif
    #if HAS_Y_STEP
      PULSE_STOP(Y);
    #endif
    #if HAS_Z_STEP
      PULSE_STOP(Z);
    #endif
 
    #if DISABLED(LIN_ADVANCE)
      #if ENABLED(MIXING_EXTRUDER)
        if (delta_error.e >= 0) {
          delta_error.e -= advance_divisor;
          E_STEP_WRITE(mixer.get_stepper(), INVERT_E_STEP_PIN);
        }
      #else // !MIXING_EXTRUDER
        #if HAS_E0_STEP
          PULSE_STOP(E);
        #endif
      #endif
    #endif // !LIN_ADVANCE
 
    // Decrement the count of pending pulses to do
    --events_to_do;
 
    // For minimum pulse time wait after stopping pulses also
    if (events_to_do) {
      // Just wait for the requested pulse duration
      while (HAL_timer_get_count(PULSE_TIMER_NUM) < pulse_end) { /* nada */ }
      #if MINIMUM_STEPPER_PULSE
        // Add to the value, the time that the pulse must be active (to be used on the next loop)
        pulse_end += hal_timer_t(MIN_PULSE_TICKS);
      #endif
    }
 
  } while (events_to_do);
}

Here is the call graph for this function:

Here is the caller graph for this function:

stepper_block_phase_isr()

uint32_t Stepper::stepper_block_phase_isr ( )

static

Head direction in -X axis for CoreXY and CoreXZ bots.

If steps differ, both axes are moving. If DeltaA == -DeltaB, the movement is only in the 2nd axis (Y or Z, handled below) If DeltaA == DeltaB, the movement is only in the 1st axis (X)

Head direction in -Y axis for CoreXY / CoreYZ bots.

If steps differ, both axes are moving If DeltaA == DeltaB, the movement is only in the 1st axis (X or Y) If DeltaA == -DeltaB, the movement is only in the 2nd axis (Y or Z)

Head direction in -Z axis for CoreXZ or CoreYZ bots.

If steps differ, both axes are moving If DeltaA == DeltaB, the movement is only in the 1st axis (X or Y, already handled above) If DeltaA == -DeltaB, the movement is only in the 2nd axis (Z)

                                          {
 
  // If no queued movements, just wait 1ms for the next move
  uint32_t interval = (STEPPER_TIMER_RATE / 1000);
 
  // If there is a current block
  if (current_block) {
 
    // If current block is finished, reset pointer
    if (step_events_completed >= step_event_count) {
      #ifdef FILAMENT_RUNOUT_DISTANCE_MM
        runout.block_completed(current_block);
      #endif
      axis_did_move = 0;
      current_block = nullptr;
      planner.discard_current_block();
    }
    else {
      // Step events not completed yet...
 
      // Are we in acceleration phase ?
      if (step_events_completed <= accelerate_until) { // Calculate new timer value
 
        #if ENABLED(S_CURVE_ACCELERATION)
          // Get the next speed to use (Jerk limited!)
          uint32_t acc_step_rate =
            acceleration_time < current_block->acceleration_time
              ? _eval_bezier_curve(acceleration_time)
              : current_block->cruise_rate;
        #else
          acc_step_rate = STEP_MULTIPLY(acceleration_time, current_block->acceleration_rate) + current_block->initial_rate;
          NOMORE(acc_step_rate, current_block->nominal_rate);
        #endif
 
        // acc_step_rate is in steps/second
 
        // step_rate to timer interval and steps per stepper isr
        interval = calc_timer_interval(acc_step_rate, oversampling_factor, &steps_per_isr);
        acceleration_time += interval;
 
        #if ENABLED(LIN_ADVANCE)
          if (LA_use_advance_lead) {
            // Fire ISR if final adv_rate is reached
            if (LA_steps && LA_isr_rate != current_block->advance_speed) nextAdvanceISR = 0;
          }
          else if (LA_steps) nextAdvanceISR = 0;
        #endif // LIN_ADVANCE
      }
      // Are we in Deceleration phase ?
      else if (step_events_completed > decelerate_after) {
        uint32_t step_rate;
 
        #if ENABLED(S_CURVE_ACCELERATION)
          // If this is the 1st time we process the 2nd half of the trapezoid...
          if (!bezier_2nd_half) {
            // Initialize the Bézier speed curve
            _calc_bezier_curve_coeffs(current_block->cruise_rate, current_block->final_rate, current_block->deceleration_time_inverse);
            bezier_2nd_half = true;
            // The first point starts at cruise rate. Just save evaluation of the Bézier curve
            step_rate = current_block->cruise_rate;
          }
          else {
            // Calculate the next speed to use
            step_rate = deceleration_time < current_block->deceleration_time
              ? _eval_bezier_curve(deceleration_time)
              : current_block->final_rate;
          }
        #else
 
          // Using the old trapezoidal control
          step_rate = STEP_MULTIPLY(deceleration_time, current_block->acceleration_rate);
          if (step_rate < acc_step_rate) { // Still decelerating?
            step_rate = acc_step_rate - step_rate;
            NOLESS(step_rate, current_block->final_rate);
          }
          else
            step_rate = current_block->final_rate;
        #endif
 
        // step_rate is in steps/second
 
        // step_rate to timer interval and steps per stepper isr
        interval = calc_timer_interval(step_rate, oversampling_factor, &steps_per_isr);
        deceleration_time += interval;
 
        #if ENABLED(LIN_ADVANCE)
          if (LA_use_advance_lead) {
            // Wake up eISR on first deceleration loop and fire ISR if final adv_rate is reached
            if (step_events_completed <= decelerate_after + steps_per_isr || (LA_steps && LA_isr_rate != current_block->advance_speed)) {
              nextAdvanceISR = 0;
              LA_isr_rate = current_block->advance_speed;
            }
          }
          else if (LA_steps) nextAdvanceISR = 0;
        #endif // LIN_ADVANCE
      }
      // We must be in cruise phase otherwise
      else {
 
        #if ENABLED(LIN_ADVANCE)
          // If there are any esteps, fire the next advance_isr "now"
          if (LA_steps && LA_isr_rate != current_block->advance_speed) nextAdvanceISR = 0;
        #endif
 
        // Calculate the ticks_nominal for this nominal speed, if not done yet
        if (ticks_nominal < 0) {
          // step_rate to timer interval and loops for the nominal speed
          ticks_nominal = calc_timer_interval(current_block->nominal_rate, oversampling_factor, &steps_per_isr);
        }
 
        // The timer interval is just the nominal value for the nominal speed
        interval = ticks_nominal;
      }
    }
  }
 
  // If there is no current block at this point, attempt to pop one from the buffer
  // and prepare its movement
  if (!current_block) {
 
    // Anything in the buffer?
    if ((current_block = planner.get_current_block())) {
 
      // Sync block? Sync the stepper counts and return
      while (TEST(current_block->flag, BLOCK_BIT_SYNC_POSITION)) {
        _set_position(current_block->position);
        planner.discard_current_block();
 
        // Try to get a new block
        if (!(current_block = planner.get_current_block()))
          return interval; // No more queued movements!
      }
 
      #if HAS_CUTTER
        cutter.apply_power(current_block->cutter_power);
      #endif
 
      #if ENABLED(POWER_LOSS_RECOVERY)
        recovery.info.sdpos = current_block->sdpos;
      #endif
 
      // Flag all moving axes for proper endstop handling
 
      #if IS_CORE
        // Define conditions for checking endstops
        #define S_(N) current_block->steps[CORE_AXIS_##N]
        #define D_(N) TEST(current_block->direction_bits, CORE_AXIS_##N)
      #endif
 
      #if CORE_IS_XY || CORE_IS_XZ
        /**
         * Head direction in -X axis for CoreXY and CoreXZ bots.
         *
         * If steps differ, both axes are moving.
         * If DeltaA == -DeltaB, the movement is only in the 2nd axis (Y or Z, handled below)
         * If DeltaA ==  DeltaB, the movement is only in the 1st axis (X)
         */
        #if EITHER(COREXY, COREXZ)
          #define X_CMP ==
        #else
          #define X_CMP !=
        #endif
        #define X_MOVE_TEST ( S_(1) != S_(2) || (S_(1) > 0 && D_(1) X_CMP D_(2)) )
      #else
        #define X_MOVE_TEST !!current_block->steps.a
      #endif
 
      #if CORE_IS_XY || CORE_IS_YZ
        /**
         * Head direction in -Y axis for CoreXY / CoreYZ bots.
         *
         * If steps differ, both axes are moving
         * If DeltaA ==  DeltaB, the movement is only in the 1st axis (X or Y)
         * If DeltaA == -DeltaB, the movement is only in the 2nd axis (Y or Z)
         */
        #if EITHER(COREYX, COREYZ)
          #define Y_CMP ==
        #else
          #define Y_CMP !=
        #endif
        #define Y_MOVE_TEST ( S_(1) != S_(2) || (S_(1) > 0 && D_(1) Y_CMP D_(2)) )
      #else
        #define Y_MOVE_TEST !!current_block->steps.b
      #endif
 
      #if CORE_IS_XZ || CORE_IS_YZ
        /**
         * Head direction in -Z axis for CoreXZ or CoreYZ bots.
         *
         * If steps differ, both axes are moving
         * If DeltaA ==  DeltaB, the movement is only in the 1st axis (X or Y, already handled above)
         * If DeltaA == -DeltaB, the movement is only in the 2nd axis (Z)
         */
        #if EITHER(COREZX, COREZY)
          #define Z_CMP ==
        #else
          #define Z_CMP !=
        #endif
        #define Z_MOVE_TEST ( S_(1) != S_(2) || (S_(1) > 0 && D_(1) Z_CMP D_(2)) )
      #else
        #define Z_MOVE_TEST !!current_block->steps.c
      #endif
 
      uint8_t axis_bits = 0;
      if (X_MOVE_TEST) SBI(axis_bits, A_AXIS);
      if (Y_MOVE_TEST) SBI(axis_bits, B_AXIS);
      if (Z_MOVE_TEST) SBI(axis_bits, C_AXIS);
      if (!!current_block->steps.e) SBI(axis_bits, E_AXIS);
      //if (!!current_block->steps.a) SBI(axis_bits, X_HEAD);
      //if (!!current_block->steps.b) SBI(axis_bits, Y_HEAD);
      //if (!!current_block->steps.c) SBI(axis_bits, Z_HEAD);
      axis_did_move = axis_bits;
 
      // No acceleration / deceleration time elapsed so far
      acceleration_time = deceleration_time = 0;
 
      uint8_t oversampling = 0;                         // Assume we won't use it
 
      #if ENABLED(ADAPTIVE_STEP_SMOOTHING)
        // At this point, we must decide if we can use Stepper movement axis smoothing.
        uint32_t max_rate = current_block->nominal_rate;  // Get the maximum rate (maximum event speed)
        while (max_rate < MIN_STEP_ISR_FREQUENCY) {
          max_rate <<= 1;
          if (max_rate >= MAX_STEP_ISR_FREQUENCY_1X) break;
          ++oversampling;
        }
        oversampling_factor = oversampling;
      #endif
 
      // Based on the oversampling factor, do the calculations
      step_event_count = current_block->step_event_count << oversampling;
 
      // Initialize Bresenham delta errors to 1/2
      delta_error = -int32_t(step_event_count);
 
      // Calculate Bresenham dividends and divisors
      advance_dividend = current_block->steps << 1;
      advance_divisor = step_event_count << 1;
 
      // No step events completed so far
      step_events_completed = 0;
 
      // Compute the acceleration and deceleration points
      accelerate_until = current_block->accelerate_until << oversampling;
      decelerate_after = current_block->decelerate_after << oversampling;
 
      #if ENABLED(MIXING_EXTRUDER)
        MIXER_STEPPER_SETUP();
      #endif
 
      #if EXTRUDERS > 1
        stepper_extruder = current_block->extruder;
      #endif
 
      // Initialize the trapezoid generator from the current block.
      #if ENABLED(LIN_ADVANCE)
        #if DISABLED(MIXING_EXTRUDER) && E_STEPPERS > 1
          // If the now active extruder wasn't in use during the last move, its pressure is most likely gone.
          if (stepper_extruder != last_moved_extruder) LA_current_adv_steps = 0;
        #endif
 
        if ((LA_use_advance_lead = current_block->use_advance_lead)) {
          LA_final_adv_steps = current_block->final_adv_steps;
          LA_max_adv_steps = current_block->max_adv_steps;
          //Start the ISR
          nextAdvanceISR = 0;
          LA_isr_rate = current_block->advance_speed;
        }
        else LA_isr_rate = LA_ADV_NEVER;
      #endif
 
      if (
        #if HAS_DRIVER(L6470)
          true  // Always set direction for L6470 (This also enables the chips)
        #else
          current_block->direction_bits != last_direction_bits
          #if DISABLED(MIXING_EXTRUDER)
            || stepper_extruder != last_moved_extruder
          #endif
        #endif
      ) {
        last_direction_bits = current_block->direction_bits;
        #if EXTRUDERS > 1
          last_moved_extruder = stepper_extruder;
        #endif
        set_directions();
      }
 
      // At this point, we must ensure the movement about to execute isn't
      // trying to force the head against a limit switch. If using interrupt-
      // driven change detection, and already against a limit then no call to
      // the endstop_triggered method will be done and the movement will be
      // done against the endstop. So, check the limits here: If the movement
      // is against the limits, the block will be marked as to be killed, and
      // on the next call to this ISR, will be discarded.
      endstops.update();
 
      #if ENABLED(Z_LATE_ENABLE)
        // If delayed Z enable, enable it now. This option will severely interfere with
        // timing between pulses when chaining motion between blocks, and it could lead
        // to lost steps in both X and Y axis, so avoid using it unless strictly necessary!!
        if (current_block->steps.z) enable_Z();
      #endif
 
      // Mark the time_nominal as not calculated yet
      ticks_nominal = -1;
 
      #if DISABLED(S_CURVE_ACCELERATION)
        // Set as deceleration point the initial rate of the block
        acc_step_rate = current_block->initial_rate;
      #endif
 
      #if ENABLED(S_CURVE_ACCELERATION)
        // Initialize the Bézier speed curve
        _calc_bezier_curve_coeffs(current_block->initial_rate, current_block->cruise_rate, current_block->acceleration_time_inverse);
        // We haven't started the 2nd half of the trapezoid
        bezier_2nd_half = false;
      #endif
 
      // Calculate the initial timer interval
      interval = calc_timer_interval(current_block->initial_rate, oversampling_factor, &steps_per_isr);
    }
  }
 
  // Return the interval to wait
  return interval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_block_busy()

bool Stepper::is_block_busy ( const block_t *const  block )

static

                                                      {
  #ifdef __AVR__
    // A SW memory barrier, to ensure GCC does not overoptimize loops
    #define sw_barrier() asm volatile("": : :"memory");
 
    // Keep reading until 2 consecutive reads return the same value,
    // meaning there was no update in-between caused by an interrupt.
    // This works because stepper ISRs happen at a slower rate than
    // successive reads of a variable, so 2 consecutive reads with
    // the same value means no interrupt updated it.
    block_t* vold, *vnew = current_block;
    sw_barrier();
    do {
      vold = vnew;
      vnew = current_block;
      sw_barrier();
    } while (vold != vnew);
  #else
    block_t *vnew = current_block;
  #endif
 
  // Return if the block is busy or not
  return block == vnew;
}

position()

int32_t Stepper::position ( const AxisEnum  axis )

static

Get a stepper's position in steps.

                                             {
  #ifdef __AVR__
    // Protect the access to the position. Only required for AVR, as
    //  any 32bit CPU offers atomic access to 32bit variables
    const bool was_enabled = STEPPER_ISR_ENABLED();
    if (was_enabled) DISABLE_STEPPER_DRIVER_INTERRUPT();
  #endif
 
  const int32_t v = count_position[axis];
 
  #ifdef __AVR__
    // Reenable Stepper ISR
    if (was_enabled) ENABLE_STEPPER_DRIVER_INTERRUPT();
  #endif
  return v;
}

Here is the caller graph for this function:

report_positions()

void Stepper::report_positions ( )

static

                               {
 
  #ifdef __AVR__
    // Protect the access to the position.
    const bool was_enabled = STEPPER_ISR_ENABLED();
    if (was_enabled) DISABLE_STEPPER_DRIVER_INTERRUPT();
  #endif
 
  const xyz_long_t pos = count_position;
 
  #ifdef __AVR__
    if (was_enabled) ENABLE_STEPPER_DRIVER_INTERRUPT();
  #endif
 
  #if CORE_IS_XY || CORE_IS_XZ || ENABLED(DELTA) || IS_SCARA
    SERIAL_ECHOPAIR(MSG_COUNT_A, pos.x, " B:", pos.y);
  #else
    SERIAL_ECHOPAIR(MSG_COUNT_X, pos.x, " Y:", pos.y);
  #endif
  #if CORE_IS_XZ || CORE_IS_YZ || ENABLED(DELTA)
    SERIAL_ECHOLNPAIR(" C:", pos.z);
  #else
    SERIAL_ECHOLNPAIR(" Z:", pos.z);
  #endif
}

Here is the caller graph for this function:

wake_up()

void Stepper::wake_up ( )

static

                      {
  // TCNT1 = 0;
  ENABLE_STEPPER_DRIVER_INTERRUPT();
}

Here is the caller graph for this function:

quick_stop()

static FORCE_INLINE void Stepper::quick_stop ( )

static

{ abort_current_block = true; }

Here is the caller graph for this function:

motor_direction()

static FORCE_INLINE bool Stepper::motor_direction ( const AxisEnum  axis )

static

{ return TEST(last_direction_bits, axis); }

Here is the caller graph for this function:

axis_is_moving()

static FORCE_INLINE bool Stepper::axis_is_moving ( const AxisEnum  axis )

static

{ return TEST(axis_did_move, axis); }

Here is the caller graph for this function:

movement_extruder()

static FORCE_INLINE uint8_t Stepper::movement_extruder ( )

static

                                                    {
      return (0
        #if EXTRUDERS > 1 && DISABLED(MIXING_EXTRUDER)
          + last_moved_extruder
        #endif
      );
    }

endstop_triggered()

void Stepper::endstop_triggered ( const AxisEnum  axis )

static

                                                   {
 
  const bool was_enabled = STEPPER_ISR_ENABLED();
  if (was_enabled) DISABLE_STEPPER_DRIVER_INTERRUPT();
  endstops_trigsteps[axis] = (
    #if IS_CORE
      (axis == CORE_AXIS_2
        ? CORESIGN(count_position[CORE_AXIS_1] - count_position[CORE_AXIS_2])
        : count_position[CORE_AXIS_1] + count_position[CORE_AXIS_2]
      ) * 0.5f
    #else // !IS_CORE
      count_position[axis]
    #endif
  );
 
  // Discard the rest of the move if there is a current block
  quick_stop();
 
  if (was_enabled) ENABLE_STEPPER_DRIVER_INTERRUPT();
}

Here is the call graph for this function:

Here is the caller graph for this function:

triggered_position()

int32_t Stepper::triggered_position ( const AxisEnum  axis )

static

                                                       {
  #ifdef __AVR__
    // Protect the access to the position. Only required for AVR, as
    //  any 32bit CPU offers atomic access to 32bit variables
    const bool was_enabled = STEPPER_ISR_ENABLED();
    if (was_enabled) DISABLE_STEPPER_DRIVER_INTERRUPT();
  #endif
 
  const int32_t v = endstops_trigsteps[axis];
 
  #ifdef __AVR__
    // Reenable Stepper ISR
    if (was_enabled) ENABLE_STEPPER_DRIVER_INTERRUPT();
  #endif
 
  return v;
}

Here is the caller graph for this function:

digitalPotWrite()

static void Stepper::digitalPotWrite ( const int16_t  address, const int16_t  value  )

static

Here is the caller graph for this function:

digipot_current()

void Stepper::digipot_current ( const uint8_t  driver, const int16_t  current  )

static

Software-controlled Stepper Motor Current

                                                                             {
 
      #if HAS_DIGIPOTSS
 
        const uint8_t digipot_ch[] = DIGIPOT_CHANNELS;
        digitalPotWrite(digipot_ch[driver], current);
 
      #elif HAS_MOTOR_CURRENT_PWM
 
        if (!initialized) return;
 
        if (WITHIN(driver, 0, COUNT(motor_current_setting) - 1))
          motor_current_setting[driver] = current; // update motor_current_setting
 
        #define _WRITE_CURRENT_PWM(P) analogWrite(pin_t(MOTOR_CURRENT_PWM_## P ##_PIN), 255L * current / (MOTOR_CURRENT_PWM_RANGE))
        switch (driver) {
          case 0:
            #if PIN_EXISTS(MOTOR_CURRENT_PWM_X)
              _WRITE_CURRENT_PWM(X);
            #endif
            #if PIN_EXISTS(MOTOR_CURRENT_PWM_Y)
              _WRITE_CURRENT_PWM(Y);
            #endif
            #if PIN_EXISTS(MOTOR_CURRENT_PWM_XY)
              _WRITE_CURRENT_PWM(XY);
            #endif
            break;
          case 1:
            #if PIN_EXISTS(MOTOR_CURRENT_PWM_Z)
              _WRITE_CURRENT_PWM(Z);
            #endif
            break;
          case 2:
            #if PIN_EXISTS(MOTOR_CURRENT_PWM_E)
              _WRITE_CURRENT_PWM(E);
            #endif
            #if PIN_EXISTS(MOTOR_CURRENT_PWM_E0)
              _WRITE_CURRENT_PWM(E0);
            #endif
            #if PIN_EXISTS(MOTOR_CURRENT_PWM_E1)
              _WRITE_CURRENT_PWM(E1);
            #endif
            break;
        }
      #endif
    }

Here is the call graph for this function:

Here is the caller graph for this function:

microstep_ms()

void Stepper::microstep_ms ( const uint8_t  driver, const int8_t  ms1, const int8_t  ms2, const int8_t  ms3  )

static

                                                                                                       {
    if (ms1 >= 0) switch (driver) {
      #if HAS_X_MICROSTEPS || HAS_X2_MICROSTEPS
        case 0:
          #if HAS_X_MICROSTEPS
            WRITE(X_MS1_PIN, ms1);
          #endif
          #if HAS_X2_MICROSTEPS
            WRITE(X2_MS1_PIN, ms1);
          #endif
          break;
      #endif
      #if HAS_Y_MICROSTEPS || HAS_Y2_MICROSTEPS
        case 1:
          #if HAS_Y_MICROSTEPS
            WRITE(Y_MS1_PIN, ms1);
          #endif
          #if HAS_Y2_MICROSTEPS
            WRITE(Y2_MS1_PIN, ms1);
          #endif
          break;
      #endif
      #if HAS_Z_MICROSTEPS || HAS_Z2_MICROSTEPS || HAS_Z3_MICROSTEPS
        case 2:
          #if HAS_Z_MICROSTEPS
            WRITE(Z_MS1_PIN, ms1);
          #endif
          #if HAS_Z2_MICROSTEPS
            WRITE(Z2_MS1_PIN, ms1);
          #endif
          #if HAS_Z3_MICROSTEPS
            WRITE(Z3_MS1_PIN, ms1);
          #endif
          break;
      #endif
      #if HAS_E0_MICROSTEPS
        case 3: WRITE(E0_MS1_PIN, ms1); break;
      #endif
      #if HAS_E1_MICROSTEPS
        case 4: WRITE(E1_MS1_PIN, ms1); break;
      #endif
      #if HAS_E2_MICROSTEPS
        case 5: WRITE(E2_MS1_PIN, ms1); break;
      #endif
      #if HAS_E3_MICROSTEPS
        case 6: WRITE(E3_MS1_PIN, ms1); break;
      #endif
      #if HAS_E4_MICROSTEPS
        case 7: WRITE(E4_MS1_PIN, ms1); break;
      #endif
      #if HAS_E5_MICROSTEPS
        case 8: WRITE(E5_MS1_PIN, ms1); break;
      #endif
    }
    if (ms2 >= 0) switch (driver) {
      #if HAS_X_MICROSTEPS || HAS_X2_MICROSTEPS
        case 0:
          #if HAS_X_MICROSTEPS
            WRITE(X_MS2_PIN, ms2);
          #endif
          #if HAS_X2_MICROSTEPS
            WRITE(X2_MS2_PIN, ms2);
          #endif
          break;
      #endif
      #if HAS_Y_MICROSTEPS || HAS_Y2_MICROSTEPS
        case 1:
          #if HAS_Y_MICROSTEPS
            WRITE(Y_MS2_PIN, ms2);
          #endif
          #if HAS_Y2_MICROSTEPS
            WRITE(Y2_MS2_PIN, ms2);
          #endif
          break;
      #endif
      #if HAS_Z_MICROSTEPS || HAS_Z2_MICROSTEPS || HAS_Z3_MICROSTEPS
        case 2:
          #if HAS_Z_MICROSTEPS
            WRITE(Z_MS2_PIN, ms2);
          #endif
          #if HAS_Z2_MICROSTEPS
            WRITE(Z2_MS2_PIN, ms2);
          #endif
          #if HAS_Z3_MICROSTEPS
            WRITE(Z3_MS2_PIN, ms2);
          #endif
          break;
      #endif
      #if HAS_E0_MICROSTEPS
        case 3: WRITE(E0_MS2_PIN, ms2); break;
      #endif
      #if HAS_E1_MICROSTEPS
        case 4: WRITE(E1_MS2_PIN, ms2); break;
      #endif
      #if HAS_E2_MICROSTEPS
        case 5: WRITE(E2_MS2_PIN, ms2); break;
      #endif
      #if HAS_E3_MICROSTEPS
        case 6: WRITE(E3_MS2_PIN, ms2); break;
      #endif
      #if HAS_E4_MICROSTEPS
        case 7: WRITE(E4_MS2_PIN, ms2); break;
      #endif
      #if HAS_E5_MICROSTEPS
        case 8: WRITE(E5_MS2_PIN, ms2); break;
      #endif
    }
    if (ms3 >= 0) switch (driver) {
      #if HAS_X_MICROSTEPS || HAS_X2_MICROSTEPS
        case 0:
          #if HAS_X_MICROSTEPS && PIN_EXISTS(X_MS3)
            WRITE(X_MS3_PIN, ms3);
          #endif
          #if HAS_X2_MICROSTEPS && PIN_EXISTS(X2_MS3)
            WRITE(X2_MS3_PIN, ms3);
          #endif
          break;
      #endif
      #if HAS_Y_MICROSTEPS || HAS_Y2_MICROSTEPS
        case 1:
          #if HAS_Y_MICROSTEPS && PIN_EXISTS(Y_MS3)
            WRITE(Y_MS3_PIN, ms3);
          #endif
          #if HAS_Y2_MICROSTEPS && PIN_EXISTS(Y2_MS3)
            WRITE(Y2_MS3_PIN, ms3);
          #endif
          break;
      #endif
      #if HAS_Z_MICROSTEPS || HAS_Z2_MICROSTEPS || HAS_Z3_MICROSTEPS
        case 2:
          #if HAS_Z_MICROSTEPS && PIN_EXISTS(Z_MS3)
            WRITE(Z_MS3_PIN, ms3);
          #endif
          #if HAS_Z2_MICROSTEPS && PIN_EXISTS(Z2_MS3)
            WRITE(Z2_MS3_PIN, ms3);
          #endif
          #if HAS_Z3_MICROSTEPS && PIN_EXISTS(Z3_MS3)
            WRITE(Z3_MS3_PIN, ms3);
          #endif
          break;
      #endif
      #if HAS_E0_MICROSTEPS && PIN_EXISTS(E0_MS3)
        case 3: WRITE(E0_MS3_PIN, ms3); break;
      #endif
      #if HAS_E1_MICROSTEPS && PIN_EXISTS(E1_MS3)
        case 4: WRITE(E1_MS3_PIN, ms3); break;
      #endif
      #if HAS_E2_MICROSTEPS && PIN_EXISTS(E2_MS3)
        case 5: WRITE(E2_MS3_PIN, ms3); break;
      #endif
      #if HAS_E3_MICROSTEPS && PIN_EXISTS(E3_MS3)
        case 6: WRITE(E3_MS3_PIN, ms3); break;
      #endif
      #if HAS_E4_MICROSTEPS && PIN_EXISTS(E4_MS3)
        case 7: WRITE(E4_MS3_PIN, ms3); break;
      #endif
      #if HAS_E5_MICROSTEPS && PIN_EXISTS(E5_MS3)
        case 8: WRITE(E5_MS3_PIN, ms3); break;
      #endif
    }
  }

Here is the caller graph for this function:

microstep_mode()

void Stepper::microstep_mode ( const uint8_t  driver, const uint8_t  stepping  )

static

                                                                                {
    switch (stepping_mode) {
      #if HAS_MICROSTEP1
        case 1: microstep_ms(driver, MICROSTEP1); break;
      #endif
      #if HAS_MICROSTEP2
        case 2: microstep_ms(driver, MICROSTEP2); break;
      #endif
      #if HAS_MICROSTEP4
        case 4: microstep_ms(driver, MICROSTEP4); break;
      #endif
      #if HAS_MICROSTEP8
        case 8: microstep_ms(driver, MICROSTEP8); break;
      #endif
      #if HAS_MICROSTEP16
        case 16: microstep_ms(driver, MICROSTEP16); break;
      #endif
      #if HAS_MICROSTEP32
        case 32: microstep_ms(driver, MICROSTEP32); break;
      #endif
      #if HAS_MICROSTEP64
        case 64: microstep_ms(driver, MICROSTEP64); break;
      #endif
      #if HAS_MICROSTEP128
        case 128: microstep_ms(driver, MICROSTEP128); break;
      #endif
 
      default: SERIAL_ERROR_MSG("Microsteps unavailable"); break;
    }
  }

Here is the call graph for this function:

microstep_readings()

void Stepper::microstep_readings ( )

static

                                   {
    SERIAL_ECHOPGM("MS1,MS2,MS3 Pins\nX: ");
    #if HAS_X_MICROSTEPS
      SERIAL_CHAR('0' + READ(X_MS1_PIN));
      SERIAL_CHAR('0' + READ(X_MS2_PIN));
      #if PIN_EXISTS(X_MS3)
        SERIAL_ECHOLN((int)READ(X_MS3_PIN));
      #endif
    #endif
    #if HAS_Y_MICROSTEPS
      SERIAL_ECHOPGM("Y: ");
      SERIAL_CHAR('0' + READ(Y_MS1_PIN));
      SERIAL_CHAR('0' + READ(Y_MS2_PIN));
      #if PIN_EXISTS(Y_MS3)
        SERIAL_ECHOLN((int)READ(Y_MS3_PIN));
      #endif
    #endif
    #if HAS_Z_MICROSTEPS
      SERIAL_ECHOPGM("Z: ");
      SERIAL_CHAR('0' + READ(Z_MS1_PIN));
      SERIAL_CHAR('0' + READ(Z_MS2_PIN));
      #if PIN_EXISTS(Z_MS3)
        SERIAL_ECHOLN((int)READ(Z_MS3_PIN));
      #endif
    #endif
    #if HAS_E0_MICROSTEPS
      SERIAL_ECHOPGM("E0: ");
      SERIAL_CHAR('0' + READ(E0_MS1_PIN));
      SERIAL_CHAR('0' + READ(E0_MS2_PIN));
      #if PIN_EXISTS(E0_MS3)
        SERIAL_ECHOLN((int)READ(E0_MS3_PIN));
      #endif
    #endif
    #if HAS_E1_MICROSTEPS
      SERIAL_ECHOPGM("E1: ");
      SERIAL_CHAR('0' + READ(E1_MS1_PIN));
      SERIAL_CHAR('0' + READ(E1_MS2_PIN));
      #if PIN_EXISTS(E1_MS3)
        SERIAL_ECHOLN((int)READ(E1_MS3_PIN));
      #endif
    #endif
    #if HAS_E2_MICROSTEPS
      SERIAL_ECHOPGM("E2: ");
      SERIAL_CHAR('0' + READ(E2_MS1_PIN));
      SERIAL_CHAR('0' + READ(E2_MS2_PIN));
      #if PIN_EXISTS(E2_MS3)
        SERIAL_ECHOLN((int)READ(E2_MS3_PIN));
      #endif
    #endif
    #if HAS_E3_MICROSTEPS
      SERIAL_ECHOPGM("E3: ");
      SERIAL_CHAR('0' + READ(E3_MS1_PIN));
      SERIAL_CHAR('0' + READ(E3_MS2_PIN));
      #if PIN_EXISTS(E3_MS3)
        SERIAL_ECHOLN((int)READ(E3_MS3_PIN));
      #endif
    #endif
    #if HAS_E4_MICROSTEPS
      SERIAL_ECHOPGM("E4: ");
      SERIAL_CHAR('0' + READ(E4_MS1_PIN));
      SERIAL_CHAR('0' + READ(E4_MS2_PIN));
      #if PIN_EXISTS(E4_MS3)
        SERIAL_ECHOLN((int)READ(E4_MS3_PIN));
      #endif
    #endif
    #if HAS_E5_MICROSTEPS
      SERIAL_ECHOPGM("E5: ");
      SERIAL_CHAR('0' + READ(E5_MS1_PIN));
      SERIAL_ECHOLN((int)READ(E5_MS2_PIN));
      #if PIN_EXISTS(E5_MS3)
        SERIAL_ECHOLN((int)READ(E5_MS3_PIN));
      #endif
    #endif
  }

set_separate_multi_axis()

static FORCE_INLINE void Stepper::set_separate_multi_axis ( const bool  state )

static

{ separate_multi_axis = state; }

Here is the caller graph for this function:

set_z_lock()

static FORCE_INLINE void Stepper::set_z_lock ( const bool  state )

static

{ locked_Z_motor = state; }

Here is the caller graph for this function:

set_z2_lock()

static FORCE_INLINE void Stepper::set_z2_lock ( const bool  state )

static

{ locked_Z2_motor = state; }

Here is the caller graph for this function:

set_position() [1/2]

static void Stepper::set_position ( const int32_t &  a, const int32_t &  b, const int32_t &  c, const int32_t &  e  )

static

                                                                                                            {
      planner.synchronize();
      const bool was_enabled = STEPPER_ISR_ENABLED();
      if (was_enabled) DISABLE_STEPPER_DRIVER_INTERRUPT();
      _set_position(a, b, c, e);
      if (was_enabled) ENABLE_STEPPER_DRIVER_INTERRUPT();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

set_position() [2/2]

static void Stepper::set_position ( const xyze_long_t &  abce )

static

{ set_position(abce.a, abce.b, abce.c, abce.e); }

Here is the call graph for this function:

Here is the caller graph for this function:

set_axis_position()

static void Stepper::set_axis_position ( const AxisEnum  a, const int32_t &  v  )

static

                                                                             {
      planner.synchronize();
 
      #ifdef __AVR__
        // Protect the access to the position. Only required for AVR, as
        //  any 32bit CPU offers atomic access to 32bit variables
        const bool was_enabled = STEPPER_ISR_ENABLED();
        if (was_enabled) DISABLE_STEPPER_DRIVER_INTERRUPT();
      #endif
 
      count_position[a] = v;
 
      #ifdef __AVR__
        // Reenable Stepper ISR
        if (was_enabled) ENABLE_STEPPER_DRIVER_INTERRUPT();
      #endif
    }

Here is the call graph for this function:

Here is the caller graph for this function:

set_directions()

void Stepper::set_directions ( )

static

Set the stepper direction of each axis

COREXY: X_AXIS=A_AXIS and Y_AXIS=B_AXIS COREXZ: X_AXIS=A_AXIS and Z_AXIS=C_AXIS COREYZ: Y_AXIS=B_AXIS and Z_AXIS=C_AXIS

                             {
 
  #if HAS_DRIVER(L6470)
    uint8_t L6470_buf[MAX_L6470 + 1];   // chip command sequence - element 0 not used
  #endif
 
  #if MINIMUM_STEPPER_PRE_DIR_DELAY > 0
    DELAY_NS(MINIMUM_STEPPER_PRE_DIR_DELAY);
  #endif
 
  #define SET_STEP_DIR(A)                       \
    if (motor_direction(_AXIS(A))) {            \
      A##_APPLY_DIR(INVERT_## A##_DIR, false);  \
      count_direction[_AXIS(A)] = -1;           \
    }                                           \
    else {                                      \
      A##_APPLY_DIR(!INVERT_## A##_DIR, false); \
      count_direction[_AXIS(A)] = 1;            \
    }
 
  #if HAS_X_DIR
    SET_STEP_DIR(X); // A
  #endif
 
  #if HAS_Y_DIR
    SET_STEP_DIR(Y); // B
  #endif
 
  #if HAS_Z_DIR
    SET_STEP_DIR(Z); // C
  #endif
 
  #if DISABLED(LIN_ADVANCE)
    #if ENABLED(MIXING_EXTRUDER)
       // Because this is valid for the whole block we don't know
       // what e-steppers will step. Likely all. Set all.
      if (motor_direction(E_AXIS)) {
        MIXER_STEPPER_LOOP(j) REV_E_DIR(j);
        count_direction.e = -1;
      }
      else {
        MIXER_STEPPER_LOOP(j) NORM_E_DIR(j);
        count_direction.e = 1;
      }
    #else
      if (motor_direction(E_AXIS)) {
        REV_E_DIR(stepper_extruder);
        count_direction.e = -1;
      }
      else {
        NORM_E_DIR(stepper_extruder);
        count_direction.e = 1;
      }
    #endif
  #endif // !LIN_ADVANCE
 
  #if HAS_DRIVER(L6470)
 
    if (L6470.spi_active) {
      L6470.spi_abort = true;                     // interrupted a SPI transfer - need to shut it down gracefully
      for (uint8_t j = 1; j <= L6470::chain[0]; j++)
        L6470_buf[j] = dSPIN_NOP;                 // fill buffer with NOOP commands
      L6470.transfer(L6470_buf, L6470::chain[0]);  // send enough NOOPs to complete any command
      L6470.transfer(L6470_buf, L6470::chain[0]);
      L6470.transfer(L6470_buf, L6470::chain[0]);
    }
 
    // The L6470.dir_commands[] array holds the direction command for each stepper
 
    //scan command array and copy matches into L6470.transfer
    for (uint8_t j = 1; j <= L6470::chain[0]; j++)
      L6470_buf[j] = L6470.dir_commands[L6470::chain[j]];
 
    L6470.transfer(L6470_buf, L6470::chain[0]);  // send the command stream to the drivers
 
  #endif
 
  // A small delay may be needed after changing direction
  #if MINIMUM_STEPPER_POST_DIR_DELAY > 0
    DELAY_NS(MINIMUM_STEPPER_POST_DIR_DELAY);
  #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

separate_multi_axis

bool Stepper::separate_multi_axis = false

static