浏览代码

Use arrays for delta tower parameters

Scott Lahteine 8 年前
父节点
当前提交
58b3e98878
共有 3 个文件被更改,包括 73 次插入99 次删除
  1. 2
    6
      Marlin/Marlin.h
  2. 39
    49
      Marlin/Marlin_main.cpp
  3. 32
    44
      Marlin/configuration_store.cpp

+ 2
- 6
Marlin/Marlin.h 查看文件

332
                delta_radius,
332
                delta_radius,
333
                delta_diagonal_rod,
333
                delta_diagonal_rod,
334
                delta_segments_per_second,
334
                delta_segments_per_second,
335
-               delta_diagonal_rod_trim_tower_1,
336
-               delta_diagonal_rod_trim_tower_2,
337
-               delta_diagonal_rod_trim_tower_3,
338
-               delta_tower_angle_trim_1,
339
-               delta_tower_angle_trim_2,
340
-               delta_tower_angle_trim_3,
335
+               delta_diagonal_rod_trim[ABC],
336
+               delta_tower_angle_trim[ABC],
341
                delta_clip_start_height;
337
                delta_clip_start_height;
342
   void recalc_delta_settings(float radius, float diagonal_rod);
338
   void recalc_delta_settings(float radius, float diagonal_rod);
343
 #elif IS_SCARA
339
 #elif IS_SCARA

+ 39
- 49
Marlin/Marlin_main.cpp 查看文件

559
   float delta[ABC],
559
   float delta[ABC],
560
         endstop_adj[ABC] = { 0 };
560
         endstop_adj[ABC] = { 0 };
561
 
561
 
562
-  // these are the default values, can be overriden with M665
563
-  float delta_radius = DELTA_RADIUS,
564
-        delta_tower_angle_trim_1 = DELTA_TOWER_ANGLE_TRIM_1,
565
-        delta_tower_angle_trim_2 = DELTA_TOWER_ANGLE_TRIM_2,
566
-        delta_tower_angle_trim_3 = DELTA_TOWER_ANGLE_TRIM_3,
567
-        delta_tower1_x = -sin(RADIANS(60 - delta_tower_angle_trim_1)) * (delta_radius + DELTA_RADIUS_TRIM_TOWER_1), // front left tower
568
-        delta_tower1_y = -cos(RADIANS(60 - delta_tower_angle_trim_1)) * (delta_radius + DELTA_RADIUS_TRIM_TOWER_1),
569
-        delta_tower2_x =  sin(RADIANS(60 + delta_tower_angle_trim_2)) * (delta_radius + DELTA_RADIUS_TRIM_TOWER_2), // front right tower
570
-        delta_tower2_y = -cos(RADIANS(60 + delta_tower_angle_trim_2)) * (delta_radius + DELTA_RADIUS_TRIM_TOWER_2),
571
-        delta_tower3_x = -sin(RADIANS(     delta_tower_angle_trim_3)),                                                    // back middle tower
572
-        delta_tower3_y =  cos(RADIANS(     delta_tower_angle_trim_3)) * (delta_radius + DELTA_RADIUS_TRIM_TOWER_3),
573
-        delta_diagonal_rod = DELTA_DIAGONAL_ROD,
574
-        delta_diagonal_rod_trim_tower_1 = DELTA_DIAGONAL_ROD_TRIM_TOWER_1,
575
-        delta_diagonal_rod_trim_tower_2 = DELTA_DIAGONAL_ROD_TRIM_TOWER_2,
576
-        delta_diagonal_rod_trim_tower_3 = DELTA_DIAGONAL_ROD_TRIM_TOWER_3,
577
-        delta_diagonal_rod_2_tower_1 = sq(delta_diagonal_rod + delta_diagonal_rod_trim_tower_1),
578
-        delta_diagonal_rod_2_tower_2 = sq(delta_diagonal_rod + delta_diagonal_rod_trim_tower_2),
579
-        delta_diagonal_rod_2_tower_3 = sq(delta_diagonal_rod + delta_diagonal_rod_trim_tower_3),
580
-        delta_segments_per_second = DELTA_SEGMENTS_PER_SECOND,
562
+  // These values are loaded or reset at boot time when setup() calls
563
+  // Config_RetrieveSettings(), which calls recalc_delta_settings().
564
+  float delta_radius,
565
+        delta_tower_angle_trim[ABC],
566
+        delta_tower[ABC][2],
567
+        delta_diagonal_rod,
568
+        delta_diagonal_rod_trim[ABC],
569
+        delta_diagonal_rod_2_tower[ABC],
570
+        delta_segments_per_second,
581
         delta_clip_start_height = Z_MAX_POS;
571
         delta_clip_start_height = Z_MAX_POS;
582
 
572
 
583
   float delta_safe_distance_from_top();
573
   float delta_safe_distance_from_top();
6334
     if (code_seen('L')) delta_diagonal_rod = code_value_linear_units();
6324
     if (code_seen('L')) delta_diagonal_rod = code_value_linear_units();
6335
     if (code_seen('R')) delta_radius = code_value_linear_units();
6325
     if (code_seen('R')) delta_radius = code_value_linear_units();
6336
     if (code_seen('S')) delta_segments_per_second = code_value_float();
6326
     if (code_seen('S')) delta_segments_per_second = code_value_float();
6337
-    if (code_seen('A')) delta_diagonal_rod_trim_tower_1 = code_value_linear_units();
6338
-    if (code_seen('B')) delta_diagonal_rod_trim_tower_2 = code_value_linear_units();
6339
-    if (code_seen('C')) delta_diagonal_rod_trim_tower_3 = code_value_linear_units();
6340
-    if (code_seen('I')) delta_tower_angle_trim_1 = code_value_linear_units();
6341
-    if (code_seen('J')) delta_tower_angle_trim_2 = code_value_linear_units();
6342
-    if (code_seen('K')) delta_tower_angle_trim_3 = code_value_linear_units();
6327
+    if (code_seen('A')) delta_diagonal_rod_trim[A_AXIS] = code_value_linear_units();
6328
+    if (code_seen('B')) delta_diagonal_rod_trim[B_AXIS] = code_value_linear_units();
6329
+    if (code_seen('C')) delta_diagonal_rod_trim[C_AXIS] = code_value_linear_units();
6330
+    if (code_seen('I')) delta_tower_angle_trim[A_AXIS] = code_value_linear_units();
6331
+    if (code_seen('J')) delta_tower_angle_trim[B_AXIS] = code_value_linear_units();
6332
+    if (code_seen('K')) delta_tower_angle_trim[C_AXIS] = code_value_linear_units();
6343
     recalc_delta_settings(delta_radius, delta_diagonal_rod);
6333
     recalc_delta_settings(delta_radius, delta_diagonal_rod);
6344
   }
6334
   }
6345
   /**
6335
   /**
9143
    * settings have been changed (e.g., by M665).
9133
    * settings have been changed (e.g., by M665).
9144
    */
9134
    */
9145
   void recalc_delta_settings(float radius, float diagonal_rod) {
9135
   void recalc_delta_settings(float radius, float diagonal_rod) {
9146
-    delta_tower1_x = -sin(RADIANS(60 - delta_tower_angle_trim_1)) * (delta_radius + DELTA_RADIUS_TRIM_TOWER_1), // front left tower
9147
-    delta_tower1_y = -cos(RADIANS(60 - delta_tower_angle_trim_1)) * (delta_radius + DELTA_RADIUS_TRIM_TOWER_1),
9148
-    delta_tower2_x =  sin(RADIANS(60 + delta_tower_angle_trim_2)) * (delta_radius + DELTA_RADIUS_TRIM_TOWER_2), // front right tower
9149
-    delta_tower2_y = -cos(RADIANS(60 + delta_tower_angle_trim_2)) * (delta_radius + DELTA_RADIUS_TRIM_TOWER_2),
9150
-    delta_tower3_x = -sin(RADIANS(     delta_tower_angle_trim_3)),                                              // back middle tower
9151
-    delta_tower3_y =  cos(RADIANS(     delta_tower_angle_trim_3)) * (delta_radius + DELTA_RADIUS_TRIM_TOWER_3),
9152
-    delta_diagonal_rod_2_tower_1 = sq(diagonal_rod + delta_diagonal_rod_trim_tower_1);
9153
-    delta_diagonal_rod_2_tower_2 = sq(diagonal_rod + delta_diagonal_rod_trim_tower_2);
9154
-    delta_diagonal_rod_2_tower_3 = sq(diagonal_rod + delta_diagonal_rod_trim_tower_3);
9136
+    delta_tower[A_AXIS][X_AXIS] = -sin(RADIANS(60 - delta_tower_angle_trim[A_AXIS])) * (delta_radius + DELTA_RADIUS_TRIM_TOWER_1), // front left tower
9137
+    delta_tower[A_AXIS][Y_AXIS] = -cos(RADIANS(60 - delta_tower_angle_trim[A_AXIS])) * (delta_radius + DELTA_RADIUS_TRIM_TOWER_1),
9138
+    delta_tower[B_AXIS][X_AXIS] =  sin(RADIANS(60 + delta_tower_angle_trim[B_AXIS])) * (delta_radius + DELTA_RADIUS_TRIM_TOWER_2), // front right tower
9139
+    delta_tower[B_AXIS][Y_AXIS] = -cos(RADIANS(60 + delta_tower_angle_trim[B_AXIS])) * (delta_radius + DELTA_RADIUS_TRIM_TOWER_2),
9140
+    delta_tower[C_AXIS][X_AXIS] = -sin(RADIANS(     delta_tower_angle_trim[C_AXIS])) * (delta_radius + DELTA_RADIUS_TRIM_TOWER_3), // back middle tower
9141
+    delta_tower[C_AXIS][Y_AXIS] =  cos(RADIANS(     delta_tower_angle_trim[C_AXIS])) * (delta_radius + DELTA_RADIUS_TRIM_TOWER_3),
9142
+    delta_diagonal_rod_2_tower[A_AXIS] = sq(diagonal_rod + delta_diagonal_rod_trim[A_AXIS]);
9143
+    delta_diagonal_rod_2_tower[B_AXIS] = sq(diagonal_rod + delta_diagonal_rod_trim[B_AXIS]);
9144
+    delta_diagonal_rod_2_tower[C_AXIS] = sq(diagonal_rod + delta_diagonal_rod_trim[C_AXIS]);
9155
   }
9145
   }
9156
 
9146
 
9157
   #if ENABLED(DELTA_FAST_SQRT)
9147
   #if ENABLED(DELTA_FAST_SQRT)
9201
    */
9191
    */
9202
 
9192
 
9203
   // Macro to obtain the Z position of an individual tower
9193
   // Macro to obtain the Z position of an individual tower
9204
-  #define DELTA_Z(T) raw[Z_AXIS] + _SQRT(    \
9205
-    delta_diagonal_rod_2_tower_##T - HYPOT2( \
9206
-        delta_tower##T##_x - raw[X_AXIS],    \
9207
-        delta_tower##T##_y - raw[Y_AXIS]     \
9208
-      )                                      \
9194
+  #define DELTA_Z(T) raw[Z_AXIS] + _SQRT(     \
9195
+    delta_diagonal_rod_2_tower[T] - HYPOT2(   \
9196
+        delta_tower[T][X_AXIS] - raw[X_AXIS], \
9197
+        delta_tower[T][Y_AXIS] - raw[Y_AXIS]  \
9198
+      )                                       \
9209
     )
9199
     )
9210
 
9200
 
9211
   #define DELTA_RAW_IK() do {   \
9201
   #define DELTA_RAW_IK() do {   \
9212
-    delta[A_AXIS] = DELTA_Z(1); \
9213
-    delta[B_AXIS] = DELTA_Z(2); \
9214
-    delta[C_AXIS] = DELTA_Z(3); \
9202
+    delta[A_AXIS] = DELTA_Z(A_AXIS); \
9203
+    delta[B_AXIS] = DELTA_Z(B_AXIS); \
9204
+    delta[C_AXIS] = DELTA_Z(C_AXIS); \
9215
   } while(0)
9205
   } while(0)
9216
 
9206
 
9217
   #define DELTA_LOGICAL_IK() do {      \
9207
   #define DELTA_LOGICAL_IK() do {      \
9281
    */
9271
    */
9282
   void forward_kinematics_DELTA(float z1, float z2, float z3) {
9272
   void forward_kinematics_DELTA(float z1, float z2, float z3) {
9283
     // Create a vector in old coordinates along x axis of new coordinate
9273
     // Create a vector in old coordinates along x axis of new coordinate
9284
-    float p12[3] = { delta_tower2_x - delta_tower1_x, delta_tower2_y - delta_tower1_y, z2 - z1 };
9274
+    float p12[3] = { delta_tower[B_AXIS][X_AXIS] - delta_tower[A_AXIS][X_AXIS], delta_tower[B_AXIS][Y_AXIS] - delta_tower[A_AXIS][Y_AXIS], z2 - z1 };
9285
 
9275
 
9286
     // Get the Magnitude of vector.
9276
     // Get the Magnitude of vector.
9287
     float d = sqrt( sq(p12[0]) + sq(p12[1]) + sq(p12[2]) );
9277
     float d = sqrt( sq(p12[0]) + sq(p12[1]) + sq(p12[2]) );
9290
     float ex[3] = { p12[0] / d, p12[1] / d, p12[2] / d };
9280
     float ex[3] = { p12[0] / d, p12[1] / d, p12[2] / d };
9291
 
9281
 
9292
     // Get the vector from the origin of the new system to the third point.
9282
     // Get the vector from the origin of the new system to the third point.
9293
-    float p13[3] = { delta_tower3_x - delta_tower1_x, delta_tower3_y - delta_tower1_y, z3 - z1 };
9283
+    float p13[3] = { delta_tower[C_AXIS][X_AXIS] - delta_tower[A_AXIS][X_AXIS], delta_tower[C_AXIS][Y_AXIS] - delta_tower[A_AXIS][Y_AXIS], z3 - z1 };
9294
 
9284
 
9295
     // Use the dot product to find the component of this vector on the X axis.
9285
     // Use the dot product to find the component of this vector on the X axis.
9296
     float i = ex[0] * p13[0] + ex[1] * p13[1] + ex[2] * p13[2];
9286
     float i = ex[0] * p13[0] + ex[1] * p13[1] + ex[2] * p13[2];
9318
 
9308
 
9319
     // We now have the d, i and j values defined in Wikipedia.
9309
     // We now have the d, i and j values defined in Wikipedia.
9320
     // Plug them into the equations defined in Wikipedia for Xnew, Ynew and Znew
9310
     // Plug them into the equations defined in Wikipedia for Xnew, Ynew and Znew
9321
-    float Xnew = (delta_diagonal_rod_2_tower_1 - delta_diagonal_rod_2_tower_2 + sq(d)) / (d * 2),
9322
-          Ynew = ((delta_diagonal_rod_2_tower_1 - delta_diagonal_rod_2_tower_3 + HYPOT2(i, j)) / 2 - i * Xnew) / j,
9323
-          Znew = sqrt(delta_diagonal_rod_2_tower_1 - HYPOT2(Xnew, Ynew));
9311
+    float Xnew = (delta_diagonal_rod_2_tower[A_AXIS] - delta_diagonal_rod_2_tower[B_AXIS] + sq(d)) / (d * 2),
9312
+          Ynew = ((delta_diagonal_rod_2_tower[A_AXIS] - delta_diagonal_rod_2_tower[C_AXIS] + HYPOT2(i, j)) / 2 - i * Xnew) / j,
9313
+          Znew = sqrt(delta_diagonal_rod_2_tower[A_AXIS] - HYPOT2(Xnew, Ynew));
9324
 
9314
 
9325
     // Start from the origin of the old coordinates and add vectors in the
9315
     // Start from the origin of the old coordinates and add vectors in the
9326
     // old coords that represent the Xnew, Ynew and Znew to find the point
9316
     // old coords that represent the Xnew, Ynew and Znew to find the point
9327
     // in the old system.
9317
     // in the old system.
9328
-    cartes[X_AXIS] = delta_tower1_x + ex[0] * Xnew + ey[0] * Ynew - ez[0] * Znew;
9329
-    cartes[Y_AXIS] = delta_tower1_y + ex[1] * Xnew + ey[1] * Ynew - ez[1] * Znew;
9318
+    cartes[X_AXIS] = delta_tower[A_AXIS][X_AXIS] + ex[0] * Xnew + ey[0] * Ynew - ez[0] * Znew;
9319
+    cartes[Y_AXIS] = delta_tower[A_AXIS][Y_AXIS] + ex[1] * Xnew + ey[1] * Ynew - ez[1] * Znew;
9330
     cartes[Z_AXIS] =             z1 + ex[2] * Xnew + ey[2] * Ynew - ez[2] * Znew;
9320
     cartes[Z_AXIS] =             z1 + ex[2] * Xnew + ey[2] * Ynew - ez[2] * Znew;
9331
   }
9321
   }
9332
 
9322
 

+ 32
- 44
Marlin/configuration_store.cpp 查看文件

84
  *  308  G29 L F   bilinear_start                  (int x2)
84
  *  308  G29 L F   bilinear_start                  (int x2)
85
  *  312            bed_level_grid[][]              (float x9, up to float x256) +988
85
  *  312            bed_level_grid[][]              (float x9, up to float x256) +988
86
  *
86
  *
87
- * DELTA (if deltabot):                            48 bytes
88
- *  348  M666 XYZ  endstop_adj                     (float x3)
89
- *  360  M665 R    delta_radius                    (float)
90
- *  364  M665 L    delta_diagonal_rod              (float)
91
- *  368  M665 S    delta_segments_per_second       (float)
92
- *  372  M665 A    delta_diagonal_rod_trim_tower_1 (float)
93
- *  376  M665 B    delta_diagonal_rod_trim_tower_2 (float)
94
- *  380  M665 C    delta_diagonal_rod_trim_tower_3 (float)
95
- *  384  M665 I    delta_tower_angle_trim_1        (float)
96
- *  388  M665 J    delta_tower_angle_trim_2        (float)
97
- *  392  M665 K    delta_tower_angle_trim_3        (float)
87
+ * DELTA (if deltabot):                             48 bytes
88
+ *  348  M666 XYZ  endstop_adj                      (float x3)
89
+ *  360  M665 R    delta_radius                     (float)
90
+ *  364  M665 L    delta_diagonal_rod               (float)
91
+ *  368  M665 S    delta_segments_per_second        (float)
92
+ *  372  M665 A    delta_diagonal_rod_trim[A]       (float)
93
+ *  376  M665 B    delta_diagonal_rod_trim[B]       (float)
94
+ *  380  M665 C    delta_diagonal_rod_trim[C]       (float)
95
+ *  384  M665 I    delta_tower_angle_trim[A]        (float)
96
+ *  388  M665 J    delta_tower_angle_trim[B]        (float)
97
+ *  392  M665 K    delta_tower_angle_trim[C]        (float)
98
  *
98
  *
99
  * Z_DUAL_ENDSTOPS (if not deltabot):              48 bytes
99
  * Z_DUAL_ENDSTOPS (if not deltabot):              48 bytes
100
  *  348  M666 Z    z_endstop_adj                   (float)
100
  *  348  M666 Z    z_endstop_adj                   (float)
357
       EEPROM_WRITE(delta_radius);              // 1 float
357
       EEPROM_WRITE(delta_radius);              // 1 float
358
       EEPROM_WRITE(delta_diagonal_rod);        // 1 float
358
       EEPROM_WRITE(delta_diagonal_rod);        // 1 float
359
       EEPROM_WRITE(delta_segments_per_second); // 1 float
359
       EEPROM_WRITE(delta_segments_per_second); // 1 float
360
-      EEPROM_WRITE(delta_diagonal_rod_trim_tower_1);  // 1 float
361
-      EEPROM_WRITE(delta_diagonal_rod_trim_tower_2);  // 1 float
362
-      EEPROM_WRITE(delta_diagonal_rod_trim_tower_3);  // 1 float
363
-      EEPROM_WRITE(delta_tower_angle_trim_1); // 1 float
364
-      EEPROM_WRITE(delta_tower_angle_trim_2); // 1 float
365
-      EEPROM_WRITE(delta_tower_angle_trim_3); // 1 float
360
+      EEPROM_WRITE(delta_diagonal_rod_trim);   // 3 floats
361
+      EEPROM_WRITE(delta_tower_angle_trim);    // 3 floats
366
     #elif ENABLED(Z_DUAL_ENDSTOPS)
362
     #elif ENABLED(Z_DUAL_ENDSTOPS)
367
-      EEPROM_WRITE(z_endstop_adj);            // 1 float
363
+      EEPROM_WRITE(z_endstop_adj);             // 1 float
368
       dummy = 0.0f;
364
       dummy = 0.0f;
369
       for (uint8_t q = 11; q--;) EEPROM_WRITE(dummy);
365
       for (uint8_t q = 11; q--;) EEPROM_WRITE(dummy);
370
     #else
366
     #else
681
         }
677
         }
682
 
678
 
683
       #if ENABLED(DELTA)
679
       #if ENABLED(DELTA)
684
-        EEPROM_READ(endstop_adj);                // 3 floats
685
-        EEPROM_READ(delta_radius);               // 1 float
686
-        EEPROM_READ(delta_diagonal_rod);         // 1 float
687
-        EEPROM_READ(delta_segments_per_second);  // 1 float
688
-        EEPROM_READ(delta_diagonal_rod_trim_tower_1);  // 1 float
689
-        EEPROM_READ(delta_diagonal_rod_trim_tower_2);  // 1 float
690
-        EEPROM_READ(delta_diagonal_rod_trim_tower_3);  // 1 float
691
-        EEPROM_READ(delta_tower_angle_trim_1); // 1 float
692
-        EEPROM_READ(delta_tower_angle_trim_2); // 1 float
693
-        EEPROM_READ(delta_tower_angle_trim_3); // 1 float
680
+        EEPROM_READ(endstop_adj);               // 3 floats
681
+        EEPROM_READ(delta_radius);              // 1 float
682
+        EEPROM_READ(delta_diagonal_rod);        // 1 float
683
+        EEPROM_READ(delta_segments_per_second); // 1 float
684
+        EEPROM_READ(delta_diagonal_rod_trim);   // 3 floats
685
+        EEPROM_READ(delta_tower_angle_trim);    // 3 floats
694
       #elif ENABLED(Z_DUAL_ENDSTOPS)
686
       #elif ENABLED(Z_DUAL_ENDSTOPS)
695
         EEPROM_READ(z_endstop_adj);
687
         EEPROM_READ(z_endstop_adj);
696
         dummy = 0.0f;
688
         dummy = 0.0f;
909
   #endif
901
   #endif
910
 
902
 
911
   #if ENABLED(DELTA)
903
   #if ENABLED(DELTA)
912
-    const float adj[ABC] = DELTA_ENDSTOP_ADJ;
913
-    endstop_adj[A_AXIS] = adj[A_AXIS];
914
-    endstop_adj[B_AXIS] = adj[B_AXIS];
915
-    endstop_adj[C_AXIS] = adj[C_AXIS];
904
+    const float adj[ABC] = DELTA_ENDSTOP_ADJ,
905
+                drt[ABC] = { DELTA_DIAGONAL_ROD_TRIM_TOWER_1, DELTA_DIAGONAL_ROD_TRIM_TOWER_2, DELTA_DIAGONAL_ROD_TRIM_TOWER_3 },
906
+                dta[ABC] = { DELTA_TOWER_ANGLE_TRIM_1, DELTA_TOWER_ANGLE_TRIM_2, DELTA_TOWER_ANGLE_TRIM_3 };
907
+    COPY(endstop_adj, adj);
916
     delta_radius = DELTA_RADIUS;
908
     delta_radius = DELTA_RADIUS;
917
     delta_diagonal_rod = DELTA_DIAGONAL_ROD;
909
     delta_diagonal_rod = DELTA_DIAGONAL_ROD;
918
     delta_segments_per_second = DELTA_SEGMENTS_PER_SECOND;
910
     delta_segments_per_second = DELTA_SEGMENTS_PER_SECOND;
919
-    delta_diagonal_rod_trim_tower_1 = DELTA_DIAGONAL_ROD_TRIM_TOWER_1;
920
-    delta_diagonal_rod_trim_tower_2 = DELTA_DIAGONAL_ROD_TRIM_TOWER_2;
921
-    delta_diagonal_rod_trim_tower_3 = DELTA_DIAGONAL_ROD_TRIM_TOWER_3;
922
-    delta_tower_angle_trim_1 = DELTA_TOWER_ANGLE_TRIM_1;
923
-    delta_tower_angle_trim_2 = DELTA_TOWER_ANGLE_TRIM_2;
924
-    delta_tower_angle_trim_3 = DELTA_TOWER_ANGLE_TRIM_3;
911
+    COPY(delta_diagonal_rod_trim, drt);
912
+    COPY(delta_tower_angle_trim, dta);
925
   #elif ENABLED(Z_DUAL_ENDSTOPS)
913
   #elif ENABLED(Z_DUAL_ENDSTOPS)
926
     z_endstop_adj = 0;
914
     z_endstop_adj = 0;
927
   #endif
915
   #endif
1198
       SERIAL_ECHOPAIR("  M665 L", delta_diagonal_rod);
1186
       SERIAL_ECHOPAIR("  M665 L", delta_diagonal_rod);
1199
       SERIAL_ECHOPAIR(" R", delta_radius);
1187
       SERIAL_ECHOPAIR(" R", delta_radius);
1200
       SERIAL_ECHOPAIR(" S", delta_segments_per_second);
1188
       SERIAL_ECHOPAIR(" S", delta_segments_per_second);
1201
-      SERIAL_ECHOPAIR(" A", delta_diagonal_rod_trim_tower_1);
1202
-      SERIAL_ECHOPAIR(" B", delta_diagonal_rod_trim_tower_2);
1203
-      SERIAL_ECHOPAIR(" C", delta_diagonal_rod_trim_tower_3);
1204
-      SERIAL_ECHOPAIR(" I", delta_tower_angle_trim_1);
1205
-      SERIAL_ECHOPAIR(" J", delta_tower_angle_trim_2);
1206
-      SERIAL_ECHOPAIR(" K", delta_tower_angle_trim_3);
1189
+      SERIAL_ECHOPAIR(" A", delta_diagonal_rod_trim[A_AXIS]);
1190
+      SERIAL_ECHOPAIR(" B", delta_diagonal_rod_trim[B_AXIS]);
1191
+      SERIAL_ECHOPAIR(" C", delta_diagonal_rod_trim[C_AXIS]);
1192
+      SERIAL_ECHOPAIR(" I", delta_tower_angle_trim[A_AXIS]);
1193
+      SERIAL_ECHOPAIR(" J", delta_tower_angle_trim[B_AXIS]);
1194
+      SERIAL_ECHOPAIR(" K", delta_tower_angle_trim[C_AXIS]);
1207
       SERIAL_EOL;
1195
       SERIAL_EOL;
1208
     #elif ENABLED(Z_DUAL_ENDSTOPS)
1196
     #elif ENABLED(Z_DUAL_ENDSTOPS)
1209
       CONFIG_ECHO_START;
1197
       CONFIG_ECHO_START;

正在加载...
取消
保存