[1.1.x] G33 magic numbers (#8173)

* [1.1.x] G33 magic numbers

* oops

* comments

* oops

* warning

* better comment section

* remarks

* extra grids

Marlin/Marlin_main.cpp

 
   #if ENABLED(DELTA_AUTO_CALIBRATION)
 
+    constexpr uint8_t _7P_STEP = 1,              // 7-point step - to change number of calibration points
+                      _4P_STEP = _7P_STEP * 2,   // 4-point step
+                      NPP      = _7P_STEP * 6;   // number of calibration points on the radius
+    enum CalEnum {                               // the 7 main calibration points - add definitions if needed
+      CEN      = 0,
+      __A      = 1,
+      _AB      = __A + _7P_STEP,
+      __B      = _AB + _7P_STEP,
+      _BC      = __B + _7P_STEP,
+      __C      = _BC + _7P_STEP,
+      _CA      = __C + _7P_STEP,
+    };
+    
+    #define LOOP_CAL_PT(VAR, S, N) for (uint8_t VAR=S; VAR<=NPP; VAR+=N) 
+    #define F_LOOP_CAL_PT(VAR, S, N) for (float VAR=S; VAR<NPP+0.9999; VAR+=N) 
+    #define I_LOOP_CAL_PT(VAR, S, N) for (float VAR=S; VAR>CEN+0.9999; VAR-=N)
+    #define LOOP_CAL_ALL(VAR) LOOP_CAL_PT(VAR, CEN, 1)
+    #define LOOP_CAL_RAD(VAR) LOOP_CAL_PT(VAR, __A, _7P_STEP)
+    #define LOOP_CAL_ACT(VAR, _4P, _OP) LOOP_CAL_PT(VAR, _OP ? _AB : __A, _4P ? _4P_STEP : _7P_STEP)
+
     static void print_signed_float(const char * const prefix, const float &f) {
       SERIAL_PROTOCOLPGM("  ");
       serialprintPGM(prefix);
       SERIAL_EOL();
     }
 
-    static void print_G33_results(const float z_at_pt[13], const bool tower_points, const bool opposite_points) {
+    static void print_G33_results(const float z_at_pt[NPP + 1], const bool tower_points, const bool opposite_points) {
       SERIAL_PROTOCOLPGM(".    ");
-      print_signed_float(PSTR("c"), z_at_pt[0]);
+      print_signed_float(PSTR("c"), z_at_pt[CEN]);
       if (tower_points) {
-        print_signed_float(PSTR(" x"), z_at_pt[1]);
-        print_signed_float(PSTR(" y"), z_at_pt[5]);
-        print_signed_float(PSTR(" z"), z_at_pt[9]);
+        print_signed_float(PSTR(" x"), z_at_pt[__A]);
+        print_signed_float(PSTR(" y"), z_at_pt[__B]);
+        print_signed_float(PSTR(" z"), z_at_pt[__C]);
       }
       if (tower_points && opposite_points) {
         SERIAL_EOL();
         SERIAL_PROTOCOL_SP(13);
       }
       if (opposite_points) {
-        print_signed_float(PSTR("yz"), z_at_pt[7]);
-        print_signed_float(PSTR("zx"), z_at_pt[11]);
-        print_signed_float(PSTR("xy"), z_at_pt[3]);
+        print_signed_float(PSTR("yz"), z_at_pt[_BC]);
+        print_signed_float(PSTR("zx"), z_at_pt[_CA]);
+        print_signed_float(PSTR("xy"), z_at_pt[_AB]);
       }
       SERIAL_EOL();
     }
       #endif
     }
 
-    static float probe_G33_points(float z_at_pt[13], const int8_t probe_points, const bool towers_set, const bool stow_after_each) {
+    static float probe_G33_points(float z_at_pt[NPP + 1], const int8_t probe_points, const bool towers_set, const bool stow_after_each) {
       const bool _0p_calibration      = probe_points == 0,
                  _1p_calibration      = probe_points == 1,
                  _4p_calibration      = probe_points == 2,
                  _4p_opposite_points  = _4p_calibration && !towers_set,
                  _7p_calibration      = probe_points >= 3 || probe_points == 0,
-                 _7p_half_circle      = probe_points == 3,
-                 _7p_double_circle    = probe_points == 5,
-                 _7p_triple_circle    = probe_points == 6,
-                 _7p_quadruple_circle = probe_points == 7,
+                 _7p_no_intermediates = probe_points == 3,
+                 _7p_1_intermediates  = probe_points == 4,
+                 _7p_2_intermediates  = probe_points == 5,
+                 _7p_4_intermediates  = probe_points == 6,
+                 _7p_6_intermediates  = probe_points == 7,
+                 _7p_8_intermediates  = probe_points == 8,
+                 _7p_11_intermediates = probe_points == 9,
+                 _7p_14_intermediates = probe_points == 10,
                  _7p_intermed_points  = probe_points >= 4,
-                 _7p_multi_circle     = probe_points >= 5;
-    
+                 _7p_6_centre         = probe_points >= 5 && probe_points <= 7,
+                 _7p_9_centre         = probe_points >= 8;
+
       #if DISABLED(PROBE_MANUALLY)
         const float dx = (X_PROBE_OFFSET_FROM_EXTRUDER),
                     dy = (Y_PROBE_OFFSET_FROM_EXTRUDER);
       #endif
 
-      for (uint8_t i = 0; i <= 12; i++) z_at_pt[i] = 0.0;
+          LOOP_CAL_ALL(axis) z_at_pt[axis] = 0.0;
     
       if (!_0p_calibration) {
     
-        if (!_7p_half_circle && !_7p_triple_circle) { // probe the center
+        if (!_7p_no_intermediates && !_7p_4_intermediates && !_7p_11_intermediates) { // probe the center
           #if ENABLED(PROBE_MANUALLY)
-            z_at_pt[0] += lcd_probe_pt(0, 0);
+            z_at_pt[CEN] += lcd_probe_pt(0, 0);
           #else
-            z_at_pt[0] += probe_pt(dx, dy, stow_after_each, 1, false);
+            z_at_pt[CEN] += probe_pt(dx, dy, stow_after_each, 1, false);
           #endif
         }
 
         if (_7p_calibration) { // probe extra center points
-          for (int8_t axis = _7p_multi_circle ? 11 : 9; axis > 0; axis -= _7p_multi_circle ? 2 : 4) {
-            const float a = RADIANS(180 + 30 * axis), r = delta_calibration_radius * 0.1;
+          const float start  = _7p_9_centre ? _CA + _7P_STEP / 3.0 : _7p_6_centre ? _CA : __C,
+                      steps  = _7p_9_centre ? _4P_STEP / 3.0 : _7p_6_centre ? _7P_STEP : _4P_STEP;
+          I_LOOP_CAL_PT(axis, start, steps) {
+            const float a = RADIANS(210 + (360 / NPP) *  (axis - 1)),
+                        r = delta_calibration_radius * 0.1;
             #if ENABLED(PROBE_MANUALLY)
-              z_at_pt[0] += lcd_probe_pt(cos(a) * r, sin(a) * r);
+              z_at_pt[CEN] += lcd_probe_pt(cos(a) * r, sin(a) * r);
             #else
-              z_at_pt[0] += probe_pt(cos(a) * r + dx, sin(a) * r + dy, stow_after_each, 1);
+              z_at_pt[CEN] += probe_pt(cos(a) * r + dx, sin(a) * r + dy, stow_after_each, 1);
             #endif
           }
-          z_at_pt[0] /= float(_7p_double_circle ? 7 : probe_points);
+          z_at_pt[CEN] /= float(_7p_2_intermediates ? 7 : probe_points);
         }
 
         if (!_1p_calibration) {  // probe the radius
+          const CalEnum start  = _4p_opposite_points ? _AB : __A;
+          const float   steps  = _7p_14_intermediates ? _7P_STEP / 15.0 : // 15r * 6 + 10c = 100
+                                 _7p_11_intermediates ? _7P_STEP / 12.0 : // 12r * 6 +  9c = 81
+                                 _7p_8_intermediates  ? _7P_STEP /  9.0 : //  9r * 6 + 10c = 64
+                                 _7p_6_intermediates  ? _7P_STEP /  7.0 : //  7r * 6 +  7c = 49
+                                 _7p_4_intermediates  ? _7P_STEP /  5.0 : //  5r * 6 +  6c = 36
+                                 _7p_2_intermediates  ? _7P_STEP /  3.0 : //  3r * 6 +  7c = 25 
+                                 _7p_1_intermediates  ? _7P_STEP /  2.0 : //  2r * 6 +  4c = 16 
+                                 _7p_no_intermediates ? _7P_STEP :        //  1r * 6 +  3c = 9
+                                 _4P_STEP;                                // .5r * 6 +  1c = 4
           bool zig_zag = true;
-          const uint8_t start = _4p_opposite_points ? 3 : 1,
-                        step = _4p_calibration ? 4 : _7p_half_circle ? 2 : 1;
-          for (uint8_t axis = start; axis <= 12; axis += step) {
-            const float zigadd = (zig_zag ? 0.5 : 0.0),
-                        offset_circles = _7p_quadruple_circle ? zigadd + 1.0 :
-                                         _7p_triple_circle    ? zigadd + 0.5 :
-                                         _7p_double_circle    ? zigadd : 0;
-            for (float circles = -offset_circles ; circles <= offset_circles; circles++) {
-              const float a = RADIANS(180 + 30 * axis),
-                          r = delta_calibration_radius * (1 + circles * (zig_zag ? 0.1 : -0.1));
+          F_LOOP_CAL_PT(axis, start, _7p_9_centre ? steps * 3 : steps) {
+            const int8_t offset = _7p_9_centre ? 1 : 0;
+            for (int8_t circle = -offset; circle <= offset; circle++) {
+              const float a = RADIANS(210 + (360 / NPP) *  (axis - 1)),
+                          r = delta_calibration_radius * (1 + 0.1 * (zig_zag ? circle : - circle)),
+                          interpol = fmod(axis, 1);
               #if ENABLED(PROBE_MANUALLY)
-                z_at_pt[axis] += lcd_probe_pt(cos(a) * r, sin(a) * r);
+                 float z_temp = lcd_probe_pt(cos(a) * r, sin(a) * r);
               #else
-                z_at_pt[axis] += probe_pt(cos(a) * r + dx, sin(a) * r + dy, stow_after_each, 1);
+                float z_temp = probe_pt(cos(a) * r + dx, sin(a) * r + dy, stow_after_each, 1);
               #endif
+              // split probe point to neighbouring calibration points
+              z_at_pt[round(axis - interpol + NPP - 1) % NPP + 1] += z_temp * sq(cos(RADIANS(interpol * 90)));
+              z_at_pt[round(axis - interpol) % NPP + 1] += z_temp * sq(sin(RADIANS(interpol * 90)));
             }
             zig_zag = !zig_zag;
-            z_at_pt[axis] /= (2 * offset_circles + 1);
           }
+          if (_7p_intermed_points)
+            LOOP_CAL_RAD(axis) {
+/*
+            // average intermediate points to towers and opposites - only required with _7P_STEP >= 2
+              for (int8_t i = 1; i < _7P_STEP; i++) {
+                const float interpol = i * (1.0 / _7P_STEP);
+                z_at_pt[axis] += (z_at_pt[(axis + NPP - i - 1) % NPP + 1]
+                                 + z_at_pt[axis + i]) * sq(cos(RADIANS(interpol * 90)));
+              }
+*/
+              z_at_pt[axis] /= _7P_STEP  / steps;
+            }
         }
 
-        if (_7p_intermed_points) // average intermediates to tower and opposites
-          for (uint8_t axis = 1; axis <= 12; axis += 2)
-            z_at_pt[axis] = (z_at_pt[axis] + (z_at_pt[axis + 1] + z_at_pt[(axis + 10) % 12 + 1]) / 2.0) / 2.0;
 
-        float S1 = z_at_pt[0],
-              S2 = sq(z_at_pt[0]);
+        float S1 = z_at_pt[CEN],
+              S2 = sq(z_at_pt[CEN]);
         int16_t N = 1;
-        if (!_1p_calibration) // std dev from zero plane
-          for (uint8_t axis = (_4p_opposite_points ? 3 : 1); axis <= 12; axis += (_4p_calibration ? 4 : 2)) {
+        if (!_1p_calibration) { // std dev from zero plane
+          LOOP_CAL_ACT(axis, _4p_calibration, _4p_opposite_points) {
             S1 += z_at_pt[axis];
             S2 += sq(z_at_pt[axis]);
             N++;
           }
-        return round(SQRT(S2 / N) * 1000.0) / 1000.0 + 0.00001;
+          return round(SQRT(S2 / N) * 1000.0) / 1000.0 + 0.00001;
+        }
       }
     
       return 0.00001;
     #if DISABLED(PROBE_MANUALLY)
 
       static void G33_auto_tune() {
-        float z_at_pt[13]      = { 0.0 },
-              z_at_pt_base[13] = { 0.0 },
+        float z_at_pt[NPP + 1]      = { 0.0 },
+              z_at_pt_base[NPP + 1] = { 0.0 },
               z_temp, h_fac = 0.0, r_fac = 0.0, a_fac = 0.0, norm = 0.8;
     
         #define ZP(N,I) ((N) * z_at_pt[I])
           SERIAL_EOL();
 
           probe_G33_points(z_at_pt, 3, true, false);
-          for (int8_t i = 0; i <= 12; i++) z_at_pt[i] -= z_at_pt_base[i];
+          LOOP_CAL_ALL(axis) z_at_pt[axis] -= z_at_pt_base[axis];
           print_G33_results(z_at_pt, true, true);
           delta_endstop_adj[axis] += 1.0;
           switch (axis) {
             case A_AXIS :
-              h_fac += 4.0 / (Z03(0) +Z01(1)                         +Z32(11) +Z32(3)); // Offset by X-tower end-stop
+              h_fac += 4.0 / (Z03(CEN) +Z01(__A)                               +Z32(_CA) +Z32(_AB)); // Offset by X-tower end-stop
               break;
             case B_AXIS :
-              h_fac += 4.0 / (Z03(0)         +Z01(5)         +Z32(7)          +Z32(3)); // Offset by Y-tower end-stop
+              h_fac += 4.0 / (Z03(CEN)           +Z01(__B)           +Z32(_BC)           +Z32(_AB)); // Offset by Y-tower end-stop
               break;
             case C_AXIS :
-              h_fac += 4.0 / (Z03(0)                 +Z01(9) +Z32(7) +Z32(11)        ); // Offset by Z-tower end-stop
+              h_fac += 4.0 / (Z03(CEN)                     +Z01(__C) +Z32(_BC) +Z32(_CA)          ); // Offset by Z-tower end-stop
               break;
           }
         }
           SERIAL_PROTOCOL(zig_zag == -1 ? "-" : "+");
           SERIAL_EOL();
           probe_G33_points(z_at_pt, 3, true, false);
-          for (int8_t i = 0; i <= 12; i++) z_at_pt[i] -= z_at_pt_base[i];
+          LOOP_CAL_ALL(axis) z_at_pt[axis] -= z_at_pt_base[axis];
           print_G33_results(z_at_pt, true, true);
           delta_radius -= 1.0 * zig_zag;
           recalc_delta_settings(delta_radius, delta_diagonal_rod, delta_tower_angle_trim);
-          r_fac -= zig_zag * 6.0 / (Z03(1) + Z03(5) + Z03(9) + Z03(7) + Z03(11) + Z03(3)); // Offset by delta radius
+          r_fac -= zig_zag * 6.0 / (Z03(__A) +Z03(__B) +Z03(__C) +Z03(_BC) +Z03(_CA) +Z03(_AB)); // Offset by delta radius
         }
         r_fac /= 2.0;
         r_fac *= 3 * norm; // Normalize to 2.25 for Kossel mini
           SERIAL_EOL();
 
           probe_G33_points(z_at_pt, 3, true, false);
-          for (int8_t i = 0; i <= 12; i++) z_at_pt[i] -= z_at_pt_base[i];
+          LOOP_CAL_ALL(axis) z_at_pt[axis] -= z_at_pt_base[axis];
           print_G33_results(z_at_pt, true, true);
 
           delta_tower_angle_trim[axis] -= 1.0;
           recalc_delta_settings(delta_radius, delta_diagonal_rod, delta_tower_angle_trim);
           switch (axis) {
             case A_AXIS :
-            a_fac += 4.0 / (       Z06(5) -Z06(9)         +Z06(11) -Z06(3)); // Offset by alpha tower angle
+            a_fac += 4.0 / (          Z06(__B) -Z06(__C)           +Z06(_CA) -Z06(_AB)); // Offset by alpha tower angle
             break;
             case B_AXIS :
-            a_fac += 4.0 / (-Z06(1)       +Z06(9) -Z06(7)          +Z06(3)); // Offset by beta tower angle
+            a_fac += 4.0 / (-Z06(__A)          +Z06(__C) -Z06(_BC)           +Z06(_AB)); // Offset by beta tower angle
             break;
             case C_AXIS :
-            a_fac += 4.0 / (Z06(1) -Z06(5)        +Z06(7) -Z06(11)        ); // Offset by gamma tower angle
+            a_fac += 4.0 / (Z06(__A) -Z06(__B)           +Z06(_BC) -Z06(_CA)          ); // Offset by gamma tower angle
             break;
           }
         }
      *      P1     Probe center and set height only.
      *      P2     Probe center and towers. Set height, endstops and delta radius.
      *      P3     Probe all positions: center, towers and opposite towers. Set all.
-     *      P4-P7  Probe all positions at different locations and average them.
+     *      P4-P10 Probe all positions + at different itermediate locations and average them.
      *
      *   T   Don't calibrate tower angle corrections
      *
     inline void gcode_G33() {
 
       const int8_t probe_points = parser.intval('P', DELTA_CALIBRATION_DEFAULT_POINTS);
-      if (!WITHIN(probe_points, 0, 7)) {
-        SERIAL_PROTOCOLLNPGM("?(P)oints is implausible (0-7).");
+      if (!WITHIN(probe_points, 0, 10)) {
+        SERIAL_PROTOCOLLNPGM("?(P)oints is implausible (0-10).");
         return;
       }
 
                  _0p_calibration      = probe_points == 0,
                  _1p_calibration      = probe_points == 1,
                  _4p_calibration      = probe_points == 2,
+                 _7p_9_centre         = probe_points >= 8,
                  _tower_results       = (_4p_calibration && towers_set)
                                         || probe_points >= 3 || probe_points == 0,
                  _opposite_results    = (_4p_calibration && !towers_set)
                                         || probe_points >= 3 || probe_points == 0,
                  _endstop_results     = probe_points != 1,
-                 _angle_results       = (probe_points >= 3 || probe_points == 0) && towers_set,
-                 _7p_double_circle    = probe_points == 5,
-                 _7p_triple_circle    = probe_points == 6,
-                 _7p_quadruple_circle = probe_points == 7;
+                 _angle_results       = (probe_points >= 3 || probe_points == 0) && towers_set;
       const static char save_message[] PROGMEM = "Save with M500 and/or copy to Configuration.h";
       int8_t iterations = 0;
       float test_precision,
       SERIAL_PROTOCOLLNPGM("G33 Auto Calibrate");
 
       if (!_1p_calibration && !_0p_calibration) {  // test if the outer radius is reachable
-        const float circles = (_7p_quadruple_circle ? 1.5 :
-                               _7p_triple_circle    ? 1.0 :
-                               _7p_double_circle    ? 0.5 : 0),
-                    r = (1 + circles * 0.1) * delta_calibration_radius;
-        for (uint8_t axis = 1; axis <= 12; ++axis) {
-          const float a = RADIANS(180 + 30 * axis);
+        LOOP_CAL_RAD(axis) {
+          const float a = RADIANS(210 + (360 / NPP) *  (axis - 1)),
+                      r = delta_calibration_radius * (1 + (_7p_9_centre ? 0.1 : 0.0));
           if (!position_is_reachable_xy(cos(a) * r, sin(a) * r)) {
             SERIAL_PROTOCOLLNPGM("?(M665 B)ed radius is implausible.");
             return;
 
       do {
 
-        float z_at_pt[13] = { 0.0 };
+        float z_at_pt[NPP + 1] = { 0.0 };
 
         test_precision = zero_std_dev;
 
 
             case 1:
               test_precision = 0.00; // forced end
-              LOOP_XYZ(axis) e_delta[axis] = Z1(0);
+              LOOP_XYZ(axis) e_delta[axis] = Z1(CEN);
               break;
 
             case 2:
               if (towers_set) {
-                e_delta[A_AXIS] = (Z6(0) + Z4(1) - Z2(5) - Z2(9)) * h_factor;
-                e_delta[B_AXIS] = (Z6(0) - Z2(1) + Z4(5) - Z2(9)) * h_factor;
-                e_delta[C_AXIS] = (Z6(0) - Z2(1) - Z2(5) + Z4(9)) * h_factor;
-                r_delta         = (Z6(0) - Z2(1) - Z2(5) - Z2(9)) * r_factor;
+                e_delta[A_AXIS] = (Z6(CEN) +Z4(__A) -Z2(__B) -Z2(__C)) * h_factor;
+                e_delta[B_AXIS] = (Z6(CEN) -Z2(__A) +Z4(__B) -Z2(__C)) * h_factor;
+                e_delta[C_AXIS] = (Z6(CEN) -Z2(__A) -Z2(__B) +Z4(__C)) * h_factor;
+                r_delta         = (Z6(CEN) -Z2(__A) -Z2(__B) -Z2(__C)) * r_factor;
               }
               else {
-                e_delta[A_AXIS] = (Z6(0) - Z4(7) + Z2(11) + Z2(3)) * h_factor;
-                e_delta[B_AXIS] = (Z6(0) + Z2(7) - Z4(11) + Z2(3)) * h_factor;
-                e_delta[C_AXIS] = (Z6(0) + Z2(7) + Z2(11) - Z4(3)) * h_factor;
-                r_delta         = (Z6(0) - Z2(7) - Z2(11) - Z2(3)) * r_factor;
+                e_delta[A_AXIS] = (Z6(CEN) -Z4(_BC) +Z2(_CA) +Z2(_AB)) * h_factor;
+                e_delta[B_AXIS] = (Z6(CEN) +Z2(_BC) -Z4(_CA) +Z2(_AB)) * h_factor;
+                e_delta[C_AXIS] = (Z6(CEN) +Z2(_BC) +Z2(_CA) -Z4(_AB)) * h_factor;
+                r_delta         = (Z6(CEN) -Z2(_BC) -Z2(_CA) -Z2(_AB)) * r_factor;
               }
               break;
 
             default:
-              e_delta[A_AXIS] = (Z6(0) + Z2(1) - Z1(5) - Z1(9) - Z2(7) + Z1(11) + Z1(3)) * h_factor;
-              e_delta[B_AXIS] = (Z6(0) - Z1(1) + Z2(5) - Z1(9) + Z1(7) - Z2(11) + Z1(3)) * h_factor;
-              e_delta[C_AXIS] = (Z6(0) - Z1(1) - Z1(5) + Z2(9) + Z1(7) + Z1(11) - Z2(3)) * h_factor;
-              r_delta         = (Z6(0) - Z1(1) - Z1(5) - Z1(9) - Z1(7) - Z1(11) - Z1(3)) * r_factor;
+              e_delta[A_AXIS] = (Z6(CEN) +Z2(__A) -Z1(__B) -Z1(__C) -Z2(_BC) +Z1(_CA) +Z1(_AB)) * h_factor;
+              e_delta[B_AXIS] = (Z6(CEN) -Z1(__A) +Z2(__B) -Z1(__C) +Z1(_BC) -Z2(_CA) +Z1(_AB)) * h_factor;
+              e_delta[C_AXIS] = (Z6(CEN) -Z1(__A) -Z1(__B) +Z2(__C) +Z1(_BC) +Z1(_CA) -Z2(_AB)) * h_factor;
+              r_delta         = (Z6(CEN) -Z1(__A) -Z1(__B) -Z1(__C) -Z1(_BC) -Z1(_CA) -Z1(_AB)) * r_factor;
 
               if (towers_set) {
-                t_delta[A_AXIS] = (       - Z4(5) + Z4(9)         - Z4(11) + Z4(3)) * a_factor;
-                t_delta[B_AXIS] = ( Z4(1)         - Z4(9) + Z4(7)          - Z4(3)) * a_factor;
-                t_delta[C_AXIS] = (-Z4(1) + Z4(5)         - Z4(7) + Z4(11)        ) * a_factor;
+                t_delta[A_AXIS] = (         -Z4(__B) +Z4(__C)          -Z4(_CA) +Z4(_AB)) * a_factor;
+                t_delta[B_AXIS] = ( Z4(__A)          -Z4(__C) +Z4(_BC)          -Z4(_AB)) * a_factor;
+                t_delta[C_AXIS] = (-Z4(__A) +Z4(__B)          -Z4(_BC) +Z4(_CA)         ) * a_factor;
                 e_delta[A_AXIS] += (t_delta[B_AXIS] - t_delta[C_AXIS]) / 4.5;
                 e_delta[B_AXIS] += (t_delta[C_AXIS] - t_delta[A_AXIS]) / 4.5;
                 e_delta[C_AXIS] += (t_delta[A_AXIS] - t_delta[B_AXIS]) / 4.5;

Marlin/example_configurations/delta/FLSUN/auto_calibrate/Configuration.h

     // set the default number of probe points : n*n (1 -> 7)
     #define DELTA_CALIBRATION_DEFAULT_POINTS 4
 
-    // Enable and set these values based on results of 'G33 A1'
+    // Enable and set these values based on results of 'G33 A'
     //#define H_FACTOR 1.01
     //#define R_FACTOR 2.61
     //#define A_FACTOR 0.87
   #endif
 
   #if ENABLED(DELTA_AUTO_CALIBRATION) || ENABLED(DELTA_CALIBRATION_MENU)
-    // Set the radius for the calibration probe points - max DELTA_PRINTABLE_RADIUS*0.869 for non-eccentric probes
+    // Set the radius for the calibration probe points - max DELTA_PRINTABLE_RADIUS for non-eccentric probes
     #define DELTA_CALIBRATION_RADIUS 73.5 // mm
     // Set the steprate for papertest probing
     #define PROBE_MANUALLY_STEP 0.025

Marlin/example_configurations/delta/FLSUN/kossel_mini/Configuration.h

     // set the default number of probe points : n*n (1 -> 7)
     #define DELTA_CALIBRATION_DEFAULT_POINTS 4
 
-    // Enable and set these values based on results of 'G33 A1'
+    // Enable and set these values based on results of 'G33 A'
     //#define H_FACTOR 1.01
     //#define R_FACTOR 2.61
     //#define A_FACTOR 0.87
   #endif
 
   #if ENABLED(DELTA_AUTO_CALIBRATION) || ENABLED(DELTA_CALIBRATION_MENU)
-    // Set the radius for the calibration probe points - max DELTA_PRINTABLE_RADIUS*0.869 for non-eccentric probes
+    // Set the radius for the calibration probe points - max DELTA_PRINTABLE_RADIUS for non-eccentric probes
     #define DELTA_CALIBRATION_RADIUS 73.5 // mm
     // Set the steprate for papertest probing
     #define PROBE_MANUALLY_STEP 0.025

Marlin/example_configurations/delta/generic/Configuration.h

     // set the default number of probe points : n*n (1 -> 7)
     #define DELTA_CALIBRATION_DEFAULT_POINTS 4
 
-    // Enable and set these values based on results of 'G33 A1'
+    // Enable and set these values based on results of 'G33 A'
     //#define H_FACTOR 1.01
     //#define R_FACTOR 2.61
     //#define A_FACTOR 0.87
   #endif
 
   #if ENABLED(DELTA_AUTO_CALIBRATION) || ENABLED(DELTA_CALIBRATION_MENU)
-    // Set the radius for the calibration probe points - max DELTA_PRINTABLE_RADIUS*0.869 for non-eccentric probes
+    // Set the radius for the calibration probe points - max DELTA_PRINTABLE_RADIUS for non-eccentric probes
     #define DELTA_CALIBRATION_RADIUS 121.5 // mm
     // Set the steprate for papertest probing
     #define PROBE_MANUALLY_STEP 0.025

Marlin/example_configurations/delta/kossel_mini/Configuration.h

     // set the default number of probe points : n*n (1 -> 7)
     #define DELTA_CALIBRATION_DEFAULT_POINTS 4
 
-    // Enable and set these values based on results of 'G33 A1'
+    // Enable and set these values based on results of 'G33 A'
     //#define H_FACTOR 1.01
     //#define R_FACTOR 2.61
     //#define A_FACTOR 0.87
   #endif
 
   #if ENABLED(DELTA_AUTO_CALIBRATION) || ENABLED(DELTA_CALIBRATION_MENU)
-    // Set the radius for the calibration probe points - max DELTA_PRINTABLE_RADIUS*0.869 for non-eccentric probes
+    // Set the radius for the calibration probe points - max DELTA_PRINTABLE_RADIUS for non-eccentric probes
     #define DELTA_CALIBRATION_RADIUS 78.0 // mm
     // Set the steprate for papertest probing
     #define PROBE_MANUALLY_STEP 0.025

Marlin/example_configurations/delta/kossel_pro/Configuration.h

     // set the default number of probe points : n*n (1 -> 7)
     #define DELTA_CALIBRATION_DEFAULT_POINTS 4
 
-    // Enable and set these values based on results of 'G33 A1'
+    // Enable and set these values based on results of 'G33 A'
     //#define H_FACTOR 1.01
     //#define R_FACTOR 2.61
     //#define A_FACTOR 0.87
   #endif
 
   #if ENABLED(DELTA_AUTO_CALIBRATION) || ENABLED(DELTA_CALIBRATION_MENU)
-    // Set the radius for the calibration probe points - max DELTA_PRINTABLE_RADIUS*0.869 for non-eccentric probes
+    // Set the radius for the calibration probe points - max DELTA_PRINTABLE_RADIUS for non-eccentric probes
     #define DELTA_CALIBRATION_RADIUS 110.0 // mm
     // Set the steprate for papertest probing
     #define PROBE_MANUALLY_STEP 0.025

Marlin/example_configurations/delta/kossel_xl/Configuration.h

     // set the default number of probe points : n*n (1 -> 7)
     #define DELTA_CALIBRATION_DEFAULT_POINTS 4
 
-    // Enable and set these values based on results of 'G33 A1'
+    // Enable and set these values based on results of 'G33 A'
     //#define H_FACTOR 1.01
     //#define R_FACTOR 2.61
     //#define A_FACTOR 0.87
   #endif
 
   #if ENABLED(DELTA_AUTO_CALIBRATION) || ENABLED(DELTA_CALIBRATION_MENU)
-    // Set the radius for the calibration probe points - max DELTA_PRINTABLE_RADIUS*0.869 for non-eccentric probes
+    // Set the radius for the calibration probe points - max DELTA_PRINTABLE_RADIUS for non-eccentric probes
     #define DELTA_CALIBRATION_RADIUS 121.5 // mm
     // Set the steprate for papertest probing
     #define PROBE_MANUALLY_STEP 0.025