🏗️ Support for up to 6 linear axes (#19112)
Co-authored-by: Scott Lahteine <github@thinkyhead.com>
This commit is contained in:
DerAndere
committed by
Scott Lahteine
Scott Lahteine
parent
d3c56a76e7
commit
c1fca91103
@ -55,6 +55,15 @@
|
||||
#if AXIS_IS_L64XX(Z4)
|
||||
L64XX_CLASS(Z4) stepperZ4(L6470_CHAIN_SS_PIN);
|
||||
#endif
|
||||
#if AXIS_IS_L64XX(I)
|
||||
L64XX_CLASS(I) stepperI(L6470_CHAIN_SS_PIN);
|
||||
#endif
|
||||
#if AXIS_IS_L64XX(J)
|
||||
L64XX_CLASS(J) stepperJ(L6470_CHAIN_SS_PIN);
|
||||
#endif
|
||||
#if AXIS_IS_L64XX(K)
|
||||
L64XX_CLASS(K) stepperK(L6470_CHAIN_SS_PIN);
|
||||
#endif
|
||||
#if AXIS_IS_L64XX(E0)
|
||||
L64XX_CLASS(E0) stepperE0(L6470_CHAIN_SS_PIN);
|
||||
#endif
|
||||
@ -199,6 +208,15 @@ void L64XX_Marlin::init_to_defaults() {
|
||||
#if AXIS_IS_L64XX(Z4)
|
||||
L6470_INIT_CHIP(Z4);
|
||||
#endif
|
||||
#if AXIS_IS_L64XX(I)
|
||||
L6470_INIT_CHIP(I);
|
||||
#endif
|
||||
#if AXIS_IS_L64XX(J)
|
||||
L6470_INIT_CHIP(J);
|
||||
#endif
|
||||
#if AXIS_IS_L64XX(K)
|
||||
L6470_INIT_CHIP(K);
|
||||
#endif
|
||||
#if AXIS_IS_L64XX(E0)
|
||||
L6470_INIT_CHIP(E0);
|
||||
#endif
|
||||
|
||||
@ -206,6 +206,66 @@
|
||||
#define DISABLE_STEPPER_Z4() stepperZ4.free()
|
||||
#endif
|
||||
|
||||
// I Stepper
|
||||
#if AXIS_IS_L64XX(I)
|
||||
extern L64XX_CLASS(I) stepperI;
|
||||
#define I_ENABLE_INIT() NOOP
|
||||
#define I_ENABLE_WRITE(STATE) (STATE ? stepperI.hardStop() : stepperI.free())
|
||||
#define I_ENABLE_READ() (stepperI.getStatus() & STATUS_HIZ)
|
||||
#if AXIS_DRIVER_TYPE_I(L6474)
|
||||
#define I_DIR_INIT() SET_OUTPUT(I_DIR_PIN)
|
||||
#define I_DIR_WRITE(STATE) L6474_DIR_WRITE(I, STATE)
|
||||
#define I_DIR_READ() READ(I_DIR_PIN)
|
||||
#else
|
||||
#define I_DIR_INIT() NOOP
|
||||
#define I_DIR_WRITE(STATE) L64XX_DIR_WRITE(I, STATE)
|
||||
#define I_DIR_READ() (stepper##I.getStatus() & STATUS_DIR);
|
||||
#if AXIS_DRIVER_TYPE_I(L6470)
|
||||
#define DISABLE_STEPPER_I() stepperI.free()
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// J Stepper
|
||||
#if AXIS_IS_L64XX(J)
|
||||
extern L64XX_CLASS(J) stepperJ;
|
||||
#define J_ENABLE_INIT() NOOP
|
||||
#define J_ENABLE_WRITE(STATE) (STATE ? stepperJ.hardStop() : stepperJ.free())
|
||||
#define J_ENABLE_READ() (stepperJ.getStatus() & STATUS_HIZ)
|
||||
#if AXIS_DRIVER_TYPE_J(L6474)
|
||||
#define J_DIR_INIT() SET_OUTPUT(J_DIR_PIN)
|
||||
#define J_DIR_WRITE(STATE) L6474_DIR_WRITE(J, STATE)
|
||||
#define J_DIR_READ() READ(J_DIR_PIN)
|
||||
#else
|
||||
#define J_DIR_INIT() NOOP
|
||||
#define J_DIR_WRITE(STATE) L64XX_DIR_WRITE(J, STATE)
|
||||
#define J_DIR_READ() (stepper##J.getStatus() & STATUS_DIR);
|
||||
#if AXIS_DRIVER_TYPE_J(L6470)
|
||||
#define DISABLE_STEPPER_J() stepperJ.free()
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// K Stepper
|
||||
#if AXIS_IS_L64XX(K)
|
||||
extern L64XX_CLASS(K) stepperK;
|
||||
#define K_ENABLE_INIT() NOOP
|
||||
#define K_ENABLE_WRITE(STATE) (STATE ? stepperK.hardStop() : stepperK.free())
|
||||
#define K_ENABLE_READ() (stepperK.getStatus() & STATUS_HIZ)
|
||||
#if AXIS_DRIVER_TYPE_K(L6474)
|
||||
#define K_DIR_INIT() SET_OUTPUT(K_DIR_PIN)
|
||||
#define K_DIR_WRITE(STATE) L6474_DIR_WRITE(K, STATE)
|
||||
#define K_DIR_READ() READ(K_DIR_PIN)
|
||||
#else
|
||||
#define K_DIR_INIT() NOOP
|
||||
#define K_DIR_WRITE(STATE) L64XX_DIR_WRITE(K, STATE)
|
||||
#define K_DIR_READ() (stepper##K.getStatus() & STATUS_DIR);
|
||||
#if AXIS_DRIVER_TYPE_K(L6470)
|
||||
#define DISABLE_STEPPER_K() stepperK.free()
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// E0 Stepper
|
||||
#if AXIS_IS_L64XX(E0)
|
||||
extern L64XX_CLASS(E0) stepperE0;
|
||||
|
||||
@ -60,6 +60,15 @@
|
||||
#if AXIS_DRIVER_TYPE_Z4(TMC26X)
|
||||
_TMC26X_DEFINE(Z4);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_I(TMC26X)
|
||||
_TMC26X_DEFINE(I);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_J(TMC26X)
|
||||
_TMC26X_DEFINE(J);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_K(TMC26X)
|
||||
_TMC26X_DEFINE(K);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_E0(TMC26X)
|
||||
_TMC26X_DEFINE(E0);
|
||||
#endif
|
||||
@ -115,6 +124,15 @@ void tmc26x_init_to_defaults() {
|
||||
#if AXIS_DRIVER_TYPE_Z4(TMC26X)
|
||||
_TMC26X_INIT(Z4);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_I(TMC26X)
|
||||
_TMC26X_INIT(I);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_J(TMC26X)
|
||||
_TMC26X_INIT(J);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_K(TMC26X)
|
||||
_TMC26X_INIT(K);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_E0(TMC26X)
|
||||
_TMC26X_INIT(E0);
|
||||
#endif
|
||||
|
||||
@ -99,6 +99,30 @@ void tmc26x_init_to_defaults();
|
||||
#define Z4_ENABLE_READ() stepperZ4.isEnabled()
|
||||
#endif
|
||||
|
||||
// I Stepper
|
||||
#if HAS_I_ENABLE && AXIS_DRIVER_TYPE_I(TMC26X)
|
||||
extern TMC26XStepper stepperI;
|
||||
#define I_ENABLE_INIT() NOOP
|
||||
#define I_ENABLE_WRITE(STATE) stepperI.setEnabled(STATE)
|
||||
#define I_ENABLE_READ() stepperI.isEnabled()
|
||||
#endif
|
||||
|
||||
// J Stepper
|
||||
#if HAS_J_ENABLE && AXIS_DRIVER_TYPE_J(TMC26X)
|
||||
extern TMC26XStepper stepperJ;
|
||||
#define J_ENABLE_INIT() NOOP
|
||||
#define J_ENABLE_WRITE(STATE) stepperJ.setEnabled(STATE)
|
||||
#define J_ENABLE_READ() stepperJ.isEnabled()
|
||||
#endif
|
||||
|
||||
// K Stepper
|
||||
#if HAS_K_ENABLE && AXIS_DRIVER_TYPE_K(TMC26X)
|
||||
extern TMC26XStepper stepperK;
|
||||
#define K_ENABLE_INIT() NOOP
|
||||
#define K_ENABLE_WRITE(STATE) stepperK.setEnabled(STATE)
|
||||
#define K_ENABLE_READ() stepperK.isEnabled()
|
||||
#endif
|
||||
|
||||
// E0 Stepper
|
||||
#if AXIS_DRIVER_TYPE_E0(TMC26X)
|
||||
extern TMC26XStepper stepperE0;
|
||||
|
||||
@ -37,9 +37,7 @@ void restore_stepper_drivers() {
|
||||
}
|
||||
|
||||
void reset_stepper_drivers() {
|
||||
#if HAS_DRIVER(TMC26X)
|
||||
tmc26x_init_to_defaults();
|
||||
#endif
|
||||
TERN_(HAS_TMC26X, tmc26x_init_to_defaults());
|
||||
TERN_(HAS_L64XX, L64xxManager.init_to_defaults());
|
||||
TERN_(HAS_TRINAMIC_CONFIG, reset_trinamic_drivers());
|
||||
}
|
||||
|
||||
@ -36,7 +36,7 @@
|
||||
#include "L64xx.h"
|
||||
#endif
|
||||
|
||||
#if HAS_DRIVER(TMC26X)
|
||||
#if HAS_TMC26X
|
||||
#include "TMC26X.h"
|
||||
#endif
|
||||
|
||||
@ -65,38 +65,42 @@ void reset_stepper_drivers(); // Called by settings.load / settings.reset
|
||||
#define X_STEP_READ() bool(READ(X_STEP_PIN))
|
||||
|
||||
// Y Stepper
|
||||
#ifndef Y_ENABLE_INIT
|
||||
#define Y_ENABLE_INIT() SET_OUTPUT(Y_ENABLE_PIN)
|
||||
#define Y_ENABLE_WRITE(STATE) WRITE(Y_ENABLE_PIN,STATE)
|
||||
#define Y_ENABLE_READ() bool(READ(Y_ENABLE_PIN))
|
||||
#if HAS_Y_AXIS
|
||||
#ifndef Y_ENABLE_INIT
|
||||
#define Y_ENABLE_INIT() SET_OUTPUT(Y_ENABLE_PIN)
|
||||
#define Y_ENABLE_WRITE(STATE) WRITE(Y_ENABLE_PIN,STATE)
|
||||
#define Y_ENABLE_READ() bool(READ(Y_ENABLE_PIN))
|
||||
#endif
|
||||
#ifndef Y_DIR_INIT
|
||||
#define Y_DIR_INIT() SET_OUTPUT(Y_DIR_PIN)
|
||||
#define Y_DIR_WRITE(STATE) WRITE(Y_DIR_PIN,STATE)
|
||||
#define Y_DIR_READ() bool(READ(Y_DIR_PIN))
|
||||
#endif
|
||||
#define Y_STEP_INIT() SET_OUTPUT(Y_STEP_PIN)
|
||||
#ifndef Y_STEP_WRITE
|
||||
#define Y_STEP_WRITE(STATE) WRITE(Y_STEP_PIN,STATE)
|
||||
#endif
|
||||
#define Y_STEP_READ() bool(READ(Y_STEP_PIN))
|
||||
#endif
|
||||
#ifndef Y_DIR_INIT
|
||||
#define Y_DIR_INIT() SET_OUTPUT(Y_DIR_PIN)
|
||||
#define Y_DIR_WRITE(STATE) WRITE(Y_DIR_PIN,STATE)
|
||||
#define Y_DIR_READ() bool(READ(Y_DIR_PIN))
|
||||
#endif
|
||||
#define Y_STEP_INIT() SET_OUTPUT(Y_STEP_PIN)
|
||||
#ifndef Y_STEP_WRITE
|
||||
#define Y_STEP_WRITE(STATE) WRITE(Y_STEP_PIN,STATE)
|
||||
#endif
|
||||
#define Y_STEP_READ() bool(READ(Y_STEP_PIN))
|
||||
|
||||
// Z Stepper
|
||||
#ifndef Z_ENABLE_INIT
|
||||
#define Z_ENABLE_INIT() SET_OUTPUT(Z_ENABLE_PIN)
|
||||
#define Z_ENABLE_WRITE(STATE) WRITE(Z_ENABLE_PIN,STATE)
|
||||
#define Z_ENABLE_READ() bool(READ(Z_ENABLE_PIN))
|
||||
#if HAS_Z_AXIS
|
||||
#ifndef Z_ENABLE_INIT
|
||||
#define Z_ENABLE_INIT() SET_OUTPUT(Z_ENABLE_PIN)
|
||||
#define Z_ENABLE_WRITE(STATE) WRITE(Z_ENABLE_PIN,STATE)
|
||||
#define Z_ENABLE_READ() bool(READ(Z_ENABLE_PIN))
|
||||
#endif
|
||||
#ifndef Z_DIR_INIT
|
||||
#define Z_DIR_INIT() SET_OUTPUT(Z_DIR_PIN)
|
||||
#define Z_DIR_WRITE(STATE) WRITE(Z_DIR_PIN,STATE)
|
||||
#define Z_DIR_READ() bool(READ(Z_DIR_PIN))
|
||||
#endif
|
||||
#define Z_STEP_INIT() SET_OUTPUT(Z_STEP_PIN)
|
||||
#ifndef Z_STEP_WRITE
|
||||
#define Z_STEP_WRITE(STATE) WRITE(Z_STEP_PIN,STATE)
|
||||
#endif
|
||||
#define Z_STEP_READ() bool(READ(Z_STEP_PIN))
|
||||
#endif
|
||||
#ifndef Z_DIR_INIT
|
||||
#define Z_DIR_INIT() SET_OUTPUT(Z_DIR_PIN)
|
||||
#define Z_DIR_WRITE(STATE) WRITE(Z_DIR_PIN,STATE)
|
||||
#define Z_DIR_READ() bool(READ(Z_DIR_PIN))
|
||||
#endif
|
||||
#define Z_STEP_INIT() SET_OUTPUT(Z_STEP_PIN)
|
||||
#ifndef Z_STEP_WRITE
|
||||
#define Z_STEP_WRITE(STATE) WRITE(Z_STEP_PIN,STATE)
|
||||
#endif
|
||||
#define Z_STEP_READ() bool(READ(Z_STEP_PIN))
|
||||
|
||||
// X2 Stepper
|
||||
#if HAS_X2_ENABLE
|
||||
@ -201,6 +205,63 @@ void reset_stepper_drivers(); // Called by settings.load / settings.reset
|
||||
#define Z4_DIR_WRITE(STATE) NOOP
|
||||
#endif
|
||||
|
||||
// I Stepper
|
||||
#if LINEAR_AXES >= 4
|
||||
#ifndef I_ENABLE_INIT
|
||||
#define I_ENABLE_INIT() SET_OUTPUT(I_ENABLE_PIN)
|
||||
#define I_ENABLE_WRITE(STATE) WRITE(I_ENABLE_PIN,STATE)
|
||||
#define I_ENABLE_READ() bool(READ(I_ENABLE_PIN))
|
||||
#endif
|
||||
#ifndef I_DIR_INIT
|
||||
#define I_DIR_INIT() SET_OUTPUT(I_DIR_PIN)
|
||||
#define I_DIR_WRITE(STATE) WRITE(I_DIR_PIN,STATE)
|
||||
#define I_DIR_READ() bool(READ(I_DIR_PIN))
|
||||
#endif
|
||||
#define I_STEP_INIT() SET_OUTPUT(I_STEP_PIN)
|
||||
#ifndef I_STEP_WRITE
|
||||
#define I_STEP_WRITE(STATE) WRITE(I_STEP_PIN,STATE)
|
||||
#endif
|
||||
#define I_STEP_READ() bool(READ(I_STEP_PIN))
|
||||
#endif
|
||||
|
||||
// J Stepper
|
||||
#if LINEAR_AXES >= 5
|
||||
#ifndef J_ENABLE_INIT
|
||||
#define J_ENABLE_INIT() SET_OUTPUT(J_ENABLE_PIN)
|
||||
#define J_ENABLE_WRITE(STATE) WRITE(J_ENABLE_PIN,STATE)
|
||||
#define J_ENABLE_READ() bool(READ(J_ENABLE_PIN))
|
||||
#endif
|
||||
#ifndef J_DIR_INIT
|
||||
#define J_DIR_INIT() SET_OUTPUT(J_DIR_PIN)
|
||||
#define J_DIR_WRITE(STATE) WRITE(J_DIR_PIN,STATE)
|
||||
#define J_DIR_READ() bool(READ(J_DIR_PIN))
|
||||
#endif
|
||||
#define J_STEP_INIT() SET_OUTPUT(J_STEP_PIN)
|
||||
#ifndef J_STEP_WRITE
|
||||
#define J_STEP_WRITE(STATE) WRITE(J_STEP_PIN,STATE)
|
||||
#endif
|
||||
#define J_STEP_READ() bool(READ(J_STEP_PIN))
|
||||
#endif
|
||||
|
||||
// K Stepper
|
||||
#if LINEAR_AXES >= 6
|
||||
#ifndef K_ENABLE_INIT
|
||||
#define K_ENABLE_INIT() SET_OUTPUT(K_ENABLE_PIN)
|
||||
#define K_ENABLE_WRITE(STATE) WRITE(K_ENABLE_PIN,STATE)
|
||||
#define K_ENABLE_READ() bool(READ(K_ENABLE_PIN))
|
||||
#endif
|
||||
#ifndef K_DIR_INIT
|
||||
#define K_DIR_INIT() SET_OUTPUT(K_DIR_PIN)
|
||||
#define K_DIR_WRITE(STATE) WRITE(K_DIR_PIN,STATE)
|
||||
#define K_DIR_READ() bool(READ(K_DIR_PIN))
|
||||
#endif
|
||||
#define K_STEP_INIT() SET_OUTPUT(K_STEP_PIN)
|
||||
#ifndef K_STEP_WRITE
|
||||
#define K_STEP_WRITE(STATE) WRITE(K_STEP_PIN,STATE)
|
||||
#endif
|
||||
#define K_STEP_READ() bool(READ(K_STEP_PIN))
|
||||
#endif
|
||||
|
||||
// E0 Stepper
|
||||
#ifndef E0_ENABLE_INIT
|
||||
#define E0_ENABLE_INIT() SET_OUTPUT(E0_ENABLE_PIN)
|
||||
@ -720,6 +781,51 @@ void reset_stepper_drivers(); // Called by settings.load / settings.reset
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef ENABLE_STEPPER_I
|
||||
#if HAS_I_ENABLE
|
||||
#define ENABLE_STEPPER_I() I_ENABLE_WRITE( I_ENABLE_ON)
|
||||
#else
|
||||
#define ENABLE_STEPPER_I() NOOP
|
||||
#endif
|
||||
#endif
|
||||
#ifndef DISABLE_STEPPER_I
|
||||
#if HAS_I_ENABLE
|
||||
#define DISABLE_STEPPER_I() I_ENABLE_WRITE(!I_ENABLE_ON)
|
||||
#else
|
||||
#define DISABLE_STEPPER_I() NOOP
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef ENABLE_STEPPER_J
|
||||
#if HAS_J_ENABLE
|
||||
#define ENABLE_STEPPER_J() J_ENABLE_WRITE( J_ENABLE_ON)
|
||||
#else
|
||||
#define ENABLE_STEPPER_J() NOOP
|
||||
#endif
|
||||
#endif
|
||||
#ifndef DISABLE_STEPPER_J
|
||||
#if HAS_J_ENABLE
|
||||
#define DISABLE_STEPPER_J() J_ENABLE_WRITE(!J_ENABLE_ON)
|
||||
#else
|
||||
#define DISABLE_STEPPER_J() NOOP
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef ENABLE_STEPPER_K
|
||||
#if HAS_K_ENABLE
|
||||
#define ENABLE_STEPPER_K() K_ENABLE_WRITE( K_ENABLE_ON)
|
||||
#else
|
||||
#define ENABLE_STEPPER_K() NOOP
|
||||
#endif
|
||||
#endif
|
||||
#ifndef DISABLE_STEPPER_K
|
||||
#if HAS_K_ENABLE
|
||||
#define DISABLE_STEPPER_K() K_ENABLE_WRITE(!K_ENABLE_ON)
|
||||
#else
|
||||
#define DISABLE_STEPPER_K() NOOP
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef ENABLE_STEPPER_E0
|
||||
#if HAS_E0_ENABLE
|
||||
#define ENABLE_STEPPER_E0() E0_ENABLE_WRITE( E_ENABLE_ON)
|
||||
@ -857,10 +963,22 @@ void reset_stepper_drivers(); // Called by settings.load / settings.reset
|
||||
|
||||
#define ENABLE_AXIS_X() if (SHOULD_ENABLE(x)) { ENABLE_STEPPER_X(); ENABLE_STEPPER_X2(); AFTER_CHANGE(x, true); }
|
||||
#define DISABLE_AXIS_X() if (SHOULD_DISABLE(x)) { DISABLE_STEPPER_X(); DISABLE_STEPPER_X2(); AFTER_CHANGE(x, false); set_axis_untrusted(X_AXIS); }
|
||||
#define ENABLE_AXIS_Y() if (SHOULD_ENABLE(y)) { ENABLE_STEPPER_Y(); ENABLE_STEPPER_Y2(); AFTER_CHANGE(y, true); }
|
||||
#define DISABLE_AXIS_Y() if (SHOULD_DISABLE(y)) { DISABLE_STEPPER_Y(); DISABLE_STEPPER_Y2(); AFTER_CHANGE(y, false); set_axis_untrusted(Y_AXIS); }
|
||||
#define ENABLE_AXIS_Z() if (SHOULD_ENABLE(z)) { ENABLE_STEPPER_Z(); ENABLE_STEPPER_Z2(); ENABLE_STEPPER_Z3(); ENABLE_STEPPER_Z4(); AFTER_CHANGE(z, true); }
|
||||
#define DISABLE_AXIS_Z() if (SHOULD_DISABLE(z)) { DISABLE_STEPPER_Z(); DISABLE_STEPPER_Z2(); DISABLE_STEPPER_Z3(); DISABLE_STEPPER_Z4(); AFTER_CHANGE(z, false); set_axis_untrusted(Z_AXIS); Z_RESET(); }
|
||||
|
||||
#if HAS_Y_AXIS
|
||||
#define ENABLE_AXIS_Y() if (SHOULD_ENABLE(y)) { ENABLE_STEPPER_Y(); ENABLE_STEPPER_Y2(); AFTER_CHANGE(y, true); }
|
||||
#define DISABLE_AXIS_Y() if (SHOULD_DISABLE(y)) { DISABLE_STEPPER_Y(); DISABLE_STEPPER_Y2(); AFTER_CHANGE(y, false); set_axis_untrusted(Y_AXIS); }
|
||||
#else
|
||||
#define ENABLE_AXIS_Y() NOOP
|
||||
#define DISABLE_AXIS_Y() NOOP
|
||||
#endif
|
||||
|
||||
#if HAS_Z_AXIS
|
||||
#define ENABLE_AXIS_Z() if (SHOULD_ENABLE(z)) { ENABLE_STEPPER_Z(); ENABLE_STEPPER_Z2(); ENABLE_STEPPER_Z3(); ENABLE_STEPPER_Z4(); AFTER_CHANGE(z, true); }
|
||||
#define DISABLE_AXIS_Z() if (SHOULD_DISABLE(z)) { DISABLE_STEPPER_Z(); DISABLE_STEPPER_Z2(); DISABLE_STEPPER_Z3(); DISABLE_STEPPER_Z4(); AFTER_CHANGE(z, false); set_axis_untrusted(Z_AXIS); Z_RESET(); }
|
||||
#else
|
||||
#define ENABLE_AXIS_Z() NOOP
|
||||
#define DISABLE_AXIS_Z() NOOP
|
||||
#endif
|
||||
|
||||
#ifdef Z_IDLE_HEIGHT
|
||||
#define Z_RESET() do{ current_position.z = Z_IDLE_HEIGHT; sync_plan_position(); }while(0)
|
||||
@ -868,6 +986,28 @@ void reset_stepper_drivers(); // Called by settings.load / settings.reset
|
||||
#define Z_RESET()
|
||||
#endif
|
||||
|
||||
#if LINEAR_AXES >= 4
|
||||
#define ENABLE_AXIS_I() if (SHOULD_ENABLE(i)) { ENABLE_STEPPER_I(); AFTER_CHANGE(i, true); }
|
||||
#define DISABLE_AXIS_I() if (SHOULD_DISABLE(i)) { DISABLE_STEPPER_I(); AFTER_CHANGE(i, false); set_axis_untrusted(I_AXIS); }
|
||||
#else
|
||||
#define ENABLE_AXIS_I() NOOP
|
||||
#define DISABLE_AXIS_I() NOOP
|
||||
#endif
|
||||
#if LINEAR_AXES >= 5
|
||||
#define ENABLE_AXIS_J() if (SHOULD_ENABLE(j)) { ENABLE_STEPPER_J(); AFTER_CHANGE(j, true); }
|
||||
#define DISABLE_AXIS_J() if (SHOULD_DISABLE(j)) { DISABLE_STEPPER_J(); AFTER_CHANGE(j, false); set_axis_untrusted(J_AXIS); }
|
||||
#else
|
||||
#define ENABLE_AXIS_J() NOOP
|
||||
#define DISABLE_AXIS_J() NOOP
|
||||
#endif
|
||||
#if LINEAR_AXES >= 6
|
||||
#define ENABLE_AXIS_K() if (SHOULD_ENABLE(k)) { ENABLE_STEPPER_K(); AFTER_CHANGE(k, true); }
|
||||
#define DISABLE_AXIS_K() if (SHOULD_DISABLE(k)) { DISABLE_STEPPER_K(); AFTER_CHANGE(k, false); set_axis_untrusted(K_AXIS); }
|
||||
#else
|
||||
#define ENABLE_AXIS_K() NOOP
|
||||
#define DISABLE_AXIS_K() NOOP
|
||||
#endif
|
||||
|
||||
//
|
||||
// Extruder steppers enable / disable macros
|
||||
//
|
||||
|
||||
@ -36,7 +36,7 @@
|
||||
#include <SPI.h>
|
||||
|
||||
enum StealthIndex : uint8_t {
|
||||
LOGICAL_AXIS_LIST(STEALTH_AXIS_E, STEALTH_AXIS_X, STEALTH_AXIS_Y, STEALTH_AXIS_Z)
|
||||
LOGICAL_AXIS_LIST(STEALTH_AXIS_E, STEALTH_AXIS_X, STEALTH_AXIS_Y, STEALTH_AXIS_Z, STEALTH_AXIS_I, STEALTH_AXIS_J, STEALTH_AXIS_K)
|
||||
};
|
||||
#define TMC_INIT(ST, STEALTH_INDEX) tmc_init(stepper##ST, ST##_CURRENT, ST##_MICROSTEPS, ST##_HYBRID_THRESHOLD, stealthchop_by_axis[STEALTH_INDEX], chopper_timing_##ST, ST##_INTERPOLATE)
|
||||
|
||||
@ -97,6 +97,15 @@ enum StealthIndex : uint8_t {
|
||||
#if AXIS_HAS_SPI(Z4)
|
||||
TMC_SPI_DEFINE(Z4, Z);
|
||||
#endif
|
||||
#if AXIS_HAS_SPI(I)
|
||||
TMC_SPI_DEFINE(I, I);
|
||||
#endif
|
||||
#if AXIS_HAS_SPI(J)
|
||||
TMC_SPI_DEFINE(J, J);
|
||||
#endif
|
||||
#if AXIS_HAS_SPI(K)
|
||||
TMC_SPI_DEFINE(K, K);
|
||||
#endif
|
||||
#if AXIS_HAS_SPI(E0)
|
||||
TMC_SPI_DEFINE_E(0);
|
||||
#endif
|
||||
@ -329,6 +338,34 @@ enum StealthIndex : uint8_t {
|
||||
#define Z4_HAS_SW_SERIAL 1
|
||||
#endif
|
||||
#endif
|
||||
#if AXIS_HAS_UART(I)
|
||||
#ifdef I_HARDWARE_SERIAL
|
||||
TMC_UART_DEFINE(HW, I, I);
|
||||
#define I_HAS_HW_SERIAL 1
|
||||
#else
|
||||
TMC_UART_DEFINE(SW, I, I);
|
||||
#define I_HAS_SW_SERIAL 1
|
||||
#endif
|
||||
#endif
|
||||
#if AXIS_HAS_UART(J)
|
||||
#ifdef J_HARDWARE_SERIAL
|
||||
TMC_UART_DEFINE(HW, J, J);
|
||||
#define J_HAS_HW_SERIAL 1
|
||||
#else
|
||||
TMC_UART_DEFINE(SW, J, J);
|
||||
#define J_HAS_SW_SERIAL 1
|
||||
#endif
|
||||
#endif
|
||||
#if AXIS_HAS_UART(K)
|
||||
#ifdef K_HARDWARE_SERIAL
|
||||
TMC_UART_DEFINE(HW, K, K);
|
||||
#define K_HAS_HW_SERIAL 1
|
||||
#else
|
||||
TMC_UART_DEFINE(SW, K, K);
|
||||
#define K_HAS_SW_SERIAL 1
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if AXIS_HAS_UART(E0)
|
||||
#ifdef E0_HARDWARE_SERIAL
|
||||
TMC_UART_DEFINE_E(HW, 0);
|
||||
@ -402,7 +439,9 @@ enum StealthIndex : uint8_t {
|
||||
#endif
|
||||
#endif
|
||||
|
||||
enum TMCAxis : uint8_t { LINEAR_AXIS_LIST(X, Y, Z), X2, Y2, Z2, Z3, Z4, E0, E1, E2, E3, E4, E5, E6, E7, TOTAL };
|
||||
#define _EN_ITEM(N) , E##N
|
||||
enum TMCAxis : uint8_t { LINEAR_AXIS_LIST(X, Y, Z, I, J, K), X2, Y2, Z2, Z3, Z4 REPEAT(EXTRUDERS, _EN_ITEM), TOTAL };
|
||||
#undef _EN_ITEM
|
||||
|
||||
void tmc_serial_begin() {
|
||||
#if HAS_TMC_HW_SERIAL
|
||||
@ -474,6 +513,27 @@ enum StealthIndex : uint8_t {
|
||||
stepperZ4.beginSerial(TMC_BAUD_RATE);
|
||||
#endif
|
||||
#endif
|
||||
#if AXIS_HAS_UART(I)
|
||||
#ifdef I_HARDWARE_SERIAL
|
||||
HW_SERIAL_BEGIN(I);
|
||||
#else
|
||||
stepperI.beginSerial(TMC_BAUD_RATE);
|
||||
#endif
|
||||
#endif
|
||||
#if AXIS_HAS_UART(J)
|
||||
#ifdef J_HARDWARE_SERIAL
|
||||
HW_SERIAL_BEGIN(J);
|
||||
#else
|
||||
stepperJ.beginSerial(TMC_BAUD_RATE);
|
||||
#endif
|
||||
#endif
|
||||
#if AXIS_HAS_UART(K)
|
||||
#ifdef K_HARDWARE_SERIAL
|
||||
HW_SERIAL_BEGIN(K);
|
||||
#else
|
||||
stepperK.beginSerial(TMC_BAUD_RATE);
|
||||
#endif
|
||||
#endif
|
||||
#if AXIS_HAS_UART(E0)
|
||||
#ifdef E0_HARDWARE_SERIAL
|
||||
HW_SERIAL_BEGIN(E0);
|
||||
@ -740,6 +800,15 @@ void restore_trinamic_drivers() {
|
||||
#if AXIS_IS_TMC(Z4)
|
||||
stepperZ4.push();
|
||||
#endif
|
||||
#if AXIS_IS_TMC(I)
|
||||
stepperI.push();
|
||||
#endif
|
||||
#if AXIS_IS_TMC(J)
|
||||
stepperJ.push();
|
||||
#endif
|
||||
#if AXIS_IS_TMC(K)
|
||||
stepperK.push();
|
||||
#endif
|
||||
#if AXIS_IS_TMC(E0)
|
||||
stepperE0.push();
|
||||
#endif
|
||||
@ -771,7 +840,10 @@ void reset_trinamic_drivers() {
|
||||
ENABLED(STEALTHCHOP_E),
|
||||
ENABLED(STEALTHCHOP_XY),
|
||||
ENABLED(STEALTHCHOP_XY),
|
||||
ENABLED(STEALTHCHOP_Z)
|
||||
ENABLED(STEALTHCHOP_Z),
|
||||
ENABLED(STEALTHCHOP_I),
|
||||
ENABLED(STEALTHCHOP_J),
|
||||
ENABLED(STEALTHCHOP_K)
|
||||
);
|
||||
|
||||
#if AXIS_IS_TMC(X)
|
||||
@ -798,6 +870,15 @@ void reset_trinamic_drivers() {
|
||||
#if AXIS_IS_TMC(Z4)
|
||||
TMC_INIT(Z4, STEALTH_AXIS_Z);
|
||||
#endif
|
||||
#if AXIS_IS_TMC(I)
|
||||
TMC_INIT(I, STEALTH_AXIS_I);
|
||||
#endif
|
||||
#if AXIS_IS_TMC(J)
|
||||
TMC_INIT(J, STEALTH_AXIS_J);
|
||||
#endif
|
||||
#if AXIS_IS_TMC(K)
|
||||
TMC_INIT(K, STEALTH_AXIS_K);
|
||||
#endif
|
||||
#if AXIS_IS_TMC(E0)
|
||||
TMC_INIT(E0, STEALTH_AXIS_E);
|
||||
#endif
|
||||
@ -848,6 +929,24 @@ void reset_trinamic_drivers() {
|
||||
stepperZ4.homing_threshold(CAT(TERN(Z4_SENSORLESS, Z4, Z), _STALL_SENSITIVITY));
|
||||
#endif
|
||||
#endif
|
||||
#if I_SENSORLESS
|
||||
stepperI.homing_threshold(I_STALL_SENSITIVITY);
|
||||
#if AXIS_HAS_STALLGUARD(I)
|
||||
stepperI.homing_threshold(CAT(TERN(I_SENSORLESS, I, I), _STALL_SENSITIVITY));
|
||||
#endif
|
||||
#endif
|
||||
#if J_SENSORLESS
|
||||
stepperJ.homing_threshold(J_STALL_SENSITIVITY);
|
||||
#if AXIS_HAS_STALLGUARD(J)
|
||||
stepperJ.homing_threshold(CAT(TERN(J_SENSORLESS, J, J), _STALL_SENSITIVITY));
|
||||
#endif
|
||||
#endif
|
||||
#if K_SENSORLESS
|
||||
stepperK.homing_threshold(K_STALL_SENSITIVITY);
|
||||
#if AXIS_HAS_STALLGUARD(K)
|
||||
stepperK.homing_threshold(CAT(TERN(K_SENSORLESS, K, K), _STALL_SENSITIVITY));
|
||||
#endif
|
||||
#endif
|
||||
#endif // USE SENSORLESS
|
||||
|
||||
#ifdef TMC_ADV
|
||||
|
||||
@ -46,6 +46,10 @@
|
||||
#define TMC_Y_LABEL 'Y', '0'
|
||||
#define TMC_Z_LABEL 'Z', '0'
|
||||
|
||||
#define TMC_I_LABEL 'I', '0'
|
||||
#define TMC_J_LABEL 'J', '0'
|
||||
#define TMC_K_LABEL 'K', '0'
|
||||
|
||||
#define TMC_X2_LABEL 'X', '2'
|
||||
#define TMC_Y2_LABEL 'Y', '2'
|
||||
#define TMC_Z2_LABEL 'Z', '2'
|
||||
@ -79,13 +83,22 @@ typedef struct {
|
||||
#ifndef CHOPPER_TIMING_X
|
||||
#define CHOPPER_TIMING_X CHOPPER_TIMING
|
||||
#endif
|
||||
#ifndef CHOPPER_TIMING_Y
|
||||
#if HAS_Y_AXIS && !defined(CHOPPER_TIMING_Y)
|
||||
#define CHOPPER_TIMING_Y CHOPPER_TIMING
|
||||
#endif
|
||||
#ifndef CHOPPER_TIMING_Z
|
||||
#if HAS_Z_AXIS && !defined(CHOPPER_TIMING_Z)
|
||||
#define CHOPPER_TIMING_Z CHOPPER_TIMING
|
||||
#endif
|
||||
#ifndef CHOPPER_TIMING_E
|
||||
#if LINEAR_AXES >= 4 && !defined(CHOPPER_TIMING_I)
|
||||
#define CHOPPER_TIMING_I CHOPPER_TIMING
|
||||
#endif
|
||||
#if LINEAR_AXES >= 5 && !defined(CHOPPER_TIMING_J)
|
||||
#define CHOPPER_TIMING_J CHOPPER_TIMING
|
||||
#endif
|
||||
#if LINEAR_AXES >= 6 && !defined(CHOPPER_TIMING_K)
|
||||
#define CHOPPER_TIMING_K CHOPPER_TIMING
|
||||
#endif
|
||||
#if HAS_EXTRUDERS && !defined(CHOPPER_TIMING_E)
|
||||
#define CHOPPER_TIMING_E CHOPPER_TIMING
|
||||
#endif
|
||||
|
||||
@ -225,6 +238,48 @@ void reset_trinamic_drivers();
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// I Stepper
|
||||
#if AXIS_IS_TMC(I)
|
||||
extern TMC_CLASS(I, I) stepperI;
|
||||
static constexpr chopper_timing_t chopper_timing_I = CHOPPER_TIMING_I;
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
#define I_ENABLE_INIT() NOOP
|
||||
#define I_ENABLE_WRITE(STATE) stepperI.toff((STATE)==I_ENABLE_ON ? chopper_timing.toff : 0)
|
||||
#define I_ENABLE_READ() stepperI.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_SQUARE_WAVE(I)
|
||||
#define I_STEP_WRITE(STATE) do{ if (STATE) TOGGLE(I_STEP_PIN); }while(0)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// J Stepper
|
||||
#if AXIS_IS_TMC(J)
|
||||
extern TMC_CLASS(J, J) stepperJ;
|
||||
static constexpr chopper_timing_t chopper_timing_J = CHOPPER_TIMING_J;
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
#define J_ENABLE_INIT() NOOP
|
||||
#define J_ENABLE_WRITE(STATE) stepperJ.toff((STATE)==J_ENABLE_ON ? chopper_timing.toff : 0)
|
||||
#define J_ENABLE_READ() stepperJ.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_SQUARE_WAVE(J)
|
||||
#define J_STEP_WRITE(STATE) do{ if (STATE) TOGGLE(J_STEP_PIN); }while(0)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// K Stepper
|
||||
#if AXIS_IS_TMC(K)
|
||||
extern TMC_CLASS(K, K) stepperK;
|
||||
static constexpr chopper_timing_t chopper_timing_K = CHOPPER_TIMING_K;
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
#define K_ENABLE_INIT() NOOP
|
||||
#define K_ENABLE_WRITE(STATE) stepperK.toff((STATE)==K_ENABLE_ON ? chopper_timing.toff : 0)
|
||||
#define K_ENABLE_READ() stepperK.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_SQUARE_WAVE(K)
|
||||
#define K_STEP_WRITE(STATE) do{ if (STATE) TOGGLE(K_STEP_PIN); }while(0)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// E0 Stepper
|
||||
#if AXIS_IS_TMC(E0)
|
||||
extern TMC_CLASS_E(0) stepperE0;
|
||||
|
||||
Reference in New Issue
Block a user