Ender3 - Marlin 2.1.2.4 build (#16)
This commit was merged in pull request #16.
This commit is contained in:
@@ -0,0 +1,180 @@
|
||||
/**
|
||||
* Marlin 3D Printer Firmware
|
||||
* Copyright (c) 2020 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 <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* stepper/TMC26X.cpp
|
||||
* Stepper driver indirection for TMC26X drivers
|
||||
*/
|
||||
|
||||
#include "../../inc/MarlinConfig.h"
|
||||
|
||||
//
|
||||
// TMC26X Driver objects and inits
|
||||
//
|
||||
#if HAS_TMC26X
|
||||
|
||||
#include "TMC26X.h"
|
||||
|
||||
#define _TMC26X_DEFINE(ST) TMC26XStepper stepper##ST(200, ST##_CS_PIN, ST##_STEP_PIN, ST##_DIR_PIN, ST##_CURRENT, int(ST##_RSENSE * 1000))
|
||||
|
||||
#if AXIS_DRIVER_TYPE_X(TMC26X)
|
||||
_TMC26X_DEFINE(X);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_X2(TMC26X)
|
||||
_TMC26X_DEFINE(X2);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_Y(TMC26X)
|
||||
_TMC26X_DEFINE(Y);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_Y2(TMC26X)
|
||||
_TMC26X_DEFINE(Y2);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_Z(TMC26X)
|
||||
_TMC26X_DEFINE(Z);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_Z2(TMC26X)
|
||||
_TMC26X_DEFINE(Z2);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_Z3(TMC26X)
|
||||
_TMC26X_DEFINE(Z3);
|
||||
#endif
|
||||
#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_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
|
||||
#if AXIS_DRIVER_TYPE_E1(TMC26X)
|
||||
_TMC26X_DEFINE(E1);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_E2(TMC26X)
|
||||
_TMC26X_DEFINE(E2);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_E3(TMC26X)
|
||||
_TMC26X_DEFINE(E3);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_E4(TMC26X)
|
||||
_TMC26X_DEFINE(E4);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_E5(TMC26X)
|
||||
_TMC26X_DEFINE(E5);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_E6(TMC26X)
|
||||
_TMC26X_DEFINE(E6);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_E7(TMC26X)
|
||||
_TMC26X_DEFINE(E7);
|
||||
#endif
|
||||
|
||||
#define _TMC26X_INIT(A) do{ \
|
||||
stepper##A.setMicrosteps(A##_MICROSTEPS); \
|
||||
stepper##A.start(); \
|
||||
}while(0)
|
||||
|
||||
void tmc26x_init_to_defaults() {
|
||||
#if AXIS_DRIVER_TYPE_X(TMC26X)
|
||||
_TMC26X_INIT(X);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_X2(TMC26X)
|
||||
_TMC26X_INIT(X2);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_Y(TMC26X)
|
||||
_TMC26X_INIT(Y);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_Y2(TMC26X)
|
||||
_TMC26X_INIT(Y2);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_Z(TMC26X)
|
||||
_TMC26X_INIT(Z);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_Z2(TMC26X)
|
||||
_TMC26X_INIT(Z2);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_Z3(TMC26X)
|
||||
_TMC26X_INIT(Z3);
|
||||
#endif
|
||||
#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_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
|
||||
#if AXIS_DRIVER_TYPE_E1(TMC26X)
|
||||
_TMC26X_INIT(E1);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_E2(TMC26X)
|
||||
_TMC26X_INIT(E2);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_E3(TMC26X)
|
||||
_TMC26X_INIT(E3);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_E4(TMC26X)
|
||||
_TMC26X_INIT(E4);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_E5(TMC26X)
|
||||
_TMC26X_INIT(E5);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_E6(TMC26X)
|
||||
_TMC26X_INIT(E6);
|
||||
#endif
|
||||
#if AXIS_DRIVER_TYPE_E7(TMC26X)
|
||||
_TMC26X_INIT(E7);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif // HAS_TMC26X
|
||||
@@ -0,0 +1,212 @@
|
||||
/**
|
||||
* Marlin 3D Printer Firmware
|
||||
* Copyright (c) 2020 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 <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
/**
|
||||
* stepper/TMC26X.h
|
||||
* Stepper driver indirection for TMC26X drivers
|
||||
*/
|
||||
|
||||
#include "../../inc/MarlinConfig.h"
|
||||
|
||||
// TMC26X drivers have STEP/DIR on normal pins, but ENABLE via SPI
|
||||
|
||||
#include <SPI.h>
|
||||
#include <TMC26XStepper.h>
|
||||
|
||||
void tmc26x_init_to_defaults();
|
||||
|
||||
// X Stepper
|
||||
#if AXIS_DRIVER_TYPE_X(TMC26X)
|
||||
extern TMC26XStepper stepperX;
|
||||
#define X_ENABLE_INIT() NOOP
|
||||
#define X_ENABLE_WRITE(STATE) stepperX.setEnabled(STATE)
|
||||
#define X_ENABLE_READ() stepperX.isEnabled()
|
||||
#endif
|
||||
|
||||
// Y Stepper
|
||||
#if AXIS_DRIVER_TYPE_Y(TMC26X)
|
||||
extern TMC26XStepper stepperY;
|
||||
#define Y_ENABLE_INIT() NOOP
|
||||
#define Y_ENABLE_WRITE(STATE) stepperY.setEnabled(STATE)
|
||||
#define Y_ENABLE_READ() stepperY.isEnabled()
|
||||
#endif
|
||||
|
||||
// Z Stepper
|
||||
#if AXIS_DRIVER_TYPE_Z(TMC26X)
|
||||
extern TMC26XStepper stepperZ;
|
||||
#define Z_ENABLE_INIT() NOOP
|
||||
#define Z_ENABLE_WRITE(STATE) stepperZ.setEnabled(STATE)
|
||||
#define Z_ENABLE_READ() stepperZ.isEnabled()
|
||||
#endif
|
||||
|
||||
// X2 Stepper
|
||||
#if HAS_X2_ENABLE && AXIS_DRIVER_TYPE_X2(TMC26X)
|
||||
extern TMC26XStepper stepperX2;
|
||||
#define X2_ENABLE_INIT() NOOP
|
||||
#define X2_ENABLE_WRITE(STATE) stepperX2.setEnabled(STATE)
|
||||
#define X2_ENABLE_READ() stepperX2.isEnabled()
|
||||
#endif
|
||||
|
||||
// Y2 Stepper
|
||||
#if HAS_Y2_ENABLE && AXIS_DRIVER_TYPE_Y2(TMC26X)
|
||||
extern TMC26XStepper stepperY2;
|
||||
#define Y2_ENABLE_INIT() NOOP
|
||||
#define Y2_ENABLE_WRITE(STATE) stepperY2.setEnabled(STATE)
|
||||
#define Y2_ENABLE_READ() stepperY2.isEnabled()
|
||||
#endif
|
||||
|
||||
// Z2 Stepper
|
||||
#if HAS_Z2_ENABLE && AXIS_DRIVER_TYPE_Z2(TMC26X)
|
||||
extern TMC26XStepper stepperZ2;
|
||||
#define Z2_ENABLE_INIT() NOOP
|
||||
#define Z2_ENABLE_WRITE(STATE) stepperZ2.setEnabled(STATE)
|
||||
#define Z2_ENABLE_READ() stepperZ2.isEnabled()
|
||||
#endif
|
||||
|
||||
// Z3 Stepper
|
||||
#if HAS_Z3_ENABLE && AXIS_DRIVER_TYPE_Z3(TMC26X)
|
||||
extern TMC26XStepper stepperZ3;
|
||||
#define Z3_ENABLE_INIT() NOOP
|
||||
#define Z3_ENABLE_WRITE(STATE) stepperZ3.setEnabled(STATE)
|
||||
#define Z3_ENABLE_READ() stepperZ3.isEnabled()
|
||||
#endif
|
||||
|
||||
// Z4 Stepper
|
||||
#if HAS_Z4_ENABLE && AXIS_DRIVER_TYPE_Z4(TMC26X)
|
||||
extern TMC26XStepper stepperZ4;
|
||||
#define Z4_ENABLE_INIT() NOOP
|
||||
#define Z4_ENABLE_WRITE(STATE) stepperZ4.setEnabled(STATE)
|
||||
#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
|
||||
|
||||
// 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;
|
||||
#define E0_ENABLE_INIT() NOOP
|
||||
#define E0_ENABLE_WRITE(STATE) stepperE0.setEnabled(STATE)
|
||||
#define E0_ENABLE_READ() stepperE0.isEnabled()
|
||||
#endif
|
||||
|
||||
// E1 Stepper
|
||||
#if AXIS_DRIVER_TYPE_E1(TMC26X)
|
||||
extern TMC26XStepper stepperE1;
|
||||
#define E1_ENABLE_INIT() NOOP
|
||||
#define E1_ENABLE_WRITE(STATE) stepperE1.setEnabled(STATE)
|
||||
#define E1_ENABLE_READ() stepperE1.isEnabled()
|
||||
#endif
|
||||
|
||||
// E2 Stepper
|
||||
#if AXIS_DRIVER_TYPE_E2(TMC26X)
|
||||
extern TMC26XStepper stepperE2;
|
||||
#define E2_ENABLE_INIT() NOOP
|
||||
#define E2_ENABLE_WRITE(STATE) stepperE2.setEnabled(STATE)
|
||||
#define E2_ENABLE_READ() stepperE2.isEnabled()
|
||||
#endif
|
||||
|
||||
// E3 Stepper
|
||||
#if AXIS_DRIVER_TYPE_E3(TMC26X)
|
||||
extern TMC26XStepper stepperE3;
|
||||
#define E3_ENABLE_INIT() NOOP
|
||||
#define E3_ENABLE_WRITE(STATE) stepperE3.setEnabled(STATE)
|
||||
#define E3_ENABLE_READ() stepperE3.isEnabled()
|
||||
#endif
|
||||
|
||||
// E4 Stepper
|
||||
#if AXIS_DRIVER_TYPE_E4(TMC26X)
|
||||
extern TMC26XStepper stepperE4;
|
||||
#define E4_ENABLE_INIT() NOOP
|
||||
#define E4_ENABLE_WRITE(STATE) stepperE4.setEnabled(STATE)
|
||||
#define E4_ENABLE_READ() stepperE4.isEnabled()
|
||||
#endif
|
||||
|
||||
// E5 Stepper
|
||||
#if AXIS_DRIVER_TYPE_E5(TMC26X)
|
||||
extern TMC26XStepper stepperE5;
|
||||
#define E5_ENABLE_INIT() NOOP
|
||||
#define E5_ENABLE_WRITE(STATE) stepperE5.setEnabled(STATE)
|
||||
#define E5_ENABLE_READ() stepperE5.isEnabled()
|
||||
#endif
|
||||
|
||||
// E6 Stepper
|
||||
#if AXIS_DRIVER_TYPE_E6(TMC26X)
|
||||
extern TMC26XStepper stepperE6;
|
||||
#define E6_ENABLE_INIT() NOOP
|
||||
#define E6_ENABLE_WRITE(STATE) stepperE6.setEnabled(STATE)
|
||||
#define E6_ENABLE_READ() stepperE6.isEnabled()
|
||||
#endif
|
||||
|
||||
// E7 Stepper
|
||||
#if AXIS_DRIVER_TYPE_E7(TMC26X)
|
||||
extern TMC26XStepper stepperE7;
|
||||
#define E7_ENABLE_INIT() NOOP
|
||||
#define E7_ENABLE_WRITE(STATE) stepperE7.setEnabled(STATE)
|
||||
#define E7_ENABLE_READ() stepperE7.isEnabled()
|
||||
#endif
|
||||
@@ -0,0 +1,47 @@
|
||||
/**
|
||||
* Marlin 3D Printer Firmware
|
||||
* Copyright (c) 2020 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 <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* stepper/indirection.cpp
|
||||
*
|
||||
* Stepper motor driver indirection to allow some stepper functions to
|
||||
* be done via SPI/I2c instead of direct pin manipulation.
|
||||
*
|
||||
* Copyright (c) 2015 Dominik Wenger
|
||||
*/
|
||||
|
||||
#include "../../inc/MarlinConfig.h"
|
||||
#include "indirection.h"
|
||||
|
||||
void restore_stepper_drivers() {
|
||||
TERN_(HAS_TRINAMIC_CONFIG, restore_trinamic_drivers());
|
||||
}
|
||||
|
||||
void reset_stepper_drivers() {
|
||||
TERN_(HAS_TMC26X, tmc26x_init_to_defaults());
|
||||
TERN_(HAS_TRINAMIC_CONFIG, reset_trinamic_drivers());
|
||||
}
|
||||
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
// Flags to optimize axis enabled state
|
||||
xyz_bool_t axis_sw_enabled; // = { false, false, false }
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,168 @@
|
||||
/**
|
||||
* Marlin 3D Printer Firmware
|
||||
* Copyright (c) 2020 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 <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
#if F_CPU == 16000000
|
||||
|
||||
const uint16_t speed_lookuptable_fast[256][2] PROGMEM = {
|
||||
{ 62500, 55556}, { 6944, 3268}, { 3676, 1176}, { 2500, 607}, { 1893, 369}, { 1524, 249}, { 1275, 179}, { 1096, 135},
|
||||
{ 961, 105}, { 856, 85}, { 771, 69}, { 702, 58}, { 644, 49}, { 595, 42}, { 553, 37}, { 516, 32},
|
||||
{ 484, 28}, { 456, 25}, { 431, 23}, { 408, 20}, { 388, 19}, { 369, 16}, { 353, 16}, { 337, 14},
|
||||
{ 323, 13}, { 310, 11}, { 299, 11}, { 288, 11}, { 277, 9}, { 268, 9}, { 259, 8}, { 251, 8},
|
||||
{ 243, 8}, { 235, 7}, { 228, 6}, { 222, 6}, { 216, 6}, { 210, 6}, { 204, 5}, { 199, 5},
|
||||
{ 194, 5}, { 189, 4}, { 185, 4}, { 181, 4}, { 177, 4}, { 173, 4}, { 169, 4}, { 165, 3},
|
||||
{ 162, 3}, { 159, 4}, { 155, 3}, { 152, 3}, { 149, 2}, { 147, 3}, { 144, 3}, { 141, 2},
|
||||
{ 139, 3}, { 136, 2}, { 134, 2}, { 132, 3}, { 129, 2}, { 127, 2}, { 125, 2}, { 123, 2},
|
||||
{ 121, 2}, { 119, 1}, { 118, 2}, { 116, 2}, { 114, 1}, { 113, 2}, { 111, 2}, { 109, 1},
|
||||
{ 108, 2}, { 106, 1}, { 105, 2}, { 103, 1}, { 102, 1}, { 101, 1}, { 100, 2}, { 98, 1},
|
||||
{ 97, 1}, { 96, 1}, { 95, 2}, { 93, 1}, { 92, 1}, { 91, 1}, { 90, 1}, { 89, 1},
|
||||
{ 88, 1}, { 87, 1}, { 86, 1}, { 85, 1}, { 84, 1}, { 83, 0}, { 83, 1}, { 82, 1},
|
||||
{ 81, 1}, { 80, 1}, { 79, 1}, { 78, 0}, { 78, 1}, { 77, 1}, { 76, 1}, { 75, 0},
|
||||
{ 75, 1}, { 74, 1}, { 73, 1}, { 72, 0}, { 72, 1}, { 71, 1}, { 70, 0}, { 70, 1},
|
||||
{ 69, 0}, { 69, 1}, { 68, 1}, { 67, 0}, { 67, 1}, { 66, 0}, { 66, 1}, { 65, 0},
|
||||
{ 65, 1}, { 64, 1}, { 63, 0}, { 63, 1}, { 62, 0}, { 62, 1}, { 61, 0}, { 61, 1},
|
||||
{ 60, 0}, { 60, 0}, { 60, 1}, { 59, 0}, { 59, 1}, { 58, 0}, { 58, 1}, { 57, 0},
|
||||
{ 57, 1}, { 56, 0}, { 56, 0}, { 56, 1}, { 55, 0}, { 55, 1}, { 54, 0}, { 54, 0},
|
||||
{ 54, 1}, { 53, 0}, { 53, 0}, { 53, 1}, { 52, 0}, { 52, 0}, { 52, 1}, { 51, 0},
|
||||
{ 51, 0}, { 51, 1}, { 50, 0}, { 50, 0}, { 50, 1}, { 49, 0}, { 49, 0}, { 49, 1},
|
||||
{ 48, 0}, { 48, 0}, { 48, 1}, { 47, 0}, { 47, 0}, { 47, 0}, { 47, 1}, { 46, 0},
|
||||
{ 46, 0}, { 46, 1}, { 45, 0}, { 45, 0}, { 45, 0}, { 45, 1}, { 44, 0}, { 44, 0},
|
||||
{ 44, 0}, { 44, 1}, { 43, 0}, { 43, 0}, { 43, 0}, { 43, 1}, { 42, 0}, { 42, 0},
|
||||
{ 42, 0}, { 42, 1}, { 41, 0}, { 41, 0}, { 41, 0}, { 41, 0}, { 41, 1}, { 40, 0},
|
||||
{ 40, 0}, { 40, 0}, { 40, 0}, { 40, 1}, { 39, 0}, { 39, 0}, { 39, 0}, { 39, 0},
|
||||
{ 39, 1}, { 38, 0}, { 38, 0}, { 38, 0}, { 38, 0}, { 38, 1}, { 37, 0}, { 37, 0},
|
||||
{ 37, 0}, { 37, 0}, { 37, 0}, { 37, 1}, { 36, 0}, { 36, 0}, { 36, 0}, { 36, 0},
|
||||
{ 36, 1}, { 35, 0}, { 35, 0}, { 35, 0}, { 35, 0}, { 35, 0}, { 35, 0}, { 35, 1},
|
||||
{ 34, 0}, { 34, 0}, { 34, 0}, { 34, 0}, { 34, 0}, { 34, 1}, { 33, 0}, { 33, 0},
|
||||
{ 33, 0}, { 33, 0}, { 33, 0}, { 33, 0}, { 33, 1}, { 32, 0}, { 32, 0}, { 32, 0},
|
||||
{ 32, 0}, { 32, 0}, { 32, 0}, { 32, 0}, { 32, 1}, { 31, 0}, { 31, 0}, { 31, 0},
|
||||
{ 31, 0}, { 31, 0}, { 31, 0}, { 31, 1}, { 30, 0}, { 30, 0}, { 30, 0}, { 30, 0}
|
||||
};
|
||||
|
||||
const uint16_t speed_lookuptable_slow[256][2] PROGMEM = {
|
||||
{ 62500, 12500}, { 50000, 8334}, { 41666, 5952}, { 35714, 4464}, { 31250, 3473}, { 27777, 2777}, { 25000, 2273}, { 22727, 1894},
|
||||
{ 20833, 1603}, { 19230, 1373}, { 17857, 1191}, { 16666, 1041}, { 15625, 920}, { 14705, 817}, { 13888, 731}, { 13157, 657},
|
||||
{ 12500, 596}, { 11904, 541}, { 11363, 494}, { 10869, 453}, { 10416, 416}, { 10000, 385}, { 9615, 356}, { 9259, 331},
|
||||
{ 8928, 308}, { 8620, 287}, { 8333, 269}, { 8064, 252}, { 7812, 237}, { 7575, 223}, { 7352, 210}, { 7142, 198},
|
||||
{ 6944, 188}, { 6756, 178}, { 6578, 168}, { 6410, 160}, { 6250, 153}, { 6097, 145}, { 5952, 139}, { 5813, 132},
|
||||
{ 5681, 126}, { 5555, 121}, { 5434, 115}, { 5319, 111}, { 5208, 106}, { 5102, 102}, { 5000, 99}, { 4901, 94},
|
||||
{ 4807, 91}, { 4716, 87}, { 4629, 84}, { 4545, 81}, { 4464, 79}, { 4385, 75}, { 4310, 73}, { 4237, 71},
|
||||
{ 4166, 68}, { 4098, 66}, { 4032, 64}, { 3968, 62}, { 3906, 60}, { 3846, 59}, { 3787, 56}, { 3731, 55},
|
||||
{ 3676, 53}, { 3623, 52}, { 3571, 50}, { 3521, 49}, { 3472, 48}, { 3424, 46}, { 3378, 45}, { 3333, 44},
|
||||
{ 3289, 43}, { 3246, 41}, { 3205, 41}, { 3164, 39}, { 3125, 39}, { 3086, 38}, { 3048, 36}, { 3012, 36},
|
||||
{ 2976, 35}, { 2941, 35}, { 2906, 33}, { 2873, 33}, { 2840, 32}, { 2808, 31}, { 2777, 30}, { 2747, 30},
|
||||
{ 2717, 29}, { 2688, 29}, { 2659, 28}, { 2631, 27}, { 2604, 27}, { 2577, 26}, { 2551, 26}, { 2525, 25},
|
||||
{ 2500, 25}, { 2475, 25}, { 2450, 23}, { 2427, 24}, { 2403, 23}, { 2380, 22}, { 2358, 22}, { 2336, 22},
|
||||
{ 2314, 21}, { 2293, 21}, { 2272, 20}, { 2252, 20}, { 2232, 20}, { 2212, 20}, { 2192, 19}, { 2173, 18},
|
||||
{ 2155, 19}, { 2136, 18}, { 2118, 18}, { 2100, 17}, { 2083, 17}, { 2066, 17}, { 2049, 17}, { 2032, 16},
|
||||
{ 2016, 16}, { 2000, 16}, { 1984, 16}, { 1968, 15}, { 1953, 16}, { 1937, 14}, { 1923, 15}, { 1908, 15},
|
||||
{ 1893, 14}, { 1879, 14}, { 1865, 14}, { 1851, 13}, { 1838, 14}, { 1824, 13}, { 1811, 13}, { 1798, 13},
|
||||
{ 1785, 12}, { 1773, 13}, { 1760, 12}, { 1748, 12}, { 1736, 12}, { 1724, 12}, { 1712, 12}, { 1700, 11},
|
||||
{ 1689, 12}, { 1677, 11}, { 1666, 11}, { 1655, 11}, { 1644, 11}, { 1633, 10}, { 1623, 11}, { 1612, 10},
|
||||
{ 1602, 10}, { 1592, 10}, { 1582, 10}, { 1572, 10}, { 1562, 10}, { 1552, 9}, { 1543, 10}, { 1533, 9},
|
||||
{ 1524, 9}, { 1515, 9}, { 1506, 9}, { 1497, 9}, { 1488, 9}, { 1479, 9}, { 1470, 9}, { 1461, 8},
|
||||
{ 1453, 8}, { 1445, 9}, { 1436, 8}, { 1428, 8}, { 1420, 8}, { 1412, 8}, { 1404, 8}, { 1396, 8},
|
||||
{ 1388, 7}, { 1381, 8}, { 1373, 7}, { 1366, 8}, { 1358, 7}, { 1351, 7}, { 1344, 8}, { 1336, 7},
|
||||
{ 1329, 7}, { 1322, 7}, { 1315, 7}, { 1308, 6}, { 1302, 7}, { 1295, 7}, { 1288, 6}, { 1282, 7},
|
||||
{ 1275, 6}, { 1269, 7}, { 1262, 6}, { 1256, 6}, { 1250, 7}, { 1243, 6}, { 1237, 6}, { 1231, 6},
|
||||
{ 1225, 6}, { 1219, 6}, { 1213, 6}, { 1207, 6}, { 1201, 5}, { 1196, 6}, { 1190, 6}, { 1184, 5},
|
||||
{ 1179, 6}, { 1173, 5}, { 1168, 6}, { 1162, 5}, { 1157, 5}, { 1152, 6}, { 1146, 5}, { 1141, 5},
|
||||
{ 1136, 5}, { 1131, 5}, { 1126, 5}, { 1121, 5}, { 1116, 5}, { 1111, 5}, { 1106, 5}, { 1101, 5},
|
||||
{ 1096, 5}, { 1091, 5}, { 1086, 4}, { 1082, 5}, { 1077, 5}, { 1072, 4}, { 1068, 5}, { 1063, 4},
|
||||
{ 1059, 5}, { 1054, 4}, { 1050, 4}, { 1046, 5}, { 1041, 4}, { 1037, 4}, { 1033, 5}, { 1028, 4},
|
||||
{ 1024, 4}, { 1020, 4}, { 1016, 4}, { 1012, 4}, { 1008, 4}, { 1004, 4}, { 1000, 4}, { 996, 4},
|
||||
{ 992, 4}, { 988, 4}, { 984, 4}, { 980, 4}, { 976, 4}, { 972, 4}, { 968, 3}, { 965, 3}
|
||||
};
|
||||
|
||||
#elif F_CPU == 20000000
|
||||
|
||||
const uint16_t speed_lookuptable_fast[256][2] PROGMEM = {
|
||||
{62500, 54055}, {8445, 3917}, {4528, 1434}, {3094, 745}, {2349, 456}, {1893, 307}, {1586, 222}, {1364, 167},
|
||||
{1197, 131}, {1066, 105}, {961, 86}, {875, 72}, {803, 61}, {742, 53}, {689, 45}, {644, 40},
|
||||
{604, 35}, {569, 32}, {537, 28}, {509, 25}, {484, 23}, {461, 21}, {440, 19}, {421, 17},
|
||||
{404, 16}, {388, 15}, {373, 14}, {359, 13}, {346, 12}, {334, 11}, {323, 10}, {313, 10},
|
||||
{303, 9}, {294, 9}, {285, 8}, {277, 7}, {270, 8}, {262, 7}, {255, 6}, {249, 6},
|
||||
{243, 6}, {237, 6}, {231, 5}, {226, 5}, {221, 5}, {216, 5}, {211, 4}, {207, 5},
|
||||
{202, 4}, {198, 4}, {194, 4}, {190, 3}, {187, 4}, {183, 3}, {180, 3}, {177, 4},
|
||||
{173, 3}, {170, 3}, {167, 2}, {165, 3}, {162, 3}, {159, 2}, {157, 3}, {154, 2},
|
||||
{152, 3}, {149, 2}, {147, 2}, {145, 2}, {143, 2}, {141, 2}, {139, 2}, {137, 2},
|
||||
{135, 2}, {133, 2}, {131, 2}, {129, 1}, {128, 2}, {126, 2}, {124, 1}, {123, 2},
|
||||
{121, 1}, {120, 2}, {118, 1}, {117, 1}, {116, 2}, {114, 1}, {113, 1}, {112, 2},
|
||||
{110, 1}, {109, 1}, {108, 1}, {107, 2}, {105, 1}, {104, 1}, {103, 1}, {102, 1},
|
||||
{101, 1}, {100, 1}, {99, 1}, {98, 1}, {97, 1}, {96, 1}, {95, 1}, {94, 1},
|
||||
{93, 1}, {92, 1}, {91, 0}, {91, 1}, {90, 1}, {89, 1}, {88, 1}, {87, 0},
|
||||
{87, 1}, {86, 1}, {85, 1}, {84, 0}, {84, 1}, {83, 1}, {82, 1}, {81, 0},
|
||||
{81, 1}, {80, 1}, {79, 0}, {79, 1}, {78, 0}, {78, 1}, {77, 1}, {76, 0},
|
||||
{76, 1}, {75, 0}, {75, 1}, {74, 1}, {73, 0}, {73, 1}, {72, 0}, {72, 1},
|
||||
{71, 0}, {71, 1}, {70, 0}, {70, 1}, {69, 0}, {69, 1}, {68, 0}, {68, 1},
|
||||
{67, 0}, {67, 1}, {66, 0}, {66, 1}, {65, 0}, {65, 0}, {65, 1}, {64, 0},
|
||||
{64, 1}, {63, 0}, {63, 1}, {62, 0}, {62, 0}, {62, 1}, {61, 0}, {61, 1},
|
||||
{60, 0}, {60, 0}, {60, 1}, {59, 0}, {59, 0}, {59, 1}, {58, 0}, {58, 0},
|
||||
{58, 1}, {57, 0}, {57, 0}, {57, 1}, {56, 0}, {56, 0}, {56, 1}, {55, 0},
|
||||
{55, 0}, {55, 1}, {54, 0}, {54, 0}, {54, 1}, {53, 0}, {53, 0}, {53, 0},
|
||||
{53, 1}, {52, 0}, {52, 0}, {52, 1}, {51, 0}, {51, 0}, {51, 0}, {51, 1},
|
||||
{50, 0}, {50, 0}, {50, 0}, {50, 1}, {49, 0}, {49, 0}, {49, 0}, {49, 1},
|
||||
{48, 0}, {48, 0}, {48, 0}, {48, 1}, {47, 0}, {47, 0}, {47, 0}, {47, 1},
|
||||
{46, 0}, {46, 0}, {46, 0}, {46, 0}, {46, 1}, {45, 0}, {45, 0}, {45, 0},
|
||||
{45, 1}, {44, 0}, {44, 0}, {44, 0}, {44, 0}, {44, 1}, {43, 0}, {43, 0},
|
||||
{43, 0}, {43, 0}, {43, 1}, {42, 0}, {42, 0}, {42, 0}, {42, 0}, {42, 0},
|
||||
{42, 1}, {41, 0}, {41, 0}, {41, 0}, {41, 0}, {41, 0}, {41, 1}, {40, 0},
|
||||
{40, 0}, {40, 0}, {40, 0}, {40, 1}, {39, 0}, {39, 0}, {39, 0}, {39, 0},
|
||||
{39, 0}, {39, 0}, {39, 1}, {38, 0}, {38, 0}, {38, 0}, {38, 0}, {38, 0},
|
||||
};
|
||||
|
||||
const uint16_t speed_lookuptable_slow[256][2] PROGMEM = {
|
||||
{62500, 10417}, {52083, 7441}, {44642, 5580}, {39062, 4340}, {34722, 3472}, {31250, 2841}, {28409, 2368}, {26041, 2003},
|
||||
{24038, 1717}, {22321, 1488}, {20833, 1302}, {19531, 1149}, {18382, 1021}, {17361, 914}, {16447, 822}, {15625, 745},
|
||||
{14880, 676}, {14204, 618}, {13586, 566}, {13020, 520}, {12500, 481}, {12019, 445}, {11574, 414}, {11160, 385},
|
||||
{10775, 359}, {10416, 336}, {10080, 315}, {9765, 296}, {9469, 278}, {9191, 263}, {8928, 248}, {8680, 235},
|
||||
{8445, 222}, {8223, 211}, {8012, 200}, {7812, 191}, {7621, 181}, {7440, 173}, {7267, 165}, {7102, 158},
|
||||
{6944, 151}, {6793, 145}, {6648, 138}, {6510, 133}, {6377, 127}, {6250, 123}, {6127, 118}, {6009, 113},
|
||||
{5896, 109}, {5787, 106}, {5681, 101}, {5580, 98}, {5482, 95}, {5387, 91}, {5296, 88}, {5208, 86},
|
||||
{5122, 82}, {5040, 80}, {4960, 78}, {4882, 75}, {4807, 73}, {4734, 70}, {4664, 69}, {4595, 67},
|
||||
{4528, 64}, {4464, 63}, {4401, 61}, {4340, 60}, {4280, 58}, {4222, 56}, {4166, 55}, {4111, 53},
|
||||
{4058, 52}, {4006, 51}, {3955, 49}, {3906, 48}, {3858, 48}, {3810, 45}, {3765, 45}, {3720, 44},
|
||||
{3676, 43}, {3633, 42}, {3591, 40}, {3551, 40}, {3511, 39}, {3472, 38}, {3434, 38}, {3396, 36},
|
||||
{3360, 36}, {3324, 35}, {3289, 34}, {3255, 34}, {3221, 33}, {3188, 32}, {3156, 31}, {3125, 31},
|
||||
{3094, 31}, {3063, 30}, {3033, 29}, {3004, 28}, {2976, 28}, {2948, 28}, {2920, 27}, {2893, 27},
|
||||
{2866, 26}, {2840, 25}, {2815, 25}, {2790, 25}, {2765, 24}, {2741, 24}, {2717, 24}, {2693, 23},
|
||||
{2670, 22}, {2648, 22}, {2626, 22}, {2604, 22}, {2582, 21}, {2561, 21}, {2540, 20}, {2520, 20},
|
||||
{2500, 20}, {2480, 20}, {2460, 19}, {2441, 19}, {2422, 19}, {2403, 18}, {2385, 18}, {2367, 18},
|
||||
{2349, 17}, {2332, 18}, {2314, 17}, {2297, 16}, {2281, 17}, {2264, 16}, {2248, 16}, {2232, 16},
|
||||
{2216, 16}, {2200, 15}, {2185, 15}, {2170, 15}, {2155, 15}, {2140, 15}, {2125, 14}, {2111, 14},
|
||||
{2097, 14}, {2083, 14}, {2069, 14}, {2055, 13}, {2042, 13}, {2029, 13}, {2016, 13}, {2003, 13},
|
||||
{1990, 13}, {1977, 12}, {1965, 12}, {1953, 13}, {1940, 11}, {1929, 12}, {1917, 12}, {1905, 12},
|
||||
{1893, 11}, {1882, 11}, {1871, 11}, {1860, 11}, {1849, 11}, {1838, 11}, {1827, 11}, {1816, 10},
|
||||
{1806, 11}, {1795, 10}, {1785, 10}, {1775, 10}, {1765, 10}, {1755, 10}, {1745, 9}, {1736, 10},
|
||||
{1726, 9}, {1717, 10}, {1707, 9}, {1698, 9}, {1689, 9}, {1680, 9}, {1671, 9}, {1662, 9},
|
||||
{1653, 9}, {1644, 8}, {1636, 9}, {1627, 8}, {1619, 9}, {1610, 8}, {1602, 8}, {1594, 8},
|
||||
{1586, 8}, {1578, 8}, {1570, 8}, {1562, 8}, {1554, 7}, {1547, 8}, {1539, 8}, {1531, 7},
|
||||
{1524, 8}, {1516, 7}, {1509, 7}, {1502, 7}, {1495, 7}, {1488, 7}, {1481, 7}, {1474, 7},
|
||||
{1467, 7}, {1460, 7}, {1453, 7}, {1446, 6}, {1440, 7}, {1433, 7}, {1426, 6}, {1420, 6},
|
||||
{1414, 7}, {1407, 6}, {1401, 6}, {1395, 7}, {1388, 6}, {1382, 6}, {1376, 6}, {1370, 6},
|
||||
{1364, 6}, {1358, 6}, {1352, 6}, {1346, 5}, {1341, 6}, {1335, 6}, {1329, 5}, {1324, 6},
|
||||
{1318, 5}, {1313, 6}, {1307, 5}, {1302, 6}, {1296, 5}, {1291, 5}, {1286, 6}, {1280, 5},
|
||||
{1275, 5}, {1270, 5}, {1265, 5}, {1260, 5}, {1255, 5}, {1250, 5}, {1245, 5}, {1240, 5},
|
||||
{1235, 5}, {1230, 5}, {1225, 5}, {1220, 5}, {1215, 4}, {1211, 5}, {1206, 5}, {1201, 5},
|
||||
};
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,465 @@
|
||||
/**
|
||||
* Marlin 3D Printer Firmware
|
||||
* Copyright (c) 2020 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 <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
/**
|
||||
* stepper/trinamic.h
|
||||
* Stepper driver indirection for Trinamic
|
||||
*/
|
||||
|
||||
#include <TMCStepper.h>
|
||||
#if TMCSTEPPER_VERSION < 0x000500
|
||||
#error "Update TMCStepper library to 0.5.0 or newer."
|
||||
#endif
|
||||
|
||||
#include "../../inc/MarlinConfig.h"
|
||||
#include "../../feature/tmc_util.h"
|
||||
|
||||
#define CLASS_TMC2130 TMC2130Stepper
|
||||
#define CLASS_TMC2160 TMC2160Stepper
|
||||
#define CLASS_TMC2208 TMC2208Stepper
|
||||
#define CLASS_TMC2209 TMC2209Stepper
|
||||
#define CLASS_TMC2660 TMC2660Stepper
|
||||
#define CLASS_TMC5130 TMC5130Stepper
|
||||
#define CLASS_TMC5160 TMC5160Stepper
|
||||
|
||||
#define TMC_X_LABEL 'X', '0'
|
||||
#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_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'
|
||||
#define TMC_Z2_LABEL 'Z', '2'
|
||||
#define TMC_Z3_LABEL 'Z', '3'
|
||||
#define TMC_Z4_LABEL 'Z', '4'
|
||||
|
||||
#define TMC_E0_LABEL 'E', '0'
|
||||
#define TMC_E1_LABEL 'E', '1'
|
||||
#define TMC_E2_LABEL 'E', '2'
|
||||
#define TMC_E3_LABEL 'E', '3'
|
||||
#define TMC_E4_LABEL 'E', '4'
|
||||
#define TMC_E5_LABEL 'E', '5'
|
||||
#define TMC_E6_LABEL 'E', '6'
|
||||
#define TMC_E7_LABEL 'E', '7'
|
||||
|
||||
#define __TMC_CLASS(TYPE, L, I, A) TMCMarlin<CLASS_##TYPE, L, I, A>
|
||||
#define _TMC_CLASS(TYPE, LandI, A) __TMC_CLASS(TYPE, LandI, A)
|
||||
#define TMC_CLASS(ST, A) _TMC_CLASS(ST##_DRIVER_TYPE, TMC_##ST##_LABEL, A##_AXIS)
|
||||
#if ENABLED(DISTINCT_E_FACTORS)
|
||||
#define TMC_CLASS_E(N) TMC_CLASS(E##N, E##N)
|
||||
#else
|
||||
#define TMC_CLASS_E(N) TMC_CLASS(E##N, E)
|
||||
#endif
|
||||
|
||||
#if HAS_X_AXIS && !defined(CHOPPER_TIMING_X)
|
||||
#define CHOPPER_TIMING_X CHOPPER_TIMING
|
||||
#endif
|
||||
#if HAS_Y_AXIS && !defined(CHOPPER_TIMING_Y)
|
||||
#define CHOPPER_TIMING_Y CHOPPER_TIMING
|
||||
#endif
|
||||
#if HAS_Z_AXIS && !defined(CHOPPER_TIMING_Z)
|
||||
#define CHOPPER_TIMING_Z CHOPPER_TIMING
|
||||
#endif
|
||||
#if HAS_I_AXIS && !defined(CHOPPER_TIMING_I)
|
||||
#define CHOPPER_TIMING_I CHOPPER_TIMING
|
||||
#endif
|
||||
#if HAS_J_AXIS && !defined(CHOPPER_TIMING_J)
|
||||
#define CHOPPER_TIMING_J CHOPPER_TIMING
|
||||
#endif
|
||||
#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
|
||||
|
||||
#if HAS_TMC220x
|
||||
void tmc_serial_begin();
|
||||
#endif
|
||||
|
||||
void restore_trinamic_drivers();
|
||||
void reset_trinamic_drivers();
|
||||
|
||||
#define AXIS_HAS_DEDGE(A) (AXIS_IS_TMC(A) && ENABLED(SQUARE_WAVE_STEPPING))
|
||||
|
||||
// X Stepper
|
||||
#if AXIS_IS_TMC(X)
|
||||
extern TMC_CLASS(X, X) stepperX;
|
||||
static constexpr chopper_timing_t chopper_timing_X = CHOPPER_TIMING_X;
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
#define X_ENABLE_INIT() NOOP
|
||||
#define X_ENABLE_WRITE(STATE) stepperX.toff((STATE)==X_ENABLE_ON ? chopper_timing_X.toff : 0)
|
||||
#define X_ENABLE_READ() stepperX.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_DEDGE(X)
|
||||
#define X_STEP_WRITE(STATE) do{ if (STATE) TOGGLE(X_STEP_PIN); }while(0)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Y Stepper
|
||||
#if AXIS_IS_TMC(Y)
|
||||
extern TMC_CLASS(Y, Y) stepperY;
|
||||
static constexpr chopper_timing_t chopper_timing_Y = CHOPPER_TIMING_Y;
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
#define Y_ENABLE_INIT() NOOP
|
||||
#define Y_ENABLE_WRITE(STATE) stepperY.toff((STATE)==Y_ENABLE_ON ? chopper_timing_Y.toff : 0)
|
||||
#define Y_ENABLE_READ() stepperY.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_DEDGE(Y)
|
||||
#define Y_STEP_WRITE(STATE) do{ if (STATE) TOGGLE(Y_STEP_PIN); }while(0)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Z Stepper
|
||||
#if AXIS_IS_TMC(Z)
|
||||
extern TMC_CLASS(Z, Z) stepperZ;
|
||||
static constexpr chopper_timing_t chopper_timing_Z = CHOPPER_TIMING_Z;
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
#define Z_ENABLE_INIT() NOOP
|
||||
#define Z_ENABLE_WRITE(STATE) stepperZ.toff((STATE)==Z_ENABLE_ON ? chopper_timing_Z.toff : 0)
|
||||
#define Z_ENABLE_READ() stepperZ.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_DEDGE(Z)
|
||||
#define Z_STEP_WRITE(STATE) do{ if (STATE) TOGGLE(Z_STEP_PIN); }while(0)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// X2 Stepper
|
||||
#if HAS_X2_ENABLE && AXIS_IS_TMC(X2)
|
||||
extern TMC_CLASS(X2, X) stepperX2;
|
||||
#ifndef CHOPPER_TIMING_X2
|
||||
#define CHOPPER_TIMING_X2 CHOPPER_TIMING_X
|
||||
#endif
|
||||
static constexpr chopper_timing_t chopper_timing_X2 = CHOPPER_TIMING_X2;
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
#define X2_ENABLE_INIT() NOOP
|
||||
#define X2_ENABLE_WRITE(STATE) stepperX2.toff((STATE)==X_ENABLE_ON ? chopper_timing_X2.toff : 0)
|
||||
#define X2_ENABLE_READ() stepperX2.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_DEDGE(X2)
|
||||
#define X2_STEP_WRITE(STATE) do{ if (STATE) TOGGLE(X2_STEP_PIN); }while(0)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Y2 Stepper
|
||||
#if HAS_Y2_ENABLE && AXIS_IS_TMC(Y2)
|
||||
extern TMC_CLASS(Y2, Y) stepperY2;
|
||||
#ifndef CHOPPER_TIMING_Y2
|
||||
#define CHOPPER_TIMING_Y2 CHOPPER_TIMING_Y
|
||||
#endif
|
||||
static constexpr chopper_timing_t chopper_timing_Y2 = CHOPPER_TIMING_Y2;
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
#define Y2_ENABLE_INIT() NOOP
|
||||
#define Y2_ENABLE_WRITE(STATE) stepperY2.toff((STATE)==Y_ENABLE_ON ? chopper_timing_Y2.toff : 0)
|
||||
#define Y2_ENABLE_READ() stepperY2.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_DEDGE(Y2)
|
||||
#define Y2_STEP_WRITE(STATE) do{ if (STATE) TOGGLE(Y2_STEP_PIN); }while(0)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Z2 Stepper
|
||||
#if HAS_Z2_ENABLE && AXIS_IS_TMC(Z2)
|
||||
extern TMC_CLASS(Z2, Z) stepperZ2;
|
||||
#ifndef CHOPPER_TIMING_Z2
|
||||
#define CHOPPER_TIMING_Z2 CHOPPER_TIMING_Z
|
||||
#endif
|
||||
static constexpr chopper_timing_t chopper_timing_Z2 = CHOPPER_TIMING_Z2;
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
#define Z2_ENABLE_INIT() NOOP
|
||||
#define Z2_ENABLE_WRITE(STATE) stepperZ2.toff((STATE)==Z_ENABLE_ON ? chopper_timing_Z2.toff : 0)
|
||||
#define Z2_ENABLE_READ() stepperZ2.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_DEDGE(Z2)
|
||||
#define Z2_STEP_WRITE(STATE) do{ if (STATE) TOGGLE(Z2_STEP_PIN); }while(0)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Z3 Stepper
|
||||
#if HAS_Z3_ENABLE && AXIS_IS_TMC(Z3)
|
||||
extern TMC_CLASS(Z3, Z) stepperZ3;
|
||||
#ifndef CHOPPER_TIMING_Z3
|
||||
#define CHOPPER_TIMING_Z3 CHOPPER_TIMING_Z
|
||||
#endif
|
||||
static constexpr chopper_timing_t chopper_timing_Z3 = CHOPPER_TIMING_Z3;
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
#define Z3_ENABLE_INIT() NOOP
|
||||
#define Z3_ENABLE_WRITE(STATE) stepperZ3.toff((STATE)==Z_ENABLE_ON ? chopper_timing_Z3.toff : 0)
|
||||
#define Z3_ENABLE_READ() stepperZ3.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_DEDGE(Z3)
|
||||
#define Z3_STEP_WRITE(STATE) do{ if (STATE) TOGGLE(Z3_STEP_PIN); }while(0)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Z4 Stepper
|
||||
#if HAS_Z4_ENABLE && AXIS_IS_TMC(Z4)
|
||||
extern TMC_CLASS(Z4, Z) stepperZ4;
|
||||
#ifndef CHOPPER_TIMING_Z4
|
||||
#define CHOPPER_TIMING_Z4 CHOPPER_TIMING_Z
|
||||
#endif
|
||||
static constexpr chopper_timing_t chopper_timing_Z4 = CHOPPER_TIMING_Z4;
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
#define Z4_ENABLE_INIT() NOOP
|
||||
#define Z4_ENABLE_WRITE(STATE) stepperZ4.toff((STATE)==Z_ENABLE_ON ? chopper_timing_Z4.toff : 0)
|
||||
#define Z4_ENABLE_READ() stepperZ4.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_DEDGE(Z4)
|
||||
#define Z4_STEP_WRITE(STATE) do{ if (STATE) TOGGLE(Z4_STEP_PIN); }while(0)
|
||||
#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_I.toff : 0)
|
||||
#define I_ENABLE_READ() stepperI.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_DEDGE(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_J.toff : 0)
|
||||
#define J_ENABLE_READ() stepperJ.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_DEDGE(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_K.toff : 0)
|
||||
#define K_ENABLE_READ() stepperK.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_DEDGE(K)
|
||||
#define K_STEP_WRITE(STATE) do{ if (STATE) TOGGLE(K_STEP_PIN); }while(0)
|
||||
#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_DEDGE(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_DEDGE(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_DEDGE(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;
|
||||
#ifndef CHOPPER_TIMING_E0
|
||||
#define CHOPPER_TIMING_E0 CHOPPER_TIMING_E
|
||||
#endif
|
||||
static constexpr chopper_timing_t chopper_timing_E0 = CHOPPER_TIMING_E0;
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
#define E0_ENABLE_INIT() NOOP
|
||||
#define E0_ENABLE_WRITE(STATE) stepperE0.toff((STATE)==E_ENABLE_ON ? chopper_timing_E0.toff : 0)
|
||||
#define E0_ENABLE_READ() stepperE0.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_DEDGE(E0)
|
||||
#define E0_STEP_WRITE(STATE) do{ if (STATE) TOGGLE(E0_STEP_PIN); }while(0)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// E1 Stepper
|
||||
#if AXIS_IS_TMC(E1)
|
||||
extern TMC_CLASS_E(1) stepperE1;
|
||||
#ifndef CHOPPER_TIMING_E1
|
||||
#define CHOPPER_TIMING_E1 CHOPPER_TIMING_E
|
||||
#endif
|
||||
static constexpr chopper_timing_t chopper_timing_E1 = CHOPPER_TIMING_E1;
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
#define E1_ENABLE_INIT() NOOP
|
||||
#define E1_ENABLE_WRITE(STATE) stepperE1.toff((STATE)==E_ENABLE_ON ? chopper_timing_E1.toff : 0)
|
||||
#define E1_ENABLE_READ() stepperE1.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_DEDGE(E1)
|
||||
#define E1_STEP_WRITE(STATE) do{ if (STATE) TOGGLE(E1_STEP_PIN); }while(0)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// E2 Stepper
|
||||
#if AXIS_IS_TMC(E2)
|
||||
extern TMC_CLASS_E(2) stepperE2;
|
||||
#ifndef CHOPPER_TIMING_E2
|
||||
#define CHOPPER_TIMING_E2 CHOPPER_TIMING_E
|
||||
#endif
|
||||
static constexpr chopper_timing_t chopper_timing_E2 = CHOPPER_TIMING_E2;
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
#define E2_ENABLE_INIT() NOOP
|
||||
#define E2_ENABLE_WRITE(STATE) stepperE2.toff((STATE)==E_ENABLE_ON ? chopper_timing_E2.toff : 0)
|
||||
#define E2_ENABLE_READ() stepperE2.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_DEDGE(E2)
|
||||
#define E2_STEP_WRITE(STATE) do{ if (STATE) TOGGLE(E2_STEP_PIN); }while(0)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// E3 Stepper
|
||||
#if AXIS_IS_TMC(E3)
|
||||
extern TMC_CLASS_E(3) stepperE3;
|
||||
#ifndef CHOPPER_TIMING_E3
|
||||
#define CHOPPER_TIMING_E3 CHOPPER_TIMING_E
|
||||
#endif
|
||||
static constexpr chopper_timing_t chopper_timing_E3 = CHOPPER_TIMING_E3;
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
#define E3_ENABLE_INIT() NOOP
|
||||
#define E3_ENABLE_WRITE(STATE) stepperE3.toff((STATE)==E_ENABLE_ON ? chopper_timing_E3.toff : 0)
|
||||
#define E3_ENABLE_READ() stepperE3.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_DEDGE(E3)
|
||||
#define E3_STEP_WRITE(STATE) do{ if (STATE) TOGGLE(E3_STEP_PIN); }while(0)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// E4 Stepper
|
||||
#if AXIS_IS_TMC(E4)
|
||||
extern TMC_CLASS_E(4) stepperE4;
|
||||
#ifndef CHOPPER_TIMING_E4
|
||||
#define CHOPPER_TIMING_E4 CHOPPER_TIMING_E
|
||||
#endif
|
||||
static constexpr chopper_timing_t chopper_timing_E4 = CHOPPER_TIMING_E4;
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
#define E4_ENABLE_INIT() NOOP
|
||||
#define E4_ENABLE_WRITE(STATE) stepperE4.toff((STATE)==E_ENABLE_ON ? chopper_timing_E4.toff : 0)
|
||||
#define E4_ENABLE_READ() stepperE4.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_DEDGE(E4)
|
||||
#define E4_STEP_WRITE(STATE) do{ if (STATE) TOGGLE(E4_STEP_PIN); }while(0)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// E5 Stepper
|
||||
#if AXIS_IS_TMC(E5)
|
||||
extern TMC_CLASS_E(5) stepperE5;
|
||||
#ifndef CHOPPER_TIMING_E5
|
||||
#define CHOPPER_TIMING_E5 CHOPPER_TIMING_E
|
||||
#endif
|
||||
static constexpr chopper_timing_t chopper_timing_E5 = CHOPPER_TIMING_E5;
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
#define E5_ENABLE_INIT() NOOP
|
||||
#define E5_ENABLE_WRITE(STATE) stepperE5.toff((STATE)==E_ENABLE_ON ? chopper_timing_E5.toff : 0)
|
||||
#define E5_ENABLE_READ() stepperE5.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_DEDGE(E5)
|
||||
#define E5_STEP_WRITE(STATE) do{ if (STATE) TOGGLE(E5_STEP_PIN); }while(0)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// E6 Stepper
|
||||
#if AXIS_IS_TMC(E6)
|
||||
extern TMC_CLASS_E(6) stepperE6;
|
||||
#ifndef CHOPPER_TIMING_E6
|
||||
#define CHOPPER_TIMING_E6 CHOPPER_TIMING_E
|
||||
#endif
|
||||
static constexpr chopper_timing_t chopper_timing_E6 = CHOPPER_TIMING_E6;
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
#define E6_ENABLE_INIT() NOOP
|
||||
#define E6_ENABLE_WRITE(STATE) stepperE6.toff((STATE)==E_ENABLE_ON ? chopper_timing_E6.toff : 0)
|
||||
#define E6_ENABLE_READ() stepperE6.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_DEDGE(E6)
|
||||
#define E6_STEP_WRITE(STATE) do{ if (STATE) TOGGLE(E6_STEP_PIN); }while(0)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// E7 Stepper
|
||||
#if AXIS_IS_TMC(E7)
|
||||
extern TMC_CLASS_E(7) stepperE7;
|
||||
#ifndef CHOPPER_TIMING_E7
|
||||
#define CHOPPER_TIMING_E7 CHOPPER_TIMING_E
|
||||
#endif
|
||||
static constexpr chopper_timing_t chopper_timing_E7 = CHOPPER_TIMING_E7;
|
||||
#if ENABLED(SOFTWARE_DRIVER_ENABLE)
|
||||
#define E7_ENABLE_INIT() NOOP
|
||||
#define E7_ENABLE_WRITE(STATE) stepperE7.toff((STATE)==E_ENABLE_ON ? chopper_timing_E7.toff : 0)
|
||||
#define E7_ENABLE_READ() stepperE7.isEnabled()
|
||||
#endif
|
||||
#if AXIS_HAS_DEDGE(E7)
|
||||
#define E7_STEP_WRITE(STATE) do{ if (STATE) TOGGLE(E7_STEP_PIN); }while(0)
|
||||
#endif
|
||||
#endif
|
||||
Reference in New Issue
Block a user