Merge pull request #6533 from thinkyhead/rc_autocal_patches

General cleanup of G33

Marlin/Marlin_main.cpp

  * G30 - Single Z probe, probes bed at X Y location (defaults to current XY location)
  * G31 - Dock sled (Z_PROBE_SLED only)
  * G32 - Undock sled (Z_PROBE_SLED only)
- * G33 - Delta '1-4-7-point' auto calibration : "G33 V<verbose> P<points> <A> <O> <T>" (Requires DELTA)
+ * G33 - Delta Auto-Calibration (Requires DELTA_AUTO_CALIBRATION)
  * G38 - Probe target - similar to G28 except it uses the Z_MIN_PROBE for all three axes
  * G90 - Use Absolute Coordinates
  * G91 - Use Relative Coordinates
   #if ENABLED(DEBUG_LEVELING_FEATURE)
     if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("<<< gcode_G28");
   #endif
-}
+} // G28
 
 void home_all_axes() { gcode_G28(); }
 
 
   #if ENABLED(DELTA_AUTO_CALIBRATION)
     /**
-     * G33 - Delta '1-4-7-point' auto calibration (Requires DELTA)
-     * 
-     * Usage:
-     *   G33 <Vn> <Pn> <A> <O> <T>
-     *   
-     *     Vn = verbose level (n=0-2 default 1)
-     *          n=0 dry-run mode: setting + probe results / no calibration
-     *          n=1 settings 
-     *          n=2 setting + probe results 
-     *     Pn = n=-7 -> +7 : n*n probe points
-     *          calibrates height ('1 point'), endstops, and delta radius ('4 points') 
-     *          and tower angles with n > 2 ('7+ points')
-     *          n=1  probes center / sets height only
-     *          n=2  probes center and towers / sets height, endstops and delta radius
-     *          n=3  probes all points: center, towers and opposite towers / sets all
-     *          n>3  probes all points multiple times and averages
-     *     A  = abort 1 point delta height calibration after 1 probe
-     *     O  = use oposite tower points instead of tower points with 4 point calibration
-     *     T  = do not calibrate tower angles with 7+ point calibration
+     * G33 - Delta '1-4-7-point' Auto-Calibration
+     *       Calibrate height, endstops, delta radius, and tower angles.
+     *
+     * Parameters:
+     *
+     *   P  Number of probe points:
+     *
+     *      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.
+     *
+     *   A  Abort delta height calibration after 1 probe (only P1)
+     *
+     *   O  Use opposite tower points instead of tower points (only P2)
+     *
+     *   T  Don't calibrate tower angle corrections (P3-P7)
+     *
+     *   V  Verbose level:
+     *
+     *      V0  Dry-run mode. Report settings and probe results. No calibration.
+     *      V1  Report settings
+     *      V2  Report settings and probe results
      */
     inline void gcode_G33() {
 
-      stepper.synchronize();
+      const int8_t probe_points = code_seen('P') ? code_value_int() : DELTA_CALIBRATION_DEFAULT_POINTS;
+      if (!WITHIN(probe_points, 1, 7)) {
+        SERIAL_PROTOCOLLNPGM("?(P)oints is implausible (1 to 7).");
+        return;
+      }
 
-      #if HAS_LEVELING
-        set_bed_leveling_enabled(false);
-      #endif
+      const int8_t verbose_level = code_seen('V') ? code_value_byte() : 1;
+      if (!WITHIN(verbose_level, 0, 2)) {
+        SERIAL_PROTOCOLLNPGM("?(V)erbose Level is implausible (0-2).");
+        return;
+      }
 
-      int8_t pp = (code_seen('P') ? code_value_int() : DELTA_CALIBRATION_DEFAULT_POINTS),
-             probe_mode = (WITHIN(pp, 1, 7) ? pp : DELTA_CALIBRATION_DEFAULT_POINTS);
+      const bool do_height_only       = probe_points == 1,
+                 do_center_and_towers = probe_points == 2,
+                 do_all_positions     = probe_points == 3,
+                 do_circle_x2         = probe_points == 5,
+                 do_circle_x3         = probe_points == 6,
+                 do_circle_x4         = probe_points == 7,
+                 probe_center_plus_3  = probe_points >= 3,
+                 point_averaging      = probe_points >= 4,
+                 probe_center_plus_6  = probe_points >= 5;
 
-      probe_mode = (code_seen('A') && probe_mode == 1 ? -probe_mode : probe_mode);
-      probe_mode = (code_seen('O') && probe_mode == 2 ? -probe_mode : probe_mode);
-      probe_mode = (code_seen('T') && probe_mode > 2 ? -probe_mode : probe_mode);
-      
-      int8_t verbose_level = (code_seen('V') ? code_value_byte() : 1);
+      const char negating_parameter = do_height_only ? 'A' : do_center_and_towers ? 'O' : 'T';
+      int8_t probe_mode = code_seen(negating_parameter) && code_value_bool() ? -probe_points : probe_points;
+
+      SERIAL_PROTOCOLLNPGM("G33 Auto Calibrate");
 
-      if (!WITHIN(verbose_level, 0, 2)) verbose_level = 1;
+      #if HAS_LEVELING
+        set_bed_leveling_enabled(false);
+      #endif
 
-      gcode_G28();
+      home_all_axes();
 
       const static char save_message[] PROGMEM = "Save with M500 and/or copy to Configuration.h";
       float test_precision,
             dr_old = delta_radius,
             zh_old = home_offset[Z_AXIS],
             alpha_old = delta_tower_angle_trim[A_AXIS],
-            beta_old = delta_tower_angle_trim[B_AXIS]; 
-      int8_t iterations = 0,
-             probe_points = abs(probe_mode);
-      const bool pp_equals_1 = (probe_points == 1),
-                 pp_equals_2 = (probe_points == 2),
-                 pp_equals_3 = (probe_points == 3),
-                 pp_equals_4 = (probe_points == 4),
-                 pp_equals_5 = (probe_points == 5),
-                 pp_equals_6 = (probe_points == 6),
-                 pp_equals_7 = (probe_points == 7),
-                 pp_greather_2 = (probe_points > 2),
-                 pp_greather_3 = (probe_points > 3),
-                 pp_greather_4 = (probe_points > 4),
-                 pp_greather_5 = (probe_points > 5);
- 
+            beta_old = delta_tower_angle_trim[B_AXIS];
+
       // print settings
 
-      SERIAL_PROTOCOLLNPGM("G33 Auto Calibrate");
       SERIAL_PROTOCOLPGM("Checking... AC");
       if (verbose_level == 0) SERIAL_PROTOCOLPGM(" (DRY-RUN)");
       SERIAL_EOL;
       LCD_MESSAGEPGM("Checking... AC");
 
       SERIAL_PROTOCOLPAIR(".Height:", DELTA_HEIGHT + home_offset[Z_AXIS]);
-      if (!pp_equals_1) {
+      if (!do_height_only) {
         SERIAL_PROTOCOLPGM("    Ex:");
         if (endstop_adj[A_AXIS] >= 0) SERIAL_CHAR('+');
         SERIAL_PROTOCOL_F(endstop_adj[A_AXIS], 2);
         DEPLOY_PROBE();
       #endif
 
+      int8_t iterations = 0;
+
       do {
 
         float z_at_pt[13] = { 0 },
         test_precision = zero_std_dev;
         iterations++;
 
-        // probe the points
+        // Probe the points
 
-        if (!pp_equals_3 && !pp_equals_6) { // probe the centre
+        if (!do_all_positions && !do_circle_x3) { // probe the center
           setup_for_endstop_or_probe_move();
           z_at_pt[0] += probe_pt(0.0, 0.0 , true, 1);
           clean_up_after_endstop_or_probe_move();
         }
-        if (pp_greather_2) { // probe extra centre points
-          for (int8_t axis = (pp_greather_4 ? 11 : 9); axis > 0; axis -= (pp_greather_4 ? 2 : 4)) {              
+        if (probe_center_plus_3) { // probe extra center points
+          for (int8_t axis = probe_center_plus_6 ? 11 : 9; axis > 0; axis -= probe_center_plus_6 ? 2 : 4) {
             setup_for_endstop_or_probe_move();
             z_at_pt[0] += probe_pt(
               cos(RADIANS(180 + 30 * axis)) * (0.1 * delta_calibration_radius),
               sin(RADIANS(180 + 30 * axis)) * (0.1 * delta_calibration_radius), true, 1);
             clean_up_after_endstop_or_probe_move();
           }
-          z_at_pt[0] /= (pp_equals_5 ? 7 : probe_points);
+          z_at_pt[0] /= float(do_circle_x2 ? 7 : probe_points);
         }
-        if (!pp_equals_1) {  // probe the radius
-          float start_circles = (pp_equals_7 ? -1.5 : pp_equals_6 || pp_equals_5 ? -1 : 0),
-                end_circles = -start_circles;
+        if (!do_height_only) {  // probe the radius
           bool zig_zag = true;
-          for (uint8_t axis = (probe_mode == -2 ? 3 : 1); axis < 13; 
-               axis += (pp_equals_2 ? 4 : pp_equals_3 || pp_equals_5 ? 2 : 1)) {
-            for (float circles = start_circles ; circles <= end_circles; circles++) {
+          for (uint8_t axis = (probe_mode == -2 ? 3 : 1); axis < 13;
+                       axis += (do_center_and_towers ? 4 : do_all_positions ? 2 : 1)) {
+            float offset_circles = (do_circle_x4 ? (zig_zag ? 1.5 : 1.0) :
+                                    do_circle_x3 ? (zig_zag ? 1.0 : 0.5) :
+                                    do_circle_x2 ? (zig_zag ? 0.5 : 0.0) : 0);
+            for (float circles = -offset_circles ; circles <= offset_circles; circles++) {
               setup_for_endstop_or_probe_move();
               z_at_pt[axis] += probe_pt(
-                cos(RADIANS(180 + 30 * axis)) * 
-                (1 + circles * 0.1 * (zig_zag ? 1 : -1)) * delta_calibration_radius, 
-                sin(RADIANS(180 + 30 * axis)) * 
-                (1 + circles * 0.1 * (zig_zag ? 1 : -1)) * delta_calibration_radius, true, 1);
+                cos(RADIANS(180 + 30 * axis)) * delta_calibration_radius *
+                (1 + circles * 0.1 * (zig_zag ? 1 : -1)),
+                sin(RADIANS(180 + 30 * axis)) * delta_calibration_radius *
+                (1 + circles * 0.1 * (zig_zag ? 1 : -1)), true, 1);
               clean_up_after_endstop_or_probe_move();
             }
-            start_circles += (pp_greather_5 ? (zig_zag ? 0.5 : -0.5) : 0);
-            end_circles = -start_circles;
             zig_zag = !zig_zag;
-            z_at_pt[axis] /= (pp_equals_7 ? (zig_zag ? 4.0 : 3.0) :
-                              pp_equals_6 ? (zig_zag ? 3.0 : 2.0) : pp_equals_5 ? 3 : 1);
+            z_at_pt[axis] /= (2 * offset_circles + 1);
           }
         }
-        if (pp_greather_3 && !pp_equals_5) // average intermediates to tower and opposites
-          for (uint8_t axis = 1; axis < 13; axis += 2)
+        if (point_averaging) // average intermediates to tower and opposites
+          for (uint8_t axis = 1; axis <= 11; 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;
 
         S1 += z_at_pt[0];
         S2 += sq(z_at_pt[0]);
         N++;
-        if (!pp_equals_1) // std dev from zero plane
-          for (uint8_t axis = (probe_mode == -2 ? 3 : 1); axis < 13; axis += (pp_equals_2 ? 4 : 2)) {
+        if (!do_height_only) // std dev from zero plane
+          for (uint8_t axis = (probe_mode == -2 ? 3 : 1); axis < 13; axis += (do_center_and_towers ? 4 : 2)) {
             S1 += z_at_pt[axis];
             S2 += sq(z_at_pt[axis]);
             N++;
               e_delta[Y_AXIS] = Z1050(0) - Z0175(1) + Z0350(5) - Z0175(9) + Z0175(7) - Z0350(11) + Z0175(3);
               e_delta[Z_AXIS] = Z1050(0) - Z0175(1) - Z0175(5) + Z0350(9) + Z0175(7) + Z0175(11) - Z0350(3);
               r_delta         = Z2250(0) - Z0375(1) - Z0375(5) - Z0375(9) - Z0375(7) - Z0375(11) - Z0375(3);
-              
+
               if (probe_mode > 0) {  // negative disables tower angles
                 t_alpha = + Z0444(1) - Z0888(5) + Z0444(9) + Z0444(7) - Z0888(11) + Z0444(3);
                 t_beta  = - Z0888(1) + Z0444(5) + Z0444(9) - Z0888(7) + Z0444(11) + Z0444(3);
           SERIAL_PROTOCOLPGM(".      c:");
           if (z_at_pt[0] > 0) SERIAL_CHAR('+');
           SERIAL_PROTOCOL_F(z_at_pt[0], 2);
-          if (probe_mode == 2 || pp_greather_2) {
+          if (probe_mode == 2 || probe_center_plus_3) {
             SERIAL_PROTOCOLPGM("     x:");
             if (z_at_pt[1] >= 0) SERIAL_CHAR('+');
             SERIAL_PROTOCOL_F(z_at_pt[1], 2);
             SERIAL_PROTOCOL_F(z_at_pt[9], 2);
           }
           if (probe_mode != -2) SERIAL_EOL;
-          if (probe_mode == -2 || pp_greather_2) {
-            if (pp_greather_2) {
+          if (probe_mode == -2 || probe_center_plus_3) {
+            if (probe_center_plus_3) {
               SERIAL_CHAR('.');
               SERIAL_PROTOCOL_SP(13);
             }
             lcd_setstatus(mess);
           }
           SERIAL_PROTOCOLPAIR(".Height:", DELTA_HEIGHT + home_offset[Z_AXIS]);
-          if (!pp_equals_1) {
+          if (!do_height_only) {
             SERIAL_PROTOCOLPGM("    Ex:");
             if (endstop_adj[A_AXIS] >= 0) SERIAL_CHAR('+');
             SERIAL_PROTOCOL_F(endstop_adj[A_AXIS], 2);
 
         stepper.synchronize();
 
-        gcode_G28();
+        home_all_axes();
 
       } while (zero_std_dev < test_precision && iterations < 31);
 
     clean_up_after_endstop_or_probe_move();
 
     // Re-enable bed level correction if it had been on
-    #if HAS_ABL
+    #if HAS_LEVELING
       set_bed_leveling_enabled(was_enabled);
     #endif
 
       #else
         UNUSED(no_babystep);
       #endif
- 
+
       #if ENABLED(DELTA) // correct the delta_height
         home_offset[Z_AXIS] -= diff;
       #endif
 
         #if ENABLED(DELTA_AUTO_CALIBRATION)
 
-          case 33: // G33: Delta Auto Calibrate
+          case 33: // G33: Delta Auto-Calibration
             gcode_G33();
             break;
 

Marlin/configuration_store.cpp

  *
  */
 
-#define EEPROM_VERSION "V36"
+#define EEPROM_VERSION "V37"
 
 // Change EEPROM version if these are changed:
 #define EEPROM_OFFSET 100
 
 /**
- * V35 EEPROM Layout:
+ * V37 EEPROM Layout:
  *
  *  100  Version                                    (char x4)
  *  104  EEPROM Checksum                            (uint16_t)

Marlin/ubl.cpp

   void bit_set(uint16_t bits[16], uint8_t x, uint8_t y) { SBI(bits[y], x); }
   bool is_bit_set(uint16_t bits[16], uint8_t x, uint8_t y) { return TEST(bits[y], x); }
 
-  int ubl_cnt=0;
+  uint8_t ubl_cnt = 0;
 
   static void serial_echo_xy(const uint16_t x, const uint16_t y) {
     SERIAL_CHAR('(');

Marlin/ubl.h

     float distance; // When populated, the distance from the search location
   } mesh_index_pair;
 
+  // ubl.cpp
+
+  void bit_clear(uint16_t bits[16], uint8_t x, uint8_t y);
+  void bit_set(uint16_t bits[16], uint8_t x, uint8_t y);
+  bool is_bit_set(uint16_t bits[16], uint8_t x, uint8_t y);
+
+  // ubl_motion.cpp
+
+  void debug_current_and_destination(const char * const title);
+  void ubl_line_to_destination(const float&, uint8_t);
+
+  // ubl_G29.cpp
+
   enum MeshPointType { INVALID, REAL, SET_IN_BITMAP };
 
   void dump(char * const str, const float &f);
-  bool ubl_lcd_clicked();
   void probe_entire_mesh(const float&, const float&, const bool, const bool, const bool);
-  void debug_current_and_destination(const char * const title);
-  void ubl_line_to_destination(const float&, uint8_t);
   void manually_probe_remaining_mesh(const float&, const float&, const float&, const float&, const bool);
   float measure_business_card_thickness(const float&);
   mesh_index_pair find_closest_mesh_point_of_type(const MeshPointType, const float&, const float&, const bool, unsigned int[16], bool);
   void shift_mesh_height();
+  void fine_tune_mesh(const float&, const float&, const bool);
   bool g29_parameter_parsing();
   void g29_what_command();
   void g29_eeprom_dump();
   void g29_compare_current_mesh_to_stored_mesh();
-  void fine_tune_mesh(const float&, const float&, const bool);
-  void bit_clear(uint16_t bits[16], uint8_t x, uint8_t y);
-  void bit_set(uint16_t bits[16], uint8_t x, uint8_t y);
-  bool is_bit_set(uint16_t bits[16], uint8_t x, uint8_t y);
-  char *ftostr43sign(const float&, char);
 
-  void home_all_axes();
+  // External references
 
+  char *ftostr43sign(const float&, char);
+  bool ubl_lcd_clicked();
+  void home_all_axes();
   void gcode_G26();
   void gcode_G29();
 
-  extern int ubl_cnt;
+  extern uint8_t ubl_cnt;
 
   ///////////////////////////////////////////////////////////////////////////////////////////////////////
 
     void lcd_quick_feedback();
   #endif
 
-
   #define MESH_X_DIST (float(UBL_MESH_MAX_X - (UBL_MESH_MIN_X)) / float(GRID_MAX_POINTS_X - 1))
   #define MESH_Y_DIST (float(UBL_MESH_MAX_Y - (UBL_MESH_MIN_Y)) / float(GRID_MAX_POINTS_Y - 1))
 

Marlin/ubl_G29.cpp

     SERIAL_EOL;
     safe_delay(50);
 
-    SERIAL_PROTOCOLLNPAIR("UBL object count: ", ubl_cnt);
+    SERIAL_PROTOCOLLNPAIR("UBL object count: ", (int)ubl_cnt);
 
     #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
       SERIAL_PROTOCOLLNPAIR("planner.z_fade_height : ", planner.z_fade_height);

Marlin/ubl_motion.cpp

-
 /**
  * Marlin 3D Printer Firmware
  * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
         if (y != start[Y_AXIS]) {
           if (!inf_normalized_flag) {
 
-//          on_axis_distance = y - start[Y_AXIS];                               
+            //on_axis_distance = y - start[Y_AXIS];                               
             on_axis_distance = use_x_dist ? x - start[X_AXIS] : y - start[Y_AXIS];
 
-//          on_axis_distance = use_x_dist ? next_mesh_line_x - start[X_AXIS] : y - start[Y_AXIS];
-//          on_axis_distance = use_x_dist ? x - start[X_AXIS] : next_mesh_line_y - start[Y_AXIS];
-
-//          on_axis_distance = use_x_dist ? next_mesh_line_x - start[X_AXIS] : y - start[Y_AXIS];
-//          on_axis_distance = use_x_dist ? x - start[X_AXIS] : next_mesh_line_y - start[Y_AXIS];
+            //on_axis_distance = use_x_dist ? next_mesh_line_x - start[X_AXIS] : y - start[Y_AXIS];
+            //on_axis_distance = use_x_dist ? x - start[X_AXIS] : next_mesh_line_y - start[Y_AXIS];
 
+            //on_axis_distance = use_x_dist ? next_mesh_line_x - start[X_AXIS] : y - start[Y_AXIS];
+            //on_axis_distance = use_x_dist ? x - start[X_AXIS] : next_mesh_line_y - start[Y_AXIS];
 
             e_position = start[E_AXIS] + on_axis_distance * e_normalized_dist;  
             z_position = start[Z_AXIS] + on_axis_distance * z_normalized_dist;
         if (x != start[X_AXIS]) {
           if (!inf_normalized_flag) {
 
-//          on_axis_distance = x - start[X_AXIS];
+            //on_axis_distance = x - start[X_AXIS];
             on_axis_distance = use_x_dist ? x - start[X_AXIS] : y - start[Y_AXIS];
 
-//          on_axis_distance = use_x_dist ? next_mesh_line_x - start[X_AXIS] : y - start[Y_AXIS];
-//          on_axis_distance = use_x_dist ? x - start[X_AXIS] : next_mesh_line_y - start[Y_AXIS];
+            //on_axis_distance = use_x_dist ? next_mesh_line_x - start[X_AXIS] : y - start[Y_AXIS];
+            //on_axis_distance = use_x_dist ? x - start[X_AXIS] : next_mesh_line_y - start[Y_AXIS];
 
             e_position = start[E_AXIS] + on_axis_distance * e_normalized_dist;  // is based on X or Y because this is a horizontal move
             z_position = start[Z_AXIS] + on_axis_distance * z_normalized_dist;