2016-03-25 01:19:46 -05:00
/**
2016-03-24 13:01:20 -05:00
* Marlin 3 D Printer Firmware
* Copyright ( C ) 2016 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/>.
*
*/
2015-05-17 03:44:53 -05:00
/**
2016-04-27 09:15:20 -05:00
* stepper . cpp - A singleton object to execute motion plans using stepper motors
2015-05-17 03:44:53 -05:00
* Marlin Firmware
*
* Derived from Grbl
* Copyright ( c ) 2009 - 2011 Simen Svale Skogsrud
*
* Grbl 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 .
*
* Grbl 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 Grbl . If not , see < http : //www.gnu.org/licenses/>.
*/
2011-11-13 13:42:08 -06:00
/* The timer calculations of this module informed by the 'RepRap cartesian firmware' by Zack Smith
and Philipp Tiefenbacher . */
# include "Marlin.h"
2011-12-22 07:55:45 -06:00
# include "stepper.h"
2016-04-27 09:15:20 -05:00
# include "endstops.h"
2011-11-13 13:42:08 -06:00
# include "planner.h"
# include "temperature.h"
# include "ultralcd.h"
2012-03-03 09:51:47 -06:00
# include "language.h"
2013-01-08 04:53:18 -06:00
# include "cardreader.h"
2011-11-13 13:42:08 -06:00
# include "speed_lookuptable.h"
2016-03-19 21:03:17 -05:00
2015-03-14 06:28:22 -05:00
# if HAS_DIGIPOTSS
# include <SPI.h>
2012-11-21 13:53:56 -06:00
# endif
2011-11-13 13:42:08 -06:00
2016-04-27 09:15:20 -05:00
Stepper stepper ; // Singleton
2011-12-04 14:03:02 -06:00
2016-05-11 17:24:24 -05:00
// public:
block_t * Stepper : : current_block = NULL ; // A pointer to the block currently being traced
# if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED)
bool Stepper : : abort_on_endstop_hit = false ;
# endif
# if ENABLED(Z_DUAL_ENDSTOPS)
bool Stepper : : performing_homing = false ;
# endif
// private:
unsigned char Stepper : : last_direction_bits = 0 ; // The next stepping-bits to be output
unsigned int Stepper : : cleaning_buffer_counter = 0 ;
# if ENABLED(Z_DUAL_ENDSTOPS)
bool Stepper : : locked_z_motor = false ;
bool Stepper : : locked_z2_motor = false ;
# endif
2016-09-20 05:16:05 -05:00
long Stepper : : counter_X = 0 ,
Stepper : : counter_Y = 0 ,
Stepper : : counter_Z = 0 ,
Stepper : : counter_E = 0 ;
2016-05-11 17:24:24 -05:00
2016-08-30 14:19:49 -05:00
volatile uint32_t Stepper : : step_events_completed = 0 ; // The number of step events executed in the current block
2016-05-11 17:24:24 -05:00
2016-05-04 14:10:42 -05:00
# if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
2016-11-17 23:42:41 -06:00
uint8_t Stepper : : old_OCR0A = 0 ;
volatile uint8_t Stepper : : eISR_Rate = 200 ; // Keep the ISR at a low rate until needed
2016-05-04 14:10:42 -05:00
# if ENABLED(LIN_ADVANCE)
2016-10-08 11:13:04 -05:00
volatile int Stepper : : e_steps [ E_STEPPERS ] ;
2016-10-31 10:17:30 -05:00
int Stepper : : final_estep_rate ,
2016-06-28 17:06:56 -05:00
Stepper : : current_estep_rate [ E_STEPPERS ] ,
Stepper : : current_adv_steps [ E_STEPPERS ] ;
2016-05-04 14:10:42 -05:00
# else
2016-09-20 05:16:05 -05:00
long Stepper : : e_steps [ E_STEPPERS ] ,
Stepper : : final_advance = 0 ,
Stepper : : old_advance = 0 ,
Stepper : : advance_rate ,
Stepper : : advance ;
2016-05-04 14:10:42 -05:00
# endif
2016-05-11 17:24:24 -05:00
# endif
long Stepper : : acceleration_time , Stepper : : deceleration_time ;
volatile long Stepper : : count_position [ NUM_AXIS ] = { 0 } ;
volatile signed char Stepper : : count_direction [ NUM_AXIS ] = { 1 , 1 , 1 , 1 } ;
2016-06-28 17:06:56 -05:00
# if ENABLED(MIXING_EXTRUDER)
2016-09-02 11:31:45 -05:00
long Stepper : : counter_m [ MIXING_STEPPERS ] ;
2016-06-28 17:06:56 -05:00
# endif
2016-05-11 17:24:24 -05:00
unsigned short Stepper : : acc_step_rate ; // needed for deceleration start point
uint8_t Stepper : : step_loops , Stepper : : step_loops_nominal ;
unsigned short Stepper : : OCR1A_nominal ;
2016-08-20 22:38:32 -05:00
volatile long Stepper : : endstops_trigsteps [ XYZ ] ;
2016-05-11 17:24:24 -05:00
2016-07-11 12:19:07 -05:00
# if ENABLED(X_DUAL_STEPPER_DRIVERS)
# define X_APPLY_DIR(v,Q) do{ X_DIR_WRITE(v); X2_DIR_WRITE((v) != INVERT_X2_VS_X_DIR); }while(0)
# define X_APPLY_STEP(v,Q) do{ X_STEP_WRITE(v); X2_STEP_WRITE(v); }while(0)
# elif ENABLED(DUAL_X_CARRIAGE)
2015-03-14 06:28:22 -05:00
# define X_APPLY_DIR(v,ALWAYS) \
if ( extruder_duplication_enabled | | ALWAYS ) { \
X_DIR_WRITE ( v ) ; \
X2_DIR_WRITE ( v ) ; \
} \
2015-03-21 18:43:47 -05:00
else { \
if ( current_block - > active_extruder ) X2_DIR_WRITE ( v ) ; else X_DIR_WRITE ( v ) ; \
2015-03-14 06:28:22 -05:00
}
# define X_APPLY_STEP(v,ALWAYS) \
if ( extruder_duplication_enabled | | ALWAYS ) { \
X_STEP_WRITE ( v ) ; \
X2_STEP_WRITE ( v ) ; \
} \
else { \
2015-03-21 18:43:47 -05:00
if ( current_block - > active_extruder ! = 0 ) X2_STEP_WRITE ( v ) ; else X_STEP_WRITE ( v ) ; \
2015-03-14 06:28:22 -05:00
}
# else
2015-03-14 20:31:25 -05:00
# define X_APPLY_DIR(v,Q) X_DIR_WRITE(v)
# define X_APPLY_STEP(v,Q) X_STEP_WRITE(v)
2015-03-14 06:28:22 -05:00
# endif
2015-07-31 00:28:11 -05:00
# if ENABLED(Y_DUAL_STEPPER_DRIVERS)
2016-07-11 12:19:07 -05:00
# define Y_APPLY_DIR(v,Q) do{ Y_DIR_WRITE(v); Y2_DIR_WRITE((v) != INVERT_Y2_VS_Y_DIR); }while(0)
# define Y_APPLY_STEP(v,Q) do{ Y_STEP_WRITE(v); Y2_STEP_WRITE(v); }while(0)
2015-03-14 06:28:22 -05:00
# else
2015-03-14 20:31:25 -05:00
# define Y_APPLY_DIR(v,Q) Y_DIR_WRITE(v)
# define Y_APPLY_STEP(v,Q) Y_STEP_WRITE(v)
2015-03-14 06:28:22 -05:00
# endif
2015-07-31 00:28:11 -05:00
# if ENABLED(Z_DUAL_STEPPER_DRIVERS)
2016-07-11 12:19:07 -05:00
# define Z_APPLY_DIR(v,Q) do{ Z_DIR_WRITE(v); Z2_DIR_WRITE(v); }while(0)
2015-07-31 00:28:11 -05:00
# if ENABLED(Z_DUAL_ENDSTOPS)
2015-03-24 12:06:44 -05:00
# define Z_APPLY_STEP(v,Q) \
if ( performing_homing ) { \
2016-10-29 01:54:19 -05:00
if ( Z_HOME_DIR < 0 ) { \
2016-04-27 09:15:20 -05:00
if ( ! ( TEST ( endstops . old_endstop_bits , Z_MIN ) & & ( count_direction [ Z_AXIS ] < 0 ) ) & & ! locked_z_motor ) Z_STEP_WRITE ( v ) ; \
if ( ! ( TEST ( endstops . old_endstop_bits , Z2_MIN ) & & ( count_direction [ Z_AXIS ] < 0 ) ) & & ! locked_z2_motor ) Z2_STEP_WRITE ( v ) ; \
2015-03-24 12:06:44 -05:00
} \
2016-10-29 01:54:19 -05:00
else { \
if ( ! ( TEST ( endstops . old_endstop_bits , Z_MAX ) & & ( count_direction [ Z_AXIS ] > 0 ) ) & & ! locked_z_motor ) Z_STEP_WRITE ( v ) ; \
if ( ! ( TEST ( endstops . old_endstop_bits , Z2_MAX ) & & ( count_direction [ Z_AXIS ] > 0 ) ) & & ! locked_z2_motor ) Z2_STEP_WRITE ( v ) ; \
} \
2015-10-13 05:51:34 -05:00
} \
else { \
2015-03-24 12:06:44 -05:00
Z_STEP_WRITE ( v ) ; \
Z2_STEP_WRITE ( v ) ; \
}
# else
2016-07-11 12:19:07 -05:00
# define Z_APPLY_STEP(v,Q) do{ Z_STEP_WRITE(v); Z2_STEP_WRITE(v); }while(0)
2015-03-24 12:06:44 -05:00
# endif
2015-03-14 06:28:22 -05:00
# else
2015-03-14 20:31:25 -05:00
# define Z_APPLY_DIR(v,Q) Z_DIR_WRITE(v)
# define Z_APPLY_STEP(v,Q) Z_STEP_WRITE(v)
2015-03-14 06:28:22 -05:00
# endif
2016-06-28 17:06:56 -05:00
# if DISABLED(MIXING_EXTRUDER)
# define E_APPLY_STEP(v,Q) E_STEP_WRITE(v)
# endif
2011-11-13 13:42:08 -06:00
2015-04-16 17:04:38 -05:00
// intRes = longIn1 * longIn2 >> 24
// uses:
// r26 to store 0
// r27 to store bits 16-23 of the 48bit result. The top bit is used to round the two byte result.
// note that the lower two bytes and the upper byte of the 48bit result are not calculated.
// this can cause the result to be out by one as the lower bytes may cause carries into the upper ones.
// B0 A0 are bits 24-39 and are the returned value
// C1 B1 A1 is longIn1
// D2 C2 B2 A2 is longIn2
//
# define MultiU24X32toH16(intRes, longIn1, longIn2) \
2015-03-14 06:28:22 -05:00
asm volatile ( \
2015-10-03 01:08:58 -05:00
" clr r26 \n \t " \
" mul %A1, %B2 \n \t " \
" mov r27, r1 \n \t " \
" mul %B1, %C2 \n \t " \
" movw %A0, r0 \n \t " \
" mul %C1, %C2 \n \t " \
" add %B0, r0 \n \t " \
" mul %C1, %B2 \n \t " \
" add %A0, r0 \n \t " \
" adc %B0, r1 \n \t " \
" mul %A1, %C2 \n \t " \
" add r27, r0 \n \t " \
" adc %A0, r1 \n \t " \
" adc %B0, r26 \n \t " \
" mul %B1, %B2 \n \t " \
" add r27, r0 \n \t " \
" adc %A0, r1 \n \t " \
" adc %B0, r26 \n \t " \
" mul %C1, %A2 \n \t " \
" add r27, r0 \n \t " \
" adc %A0, r1 \n \t " \
" adc %B0, r26 \n \t " \
" mul %B1, %A2 \n \t " \
" add r27, r1 \n \t " \
" adc %A0, r26 \n \t " \
" adc %B0, r26 \n \t " \
" lsr r27 \n \t " \
" adc %A0, r26 \n \t " \
" adc %B0, r26 \n \t " \
" mul %D2, %A1 \n \t " \
" add %A0, r0 \n \t " \
" adc %B0, r1 \n \t " \
" mul %D2, %B1 \n \t " \
" add %B0, r0 \n \t " \
" clr r1 \n \t " \
: \
" =&r " ( intRes ) \
: \
" d " ( longIn1 ) , \
" d " ( longIn2 ) \
: \
" r26 " , " r27 " \
)
2011-11-13 13:42:08 -06:00
// Some useful constants
2016-02-27 06:51:44 -06:00
# define ENABLE_STEPPER_DRIVER_INTERRUPT() SBI(TIMSK1, OCIE1A)
# define DISABLE_STEPPER_DRIVER_INTERRUPT() CBI(TIMSK1, OCIE1A)
2011-11-13 13:42:08 -06:00
2016-04-27 09:15:20 -05:00
/**
* __________________________
* / | | \ _________________ ^
* / | | \ / | | \ |
* / | | \ / | | \ s
* / | | | | | \ p
* / | | | | | \ e
* + - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - + - - - + - - + - - - - - - - - - - - - - - - + - - - - + e
* | BLOCK 1 | BLOCK 2 | d
*
* time - - - - - >
*
* The trapezoid is the shape the speed curve over time . It starts at block - > initial_rate , accelerates
* first block - > accelerate_until step_events_completed , then keeps going at constant speed until
* step_events_completed reaches block - > decelerate_after after which it decelerates until the trapezoid generator is reset .
* The slope of acceleration is calculated using v = u + at where t is the accumulated timer values of the steps so far .
*/
void Stepper : : wake_up ( ) {
2011-11-13 13:42:08 -06:00
// TCNT1 = 0;
2013-08-01 08:06:39 -05:00
ENABLE_STEPPER_DRIVER_INTERRUPT ( ) ;
2011-11-13 13:42:08 -06:00
}
2015-06-15 19:36:41 -05:00
/**
* Set the stepper direction of each axis
*
2016-05-20 15:27:49 -05:00
* 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
2015-06-15 19:36:41 -05:00
*/
2016-04-27 09:15:20 -05:00
void Stepper : : set_directions ( ) {
2015-06-15 19:36:41 -05:00
2016-03-10 03:42:58 -06:00
# define SET_STEP_DIR(AXIS) \
2016-04-27 09:15:20 -05:00
if ( motor_direction ( AXIS # # _AXIS ) ) { \
2016-03-10 03:42:58 -06:00
AXIS # # _APPLY_DIR ( INVERT_ # # AXIS # # _DIR , false ) ; \
count_direction [ AXIS # # _AXIS ] = - 1 ; \
} \
else { \
AXIS # # _APPLY_DIR ( ! INVERT_ # # AXIS # # _DIR , false ) ; \
count_direction [ AXIS # # _AXIS ] = 1 ; \
}
2015-10-03 01:08:58 -05:00
2016-08-27 19:38:24 -05:00
# 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
2015-10-03 01:08:58 -05:00
2016-10-01 04:51:45 -05:00
# if DISABLED(ADVANCE) && DISABLED(LIN_ADVANCE)
if ( motor_direction ( E_AXIS ) ) {
REV_E_DIR ( ) ;
count_direction [ E_AXIS ] = - 1 ;
}
else {
NORM_E_DIR ( ) ;
count_direction [ E_AXIS ] = 1 ;
}
# endif // !ADVANCE && !LIN_ADVANCE
2015-05-17 07:33:09 -05:00
}
2016-11-05 16:38:48 -05:00
# if ENABLED(ENDSTOP_INTERRUPTS_FEATURE)
extern volatile uint8_t e_hit ;
# endif
2016-10-09 10:06:31 -05:00
/**
* Stepper Driver Interrupt
*
* Directly pulses the stepper motors at high frequency .
* Timer 1 runs at a base frequency of 2 MHz , with this ISR using OCR1A compare mode .
*
* OCR1A Frequency
* 1 2 MHz
* 50 40 KHz
* 100 20 KHz - capped max rate
* 200 10 KHz - nominal max rate
* 2000 1 KHz - sleep rate
* 4000 500 Hz - init rate
*/
2016-05-11 17:24:24 -05:00
ISR ( TIMER1_COMPA_vect ) { Stepper : : isr ( ) ; }
2015-03-19 12:16:18 -05:00
2016-04-27 09:15:20 -05:00
void Stepper : : isr ( ) {
2016-11-20 06:09:12 -06:00
//Disable Timer0 ISRs and enable global ISR again to capture UART events (incoming chars)
# if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
CBI ( TIMSK0 , OCIE0A ) ; //estepper ISR
# endif
CBI ( TIMSK0 , OCIE0B ) ; //Temperature ISR
DISABLE_STEPPER_DRIVER_INTERRUPT ( ) ;
sei ( ) ;
2015-07-19 17:20:12 -05:00
if ( cleaning_buffer_counter ) {
2016-11-17 23:42:41 -06:00
- - cleaning_buffer_counter ;
2015-03-19 12:16:18 -05:00
current_block = NULL ;
2016-04-27 20:06:32 -05:00
planner . discard_current_block ( ) ;
2015-03-31 01:31:48 -05:00
# ifdef SD_FINISHED_RELEASECOMMAND
2016-11-17 23:42:41 -06:00
if ( ! cleaning_buffer_counter & & ( SD_FINISHED_STEPPERRELEASE ) ) enqueue_and_echo_commands_P ( PSTR ( SD_FINISHED_RELEASECOMMAND ) ) ;
2015-03-31 01:31:48 -05:00
# endif
2016-10-09 10:06:31 -05:00
OCR1A = 200 ; // Run at max speed - 10 KHz
2016-11-20 06:09:12 -06:00
//re-enable ISRs
# if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
SBI ( TIMSK0 , OCIE0A ) ;
# endif
SBI ( TIMSK0 , OCIE0B ) ;
ENABLE_STEPPER_DRIVER_INTERRUPT ( ) ;
2015-03-19 12:16:18 -05:00
return ;
}
2015-04-24 01:03:17 -05:00
2011-11-13 13:42:08 -06:00
// If there is no current block, attempt to pop one from the buffer
2015-03-14 06:28:22 -05:00
if ( ! current_block ) {
2011-11-13 13:42:08 -06:00
// Anything in the buffer?
2016-04-27 20:06:32 -05:00
current_block = planner . get_current_block ( ) ;
2015-03-14 06:28:22 -05:00
if ( current_block ) {
2011-11-13 13:42:08 -06:00
trapezoid_generator_reset ( ) ;
2016-06-28 17:06:56 -05:00
// Initialize Bresenham counters to 1/2 the ceiling
counter_X = counter_Y = counter_Z = counter_E = - ( current_block - > step_event_count > > 1 ) ;
# if ENABLED(MIXING_EXTRUDER)
MIXING_STEPPERS_LOOP ( i )
2016-09-02 11:31:45 -05:00
counter_m [ i ] = - ( current_block - > mix_event_count [ i ] > > 1 ) ;
2016-06-28 17:06:56 -05:00
# endif
2013-08-01 08:06:39 -05:00
step_events_completed = 0 ;
2016-11-15 09:41:13 -06:00
# if ENABLED(ENDSTOP_INTERRUPTS_FEATURE)
e_hit = 2 ; // Needed for the case an endstop is already triggered before the new move begins.
// No 'change' can be detected.
# endif
2015-07-31 00:28:11 -05:00
# if ENABLED(Z_LATE_ENABLE)
2015-03-20 22:42:49 -05:00
if ( current_block - > steps [ Z_AXIS ] > 0 ) {
2012-02-06 10:38:16 -06:00
enable_z ( ) ;
2016-10-09 10:06:31 -05:00
OCR1A = 2000 ; // Run at slow speed - 1 KHz
2016-11-20 06:09:12 -06:00
# if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
SBI ( TIMSK0 , OCIE0A ) ;
# endif
SBI ( TIMSK0 , OCIE0B ) ;
ENABLE_STEPPER_DRIVER_INTERRUPT ( ) ;
2012-02-06 10:38:16 -06:00
return ;
}
# endif
2013-08-01 08:06:39 -05:00
2015-07-31 00:28:11 -05:00
// #if ENABLED(ADVANCE)
2016-06-28 17:06:56 -05:00
// e_steps[TOOL_E_INDEX] = 0;
2015-03-14 06:28:22 -05:00
// #endif
2013-08-01 08:06:39 -05:00
}
2011-11-13 13:42:08 -06:00
else {
2016-10-09 10:06:31 -05:00
OCR1A = 2000 ; // Run at slow speed - 1 KHz
2016-11-20 06:09:12 -06:00
# if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
SBI ( TIMSK0 , OCIE0A ) ;
# endif
SBI ( TIMSK0 , OCIE0B ) ;
ENABLE_STEPPER_DRIVER_INTERRUPT ( ) ;
2016-09-21 17:28:54 -05:00
return ;
2013-08-01 08:06:39 -05:00
}
}
2011-11-13 13:42:08 -06:00
2016-09-21 17:28:54 -05:00
// Update endstops state, if enabled
2016-11-18 21:53:45 -06:00
if ( ( endstops . enabled
2016-09-21 17:28:54 -05:00
# if HAS_BED_PROBE
| | endstops . z_probe_enabled
# endif
2016-11-18 21:53:45 -06:00
)
# if ENABLED(ENDSTOP_INTERRUPTS_FEATURE)
& & e_hit
# endif
) {
endstops . update ( ) ;
# if ENABLED(ENDSTOP_INTERRUPTS_FEATURE)
2016-11-05 16:38:48 -05:00
e_hit - - ;
2016-11-18 21:53:45 -06:00
# endif
}
2015-04-24 01:03:17 -05:00
2016-09-21 17:28:54 -05:00
// Take multiple steps per interrupt (For high speed moves)
bool all_steps_done = false ;
for ( int8_t i = 0 ; i < step_loops ; i + + ) {
# if ENABLED(LIN_ADVANCE)
2012-12-09 03:32:09 -06:00
2016-09-21 17:28:54 -05:00
counter_E + = current_block - > steps [ E_AXIS ] ;
if ( counter_E > 0 ) {
counter_E - = current_block - > step_event_count ;
# if DISABLED(MIXING_EXTRUDER)
// Don't step E here for mixing extruder
count_position [ E_AXIS ] + = count_direction [ E_AXIS ] ;
motor_direction ( E_AXIS ) ? - - e_steps [ TOOL_E_INDEX ] : + + e_steps [ TOOL_E_INDEX ] ;
# endif
}
2016-05-04 14:10:42 -05:00
2016-09-21 17:28:54 -05:00
# if ENABLED(MIXING_EXTRUDER)
// Step mixing steppers proportionally
2016-10-08 11:13:04 -05:00
const bool dir = motor_direction ( E_AXIS ) ;
2016-09-21 17:28:54 -05:00
MIXING_STEPPERS_LOOP ( j ) {
counter_m [ j ] + = current_block - > steps [ E_AXIS ] ;
if ( counter_m [ j ] > 0 ) {
counter_m [ j ] - = current_block - > mix_event_count [ j ] ;
dir ? - - e_steps [ j ] : + + e_steps [ j ] ;
}
2016-05-04 11:53:17 -05:00
}
2016-09-21 17:28:54 -05:00
# endif
2016-05-04 14:10:42 -05:00
2016-09-21 17:28:54 -05:00
# elif ENABLED(ADVANCE)
2016-05-04 14:10:42 -05:00
2016-09-21 17:28:54 -05:00
// Always count the unified E axis
counter_E + = current_block - > steps [ E_AXIS ] ;
if ( counter_E > 0 ) {
counter_E - = current_block - > step_event_count ;
# if DISABLED(MIXING_EXTRUDER)
// Don't step E here for mixing extruder
motor_direction ( E_AXIS ) ? - - e_steps [ TOOL_E_INDEX ] : + + e_steps [ TOOL_E_INDEX ] ;
# endif
}
2016-05-04 14:10:42 -05:00
2016-09-21 17:28:54 -05:00
# if ENABLED(MIXING_EXTRUDER)
2016-06-28 17:06:56 -05:00
2016-09-21 17:28:54 -05:00
// Step mixing steppers proportionally
2016-10-08 11:13:04 -05:00
const bool dir = motor_direction ( E_AXIS ) ;
2016-09-21 17:28:54 -05:00
MIXING_STEPPERS_LOOP ( j ) {
counter_m [ j ] + = current_block - > steps [ E_AXIS ] ;
if ( counter_m [ j ] > 0 ) {
counter_m [ j ] - = current_block - > mix_event_count [ j ] ;
dir ? - - e_steps [ j ] : + + e_steps [ j ] ;
2016-06-28 17:06:56 -05:00
}
2016-09-21 17:28:54 -05:00
}
2016-06-28 17:06:56 -05:00
2016-09-21 17:28:54 -05:00
# endif // MIXING_EXTRUDER
2015-04-24 01:03:17 -05:00
2016-09-21 17:28:54 -05:00
# endif // ADVANCE or LIN_ADVANCE
2013-08-01 08:06:39 -05:00
2016-09-21 17:28:54 -05:00
# define _COUNTER(AXIS) counter_## AXIS
# define _APPLY_STEP(AXIS) AXIS ##_APPLY_STEP
# define _INVERT_STEP_PIN(AXIS) INVERT_## AXIS ##_STEP_PIN
2016-08-27 23:38:05 -05:00
2016-09-21 17:28:54 -05:00
// Advance the Bresenham counter; start a pulse if the axis needs a step
# define PULSE_START(AXIS) \
_COUNTER ( AXIS ) + = current_block - > steps [ _AXIS ( AXIS ) ] ; \
if ( _COUNTER ( AXIS ) > 0 ) { _APPLY_STEP ( AXIS ) ( ! _INVERT_STEP_PIN ( AXIS ) , 0 ) ; }
2016-08-27 23:38:05 -05:00
2016-09-21 17:28:54 -05:00
// Stop an active pulse, reset the Bresenham counter, update the position
# define PULSE_STOP(AXIS) \
if ( _COUNTER ( AXIS ) > 0 ) { \
_COUNTER ( AXIS ) - = current_block - > step_event_count ; \
count_position [ _AXIS ( AXIS ) ] + = count_direction [ _AXIS ( AXIS ) ] ; \
_APPLY_STEP ( AXIS ) ( _INVERT_STEP_PIN ( AXIS ) , 0 ) ; \
}
2016-06-28 17:06:56 -05:00
2016-09-23 23:59:16 -05:00
# define CYCLES_EATEN_BY_CODE 240
2016-09-21 17:28:54 -05:00
// If a minimum pulse time was specified get the CPU clock
2016-09-23 23:59:16 -05:00
# if STEP_PULSE_CYCLES > CYCLES_EATEN_BY_CODE
2016-09-21 17:28:54 -05:00
static uint32_t pulse_start ;
pulse_start = TCNT0 ;
# endif
2015-03-14 06:28:22 -05:00
2016-09-21 17:28:54 -05:00
# if HAS_X_STEP
PULSE_START ( X ) ;
# endif
# if HAS_Y_STEP
PULSE_START ( Y ) ;
# endif
# if HAS_Z_STEP
PULSE_START ( Z ) ;
# endif
2015-03-07 00:14:34 -06:00
2016-09-21 17:28:54 -05:00
// For non-advance use linear interpolation for E also
# if DISABLED(ADVANCE) && DISABLED(LIN_ADVANCE)
# if ENABLED(MIXING_EXTRUDER)
// Keep updating the single E axis
counter_E + = current_block - > steps [ E_AXIS ] ;
// Tick the counters used for this mix
MIXING_STEPPERS_LOOP ( j ) {
// Step mixing steppers (proportionally)
counter_m [ j ] + = current_block - > steps [ E_AXIS ] ;
// Step when the counter goes over zero
if ( counter_m [ j ] > 0 ) En_STEP_WRITE ( j , ! INVERT_E_STEP_PIN ) ;
}
# else // !MIXING_EXTRUDER
PULSE_START ( E ) ;
2016-08-27 19:38:24 -05:00
# endif
2016-09-21 17:28:54 -05:00
# endif // !ADVANCE && !LIN_ADVANCE
2016-06-28 17:06:56 -05:00
2016-09-21 17:28:54 -05:00
// For a minimum pulse time wait before stopping pulses
2016-09-23 23:59:16 -05:00
# if STEP_PULSE_CYCLES > CYCLES_EATEN_BY_CODE
while ( ( uint32_t ) ( TCNT0 - pulse_start ) < STEP_PULSE_CYCLES - CYCLES_EATEN_BY_CODE ) { /* nada */ }
2016-05-08 14:16:26 -05:00
# endif
2016-09-21 17:28:54 -05:00
# if HAS_X_STEP
PULSE_STOP ( X ) ;
# endif
# if HAS_Y_STEP
PULSE_STOP ( Y ) ;
# endif
# if HAS_Z_STEP
PULSE_STOP ( Z ) ;
# endif
2013-08-01 08:06:39 -05:00
2016-09-21 17:28:54 -05:00
# if DISABLED(ADVANCE) && DISABLED(LIN_ADVANCE)
# if ENABLED(MIXING_EXTRUDER)
// Always step the single E axis
if ( counter_E > 0 ) {
counter_E - = current_block - > step_event_count ;
count_position [ E_AXIS ] + = count_direction [ E_AXIS ] ;
}
MIXING_STEPPERS_LOOP ( j ) {
if ( counter_m [ j ] > 0 ) {
counter_m [ j ] - = current_block - > mix_event_count [ j ] ;
En_STEP_WRITE ( j , INVERT_E_STEP_PIN ) ;
}
}
# else // !MIXING_EXTRUDER
PULSE_STOP ( E ) ;
# endif
# endif // !ADVANCE && !LIN_ADVANCE
2013-08-01 08:06:39 -05:00
2016-09-21 17:28:54 -05:00
if ( + + step_events_completed > = current_block - > step_event_count ) {
all_steps_done = true ;
break ;
}
}
2011-11-13 13:42:08 -06:00
2016-10-08 11:13:04 -05:00
# if ENABLED(LIN_ADVANCE)
if ( current_block - > use_advance_lead ) {
2016-10-31 10:17:30 -05:00
int delta_adv_steps = current_estep_rate [ TOOL_E_INDEX ] - current_adv_steps [ TOOL_E_INDEX ] ;
2016-10-08 11:13:04 -05:00
current_adv_steps [ TOOL_E_INDEX ] + = delta_adv_steps ;
# if ENABLED(MIXING_EXTRUDER)
// Mixing extruders apply advance lead proportionally
MIXING_STEPPERS_LOOP ( j )
e_steps [ j ] + = delta_adv_steps * current_block - > step_event_count / current_block - > mix_event_count [ j ] ;
# else
// For most extruders, advance the single E stepper
e_steps [ TOOL_E_INDEX ] + = delta_adv_steps ;
# endif
}
# endif
2016-09-21 17:28:54 -05:00
# if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
// If we have esteps to execute, fire the next advance_isr "now"
if ( e_steps [ TOOL_E_INDEX ] ) OCR0A = TCNT0 + 2 ;
# endif
2016-05-08 14:16:26 -05:00
2016-09-21 17:28:54 -05:00
// Calculate new timer value
if ( step_events_completed < = ( uint32_t ) current_block - > accelerate_until ) {
2016-05-04 14:10:42 -05:00
2016-09-21 17:28:54 -05:00
MultiU24X32toH16 ( acc_step_rate , acceleration_time , current_block - > acceleration_rate ) ;
acc_step_rate + = current_block - > initial_rate ;
2016-06-28 17:06:56 -05:00
2016-09-21 17:28:54 -05:00
// upper limit
NOMORE ( acc_step_rate , current_block - > nominal_rate ) ;
2015-10-03 01:08:58 -05:00
2016-09-21 17:28:54 -05:00
// step_rate to timer interval
2016-11-17 23:42:41 -06:00
uint16_t timer = calc_timer ( acc_step_rate ) ;
2016-09-21 17:28:54 -05:00
OCR1A = timer ;
acceleration_time + = timer ;
2015-10-03 01:08:58 -05:00
2016-09-21 17:28:54 -05:00
# if ENABLED(LIN_ADVANCE)
2015-12-10 07:05:38 -06:00
2016-09-21 17:28:54 -05:00
if ( current_block - > use_advance_lead ) {
2016-06-28 17:06:56 -05:00
# if ENABLED(MIXING_EXTRUDER)
MIXING_STEPPERS_LOOP ( j )
2016-10-31 10:17:30 -05:00
current_estep_rate [ j ] = ( ( uint32_t ) acc_step_rate * current_block - > abs_adv_steps_multiplier8 * current_block - > step_event_count / current_block - > mix_event_count [ j ] ) > > 17 ;
2016-06-28 17:06:56 -05:00
# else
2016-10-31 10:17:30 -05:00
current_estep_rate [ TOOL_E_INDEX ] = ( ( uint32_t ) acc_step_rate * current_block - > abs_adv_steps_multiplier8 ) > > 17 ;
2016-06-28 17:06:56 -05:00
# endif
2016-09-21 17:28:54 -05:00
}
# elif ENABLED(ADVANCE)
2016-06-28 17:06:56 -05:00
2016-09-21 17:28:54 -05:00
advance + = advance_rate * step_loops ;
//NOLESS(advance, current_block->advance);
2013-08-01 08:06:39 -05:00
2016-09-21 17:28:54 -05:00
long advance_whole = advance > > 8 ,
advance_factor = advance_whole - old_advance ;
2016-05-04 14:10:42 -05:00
2016-09-21 17:28:54 -05:00
// Do E steps + advance steps
# if ENABLED(MIXING_EXTRUDER)
// ...for mixing steppers proportionally
MIXING_STEPPERS_LOOP ( j )
e_steps [ j ] + = advance_factor * current_block - > step_event_count / current_block - > mix_event_count [ j ] ;
# else
// ...for the active extruder
e_steps [ TOOL_E_INDEX ] + = advance_factor ;
2016-05-08 14:16:26 -05:00
# endif
2013-08-01 08:06:39 -05:00
2016-09-21 17:28:54 -05:00
old_advance = advance_whole ;
# endif // ADVANCE or LIN_ADVANCE
2015-12-10 07:05:38 -06:00
2016-09-21 17:28:54 -05:00
# if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
2016-10-09 17:44:27 -05:00
eISR_Rate = ( timer > > 3 ) * step_loops / abs ( e_steps [ TOOL_E_INDEX ] ) ; //>> 3 is divide by 8. Reason: Timer 1 runs at 16/8=2MHz, Timer 0 at 16/64=0.25MHz. ==> 2/0.25=8.
2016-09-21 17:28:54 -05:00
# endif
}
else if ( step_events_completed > ( uint32_t ) current_block - > decelerate_after ) {
2016-11-17 23:42:41 -06:00
uint16_t step_rate ;
2016-09-21 17:28:54 -05:00
MultiU24X32toH16 ( step_rate , 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 ;
2016-05-04 14:10:42 -05:00
2016-09-21 17:28:54 -05:00
// step_rate to timer interval
2016-11-17 23:42:41 -06:00
uint16_t timer = calc_timer ( step_rate ) ;
2016-09-21 17:28:54 -05:00
OCR1A = timer ;
deceleration_time + = timer ;
2015-12-10 07:05:38 -06:00
2016-09-21 17:28:54 -05:00
# if ENABLED(LIN_ADVANCE)
2016-06-28 17:06:56 -05:00
2016-09-21 17:28:54 -05:00
if ( current_block - > use_advance_lead ) {
2016-06-28 17:06:56 -05:00
# if ENABLED(MIXING_EXTRUDER)
MIXING_STEPPERS_LOOP ( j )
2016-10-31 10:17:30 -05:00
current_estep_rate [ j ] = ( ( uint32_t ) step_rate * current_block - > abs_adv_steps_multiplier8 * current_block - > step_event_count / current_block - > mix_event_count [ j ] ) > > 17 ;
2016-06-28 17:06:56 -05:00
# else
2016-10-31 10:17:30 -05:00
current_estep_rate [ TOOL_E_INDEX ] = ( ( uint32_t ) step_rate * current_block - > abs_adv_steps_multiplier8 ) > > 17 ;
2016-06-28 17:06:56 -05:00
# endif
2016-09-21 17:28:54 -05:00
}
# elif ENABLED(ADVANCE)
2016-06-28 17:06:56 -05:00
2016-09-21 17:28:54 -05:00
advance - = advance_rate * step_loops ;
NOLESS ( advance , final_advance ) ;
2016-05-04 14:10:42 -05:00
2016-09-21 17:28:54 -05:00
// Do E steps + advance steps
long advance_whole = advance > > 8 ,
advance_factor = advance_whole - old_advance ;
2016-05-08 14:16:26 -05:00
2016-09-21 17:28:54 -05:00
# if ENABLED(MIXING_EXTRUDER)
MIXING_STEPPERS_LOOP ( j )
e_steps [ j ] + = advance_factor * current_block - > step_event_count / current_block - > mix_event_count [ j ] ;
# else
e_steps [ TOOL_E_INDEX ] + = advance_factor ;
2016-05-08 14:16:26 -05:00
# endif
2016-09-21 17:28:54 -05:00
old_advance = advance_whole ;
# endif // ADVANCE or LIN_ADVANCE
2016-05-08 14:16:26 -05:00
2016-09-21 17:28:54 -05:00
# if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
2016-10-08 11:13:04 -05:00
eISR_Rate = ( timer > > 3 ) * step_loops / abs ( e_steps [ TOOL_E_INDEX ] ) ;
2016-09-21 17:28:54 -05:00
# endif
}
else {
2016-05-08 14:16:26 -05:00
2016-09-21 17:28:54 -05:00
# if ENABLED(LIN_ADVANCE)
2016-05-08 14:16:26 -05:00
2016-09-21 17:28:54 -05:00
if ( current_block - > use_advance_lead )
current_estep_rate [ TOOL_E_INDEX ] = final_estep_rate ;
2016-05-04 14:10:42 -05:00
2016-10-08 11:13:04 -05:00
eISR_Rate = ( OCR1A_nominal > > 3 ) * step_loops_nominal / abs ( e_steps [ TOOL_E_INDEX ] ) ;
2011-12-02 10:45:05 -06:00
2016-09-21 17:28:54 -05:00
# endif
2015-09-04 17:59:19 -05:00
2016-09-21 17:28:54 -05:00
OCR1A = OCR1A_nominal ;
// ensure we're running at the correct step rate, even if we just came off an acceleration
step_loops = step_loops_nominal ;
}
NOLESS ( OCR1A , TCNT1 + 16 ) ;
// If current block is finished, reset pointer
if ( all_steps_done ) {
current_block = NULL ;
planner . discard_current_block ( ) ;
2013-08-01 08:06:39 -05:00
}
2016-11-20 06:09:12 -06:00
# if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
SBI ( TIMSK0 , OCIE0A ) ;
# endif
SBI ( TIMSK0 , OCIE0B ) ;
ENABLE_STEPPER_DRIVER_INTERRUPT ( ) ;
2011-11-13 13:42:08 -06:00
}
2016-05-04 14:10:42 -05:00
# if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
2011-11-13 13:42:08 -06:00
// Timer interrupt for E. e_steps is set in the main routine;
// Timer 0 is shared with millies
2016-05-11 17:24:24 -05:00
ISR ( TIMER0_COMPA_vect ) { Stepper : : advance_isr ( ) ; }
2016-04-27 09:15:20 -05:00
void Stepper : : advance_isr ( ) {
2016-05-04 14:10:42 -05:00
2016-05-08 14:16:26 -05:00
old_OCR0A + = eISR_Rate ;
2011-12-02 10:45:05 -06:00
OCR0A = old_OCR0A ;
2016-03-10 03:42:58 -06:00
2016-10-01 04:51:45 -05:00
# define SET_E_STEP_DIR(INDEX) \
if ( e_steps [ INDEX ] ) E # # INDEX # # _DIR_WRITE ( e_steps [ INDEX ] < 0 ? INVERT_E # # INDEX # # _DIR : ! INVERT_E # # INDEX # # _DIR )
2016-08-30 14:22:42 -05:00
# define START_E_PULSE(INDEX) \
2016-09-19 07:05:22 -05:00
if ( e_steps [ INDEX ] ) E # # INDEX # # _STEP_WRITE ( ! INVERT_E_STEP_PIN )
2016-08-30 14:22:42 -05:00
# define STOP_E_PULSE(INDEX) \
if ( e_steps [ INDEX ] ) { \
2016-10-01 04:51:45 -05:00
e_steps [ INDEX ] < 0 ? + + e_steps [ INDEX ] : - - e_steps [ INDEX ] ; \
2016-09-19 07:05:22 -05:00
E # # INDEX # # _STEP_WRITE ( INVERT_E_STEP_PIN ) ; \
2011-12-12 12:34:37 -06:00
}
2016-03-10 03:42:58 -06:00
2016-10-01 04:51:45 -05:00
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
2016-09-23 23:59:16 -05:00
# define CYCLES_EATEN_BY_E 60
2016-05-06 13:03:56 -05:00
// Step all E steppers that have steps
2016-06-22 11:32:01 -05:00
for ( uint8_t i = 0 ; i < step_loops ; i + + ) {
2016-08-30 14:22:42 -05:00
2016-09-23 23:59:16 -05:00
# if STEP_PULSE_CYCLES > CYCLES_EATEN_BY_E
2016-08-30 14:22:58 -05:00
static uint32_t pulse_start ;
pulse_start = TCNT0 ;
# endif
2016-08-30 14:22:42 -05:00
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
2016-08-30 14:22:58 -05:00
// For a minimum pulse time wait before stopping pulses
2016-09-23 23:59:16 -05:00
# if STEP_PULSE_CYCLES > CYCLES_EATEN_BY_E
while ( ( uint32_t ) ( TCNT0 - pulse_start ) < STEP_PULSE_CYCLES - CYCLES_EATEN_BY_E ) { /* nada */ }
2016-08-30 14:22:58 -05:00
# endif
2016-08-30 14:22:42 -05:00
STOP_E_PULSE ( 0 ) ;
2016-06-28 17:06:56 -05:00
# if E_STEPPERS > 1
2016-08-30 14:22:42 -05:00
STOP_E_PULSE ( 1 ) ;
2016-06-28 17:06:56 -05:00
# if E_STEPPERS > 2
2016-08-30 14:22:42 -05:00
STOP_E_PULSE ( 2 ) ;
2016-06-28 17:06:56 -05:00
# if E_STEPPERS > 3
2016-08-30 14:22:42 -05:00
STOP_E_PULSE ( 3 ) ;
2016-06-22 11:32:01 -05:00
# endif
2016-03-10 03:42:58 -06:00
# endif
2015-10-03 01:08:58 -05:00
# endif
2016-06-22 11:32:01 -05:00
}
2016-04-27 09:15:20 -05:00
2016-05-04 11:53:17 -05:00
}
2016-05-04 14:10:42 -05:00
# endif // ADVANCE or LIN_ADVANCE
2016-05-04 11:53:17 -05:00
2016-04-27 09:15:20 -05:00
void Stepper : : init ( ) {
2016-05-11 17:24:24 -05:00
2016-09-25 06:32:58 -05:00
// Init Digipot Motor Current
# if HAS_DIGIPOTSS || HAS_MOTOR_CURRENT_PWM
digipot_init ( ) ;
# endif
2013-08-01 08:06:39 -05:00
2016-09-25 06:32:58 -05:00
// Init Microstepping Pins
# if HAS_MICROSTEPS
microstep_init ( ) ;
# endif
// Init TMC Steppers
2015-07-31 00:28:11 -05:00
# if ENABLED(HAVE_TMCDRIVER)
2015-03-14 06:28:22 -05:00
tmc_init ( ) ;
2015-02-23 10:45:29 -06:00
# endif
2016-09-25 06:32:58 -05:00
2016-09-14 01:48:47 -05:00
// Init TMC2130 Steppers
# if ENABLED(HAVE_TMC2130DRIVER)
tmc2130_init ( ) ;
# endif
2016-09-25 06:32:58 -05:00
// Init L6470 Steppers
2015-07-31 00:28:11 -05:00
# if ENABLED(HAVE_L6470DRIVER)
2015-03-14 06:28:22 -05:00
L6470_init ( ) ;
2015-02-27 05:43:23 -06:00
# endif
2015-04-24 01:03:17 -05:00
2016-09-25 06:32:58 -05:00
// Init Dir Pins
2015-04-03 17:31:35 -05:00
# if HAS_X_DIR
2015-02-23 09:12:35 -06:00
X_DIR_INIT ;
2011-11-13 13:42:08 -06:00
# endif
2015-04-03 17:31:35 -05:00
# if HAS_X2_DIR
2015-02-23 09:12:35 -06:00
X2_DIR_INIT ;
2013-07-17 07:44:45 -05:00
# endif
2015-04-03 17:31:35 -05:00
# if HAS_Y_DIR
2015-02-23 09:12:35 -06:00
Y_DIR_INIT ;
2015-07-31 00:28:11 -05:00
# if ENABLED(Y_DUAL_STEPPER_DRIVERS) && HAS_Y2_DIR
2015-03-14 06:28:22 -05:00
Y2_DIR_INIT ;
# endif
2011-11-13 13:42:08 -06:00
# endif
2015-04-03 17:31:35 -05:00
# if HAS_Z_DIR
2015-02-23 09:12:35 -06:00
Z_DIR_INIT ;
2015-07-31 00:28:11 -05:00
# if ENABLED(Z_DUAL_STEPPER_DRIVERS) && HAS_Z2_DIR
2015-02-23 09:12:35 -06:00
Z2_DIR_INIT ;
2012-08-04 01:32:26 -05:00
# endif
2011-11-13 13:42:08 -06:00
# endif
2015-04-03 17:31:35 -05:00
# if HAS_E0_DIR
2015-02-23 09:12:35 -06:00
E0_DIR_INIT ;
2011-12-05 22:33:33 -06:00
# endif
2015-04-03 17:31:35 -05:00
# if HAS_E1_DIR
2015-02-23 09:12:35 -06:00
E1_DIR_INIT ;
2011-12-05 22:33:33 -06:00
# endif
2015-04-03 17:31:35 -05:00
# if HAS_E2_DIR
2015-02-23 09:12:35 -06:00
E2_DIR_INIT ;
2011-11-13 13:42:08 -06:00
# endif
2015-04-03 17:31:35 -05:00
# if HAS_E3_DIR
2015-02-23 09:12:35 -06:00
E3_DIR_INIT ;
2015-01-23 16:13:06 -06:00
# endif
2011-11-13 13:42:08 -06:00
2016-09-25 06:32:58 -05:00
// Init Enable Pins - steppers default to disabled.
2015-04-03 17:31:35 -05:00
# if HAS_X_ENABLE
2015-02-23 09:12:35 -06:00
X_ENABLE_INIT ;
2015-03-14 06:28:22 -05:00
if ( ! X_ENABLE_ON ) X_ENABLE_WRITE ( HIGH ) ;
2016-05-17 16:56:49 -05:00
# if ENABLED(DUAL_X_CARRIAGE) && HAS_X2_ENABLE
X2_ENABLE_INIT ;
if ( ! X_ENABLE_ON ) X2_ENABLE_WRITE ( HIGH ) ;
# endif
2011-11-13 13:42:08 -06:00
# endif
2015-04-03 17:31:35 -05:00
# if HAS_Y_ENABLE
2015-02-23 09:12:35 -06:00
Y_ENABLE_INIT ;
2015-03-14 06:28:22 -05:00
if ( ! Y_ENABLE_ON ) Y_ENABLE_WRITE ( HIGH ) ;
2016-05-17 16:56:49 -05:00
# if ENABLED(Y_DUAL_STEPPER_DRIVERS) && HAS_Y2_ENABLE
Y2_ENABLE_INIT ;
if ( ! Y_ENABLE_ON ) Y2_ENABLE_WRITE ( HIGH ) ;
# endif
2011-11-13 13:42:08 -06:00
# endif
2015-04-03 17:31:35 -05:00
# if HAS_Z_ENABLE
2015-02-23 09:12:35 -06:00
Z_ENABLE_INIT ;
2015-03-14 06:28:22 -05:00
if ( ! Z_ENABLE_ON ) Z_ENABLE_WRITE ( HIGH ) ;
2015-07-31 00:28:11 -05:00
# if ENABLED(Z_DUAL_STEPPER_DRIVERS) && HAS_Z2_ENABLE
2015-02-23 09:12:35 -06:00
Z2_ENABLE_INIT ;
2015-03-14 06:28:22 -05:00
if ( ! Z_ENABLE_ON ) Z2_ENABLE_WRITE ( HIGH ) ;
2012-08-04 01:32:26 -05:00
# endif
2011-11-13 13:42:08 -06:00
# endif
2015-04-03 17:31:35 -05:00
# if HAS_E0_ENABLE
2015-02-23 09:12:35 -06:00
E0_ENABLE_INIT ;
2015-03-14 06:28:22 -05:00
if ( ! E_ENABLE_ON ) E0_ENABLE_WRITE ( HIGH ) ;
2011-12-05 22:33:33 -06:00
# endif
2015-04-03 17:31:35 -05:00
# if HAS_E1_ENABLE
2015-02-23 09:12:35 -06:00
E1_ENABLE_INIT ;
2015-03-14 06:28:22 -05:00
if ( ! E_ENABLE_ON ) E1_ENABLE_WRITE ( HIGH ) ;
2011-12-05 22:33:33 -06:00
# endif
2015-04-03 17:31:35 -05:00
# if HAS_E2_ENABLE
2015-02-23 09:12:35 -06:00
E2_ENABLE_INIT ;
2015-03-14 06:28:22 -05:00
if ( ! E_ENABLE_ON ) E2_ENABLE_WRITE ( HIGH ) ;
2011-11-13 13:42:08 -06:00
# endif
2015-04-03 17:31:35 -05:00
# if HAS_E3_ENABLE
2015-02-23 09:12:35 -06:00
E3_ENABLE_INIT ;
2015-03-14 06:28:22 -05:00
if ( ! E_ENABLE_ON ) E3_ENABLE_WRITE ( HIGH ) ;
2015-01-23 16:13:06 -06:00
# endif
2011-11-13 13:42:08 -06:00
2016-09-25 06:32:58 -05:00
// Init endstops and pullups
2016-04-27 09:15:20 -05:00
endstops . init ( ) ;
2015-03-28 04:31:51 -05:00
2015-04-24 01:03:17 -05:00
# define _STEP_INIT(AXIS) AXIS ##_STEP_INIT
2015-05-07 11:55:47 -05:00
# define _WRITE_STEP(AXIS, HIGHLOW) AXIS ##_STEP_WRITE(HIGHLOW)
2015-04-24 01:03:17 -05:00
# define _DISABLE(axis) disable_## axis()
2015-03-14 06:28:22 -05:00
# define AXIS_INIT(axis, AXIS, PIN) \
2015-04-24 01:03:17 -05:00
_STEP_INIT ( AXIS ) ; \
_WRITE_STEP ( AXIS , _INVERT_STEP_PIN ( PIN ) ) ; \
_DISABLE ( axis )
2011-11-13 13:42:08 -06:00
2015-03-14 06:28:22 -05:00
# define E_AXIS_INIT(NUM) AXIS_INIT(e## NUM, E## NUM, E)
2016-09-25 06:32:58 -05:00
// Init Step Pins
2015-04-03 17:31:35 -05:00
# if HAS_X_STEP
2016-07-11 12:19:07 -05:00
# if ENABLED(X_DUAL_STEPPER_DRIVERS) || ENABLED(DUAL_X_CARRIAGE)
X2_STEP_INIT ;
X2_STEP_WRITE ( INVERT_X_STEP_PIN ) ;
2016-05-17 16:56:49 -05:00
# endif
2016-07-11 12:19:07 -05:00
AXIS_INIT ( x , X , X ) ;
2013-08-01 08:06:39 -05:00
# endif
2016-05-17 16:56:49 -05:00
2015-04-03 17:31:35 -05:00
# if HAS_Y_STEP
2016-07-11 12:19:07 -05:00
# if ENABLED(Y_DUAL_STEPPER_DRIVERS)
2015-02-23 09:12:35 -06:00
Y2_STEP_INIT ;
Y2_STEP_WRITE ( INVERT_Y_STEP_PIN ) ;
2013-09-17 13:19:20 -05:00
# endif
2015-03-14 06:28:22 -05:00
AXIS_INIT ( y , Y , Y ) ;
2013-08-01 08:06:39 -05:00
# endif
2016-05-17 16:56:49 -05:00
2015-04-03 17:31:35 -05:00
# if HAS_Z_STEP
2016-07-11 12:19:07 -05:00
# if ENABLED(Z_DUAL_STEPPER_DRIVERS)
2015-02-23 09:12:35 -06:00
Z2_STEP_INIT ;
Z2_STEP_WRITE ( INVERT_Z_STEP_PIN ) ;
2012-08-04 01:32:26 -05:00
# endif
2015-03-14 06:28:22 -05:00
AXIS_INIT ( z , Z , Z ) ;
2013-08-01 08:06:39 -05:00
# endif
2016-05-17 16:56:49 -05:00
2015-04-03 17:31:35 -05:00
# if HAS_E0_STEP
2015-03-14 06:28:22 -05:00
E_AXIS_INIT ( 0 ) ;
2013-08-01 08:06:39 -05:00
# endif
2015-04-03 17:31:35 -05:00
# if HAS_E1_STEP
2015-03-14 06:28:22 -05:00
E_AXIS_INIT ( 1 ) ;
2013-08-01 08:06:39 -05:00
# endif
2015-04-03 17:31:35 -05:00
# if HAS_E2_STEP
2015-03-14 06:28:22 -05:00
E_AXIS_INIT ( 2 ) ;
2013-08-01 08:06:39 -05:00
# endif
2015-04-03 17:31:35 -05:00
# if HAS_E3_STEP
2015-03-14 06:28:22 -05:00
E_AXIS_INIT ( 3 ) ;
2015-01-23 16:13:06 -06:00
# endif
2011-11-13 13:42:08 -06:00
// waveform generation = 0100 = CTC
2016-02-27 06:51:44 -06:00
CBI ( TCCR1B , WGM13 ) ;
SBI ( TCCR1B , WGM12 ) ;
CBI ( TCCR1A , WGM11 ) ;
CBI ( TCCR1A , WGM10 ) ;
2011-11-13 13:42:08 -06:00
// output mode = 00 (disconnected)
2015-10-03 01:08:58 -05:00
TCCR1A & = ~ ( 3 < < COM1A0 ) ;
TCCR1A & = ~ ( 3 < < COM1B0 ) ;
2016-10-09 10:06:31 -05:00
2012-03-07 16:58:35 -06:00
// Set the timer pre-scaler
// Generally we use a divider of 8, resulting in a 2MHz timer
// frequency on a 16MHz MCU. If you are going to change this, be
// sure to regenerate speed_lookuptable.h with
// create_speed_lookuptable.py
2015-10-03 01:08:58 -05:00
TCCR1B = ( TCCR1B & ~ ( 0x07 < < CS10 ) ) | ( 2 < < CS10 ) ;
2011-11-13 13:42:08 -06:00
2016-10-09 10:06:31 -05:00
// Init Stepper ISR to 122 Hz for quick starting
2011-11-13 13:42:08 -06:00
OCR1A = 0x4000 ;
2011-11-18 11:59:17 -06:00
TCNT1 = 0 ;
2013-08-01 08:06:39 -05:00
ENABLE_STEPPER_DRIVER_INTERRUPT ( ) ;
2016-05-04 14:10:42 -05:00
# if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
2016-06-28 17:06:56 -05:00
for ( int i = 0 ; i < E_STEPPERS ; i + + ) {
e_steps [ i ] = 0 ;
# if ENABLED(LIN_ADVANCE)
2016-05-04 14:10:42 -05:00
current_adv_steps [ i ] = 0 ;
2016-06-28 17:06:56 -05:00
# endif
}
2011-11-13 13:42:08 -06:00
2015-03-14 06:28:22 -05:00
# if defined(TCCR0A) && defined(WGM01)
2016-02-27 06:51:44 -06:00
CBI ( TCCR0A , WGM01 ) ;
CBI ( TCCR0A , WGM00 ) ;
2015-03-14 06:28:22 -05:00
# endif
2016-02-27 06:51:44 -06:00
SBI ( TIMSK0 , OCIE0A ) ;
2016-05-04 14:10:42 -05:00
# endif // ADVANCE or LIN_ADVANCE
2013-08-01 08:06:39 -05:00
2016-04-27 09:15:20 -05:00
endstops . enable ( true ) ; // Start with endstops active. After homing they can be disabled
2011-11-13 13:42:08 -06:00
sei ( ) ;
2015-10-03 01:08:58 -05:00
2016-04-27 09:15:20 -05:00
set_directions ( ) ; // Init directions to last_direction_bits = 0
2011-11-13 13:42:08 -06:00
}
2011-12-09 05:32:31 -06:00
2015-05-26 22:08:21 -05:00
/**
* Block until all buffered steps are executed
*/
2016-04-27 20:06:32 -05:00
void Stepper : : synchronize ( ) { while ( planner . blocks_queued ( ) ) idle ( ) ; }
2011-11-20 07:50:08 -06:00
2016-04-11 03:03:50 -05:00
/**
* Set the stepper positions directly in steps
*
* The input is based on the typical per - axis XYZ steps .
* For CORE machines XYZ needs to be translated to ABC .
*
2016-04-27 09:15:20 -05:00
* This allows get_axis_position_mm to correctly
2016-04-11 03:03:50 -05:00
* derive the current XYZ position later on .
*/
2016-10-09 13:25:25 -05:00
void Stepper : : set_position ( const long & a , const long & b , const long & c , const long & e ) {
2016-09-21 17:37:05 -05:00
synchronize ( ) ; // Bad to set stepper counts in the middle of a move
2011-11-20 07:50:08 -06:00
CRITICAL_SECTION_START ;
2016-04-11 03:03:50 -05:00
2016-11-05 23:47:38 -05:00
# if CORE_IS_XY
2016-04-11 03:03:50 -05:00
// corexy positioning
// these equations follow the form of the dA and dB equations on http://www.corexy.com/theory.html
2016-10-09 13:25:25 -05:00
count_position [ A_AXIS ] = a + b ;
2016-11-05 23:47:38 -05:00
count_position [ B_AXIS ] = CORESIGN ( a - b ) ;
2016-10-09 13:25:25 -05:00
count_position [ Z_AXIS ] = c ;
2016-11-05 23:47:38 -05:00
# elif CORE_IS_XZ
2016-04-11 03:03:50 -05:00
// corexz planning
2016-10-09 13:25:25 -05:00
count_position [ A_AXIS ] = a + c ;
count_position [ Y_AXIS ] = b ;
2016-11-05 23:47:38 -05:00
count_position [ C_AXIS ] = CORESIGN ( a - c ) ;
# elif CORE_IS_YZ
2016-05-20 15:27:49 -05:00
// coreyz planning
2016-10-09 13:25:25 -05:00
count_position [ X_AXIS ] = a ;
2016-11-03 16:41:55 -05:00
count_position [ B_AXIS ] = b + c ;
2016-11-05 23:47:38 -05:00
count_position [ C_AXIS ] = CORESIGN ( b - c ) ;
2016-04-11 03:03:50 -05:00
# else
// default non-h-bot planning
2016-10-09 13:25:25 -05:00
count_position [ X_AXIS ] = a ;
count_position [ Y_AXIS ] = b ;
count_position [ Z_AXIS ] = c ;
2016-04-11 03:03:50 -05:00
# endif
2011-11-20 07:50:08 -06:00
count_position [ E_AXIS ] = e ;
CRITICAL_SECTION_END ;
}
2016-10-09 13:25:25 -05:00
void Stepper : : set_position ( const AxisEnum & axis , const long & v ) {
2016-09-28 14:01:29 -05:00
CRITICAL_SECTION_START ;
count_position [ axis ] = v ;
CRITICAL_SECTION_END ;
}
2016-10-09 13:25:25 -05:00
void Stepper : : set_e_position ( const long & e ) {
2011-11-25 06:43:06 -06:00
CRITICAL_SECTION_START ;
count_position [ E_AXIS ] = e ;
CRITICAL_SECTION_END ;
}
2016-04-11 03:03:10 -05:00
/**
* Get a stepper ' s position in steps .
*/
2016-04-27 09:15:20 -05:00
long Stepper : : position ( AxisEnum axis ) {
2011-11-20 07:50:08 -06:00
CRITICAL_SECTION_START ;
2016-02-11 20:17:17 -06:00
long count_pos = count_position [ axis ] ;
2011-11-20 07:50:08 -06:00
CRITICAL_SECTION_END ;
return count_pos ;
}
2011-11-26 04:50:23 -06:00
2016-04-11 03:03:10 -05:00
/**
* Get an axis position according to stepper position ( s )
* For CORE machines apply translation from ABC to XYZ .
*/
2016-04-27 09:15:20 -05:00
float Stepper : : get_axis_position_mm ( AxisEnum axis ) {
2016-04-11 03:03:10 -05:00
float axis_steps ;
2016-11-05 23:47:38 -05:00
# if IS_CORE
2016-05-20 15:27:49 -05:00
// Requesting one of the "core" axes?
if ( axis = = CORE_AXIS_1 | | axis = = CORE_AXIS_2 ) {
2016-02-11 20:17:17 -06:00
CRITICAL_SECTION_START ;
// ((a1+a2)+(a1-a2))/2 -> (a1+a2+a1-a2)/2 -> (a1+a1)/2 -> a1
// ((a1+a2)-(a1-a2))/2 -> (a1+a2-a1+a2)/2 -> (a2+a2)/2 -> a2
2016-11-05 23:47:38 -05:00
axis_steps = 0.5f * (
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 ]
) ;
CRITICAL_SECTION_END ;
2016-02-11 20:17:17 -06:00
}
else
2016-04-27 09:15:20 -05:00
axis_steps = position ( axis ) ;
2016-02-11 20:17:17 -06:00
# else
2016-04-27 09:15:20 -05:00
axis_steps = position ( axis ) ;
2016-02-11 20:17:17 -06:00
# endif
2016-07-23 21:36:26 -05:00
return axis_steps * planner . steps_to_mm [ axis ] ;
2016-02-11 20:17:17 -06:00
}
2013-09-29 11:20:06 -05:00
2016-04-27 09:15:20 -05:00
void Stepper : : finish_and_disable ( ) {
synchronize ( ) ;
2015-04-03 21:25:22 -05:00
disable_all_steppers ( ) ;
2011-11-26 04:50:23 -06:00
}
2011-12-11 15:10:06 -06:00
2016-04-27 09:15:20 -05:00
void Stepper : : quick_stop ( ) {
2015-03-19 12:16:18 -05:00
cleaning_buffer_counter = 5000 ;
2011-12-11 15:10:06 -06:00
DISABLE_STEPPER_DRIVER_INTERRUPT ( ) ;
2016-04-27 20:06:32 -05:00
while ( planner . blocks_queued ( ) ) planner . discard_current_block ( ) ;
2012-03-03 13:40:46 -06:00
current_block = NULL ;
2011-12-11 15:10:06 -06:00
ENABLE_STEPPER_DRIVER_INTERRUPT ( ) ;
2016-12-12 07:35:02 -06:00
# if ENABLED(ULTRA_LCD)
planner . clear_block_buffer_runtime ( ) ;
# endif
2011-12-11 15:10:06 -06:00
}
2016-04-27 09:15:20 -05:00
void Stepper : : endstop_triggered ( AxisEnum axis ) {
2016-11-05 23:47:38 -05:00
# if IS_CORE
2016-04-27 09:15:20 -05:00
2016-11-05 23:47:38 -05:00
endstops_trigsteps [ axis ] = 0.5f * (
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 ]
) ;
2016-04-27 09:15:20 -05:00
2016-05-20 15:27:49 -05:00
# else // !COREXY && !COREXZ && !COREYZ
2016-04-27 09:15:20 -05:00
endstops_trigsteps [ axis ] = count_position [ axis ] ;
2016-05-20 15:27:49 -05:00
# endif // !COREXY && !COREXZ && !COREYZ
2016-04-27 09:15:20 -05:00
kill_current_block ( ) ;
}
void Stepper : : report_positions ( ) {
CRITICAL_SECTION_START ;
long xpos = count_position [ X_AXIS ] ,
ypos = count_position [ Y_AXIS ] ,
zpos = count_position [ Z_AXIS ] ;
CRITICAL_SECTION_END ;
2016-11-05 23:47:38 -05:00
# if CORE_IS_XY || CORE_IS_XZ || IS_SCARA
2016-04-27 09:15:20 -05:00
SERIAL_PROTOCOLPGM ( MSG_COUNT_A ) ;
# else
SERIAL_PROTOCOLPGM ( MSG_COUNT_X ) ;
# endif
SERIAL_PROTOCOL ( xpos ) ;
2016-11-05 23:47:38 -05:00
# if CORE_IS_XY || CORE_IS_YZ || IS_SCARA
2016-04-27 09:15:20 -05:00
SERIAL_PROTOCOLPGM ( " B: " ) ;
# else
SERIAL_PROTOCOLPGM ( " Y: " ) ;
# endif
SERIAL_PROTOCOL ( ypos ) ;
2016-11-05 23:47:38 -05:00
# if CORE_IS_XZ || CORE_IS_YZ
2016-04-27 09:15:20 -05:00
SERIAL_PROTOCOLPGM ( " C: " ) ;
# else
SERIAL_PROTOCOLPGM ( " Z: " ) ;
# endif
SERIAL_PROTOCOL ( zpos ) ;
SERIAL_EOL ;
}
2015-07-31 00:28:11 -05:00
# if ENABLED(BABYSTEPPING)
Add the socalled "Babystepping" feature.
It is a realtime control over the head position via the LCD menu system that works _while_ printing.
Using it, one can e.g. tune the z-position in realtime, while printing the first layer.
Also, lost steps can be manually added/removed, but thats not the prime feature.
Stuff is placed into the Tune->Babystep *
It is not possible to have realtime control via gcode sending due to the buffering, so I did not include a gcode yet. However, it could be added, but it movements will not be realtime then.
Historically, a very similar thing was implemented for the "Kaamermaker" project, while Joris was babysitting his offspring, hence the name.
say goodby to fuddling around with the z-axis.
2013-10-06 14:14:51 -05:00
2016-11-03 16:42:44 -05:00
# define _ENABLE(axis) enable_## axis()
# define _READ_DIR(AXIS) AXIS ##_DIR_READ
# define _INVERT_DIR(AXIS) INVERT_## AXIS ##_DIR
# define _APPLY_DIR(AXIS, INVERT) AXIS ##_APPLY_DIR(INVERT, true)
# define BABYSTEP_AXIS(axis, AXIS, INVERT) { \
_ENABLE ( axis ) ; \
uint8_t old_pin = _READ_DIR ( AXIS ) ; \
_APPLY_DIR ( AXIS , _INVERT_DIR ( AXIS ) ^ direction ^ INVERT ) ; \
_APPLY_STEP ( AXIS ) ( ! _INVERT_STEP_PIN ( AXIS ) , true ) ; \
delayMicroseconds ( 2 ) ; \
_APPLY_STEP ( AXIS ) ( _INVERT_STEP_PIN ( AXIS ) , true ) ; \
_APPLY_DIR ( AXIS , old_pin ) ; \
}
2015-03-14 06:28:22 -05:00
// MUST ONLY BE CALLED BY AN ISR,
// No other ISR should ever interrupt this!
2016-11-03 18:23:31 -05:00
void Stepper : : babystep ( const AxisEnum axis , const bool direction ) {
2015-03-14 06:28:22 -05:00
2015-10-03 01:08:58 -05:00
switch ( axis ) {
Add the socalled "Babystepping" feature.
It is a realtime control over the head position via the LCD menu system that works _while_ printing.
Using it, one can e.g. tune the z-position in realtime, while printing the first layer.
Also, lost steps can be manually added/removed, but thats not the prime feature.
Stuff is placed into the Tune->Babystep *
It is not possible to have realtime control via gcode sending due to the buffering, so I did not include a gcode yet. However, it could be added, but it movements will not be realtime then.
Historically, a very similar thing was implemented for the "Kaamermaker" project, while Joris was babysitting his offspring, hence the name.
say goodby to fuddling around with the z-axis.
2013-10-06 14:14:51 -05:00
2015-03-14 06:28:22 -05:00
case X_AXIS :
BABYSTEP_AXIS ( x , X , false ) ;
break ;
Add the socalled "Babystepping" feature.
It is a realtime control over the head position via the LCD menu system that works _while_ printing.
Using it, one can e.g. tune the z-position in realtime, while printing the first layer.
Also, lost steps can be manually added/removed, but thats not the prime feature.
Stuff is placed into the Tune->Babystep *
It is not possible to have realtime control via gcode sending due to the buffering, so I did not include a gcode yet. However, it could be added, but it movements will not be realtime then.
Historically, a very similar thing was implemented for the "Kaamermaker" project, while Joris was babysitting his offspring, hence the name.
say goodby to fuddling around with the z-axis.
2013-10-06 14:14:51 -05:00
2015-03-14 06:28:22 -05:00
case Y_AXIS :
BABYSTEP_AXIS ( y , Y , false ) ;
break ;
2015-10-03 01:08:58 -05:00
2015-03-14 06:28:22 -05:00
case Z_AXIS : {
2015-01-23 05:24:45 -06:00
2015-07-31 00:28:11 -05:00
# if DISABLED(DELTA)
Add the socalled "Babystepping" feature.
It is a realtime control over the head position via the LCD menu system that works _while_ printing.
Using it, one can e.g. tune the z-position in realtime, while printing the first layer.
Also, lost steps can be manually added/removed, but thats not the prime feature.
Stuff is placed into the Tune->Babystep *
It is not possible to have realtime control via gcode sending due to the buffering, so I did not include a gcode yet. However, it could be added, but it movements will not be realtime then.
Historically, a very similar thing was implemented for the "Kaamermaker" project, while Joris was babysitting his offspring, hence the name.
say goodby to fuddling around with the z-axis.
2013-10-06 14:14:51 -05:00
2015-03-14 06:28:22 -05:00
BABYSTEP_AXIS ( z , Z , BABYSTEP_INVERT_Z ) ;
Add the socalled "Babystepping" feature.
It is a realtime control over the head position via the LCD menu system that works _while_ printing.
Using it, one can e.g. tune the z-position in realtime, while printing the first layer.
Also, lost steps can be manually added/removed, but thats not the prime feature.
Stuff is placed into the Tune->Babystep *
It is not possible to have realtime control via gcode sending due to the buffering, so I did not include a gcode yet. However, it could be added, but it movements will not be realtime then.
Historically, a very similar thing was implemented for the "Kaamermaker" project, while Joris was babysitting his offspring, hence the name.
say goodby to fuddling around with the z-axis.
2013-10-06 14:14:51 -05:00
2015-03-14 06:28:22 -05:00
# else // DELTA
2015-01-23 05:24:45 -06:00
2015-03-14 06:28:22 -05:00
bool z_direction = direction ^ BABYSTEP_INVERT_Z ;
2015-01-23 05:24:45 -06:00
2015-03-14 06:28:22 -05:00
enable_x ( ) ;
enable_y ( ) ;
enable_z ( ) ;
uint8_t old_x_dir_pin = X_DIR_READ ,
old_y_dir_pin = Y_DIR_READ ,
old_z_dir_pin = Z_DIR_READ ;
//setup new step
2015-10-03 01:08:58 -05:00
X_DIR_WRITE ( INVERT_X_DIR ^ z_direction ) ;
Y_DIR_WRITE ( INVERT_Y_DIR ^ z_direction ) ;
Z_DIR_WRITE ( INVERT_Z_DIR ^ z_direction ) ;
//perform step
2015-03-14 06:28:22 -05:00
X_STEP_WRITE ( ! INVERT_X_STEP_PIN ) ;
Y_STEP_WRITE ( ! INVERT_Y_STEP_PIN ) ;
Z_STEP_WRITE ( ! INVERT_Z_STEP_PIN ) ;
2015-04-16 06:16:36 -05:00
delayMicroseconds ( 2 ) ;
2015-10-03 01:08:58 -05:00
X_STEP_WRITE ( INVERT_X_STEP_PIN ) ;
Y_STEP_WRITE ( INVERT_Y_STEP_PIN ) ;
2015-03-14 06:28:22 -05:00
Z_STEP_WRITE ( INVERT_Z_STEP_PIN ) ;
//get old pin state back.
X_DIR_WRITE ( old_x_dir_pin ) ;
Y_DIR_WRITE ( old_y_dir_pin ) ;
Z_DIR_WRITE ( old_z_dir_pin ) ;
Add the socalled "Babystepping" feature.
It is a realtime control over the head position via the LCD menu system that works _while_ printing.
Using it, one can e.g. tune the z-position in realtime, while printing the first layer.
Also, lost steps can be manually added/removed, but thats not the prime feature.
Stuff is placed into the Tune->Babystep *
It is not possible to have realtime control via gcode sending due to the buffering, so I did not include a gcode yet. However, it could be added, but it movements will not be realtime then.
Historically, a very similar thing was implemented for the "Kaamermaker" project, while Joris was babysitting his offspring, hence the name.
say goodby to fuddling around with the z-axis.
2013-10-06 14:14:51 -05:00
2015-03-14 06:28:22 -05:00
# endif
Add the socalled "Babystepping" feature.
It is a realtime control over the head position via the LCD menu system that works _while_ printing.
Using it, one can e.g. tune the z-position in realtime, while printing the first layer.
Also, lost steps can be manually added/removed, but thats not the prime feature.
Stuff is placed into the Tune->Babystep *
It is not possible to have realtime control via gcode sending due to the buffering, so I did not include a gcode yet. However, it could be added, but it movements will not be realtime then.
Historically, a very similar thing was implemented for the "Kaamermaker" project, while Joris was babysitting his offspring, hence the name.
say goodby to fuddling around with the z-axis.
2013-10-06 14:14:51 -05:00
2015-03-14 06:28:22 -05:00
} break ;
2015-10-03 01:08:58 -05:00
2015-03-14 06:28:22 -05:00
default : break ;
}
Add the socalled "Babystepping" feature.
It is a realtime control over the head position via the LCD menu system that works _while_ printing.
Using it, one can e.g. tune the z-position in realtime, while printing the first layer.
Also, lost steps can be manually added/removed, but thats not the prime feature.
Stuff is placed into the Tune->Babystep *
It is not possible to have realtime control via gcode sending due to the buffering, so I did not include a gcode yet. However, it could be added, but it movements will not be realtime then.
Historically, a very similar thing was implemented for the "Kaamermaker" project, while Joris was babysitting his offspring, hence the name.
say goodby to fuddling around with the z-axis.
2013-10-06 14:14:51 -05:00
}
2013-10-07 02:14:04 -05:00
Add the socalled "Babystepping" feature.
It is a realtime control over the head position via the LCD menu system that works _while_ printing.
Using it, one can e.g. tune the z-position in realtime, while printing the first layer.
Also, lost steps can be manually added/removed, but thats not the prime feature.
Stuff is placed into the Tune->Babystep *
It is not possible to have realtime control via gcode sending due to the buffering, so I did not include a gcode yet. However, it could be added, but it movements will not be realtime then.
Historically, a very similar thing was implemented for the "Kaamermaker" project, while Joris was babysitting his offspring, hence the name.
say goodby to fuddling around with the z-axis.
2013-10-06 14:14:51 -05:00
# endif //BABYSTEPPING
2016-04-27 09:15:20 -05:00
/**
* Software - controlled Stepper Motor Current
*/
2016-03-19 20:44:08 -05:00
# if HAS_DIGIPOTSS
// From Arduino DigitalPotControl example
2016-04-27 09:15:20 -05:00
void Stepper : : digitalPotWrite ( int address , int value ) {
2016-09-25 05:52:10 -05:00
WRITE ( DIGIPOTSS_PIN , LOW ) ; // take the SS pin low to select the chip
2012-08-30 02:16:57 -05:00
SPI . transfer ( address ) ; // send in the address and value via SPI:
SPI . transfer ( value ) ;
2016-09-25 05:52:10 -05:00
WRITE ( DIGIPOTSS_PIN , HIGH ) ; // take the SS pin high to de-select the chip:
2012-08-30 02:16:57 -05:00
//delay(10);
2016-03-19 20:44:08 -05:00
}
# endif //HAS_DIGIPOTSS
2012-08-30 02:16:57 -05:00
2016-09-25 06:32:58 -05:00
# if HAS_DIGIPOTSS || HAS_MOTOR_CURRENT_PWM
2013-08-01 08:06:39 -05:00
2016-09-25 06:32:58 -05:00
void Stepper : : digipot_init ( ) {
# if HAS_DIGIPOTSS
static const uint8_t digipot_motor_current [ ] = DIGIPOT_MOTOR_CURRENT ;
SPI . begin ( ) ;
SET_OUTPUT ( DIGIPOTSS_PIN ) ;
for ( uint8_t i = 0 ; i < COUNT ( digipot_motor_current ) ; i + + ) {
//digitalPotWrite(digipot_ch[i], digipot_motor_current[i]);
digipot_current ( i , digipot_motor_current [ i ] ) ;
}
# elif HAS_MOTOR_CURRENT_PWM
2016-03-25 06:05:07 -05:00
# if PIN_EXISTS(MOTOR_CURRENT_PWM_XY)
2016-09-25 06:32:58 -05:00
SET_OUTPUT ( MOTOR_CURRENT_PWM_XY_PIN ) ;
digipot_current ( 0 , motor_current_setting [ 0 ] ) ;
2016-03-25 06:05:07 -05:00
# endif
# if PIN_EXISTS(MOTOR_CURRENT_PWM_Z)
2016-09-25 06:32:58 -05:00
SET_OUTPUT ( MOTOR_CURRENT_PWM_Z_PIN ) ;
digipot_current ( 1 , motor_current_setting [ 1 ] ) ;
2016-03-25 06:05:07 -05:00
# endif
# if PIN_EXISTS(MOTOR_CURRENT_PWM_E)
2016-09-25 06:32:58 -05:00
SET_OUTPUT ( MOTOR_CURRENT_PWM_E_PIN ) ;
digipot_current ( 2 , motor_current_setting [ 2 ] ) ;
2016-03-25 06:05:07 -05:00
# endif
2016-09-25 06:32:58 -05:00
//Set timer5 to 31khz so the PWM of the motor power is as constant as possible. (removes a buzzing noise)
TCCR5B = ( TCCR5B & ~ ( _BV ( CS50 ) | _BV ( CS51 ) | _BV ( CS52 ) ) ) | _BV ( CS50 ) ;
# endif
}
2012-08-30 02:16:57 -05:00
2016-09-25 06:32:58 -05:00
void Stepper : : digipot_current ( uint8_t driver , int current ) {
# if HAS_DIGIPOTSS
const uint8_t digipot_ch [ ] = DIGIPOT_CHANNELS ;
digitalPotWrite ( digipot_ch [ driver ] , current ) ;
# elif HAS_MOTOR_CURRENT_PWM
# define _WRITE_CURRENT_PWM(P) analogWrite(P, 255L * current / (MOTOR_CURRENT_PWM_RANGE))
switch ( driver ) {
# if PIN_EXISTS(MOTOR_CURRENT_PWM_XY)
case 0 : _WRITE_CURRENT_PWM ( MOTOR_CURRENT_PWM_XY_PIN ) ; break ;
# endif
# if PIN_EXISTS(MOTOR_CURRENT_PWM_Z)
case 1 : _WRITE_CURRENT_PWM ( MOTOR_CURRENT_PWM_Z_PIN ) ; break ;
# endif
# if PIN_EXISTS(MOTOR_CURRENT_PWM_E)
case 2 : _WRITE_CURRENT_PWM ( MOTOR_CURRENT_PWM_E_PIN ) ; break ;
# endif
}
# endif
}
2014-04-24 23:57:11 -05:00
2016-09-25 06:32:58 -05:00
# endif
2012-08-30 02:16:57 -05:00
2016-09-25 06:32:58 -05:00
# if HAS_MICROSTEPS
/**
* Software - controlled Microstepping
*/
2016-04-27 09:15:20 -05:00
2016-09-25 06:32:58 -05:00
void Stepper : : microstep_init ( ) {
SET_OUTPUT ( X_MS1_PIN ) ;
SET_OUTPUT ( X_MS2_PIN ) ;
# if HAS_MICROSTEPS_Y
SET_OUTPUT ( Y_MS1_PIN ) ;
SET_OUTPUT ( Y_MS2_PIN ) ;
# endif
# if HAS_MICROSTEPS_Z
SET_OUTPUT ( Z_MS1_PIN ) ;
SET_OUTPUT ( Z_MS2_PIN ) ;
# endif
# if HAS_MICROSTEPS_E0
SET_OUTPUT ( E0_MS1_PIN ) ;
SET_OUTPUT ( E0_MS2_PIN ) ;
# endif
2015-04-03 17:31:35 -05:00
# if HAS_MICROSTEPS_E1
2016-09-25 06:32:58 -05:00
SET_OUTPUT ( E1_MS1_PIN ) ;
SET_OUTPUT ( E1_MS2_PIN ) ;
2014-04-24 23:57:11 -05:00
# endif
2016-09-25 06:32:58 -05:00
static const uint8_t microstep_modes [ ] = MICROSTEP_MODES ;
for ( uint16_t i = 0 ; i < COUNT ( microstep_modes ) ; i + + )
microstep_mode ( i , microstep_modes [ i ] ) ;
2012-08-30 02:16:57 -05:00
}
2016-09-25 06:32:58 -05:00
void Stepper : : microstep_ms ( uint8_t driver , int8_t ms1 , int8_t ms2 ) {
if ( ms1 > = 0 ) switch ( driver ) {
case 0 : digitalWrite ( X_MS1_PIN , ms1 ) ; break ;
# if HAS_MICROSTEPS_Y
case 1 : digitalWrite ( Y_MS1_PIN , ms1 ) ; break ;
# endif
# if HAS_MICROSTEPS_Z
case 2 : digitalWrite ( Z_MS1_PIN , ms1 ) ; break ;
# endif
# if HAS_MICROSTEPS_E0
case 3 : digitalWrite ( E0_MS1_PIN , ms1 ) ; break ;
# endif
# if HAS_MICROSTEPS_E1
case 4 : digitalWrite ( E1_MS1_PIN , ms1 ) ; break ;
# endif
}
if ( ms2 > = 0 ) switch ( driver ) {
case 0 : digitalWrite ( X_MS2_PIN , ms2 ) ; break ;
# if HAS_MICROSTEPS_Y
case 1 : digitalWrite ( Y_MS2_PIN , ms2 ) ; break ;
# endif
# if HAS_MICROSTEPS_Z
case 2 : digitalWrite ( Z_MS2_PIN , ms2 ) ; break ;
# endif
# if HAS_MICROSTEPS_E0
case 3 : digitalWrite ( E0_MS2_PIN , ms2 ) ; break ;
# endif
# if HAS_MICROSTEPS_E1
case 4 : digitalWrite ( E1_MS2_PIN , ms2 ) ; break ;
# endif
}
2012-08-30 02:16:57 -05:00
}
2016-09-25 06:32:58 -05:00
void Stepper : : microstep_mode ( uint8_t driver , uint8_t stepping_mode ) {
switch ( stepping_mode ) {
case 1 : microstep_ms ( driver , MICROSTEP1 ) ; break ;
case 2 : microstep_ms ( driver , MICROSTEP2 ) ; break ;
case 4 : microstep_ms ( driver , MICROSTEP4 ) ; break ;
case 8 : microstep_ms ( driver , MICROSTEP8 ) ; break ;
case 16 : microstep_ms ( driver , MICROSTEP16 ) ; break ;
}
2012-08-30 02:16:57 -05:00
}
2016-09-25 06:32:58 -05:00
void Stepper : : microstep_readings ( ) {
SERIAL_PROTOCOLLNPGM ( " MS1,MS2 Pins " ) ;
SERIAL_PROTOCOLPGM ( " X: " ) ;
SERIAL_PROTOCOL ( READ ( X_MS1_PIN ) ) ;
SERIAL_PROTOCOLLN ( READ ( X_MS2_PIN ) ) ;
# if HAS_MICROSTEPS_Y
SERIAL_PROTOCOLPGM ( " Y: " ) ;
SERIAL_PROTOCOL ( READ ( Y_MS1_PIN ) ) ;
SERIAL_PROTOCOLLN ( READ ( Y_MS2_PIN ) ) ;
# endif
# if HAS_MICROSTEPS_Z
SERIAL_PROTOCOLPGM ( " Z: " ) ;
SERIAL_PROTOCOL ( READ ( Z_MS1_PIN ) ) ;
SERIAL_PROTOCOLLN ( READ ( Z_MS2_PIN ) ) ;
# endif
# if HAS_MICROSTEPS_E0
SERIAL_PROTOCOLPGM ( " E0: " ) ;
SERIAL_PROTOCOL ( READ ( E0_MS1_PIN ) ) ;
SERIAL_PROTOCOLLN ( READ ( E0_MS2_PIN ) ) ;
# endif
# if HAS_MICROSTEPS_E1
SERIAL_PROTOCOLPGM ( " E1: " ) ;
SERIAL_PROTOCOL ( READ ( E1_MS1_PIN ) ) ;
SERIAL_PROTOCOLLN ( READ ( E1_MS2_PIN ) ) ;
# endif
}
# endif // HAS_MICROSTEPS