Browse Source

Improve Trinamic support in the EEPROM

Scott Lahteine 7 years ago
parent
commit
c95450016b
2 changed files with 272 additions and 170 deletions
  1. 1
    1
      Marlin/src/feature/tmc_util.h
  2. 271
    169
      Marlin/src/module/configuration_store.cpp

+ 1
- 1
Marlin/src/feature/tmc_util.h View File

@@ -35,7 +35,7 @@
35 35
 
36 36
 extern bool report_tmc_status;
37 37
 
38
-enum TMC_AxisEnum : char { TMC_X, TMC_X2, TMC_Y, TMC_Y2, TMC_Z, TMC_Z2, TMC_E0, TMC_E1, TMC_E2, TMC_E3, TMC_E4 };
38
+enum TMC_AxisEnum : char { TMC_X, TMC_Y, TMC_Z, TMC_X2, TMC_Y2, TMC_Z2, TMC_E0, TMC_E1, TMC_E2, TMC_E3, TMC_E4 };
39 39
 
40 40
 constexpr uint32_t _tmc_thrs(const uint16_t msteps, const int32_t thrs, const uint32_t spmm) {
41 41
   return 12650000UL * msteps / (256 * thrs * spmm);

+ 271
- 169
Marlin/src/module/configuration_store.cpp View File

@@ -37,7 +37,7 @@
37 37
  */
38 38
 
39 39
 // Change EEPROM version if the structure changes
40
-#define EEPROM_VERSION "V52"
40
+#define EEPROM_VERSION "V53"
41 41
 #define EEPROM_OFFSET 100
42 42
 
43 43
 // Check the integrity of data offsets.
@@ -74,8 +74,10 @@
74 74
   #include "../module/probe.h"
75 75
 #endif
76 76
 
77
-#if ENABLED(HAVE_TMC2130)
77
+#if HAS_TRINAMIC
78 78
   #include "stepper_indirection.h"
79
+  #include "../feature/tmc_util.h"
80
+  #define TMC_GET_PWMTHRS(P,Q) _tmc_thrs(stepper##Q.microsteps(), stepper##Q.TPWMTHRS(), planner.axis_steps_per_mm[P##_AXIS])
79 81
 #endif
80 82
 
81 83
 #if ENABLED(FWRETRACT)
@@ -230,7 +232,9 @@ typedef struct SettingsDataStruct {
230 232
   //
231 233
   // HAS_TRINAMIC
232 234
   //
233
-  uint16_t tmc_stepper_current[11];                     // M906 X Y Z X2 Y2 Z2 E0 E1 E2 E3 E4
235
+  #define TMC_AXES (MAX_EXTRUDERS + 6)
236
+  uint16_t tmc_stepper_current[TMC_AXES];               // M906 X Y Z X2 Y2 Z2 E0 E1 E2 E3 E4
237
+  uint32_t tmc_hybrid_threshold[TMC_AXES];              // M913 X Y Z X2 Y2 Z2 E0 E1 E2 E3 E4
234 238
   int16_t tmc_sgt[XYZ];                                 // M914 X Y Z
235 239
 
236 240
   //
@@ -658,7 +662,7 @@ void MarlinSettings::postprocess() {
658 662
 
659 663
     _FIELD_TEST(tmc_stepper_current);
660 664
 
661
-    uint16_t currents[11] = {
665
+    uint16_t tmc_stepper_current[TMC_AXES] = {
662 666
       #if HAS_TRINAMIC
663 667
         #if X_IS_TRINAMIC
664 668
           stepperX.getCurrent(),
@@ -719,24 +723,95 @@ void MarlinSettings::postprocess() {
719 723
         0
720 724
       #endif
721 725
     };
722
-    EEPROM_WRITE(currents);
726
+    EEPROM_WRITE(tmc_stepper_current);
727
+
728
+    //
729
+    // Save TMC2130 or TMC2208 Hybrid Threshold, and placeholder values
730
+    //
731
+
732
+    _FIELD_TEST(tmc_hybrid_threshold);
733
+
734
+    uint32_t tmc_hybrid_threshold[TMC_AXES] = {
735
+      #if HAS_TRINAMIC
736
+        #if X_IS_TRINAMIC
737
+          TMC_GET_PWMTHRS(X, X),
738
+        #else
739
+          X_HYBRID_THRESHOLD,
740
+        #endif
741
+        #if Y_IS_TRINAMIC
742
+          TMC_GET_PWMTHRS(Y, Y),
743
+        #else
744
+          Y_HYBRID_THRESHOLD,
745
+        #endif
746
+        #if Z_IS_TRINAMIC
747
+          TMC_GET_PWMTHRS(Z, Z),
748
+        #else
749
+          Z_HYBRID_THRESHOLD,
750
+        #endif
751
+        #if X2_IS_TRINAMIC
752
+          TMC_GET_PWMTHRS(X, X2),
753
+        #else
754
+          X2_HYBRID_THRESHOLD,
755
+        #endif
756
+        #if Y2_IS_TRINAMIC
757
+          TMC_GET_PWMTHRS(Y, Y2),
758
+        #else
759
+          Y2_HYBRID_THRESHOLD,
760
+        #endif
761
+        #if Z2_IS_TRINAMIC
762
+          TMC_GET_PWMTHRS(Z, Z2),
763
+        #else
764
+          Z2_HYBRID_THRESHOLD,
765
+        #endif
766
+        #if E0_IS_TRINAMIC
767
+          TMC_GET_PWMTHRS(E, E0),
768
+        #else
769
+          E0_HYBRID_THRESHOLD,
770
+        #endif
771
+        #if E1_IS_TRINAMIC
772
+          TMC_GET_PWMTHRS(E, E1),
773
+        #else
774
+          E1_HYBRID_THRESHOLD,
775
+        #endif
776
+        #if E2_IS_TRINAMIC
777
+          TMC_GET_PWMTHRS(E, E2),
778
+        #else
779
+          E2_HYBRID_THRESHOLD,
780
+        #endif
781
+        #if E3_IS_TRINAMIC
782
+          TMC_GET_PWMTHRS(E, E3),
783
+        #else
784
+          E3_HYBRID_THRESHOLD,
785
+        #endif
786
+        #if E4_IS_TRINAMIC
787
+          TMC_GET_PWMTHRS(E, E4)
788
+        #else
789
+          E4_HYBRID_THRESHOLD
790
+        #endif
791
+      #else
792
+        100, 100, 3,          // X, Y, Z
793
+        100, 100, 3,          // X2, Y2, Z2
794
+        30, 30, 30, 30, 30    // E0, E1, E2, E3, E4
795
+      #endif
796
+    };
797
+    EEPROM_WRITE(tmc_hybrid_threshold);
723 798
 
724 799
     //
725 800
     // TMC2130 Sensorless homing threshold
726 801
     //
727
-    int16_t thrs[XYZ] = {
802
+    int16_t tmc_sgt[XYZ] = {
728 803
       #if ENABLED(SENSORLESS_HOMING)
729
-        #if ENABLED(X_IS_TMC2130) && defined(X_HOMING_SENSITIVITY)
804
+        #if defined(X_HOMING_SENSITIVITY) && (ENABLED(X_IS_TMC2130) || ENABLED(IS_TRAMS))
730 805
           stepperX.sgt(),
731 806
         #else
732 807
           0,
733 808
         #endif
734
-        #if ENABLED(Y_IS_TMC2130) && defined(Y_HOMING_SENSITIVITY)
809
+        #if defined(Y_HOMING_SENSITIVITY) && (ENABLED(Y_IS_TMC2130) || ENABLED(IS_TRAMS))
735 810
           stepperY.sgt(),
736 811
         #else
737 812
           0
738 813
         #endif
739
-        #if ENABLED(Z_IS_TMC2130) && defined(Z_HOMING_SENSITIVITY)
814
+        #if defined(Z_HOMING_SENSITIVITY) && (ENABLED(Z_IS_TMC2130) || ENABLED(IS_TRAMS))
740 815
           stepperZ.sgt()
741 816
         #else
742 817
           0
@@ -745,7 +820,7 @@ void MarlinSettings::postprocess() {
745 820
         0
746 821
       #endif
747 822
     };
748
-    EEPROM_WRITE(thrs);
823
+    EEPROM_WRITE(tmc_sgt);
749 824
 
750 825
     //
751 826
     // Linear Advance
@@ -794,7 +869,7 @@ void MarlinSettings::postprocess() {
794 869
       EEPROM_WRITE(planner.yz_skew_factor);
795 870
     #else
796 871
       dummy = 0.0f;
797
-      for (uint8_t q = XYZ; q--;) EEPROM_WRITE(dummy);
872
+      for (uint8_t q = 3; q--;) EEPROM_WRITE(dummy);
798 873
     #endif
799 874
 
800 875
     //
@@ -1197,54 +1272,101 @@ void MarlinSettings::postprocess() {
1197 1272
 
1198 1273
       #endif
1199 1274
 
1275
+      if (!validating) reset_stepper_drivers();
1276
+
1200 1277
       //
1201
-      // TMC2130 Stepper Current
1278
+      // TMC2130 Stepper Settings
1202 1279
       //
1203 1280
 
1204 1281
       _FIELD_TEST(tmc_stepper_current);
1205 1282
 
1206 1283
       #if HAS_TRINAMIC
1207
-        #define SET_CURR(N,Q) stepper##Q.setCurrent(currents[N] ? currents[N] : Q##_CURRENT, R_SENSE, HOLD_MULTIPLIER)
1208
-        uint16_t currents[11];
1284
+
1285
+        #define SET_CURR(Q) stepper##Q.setCurrent(currents[TMC_##Q] ? currents[TMC_##Q] : Q##_CURRENT, R_SENSE, HOLD_MULTIPLIER)
1286
+        uint16_t currents[TMC_AXES];
1209 1287
         EEPROM_READ(currents);
1210 1288
         if (!validating) {
1211 1289
           #if X_IS_TRINAMIC
1212
-            SET_CURR(0, X);
1290
+            SET_CURR(X);
1213 1291
           #endif
1214 1292
           #if Y_IS_TRINAMIC
1215
-            SET_CURR(1, Y);
1293
+            SET_CURR(Y);
1216 1294
           #endif
1217 1295
           #if Z_IS_TRINAMIC
1218
-            SET_CURR(2, Z);
1296
+            SET_CURR(Z);
1219 1297
           #endif
1220 1298
           #if X2_IS_TRINAMIC
1221
-            SET_CURR(3, X2);
1299
+            SET_CURR(X2);
1222 1300
           #endif
1223 1301
           #if Y2_IS_TRINAMIC
1224
-            SET_CURR(4, Y2);
1302
+            SET_CURR(Y2);
1225 1303
           #endif
1226 1304
           #if Z2_IS_TRINAMIC
1227
-            SET_CURR(5, Z2);
1305
+            SET_CURR(Z2);
1228 1306
           #endif
1229 1307
           #if E0_IS_TRINAMIC
1230
-            SET_CURR(6, E0);
1308
+            SET_CURR(E0);
1231 1309
           #endif
1232 1310
           #if E1_IS_TRINAMIC
1233
-            SET_CURR(7, E1);
1311
+            SET_CURR(E1);
1234 1312
           #endif
1235 1313
           #if E2_IS_TRINAMIC
1236
-            SET_CURR(8, E2);
1314
+            SET_CURR(E2);
1237 1315
           #endif
1238 1316
           #if E3_IS_TRINAMIC
1239
-            SET_CURR(9, E3);
1317
+            SET_CURR(E3);
1240 1318
           #endif
1241 1319
           #if E4_IS_TRINAMIC
1242
-            SET_CURR(10, E4);
1320
+            SET_CURR(E4);
1243 1321
           #endif
1244 1322
         }
1245 1323
       #else
1246 1324
         uint16_t val;
1247
-        for (uint8_t q=11; q--;) EEPROM_READ(val);
1325
+        for (uint8_t q=TMC_AXES; q--;) EEPROM_READ(val);
1326
+      #endif
1327
+
1328
+      #if HAS_TRINAMIC
1329
+        #define TMC_SET_PWMTHRS(P,Q) tmc_set_pwmthrs(stepper##Q, TMC_##Q, tmc_hybrid_threshold[TMC_##Q], planner.axis_steps_per_mm[P##_AXIS])
1330
+        uint16_t tmc_hybrid_threshold[TMC_AXES];
1331
+        EEPROM_READ(tmc_hybrid_threshold);
1332
+        if (!validating) {
1333
+          #if X_IS_TRINAMIC
1334
+            TMC_SET_PWMTHRS(X, X);
1335
+          #endif
1336
+          #if Y_IS_TRINAMIC
1337
+            TMC_SET_PWMTHRS(Y, Y);
1338
+          #endif
1339
+          #if Z_IS_TRINAMIC
1340
+            TMC_SET_PWMTHRS(Z, Z);
1341
+          #endif
1342
+          #if X2_IS_TRINAMIC
1343
+            TMC_SET_PWMTHRS(X, X2);
1344
+          #endif
1345
+          #if Y2_IS_TRINAMIC
1346
+            TMC_SET_PWMTHRS(Y, Y2);
1347
+          #endif
1348
+          #if Z2_IS_TRINAMIC
1349
+            TMC_SET_PWMTHRS(Z, Z2);
1350
+          #endif
1351
+          #if E0_IS_TRINAMIC
1352
+            TMC_SET_PWMTHRS(E, E0);
1353
+          #endif
1354
+          #if E1_IS_TRINAMIC
1355
+            TMC_SET_PWMTHRS(E, E1);
1356
+          #endif
1357
+          #if E2_IS_TRINAMIC
1358
+            TMC_SET_PWMTHRS(E, E2);
1359
+          #endif
1360
+          #if E3_IS_TRINAMIC
1361
+            TMC_SET_PWMTHRS(E, E3);
1362
+          #endif
1363
+          #if E4_IS_TRINAMIC
1364
+            TMC_SET_PWMTHRS(E, E4);
1365
+          #endif
1366
+        }
1367
+      #else
1368
+        uint16_t thrs_val;
1369
+        for (uint8_t q=TMC_AXES; q--;) EEPROM_READ(thrs_val);
1248 1370
       #endif
1249 1371
 
1250 1372
       /*
@@ -1253,32 +1375,32 @@ void MarlinSettings::postprocess() {
1253 1375
        * Y and Y2 use the same value
1254 1376
        * Z and Z2 use the same value
1255 1377
        */
1256
-      int16_t thrs[XYZ];
1257
-      EEPROM_READ(thrs);
1378
+      int16_t tmc_sgt[XYZ];
1379
+      EEPROM_READ(tmc_sgt);
1258 1380
       #if ENABLED(SENSORLESS_HOMING)
1259 1381
         if (!validating) {
1260 1382
           #ifdef X_HOMING_SENSITIVITY
1261
-            #if ENABLED(X_IS_TMC2130)
1262
-              stepperX.sgt(thrs[0]);
1383
+            #if ENABLED(X_IS_TMC2130) || ENABLED(IS_TRAMS)
1384
+              stepperX.sgt(tmc_sgt[0]);
1263 1385
             #endif
1264 1386
             #if ENABLED(X2_IS_TMC2130)
1265
-              stepperX2.sgt(thrs[0]);
1387
+              stepperX2.sgt(tmc_sgt[0]);
1266 1388
             #endif
1267 1389
           #endif
1268 1390
           #ifdef Y_HOMING_SENSITIVITY
1269
-            #if ENABLED(Y_IS_TMC2130)
1270
-              stepperY.sgt(thrs[1]);
1391
+            #if ENABLED(Y_IS_TMC2130) || ENABLED(IS_TRAMS)
1392
+              stepperY.sgt(tmc_sgt[1]);
1271 1393
             #endif
1272 1394
             #if ENABLED(Y2_IS_TMC2130)
1273
-              stepperY2.sgt(thrs[1]);
1395
+              stepperY2.sgt(tmc_sgt[1]);
1274 1396
             #endif
1275 1397
           #endif
1276 1398
           #ifdef Z_HOMING_SENSITIVITY
1277
-            #if ENABLED(Z_IS_TMC2130)
1278
-              stepperZ.sgt(thrs[2]);
1399
+            #if ENABLED(Z_IS_TMC2130) || ENABLED(IS_TRAMS)
1400
+              stepperZ.sgt(tmc_sgt[2]);
1279 1401
             #endif
1280 1402
             #if ENABLED(Z2_IS_TMC2130)
1281
-              stepperZ2.sgt(thrs[2]);
1403
+              stepperZ2.sgt(tmc_sgt[2]);
1282 1404
             #endif
1283 1405
           #endif
1284 1406
         }
@@ -1338,7 +1460,7 @@ void MarlinSettings::postprocess() {
1338 1460
           EEPROM_READ(dummy);
1339 1461
         #endif
1340 1462
       #else
1341
-        for (uint8_t q = XYZ; q--;) EEPROM_READ(dummy);
1463
+        for (uint8_t q = 3; q--;) EEPROM_READ(dummy);
1342 1464
       #endif
1343 1465
 
1344 1466
       //
@@ -1731,66 +1853,7 @@ void MarlinSettings::reset(PORTARG_SOLO) {
1731 1853
     #endif
1732 1854
   );
1733 1855
 
1734
-  #if X_IS_TRINAMIC
1735
-    stepperX.setCurrent(X_CURRENT, R_SENSE, HOLD_MULTIPLIER);
1736
-  #endif
1737
-  #if Y_IS_TRINAMIC
1738
-    stepperY.setCurrent(Y_CURRENT, R_SENSE, HOLD_MULTIPLIER);
1739
-  #endif
1740
-  #if Z_IS_TRINAMIC
1741
-    stepperZ.setCurrent(Z_CURRENT, R_SENSE, HOLD_MULTIPLIER);
1742
-  #endif
1743
-  #if X2_IS_TRINAMIC
1744
-    stepperX2.setCurrent(X2_CURRENT, R_SENSE, HOLD_MULTIPLIER);
1745
-  #endif
1746
-  #if Y2_IS_TRINAMIC
1747
-    stepperY2.setCurrent(Y2_CURRENT, R_SENSE, HOLD_MULTIPLIER);
1748
-  #endif
1749
-  #if Z2_IS_TRINAMIC
1750
-    stepperZ2.setCurrent(Z2_CURRENT, R_SENSE, HOLD_MULTIPLIER);
1751
-  #endif
1752
-  #if E0_IS_TRINAMIC
1753
-    stepperE0.setCurrent(E0_CURRENT, R_SENSE, HOLD_MULTIPLIER);
1754
-  #endif
1755
-  #if E1_IS_TRINAMIC
1756
-    stepperE1.setCurrent(E1_CURRENT, R_SENSE, HOLD_MULTIPLIER);
1757
-  #endif
1758
-  #if E2_IS_TRINAMIC
1759
-    stepperE2.setCurrent(E2_CURRENT, R_SENSE, HOLD_MULTIPLIER);
1760
-  #endif
1761
-  #if E3_IS_TRINAMIC
1762
-    stepperE3.setCurrent(E3_CURRENT, R_SENSE, HOLD_MULTIPLIER);
1763
-  #endif
1764
-  #if E4_IS_TRINAMIC
1765
-    stepperE4.setCurrent(E4_CURRENT, R_SENSE, HOLD_MULTIPLIER);
1766
-  #endif
1767
-
1768
-  #if ENABLED(SENSORLESS_HOMING)
1769
-    #ifdef X_HOMING_SENSITIVITY
1770
-      #if ENABLED(X_IS_TMC2130)
1771
-        stepperX.sgt(X_HOMING_SENSITIVITY);
1772
-      #endif
1773
-      #if ENABLED(X2_IS_TMC2130)
1774
-        stepperX2.sgt(X_HOMING_SENSITIVITY);
1775
-      #endif
1776
-    #endif
1777
-    #ifdef Y_HOMING_SENSITIVITY
1778
-      #if ENABLED(Y_IS_TMC2130)
1779
-        stepperY.sgt(Y_HOMING_SENSITIVITY);
1780
-      #endif
1781
-      #if ENABLED(Y2_IS_TMC2130)
1782
-        stepperY2.sgt(Y_HOMING_SENSITIVITY);
1783
-      #endif
1784
-    #endif
1785
-    #ifdef Z_HOMING_SENSITIVITY
1786
-      #if ENABLED(Z_IS_TMC2130)
1787
-        stepperZ.sgt(Z_HOMING_SENSITIVITY);
1788
-      #endif
1789
-      #if ENABLED(Z2_IS_TMC2130)
1790
-        stepperZ2.sgt(Z_HOMING_SENSITIVITY);
1791
-      #endif
1792
-    #endif
1793
-  #endif
1856
+  reset_stepper_drivers();
1794 1857
 
1795 1858
   #if ENABLED(LIN_ADVANCE)
1796 1859
     planner.extruder_advance_K = LIN_ADVANCE_K;
@@ -1829,6 +1892,10 @@ void MarlinSettings::reset(PORTARG_SOLO) {
1829 1892
 
1830 1893
   #define CONFIG_ECHO_START do{ if (!forReplay) SERIAL_ECHO_START_P(port); }while(0)
1831 1894
 
1895
+  #if ENABLED(ADVANCED_PAUSE_FEATURE)
1896
+    void say_M603() { SERIAL_ECHOPGM_P(port, "  M603 "); }
1897
+  #endif
1898
+
1832 1899
   /**
1833 1900
    * M503 - Report current settings in RAM
1834 1901
    *
@@ -1849,7 +1916,7 @@ void MarlinSettings::reset(PORTARG_SOLO) {
1849 1916
       SERIAL_ECHOPGM_P(port, "  G2");
1850 1917
       SERIAL_CHAR_P(port, parser.linear_unit_factor == 1.0 ? '1' : '0');
1851 1918
       SERIAL_ECHOPGM_P(port, " ; Units in ");
1852
-      serialprintPGM(parser.linear_unit_factor == 1.0 ? PSTR("mm\n") : PSTR("inches\n"));
1919
+      serialprintPGM_P(port, parser.linear_unit_factor == 1.0 ? PSTR("mm\n") : PSTR("inches\n"));
1853 1920
     #else
1854 1921
       #define LINEAR_UNIT(N) (N)
1855 1922
       #define VOLUMETRIC_UNIT(N) (N)
@@ -2076,7 +2143,7 @@ void MarlinSettings::reset(PORTARG_SOLO) {
2076 2143
               SERIAL_ECHOPAIR_P(port, "  G29 S3 X", (int)px + 1);
2077 2144
               SERIAL_ECHOPAIR_P(port, " Y", (int)py + 1);
2078 2145
               SERIAL_ECHOPGM_P(port, " Z");
2079
-              SERIAL_PROTOCOL_F_P(port, LINEAR_UNIT(mbl.z_values[px][py]), 5);
2146
+              SERIAL_ECHO_F_P(port, LINEAR_UNIT(mbl.z_values[px][py]), 5);
2080 2147
               SERIAL_EOL_P(port);
2081 2148
             }
2082 2149
           }
@@ -2103,7 +2170,7 @@ void MarlinSettings::reset(PORTARG_SOLO) {
2103 2170
               SERIAL_ECHOPAIR_P(port, "  G29 W I", (int)px + 1);
2104 2171
               SERIAL_ECHOPAIR_P(port, " J", (int)py + 1);
2105 2172
               SERIAL_ECHOPGM_P(port, " Z");
2106
-              SERIAL_PROTOCOL_F_P(port, LINEAR_UNIT(z_values[px][py]), 5);
2173
+              SERIAL_ECHO_F_P(port, LINEAR_UNIT(z_values[px][py]), 5);
2107 2174
               SERIAL_EOL_P(port);
2108 2175
             }
2109 2176
           }
@@ -2289,95 +2356,124 @@ void MarlinSettings::reset(PORTARG_SOLO) {
2289 2356
         SERIAL_ECHOPGM_P(port, " K");
2290 2357
         SERIAL_ECHO_F_P(port, LINEAR_UNIT(planner.yz_skew_factor), 6);
2291 2358
         SERIAL_EOL_P(port);
2292
-       #else
2359
+      #else
2293 2360
         SERIAL_ECHOPGM_P(port, "  M852 S");
2294 2361
         SERIAL_ECHO_F_P(port, LINEAR_UNIT(planner.xy_skew_factor), 6);
2295 2362
         SERIAL_EOL_P(port);
2296 2363
       #endif
2297 2364
     #endif
2298 2365
 
2299
-    /**
2300
-     * TMC2130 stepper driver current
2301
-     */
2302 2366
     #if HAS_TRINAMIC
2367
+
2368
+      /**
2369
+       * TMC2130 / TMC2208 / TRAMS stepper driver current
2370
+       */
2303 2371
       if (!forReplay) {
2304 2372
         CONFIG_ECHO_START;
2305 2373
         SERIAL_ECHOLNPGM_P(port, "Stepper driver current:");
2306 2374
       }
2307 2375
       CONFIG_ECHO_START;
2308 2376
       SERIAL_ECHOPGM_P(port, "  M906");
2309
-      #if ENABLED(X_IS_TMC2130) || ENABLED(X_IS_TMC2208)
2310
-        SERIAL_ECHOPAIR_P(port, " X ", stepperX.getCurrent());
2377
+      #if X_IS_TRINAMIC
2378
+        SERIAL_ECHOPAIR_P(port, " X", stepperX.getCurrent());
2379
+      #elif X2_IS_TRINAMIC
2380
+        SERIAL_ECHOPAIR_P(port, " X", stepperX2.getCurrent());
2311 2381
       #endif
2312
-      #if ENABLED(Y_IS_TMC2130) || ENABLED(Y_IS_TMC2208)
2313
-        SERIAL_ECHOPAIR_P(port, " Y ", stepperY.getCurrent());
2382
+      #if Y_IS_TRINAMIC
2383
+        SERIAL_ECHOPAIR_P(port, " Y", stepperY.getCurrent());
2384
+      #elif Y2_IS_TRINAMIC
2385
+        SERIAL_ECHOPAIR_P(port, " Y", stepperY2.getCurrent());
2314 2386
       #endif
2315
-      #if ENABLED(Z_IS_TMC2130) || ENABLED(Z_IS_TMC2208)
2316
-        SERIAL_ECHOPAIR_P(port, " Z ", stepperZ.getCurrent());
2387
+      #if Z_IS_TRINAMIC
2388
+        SERIAL_ECHOPAIR_P(port, " Z", stepperZ.getCurrent());
2389
+      #elif Z2_IS_TRINAMIC
2390
+        SERIAL_ECHOPAIR_P(port, " Z", stepperZ2.getCurrent());
2317 2391
       #endif
2318
-      #if ENABLED(X2_IS_TMC2130) || ENABLED(X2_IS_TMC2208)
2319
-        SERIAL_ECHOPAIR_P(port, " X2 ", stepperX2.getCurrent());
2392
+      #if E0_IS_TRINAMIC
2393
+        SERIAL_ECHOPAIR_P(port, " E", stepperE0.getCurrent());
2394
+      #elif E1_IS_TRINAMIC
2395
+        SERIAL_ECHOPAIR_P(port, " E", stepperE1.getCurrent());
2396
+      #elif E2_IS_TRINAMIC
2397
+        SERIAL_ECHOPAIR_P(port, " E", stepperE2.getCurrent());
2398
+      #elif E3_IS_TRINAMIC
2399
+        SERIAL_ECHOPAIR_P(port, " E", stepperE3.getCurrent());
2400
+      #elif E4_IS_TRINAMIC
2401
+        SERIAL_ECHOPAIR_P(port, " E", stepperE4.getCurrent());
2320 2402
       #endif
2321
-      #if ENABLED(Y2_IS_TMC2130) || ENABLED(Y2_IS_TMC2208)
2322
-        SERIAL_ECHOPAIR_P(port, " Y2 ", stepperY2.getCurrent());
2323
-      #endif
2324
-      #if ENABLED(Z2_IS_TMC2130) || ENABLED(Z2_IS_TMC2208)
2325
-        SERIAL_ECHOPAIR_P(port, " Z2 ", stepperZ2.getCurrent());
2326
-      #endif
2327
-      #if ENABLED(E0_IS_TMC2130) || ENABLED(E0_IS_TMC2208)
2328
-        SERIAL_ECHOPAIR_P(port, " E0 ", stepperE0.getCurrent());
2329
-      #endif
2330
-      #if ENABLED(E1_IS_TMC2130) || ENABLED(E1_IS_TMC2208)
2331
-        SERIAL_ECHOPAIR_P(port, " E1 ", stepperE1.getCurrent());
2332
-      #endif
2333
-      #if ENABLED(E2_IS_TMC2130) || ENABLED(E2_IS_TMC2208)
2334
-        SERIAL_ECHOPAIR_P(port, " E2 ", stepperE2.getCurrent());
2335
-      #endif
2336
-      #if ENABLED(E3_IS_TMC2130) || ENABLED(E3_IS_TMC2208)
2337
-        SERIAL_ECHOPAIR_P(port, " E3 ", stepperE3.getCurrent());
2338
-      #endif
2339
-      #if ENABLED(E4_IS_TMC2130) || ENABLED(E4_IS_TMC2208)
2340
-        SERIAL_ECHOPAIR_P(port, " E4 ", stepperE4.getCurrent());
2341
-      #endif
2342
-      SERIAL_EOL_P(port);
2343
-    #endif
2403
+      SERIAL_EOL();
2344 2404
 
2345
-    /**
2346
-     * TMC2130 Sensorless homing thresholds
2347
-     */
2348
-    #if ENABLED(SENSORLESS_HOMING)
2405
+      /**
2406
+       * TMC2130 / TMC2208 / TRAMS Hybrid Threshold
2407
+       */
2349 2408
       if (!forReplay) {
2350 2409
         CONFIG_ECHO_START;
2351
-        SERIAL_ECHOLNPGM_P(port, "Sensorless homing threshold:");
2410
+        SERIAL_ECHOLNPGM_P(port, "Hybrid Threshold:");
2352 2411
       }
2353 2412
       CONFIG_ECHO_START;
2354
-      SERIAL_ECHOPGM_P(port, "  M914");
2355
-      #ifdef X_HOMING_SENSITIVITY
2356
-        #if ENABLED(X_IS_TMC2130)
2357
-          SERIAL_ECHOPAIR_P(port, " X", stepperX.sgt());
2358
-        #endif
2359
-        #if ENABLED(X2_IS_TMC2130)
2360
-          SERIAL_ECHOPAIR_P(port, " X2 ", stepperX2.sgt());
2361
-        #endif
2413
+      SERIAL_ECHOPGM_P(port, "  M913");
2414
+      #if X_IS_TRINAMIC
2415
+        SERIAL_ECHOPAIR_P(port, " X", TMC_GET_PWMTHRS(X, X));
2416
+      #elif X2_IS_TRINAMIC
2417
+        SERIAL_ECHOPAIR_P(port, " X", TMC_GET_PWMTHRS(X, X2));
2362 2418
       #endif
2363
-      #ifdef Y_HOMING_SENSITIVITY
2364
-        #if ENABLED(Y_IS_TMC2130)
2365
-          SERIAL_ECHOPAIR_P(port, " Y", stepperY.sgt());
2366
-        #endif
2367
-        #if ENABLED(Y2_IS_TMC2130)
2368
-          SERIAL_ECHOPAIR_P(port, " Y2 ", stepperY2.sgt());
2369
-        #endif
2419
+      #if Y_IS_TRINAMIC
2420
+        SERIAL_ECHOPAIR_P(port, " Y", TMC_GET_PWMTHRS(Y, Y));
2421
+      #elif Y2_IS_TRINAMIC
2422
+        SERIAL_ECHOPAIR_P(port, " Y", TMC_GET_PWMTHRS(Y, Y2));
2370 2423
       #endif
2371
-      #ifdef Z_HOMING_SENSITIVITY
2372
-        #if ENABLED(Z_IS_TMC2130)
2373
-          SERIAL_ECHOPAIR_P(port, " Z ", stepperZ.sgt());
2424
+      #if Z_IS_TRINAMIC
2425
+        SERIAL_ECHOPAIR_P(port, " Z", TMC_GET_PWMTHRS(Z, Z));
2426
+      #elif Z2_IS_TRINAMIC
2427
+        SERIAL_ECHOPAIR_P(port, " Z", TMC_GET_PWMTHRS(Z, Z2));
2428
+      #endif
2429
+      #if E0_IS_TRINAMIC
2430
+        SERIAL_ECHOPAIR_P(port, " E", TMC_GET_PWMTHRS(E, E0));
2431
+      #elif E1_IS_TRINAMIC
2432
+        SERIAL_ECHOPAIR_P(port, " E", TMC_GET_PWMTHRS(E, E1));
2433
+      #elif E2_IS_TRINAMIC
2434
+        SERIAL_ECHOPAIR_P(port, " E", TMC_GET_PWMTHRS(E, E2));
2435
+      #elif E3_IS_TRINAMIC
2436
+        SERIAL_ECHOPAIR_P(port, " E", TMC_GET_PWMTHRS(E, E3));
2437
+      #elif E4_IS_TRINAMIC
2438
+        SERIAL_ECHOPAIR_P(port, " E", TMC_GET_PWMTHRS(E, E4));
2439
+      #endif
2440
+      SERIAL_EOL();
2441
+
2442
+      /**
2443
+       * TMC2130 Sensorless homing thresholds
2444
+       */
2445
+      #if ENABLED(SENSORLESS_HOMING)
2446
+        if (!forReplay) {
2447
+          CONFIG_ECHO_START;
2448
+          SERIAL_ECHOLNPGM_P(port, "Sensorless homing threshold:");
2449
+        }
2450
+        CONFIG_ECHO_START;
2451
+        SERIAL_ECHOPGM_P(port, "  M914");
2452
+        #ifdef X_HOMING_SENSITIVITY
2453
+          #if ENABLED(X_IS_TMC2130) || ENABLED(IS_TRAMS)
2454
+            SERIAL_ECHOPAIR_P(port, " X", stepperX.sgt());
2455
+          #elif ENABLED(X2_IS_TMC2130)
2456
+            SERIAL_ECHOPAIR_P(port, " X", stepperX2.sgt());
2457
+          #endif
2458
+        #endif
2459
+        #ifdef Y_HOMING_SENSITIVITY
2460
+          #if ENABLED(Y_IS_TMC2130) || ENABLED(IS_TRAMS)
2461
+            SERIAL_ECHOPAIR_P(port, " Y", stepperY.sgt());
2462
+          #elif ENABLED(Y2_IS_TMC2130)
2463
+            SERIAL_ECHOPAIR_P(port, " Y", stepperY2.sgt());
2464
+          #endif
2374 2465
         #endif
2375
-        #if ENABLED(Z2_IS_TMC2130)
2376
-          SERIAL_ECHOPAIR_P(port, " Z2 ", stepperZ2.sgt());
2466
+        #ifdef Z_HOMING_SENSITIVITY
2467
+          #if ENABLED(Z_IS_TMC2130) || ENABLED(IS_TRAMS)
2468
+            SERIAL_ECHOPAIR_P(port, " Z", stepperZ.sgt());
2469
+          #elif ENABLED(Z2_IS_TMC2130)
2470
+            SERIAL_ECHOPAIR_P(port, " Z", stepperZ2.sgt());
2471
+          #endif
2377 2472
         #endif
2473
+        SERIAL_EOL();
2378 2474
       #endif
2379
-      SERIAL_EOL_P(port);
2380
-    #endif
2475
+
2476
+    #endif // HAS_TRINAMIC
2381 2477
 
2382 2478
     /**
2383 2479
      * Linear Advance
@@ -2413,25 +2509,31 @@ void MarlinSettings::reset(PORTARG_SOLO) {
2413 2509
       }
2414 2510
       CONFIG_ECHO_START;
2415 2511
       #if EXTRUDERS == 1
2416
-        SERIAL_ECHOPAIR_P(port, "  M603 L", LINEAR_UNIT(filament_change_load_length[0]));
2512
+        say_M603();
2513
+        SERIAL_ECHOPAIR_P(port, "L", LINEAR_UNIT(filament_change_load_length[0]));
2417 2514
         SERIAL_ECHOLNPAIR_P(port, " U", LINEAR_UNIT(filament_change_unload_length[0]));
2418 2515
       #else
2419
-        SERIAL_ECHOPAIR_P(port, "  M603 T0 L", LINEAR_UNIT(filament_change_load_length[0]));
2516
+        say_M603();
2517
+        SERIAL_ECHOPAIR_P(port, "T0 L", LINEAR_UNIT(filament_change_load_length[0]));
2420 2518
         SERIAL_ECHOLNPAIR_P(port, " U", LINEAR_UNIT(filament_change_unload_length[0]));
2421 2519
         CONFIG_ECHO_START;
2422
-        SERIAL_ECHOPAIR_P(port, "  M603 T1 L", LINEAR_UNIT(filament_change_load_length[1]));
2520
+        say_M603();
2521
+        SERIAL_ECHOPAIR_P(port, "T1 L", LINEAR_UNIT(filament_change_load_length[1]));
2423 2522
         SERIAL_ECHOLNPAIR_P(port, " U", LINEAR_UNIT(filament_change_unload_length[1]));
2424 2523
         #if EXTRUDERS > 2
2425 2524
           CONFIG_ECHO_START;
2426
-          SERIAL_ECHOPAIR_P(port, "  M603 T2 L", LINEAR_UNIT(filament_change_load_length[2]));
2525
+          say_M603();
2526
+          SERIAL_ECHOPAIR_P(port, "T2 L", LINEAR_UNIT(filament_change_load_length[2]));
2427 2527
           SERIAL_ECHOLNPAIR_P(port, " U", LINEAR_UNIT(filament_change_unload_length[2]));
2428 2528
           #if EXTRUDERS > 3
2429 2529
             CONFIG_ECHO_START;
2430
-            SERIAL_ECHOPAIR_P(port, "  M603 T3 L", LINEAR_UNIT(filament_change_load_length[3]));
2530
+            say_M603();
2531
+            SERIAL_ECHOPAIR_P(port, "T3 L", LINEAR_UNIT(filament_change_load_length[3]));
2431 2532
             SERIAL_ECHOLNPAIR_P(port, " U", LINEAR_UNIT(filament_change_unload_length[3]));
2432 2533
             #if EXTRUDERS > 4
2433 2534
               CONFIG_ECHO_START;
2434
-              SERIAL_ECHOPAIR_P(port, "  M603 T4 L", LINEAR_UNIT(filament_change_load_length[4]));
2535
+              say_M603();
2536
+              SERIAL_ECHOPAIR_P(port, "T4 L", LINEAR_UNIT(filament_change_load_length[4]));
2435 2537
               SERIAL_ECHOLNPAIR_P(port, " U", LINEAR_UNIT(filament_change_unload_length[4]));
2436 2538
             #endif // EXTRUDERS > 4
2437 2539
           #endif // EXTRUDERS > 3

Loading…
Cancel
Save