|
|
|
@ -34,7 +34,10 @@ |
|
|
|
|
|
|
|
#if ENABLED(TMC_DEBUG) |
|
|
|
#include "../module/planner.h" |
|
|
|
static bool report_tmc_status; // = false;
|
|
|
|
#include "../libs/hex_print_routines.h" |
|
|
|
#if ENABLED(MONITOR_DRIVER_STATUS) |
|
|
|
static bool report_tmc_status; // = false;
|
|
|
|
#endif |
|
|
|
#endif |
|
|
|
|
|
|
|
/**
|
|
|
|
@ -130,7 +133,7 @@ |
|
|
|
if (data.is_s2ga) SERIAL_ECHOLNPGM("short to ground (coil A)"); |
|
|
|
if (data.is_s2gb) SERIAL_ECHOLNPGM("short to ground (coil B)"); |
|
|
|
#if ENABLED(TMC_DEBUG) |
|
|
|
tmc_report_all(); |
|
|
|
tmc_report_all(true, true, true, true); |
|
|
|
#endif |
|
|
|
kill(PSTR("Driver error")); |
|
|
|
} |
|
|
|
@ -326,16 +329,28 @@ |
|
|
|
TMC_S2VSB, |
|
|
|
TMC_S2VSA |
|
|
|
}; |
|
|
|
static void drv_status_print_hex(const uint32_t drv_status) { |
|
|
|
for (int B = 24; B >= 8; B -= 8){ |
|
|
|
SERIAL_PRINT((drv_status >> (B + 4)) & 0xF, HEX); |
|
|
|
SERIAL_PRINT((drv_status >> B) & 0xF, HEX); |
|
|
|
SERIAL_CHAR(':'); |
|
|
|
} |
|
|
|
SERIAL_PRINT((drv_status >> 4) & 0xF, HEX); |
|
|
|
SERIAL_PRINT((drv_status) & 0xF, HEX); |
|
|
|
SERIAL_EOL(); |
|
|
|
} |
|
|
|
enum TMC_get_registers_enum : char { |
|
|
|
TMC_AXIS_CODES, |
|
|
|
TMC_GET_GCONF, |
|
|
|
TMC_GET_IHOLD_IRUN, |
|
|
|
TMC_GET_GSTAT, |
|
|
|
TMC_GET_IOIN, |
|
|
|
TMC_GET_TPOWERDOWN, |
|
|
|
TMC_GET_TSTEP, |
|
|
|
TMC_GET_TPWMTHRS, |
|
|
|
TMC_GET_TCOOLTHRS, |
|
|
|
TMC_GET_THIGH, |
|
|
|
TMC_GET_CHOPCONF, |
|
|
|
TMC_GET_COOLCONF, |
|
|
|
TMC_GET_PWMCONF, |
|
|
|
TMC_GET_PWM_SCALE, |
|
|
|
TMC_GET_DRV_STATUS, |
|
|
|
TMC_GET_DRVCONF, |
|
|
|
TMC_GET_DRVCTRL, |
|
|
|
TMC_GET_DRVSTATUS, |
|
|
|
TMC_GET_SGCSCONF, |
|
|
|
TMC_GET_SMARTEN |
|
|
|
}; |
|
|
|
|
|
|
|
template<class TMC> |
|
|
|
static void print_vsense(TMC &st) { serialprintPGM(st.vsense() ? PSTR("1=.18") : PSTR("0=.325")); } |
|
|
|
@ -480,125 +495,146 @@ |
|
|
|
case TMC_S2GA: if (st.s2ga()) SERIAL_CHAR('X'); break; |
|
|
|
case TMC_DRV_OTPW: if (st.otpw()) SERIAL_CHAR('X'); break; |
|
|
|
case TMC_OT: if (st.ot()) SERIAL_CHAR('X'); break; |
|
|
|
case TMC_DRV_STATUS_HEX: |
|
|
|
case TMC_DRV_STATUS_HEX: { |
|
|
|
const uint32_t drv_status = st.DRV_STATUS(); |
|
|
|
SERIAL_CHAR('\t'); |
|
|
|
st.printLabel(); |
|
|
|
SERIAL_ECHOPGM("\t0x"); |
|
|
|
drv_status_print_hex(st.DRV_STATUS()); |
|
|
|
SERIAL_CHAR('\t'); |
|
|
|
print_hex_long(drv_status, ':'); |
|
|
|
if (drv_status == 0xFFFFFFFF || drv_status == 0) SERIAL_ECHOPGM("\t Bad response!"); |
|
|
|
SERIAL_EOL(); |
|
|
|
break; |
|
|
|
} |
|
|
|
default: _tmc_parse_drv_status(st, i); break; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
static void tmc_debug_loop(const TMC_debug_enum i) { |
|
|
|
#if AXIS_IS_TMC(X) |
|
|
|
tmc_status(stepperX, i, planner.settings.axis_steps_per_mm[X_AXIS]); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(X2) |
|
|
|
tmc_status(stepperX2, i, planner.settings.axis_steps_per_mm[X_AXIS]); |
|
|
|
#endif |
|
|
|
static void tmc_debug_loop(const TMC_debug_enum i, const bool print_x, const bool print_y, const bool print_z, const bool print_e) { |
|
|
|
if (print_x) { |
|
|
|
#if AXIS_IS_TMC(X) |
|
|
|
tmc_status(stepperX, i, planner.settings.axis_steps_per_mm[X_AXIS]); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(X2) |
|
|
|
tmc_status(stepperX2, i, planner.settings.axis_steps_per_mm[X_AXIS]); |
|
|
|
#endif |
|
|
|
} |
|
|
|
|
|
|
|
#if AXIS_IS_TMC(Y) |
|
|
|
tmc_status(stepperY, i, planner.settings.axis_steps_per_mm[Y_AXIS]); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(Y2) |
|
|
|
tmc_status(stepperY2, i, planner.settings.axis_steps_per_mm[Y_AXIS]); |
|
|
|
#endif |
|
|
|
if (print_y) { |
|
|
|
#if AXIS_IS_TMC(Y) |
|
|
|
tmc_status(stepperY, i, planner.settings.axis_steps_per_mm[Y_AXIS]); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(Y2) |
|
|
|
tmc_status(stepperY2, i, planner.settings.axis_steps_per_mm[Y_AXIS]); |
|
|
|
#endif |
|
|
|
} |
|
|
|
|
|
|
|
#if AXIS_IS_TMC(Z) |
|
|
|
tmc_status(stepperZ, i, planner.settings.axis_steps_per_mm[Z_AXIS]); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(Z2) |
|
|
|
tmc_status(stepperZ2, i, planner.settings.axis_steps_per_mm[Z_AXIS]); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(Z3) |
|
|
|
tmc_status(stepperZ3, i, planner.settings.axis_steps_per_mm[Z_AXIS]); |
|
|
|
#endif |
|
|
|
if (print_z) { |
|
|
|
#if AXIS_IS_TMC(Z) |
|
|
|
tmc_status(stepperZ, i, planner.settings.axis_steps_per_mm[Z_AXIS]); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(Z2) |
|
|
|
tmc_status(stepperZ2, i, planner.settings.axis_steps_per_mm[Z_AXIS]); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(Z3) |
|
|
|
tmc_status(stepperZ3, i, planner.settings.axis_steps_per_mm[Z_AXIS]); |
|
|
|
#endif |
|
|
|
} |
|
|
|
|
|
|
|
#if AXIS_IS_TMC(E0) |
|
|
|
tmc_status(stepperE0, i, planner.settings.axis_steps_per_mm[E_AXIS]); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E1) |
|
|
|
tmc_status(stepperE1, i, planner.settings.axis_steps_per_mm[E_AXIS |
|
|
|
#if ENABLED(DISTINCT_E_FACTORS) |
|
|
|
+ 1 |
|
|
|
#endif |
|
|
|
]); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E2) |
|
|
|
tmc_status(stepperE2, i, planner.settings.axis_steps_per_mm[E_AXIS |
|
|
|
#if ENABLED(DISTINCT_E_FACTORS) |
|
|
|
+ 2 |
|
|
|
#endif |
|
|
|
]); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E3) |
|
|
|
tmc_status(stepperE3, i, planner.settings.axis_steps_per_mm[E_AXIS |
|
|
|
#if ENABLED(DISTINCT_E_FACTORS) |
|
|
|
+ 3 |
|
|
|
#endif |
|
|
|
]); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E4) |
|
|
|
tmc_status(stepperE4, i, planner.settings.axis_steps_per_mm[E_AXIS |
|
|
|
#if ENABLED(DISTINCT_E_FACTORS) |
|
|
|
+ 4 |
|
|
|
#endif |
|
|
|
]); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E5) |
|
|
|
tmc_status(stepperE5, i, planner.settings.axis_steps_per_mm[E_AXIS |
|
|
|
#if ENABLED(DISTINCT_E_FACTORS) |
|
|
|
+ 5 |
|
|
|
#endif |
|
|
|
]); |
|
|
|
#endif |
|
|
|
if (print_e) { |
|
|
|
#if AXIS_IS_TMC(E0) |
|
|
|
tmc_status(stepperE0, i, planner.settings.axis_steps_per_mm[E_AXIS]); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E1) |
|
|
|
tmc_status(stepperE1, i, planner.settings.axis_steps_per_mm[E_AXIS |
|
|
|
#if ENABLED(DISTINCT_E_FACTORS) |
|
|
|
+ 1 |
|
|
|
#endif |
|
|
|
]); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E2) |
|
|
|
tmc_status(stepperE2, i, planner.settings.axis_steps_per_mm[E_AXIS |
|
|
|
#if ENABLED(DISTINCT_E_FACTORS) |
|
|
|
+ 2 |
|
|
|
#endif |
|
|
|
]); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E3) |
|
|
|
tmc_status(stepperE3, i, planner.settings.axis_steps_per_mm[E_AXIS |
|
|
|
#if ENABLED(DISTINCT_E_FACTORS) |
|
|
|
+ 3 |
|
|
|
#endif |
|
|
|
]); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E4) |
|
|
|
tmc_status(stepperE4, i, planner.settings.axis_steps_per_mm[E_AXIS |
|
|
|
#if ENABLED(DISTINCT_E_FACTORS) |
|
|
|
+ 4 |
|
|
|
#endif |
|
|
|
]); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E5) |
|
|
|
tmc_status(stepperE5, i, planner.settings.axis_steps_per_mm[E_AXIS |
|
|
|
#if ENABLED(DISTINCT_E_FACTORS) |
|
|
|
+ 5 |
|
|
|
#endif |
|
|
|
]); |
|
|
|
#endif |
|
|
|
} |
|
|
|
|
|
|
|
SERIAL_EOL(); |
|
|
|
} |
|
|
|
|
|
|
|
static void drv_status_loop(const TMC_drv_status_enum i) { |
|
|
|
#if AXIS_IS_TMC(X) |
|
|
|
tmc_parse_drv_status(stepperX, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(X2) |
|
|
|
tmc_parse_drv_status(stepperX2, i); |
|
|
|
#endif |
|
|
|
static void drv_status_loop(const TMC_drv_status_enum i, const bool print_x, const bool print_y, const bool print_z, const bool print_e) { |
|
|
|
if (print_x) { |
|
|
|
#if AXIS_IS_TMC(X) |
|
|
|
tmc_parse_drv_status(stepperX, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(X2) |
|
|
|
tmc_parse_drv_status(stepperX2, i); |
|
|
|
#endif |
|
|
|
} |
|
|
|
|
|
|
|
#if AXIS_IS_TMC(Y) |
|
|
|
tmc_parse_drv_status(stepperY, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(Y2) |
|
|
|
tmc_parse_drv_status(stepperY2, i); |
|
|
|
#endif |
|
|
|
if (print_y) { |
|
|
|
#if AXIS_IS_TMC(Y) |
|
|
|
tmc_parse_drv_status(stepperY, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(Y2) |
|
|
|
tmc_parse_drv_status(stepperY2, i); |
|
|
|
#endif |
|
|
|
} |
|
|
|
|
|
|
|
#if AXIS_IS_TMC(Z) |
|
|
|
tmc_parse_drv_status(stepperZ, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(Z2) |
|
|
|
tmc_parse_drv_status(stepperZ2, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(Z3) |
|
|
|
tmc_parse_drv_status(stepperZ3, i); |
|
|
|
#endif |
|
|
|
if (print_z) { |
|
|
|
#if AXIS_IS_TMC(Z) |
|
|
|
tmc_parse_drv_status(stepperZ, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(Z2) |
|
|
|
tmc_parse_drv_status(stepperZ2, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(Z3) |
|
|
|
tmc_parse_drv_status(stepperZ3, i); |
|
|
|
#endif |
|
|
|
} |
|
|
|
|
|
|
|
#if AXIS_IS_TMC(E0) |
|
|
|
tmc_parse_drv_status(stepperE0, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E1) |
|
|
|
tmc_parse_drv_status(stepperE1, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E2) |
|
|
|
tmc_parse_drv_status(stepperE2, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E3) |
|
|
|
tmc_parse_drv_status(stepperE3, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E4) |
|
|
|
tmc_parse_drv_status(stepperE4, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E5) |
|
|
|
tmc_parse_drv_status(stepperE5, i); |
|
|
|
#endif |
|
|
|
if (print_e) { |
|
|
|
#if AXIS_IS_TMC(E0) |
|
|
|
tmc_parse_drv_status(stepperE0, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E1) |
|
|
|
tmc_parse_drv_status(stepperE1, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E2) |
|
|
|
tmc_parse_drv_status(stepperE2, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E3) |
|
|
|
tmc_parse_drv_status(stepperE3, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E4) |
|
|
|
tmc_parse_drv_status(stepperE4, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E5) |
|
|
|
tmc_parse_drv_status(stepperE5, i); |
|
|
|
#endif |
|
|
|
} |
|
|
|
|
|
|
|
SERIAL_EOL(); |
|
|
|
} |
|
|
|
@ -607,9 +643,9 @@ |
|
|
|
* M122 report functions |
|
|
|
*/ |
|
|
|
|
|
|
|
void tmc_report_all() { |
|
|
|
#define TMC_REPORT(LABEL, ITEM) do{ SERIAL_ECHOPGM(LABEL); tmc_debug_loop(ITEM); }while(0) |
|
|
|
#define DRV_REPORT(LABEL, ITEM) do{ SERIAL_ECHOPGM(LABEL); drv_status_loop(ITEM); }while(0) |
|
|
|
void tmc_report_all(bool print_x, const bool print_y, const bool print_z, const bool print_e) { |
|
|
|
#define TMC_REPORT(LABEL, ITEM) do{ SERIAL_ECHOPGM(LABEL); tmc_debug_loop(ITEM, print_x, print_y, print_z, print_e); }while(0) |
|
|
|
#define DRV_REPORT(LABEL, ITEM) do{ SERIAL_ECHOPGM(LABEL); drv_status_loop(ITEM, print_x, print_y, print_z, print_e); }while(0) |
|
|
|
TMC_REPORT("\t", TMC_CODES); |
|
|
|
TMC_REPORT("Enabled\t", TMC_ENABLED); |
|
|
|
TMC_REPORT("Set current", TMC_CURRENT); |
|
|
|
@ -661,6 +697,135 @@ |
|
|
|
SERIAL_EOL(); |
|
|
|
} |
|
|
|
|
|
|
|
#define PRINT_TMC_REGISTER(REG_CASE) case TMC_GET_##REG_CASE: print_hex_long(st.REG_CASE(), ':'); break |
|
|
|
|
|
|
|
#if HAS_DRIVER(TMC2130) |
|
|
|
static void tmc_get_ic_registers(TMC2130Stepper &st, const TMC_get_registers_enum i) { |
|
|
|
switch (i) { |
|
|
|
PRINT_TMC_REGISTER(TCOOLTHRS); |
|
|
|
PRINT_TMC_REGISTER(THIGH); |
|
|
|
PRINT_TMC_REGISTER(COOLCONF); |
|
|
|
default: SERIAL_CHAR('\t'); break; |
|
|
|
} |
|
|
|
} |
|
|
|
#endif |
|
|
|
#if HAS_DRIVER(TMC2208) |
|
|
|
static void tmc_get_ic_registers(TMC2208Stepper, const TMC_get_registers_enum) { SERIAL_CHAR('\t'); } |
|
|
|
#endif |
|
|
|
|
|
|
|
#if HAS_TRINAMIC |
|
|
|
template<class TMC> |
|
|
|
static void tmc_get_registers(TMC &st, const TMC_get_registers_enum i) { |
|
|
|
switch (i) { |
|
|
|
case TMC_AXIS_CODES: SERIAL_CHAR('\t'); st.printLabel(); break; |
|
|
|
PRINT_TMC_REGISTER(GCONF); |
|
|
|
PRINT_TMC_REGISTER(IHOLD_IRUN); |
|
|
|
PRINT_TMC_REGISTER(GSTAT); |
|
|
|
PRINT_TMC_REGISTER(IOIN); |
|
|
|
PRINT_TMC_REGISTER(TPOWERDOWN); |
|
|
|
PRINT_TMC_REGISTER(TSTEP); |
|
|
|
PRINT_TMC_REGISTER(TPWMTHRS); |
|
|
|
PRINT_TMC_REGISTER(CHOPCONF); |
|
|
|
PRINT_TMC_REGISTER(PWMCONF); |
|
|
|
PRINT_TMC_REGISTER(PWM_SCALE); |
|
|
|
PRINT_TMC_REGISTER(DRV_STATUS); |
|
|
|
default: tmc_get_ic_registers(st, i); break; |
|
|
|
} |
|
|
|
SERIAL_CHAR('\t'); |
|
|
|
} |
|
|
|
#endif |
|
|
|
#if HAS_DRIVER(TMC2660) |
|
|
|
template <char AXIS_LETTER, char DRIVER_ID> |
|
|
|
static void tmc_get_registers(TMCMarlin<TMC2660Stepper, AXIS_LETTER, DRIVER_ID> &st, const TMC_get_registers_enum i) { |
|
|
|
switch (i) { |
|
|
|
case TMC_AXIS_CODES: SERIAL_CHAR('\t'); st.printLabel(); break; |
|
|
|
PRINT_TMC_REGISTER(DRVCONF); |
|
|
|
PRINT_TMC_REGISTER(DRVCTRL); |
|
|
|
PRINT_TMC_REGISTER(CHOPCONF); |
|
|
|
PRINT_TMC_REGISTER(DRVSTATUS); |
|
|
|
PRINT_TMC_REGISTER(SGCSCONF); |
|
|
|
PRINT_TMC_REGISTER(SMARTEN); |
|
|
|
default: SERIAL_CHAR('\t'); break; |
|
|
|
} |
|
|
|
SERIAL_CHAR('\t'); |
|
|
|
} |
|
|
|
#endif |
|
|
|
|
|
|
|
static void tmc_get_registers(TMC_get_registers_enum i, const bool print_x, const bool print_y, const bool print_z, const bool print_e) { |
|
|
|
if (print_x) { |
|
|
|
#if AXIS_IS_TMC(X) |
|
|
|
tmc_get_registers(stepperX, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(X2) |
|
|
|
tmc_get_registers(stepperX2, i); |
|
|
|
#endif |
|
|
|
} |
|
|
|
|
|
|
|
if (print_y) { |
|
|
|
#if AXIS_IS_TMC(Y) |
|
|
|
tmc_get_registers(stepperY, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(Y2) |
|
|
|
tmc_get_registers(stepperY2, i); |
|
|
|
#endif |
|
|
|
} |
|
|
|
|
|
|
|
if (print_z) { |
|
|
|
#if AXIS_IS_TMC(Z) |
|
|
|
tmc_get_registers(stepperZ, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(Z2) |
|
|
|
tmc_get_registers(stepperZ2, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(Z3) |
|
|
|
tmc_get_registers(stepperZ3, i); |
|
|
|
#endif |
|
|
|
} |
|
|
|
|
|
|
|
if (print_e) { |
|
|
|
#if AXIS_IS_TMC(E0) |
|
|
|
tmc_get_registers(stepperE0, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E1) |
|
|
|
tmc_get_registers(stepperE1, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E2) |
|
|
|
tmc_get_registers(stepperE2, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E3) |
|
|
|
tmc_get_registers(stepperE3, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E4) |
|
|
|
tmc_get_registers(stepperE4, i); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E5) |
|
|
|
tmc_get_registers(stepperE5, i); |
|
|
|
#endif |
|
|
|
} |
|
|
|
|
|
|
|
SERIAL_EOL(); |
|
|
|
} |
|
|
|
|
|
|
|
void tmc_get_registers(bool print_x, bool print_y, bool print_z, bool print_e) { |
|
|
|
#define _TMC_GET_REG(LABEL, ITEM) do{ SERIAL_ECHOPGM(LABEL); tmc_get_registers(ITEM, print_x, print_y, print_z, print_e); }while(0) |
|
|
|
#define TMC_GET_REG(NAME, TABS) _TMC_GET_REG(STRINGIFY(NAME) TABS, TMC_GET_##NAME) |
|
|
|
_TMC_GET_REG("\t", TMC_AXIS_CODES); |
|
|
|
TMC_GET_REG(GCONF, "\t\t"); |
|
|
|
TMC_GET_REG(IHOLD_IRUN, "\t"); |
|
|
|
TMC_GET_REG(GSTAT, "\t\t"); |
|
|
|
TMC_GET_REG(IOIN, "\t\t"); |
|
|
|
TMC_GET_REG(TPOWERDOWN, "\t"); |
|
|
|
TMC_GET_REG(TSTEP, "\t\t"); |
|
|
|
TMC_GET_REG(TPWMTHRS, "\t"); |
|
|
|
TMC_GET_REG(TCOOLTHRS, "\t"); |
|
|
|
TMC_GET_REG(THIGH, "\t\t"); |
|
|
|
TMC_GET_REG(CHOPCONF, "\t"); |
|
|
|
TMC_GET_REG(COOLCONF, "\t"); |
|
|
|
TMC_GET_REG(PWMCONF, "\t"); |
|
|
|
TMC_GET_REG(PWM_SCALE, "\t"); |
|
|
|
TMC_GET_REG(DRV_STATUS, "\t"); |
|
|
|
} |
|
|
|
|
|
|
|
#endif // TMC_DEBUG
|
|
|
|
|
|
|
|
#if USE_SENSORLESS |
|
|
|
@ -736,4 +901,83 @@ |
|
|
|
} |
|
|
|
#endif // TMC_HAS_SPI
|
|
|
|
|
|
|
|
template<typename TMC> |
|
|
|
static bool test_connection(TMC &st) { |
|
|
|
SERIAL_ECHOPGM("Testing "); |
|
|
|
st.printLabel(); |
|
|
|
SERIAL_ECHOPGM(" connection... "); |
|
|
|
const uint8_t test_result = st.test_connection(); |
|
|
|
|
|
|
|
if (test_result > 0) SERIAL_ECHOPGM("Error: All "); |
|
|
|
|
|
|
|
const char *stat; |
|
|
|
switch (test_result) { |
|
|
|
default: |
|
|
|
case 0: stat = PSTR("OK"); break; |
|
|
|
case 1: stat = PSTR("HIGH"); break; |
|
|
|
case 2: stat = PSTR("LOW"); break; |
|
|
|
} |
|
|
|
serialprintPGM(stat); |
|
|
|
SERIAL_EOL(); |
|
|
|
|
|
|
|
return test_result; |
|
|
|
} |
|
|
|
|
|
|
|
void test_tmc_connection(const bool test_x, const bool test_y, const bool test_z, const bool test_e) { |
|
|
|
uint8_t axis_connection = 0; |
|
|
|
|
|
|
|
if (test_x) { |
|
|
|
#if AXIS_IS_TMC(X) |
|
|
|
axis_connection += test_connection(stepperX); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(X2) |
|
|
|
axis_connection += test_connection(stepperX2); |
|
|
|
#endif |
|
|
|
} |
|
|
|
|
|
|
|
if (test_y) { |
|
|
|
#if AXIS_IS_TMC(Y) |
|
|
|
axis_connection += test_connection(stepperY); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(Y2) |
|
|
|
axis_connection += test_connection(stepperY2); |
|
|
|
#endif |
|
|
|
} |
|
|
|
|
|
|
|
if (test_z) { |
|
|
|
#if AXIS_IS_TMC(Z) |
|
|
|
axis_connection += test_connection(stepperZ); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(Z2) |
|
|
|
axis_connection += test_connection(stepperZ2); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(Z3) |
|
|
|
axis_connection += test_connection(stepperZ3); |
|
|
|
#endif |
|
|
|
} |
|
|
|
|
|
|
|
if (test_e) { |
|
|
|
#if AXIS_IS_TMC(E0) |
|
|
|
axis_connection += test_connection(stepperE0); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E1) |
|
|
|
axis_connection += test_connection(stepperE1); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E2) |
|
|
|
axis_connection += test_connection(stepperE2); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E3) |
|
|
|
axis_connection += test_connection(stepperE3); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E4) |
|
|
|
axis_connection += test_connection(stepperE4); |
|
|
|
#endif |
|
|
|
#if AXIS_IS_TMC(E5) |
|
|
|
axis_connection += test_connection(stepperE5); |
|
|
|
#endif |
|
|
|
} |
|
|
|
|
|
|
|
if (axis_connection) ui.set_status_P(PSTR("TMC CONNECTION ERROR")); |
|
|
|
} |
|
|
|
|
|
|
|
#endif // HAS_TRINAMIC
|
|
|
|
|
teemuatlut
6 years ago
Scott Lahteine