andrey
/
Marlin_FB4S
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Merge pull request #4738 from thinkyhead/rc_ensure_floats 

Optimize stepper ISRs, plus cleanup, shorthand
pull/1/head
Scott Lahteine 8 years ago
committed by GitHub
parent
3ff657e729 426f662586
commit
c3caa42630
6 changed files with 97 additions and 59 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 7
      Marlin/Conditionals_post.h
  2. 29
      Marlin/Marlin_main.cpp
  3. 12
      Marlin/planner.cpp
  4. 4
      Marlin/planner.h
  5. 102
      Marlin/stepper.cpp
  6. 2
      Marlin/stepper.h

7
Marlin/Conditionals_post.h
View File

@ -35,11 +35,14 @@
#endif #endif
/** /**
* Axis lengths * Axis lengths and center
*/ */
#define X_MAX_LENGTH (X_MAX_POS - (X_MIN_POS)) #define X_MAX_LENGTH (X_MAX_POS - (X_MIN_POS))
#define Y_MAX_LENGTH (Y_MAX_POS - (Y_MIN_POS)) #define Y_MAX_LENGTH (Y_MAX_POS - (Y_MIN_POS))
#define Z_MAX_LENGTH (Z_MAX_POS - (Z_MIN_POS)) #define Z_MAX_LENGTH (Z_MAX_POS - (Z_MIN_POS))
#define X_CENTER float((X_MIN_POS + X_MAX_POS) * 0.5)
#define Y_CENTER float((Y_MIN_POS + Y_MAX_POS) * 0.5)
#define Z_CENTER float((Z_MIN_POS + Z_MAX_POS) * 0.5)
/** /**
* CoreXY and CoreXZ * CoreXY and CoreXZ
@ -127,6 +130,8 @@
*/ */
#define HAS_PROBING_PROCEDURE (ENABLED(AUTO_BED_LEVELING_FEATURE) || ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST)) #define HAS_PROBING_PROCEDURE (ENABLED(AUTO_BED_LEVELING_FEATURE) || ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST))
#define HOMING_Z_WITH_PROBE (HAS_BED_PROBE && Z_HOME_DIR < 0 && ENABLED(Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN))
// Boundaries for probing based on set limits // Boundaries for probing based on set limits
#define MIN_PROBE_X (max(X_MIN_POS, X_MIN_POS + X_PROBE_OFFSET_FROM_EXTRUDER)) #define MIN_PROBE_X (max(X_MIN_POS, X_MIN_POS + X_PROBE_OFFSET_FROM_EXTRUDER))
#define MAX_PROBE_X (min(X_MAX_POS, X_MAX_POS + X_PROBE_OFFSET_FROM_EXTRUDER)) #define MAX_PROBE_X (min(X_MAX_POS, X_MAX_POS + X_PROBE_OFFSET_FROM_EXTRUDER))

29
Marlin/Marlin_main.cpp
View File

@ -1586,7 +1586,7 @@ static void set_axis_is_at_home(AxisEnum axis) {
if (axis == Z_AXIS) { if (axis == Z_AXIS) {
#if HAS_BED_PROBE && Z_HOME_DIR < 0 #if HAS_BED_PROBE && Z_HOME_DIR < 0
#if DISABLED(Z_MIN_PROBE_ENDSTOP) #if HOMING_Z_WITH_PROBE
current_position[Z_AXIS] -= zprobe_zoffset; current_position[Z_AXIS] -= zprobe_zoffset;
#if ENABLED(DEBUG_LEVELING_FEATURE) #if ENABLED(DEBUG_LEVELING_FEATURE)
if (DEBUGGING(LEVELING)) { if (DEBUGGING(LEVELING)) {
@ -2049,8 +2049,8 @@ static void clean_up_after_endstop_or_probe_move() {
#endif #endif
#endif #endif
#define DEPLOY_PROBE() set_probe_deployed( true ) #define DEPLOY_PROBE() set_probe_deployed(true)
#define STOW_PROBE() set_probe_deployed( false ) #define STOW_PROBE() set_probe_deployed(false)
// returns false for ok and true for failure // returns false for ok and true for failure
static bool set_probe_deployed(bool deploy) { static bool set_probe_deployed(bool deploy) {
@ -2073,8 +2073,8 @@ static void clean_up_after_endstop_or_probe_move() {
if (axis_unhomed_error(true, true, true )) { stop(); return true; } if (axis_unhomed_error(true, true, true )) { stop(); return true; }
#endif #endif
float oldXpos = current_position[X_AXIS]; // save x position float oldXpos = current_position[X_AXIS],
float oldYpos = current_position[Y_AXIS]; // save y position oldYpos = current_position[Y_AXIS];
#ifdef _TRIGGERED_WHEN_STOWED_TEST #ifdef _TRIGGERED_WHEN_STOWED_TEST
@ -2430,10 +2430,10 @@ static void do_homing_move(AxisEnum axis, float where, float fr_mm_s = 0.0) {
#define HOMEAXIS(LETTER) homeaxis(LETTER##_AXIS) #define HOMEAXIS(LETTER) homeaxis(LETTER##_AXIS)
static void homeaxis(AxisEnum axis) { static void homeaxis(AxisEnum axis) {
#define HOMEAXIS_DO(LETTER) \ #define CAN_HOME(A) \
((LETTER##_MIN_PIN > -1 && LETTER##_HOME_DIR==-1) || (LETTER##_MAX_PIN > -1 && LETTER##_HOME_DIR==1)) (axis == A##_AXIS && ((A##_MIN_PIN > -1 && A##_HOME_DIR < 0) || (A##_MAX_PIN > -1 && A##_HOME_DIR > 0)))
if (!(axis == X_AXIS ? HOMEAXIS_DO(X) : axis == Y_AXIS ? HOMEAXIS_DO(Y) : axis == Z_AXIS ? HOMEAXIS_DO(Z) : false)) return; if (!CAN_HOME(X) && !CAN_HOME(Y) && !CAN_HOME(Z)) return;
#if ENABLED(DEBUG_LEVELING_FEATURE) #if ENABLED(DEBUG_LEVELING_FEATURE)
if (DEBUGGING(LEVELING)) { if (DEBUGGING(LEVELING)) {
@ -2449,7 +2449,7 @@ static void homeaxis(AxisEnum axis) {
home_dir(axis); home_dir(axis);
// Homing Z towards the bed? Deploy the Z probe or endstop. // Homing Z towards the bed? Deploy the Z probe or endstop.
#if HAS_BED_PROBE && Z_HOME_DIR < 0 && DISABLED(Z_MIN_PROBE_ENDSTOP) #if HOMING_Z_WITH_PROBE
if (axis == Z_AXIS) { if (axis == Z_AXIS) {
#if ENABLED(DEBUG_LEVELING_FEATURE) #if ENABLED(DEBUG_LEVELING_FEATURE)
if (DEBUGGING(LEVELING)) SERIAL_ECHOPGM("> "); if (DEBUGGING(LEVELING)) SERIAL_ECHOPGM("> ");
@ -2532,7 +2532,7 @@ static void homeaxis(AxisEnum axis) {
#endif #endif
// Put away the Z probe // Put away the Z probe
#if HAS_BED_PROBE && Z_HOME_DIR < 0 && DISABLED(Z_MIN_PROBE_ENDSTOP) #if HOMING_Z_WITH_PROBE
if (axis == Z_AXIS) { if (axis == Z_AXIS) {
#if ENABLED(DEBUG_LEVELING_FEATURE) #if ENABLED(DEBUG_LEVELING_FEATURE)
if (DEBUGGING(LEVELING)) SERIAL_ECHOPGM("> "); if (DEBUGGING(LEVELING)) SERIAL_ECHOPGM("> ");
@ -3104,9 +3104,7 @@ inline void gcode_G28() {
#if ENABLED(Z_SAFE_HOMING) #if ENABLED(Z_SAFE_HOMING)
#if ENABLED(DEBUG_LEVELING_FEATURE) #if ENABLED(DEBUG_LEVELING_FEATURE)
if (DEBUGGING(LEVELING)) { if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("> Z_SAFE_HOMING >>>");
SERIAL_ECHOLNPGM("> Z_SAFE_HOMING >>>");
}
#endif #endif
if (home_all_axis) { if (home_all_axis) {
@ -3127,10 +3125,7 @@ inline void gcode_G28() {
destination[Z_AXIS] = current_position[Z_AXIS]; // Z is already at the right height destination[Z_AXIS] = current_position[Z_AXIS]; // Z is already at the right height
#if ENABLED(DEBUG_LEVELING_FEATURE) #if ENABLED(DEBUG_LEVELING_FEATURE)
if (DEBUGGING(LEVELING)) { if (DEBUGGING(LEVELING)) DEBUG_POS("> Z_SAFE_HOMING > home_all_axis", destination);
DEBUG_POS("> Z_SAFE_HOMING > home_all_axis", current_position);
DEBUG_POS("> Z_SAFE_HOMING > home_all_axis", destination);
}
#endif #endif
// Move in the XY plane // Move in the XY plane

12
Marlin/planner.cpp
View File

@ -203,9 +203,8 @@ void Planner::calculate_trapezoid_for_block(block_t* block, float entry_factor,
// The kernel called by recalculate() when scanning the plan from last to first entry. // The kernel called by recalculate() when scanning the plan from last to first entry.
void Planner::reverse_pass_kernel(block_t* previous, block_t* current, block_t* next) { void Planner::reverse_pass_kernel(block_t* current, block_t* next) {
if (!current) return; if (!current) return;
UNUSED(previous);
if (next) { if (next) {
// If entry speed is already at the maximum entry speed, no need to recheck. Block is cruising. // If entry speed is already at the maximum entry speed, no need to recheck. Block is cruising.
@ -250,15 +249,14 @@ void Planner::reverse_pass() {
block[2] = block[1]; block[2] = block[1];
block[1] = block[0]; block[1] = block[0];
block[0] = &block_buffer[b]; block[0] = &block_buffer[b];
reverse_pass_kernel(block[0], block[1], block[2]); reverse_pass_kernel(block[1], block[2]);
} }
} }
} }
// The kernel called by recalculate() when scanning the plan from first to last entry. // The kernel called by recalculate() when scanning the plan from first to last entry.
void Planner::forward_pass_kernel(block_t* previous, block_t* current, block_t* next) { void Planner::forward_pass_kernel(block_t* previous, block_t* current) {
if (!previous) return; if (!previous) return;
UNUSED(next);
// If the previous block is an acceleration block, but it is not long enough to complete the // If the previous block is an acceleration block, but it is not long enough to complete the
// full speed change within the block, we need to adjust the entry speed accordingly. Entry // full speed change within the block, we need to adjust the entry speed accordingly. Entry
@ -288,9 +286,9 @@ void Planner::forward_pass() {
block[0] = block[1]; block[0] = block[1];
block[1] = block[2]; block[1] = block[2];
block[2] = &block_buffer[b]; block[2] = &block_buffer[b];
forward_pass_kernel(block[0], block[1], block[2]); forward_pass_kernel(block[0], block[1]);
} }
forward_pass_kernel(block[1], block[2], NULL); forward_pass_kernel(block[1], block[2]);
} }
/** /**

4
Marlin/planner.h
View File

@ -320,8 +320,8 @@ class Planner {
static void calculate_trapezoid_for_block(block_t* block, float entry_factor, float exit_factor); static void calculate_trapezoid_for_block(block_t* block, float entry_factor, float exit_factor);
static void reverse_pass_kernel(block_t* previous, block_t* current, block_t* next); static void reverse_pass_kernel(block_t* current, block_t* next);
static void forward_pass_kernel(block_t* previous, block_t* current, block_t* next); static void forward_pass_kernel(block_t* previous, block_t* current);
static void reverse_pass(); static void reverse_pass();
static void forward_pass(); static void forward_pass();

102
Marlin/stepper.cpp
View File

@ -87,7 +87,7 @@ long Stepper::counter_X = 0,
Stepper::counter_Z = 0, Stepper::counter_Z = 0,
Stepper::counter_E = 0; Stepper::counter_E = 0;
volatile unsigned long Stepper::step_events_completed = 0; // The number of step events executed in the current block volatile uint32_t Stepper::step_events_completed = 0; // The number of step events executed in the current block
#if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE) #if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
@ -372,6 +372,7 @@ void Stepper::isr() {
) endstops.update(); ) endstops.update();
// Take multiple steps per interrupt (For high speed moves) // Take multiple steps per interrupt (For high speed moves)
bool all_steps_done = false;
for (int8_t i = 0; i < step_loops; i++) { for (int8_t i = 0; i < step_loops; i++) {
#ifndef USBCON #ifndef USBCON
customizedSerial.checkRx(); // Check for serial chars. customizedSerial.checkRx(); // Check for serial chars.
@ -385,7 +386,7 @@ void Stepper::isr() {
#if DISABLED(MIXING_EXTRUDER) #if DISABLED(MIXING_EXTRUDER)
// Don't step E here for mixing extruder // Don't step E here for mixing extruder
count_position[E_AXIS] += count_direction[E_AXIS]; count_position[E_AXIS] += count_direction[E_AXIS];
e_steps[TOOL_E_INDEX] += motor_direction(E_AXIS) ? -1 : 1; motor_direction(E_AXIS) ? --e_steps[TOOL_E_INDEX] : ++e_steps[TOOL_E_INDEX];
#endif #endif
} }
@ -449,10 +450,12 @@ void Stepper::isr() {
#define _APPLY_STEP(AXIS) AXIS ##_APPLY_STEP #define _APPLY_STEP(AXIS) AXIS ##_APPLY_STEP
#define _INVERT_STEP_PIN(AXIS) INVERT_## AXIS ##_STEP_PIN #define _INVERT_STEP_PIN(AXIS) INVERT_## AXIS ##_STEP_PIN
// Advance the Bresenham counter; start a pulse if the axis needs a step
#define PULSE_START(AXIS) \ #define PULSE_START(AXIS) \
_COUNTER(AXIS) += current_block->steps[_AXIS(AXIS)]; \ _COUNTER(AXIS) += current_block->steps[_AXIS(AXIS)]; \
if (_COUNTER(AXIS) > 0) { _APPLY_STEP(AXIS)(!_INVERT_STEP_PIN(AXIS),0); } if (_COUNTER(AXIS) > 0) { _APPLY_STEP(AXIS)(!_INVERT_STEP_PIN(AXIS),0); }
// Stop an active pulse, reset the Bresenham counter, update the position
#define PULSE_STOP(AXIS) \ #define PULSE_STOP(AXIS) \
if (_COUNTER(AXIS) > 0) { \ if (_COUNTER(AXIS) > 0) { \
_COUNTER(AXIS) -= current_block->step_event_count; \ _COUNTER(AXIS) -= current_block->step_event_count; \
@ -460,6 +463,7 @@ void Stepper::isr() {
_APPLY_STEP(AXIS)(_INVERT_STEP_PIN(AXIS),0); \ _APPLY_STEP(AXIS)(_INVERT_STEP_PIN(AXIS),0); \
} }
// If a minimum pulse time was specified get the CPU clock
#if MINIMUM_STEPPER_PULSE > 0 #if MINIMUM_STEPPER_PULSE > 0
static uint32_t pulse_start; static uint32_t pulse_start;
pulse_start = TCNT0; pulse_start = TCNT0;
@ -475,6 +479,7 @@ void Stepper::isr() {
PULSE_START(Z); PULSE_START(Z);
#endif #endif
// For non-advance use linear interpolation for E also
#if DISABLED(ADVANCE) && DISABLED(LIN_ADVANCE) #if DISABLED(ADVANCE) && DISABLED(LIN_ADVANCE)
#if ENABLED(MIXING_EXTRUDER) #if ENABLED(MIXING_EXTRUDER)
// Keep updating the single E axis // Keep updating the single E axis
@ -491,6 +496,7 @@ void Stepper::isr() {
#endif #endif
#endif // !ADVANCE && !LIN_ADVANCE #endif // !ADVANCE && !LIN_ADVANCE
// For a minimum pulse time wait before stopping pulses
#if MINIMUM_STEPPER_PULSE > 0 #if MINIMUM_STEPPER_PULSE > 0
#define CYCLES_EATEN_BY_CODE 10 #define CYCLES_EATEN_BY_CODE 10
while ((uint32_t)(TCNT0 - pulse_start) < (MINIMUM_STEPPER_PULSE * (F_CPU / 1000000UL)) - CYCLES_EATEN_BY_CODE) { /* nada */ } while ((uint32_t)(TCNT0 - pulse_start) < (MINIMUM_STEPPER_PULSE * (F_CPU / 1000000UL)) - CYCLES_EATEN_BY_CODE) { /* nada */ }
@ -524,18 +530,20 @@ void Stepper::isr() {
#endif #endif
#endif // !ADVANCE && !LIN_ADVANCE #endif // !ADVANCE && !LIN_ADVANCE
step_events_completed++; if (++step_events_completed >= current_block->step_event_count) {
if (step_events_completed >= current_block->step_event_count) break; all_steps_done = true;
break;
}
} }
#if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE) #if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
// If we have esteps to execute, fire the next ISR "now" // If we have esteps to execute, fire the next advance_isr "now"
if (e_steps[TOOL_E_INDEX]) OCR0A = TCNT0 + 2; if (e_steps[TOOL_E_INDEX]) OCR0A = TCNT0 + 2;
#endif #endif
// Calculate new timer value // Calculate new timer value
unsigned short timer, step_rate; uint16_t timer, step_rate;
if (step_events_completed <= (unsigned long)current_block->accelerate_until) { if (step_events_completed <= (uint32_t)current_block->accelerate_until) {
MultiU24X32toH16(acc_step_rate, acceleration_time, current_block->acceleration_rate); MultiU24X32toH16(acc_step_rate, acceleration_time, current_block->acceleration_rate);
acc_step_rate += current_block->initial_rate; acc_step_rate += current_block->initial_rate;
@ -551,14 +559,14 @@ void Stepper::isr() {
#if ENABLED(LIN_ADVANCE) #if ENABLED(LIN_ADVANCE)
if (current_block->use_advance_lead) if (current_block->use_advance_lead)
current_estep_rate[TOOL_E_INDEX] = ((unsigned long)acc_step_rate * current_block->e_speed_multiplier8) >> 8; current_estep_rate[TOOL_E_INDEX] = ((uint32_t)acc_step_rate * current_block->e_speed_multiplier8) >> 8;
if (current_block->use_advance_lead) { if (current_block->use_advance_lead) {
#if ENABLED(MIXING_EXTRUDER) #if ENABLED(MIXING_EXTRUDER)
MIXING_STEPPERS_LOOP(j) MIXING_STEPPERS_LOOP(j)
current_estep_rate[j] = ((unsigned long)acc_step_rate * current_block->e_speed_multiplier8 * current_block->step_event_count / current_block->mix_event_count[j]) >> 8; current_estep_rate[j] = ((uint32_t)acc_step_rate * current_block->e_speed_multiplier8 * current_block->step_event_count / current_block->mix_event_count[j]) >> 8;
#else #else
current_estep_rate[TOOL_E_INDEX] = ((unsigned long)acc_step_rate * current_block->e_speed_multiplier8) >> 8; current_estep_rate[TOOL_E_INDEX] = ((uint32_t)acc_step_rate * current_block->e_speed_multiplier8) >> 8;
#endif #endif
} }
@ -588,10 +596,10 @@ void Stepper::isr() {
eISR_Rate = (timer >> 2) * step_loops / abs(e_steps[TOOL_E_INDEX]); eISR_Rate = (timer >> 2) * step_loops / abs(e_steps[TOOL_E_INDEX]);
#endif #endif
} }
else if (step_events_completed > (unsigned long)current_block->decelerate_after) { else if (step_events_completed > (uint32_t)current_block->decelerate_after) {
MultiU24X32toH16(step_rate, deceleration_time, current_block->acceleration_rate); MultiU24X32toH16(step_rate, deceleration_time, current_block->acceleration_rate);
if (step_rate <= acc_step_rate) { // Still decelerating? if (step_rate < acc_step_rate) { // Still decelerating?
step_rate = acc_step_rate - step_rate; step_rate = acc_step_rate - step_rate;
NOLESS(step_rate, current_block->final_rate); NOLESS(step_rate, current_block->final_rate);
} }
@ -608,9 +616,9 @@ void Stepper::isr() {
if (current_block->use_advance_lead) { if (current_block->use_advance_lead) {
#if ENABLED(MIXING_EXTRUDER) #if ENABLED(MIXING_EXTRUDER)
MIXING_STEPPERS_LOOP(j) MIXING_STEPPERS_LOOP(j)
current_estep_rate[j] = ((unsigned long)step_rate * current_block->e_speed_multiplier8 * current_block->step_event_count / current_block->mix_event_count[j]) >> 8; current_estep_rate[j] = ((uint32_t)step_rate * current_block->e_speed_multiplier8 * current_block->step_event_count / current_block->mix_event_count[j]) >> 8;
#else #else
current_estep_rate[TOOL_E_INDEX] = ((unsigned long)step_rate * current_block->e_speed_multiplier8) >> 8; current_estep_rate[TOOL_E_INDEX] = ((uint32_t)step_rate * current_block->e_speed_multiplier8) >> 8;
#endif #endif
} }
@ -654,10 +662,10 @@ void Stepper::isr() {
step_loops = step_loops_nominal; step_loops = step_loops_nominal;
} }
OCR1A = (OCR1A < (TCNT1 + 16)) ? (TCNT1 + 16) : OCR1A; NOLESS(OCR1A, TCNT1 + 16);
// If current block is finished, reset pointer // If current block is finished, reset pointer
if (step_events_completed >= current_block->step_event_count) { if (all_steps_done) {
current_block = NULL; current_block = NULL;
planner.discard_current_block(); planner.discard_current_block();
} }
@ -675,29 +683,61 @@ void Stepper::isr() {
old_OCR0A += eISR_Rate; old_OCR0A += eISR_Rate;
OCR0A = old_OCR0A; OCR0A = old_OCR0A;
#define STEP_E_ONCE(INDEX) \ #define SET_E_STEP_DIR(INDEX) \
if (e_steps[INDEX] != 0) { \ E## INDEX ##_DIR_WRITE(e_steps[INDEX] <= 0 ? INVERT_E## INDEX ##_DIR : !INVERT_E## INDEX ##_DIR)
E## INDEX ##_STEP_WRITE(INVERT_E_STEP_PIN); \
if (e_steps[INDEX] < 0) { \ #define START_E_PULSE(INDEX) \
E## INDEX ##_DIR_WRITE(INVERT_E## INDEX ##_DIR); \ if (e_steps[INDEX]) E## INDEX ##_STEP_WRITE(INVERT_E_STEP_PIN)
e_steps[INDEX]++; \
} \ #define STOP_E_PULSE(INDEX) \
else { \ if (e_steps[INDEX]) { \
E## INDEX ##_DIR_WRITE(!INVERT_E## INDEX ##_DIR); \ e_steps[INDEX] < 0 ? ++e_steps[INDEX] : --e_steps[INDEX]; \
e_steps[INDEX]--; \
} \
E## INDEX ##_STEP_WRITE(!INVERT_E_STEP_PIN); \ E## INDEX ##_STEP_WRITE(!INVERT_E_STEP_PIN); \
} }
SET_E_STEP_DIR(0);
#if E_STEPPERS > 1
SET_E_STEP_DIR(1);
#if E_STEPPERS > 2
SET_E_STEP_DIR(2);
#if E_STEPPERS > 3
SET_E_STEP_DIR(3);
#endif
#endif
#endif
// Step all E steppers that have steps // Step all E steppers that have steps
for (uint8_t i = 0; i < step_loops; i++) { for (uint8_t i = 0; i < step_loops; i++) {
STEP_E_ONCE(0);
#if MINIMUM_STEPPER_PULSE > 0
static uint32_t pulse_start;
pulse_start = TCNT0;
#endif
START_E_PULSE(0);
#if E_STEPPERS > 1
START_E_PULSE(1);
#if E_STEPPERS > 2
START_E_PULSE(2);
#if E_STEPPERS > 3
START_E_PULSE(3);
#endif
#endif
#endif
// For a minimum pulse time wait before stopping pulses
#if MINIMUM_STEPPER_PULSE > 0
#define CYCLES_EATEN_BY_E 10
while ((uint32_t)(TCNT0 - pulse_start) < (MINIMUM_STEPPER_PULSE * (F_CPU / 1000000UL)) - CYCLES_EATEN_BY_E) { /* nada */ }
#endif
STOP_E_PULSE(0);
#if E_STEPPERS > 1 #if E_STEPPERS > 1
STEP_E_ONCE(1); STOP_E_PULSE(1);
#if E_STEPPERS > 2 #if E_STEPPERS > 2
STEP_E_ONCE(2); STOP_E_PULSE(2);
#if E_STEPPERS > 3 #if E_STEPPERS > 3
STEP_E_ONCE(3); STOP_E_PULSE(3);
#endif #endif
#endif #endif
#endif #endif

2
Marlin/stepper.h
View File

@ -102,7 +102,7 @@ class Stepper {
// Counter variables for the Bresenham line tracer // Counter variables for the Bresenham line tracer
static long counter_X, counter_Y, counter_Z, counter_E; static long counter_X, counter_Y, counter_Z, counter_E;
static volatile unsigned long step_events_completed; // The number of step events executed in the current block static volatile uint32_t step_events_completed; // The number of step events executed in the current block
#if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE) #if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
static unsigned char old_OCR0A; static unsigned char old_OCR0A;

Write Preview
Loading…
Cancel
Save