Scott Lahteine
@ -64,6 +64,15 @@
|
||||
#if AXIS_IS_L64XX(K)
|
||||
L64XX_CLASS(K) stepperK(L6470_CHAIN_SS_PIN);
|
||||
#endif
|
||||
#if AXIS_IS_L64XX(U)
|
||||
L64XX_CLASS(u) stepperU(L6470_CHAIN_SS_PIN);
|
||||
#endif
|
||||
#if AXIS_IS_L64XX(V)
|
||||
L64XX_CLASS(v) stepperV(L6470_CHAIN_SS_PIN);
|
||||
#endif
|
||||
#if AXIS_IS_L64XX(W)
|
||||
L64XX_CLASS(w) stepperW(L6470_CHAIN_SS_PIN);
|
||||
#endif
|
||||
#if AXIS_IS_L64XX(E0)
|
||||
L64XX_CLASS(E0) stepperE0(L6470_CHAIN_SS_PIN);
|
||||
#endif
|
||||
@ -217,6 +226,15 @@ void L64XX_Marlin::init_to_defaults() {
|
||||
#if AXIS_IS_L64XX(K)
|
||||
L6470_INIT_CHIP(K);
|
||||
#endif
|
||||
#if AXIS_IS_L64XX(U)
|
||||
L6470_INIT_CHIP(U);
|
||||
#endif
|
||||
#if AXIS_IS_L64XX(V)
|
||||
L6470_INIT_CHIP(V);
|
||||
#endif
|
||||
#if AXIS_IS_L64XX(W)
|
||||
L6470_INIT_CHIP(W);
|
||||
#endif
|
||||
#if AXIS_IS_L64XX(E0)
|
||||
L6470_INIT_CHIP(E0);
|
||||
#endif
|
||||
|
||||
@ -266,6 +266,72 @@
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// U Stepper
|
||||
#if HAS_U_AXIS
|
||||
#if AXIS_IS_L64XX(U)
|
||||
extern L64XX_CLASS(U) stepperU;
|
||||
#define U_ENABLE_INIT() NOOP
|
||||
#define U_ENABLE_WRITE(STATE) (STATE ? stepperU.hardStop() : stepperU.free())
|
||||
#define U_ENABLE_READ() (stepperU.getStatus() & STATUS_HIZ)
|
||||
#if AXIS_DRIVER_TYPE_U(L6474)
|
||||
#define U_DIR_INIT() SET_OUTPUT(U_DIR_PIN)
|
||||
#define U_DIR_WRITE(STATE) L6474_DIR_WRITE(U, STATE)
|
||||
#define U_DIR_READ() READ(U_DIR_PIN)
|
||||
#else
|
||||
#define U_DIR_INIT() NOOP
|
||||
#define U_DIR_WRITE(STATE) L64XX_DIR_WRITE(U, STATE)
|
||||
#define U_DIR_READ() (stepper##U.getStatus() & STATUS_DIR);
|
||||
#if AXIS_DRIVER_TYPE_U(L6470)
|
||||
#define DISABLE_STEPPER_U() stepperU.free()
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// V Stepper
|
||||
#if HAS_V_AXIS
|
||||
#if AXIS_IS_L64XX(V)
|
||||
extern L64XX_CLASS(V) stepperV;
|
||||
#define V_ENABLE_INIT() NOOP
|
||||
#define V_ENABLE_WRITE(STATE) (STATE ? stepperV.hardStop() : stepperV.free())
|
||||
#define V_ENABLE_READ() (stepperV.getStatus() & STATUS_HIZ)
|
||||
#if AXIS_DRIVER_TYPE_V(L6474)
|
||||
#define V_DIR_INIT() SET_OUTPUT(V_DIR_PIN)
|
||||
#define V_DIR_WRITE(STATE) L6474_DIR_WRITE(V, STATE)
|
||||
#define V_DIR_READ() READ(V_DIR_PIN)
|
||||
#else
|
||||
#define V_DIR_INIT() NOOP
|
||||
#define V_DIR_WRITE(STATE) L64XX_DIR_WRITE(V, STATE)
|
||||
#define V_DIR_READ() (stepper##V.getStatus() & STATUS_DIR);
|
||||
#if AXIS_DRIVER_TYPE_V(L6470)
|
||||
#define DISABLE_STEPPER_V() stepperV.free()
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// W Stepper
|
||||
#if HAS_W_AXIS
|
||||
#if AXIS_IS_L64XX(W)
|
||||
extern L64XX_CLASS(w) stepperW;
|
||||
#define W_ENABLE_INIT() NOOP
|
||||
#define W_ENABLE_WRITE(STATE) (STATE ? stepperW.hardStop() : stepperW.free())
|
||||
#define W_ENABLE_READ() (stepperW.getStatus() & STATUS_HIZ)
|
||||
#if AXIS_DRIVER_TYPE_W(L6474)
|
||||
#define W_DIR_INIT() SET_OUTPUT(W_DIR_PIN)
|
||||
#define W_DIR_WRITE(STATE) L6474_DIR_WRITE(W, STATE)
|
||||
#define W_DIR_READ() READ(W_DIR_PIN)
|
||||
#else
|
||||
#define W_DIR_INIT() NOOP
|
||||
#define W_DIR_WRITE(STATE) L64XX_DIR_WRITE(W, STATE)
|
||||
#define W_DIR_READ() (stepper##W.getStatus() & STATUS_DIR);
|
||||
#if AXIS_DRIVER_TYPE_W(L6470)
|
||||
#define DISABLE_STEPPER_W() stepperW.free()
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// E0 Stepper
|
||||
#if AXIS_IS_L64XX(E0)
|
||||
extern L64XX_CLASS(E0) stepperE0;
|
||||
|
||||
@ -69,6 +69,15 @@
|
||||
#if AXIS_DRIVER_TYPE_K(TMC26X)
|
||||
_TMC26X_DEFINE(K);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_U(TMC26X)
|
||||
_TMC26X_DEFINE(U);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_V(TMC26X)
|
||||
_TMC26X_DEFINE(V);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_W(TMC26X)
|
||||
_TMC26X_DEFINE(W);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_E0(TMC26X)
|
||||
_TMC26X_DEFINE(E0);
|
||||
#endif
|
||||
@ -133,6 +142,15 @@ void tmc26x_init_to_defaults() {
|
||||
#if AXIS_DRIVER_TYPE_K(TMC26X)
|
||||
_TMC26X_INIT(K);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_U(TMC26X)
|
||||
_TMC26X_INIT(U);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_V(TMC26X)
|
||||
_TMC26X_INIT(V);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_W(TMC26X)
|
||||
_TMC26X_INIT(W);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_E0(TMC26X)
|
||||
_TMC26X_INIT(E0);
|
||||
#endif
|
||||
|
||||
@ -123,6 +123,30 @@ void tmc26x_init_to_defaults();
|
||||
#define K_ENABLE_READ() stepperK.isEnabled()
|
||||
#endif
|
||||
|
||||
// U Stepper
|
||||
#if HAS_U_ENABLE && AXIS_DRIVER_TYPE_U(TMC26X)
|
||||
extern TMC26XStepper stepperU;
|
||||
#define U_ENABLE_INIT() NOOP
|
||||
#define U_ENABLE_WRITE(STATE) stepperU.setEnabled(STATE)
|
||||
#define U_ENABLE_READ() stepperU.isEnabled()
|
||||
#endif
|
||||
|
||||
// V Stepper
|
||||
#if HAS_V_ENABLE && AXIS_DRIVER_TYPE_V(TMC26X)
|
||||
extern TMC26XStepper stepperV;
|
||||
#define V_ENABLE_INIT() NOOP
|
||||
#define V_ENABLE_WRITE(STATE) stepperV.setEnabled(STATE)
|
||||
#define V_ENABLE_READ() stepperV.isEnabled()
|
||||
#endif
|
||||
|
||||
// W Stepper
|
||||
#if HAS_W_ENABLE && AXIS_DRIVER_TYPE_W(TMC26X)
|
||||
extern TMC26XStepper stepperW;
|
||||
#define W_ENABLE_INIT() NOOP
|
||||
#define W_ENABLE_WRITE(STATE) stepperW.setEnabled(STATE)
|
||||
#define W_ENABLE_READ() stepperW.isEnabled()
|
||||
#endif
|
||||
|
||||
// E0 Stepper
|
||||
#if AXIS_DRIVER_TYPE_E0(TMC26X)
|
||||
extern TMC26XStepper stepperE0;
|
||||
|
||||
@ -262,6 +262,63 @@ void reset_stepper_drivers(); // Called by settings.load / settings.reset
|
||||
#define K_STEP_READ() bool(READ(K_STEP_PIN))
|
||||
#endif
|
||||
|
||||
// U Stepper
|
||||
#if HAS_U_AXIS
|
||||
#ifndef U_ENABLE_INIT
|
||||
#define U_ENABLE_INIT() SET_OUTPUT(U_ENABLE_PIN)
|
||||
#define U_ENABLE_WRITE(STATE) WRITE(U_ENABLE_PIN,STATE)
|
||||
#define U_ENABLE_READ() bool(READ(U_ENABLE_PIN))
|
||||
#endif
|
||||
#ifndef U_DIR_INIT
|
||||
#define U_DIR_INIT() SET_OUTPUT(U_DIR_PIN)
|
||||
#define U_DIR_WRITE(STATE) WRITE(U_DIR_PIN,STATE)
|
||||
#define U_DIR_READ() bool(READ(U_DIR_PIN))
|
||||
#endif
|
||||
#define U_STEP_INIT() SET_OUTPUT(U_STEP_PIN)
|
||||
#ifndef U_STEP_WRITE
|
||||
#define U_STEP_WRITE(STATE) WRITE(U_STEP_PIN,STATE)
|
||||
#endif
|
||||
#define U_STEP_READ() bool(READ(U_STEP_PIN))
|
||||
#endif
|
||||
|
||||
// V Stepper
|
||||
#if HAS_V_AXIS
|
||||
#ifndef V_ENABLE_INIT
|
||||
#define V_ENABLE_INIT() SET_OUTPUT(V_ENABLE_PIN)
|
||||
#define V_ENABLE_WRITE(STATE) WRITE(V_ENABLE_PIN,STATE)
|
||||
#define V_ENABLE_READ() bool(READ(V_ENABLE_PIN))
|
||||
#endif
|
||||
#ifndef V_DIR_INIT
|
||||
#define V_DIR_INIT() SET_OUTPUT(V_DIR_PIN)
|
||||
#define V_DIR_WRITE(STATE) WRITE(V_DIR_PIN,STATE)
|
||||
#define V_DIR_READ() bool(READ(V_DIR_PIN))
|
||||
#endif
|
||||
#define V_STEP_INIT() SET_OUTPUT(V_STEP_PIN)
|
||||
#ifndef V_STEP_WRITE
|
||||
#define V_STEP_WRITE(STATE) WRITE(V_STEP_PIN,STATE)
|
||||
#endif
|
||||
#define V_STEP_READ() bool(READ(V_STEP_PIN))
|
||||
#endif
|
||||
|
||||
// W Stepper
|
||||
#if HAS_W_AXIS
|
||||
#ifndef W_ENABLE_INIT
|
||||
#define W_ENABLE_INIT() SET_OUTPUT(W_ENABLE_PIN)
|
||||
#define W_ENABLE_WRITE(STATE) WRITE(W_ENABLE_PIN,STATE)
|
||||
#define W_ENABLE_READ() bool(READ(W_ENABLE_PIN))
|
||||
#endif
|
||||
#ifndef W_DIR_INIT
|
||||
#define W_DIR_INIT() SET_OUTPUT(W_DIR_PIN)
|
||||
#define W_DIR_WRITE(STATE) WRITE(W_DIR_PIN,STATE)
|
||||
#define W_DIR_READ() bool(READ(W_DIR_PIN))
|
||||
#endif
|
||||
#define W_STEP_INIT() SET_OUTPUT(W_STEP_PIN)
|
||||
#ifndef W_STEP_WRITE
|
||||
#define W_STEP_WRITE(STATE) WRITE(W_STEP_PIN,STATE)
|
||||
#endif
|
||||
#define W_STEP_READ() bool(READ(W_STEP_PIN))
|
||||
#endif
|
||||
|
||||
// E0 Stepper
|
||||
#ifndef E0_ENABLE_INIT
|
||||
#define E0_ENABLE_INIT() SET_OUTPUT(E0_ENABLE_PIN)
|
||||
@ -743,6 +800,51 @@ void reset_stepper_drivers(); // Called by settings.load / settings.reset
|
||||
#define DISABLE_STEPPER_K() TERN(HAS_K_ENABLE, K_ENABLE_WRITE(!K_ENABLE_ON), NOOP)
|
||||
#endif
|
||||
|
||||
#ifndef ENABLE_STEPPER_U
|
||||
#if HAS_U_ENABLE
|
||||
#define ENABLE_STEPPER_U() U_ENABLE_WRITE( U_ENABLE_ON)
|
||||
#else
|
||||
#define ENABLE_STEPPER_U() NOOP
|
||||
#endif
|
||||
#endif
|
||||
#ifndef DISABLE_STEPPER_U
|
||||
#if HAS_U_ENABLE
|
||||
#define DISABLE_STEPPER_U() U_ENABLE_WRITE(!U_ENABLE_ON)
|
||||
#else
|
||||
#define DISABLE_STEPPER_U() NOOP
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef ENABLE_STEPPER_V
|
||||
#if HAS_V_ENABLE
|
||||
#define ENABLE_STEPPER_V() V_ENABLE_WRITE( V_ENABLE_ON)
|
||||
#else
|
||||
#define ENABLE_STEPPER_V() NOOP
|
||||
#endif
|
||||
#endif
|
||||
#ifndef DISABLE_STEPPER_V
|
||||
#if HAS_V_ENABLE
|
||||
#define DISABLE_STEPPER_V() V_ENABLE_WRITE(!V_ENABLE_ON)
|
||||
#else
|
||||
#define DISABLE_STEPPER_V() NOOP
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef ENABLE_STEPPER_W
|
||||
#if HAS_W_ENABLE
|
||||
#define ENABLE_STEPPER_W() W_ENABLE_WRITE( W_ENABLE_ON)
|
||||
#else
|
||||
#define ENABLE_STEPPER_W() NOOP
|
||||
#endif
|
||||
#endif
|
||||
#ifndef DISABLE_STEPPER_W
|
||||
#if HAS_W_ENABLE
|
||||
#define DISABLE_STEPPER_W() W_ENABLE_WRITE(!W_ENABLE_ON)
|
||||
#else
|
||||
#define DISABLE_STEPPER_W() NOOP
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef ENABLE_STEPPER_E0
|
||||
#define ENABLE_STEPPER_E0() TERN(HAS_E0_ENABLE, E0_ENABLE_WRITE( E_ENABLE_ON), NOOP)
|
||||
#endif
|
||||
@ -917,6 +1019,28 @@ void reset_stepper_drivers(); // Called by settings.load / settings.reset
|
||||
#define DISABLE_AXIS_K() NOOP
|
||||
#endif
|
||||
|
||||
#if HAS_U_AXIS
|
||||
#define ENABLE_AXIS_U() if (SHOULD_ENABLE(u)) { ENABLE_STEPPER_U(); AFTER_CHANGE(u, true); }
|
||||
#define DISABLE_AXIS_U() if (SHOULD_DISABLE(u)) { DISABLE_STEPPER_U(); AFTER_CHANGE(u, false); set_axis_untrusted(U_AXIS); }
|
||||
#else
|
||||
#define ENABLE_AXIS_U() NOOP
|
||||
#define DISABLE_AXIS_U() NOOP
|
||||
#endif
|
||||
#if HAS_V_AXIS
|
||||
#define ENABLE_AXIS_V() if (SHOULD_ENABLE(v)) { ENABLE_STEPPER_V(); AFTER_CHANGE(v, true); }
|
||||
#define DISABLE_AXIS_V() if (SHOULD_DISABLE(v)) { DISABLE_STEPPER_V(); AFTER_CHANGE(v, false); set_axis_untrusted(V_AXIS); }
|
||||
#else
|
||||
#define ENABLE_AXIS_V() NOOP
|
||||
#define DISABLE_AXIS_V() NOOP
|
||||
#endif
|
||||
#if HAS_W_AXIS
|
||||
#define ENABLE_AXIS_W() if (SHOULD_ENABLE(w)) { ENABLE_STEPPER_W(); AFTER_CHANGE(w, true); }
|
||||
#define DISABLE_AXIS_W() if (SHOULD_DISABLE(w)) { DISABLE_STEPPER_W(); AFTER_CHANGE(w, false); set_axis_untrusted(W_AXIS); }
|
||||
#else
|
||||
#define ENABLE_AXIS_W() NOOP
|
||||
#define DISABLE_AXIS_W() 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, STEALTH_AXIS_I, STEALTH_AXIS_J, STEALTH_AXIS_K)
|
||||
LOGICAL_AXIS_LIST(STEALTH_AXIS_E, STEALTH_AXIS_X, STEALTH_AXIS_Y, STEALTH_AXIS_Z, STEALTH_AXIS_I, STEALTH_AXIS_J, STEALTH_AXIS_K, STEALTH_AXIS_U, STEALTH_AXIS_V, STEALTH_AXIS_W)
|
||||
};
|
||||
#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, ST##_HOLD_MULTIPLIER)
|
||||
|
||||
@ -106,6 +106,15 @@ enum StealthIndex : uint8_t {
|
||||
#if AXIS_HAS_SPI(K)
|
||||
TMC_SPI_DEFINE(K, K);
|
||||
#endif
|
||||
#if AXIS_HAS_SPI(U)
|
||||
TMC_SPI_DEFINE(U, U);
|
||||
#endif
|
||||
#if AXIS_HAS_SPI(V)
|
||||
TMC_SPI_DEFINE(V, V);
|
||||
#endif
|
||||
#if AXIS_HAS_SPI(W)
|
||||
TMC_SPI_DEFINE(W, W);
|
||||
#endif
|
||||
#if AXIS_HAS_SPI(E0)
|
||||
TMC_SPI_DEFINE_E(0);
|
||||
#endif
|
||||
@ -173,6 +182,15 @@ enum StealthIndex : uint8_t {
|
||||
#ifndef TMC_K_BAUD_RATE
|
||||
#define TMC_K_BAUD_RATE TMC_BAUD_RATE
|
||||
#endif
|
||||
#ifndef TMC_U_BAUD_RATE
|
||||
#define TMC_U_BAUD_RATE TMC_BAUD_RATE
|
||||
#endif
|
||||
#ifndef TMC_V_BAUD_RATE
|
||||
#define TMC_V_BAUD_RATE TMC_BAUD_RATE
|
||||
#endif
|
||||
#ifndef TMC_W_BAUD_RATE
|
||||
#define TMC_W_BAUD_RATE TMC_BAUD_RATE
|
||||
#endif
|
||||
#ifndef TMC_E0_BAUD_RATE
|
||||
#define TMC_E0_BAUD_RATE TMC_BAUD_RATE
|
||||
#endif
|
||||
@ -374,6 +392,32 @@ enum StealthIndex : uint8_t {
|
||||
#define K_HAS_SW_SERIAL 1
|
||||
#endif
|
||||
#endif
|
||||
#if AXIS_HAS_UART(U)
|
||||
#ifdef U_HARDWARE_SERIAL
|
||||
TMC_UART_DEFINE(HW, U, U);
|
||||
#define U_HAS_HW_SERIAL 1
|
||||
#else
|
||||
TMC_UART_DEFINE(SW, U, U);
|
||||
#define U_HAS_SW_SERIAL 1
|
||||
#endif
|
||||
#endif
|
||||
#if AXIS_HAS_UART(V)
|
||||
#ifdef V_HARDWARE_SERIAL
|
||||
TMC_UART_DEFINE(HW, V, V);
|
||||
#else
|
||||
TMC_UART_DEFINE(SW, V, V);
|
||||
#define V_HAS_SW_SERIAL 1
|
||||
#endif
|
||||
#endif
|
||||
#if AXIS_HAS_UART(W)
|
||||
#ifdef W_HARDWARE_SERIAL
|
||||
TMC_UART_DEFINE(HW, W, W);
|
||||
#define W_HAS_HW_SERIAL 1
|
||||
#else
|
||||
TMC_UART_DEFINE(SW, W, W);
|
||||
#define W_HAS_SW_SERIAL 1
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if AXIS_HAS_UART(E0)
|
||||
#ifdef E0_HARDWARE_SERIAL
|
||||
@ -449,7 +493,7 @@ enum StealthIndex : uint8_t {
|
||||
#endif
|
||||
|
||||
#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 };
|
||||
enum TMCAxis : uint8_t { NUM_AXIS_LIST(X, Y, Z, I, J, K, U, V, W), X2, Y2, Z2, Z3, Z4 REPEAT(EXTRUDERS, _EN_ITEM), TOTAL };
|
||||
#undef _EN_ITEM
|
||||
|
||||
void tmc_serial_begin() {
|
||||
@ -543,6 +587,27 @@ enum StealthIndex : uint8_t {
|
||||
stepperK.beginSerial(TMC_BAUD_RATE);
|
||||
#endif
|
||||
#endif
|
||||
#if AXIS_HAS_UART(U)
|
||||
#ifdef U_HARDWARE_SERIAL
|
||||
HW_SERIAL_BEGIN(U);
|
||||
#else
|
||||
stepperU.beginSerial(TMC_BAUD_RATE);
|
||||
#endif
|
||||
#endif
|
||||
#if AXIS_HAS_UART(V)
|
||||
#ifdef V_HARDWARE_SERIAL
|
||||
HW_SERIAL_BEGIN(V);
|
||||
#else
|
||||
stepperV.beginSerial(TMC_BAUD_RATE);
|
||||
#endif
|
||||
#endif
|
||||
#if AXIS_HAS_UART(W)
|
||||
#ifdef W_HARDWARE_SERIAL
|
||||
HW_SERIAL_BEGIN(W);
|
||||
#else
|
||||
stepperW.beginSerial(TMC_BAUD_RATE);
|
||||
#endif
|
||||
#endif
|
||||
#if AXIS_HAS_UART(E0)
|
||||
#ifdef E0_HARDWARE_SERIAL
|
||||
HW_SERIAL_BEGIN(E0);
|
||||
@ -814,6 +879,15 @@ void restore_trinamic_drivers() {
|
||||
#if AXIS_IS_TMC(K)
|
||||
stepperK.push();
|
||||
#endif
|
||||
#if AXIS_IS_TMC(U)
|
||||
stepperU.push();
|
||||
#endif
|
||||
#if AXIS_IS_TMC(V)
|
||||
stepperV.push();
|
||||
#endif
|
||||
#if AXIS_IS_TMC(W)
|
||||
stepperW.push();
|
||||
#endif
|
||||
#if AXIS_IS_TMC(E0)
|
||||
stepperE0.push();
|
||||
#endif
|
||||
@ -844,7 +918,8 @@ void reset_trinamic_drivers() {
|
||||
static constexpr bool stealthchop_by_axis[] = LOGICAL_AXIS_ARRAY(
|
||||
ENABLED(STEALTHCHOP_E),
|
||||
ENABLED(STEALTHCHOP_XY), ENABLED(STEALTHCHOP_XY), ENABLED(STEALTHCHOP_Z),
|
||||
ENABLED(STEALTHCHOP_I), ENABLED(STEALTHCHOP_J), ENABLED(STEALTHCHOP_K)
|
||||
ENABLED(STEALTHCHOP_I), ENABLED(STEALTHCHOP_J), ENABLED(STEALTHCHOP_K),
|
||||
ENABLED(STEALTHCHOP_U), ENABLED(STEALTHCHOP_V), ENABLED(STEALTHCHOP_W)
|
||||
);
|
||||
|
||||
#if AXIS_IS_TMC(X)
|
||||
@ -880,6 +955,15 @@ void reset_trinamic_drivers() {
|
||||
#if AXIS_IS_TMC(K)
|
||||
TMC_INIT(K, STEALTH_AXIS_K);
|
||||
#endif
|
||||
#if AXIS_IS_TMC(U)
|
||||
TMC_INIT(U, STEALTH_AXIS_U);
|
||||
#endif
|
||||
#if AXIS_IS_TMC(V)
|
||||
TMC_INIT(V, STEALTH_AXIS_V);
|
||||
#endif
|
||||
#if AXIS_IS_TMC(W)
|
||||
TMC_INIT(W, STEALTH_AXIS_W);
|
||||
#endif
|
||||
#if AXIS_IS_TMC(E0)
|
||||
TMC_INIT(E0, STEALTH_AXIS_E);
|
||||
#endif
|
||||
@ -917,6 +1001,9 @@ void reset_trinamic_drivers() {
|
||||
TERN_(I_SENSORLESS, stepperI.homing_threshold(I_STALL_SENSITIVITY));
|
||||
TERN_(J_SENSORLESS, stepperJ.homing_threshold(J_STALL_SENSITIVITY));
|
||||
TERN_(K_SENSORLESS, stepperK.homing_threshold(K_STALL_SENSITIVITY));
|
||||
TERN_(U_SENSORLESS, stepperU.homing_threshold(U_STALL_SENSITIVITY));
|
||||
TERN_(V_SENSORLESS, stepperV.homing_threshold(V_STALL_SENSITIVITY));
|
||||
TERN_(W_SENSORLESS, stepperW.homing_threshold(W_STALL_SENSITIVITY));
|
||||
#endif
|
||||
|
||||
#ifdef TMC_ADV
|
||||
@ -946,7 +1033,7 @@ void reset_trinamic_drivers() {
|
||||
TMC_HW_DETAIL(X), TMC_HW_DETAIL(X2),
|
||||
TMC_HW_DETAIL(Y), TMC_HW_DETAIL(Y2),
|
||||
TMC_HW_DETAIL(Z), TMC_HW_DETAIL(Z2), TMC_HW_DETAIL(Z3), TMC_HW_DETAIL(Z4),
|
||||
TMC_HW_DETAIL(I), TMC_HW_DETAIL(J), TMC_HW_DETAIL(K),
|
||||
TMC_HW_DETAIL(I), TMC_HW_DETAIL(J), TMC_HW_DETAIL(K), TMC_HW_DETAIL(U), TMC_HW_DETAIL(V), TMC_HW_DETAIL(W),
|
||||
TMC_HW_DETAIL(E0), TMC_HW_DETAIL(E1), TMC_HW_DETAIL(E2), TMC_HW_DETAIL(E3), TMC_HW_DETAIL(E4), TMC_HW_DETAIL(E5), TMC_HW_DETAIL(E6), TMC_HW_DETAIL(E7)
|
||||
};
|
||||
|
||||
@ -969,7 +1056,7 @@ void reset_trinamic_drivers() {
|
||||
SA_NO_TMC_HW_C(X); SA_NO_TMC_HW_C(X2);
|
||||
SA_NO_TMC_HW_C(Y); SA_NO_TMC_HW_C(Y2);
|
||||
SA_NO_TMC_HW_C(Z); SA_NO_TMC_HW_C(Z2); SA_NO_TMC_HW_C(Z3); SA_NO_TMC_HW_C(Z4);
|
||||
SA_NO_TMC_HW_C(I); SA_NO_TMC_HW_C(J); SA_NO_TMC_HW_C(K);
|
||||
SA_NO_TMC_HW_C(I); SA_NO_TMC_HW_C(J); SA_NO_TMC_HW_C(K); SA_NO_TMC_HW_C(U); SA_NO_TMC_HW_C(V); SA_NO_TMC_HW_C(W);
|
||||
SA_NO_TMC_HW_C(E0); SA_NO_TMC_HW_C(E1); SA_NO_TMC_HW_C(E2); SA_NO_TMC_HW_C(E3); SA_NO_TMC_HW_C(E4); SA_NO_TMC_HW_C(E5); SA_NO_TMC_HW_C(E6); SA_NO_TMC_HW_C(E7);
|
||||
#endif
|
||||
|
||||
@ -981,7 +1068,7 @@ void reset_trinamic_drivers() {
|
||||
TMC_SW_DETAIL(X), TMC_SW_DETAIL(X2),
|
||||
TMC_SW_DETAIL(Y), TMC_SW_DETAIL(Y2),
|
||||
TMC_SW_DETAIL(Z), TMC_SW_DETAIL(Z2), TMC_SW_DETAIL(Z3), TMC_SW_DETAIL(Z4),
|
||||
TMC_SW_DETAIL(I), TMC_SW_DETAIL(J), TMC_SW_DETAIL(K),
|
||||
TMC_SW_DETAIL(I), TMC_SW_DETAIL(J), TMC_SW_DETAIL(K), TMC_SW_DETAIL(U), TMC_SW_DETAIL(V), TMC_SW_DETAIL(W),
|
||||
TMC_SW_DETAIL(E0), TMC_SW_DETAIL(E1), TMC_SW_DETAIL(E2), TMC_SW_DETAIL(E3), TMC_SW_DETAIL(E4), TMC_SW_DETAIL(E5), TMC_SW_DETAIL(E6), TMC_SW_DETAIL(E7)
|
||||
};
|
||||
|
||||
@ -999,7 +1086,7 @@ void reset_trinamic_drivers() {
|
||||
SA_NO_TMC_SW_C(X); SA_NO_TMC_SW_C(X2);
|
||||
SA_NO_TMC_SW_C(Y); SA_NO_TMC_SW_C(Y2);
|
||||
SA_NO_TMC_SW_C(Z); SA_NO_TMC_SW_C(Z2); SA_NO_TMC_SW_C(Z3); SA_NO_TMC_SW_C(Z4);
|
||||
SA_NO_TMC_SW_C(I); SA_NO_TMC_SW_C(J); SA_NO_TMC_SW_C(K);
|
||||
SA_NO_TMC_SW_C(I); SA_NO_TMC_SW_C(J); SA_NO_TMC_SW_C(K); SA_NO_TMC_SW_C(U); SA_NO_TMC_SW_C(V); SA_NO_TMC_SW_C(W);
|
||||
SA_NO_TMC_SW_C(E0); SA_NO_TMC_SW_C(E1); SA_NO_TMC_SW_C(E2); SA_NO_TMC_SW_C(E3); SA_NO_TMC_SW_C(E4); SA_NO_TMC_SW_C(E5); SA_NO_TMC_SW_C(E6); SA_NO_TMC_SW_C(E7);
|
||||
#endif
|
||||
|
||||
|
||||
@ -49,6 +49,9 @@
|
||||
#define TMC_I_LABEL 'I', '0'
|
||||
#define TMC_J_LABEL 'J', '0'
|
||||
#define TMC_K_LABEL 'K', '0'
|
||||
#define TMC_U_LABEL 'U', '0'
|
||||
#define TMC_V_LABEL 'V', '0'
|
||||
#define TMC_W_LABEL 'W', '0'
|
||||
|
||||
#define TMC_X2_LABEL 'X', '2'
|
||||
#define TMC_Y2_LABEL 'Y', '2'
|
||||
@ -92,6 +95,15 @@
|
||||
#if HAS_K_AXIS && !defined(CHOPPER_TIMING_K)
|
||||
#define CHOPPER_TIMING_K CHOPPER_TIMING
|
||||
#endif
|
||||
#if HAS_U_AXIS && !defined(CHOPPER_TIMING_U)
|
||||
#define CHOPPER_TIMING_U CHOPPER_TIMING
|
||||
#endif
|
||||
#if HAS_V_AXIS && !defined(CHOPPER_TIMING_V)
|
||||
#define CHOPPER_TIMING_V CHOPPER_TIMING
|
||||
#endif
|
||||
#if HAS_W_AXIS && !defined(CHOPPER_TIMING_W)
|
||||
#define CHOPPER_TIMING_W CHOPPER_TIMING
|
||||
#endif
|
||||
#if HAS_EXTRUDERS && !defined(CHOPPER_TIMING_E)
|
||||
#define CHOPPER_TIMING_E CHOPPER_TIMING
|
||||
#endif
|
||||
@ -274,6 +286,48 @@ void reset_trinamic_drivers();
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// U Stepper
|
||||
#if AXIS_IS_TMC(U)
|
||||
extern TMC_CLASS(U, U) stepperU;
|
||||
static constexpr chopper_timing_t chopper_timing_U = CHOPPER_TIMING_U;
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
#define U_ENABLE_INIT() NOOP
|
||||
#define U_ENABLE_WRITE(STATE) stepperU.toff((STATE)==U_ENABLE_ON ? chopper_timing_U.toff : 0)
|
||||
#define U_ENABLE_READ() stepperU.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_SQUARE_WAVE(U)
|
||||
#define U_STEP_WRITE(STATE) do{ if(STATE) TOGGLE(U_STEP_PIN); }while(0)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// V Stepper
|
||||
#if AXIS_IS_TMC(V)
|
||||
extern TMC_CLASS(V, V) stepperV;
|
||||
static constexpr chopper_timing_t chopper_timing_V = CHOPPER_TIMING_V;
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
#define V_ENABLE_INIT() NOOP
|
||||
#define V_ENABLE_WRITE(STATE) stepperV.toff((STATE)==V_ENABLE_ON ? chopper_timing_V.toff : 0)
|
||||
#define V_ENABLE_READ() stepperV.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_SQUARE_WAVE(V)
|
||||
#define V_STEP_WRITE(STATE) do{ if(STATE) TOGGLE(V_STEP_PIN); }while(0)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// W Stepper
|
||||
#if AXIS_IS_TMC(W)
|
||||
extern TMC_CLASS(W, W) stepperW;
|
||||
static constexpr chopper_timing_t chopper_timing_W = CHOPPER_TIMING_W;
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
#define W_ENABLE_INIT() NOOP
|
||||
#define W_ENABLE_WRITE(STATE) stepperW.toff((STATE)==W_ENABLE_ON ? chopper_timing_W.toff : 0)
|
||||
#define W_ENABLE_READ() stepperW.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_SQUARE_WAVE(W)
|
||||
#define W_STEP_WRITE(STATE) do{ if(STATE) TOGGLE(W_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