From 6a043eee558695e91f64b6f4a48fcd1816a5f130 Mon Sep 17 00:00:00 2001 From: Scott Lahteine Date: Tue, 9 Jan 2018 19:14:07 -0600 Subject: [PATCH] Various updates for TMC support --- Marlin/src/HAL/HAL_DUE/usb/sd_mmc_spi_mem.cpp | 4 +- Marlin/src/core/serial.h | 6 +- Marlin/src/feature/tmc_macros.h | 39 -- Marlin/src/feature/tmc_util.cpp | 419 ++++++++++++++++-- Marlin/src/feature/tmc_util.h | 54 +-- Marlin/src/gcode/feature/trinamic/M122.cpp | 315 +------------ Marlin/src/gcode/feature/trinamic/M906.cpp | 42 +- .../src/gcode/feature/trinamic/M911-M915.cpp | 59 +-- Marlin/src/inc/Conditionals_post.h | 14 + Marlin/src/inc/MarlinConfigPre.h | 1 - Marlin/src/inc/SanityCheck.h | 2 - 11 files changed, 472 insertions(+), 483 deletions(-) delete mode 100644 Marlin/src/feature/tmc_macros.h diff --git a/Marlin/src/HAL/HAL_DUE/usb/sd_mmc_spi_mem.cpp b/Marlin/src/HAL/HAL_DUE/usb/sd_mmc_spi_mem.cpp index 1d33530276..dfc1695711 100644 --- a/Marlin/src/HAL/HAL_DUE/usb/sd_mmc_spi_mem.cpp +++ b/Marlin/src/HAL/HAL_DUE/usb/sd_mmc_spi_mem.cpp @@ -65,7 +65,7 @@ Ctrl_status sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector) { #ifdef DEBUG_MMC char buffer[80]; sprintf(buffer, "SDRD: %d @ 0x%08x\n", nb_sector, addr); - MYSERIAL.print(buffer); + MYSERIAL0.print(buffer); #endif // Start reading @@ -99,7 +99,7 @@ Ctrl_status sd_mmc_spi_usb_write_10(uint32_t addr, uint16_t nb_sector) { #ifdef DEBUG_MMC char buffer[80]; sprintf(buffer, "SDWR: %d @ 0x%08x\n", nb_sector, addr); - MYSERIAL.print(buffer); + MYSERIAL0.print(buffer); #endif if (!card.getSd2Card().writeStart(addr, nb_sector)) diff --git a/Marlin/src/core/serial.h b/Marlin/src/core/serial.h index 4c04533829..5f90cd0e7f 100644 --- a/Marlin/src/core/serial.h +++ b/Marlin/src/core/serial.h @@ -67,13 +67,13 @@ enum DebugFlags { #ifdef USBCON #include #if ENABLED(BLUETOOTH) - #define MYSERIAL bluetoothSerial + #define MYSERIAL0 bluetoothSerial #else - #define MYSERIAL Serial + #define MYSERIAL0 Serial #endif // BLUETOOTH #else #include "../HAL/HAL_AVR/MarlinSerial.h" - #define MYSERIAL customizedSerial + #define MYSERIAL0 customizedSerial #endif #elif defined(ARDUINO_ARCH_SAM) // To pull the Serial port definitions and overrides diff --git a/Marlin/src/feature/tmc_macros.h b/Marlin/src/feature/tmc_macros.h deleted file mode 100644 index b98c460e0b..0000000000 --- a/Marlin/src/feature/tmc_macros.h +++ /dev/null @@ -1,39 +0,0 @@ -/** - * Marlin 3D Printer Firmware - * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin] - * - * Based on Sprinter and grbl. - * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - * - */ -#ifndef TMC_MACROS_H -#define TMC_MACROS_H - - // Trinamic Stepper Drivers - #define HAS_TRINAMIC (ENABLED(HAVE_TMC2130) || ENABLED(HAVE_TMC2208) || ENABLED(IS_TRAMS)) - #define X_IS_TRINAMIC (ENABLED( X_IS_TMC2130) || ENABLED( X_IS_TMC2208) || ENABLED(IS_TRAMS)) - #define X2_IS_TRINAMIC (ENABLED(X2_IS_TMC2130) || ENABLED(X2_IS_TMC2208)) - #define Y_IS_TRINAMIC (ENABLED( Y_IS_TMC2130) || ENABLED( Y_IS_TMC2208) || ENABLED(IS_TRAMS)) - #define Y2_IS_TRINAMIC (ENABLED(Y2_IS_TMC2130) || ENABLED(Y2_IS_TMC2208)) - #define Z_IS_TRINAMIC (ENABLED( Z_IS_TMC2130) || ENABLED( Z_IS_TMC2208) || ENABLED(IS_TRAMS)) - #define Z2_IS_TRINAMIC (ENABLED(Z2_IS_TMC2130) || ENABLED(Z2_IS_TMC2208)) - #define E0_IS_TRINAMIC (ENABLED(E0_IS_TMC2130) || ENABLED(E0_IS_TMC2208) || ENABLED(IS_TRAMS)) - #define E1_IS_TRINAMIC (ENABLED(E1_IS_TMC2130) || ENABLED(E1_IS_TMC2208)) - #define E2_IS_TRINAMIC (ENABLED(E2_IS_TMC2130) || ENABLED(E2_IS_TMC2208)) - #define E3_IS_TRINAMIC (ENABLED(E3_IS_TMC2130) || ENABLED(E3_IS_TMC2208)) - #define E4_IS_TRINAMIC (ENABLED(E4_IS_TMC2130) || ENABLED(E4_IS_TMC2208)) - -#endif diff --git a/Marlin/src/feature/tmc_util.cpp b/Marlin/src/feature/tmc_util.cpp index b799462d35..f083258559 100644 --- a/Marlin/src/feature/tmc_util.cpp +++ b/Marlin/src/feature/tmc_util.cpp @@ -32,6 +32,10 @@ #include "../libs/duration_t.h" #include "../gcode/gcode.h" +#if ENABLED(TMC_DEBUG) + #include "../module/planner.h" +#endif + bool report_tmc_status = false; char extended_axis_codes[11][3] = { "X", "X2", "Y", "Y2", "Z", "Z2", "E0", "E1", "E2", "E3", "E4" }; @@ -51,7 +55,7 @@ char extended_axis_codes[11][3] = { "X", "X2", "Y", "Y2", "Z", "Z2", "E0", "E1", }; #if ENABLED(HAVE_TMC2130) static uint32_t get_pwm_scale(TMC2130Stepper &st) { return st.PWM_SCALE(); } - static uint8_t get_status_response(TMC2130Stepper &st) { return st.status_response&0xF; } + static uint8_t get_status_response(TMC2130Stepper &st) { return st.status_response & 0xF; } static TMC_driver_data get_driver_data(TMC2130Stepper &st) { constexpr uint32_t OTPW_bm = 0x4000000UL; constexpr uint8_t OTPW_bp = 26; @@ -61,9 +65,9 @@ char extended_axis_codes[11][3] = { "X", "X2", "Y", "Y2", "Z", "Z2", "E0", "E1", constexpr uint8_t DRIVER_ERROR_bp = 1; TMC_driver_data data; data.drv_status = st.DRV_STATUS(); - data.is_otpw = (data.drv_status & OTPW_bm)>>OTPW_bp; - data.is_ot = (data.drv_status & OT_bm)>>OT_bp; - data.is_error = (st.status_response & DRIVER_ERROR_bm)>>DRIVER_ERROR_bp; + data.is_otpw = (data.drv_status & OTPW_bm) >> OTPW_bp; + data.is_ot = (data.drv_status & OT_bm) >> OT_bp; + data.is_error = (st.status_response & DRIVER_ERROR_bm) >> DRIVER_ERROR_bp; return data; } #endif @@ -84,35 +88,35 @@ char extended_axis_codes[11][3] = { "X", "X2", "Y", "Y2", "Z", "Z2", "E0", "E1", constexpr uint8_t OT_bp = 1; TMC_driver_data data; data.drv_status = st.DRV_STATUS(); - data.is_otpw = (data.drv_status & OTPW_bm)>>OTPW_bp; - data.is_ot = (data.drv_status & OT_bm)>>OT_bp; + data.is_otpw = (data.drv_status & OTPW_bm) >> OTPW_bp; + data.is_ot = (data.drv_status & OT_bm) >> OT_bp; data.is_error = st.drv_err(); return data; } #endif template - uint8_t monitor_tmc_driver(TMC &st, const char axisID, uint8_t otpw_cnt) { + void monitor_tmc_driver(TMC &st, const char axisID, uint8_t &otpw_cnt) { TMC_driver_data data = get_driver_data(st); #if ENABLED(STOP_ON_ERROR) if (data.is_error) { SERIAL_EOL(); SERIAL_ECHO(axisID); - SERIAL_ECHO(" driver error detected:"); - if (data.is_ot) SERIAL_ECHO("\novertemperature"); - if (st.s2ga()) SERIAL_ECHO("\nshort to ground (coil A)"); - if (st.s2gb()) SERIAL_ECHO("\nshort to ground (coil B)"); + SERIAL_ECHOPGM(" driver error detected:"); + if (data.is_ot) SERIAL_ECHOPGM("\novertemperature"); + if (st.s2ga()) SERIAL_ECHOPGM("\nshort to ground (coil A)"); + if (st.s2gb()) SERIAL_ECHOPGM("\nshort to ground (coil B)"); SERIAL_EOL(); #if ENABLED(TMC_DEBUG) - _M122(); + tmc_report_all(); #endif kill(PSTR("Driver error")); } #endif // Report if a warning was triggered - if (data.is_otpw && otpw_cnt==0) { + if (data.is_otpw && otpw_cnt == 0) { char timestamp[10]; duration_t elapsed = print_job_timer.duration(); const bool has_days = (elapsed.value > 60*60*24L); @@ -123,7 +127,7 @@ char extended_axis_codes[11][3] = { "X", "X2", "Y", "Y2", "Z", "Z2", "E0", "E1", SERIAL_ECHO(axisID); SERIAL_ECHOPGM(" driver overtemperature warning! ("); SERIAL_ECHO(st.getCurrent()); - SERIAL_ECHOLN("mA)"); + SERIAL_ECHOLNPGM("mA)"); } #if CURRENT_STEP_DOWN > 0 // Decrease current if is_otpw is true and driver is enabled and there's been more then 4 warnings @@ -140,23 +144,21 @@ char extended_axis_codes[11][3] = { "X", "X2", "Y", "Y2", "Z", "Z2", "E0", "E1", otpw_cnt++; st.flag_otpw = true; } - else if (otpw_cnt>0) otpw_cnt--; + else if (otpw_cnt > 0) otpw_cnt--; if (report_tmc_status) { const uint32_t pwm_scale = get_pwm_scale(st); SERIAL_ECHO(axisID); SERIAL_ECHOPAIR(":", pwm_scale); - SERIAL_ECHO(" |0b"); SERIAL_PRINT(get_status_response(st), BIN); - SERIAL_ECHO("| "); - if (data.is_error) SERIAL_ECHO('E'); - else if (data.is_ot) SERIAL_ECHO('O'); - else if (data.is_otpw) SERIAL_ECHO('W'); - else if (otpw_cnt>0) SERIAL_PRINT(otpw_cnt, DEC); - else if (st.flag_otpw) SERIAL_ECHO('F'); - SERIAL_ECHO("\t"); + SERIAL_ECHOPGM(" |0b"); MYSERIAL0.print(get_status_response(st), BIN); + SERIAL_ECHOPGM("| "); + if (data.is_error) SERIAL_CHAR('E'); + else if (data.is_ot) SERIAL_CHAR('O'); + else if (data.is_otpw) SERIAL_CHAR('W'); + else if (otpw_cnt > 0) SERIAL_PRINT(otpw_cnt, DEC); + else if (st.flag_otpw) SERIAL_CHAR('F'); + SERIAL_CHAR('\t'); } - - return otpw_cnt; } #define HAS_HW_COMMS(ST) ENABLED(ST##_IS_TMC2130)|| (ENABLED(ST##_IS_TMC2208) && defined(ST##_HARDWARE_SERIAL)) @@ -167,47 +169,47 @@ char extended_axis_codes[11][3] = { "X", "X2", "Y", "Y2", "Z", "Z2", "E0", "E1", next_cOT = millis() + 500; #if HAS_HW_COMMS(X) || ENABLED(IS_TRAMS) static uint8_t x_otpw_cnt = 0; - x_otpw_cnt = monitor_tmc_driver(stepperX, axis_codes[X_AXIS], x_otpw_cnt); + monitor_tmc_driver(stepperX, axis_codes[X_AXIS], x_otpw_cnt); #endif #if HAS_HW_COMMS(Y) || ENABLED(IS_TRAMS) static uint8_t y_otpw_cnt = 0; - y_otpw_cnt = monitor_tmc_driver(stepperY, axis_codes[Y_AXIS], y_otpw_cnt); + monitor_tmc_driver(stepperY, axis_codes[Y_AXIS], y_otpw_cnt); #endif #if HAS_HW_COMMS(Z) || ENABLED(IS_TRAMS) static uint8_t z_otpw_cnt = 0; - z_otpw_cnt = monitor_tmc_driver(stepperZ, axis_codes[Z_AXIS], z_otpw_cnt); + monitor_tmc_driver(stepperZ, axis_codes[Z_AXIS], z_otpw_cnt); #endif #if HAS_HW_COMMS(X2) static uint8_t x2_otpw_cnt = 0; - x2_otpw_cnt = monitor_tmc_driver(stepperX2, axis_codes[X_AXIS], x2_otpw_cnt); + monitor_tmc_driver(stepperX2, axis_codes[X_AXIS], x2_otpw_cnt); #endif #if HAS_HW_COMMS(Y2) static uint8_t y2_otpw_cnt = 0; - y2_otpw_cnt = monitor_tmc_driver(stepperY2, axis_codes[Y_AXIS], y2_otpw_cnt); + monitor_tmc_driver(stepperY2, axis_codes[Y_AXIS], y2_otpw_cnt); #endif #if HAS_HW_COMMS(Z2) static uint8_t z2_otpw_cnt = 0; - z2_otpw_cnt = monitor_tmc_driver(stepperZ2, axis_codes[Z_AXIS], z2_otpw_cnt); + monitor_tmc_driver(stepperZ2, axis_codes[Z_AXIS], z2_otpw_cnt); #endif #if HAS_HW_COMMS(E0) || ENABLED(IS_TRAMS) static uint8_t e0_otpw_cnt = 0; - e0_otpw_cnt = monitor_tmc_driver(stepperE0, axis_codes[E_AXIS], e0_otpw_cnt); + monitor_tmc_driver(stepperE0, axis_codes[E_AXIS], e0_otpw_cnt); #endif #if HAS_HW_COMMS(E1) static uint8_t e1_otpw_cnt = 0; - e1_otpw_cnt = monitor_tmc_driver(stepperE1, axis_codes[E_AXIS], e1_otpw_cnt); + monitor_tmc_driver(stepperE1, axis_codes[E_AXIS], e1_otpw_cnt); #endif #if HAS_HW_COMMS(E2) static uint8_t e2_otpw_cnt = 0; - e2_otpw_cnt = monitor_tmc_driver(stepperE2, axis_codes[E_AXIS], e2_otpw_cnt); + monitor_tmc_driver(stepperE2, axis_codes[E_AXIS], e2_otpw_cnt); #endif #if HAS_HW_COMMS(E3) static uint8_t e3_otpw_cnt = 0; - e3_otpw_cnt = monitor_tmc_driver(stepperE3, axis_codes[E_AXIS], e3_otpw_cnt); + monitor_tmc_driver(stepperE3, axis_codes[E_AXIS], e3_otpw_cnt); #endif #if HAS_HW_COMMS(E4) static uint8_t e4_otpw_cnt = 0; - e4_otpw_cnt = monitor_tmc_driver(stepperE4, axis_codes[E_AXIS], e4_otpw_cnt); + monitor_tmc_driver(stepperE4, axis_codes[E_AXIS], e4_otpw_cnt); #endif if (report_tmc_status) SERIAL_EOL(); @@ -216,4 +218,349 @@ char extended_axis_codes[11][3] = { "X", "X2", "Y", "Y2", "Z", "Z2", "E0", "E1", #endif // MONITOR_DRIVER_STATUS +void _tmc_say_current(const char name[], const uint16_t curr) { + SERIAL_ECHO(name); + SERIAL_ECHOLNPAIR(" axis driver current: ", curr); +} +void _tmc_say_otpw(const char name[], const bool otpw) { + SERIAL_ECHO(name); + SERIAL_ECHOPGM(" axis temperature prewarn triggered: "); + serialprintPGM(otpw ? PSTR("true") : PSTR("false")); + SERIAL_EOL(); +} +void _tmc_say_otpw_cleared(const char name[]) { + SERIAL_ECHO(name); + SERIAL_ECHOLNPGM(" prewarn flag cleared"); +} +void _tmc_say_pwmthrs(const char name[], const uint32_t thrs) { + SERIAL_ECHO(name); + SERIAL_ECHOLNPAIR(" stealthChop max speed set to ", thrs); +} +void _tmc_say_sgt(const char name[], const uint32_t sgt) { + SERIAL_ECHO(name); + SERIAL_ECHOPGM(" driver homing sensitivity set to "); + MYSERIAL0.println(sgt, DEC); +} + +#if ENABLED(TMC_DEBUG) + + enum TMC_debug_enum { + TMC_CODES, + TMC_ENABLED, + TMC_CURRENT, + TMC_RMS_CURRENT, + TMC_MAX_CURRENT, + TMC_IRUN, + TMC_IHOLD, + TMC_CS_ACTUAL, + TMC_PWM_SCALE, + TMC_VSENSE, + TMC_STEALTHCHOP, + TMC_MICROSTEPS, + TMC_TSTEP, + TMC_TPWMTHRS, + TMC_TPWMTHRS_MMS, + TMC_OTPW, + TMC_OTPW_TRIGGERED, + TMC_TOFF, + TMC_TBL, + TMC_HEND, + TMC_HSTRT, + TMC_SGT + }; + enum TMC_drv_status_enum { + TMC_DRV_CODES, + TMC_STST, + TMC_OLB, + TMC_OLA, + TMC_S2GB, + TMC_S2GA, + TMC_DRV_OTPW, + TMC_OT, + TMC_STALLGUARD, + TMC_DRV_CS_ACTUAL, + TMC_FSACTIVE, + TMC_SG_RESULT, + TMC_DRV_STATUS_HEX, + TMC_T157, + TMC_T150, + TMC_T143, + TMC_T120, + TMC_STEALTH, + TMC_S2VSB, + TMC_S2VSA + }; + static void drv_status_print_hex(const char name[], const uint32_t drv_status) { + SERIAL_ECHO(name); + SERIAL_ECHOPGM(" = 0x"); + 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(); + } + + #if ENABLED(HAVE_TMC2130) + static void tmc_status(TMC2130Stepper &st, const TMC_debug_enum i) { + switch(i) { + case TMC_PWM_SCALE: SERIAL_PRINT(st.PWM_SCALE(), DEC); break; + case TMC_TSTEP: SERIAL_ECHO(st.TSTEP()); break; + case TMC_SGT: SERIAL_PRINT(st.sgt(), DEC); break; + case TMC_STEALTHCHOP: serialprintPGM(st.stealthChop() ? PSTR("true") : PSTR("false")); break; + default: break; + } + } + static void tmc_parse_drv_status(TMC2130Stepper &st, const TMC_drv_status_enum i) { + switch(i) { + case TMC_STALLGUARD: if (st.stallguard()) SERIAL_CHAR('X'); break; + case TMC_SG_RESULT: SERIAL_PRINT(st.sg_result(), DEC); break; + case TMC_FSACTIVE: if (st.fsactive()) SERIAL_CHAR('X'); break; + default: break; + } + } + #endif + #if ENABLED(HAVE_TMC2208) + static void tmc_status(TMC2208Stepper &st, const TMC_debug_enum i) { + switch(i) { + case TMC_TSTEP: { uint32_t data = 0; st.TSTEP(&data); MYSERIAL0.print(data); break; } + case TMC_PWM_SCALE: SERIAL_PRINT(st.pwm_scale_sum(), DEC); break; + case TMC_STEALTHCHOP: serialprintPGM(st.stealth() ? PSTR("true") : PSTR("false")); break; + case TMC_S2VSA: if (st.s2vsa()) SERIAL_CHAR('X'); break; + case TMC_S2VSB: if (st.s2vsb()) SERIAL_CHAR('X'); break; + default: break; + } + } + static void tmc_parse_drv_status(TMC2208Stepper &st, const TMC_drv_status_enum i) { + switch(i) { + case TMC_T157: if (st.t157()) SERIAL_CHAR('X'); break; + case TMC_T150: if (st.t150()) SERIAL_CHAR('X'); break; + case TMC_T143: if (st.t143()) SERIAL_CHAR('X'); break; + case TMC_T120: if (st.t120()) SERIAL_CHAR('X'); break; + default: break; + } + } + #endif + + template + static void tmc_status(TMC &st, TMC_AxisEnum axis, const TMC_debug_enum i, const float spmm) { + SERIAL_ECHO('\t'); + switch(i) { + case TMC_CODES: SERIAL_ECHO(extended_axis_codes[axis]); break; + case TMC_ENABLED: serialprintPGM(st.isEnabled() ? PSTR("true") : PSTR("false")); break; + case TMC_CURRENT: SERIAL_ECHO(st.getCurrent()); break; + case TMC_RMS_CURRENT: MYSERIAL0.print(st.rms_current()); break; + case TMC_MAX_CURRENT: SERIAL_PRINT((float)st.rms_current() * 1.41, 0); break; + case TMC_IRUN: + SERIAL_PRINT(st.irun(), DEC); + SERIAL_ECHOPGM("/31"); + break; + case TMC_IHOLD: + SERIAL_PRINT(st.ihold(), DEC); + SERIAL_ECHOPGM("/31"); + break; + case TMC_CS_ACTUAL: + SERIAL_PRINT(st.cs_actual(), DEC); + SERIAL_ECHOPGM("/31"); + break; + + case TMC_VSENSE: serialprintPGM(st.vsense() ? PSTR("1=.18") : PSTR("0=.325")); break; + + case TMC_MICROSTEPS: SERIAL_ECHO(st.microsteps()); break; + case TMC_TPWMTHRS: { + uint32_t tpwmthrs_val = st.TPWMTHRS(); + SERIAL_ECHO(tpwmthrs_val); + } + break; + case TMC_TPWMTHRS_MMS: { + uint32_t tpwmthrs_val = st.TPWMTHRS(); + tpwmthrs_val ? SERIAL_ECHO(12650000UL * st.microsteps() / (256 * tpwmthrs_val * spmm)) : SERIAL_CHAR('-'); + } + break; + case TMC_OTPW: serialprintPGM(st.otpw() ? PSTR("true") : PSTR("false")); break; + case TMC_OTPW_TRIGGERED: serialprintPGM(st.getOTPW() ? PSTR("true") : PSTR("false")); break; + case TMC_TOFF: SERIAL_PRINT(st.toff(), DEC); break; + case TMC_TBL: SERIAL_PRINT(st.blank_time(), DEC); break; + case TMC_HEND: SERIAL_PRINT(st.hysterisis_end(), DEC); break; + case TMC_HSTRT: SERIAL_PRINT(st.hysterisis_start(), DEC); break; + default: tmc_status(st, i); break; + } + } + + template + static void tmc_parse_drv_status(TMC &st, TMC_AxisEnum axis, const TMC_drv_status_enum i) { + SERIAL_CHAR('\t'); + switch(i) { + case TMC_DRV_CODES: SERIAL_ECHO(extended_axis_codes[axis]); break; + case TMC_STST: if (st.stst()) SERIAL_CHAR('X'); break; + case TMC_OLB: if (st.olb()) SERIAL_CHAR('X'); break; + case TMC_OLA: if (st.ola()) SERIAL_CHAR('X'); break; + case TMC_S2GB: if (st.s2gb()) SERIAL_CHAR('X'); break; + 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_CS_ACTUAL: SERIAL_PRINT(st.cs_actual(), DEC); break; + case TMC_DRV_STATUS_HEX:drv_status_print_hex(extended_axis_codes[axis], st.DRV_STATUS()); break; + default: tmc_parse_drv_status(st, i); break; + } + } + + static void tmc_debug_loop(const TMC_debug_enum i) { + #if X_IS_TRINAMIC + tmc_status(stepperX, TMC_X, i, planner.axis_steps_per_mm[X_AXIS]); + #endif + #if X2_IS_TRINAMIC + tmc_status(stepperX2, TMC_X2, i, planner.axis_steps_per_mm[X_AXIS]); + #endif + + #if Y_IS_TRINAMIC + tmc_status(stepperY, TMC_Y, i, planner.axis_steps_per_mm[Y_AXIS]); + #endif + #if Y2_IS_TRINAMIC + tmc_status(stepperY2, TMC_Y2, i, planner.axis_steps_per_mm[Y_AXIS]); + #endif + + #if Z_IS_TRINAMIC + tmc_status(stepperZ, TMC_Z, i, planner.axis_steps_per_mm[Z_AXIS]); + #endif + #if Z2_IS_TRINAMIC + tmc_status(stepperZ2, TMC_Z2, i, planner.axis_steps_per_mm[Z_AXIS]); + #endif + + #if E0_IS_TRINAMIC + tmc_status(stepperE0, TMC_E0, i, planner.axis_steps_per_mm[E_AXIS]); + #endif + #if E1_IS_TRINAMIC + tmc_status(stepperE1, TMC_E1, i, planner.axis_steps_per_mm[E_AXIS+1]); + #endif + #if E2_IS_TRINAMIC + tmc_status(stepperE2, TMC_E2, i, planner.axis_steps_per_mm[E_AXIS+2]); + #endif + #if E3_IS_TRINAMIC + tmc_status(stepperE3, TMC_E3, i, planner.axis_steps_per_mm[E_AXIS+3]); + #endif + #if E4_IS_TRINAMIC + tmc_status(stepperE4, TMC_E4, i, planner.axis_steps_per_mm[E_AXIS+4]); + #endif + + SERIAL_EOL(); + } + + static void drv_status_loop(const TMC_drv_status_enum i) { + #if X_IS_TRINAMIC + tmc_parse_drv_status(stepperX, TMC_X, i); + #endif + #if X2_IS_TRINAMIC + tmc_parse_drv_status(stepperX2, TMC_X2, i); + #endif + + #if Y_IS_TRINAMIC + tmc_parse_drv_status(stepperY, TMC_Y, i); + #endif + #if Y2_IS_TRINAMIC + tmc_parse_drv_status(stepperY2, TMC_Y2, i); + #endif + + #if Z_IS_TRINAMIC + tmc_parse_drv_status(stepperZ, TMC_Z, i); + #endif + #if Z2_IS_TRINAMIC + tmc_parse_drv_status(stepperZ2, TMC_Z2, i); + #endif + + #if E0_IS_TRINAMIC + tmc_parse_drv_status(stepperE0, TMC_E0, i); + #endif + #if E1_IS_TRINAMIC + tmc_parse_drv_status(stepperE1, TMC_E1, i); + #endif + #if E2_IS_TRINAMIC + tmc_parse_drv_status(stepperE2, TMC_E2, i); + #endif + #if E3_IS_TRINAMIC + tmc_parse_drv_status(stepperE3, TMC_E3, i); + #endif + #if E4_IS_TRINAMIC + tmc_parse_drv_status(stepperE4, TMC_E4, i); + #endif + + SERIAL_EOL(); + } + + /** + * M122 report functions + */ + void tmc_set_report_status(const bool status) { + if ((report_tmc_status = status)) + SERIAL_ECHOLNPGM("axis:pwm_scale |status_response|"); + } + + 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) + TMC_REPORT("\t", TMC_CODES); + TMC_REPORT("Enabled\t", TMC_ENABLED); + TMC_REPORT("Set current", TMC_CURRENT); + TMC_REPORT("RMS current", TMC_RMS_CURRENT); + TMC_REPORT("MAX current", TMC_MAX_CURRENT); + TMC_REPORT("Run current", TMC_IRUN); + TMC_REPORT("Hold current", TMC_IHOLD); + TMC_REPORT("CS actual\t", TMC_CS_ACTUAL); + TMC_REPORT("PWM scale", TMC_PWM_SCALE); + TMC_REPORT("vsense\t", TMC_VSENSE); + TMC_REPORT("stealthChop", TMC_STEALTHCHOP); + TMC_REPORT("msteps\t", TMC_MICROSTEPS); + TMC_REPORT("tstep\t", TMC_TSTEP); + TMC_REPORT("pwm\nthreshold\t", TMC_TPWMTHRS); + TMC_REPORT("[mm/s]\t", TMC_TPWMTHRS_MMS); + TMC_REPORT("OT prewarn", TMC_OTPW); + TMC_REPORT("OT prewarn has\n" + "been triggered", TMC_OTPW_TRIGGERED); + TMC_REPORT("off time\t", TMC_TOFF); + TMC_REPORT("blank time", TMC_TBL); + TMC_REPORT("hysterisis\n-end\t", TMC_HEND); + TMC_REPORT("-start\t", TMC_HSTRT); + TMC_REPORT("Stallguard thrs", TMC_SGT); + + DRV_REPORT("DRVSTATUS", TMC_DRV_CODES); + #if ENABLED(HAVE_TMC2130) + DRV_REPORT("stallguard\t", TMC_STALLGUARD); + DRV_REPORT("sg_result\t", TMC_SG_RESULT); + DRV_REPORT("fsactive\t", TMC_FSACTIVE); + #endif + DRV_REPORT("stst\t", TMC_STST); + DRV_REPORT("olb\t", TMC_OLB); + DRV_REPORT("ola\t", TMC_OLA); + DRV_REPORT("s2gb\t", TMC_S2GB); + DRV_REPORT("s2ga\t", TMC_S2GA); + DRV_REPORT("otpw\t", TMC_DRV_OTPW); + DRV_REPORT("ot\t", TMC_OT); + #if ENABLED(HAVE_TMC2208) + DRV_REPORT("157C\t", TMC_T157); + DRV_REPORT("150C\t", TMC_T150); + DRV_REPORT("143C\t", TMC_T143); + DRV_REPORT("120C\t", TMC_T120); + DRV_REPORT("s2vsa\t", TMC_S2VSA); + DRV_REPORT("s2vsb\t", TMC_S2VSB); + #endif + DRV_REPORT("Driver registers:", TMC_DRV_STATUS_HEX); + SERIAL_EOL(); + } + +#endif // TMC_DEBUG + +#if ENABLED(SENSORLESS_HOMING) + + void tmc_sensorless_homing(TMC2130Stepper &st, bool enable/*=true*/) { + #if ENABLED(STEALTHCHOP) + st.coolstep_min_speed(enable ? 1024UL * 1024UL - 1UL : 0); + st.stealthChop(!enable); + #endif + st.diag1_stall(enable ? 1 : 0); + } + +#endif // SENSORLESS_HOMING + #endif // HAS_TRINAMIC diff --git a/Marlin/src/feature/tmc_util.h b/Marlin/src/feature/tmc_util.h index 7741c7b449..abe44e9dbc 100644 --- a/Marlin/src/feature/tmc_util.h +++ b/Marlin/src/feature/tmc_util.h @@ -35,11 +35,19 @@ enum TMC_AxisEnum { TMC_E0, TMC_E1, TMC_E2, TMC_E3, TMC_E4 }; +constexpr uint32_t _tmc_thrs(const uint16_t msteps, const int32_t thrs, const uint32_t spmm) { + return 12650000UL * msteps / (256 * thrs * spmm); +} + +void _tmc_say_current(const char name[], const uint16_t curr); +void _tmc_say_otpw(const char name[], const bool otpw); +void _tmc_say_otpw_cleared(const char name[]); +void _tmc_say_pwmthrs(const char name[], const uint32_t thrs); +void _tmc_say_sgt(const char name[], const uint32_t sgt); + template void tmc_get_current(TMC &st, const char name[]) { - SERIAL_ECHO(name); - SERIAL_ECHOPGM(" axis driver current: "); - SERIAL_ECHOLN(st.getCurrent()); + _tmc_say_current(name, st.getCurrent()); } template void tmc_set_current(TMC &st, const char name[], const int mA) { @@ -48,33 +56,25 @@ void tmc_set_current(TMC &st, const char name[], const int mA) { } template void tmc_report_otpw(TMC &st, const char name[]) { - SERIAL_ECHO(name); - SERIAL_ECHOPGM(" axis temperature prewarn triggered: "); - serialprintPGM(st.getOTPW() ? PSTR("true") : PSTR("false")); - SERIAL_EOL(); + _tmc_say_otpw(name, st.getOTPW()); } template void tmc_clear_otpw(TMC &st, const char name[]) { st.clear_otpw(); - SERIAL_ECHO(name); - SERIAL_ECHOLNPGM(" prewarn flag cleared"); + _tmc_say_otpw_cleared(name); } template void tmc_get_pwmthrs(TMC &st, const char name[], const uint16_t spmm) { - SERIAL_ECHO(name); - SERIAL_ECHOPGM(" stealthChop max speed set to "); - SERIAL_ECHOLN(12650000UL * st.microsteps() / (256 * st.TPWMTHRS() * spmm)); + _tmc_say_pwmthrs(name, _tmc_thrs(st.microsteps(), st.TPWMTHRS(), spmm)); } template void tmc_set_pwmthrs(TMC &st, const char name[], const int32_t thrs, const uint32_t spmm) { - st.TPWMTHRS(12650000UL * st.microsteps() / (256 * thrs * spmm)); + st.TPWMTHRS(_tmc_thrs(st.microsteps(), thrs, spmm)); tmc_get_pwmthrs(st, name, spmm); } template void tmc_get_sgt(TMC &st, const char name[]) { - SERIAL_ECHO(name); - SERIAL_ECHOPGM(" driver homing sensitivity set to "); - MYSERIAL.println(st.sgt(), DEC); + _tmc_say_sgt(name, st.sgt()); } template void tmc_set_sgt(TMC &st, const char name[], const int8_t sgt_val) { @@ -82,9 +82,13 @@ void tmc_set_sgt(TMC &st, const char name[], const int8_t sgt_val) { tmc_get_sgt(st, name); } -void _M122(); void monitor_tmc_driver(); +#if ENABLED(TMC_DEBUG) + void tmc_set_report_status(const bool status); + void tmc_report_all(); +#endif + /** * TMC2130 specific sensorless homing using stallGuard2. * stallGuard2 only works when in spreadCycle mode. @@ -93,21 +97,7 @@ void monitor_tmc_driver(); * Defined here because of limitations with templates and headers. */ #if ENABLED(SENSORLESS_HOMING) - template - void tmc_sensorless_homing(TMC &st, bool enable=true) { - #if ENABLED(STEALTHCHOP) - if (enable) { - st.coolstep_min_speed(1024UL * 1024UL - 1UL); - st.stealthChop(0); - } - else { - st.coolstep_min_speed(0); - st.stealthChop(1); - } - #endif - - st.diag1_stall(enable ? 1 : 0); - } + void tmc_sensorless_homing(TMC2130Stepper &st, bool enable=true); #endif #endif // _TMC_UTIL_H_ diff --git a/Marlin/src/gcode/feature/trinamic/M122.cpp b/Marlin/src/gcode/feature/trinamic/M122.cpp index dc6d51eed9..f079b39c08 100644 --- a/Marlin/src/gcode/feature/trinamic/M122.cpp +++ b/Marlin/src/gcode/feature/trinamic/M122.cpp @@ -26,314 +26,15 @@ #include "../../gcode.h" #include "../../../feature/tmc_util.h" -#include "../../../module/stepper_indirection.h" -#include "../../../module/planner.h" -enum TMC_debug_enum { - TMC_CODES, - TMC_ENABLED, - TMC_CURRENT, - TMC_RMS_CURRENT, - TMC_MAX_CURRENT, - TMC_IRUN, - TMC_IHOLD, - TMC_CS_ACTUAL, - TMC_PWM_SCALE, - TMC_VSENSE, - TMC_STEALTHCHOP, - TMC_MICROSTEPS, - TMC_TSTEP, - TMC_TPWMTHRS, - TMC_TPWMTHRS_MMS, - TMC_OTPW, - TMC_OTPW_TRIGGERED, - TMC_TOFF, - TMC_TBL, - TMC_HEND, - TMC_HSTRT, - TMC_SGT -}; -enum TMC_drv_status_enum { - TMC_DRV_CODES, - TMC_STST, - TMC_OLB, - TMC_OLA, - TMC_S2GB, - TMC_S2GA, - TMC_DRV_OTPW, - TMC_OT, - TMC_STALLGUARD, - TMC_DRV_CS_ACTUAL, - TMC_FSACTIVE, - TMC_SG_RESULT, - TMC_DRV_STATUS_HEX, - TMC_T157, - TMC_T150, - TMC_T143, - TMC_T120, - TMC_STEALTH, - TMC_S2VSB, - TMC_S2VSA -}; -static void drv_status_print_hex(const char name[], const uint32_t drv_status) { - SERIAL_ECHO(name); - SERIAL_ECHOPGM(" = 0x"); - 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(); +/** + * M122: Debug TMC drivers + */ +void GcodeSuite::M122() { + if (parser.seen('S')) + tmc_set_report_status(parser.value_bool()); + else + tmc_report_all(); } -#if ENABLED(HAVE_TMC2130) - static void tmc_status(TMC2130Stepper &st, const TMC_debug_enum i) { - switch(i) { - case TMC_PWM_SCALE: SERIAL_PRINT(st.PWM_SCALE(), DEC); break; - case TMC_TSTEP: SERIAL_ECHO(st.TSTEP()); break; - case TMC_SGT: SERIAL_PRINT(st.sgt(), DEC); break; - case TMC_STEALTHCHOP: serialprintPGM(st.stealthChop() ? PSTR("true") : PSTR("false")); break; - default: break; - } - } - static void tmc_parse_drv_status(TMC2130Stepper &st, const TMC_drv_status_enum i) { - switch(i) { - case TMC_STALLGUARD: if (st.stallguard()) SERIAL_ECHOPGM("X"); break; - case TMC_SG_RESULT: SERIAL_PRINT(st.sg_result(), DEC); break; - case TMC_FSACTIVE: if (st.fsactive()) SERIAL_ECHOPGM("X"); break; - default: break; - } - } -#endif -#if ENABLED(HAVE_TMC2208) - static void tmc_status(TMC2208Stepper &st, const TMC_debug_enum i) { - switch(i) { - case TMC_TSTEP: { - uint32_t data = 0; - st.TSTEP(&data); - SERIAL_PROTOCOL(data); - break; - } - case TMC_PWM_SCALE: SERIAL_PRINT(st.pwm_scale_sum(), DEC); break; - case TMC_STEALTHCHOP: serialprintPGM(st.stealth() ? PSTR("true") : PSTR("false")); break; - case TMC_S2VSA: if (st.s2vsa()) SERIAL_ECHOPGM("X"); break; - case TMC_S2VSB: if (st.s2vsb()) SERIAL_ECHOPGM("X"); break; - default: break; - } - } - static void tmc_parse_drv_status(TMC2208Stepper &st, const TMC_drv_status_enum i) { - switch(i) { - case TMC_T157: if (st.t157()) SERIAL_ECHOPGM("X"); break; - case TMC_T150: if (st.t150()) SERIAL_ECHOPGM("X"); break; - case TMC_T143: if (st.t143()) SERIAL_ECHOPGM("X"); break; - case TMC_T120: if (st.t120()) SERIAL_ECHOPGM("X"); break; - default: break; - } - } -#endif -template -static void tmc_status(TMC &st, TMC_AxisEnum axis, const TMC_debug_enum i, const float spmm) { - SERIAL_ECHO('\t'); - switch(i) { - case TMC_CODES: SERIAL_ECHO(extended_axis_codes[axis]); break; - case TMC_ENABLED: serialprintPGM(st.isEnabled() ? PSTR("true") : PSTR("false")); break; - case TMC_CURRENT: SERIAL_ECHO(st.getCurrent()); break; - case TMC_RMS_CURRENT: SERIAL_PROTOCOL(st.rms_current()); break; - case TMC_MAX_CURRENT: SERIAL_PRINT((float)st.rms_current()*1.41, 0); break; - case TMC_IRUN: - SERIAL_PRINT(st.irun(), DEC); - SERIAL_ECHOPGM("/31"); - break; - case TMC_IHOLD: - SERIAL_PRINT(st.ihold(), DEC); - SERIAL_ECHOPGM("/31"); - break; - case TMC_CS_ACTUAL: - SERIAL_PRINT(st.cs_actual(), DEC); - SERIAL_ECHOPGM("/31"); - break; - - case TMC_VSENSE: serialprintPGM(st.vsense() ? PSTR("1=.18") : PSTR("0=.325")); break; - - case TMC_MICROSTEPS: SERIAL_ECHO(st.microsteps()); break; - case TMC_TPWMTHRS: { - uint32_t tpwmthrs_val = st.TPWMTHRS(); - SERIAL_ECHO(tpwmthrs_val); - } - break; - case TMC_TPWMTHRS_MMS: { - uint32_t tpwmthrs_val = st.TPWMTHRS(); - tpwmthrs_val ? SERIAL_ECHO(12650000UL * st.microsteps() / (256 * tpwmthrs_val * spmm)) : SERIAL_ECHO('-'); - } - break; - case TMC_OTPW: serialprintPGM(st.otpw() ? PSTR("true") : PSTR("false")); break; - case TMC_OTPW_TRIGGERED: serialprintPGM(st.getOTPW() ? PSTR("true") : PSTR("false")); break; - case TMC_TOFF: SERIAL_PRINT(st.toff(), DEC); break; - case TMC_TBL: SERIAL_PRINT(st.blank_time(), DEC); break; - case TMC_HEND: SERIAL_PRINT(st.hysterisis_end(), DEC); break; - case TMC_HSTRT: SERIAL_PRINT(st.hysterisis_start(), DEC); break; - default: tmc_status(st, i); break; - } -} -template -static void tmc_parse_drv_status(TMC &st, TMC_AxisEnum axis, const TMC_drv_status_enum i) { - SERIAL_ECHOPGM("\t"); - switch(i) { - case TMC_DRV_CODES: SERIAL_ECHO(extended_axis_codes[axis]); break; - case TMC_STST: if (st.stst()) SERIAL_ECHOPGM("X"); break; - case TMC_OLB: if (st.olb()) SERIAL_ECHOPGM("X"); break; - case TMC_OLA: if (st.ola()) SERIAL_ECHOPGM("X"); break; - case TMC_S2GB: if (st.s2gb()) SERIAL_ECHOPGM("X"); break; - case TMC_S2GA: if (st.s2ga()) SERIAL_ECHOPGM("X"); break; - case TMC_DRV_OTPW: if (st.otpw()) SERIAL_ECHOPGM("X"); break; - case TMC_OT: if (st.ot()) SERIAL_ECHOPGM("X"); break; - case TMC_DRV_CS_ACTUAL: SERIAL_PRINT(st.cs_actual(), DEC); break; - case TMC_DRV_STATUS_HEX:drv_status_print_hex(extended_axis_codes[axis], st.DRV_STATUS()); break; - default: tmc_parse_drv_status(st, i); break; - } -} - -static void tmc_debug_loop(const TMC_debug_enum i) { - #if X_IS_TRINAMIC - tmc_status(stepperX, TMC_X, i, planner.axis_steps_per_mm[X_AXIS]); - #endif - #if X2_IS_TRINAMIC - tmc_status(stepperX2, TMC_X2, i, planner.axis_steps_per_mm[X_AXIS]); - #endif - - #if Y_IS_TRINAMIC - tmc_status(stepperY, TMC_Y, i, planner.axis_steps_per_mm[Y_AXIS]); - #endif - #if Y2_IS_TRINAMIC - tmc_status(stepperY2, TMC_Y2, i, planner.axis_steps_per_mm[Y_AXIS]); - #endif - - #if Z_IS_TRINAMIC - tmc_status(stepperZ, TMC_Z, i, planner.axis_steps_per_mm[Z_AXIS]); - #endif - #if Z2_IS_TRINAMIC - tmc_status(stepperZ2, TMC_Z2, i, planner.axis_steps_per_mm[Z_AXIS]); - #endif - - #if E0_IS_TRINAMIC - tmc_status(stepperE0, TMC_E0, i, planner.axis_steps_per_mm[E_AXIS]); - #endif - #if E1_IS_TRINAMIC - tmc_status(stepperE1, TMC_E1, i, planner.axis_steps_per_mm[E_AXIS+1]); - #endif - #if E2_IS_TRINAMIC - tmc_status(stepperE2, TMC_E2, i, planner.axis_steps_per_mm[E_AXIS+2]); - #endif - #if E3_IS_TRINAMIC - tmc_status(stepperE3, TMC_E3, i, planner.axis_steps_per_mm[E_AXIS+3]); - #endif - #if E4_IS_TRINAMIC - tmc_status(stepperE4, TMC_E4, i, planner.axis_steps_per_mm[E_AXIS+4]); - #endif - - SERIAL_EOL(); -} - -static void drv_status_loop(const TMC_drv_status_enum i) { - #if X_IS_TRINAMIC - tmc_parse_drv_status(stepperX, TMC_X, i); - #endif - #if X2_IS_TRINAMIC - tmc_parse_drv_status(stepperX2, TMC_X2, i); - #endif - - #if Y_IS_TRINAMIC - tmc_parse_drv_status(stepperY, TMC_Y, i); - #endif - #if Y2_IS_TRINAMIC - tmc_parse_drv_status(stepperY2, TMC_Y2, i); - #endif - - #if Z_IS_TRINAMIC - tmc_parse_drv_status(stepperZ, TMC_Z, i); - #endif - #if Z2_IS_TRINAMIC - tmc_parse_drv_status(stepperZ2, TMC_Z2, i); - #endif - - #if E0_IS_TRINAMIC - tmc_parse_drv_status(stepperE0, TMC_E0, i); - #endif - #if E1_IS_TRINAMIC - tmc_parse_drv_status(stepperE1, TMC_E1, i); - #endif - #if E2_IS_TRINAMIC - tmc_parse_drv_status(stepperE2, TMC_E2, i); - #endif - #if E3_IS_TRINAMIC - tmc_parse_drv_status(stepperE3, TMC_E3, i); - #endif - #if E4_IS_TRINAMIC - tmc_parse_drv_status(stepperE4, TMC_E4, i); - #endif - - SERIAL_EOL(); -} - -void _M122() { - if (parser.seen('S')) { - if (parser.value_bool()) { - SERIAL_ECHOLNPGM("axis:pwm_scale |status_response|"); - report_tmc_status = true; - } else - report_tmc_status = false; - } else { - SERIAL_ECHOPGM("\t"); tmc_debug_loop(TMC_CODES); - SERIAL_ECHOPGM("Enabled\t"); tmc_debug_loop(TMC_ENABLED); - SERIAL_ECHOPGM("Set current"); tmc_debug_loop(TMC_CURRENT); - SERIAL_ECHOPGM("RMS current"); tmc_debug_loop(TMC_RMS_CURRENT); - SERIAL_ECHOPGM("MAX current"); tmc_debug_loop(TMC_MAX_CURRENT); - SERIAL_ECHOPGM("Run current"); tmc_debug_loop(TMC_IRUN); - SERIAL_ECHOPGM("Hold current"); tmc_debug_loop(TMC_IHOLD); - SERIAL_ECHOPGM("CS actual\t"); tmc_debug_loop(TMC_CS_ACTUAL); - SERIAL_ECHOPGM("PWM scale"); tmc_debug_loop(TMC_PWM_SCALE); - SERIAL_ECHOPGM("vsense\t"); tmc_debug_loop(TMC_VSENSE); - SERIAL_ECHOPGM("stealthChop"); tmc_debug_loop(TMC_STEALTHCHOP); - SERIAL_ECHOPGM("msteps\t"); tmc_debug_loop(TMC_MICROSTEPS); - SERIAL_ECHOPGM("tstep\t"); tmc_debug_loop(TMC_TSTEP); - SERIAL_ECHOPGM("pwm\nthreshold\t"); tmc_debug_loop(TMC_TPWMTHRS); - SERIAL_ECHOPGM("[mm/s]\t"); tmc_debug_loop(TMC_TPWMTHRS_MMS); - SERIAL_ECHOPGM("OT prewarn"); tmc_debug_loop(TMC_OTPW); - SERIAL_ECHOPGM("OT prewarn has\nbeen triggered"); tmc_debug_loop(TMC_OTPW_TRIGGERED); - SERIAL_ECHOPGM("off time\t"); tmc_debug_loop(TMC_TOFF); - SERIAL_ECHOPGM("blank time"); tmc_debug_loop(TMC_TBL); - SERIAL_ECHOPGM("hysterisis\n-end\t"); tmc_debug_loop(TMC_HEND); - SERIAL_ECHOPGM("-start\t"); tmc_debug_loop(TMC_HSTRT); - SERIAL_ECHOPGM("Stallguard thrs"); tmc_debug_loop(TMC_SGT); - - SERIAL_ECHOPGM("DRVSTATUS"); drv_status_loop(TMC_DRV_CODES); - #if ENABLED(HAVE_TMC2130) - SERIAL_ECHOPGM("stallguard\t"); drv_status_loop(TMC_STALLGUARD); - SERIAL_ECHOPGM("sg_result\t"); drv_status_loop(TMC_SG_RESULT); - SERIAL_ECHOPGM("fsactive\t"); drv_status_loop(TMC_FSACTIVE); - #endif - SERIAL_ECHOPGM("stst\t"); drv_status_loop(TMC_STST); - SERIAL_ECHOPGM("olb\t"); drv_status_loop(TMC_OLB); - SERIAL_ECHOPGM("ola\t"); drv_status_loop(TMC_OLA); - SERIAL_ECHOPGM("s2gb\t"); drv_status_loop(TMC_S2GB); - SERIAL_ECHOPGM("s2ga\t"); drv_status_loop(TMC_S2GA); - SERIAL_ECHOPGM("otpw\t"); drv_status_loop(TMC_DRV_OTPW); - SERIAL_ECHOPGM("ot\t"); drv_status_loop(TMC_OT); - #if ENABLED(HAVE_TMC2208) - SERIAL_ECHOPGM("157C\t"); drv_status_loop(TMC_T157); - SERIAL_ECHOPGM("150C\t"); drv_status_loop(TMC_T150); - SERIAL_ECHOPGM("143C\t"); drv_status_loop(TMC_T143); - SERIAL_ECHOPGM("120C\t"); drv_status_loop(TMC_T120); - SERIAL_ECHOPGM("s2vsa\t"); drv_status_loop(TMC_S2VSA); - SERIAL_ECHOPGM("s2vsb\t"); drv_status_loop(TMC_S2VSB); - #endif - SERIAL_ECHOLNPGM("Driver registers:");drv_status_loop(TMC_DRV_STATUS_HEX); - } -} - -// We need to call M122 from monitor_tmc_driver() as well but GcodeSuite::M122 is private. -void GcodeSuite::M122() { _M122(); } - #endif // TMC_DEBUG diff --git a/Marlin/src/gcode/feature/trinamic/M906.cpp b/Marlin/src/gcode/feature/trinamic/M906.cpp index aa43f9269d..04c26cb21a 100644 --- a/Marlin/src/gcode/feature/trinamic/M906.cpp +++ b/Marlin/src/gcode/feature/trinamic/M906.cpp @@ -27,7 +27,6 @@ #include "../../gcode.h" #include "../../../feature/tmc_util.h" #include "../../../module/stepper_indirection.h" -#include "../../../module/planner.h" /** * M906: Set motor current in milliamps using axis codes X, Y, Z, E @@ -35,54 +34,45 @@ */ void GcodeSuite::M906() { uint16_t values[XYZE]; - LOOP_XYZE(i) - values[i] = parser.intval(axis_codes[i]); + LOOP_XYZE(i) values[i] = parser.intval(axis_codes[i]); + + #define TMC_SET_GET_CURRENT(P,Q) do { \ + if (values[P##_AXIS]) tmc_set_current(stepper##Q, extended_axis_codes[TMC_##Q], values[P##_AXIS]); \ + else tmc_get_current(stepper##Q, extended_axis_codes[TMC_##Q]); } while(0) #if X_IS_TRINAMIC - if (values[X_AXIS]) tmc_set_current(stepperX, extended_axis_codes[TMC_X], values[X_AXIS]); - else tmc_get_current(stepperX, extended_axis_codes[TMC_X]); + TMC_SET_GET_CURRENT(X,X); #endif #if X2_IS_TRINAMIC - if (values[X_AXIS]) tmc_set_current(stepperX2, extended_axis_codes[TMC_X2], values[X_AXIS]); - else tmc_get_current(stepperX2, extended_axis_codes[TMC_X2]); + TMC_SET_GET_CURRENT(X,X2); #endif #if Y_IS_TRINAMIC - if (values[Y_AXIS]) tmc_set_current(stepperY, extended_axis_codes[TMC_Y], values[Y_AXIS]); - else tmc_get_current(stepperY, extended_axis_codes[TMC_Y]); + TMC_SET_GET_CURRENT(Y,Y); #endif #if Y2_IS_TRINAMIC - if (values[Y_AXIS]) tmc_set_current(stepperY2, extended_axis_codes[TMC_Y2], values[Y_AXIS]); - else tmc_get_current(stepperY2, extended_axis_codes[TMC_Y2]); + TMC_SET_GET_CURRENT(Y,Y2); #endif #if Z_IS_TRINAMIC - if (values[Z_AXIS]) tmc_set_current(stepperZ, extended_axis_codes[TMC_Z], values[Z_AXIS]); - else tmc_get_current(stepperZ, extended_axis_codes[TMC_Z]); + TMC_SET_GET_CURRENT(Z,Z); #endif #if Z2_IS_TRINAMIC - if (values[Z_AXIS]) tmc_set_current(stepperZ2, extended_axis_codes[TMC_Z2], values[Z_AXIS]); - else tmc_get_current(stepperZ2, extended_axis_codes[TMC_Z2]); + TMC_SET_GET_CURRENT(Z,Z2); #endif #if E0_IS_TRINAMIC - if (values[E_AXIS]) tmc_set_current(stepperE0, extended_axis_codes[TMC_E0], values[E_AXIS]); - else tmc_get_current(stepperE0, extended_axis_codes[TMC_E0]); + TMC_SET_GET_CURRENT(E,E0); #endif #if E1_IS_TRINAMIC - if (values[E_AXIS]) tmc_set_current(stepperE1, extended_axis_codes[TMC_E1], values[E_AXIS]); - else tmc_get_current(stepperE1, extended_axis_codes[TMC_E1]); + TMC_SET_GET_CURRENT(E,E1); #endif #if E2_IS_TRINAMIC - if (values[E_AXIS]) tmc_set_current(stepperE2, extended_axis_codes[TMC_E2], values[E_AXIS]); - else tmc_get_current(stepperE2, extended_axis_codes[TMC_E2]); + TMC_SET_GET_CURRENT(E,E2); #endif #if E3_IS_TRINAMIC - if (values[E_AXIS]) tmc_set_current(stepperE3, extended_axis_codes[TMC_E3], values[E_AXIS]); - else tmc_get_current(stepperE3, extended_axis_codes[TMC_E3]); + TMC_SET_GET_CURRENT(E,E3); #endif #if E4_IS_TRINAMIC - if (values[E_AXIS]) tmc_set_current(stepperE4, extended_axis_codes[TMC_E4], values[E_AXIS]); - else tmc_get_current(stepperE4, extended_axis_codes[TMC_E4]); + TMC_SET_GET_CURRENT(E,E4); #endif - } #endif // HAS_TRINAMIC diff --git a/Marlin/src/gcode/feature/trinamic/M911-M915.cpp b/Marlin/src/gcode/feature/trinamic/M911-M915.cpp index 6cca7105d7..ea35e436cd 100644 --- a/Marlin/src/gcode/feature/trinamic/M911-M915.cpp +++ b/Marlin/src/gcode/feature/trinamic/M911-M915.cpp @@ -81,55 +81,44 @@ void GcodeSuite::M912() { #if ENABLED(HYBRID_THRESHOLD) void GcodeSuite::M913() { uint16_t values[XYZE]; - LOOP_XYZE(i) - values[i] = parser.intval(axis_codes[i]); + LOOP_XYZE(i) values[i] = parser.intval(axis_codes[i]); + + #define TMC_SET_GET_PWMTHRS(P,Q) do { \ + if (values[P##_AXIS]) tmc_set_pwmthrs(stepper##Q, extended_axis_codes[TMC_##Q], values[P##_AXIS], planner.axis_steps_per_mm[P##_AXIS]); \ + else tmc_get_pwmthrs(stepper##Q, extended_axis_codes[TMC_##Q], planner.axis_steps_per_mm[P##_AXIS]); } while(0) #if X_IS_TRINAMIC - if (values[X_AXIS]) tmc_set_pwmthrs(stepperX, extended_axis_codes[TMC_X], values[X_AXIS], planner.axis_steps_per_mm[X_AXIS]); - else tmc_get_pwmthrs(stepperX, extended_axis_codes[TMC_X], planner.axis_steps_per_mm[X_AXIS]); + TMC_SET_GET_PWMTHRS(X,X); #endif #if X2_IS_TRINAMIC - if (values[X_AXIS]) tmc_set_pwmthrs(stepperX2, extended_axis_codes[TMC_X2], values[X_AXIS], planner.axis_steps_per_mm[X_AXIS]); - else tmc_get_pwmthrs(stepperX, extended_axis_codes[TMC_X2], planner.axis_steps_per_mm[X_AXIS]); + TMC_SET_GET_PWMTHRS(X,X2); #endif - #if Y_IS_TRINAMIC - if (values[Y_AXIS]) tmc_set_pwmthrs(stepperY, extended_axis_codes[TMC_Y], values[Y_AXIS], planner.axis_steps_per_mm[Y_AXIS]); - else tmc_get_pwmthrs(stepperY, extended_axis_codes[TMC_Y], planner.axis_steps_per_mm[Y_AXIS]); + TMC_SET_GET_PWMTHRS(Y,Y); #endif #if Y2_IS_TRINAMIC - if (values[Y_AXIS]) tmc_set_pwmthrs(stepperY2, extended_axis_codes[TMC_Y2], values[Y_AXIS], planner.axis_steps_per_mm[Y_AXIS]); - else tmc_get_pwmthrs(stepperY, extended_axis_codes[TMC_Y2], planner.axis_steps_per_mm[Y_AXIS]); + TMC_SET_GET_PWMTHRS(Y,Y2); #endif - #if Z_IS_TRINAMIC - if (values[Z_AXIS]) tmc_set_pwmthrs(stepperZ, extended_axis_codes[TMC_Z], values[Z_AXIS], planner.axis_steps_per_mm[Z_AXIS]); - else tmc_get_pwmthrs(stepperZ, extended_axis_codes[TMC_Z], planner.axis_steps_per_mm[Z_AXIS]); + TMC_SET_GET_PWMTHRS(Z,Z); #endif #if Z2_IS_TRINAMIC - if (values[Z_AXIS]) tmc_set_pwmthrs(stepperZ2, extended_axis_codes[TMC_Z2], values[Z_AXIS], planner.axis_steps_per_mm[Z_AXIS]); - else tmc_get_pwmthrs(stepperZ, extended_axis_codes[TMC_Z2], planner.axis_steps_per_mm[Z_AXIS]); + TMC_SET_GET_PWMTHRS(Z,Z2); #endif - #if E0_IS_TRINAMIC - if (values[E_AXIS]) tmc_set_pwmthrs(stepperE0, extended_axis_codes[TMC_E0], values[E_AXIS], planner.axis_steps_per_mm[E_AXIS]); - else tmc_get_pwmthrs(stepperE0, extended_axis_codes[TMC_E0], planner.axis_steps_per_mm[E_AXIS]); + TMC_SET_GET_PWMTHRS(E,E0); #endif #if E1_IS_TRINAMIC - if (values[E_AXIS]) tmc_set_pwmthrs(stepperE1, extended_axis_codes[TMC_E1], values[E_AXIS], planner.axis_steps_per_mm[E_AXIS]); - else tmc_get_pwmthrs(stepperE1, extended_axis_codes[TMC_E1], planner.axis_steps_per_mm[E_AXIS]); + TMC_SET_GET_PWMTHRS(E,E1); #endif #if E2_IS_TRINAMIC - if (values[E_AXIS]) tmc_set_pwmthrs(stepperE2, extended_axis_codes[TMC_E2], values[E_AXIS], planner.axis_steps_per_mm[E_AXIS]); - else tmc_get_pwmthrs(stepperE2, extended_axis_codes[TMC_E2], planner.axis_steps_per_mm[E_AXIS]); + TMC_SET_GET_PWMTHRS(E,E2); #endif #if E3_IS_TRINAMIC - if (values[E_AXIS]) tmc_set_pwmthrs(stepperE3, extended_axis_codes[TMC_E3], values[E_AXIS], planner.axis_steps_per_mm[E_AXIS]); - else tmc_get_pwmthrs(stepperE3, extended_axis_codes[TMC_E3], planner.axis_steps_per_mm[E_AXIS]); + TMC_SET_GET_PWMTHRS(E,E3); #endif #if E4_IS_TRINAMIC - if (values[E_AXIS]) tmc_set_pwmthrs(stepperE4, extended_axis_codes[TMC_E4], values[E_AXIS], planner.axis_steps_per_mm[E_AXIS]); - else tmc_get_pwmthrs(stepperE4, extended_axis_codes[TMC_E4], planner.axis_steps_per_mm[E_AXIS]); + TMC_SET_GET_PWMTHRS(E,E4); #endif } #endif // HYBRID_THRESHOLD @@ -139,21 +128,21 @@ void GcodeSuite::M912() { */ #if ENABLED(SENSORLESS_HOMING) void GcodeSuite::M914() { + #define TMC_SET_GET_SGT(P,Q) do { \ + if (parser.seen(axis_codes[P##_AXIS])) tmc_set_sgt(stepper##Q, extended_axis_codes[TMC_##Q], parser.value_int()); \ + else tmc_get_sgt(stepper##Q, extended_axis_codes[TMC_##Q]); } while(0) + #if ENABLED(X_IS_TMC2130) || ENABLED(IS_TRAMS) - if (parser.seen(axis_codes[X_AXIS])) tmc_set_sgt(stepperX, extended_axis_codes[TMC_X], parser.value_int()); - else tmc_get_sgt(stepperX, extended_axis_codes[TMC_X]); + TMC_SET_GET_SGT(X,X); #endif #if ENABLED(X2_IS_TMC2130) - if (parser.seen(axis_codes[X_AXIS])) tmc_set_sgt(stepperX2, extended_axis_codes[TMC_X2], parser.value_int()); - else tmc_get_sgt(stepperX2, extended_axis_codes[TMC_X2]); + TMC_SET_GET_SGT(X,X2); #endif #if ENABLED(Y_IS_TMC2130) || ENABLED(IS_TRAMS) - if (parser.seen(axis_codes[Y_AXIS])) tmc_set_sgt(stepperY, extended_axis_codes[TMC_Y], parser.value_int()); - else tmc_get_sgt(stepperY, extended_axis_codes[TMC_Y]); + TMC_SET_GET_SGT(Y,Y); #endif #if ENABLED(Y2_IS_TMC2130) - if (parser.seen(axis_codes[Y_AXIS])) tmc_set_sgt(stepperY2, extended_axis_codes[TMC_Y2], parser.value_int()); - else tmc_get_sgt(stepperY2, extended_axis_codes[TMC_Y2]); + TMC_SET_GET_SGT(Y,Y2); #endif } #endif // SENSORLESS_HOMING diff --git a/Marlin/src/inc/Conditionals_post.h b/Marlin/src/inc/Conditionals_post.h index 36a8a0d94d..5ce961dcf0 100644 --- a/Marlin/src/inc/Conditionals_post.h +++ b/Marlin/src/inc/Conditionals_post.h @@ -679,6 +679,20 @@ #define HAS_E4_MICROSTEPS (PIN_EXISTS(E4_MS1)) #define HAS_SOLENOID_4 (PIN_EXISTS(SOL4)) +// Trinamic Stepper Drivers +#define HAS_TRINAMIC (ENABLED(HAVE_TMC2130) || ENABLED(HAVE_TMC2208) || ENABLED(IS_TRAMS)) +#define X_IS_TRINAMIC (ENABLED( X_IS_TMC2130) || ENABLED( X_IS_TMC2208) || ENABLED(IS_TRAMS)) +#define X2_IS_TRINAMIC (ENABLED(X2_IS_TMC2130) || ENABLED(X2_IS_TMC2208)) +#define Y_IS_TRINAMIC (ENABLED( Y_IS_TMC2130) || ENABLED( Y_IS_TMC2208) || ENABLED(IS_TRAMS)) +#define Y2_IS_TRINAMIC (ENABLED(Y2_IS_TMC2130) || ENABLED(Y2_IS_TMC2208)) +#define Z_IS_TRINAMIC (ENABLED( Z_IS_TMC2130) || ENABLED( Z_IS_TMC2208) || ENABLED(IS_TRAMS)) +#define Z2_IS_TRINAMIC (ENABLED(Z2_IS_TMC2130) || ENABLED(Z2_IS_TMC2208)) +#define E0_IS_TRINAMIC (ENABLED(E0_IS_TMC2130) || ENABLED(E0_IS_TMC2208) || ENABLED(IS_TRAMS)) +#define E1_IS_TRINAMIC (ENABLED(E1_IS_TMC2130) || ENABLED(E1_IS_TMC2208)) +#define E2_IS_TRINAMIC (ENABLED(E2_IS_TMC2130) || ENABLED(E2_IS_TMC2208)) +#define E3_IS_TRINAMIC (ENABLED(E3_IS_TMC2130) || ENABLED(E3_IS_TMC2208)) +#define E4_IS_TRINAMIC (ENABLED(E4_IS_TMC2130) || ENABLED(E4_IS_TMC2208)) + // Endstops and bed probe #define HAS_X_MIN (PIN_EXISTS(X_MIN) && !IS_X2_ENDSTOP(X,MIN) && !IS_Y2_ENDSTOP(X,MIN) && !IS_Z2_OR_PROBE(X,MIN)) #define HAS_X_MAX (PIN_EXISTS(X_MAX) && !IS_X2_ENDSTOP(X,MAX) && !IS_Y2_ENDSTOP(X,MAX) && !IS_Z2_OR_PROBE(X,MAX)) diff --git a/Marlin/src/inc/MarlinConfigPre.h b/Marlin/src/inc/MarlinConfigPre.h index bb0642f986..fb7258fb0a 100644 --- a/Marlin/src/inc/MarlinConfigPre.h +++ b/Marlin/src/inc/MarlinConfigPre.h @@ -28,7 +28,6 @@ #include "Version.h" #include "../../Configuration.h" #include "Conditionals_LCD.h" -#include "../feature/tmc_macros.h" #include "../../Configuration_adv.h" #include "Conditionals_adv.h" diff --git a/Marlin/src/inc/SanityCheck.h b/Marlin/src/inc/SanityCheck.h index f4278a9d69..c169cf0d27 100644 --- a/Marlin/src/inc/SanityCheck.h +++ b/Marlin/src/inc/SanityCheck.h @@ -1491,8 +1491,6 @@ static_assert(1 >= 0 #error "Enable STEALTHCHOP to use HYBRID_THRESHOLD." #endif -#include "../feature/tmc_macros.h" - #if ENABLED(TMC_Z_CALIBRATION) && !Z_IS_TRINAMIC && !Z2_IS_TRINAMIC #error "TMC_Z_CALIBRATION requires at least one TMC driver on Z axis" #endif