Merge pull request #8690 from thinkyhead/bf1_clean_blocks_on_trigger

[1.1.x] Purge blocks on endstop/probe hit

Marlin/G26_Mesh_Validation_Tool.cpp

   #if ENABLED(NEWPANEL)
 
     /**
-     * Detect is_lcd_clicked, debounce it, and return true for cancel
+     * If the LCD is clicked, cancel, wait for release, return true
      */
     bool user_canceled() {
       if (!is_lcd_clicked()) return false; // Return if the button isn't pressed
-
-      #if ENABLED(ULTRA_LCD)
-        lcd_setstatusPGM(PSTR("Mesh Validation Stopped."), 99);
+      lcd_setstatusPGM(PSTR("Mesh Validation Stopped."), 99);
+      #if ENABLED(ULTIPANEL)
         lcd_quick_feedback();
       #endif
-
-      safe_delay(10);                      // Wait for click to settle
-      while (!is_lcd_clicked()) idle();    // Wait for button press again?
-
-      // If the button is suddenly pressed again,
-      // ask the user to resolve the issue
-      lcd_setstatusPGM(PSTR("Release button"), 99); // will never appear...
       wait_for_release();
-      lcd_reset_status();
       return true;
     }
 

Marlin/Marlin_main.cpp

   saved_feedrate_percentage = feedrate_percentage;
   feedrate_percentage = 100;
   refresh_cmd_timeout();
-  planner.split_first_move = false; 
 }
 
 static void clean_up_after_endstop_or_probe_move() {
   feedrate_mm_s = saved_feedrate_mm_s;
   feedrate_percentage = saved_feedrate_percentage;
   refresh_cmd_timeout();
-  planner.split_first_move = true; 
 }
 
 #if HAS_BED_PROBE

Marlin/planner.cpp

   uint8_t Planner::last_extruder = 0;     // Respond to extruder change
 #endif
 
-bool Planner::split_first_move = true;
-
 int16_t Planner::flow_percentage[EXTRUDERS] = ARRAY_BY_EXTRUDERS1(100); // Extrusion factor for each extruder
 
 float Planner::e_factor[EXTRUDERS],               // The flow percentage and volumetric multiplier combine to scale E movement
     position[E_AXIS] = target[E_AXIS];
 
   // Always split the first move into two (if not homing or probing)
-  if (!blocks_queued() && split_first_move) {
+  if (!blocks_queued()) {
     #define _BETWEEN(A) (position[A##_AXIS] + target[A##_AXIS]) >> 1
     const int32_t between[XYZE] = { _BETWEEN(X), _BETWEEN(Y), _BETWEEN(Z), _BETWEEN(E) };
     DISABLE_STEPPER_DRIVER_INTERRUPT();

Marlin/planner.h

                  travel_acceleration,  // Travel acceleration mm/s^2  DEFAULT ACCELERATION for all NON printing moves. M204 MXXXX
                  max_jerk[XYZE],       // The largest speed change requiring no acceleration
                  min_travel_feedrate_mm_s;
-    static bool split_first_move;
 
     #if HAS_LEVELING
       static bool leveling_active;          // Flag that bed leveling is enabled

Marlin/stepper.cpp

 }
 
 void Stepper::quick_stop() {
-  #if ENABLED(AUTO_BED_LEVELING_UBL) && ENABLED(ULTIPANEL)
-    if (!ubl.lcd_map_control)
-      cleaning_buffer_counter = 5000;
-  #else
-    cleaning_buffer_counter = 5000;
-  #endif
+  cleaning_buffer_counter = 5000;
   DISABLE_STEPPER_DRIVER_INTERRUPT();
   while (planner.blocks_queued()) planner.discard_current_block();
   current_block = NULL;
   #endif // !COREXY && !COREXZ && !COREYZ
 
   kill_current_block();
+  cleaning_buffer_counter = -(BLOCK_BUFFER_SIZE - 1); // Ignore remaining blocks
 }
 
 void Stepper::report_positions() {

Marlin/stepper.h

       static uint32_t motor_current_setting[3];
     #endif
 
+    static int16_t cleaning_buffer_counter;
+
   private:
 
     static uint8_t last_direction_bits;        // The next stepping-bits to be output
-    static int16_t cleaning_buffer_counter;
 
     #if ENABLED(X_DUAL_ENDSTOPS)
       static bool locked_x_motor, locked_x2_motor;

Marlin/ubl_G29.cpp

   void unified_bed_leveling::G29() {
 
     if (!settings.calc_num_meshes()) {
-      SERIAL_PROTOCOLLNPGM("?You need to enable your EEPROM and initialize it");
-      SERIAL_PROTOCOLLNPGM("with M502, M500, M501 in that order.\n");
+      SERIAL_PROTOCOLLNPGM("?Enable EEPROM and init with M502, M500.\n");
       return;
     }
 

Marlin/ultralcd.cpp

     if (no_reentry) return;
     // Make this the current handler till all moves are done
     no_reentry = true;
-    screenFunc_t old_screen = currentScreen;
+    const screenFunc_t old_screen = currentScreen;
     lcd_goto_screen(_lcd_synchronize);
     stepper.synchronize();
     no_reentry = false;
     void set_current_from_steppers_for_axis(const AxisEnum axis);
     void sync_plan_position();
 
+    void _lcd_do_nothing() {}
+    void _lcd_hard_stop() {
+      stepper.quick_stop();
+      const screenFunc_t old_screen = currentScreen;
+      currentScreen = _lcd_do_nothing;
+      while (planner.movesplanned()) idle();
+      currentScreen = old_screen;
+      stepper.cleaning_buffer_counter = 0;
+      set_current_from_steppers_for_axis(ALL_AXES);
+      sync_plan_position();
+      refresh_cmd_timeout();
+    }
+
     void _lcd_ubl_output_map_lcd() {
       static int16_t step_scaler = 0;
 
       if (lcdDrawUpdate) {
         lcd_implementation_ubl_plot(x_plot, y_plot);
 
-        ubl_map_move_to_xy(); // Move to current location
+        if (planner.movesplanned()) // If the nozzle is already moving, cancel the move.
+          _lcd_hard_stop();
 
-        if (planner.movesplanned() > 1) { // if the nozzle is moving, cancel the move.  There is a new location
-          stepper.quick_stop();
-          set_current_from_steppers_for_axis(ALL_AXES);
-          sync_plan_position();
-          ubl_map_move_to_xy(); // Move to new location
-          refresh_cmd_timeout();
-        }
+        ubl_map_move_to_xy();       // Move to new location
       }
     }