BLTOUCH tweaks, new v3.1 command (#14015)

Marlin/src/feature/bltouch.cpp

   /**
    * Return a TRUE for "YES, it is DEPLOYED"
    * This function will ensure switch state is reset after execution
-   * This may change pin position in some scenarios, specifically
-   * if the pin has been triggered but not yet stowed.
    */
 
   if (DEBUGGING(LEVELING)) DEBUG_ECHOLN("BLTouch STATUS requested");
 
-  _set_SW_mode();
+  _set_SW_mode();              // Incidentally, _set_SW_mode() will also RESET any active alarm
   const bool tr = triggered(); // If triggered in SW mode, the pin is up, it is STOWED
 
   if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPAIR("BLTouch is ", (int)tr);
 
-  _reset();                         // turn off the SW Mode
-  if (tr) _stow(); else _deploy();  // and reset any triggered signal, restore state
+  if (tr) _stow(); else _deploy();  // Turn off SW mode, reset any trigger, honor pin state
   return !tr;
 }
 

Marlin/src/feature/bltouch.h

 #define BLTOUCH_SW_MODE         60
 #define BLTOUCH_STOW            90
 #define BLTOUCH_SELFTEST       120
+#define BLTOUCH_MODE_STORE     130
 #define BLTOUCH_5V_MODE        140
 #define BLTOUCH_OD_MODE        150
 #define BLTOUCH_RESET          160
 #ifndef BLTOUCH_SETOD_DELAY
   #define BLTOUCH_SETOD_DELAY   BLTOUCH_DELAY
 #endif
+#ifndef BLTOUCH_MODE_STORE_DELAY
+  #define BLTOUCH_MODE_STORE_DELAY   BLTOUCH_DELAY
+#endif
 #ifndef BLTOUCH_DEPLOY_DELAY
   #define BLTOUCH_DEPLOY_DELAY   750
 #endif
   FORCE_INLINE static void _selftest()           { command(BLTOUCH_SELFTEST, BLTOUCH_DELAY); }
 
   FORCE_INLINE static void _set_SW_mode()        { command(BLTOUCH_SW_MODE, BLTOUCH_DELAY); }
+  FORCE_INLINE static void _reset_SW_mode()      { if (triggered()) _stow(); else _deploy(); }
+
   FORCE_INLINE static void _set_5V_mode()        { command(BLTOUCH_5V_MODE, BLTOUCH_SET5V_DELAY); }
   FORCE_INLINE static void _set_OD_mode()        { command(BLTOUCH_OD_MODE, BLTOUCH_SETOD_DELAY); }
+  FORCE_INLINE static void _mode_store()         { command(BLTOUCH_MODE_STORE, BLTOUCH_MODE_STORE_DELAY); }
 
   FORCE_INLINE static void _deploy()             { command(BLTOUCH_DEPLOY, BLTOUCH_DEPLOY_DELAY); }
   FORCE_INLINE static void _stow()               { command(BLTOUCH_STOW, BLTOUCH_STOW_DELAY); }

Marlin/src/gcode/calibrate/G28.cpp

     workspace_plane = PLANE_XY;
   #endif
 
-  #if ENABLED(BLTOUCH)
-    bltouch.init();
-  #endif
-
   // Always home with tool 0 active
   #if HOTENDS > 1
     #if DISABLED(DELTA) || ENABLED(DELTA_HOME_TO_SAFE_ZONE)
     // Home Z last if homing towards the bed
     #if Z_HOME_DIR < 0
       if (doZ) {
+        #if ENABLED(BLTOUCH)
+          bltouch.init();
+        #endif
         #if ENABLED(Z_SAFE_HOMING)
           home_z_safely();
         #else

Marlin/src/gcode/calibrate/G34_M422.cpp

   do { // break out on error
 
     if (!TEST(axis_known_position, X_AXIS) || !TEST(axis_known_position, Y_AXIS)) {
-      if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("> XY homing required.");
+      SERIAL_ECHOLNPGM("Home XY first");
       break;
     }
 
       float z_measured_min = 100000.0f;
       // For each iteration go through all probe positions (one per Z-Stepper)
       for (uint8_t zstepper = 0; zstepper < Z_STEPPER_COUNT; ++zstepper) {
+
+        #if BOTH(BLTOUCH, BLTOUCH_HS_MODE)
+          // In BLTOUCH HS mode, the probe travels in a deployed state.
+          // Users of G34 might have a badly misaligned bed, so raise Z by the
+          // length of the deployed pin (BLTOUCH stroke < 7mm)
+          do_blocking_move_to_z(Z_CLEARANCE_BETWEEN_PROBES + 7);
+        #endif
+
         // Probe a Z height for each stepper
         z_measured[zstepper] = probe_pt(z_auto_align_xpos[zstepper], z_auto_align_ypos[zstepper], PROBE_PT_RAISE, false);
 
       ));
     #endif
 
-    #if HAS_LEVELING
-      #if ENABLED(RESTORE_LEVELING_AFTER_G34)
-        set_bed_leveling_enabled(leveling_was_active);
-      #endif
+    #if HAS_LEVELING && ENABLED(RESTORE_LEVELING_AFTER_G34)
+      set_bed_leveling_enabled(leveling_was_active);
     #endif
 
     // After this operation the z position needs correction
     set_axis_is_not_at_home(Z_AXIS);
 
+    #if BOTH(BLTOUCH, BLTOUCH_HS_MODE)
+      // In BLTOUCH HS mode, the pin is still deployed at this point.
+      // The upcoming G28 means travel, so it is better to stow the pin.
+      bltouch._stow();
+    #endif
+
     gcode.G28(false);
 
   } while(0);

Marlin/src/gcode/config/M43.cpp

   #include "../../module/servo.h"
 #endif
 
+#if ENABLED(BLTOUCH)
+  #include "../../feature/bltouch.h"
+#endif
+
 #if ENABLED(HOST_PROMPT_SUPPORT)
   #include "../../feature/host_actions.h"
 #endif
 } // toggle_pins
 
 inline void servo_probe_test() {
+
   #if !(NUM_SERVOS > 0 && HAS_SERVO_0)
 
-    SERIAL_ERROR_MSG("SERVO not setup");
+    SERIAL_ERROR_MSG("SERVO not set up.");
 
   #elif !HAS_Z_SERVO_PROBE
 
-    SERIAL_ERROR_MSG("Z_PROBE_SERVO_NR not setup");
+    SERIAL_ERROR_MSG("Z_PROBE_SERVO_NR not set up.");
 
   #else // HAS_Z_SERVO_PROBE
 
     const uint8_t probe_index = parser.byteval('P', Z_PROBE_SERVO_NR);
 
-    SERIAL_ECHOLNPGM("Servo probe test");
-    SERIAL_ECHOLNPAIR(".  using index:  ", probe_index);
-    SERIAL_ECHOLNPAIR(".  deploy angle: ", servo_angles[probe_index][0]);
-    SERIAL_ECHOLNPAIR(".  stow angle:   ", servo_angles[probe_index][1]);
+    SERIAL_ECHOLNPAIR("Servo probe test\n"
+                      ". using index:  ", int(probe_index),
+                      ", deploy angle: ", servo_angles[probe_index][0],
+                      ", stow angle:   ", servo_angles[probe_index][1]
+    );
 
-    bool probe_inverting;
+    bool deploy_state, stow_state;
 
     #if ENABLED(Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN)
 
       #define PROBE_TEST_PIN Z_MIN_PIN
+      constexpr bool probe_inverting = Z_MIN_ENDSTOP_INVERTING;
 
-      SERIAL_ECHOLNPAIR(". probe uses Z_MIN pin: ", PROBE_TEST_PIN);
-      SERIAL_ECHOLNPGM(". uses Z_MIN_ENDSTOP_INVERTING (ignores Z_MIN_PROBE_ENDSTOP_INVERTING)");
+      SERIAL_ECHOLNPAIR(". Probe Z_MIN_PIN: ", int(PROBE_TEST_PIN));
       SERIAL_ECHOPGM(". Z_MIN_ENDSTOP_INVERTING: ");
 
-      #if Z_MIN_ENDSTOP_INVERTING
-        SERIAL_ECHOLNPGM("true");
-      #else
-        SERIAL_ECHOLNPGM("false");
-      #endif
-
-      probe_inverting = Z_MIN_ENDSTOP_INVERTING;
-
-    #elif USES_Z_MIN_PROBE_ENDSTOP
+    #else
 
       #define PROBE_TEST_PIN Z_MIN_PROBE_PIN
-      SERIAL_ECHOLNPAIR(". probe uses Z_MIN_PROBE_PIN: ", PROBE_TEST_PIN);
-      SERIAL_ECHOLNPGM(". uses Z_MIN_PROBE_ENDSTOP_INVERTING (ignores Z_MIN_ENDSTOP_INVERTING)");
-      SERIAL_ECHOPGM(". Z_MIN_PROBE_ENDSTOP_INVERTING: ");
-
-      #if Z_MIN_PROBE_ENDSTOP_INVERTING
-        SERIAL_ECHOLNPGM("true");
-      #else
-        SERIAL_ECHOLNPGM("false");
-      #endif
+      constexpr bool probe_inverting = Z_MIN_PROBE_ENDSTOP_INVERTING;
 
-      probe_inverting = Z_MIN_PROBE_ENDSTOP_INVERTING;
+      SERIAL_ECHOLNPAIR(". Probe Z_MIN_PROBE_PIN: ", int(PROBE_TEST_PIN));
+      SERIAL_ECHOPGM(   ". Z_MIN_PROBE_ENDSTOP_INVERTING: ");
 
     #endif
 
-    SERIAL_ECHOLNPGM(". deploy & stow 4 times");
+    serialprint_truefalse(probe_inverting);
+    SERIAL_EOL();
+
     SET_INPUT_PULLUP(PROBE_TEST_PIN);
-    uint8_t i = 0;
-    bool deploy_state, stow_state;
-    do {
-      MOVE_SERVO(probe_index, servo_angles[Z_PROBE_SERVO_NR][0]); // Deploy
-      safe_delay(500);
-      deploy_state = READ(PROBE_TEST_PIN);
-      MOVE_SERVO(probe_index, servo_angles[Z_PROBE_SERVO_NR][1]); // Stow
-      safe_delay(500);
-      stow_state = READ(PROBE_TEST_PIN);
-    } while (++i < 4);
-    if (probe_inverting != deploy_state) SERIAL_ECHOLNPGM("WARNING - INVERTING setting probably backwards");
-
-    if (deploy_state != stow_state) {
-      SERIAL_ECHOLNPGM("BLTouch clone detected");
-      if (deploy_state) {
-        SERIAL_ECHOLNPGM(".  DEPLOYED state: HIGH (logic 1)");
-        SERIAL_ECHOLNPGM(".  STOWED (triggered) state: LOW (logic 0)");
-      }
-      else {
-        SERIAL_ECHOLNPGM(".  DEPLOYED state: LOW (logic 0)");
-        SERIAL_ECHOLNPGM(".  STOWED (triggered) state: HIGH (logic 1)");
+
+    // First, check for a probe that recognizes an advanced BLTouch sequence.
+    // In addition to STOW and DEPLOY, it uses SW MODE (and RESET in the beginning)
+    // to see if this is one of the following: BLTOUCH Classic 1.2, 1.3,  or 
+    // BLTouch Smart 1.0, 2.0, 2.2, 3.0, 3.1. But only if the user has actually
+    // configured a BLTouch as being present. If the user has not configured this,
+    // the BLTouch will be detected in the last phase of these tests (see further on).
+    bool blt = false;
+    // This code will try to detect a BLTouch probe or clone
+    #if ENABLED(BLTOUCH)
+      SERIAL_ECHOLNPGM(". Check for BLTOUCH");
+      bltouch._reset();
+      bltouch._stow();
+      if (probe_inverting == READ(PROBE_TEST_PIN)) {
+        bltouch._set_SW_mode();
+        if (probe_inverting != READ(PROBE_TEST_PIN)) {
+          bltouch._deploy();
+          if (probe_inverting == READ(PROBE_TEST_PIN)) {
+            bltouch._stow();
+            SERIAL_ECHOLNPGM("= BLTouch Classic 1.2, 1.3, Smart 1.0, 2.0, 2.2, 3.0, 3.1 detected.");
+            // Check for a 3.1 by letting the user trigger it, later
+            blt = true;
+        }
       }
-      #if ENABLED(BLTOUCH)
-        SERIAL_ECHOLNPGM("ERROR: BLTOUCH enabled - set this device up as a Z Servo Probe with inverting as true.");
-      #endif
     }
-    else {                                           // measure active signal length
-      MOVE_SERVO(probe_index, servo_angles[Z_PROBE_SERVO_NR][0]); // Deploy
-      safe_delay(500);
-      SERIAL_ECHOLNPGM("please trigger probe");
-      uint16_t probe_counter = 0;
-
-      // Allow 30 seconds max for operator to trigger probe
-      for (uint16_t j = 0; j < 500 * 30 && probe_counter == 0 ; j++) {
-
-        safe_delay(2);
-
-        if (0 == j % (500 * 1)) gcode.reset_stepper_timeout(); // Keep steppers powered
-
-        if (deploy_state != READ(PROBE_TEST_PIN)) { // probe triggered
-
-          for (probe_counter = 1; probe_counter < 50 && deploy_state != READ(PROBE_TEST_PIN); ++probe_counter)
-            safe_delay(2);
-
-          if (probe_counter == 50)
-            SERIAL_ECHOLNPGM("Z Servo Probe detected"); // >= 100mS active time
-          else if (probe_counter >= 2)
-            SERIAL_ECHOLNPAIR("BLTouch compatible probe detected - pulse width (+/- 4mS): ", probe_counter * 2); // allow 4 - 100mS pulse
-          else
-            SERIAL_ECHOLNPGM("noise detected - please re-run test"); // less than 2mS pulse
-
-          MOVE_SERVO(probe_index, servo_angles[Z_PROBE_SERVO_NR][1]); // Stow
+    #endif
 
-        }  // pulse detected
+    // The following code is common to all kinds of servo probes.
+    // Since it could be a real servo or a BLTouch (any kind) or a clone,
+    // use only "common" functions - i.e. SERVO_MOVE. No bltouch.xxxx stuff.
+
+    // If it is already recognised as a being a BLTouch, no need for this test
+    if (!blt) {
+      // DEPLOY and STOW 4 times and see if the signal follows
+      // Then it is a mechanical switch
+      uint8_t i = 0;
+      SERIAL_ECHOLNPGM(". Deploy & stow 4 times");
+      do {
+        MOVE_SERVO(probe_index, servo_angles[Z_PROBE_SERVO_NR][0]); // Deploy
+        safe_delay(500);
+        deploy_state = READ(PROBE_TEST_PIN);
+        MOVE_SERVO(probe_index, servo_angles[Z_PROBE_SERVO_NR][1]); // Stow
+        safe_delay(500);
+        stow_state = READ(PROBE_TEST_PIN);
+      } while (++i < 4);
+
+      if (probe_inverting != deploy_state) SERIAL_ECHOLNPGM("WARNING: INVERTING setting probably backwards.");
+
+      if (deploy_state != stow_state) {
+        SERIAL_ECHOLNPGM("= Mechanical Switch detected");
+        if (deploy_state) {
+          SERIAL_ECHOLNPAIR("  DEPLOYED state: HIGH (logic 1)",
+                            "  STOWED (triggered) state: LOW (logic 0)");
+        }
+        else {
+          SERIAL_ECHOLNPAIR("  DEPLOYED state: LOW (logic 0)",
+                            "  STOWED (triggered) state: HIGH (logic 1)");
+        }
+        #if ENABLED(BLTOUCH)
+          SERIAL_ECHOLNPGM("FAIL: BLTOUCH enabled - Set up this device as a Servo Probe with INVERTING set to 'true'.");
+        #endif
+        return;
+      }
+    }
 
-      } // for loop waiting for trigger
+    // Ask the user for a trigger event and measure the pulse width.
+    MOVE_SERVO(probe_index, servo_angles[Z_PROBE_SERVO_NR][0]); // Deploy
+    safe_delay(500);
+    SERIAL_ECHOLNPGM("** Please trigger probe within 30 sec **");
+    uint16_t probe_counter = 0;
+
+    // Wait 30 seconds for user to trigger probe
+    for (uint16_t j = 0; j < 500 * 30 && probe_counter == 0 ; j++) {
+      safe_delay(2);
+
+      if (0 == j % (500 * 1)) gcode.reset_stepper_timeout();    // Keep steppers powered
+
+      if (deploy_state != READ(PROBE_TEST_PIN)) {               // probe triggered
+        for (probe_counter = 0; probe_counter < 15 && deploy_state != READ(PROBE_TEST_PIN); ++probe_counter) safe_delay(2);
+
+        if (probe_counter = 15)
+          SERIAL_ECHOLNPGM(". Pulse width: 30ms or more");
+        else 
+          SERIAL_ECHOLNPAIR(". Pulse width (+/- 4ms): ", probe_counter * 2);
+          
+        if (probe_counter >= 4) {
+          if (probe_counter == 15) {
+            if (blt) SERIAL_ECHOPGM("= BLTouch V3.1");
+            else     SERIAL_ECHOPGM("= Z Servo Probe");
+          }
+          else SERIAL_ECHOPGM("= BLTouch pre V3.1 or compatible probe");
+          SERIAL_ECHOLNPGM(" detected.");
+        }
+        else SERIAL_ECHOLNPGM("FAIL: Noise detected - please re-run test");
 
-      if (probe_counter == 0) SERIAL_ECHOLNPGM("trigger not detected");
+        MOVE_SERVO(probe_index, servo_angles[Z_PROBE_SERVO_NR][1]); // Stow
+        return;
+      }
+    }
 
-    } // measure active signal length
+    if (!probe_counter) SERIAL_ECHOLNPGM("FAIL: Trigger not detected");
 
-  #endif
+  #endif // HAS_Z_SERVO_PROBE
 
 } // servo_probe_test
 
  */
 void GcodeSuite::M43() {
 
-  if (parser.seen('T')) {   // must be first or else its "S" and "E" parameters will execute endstop or servo test
-    toggle_pins();
-    return;
-  }
+  // 'T' must be first. It uses 'S' and 'E' differently.
+  if (parser.seen('T')) return toggle_pins();
 
-  // Enable or disable endstop monitoring
+  // 'E' Enable or disable endstop monitoring and return
   if (parser.seen('E')) {
     endstops.monitor_flag = parser.value_bool();
     SERIAL_ECHOPGM("endstop monitor ");
     return;
   }
 
-  if (parser.seen('S')) {
-    servo_probe_test();
-    return;
-  }
+  // 'S' Run servo probe test and return
+  if (parser.seen('S')) return servo_probe_test();
 
-  // Get the range of pins to test or watch
+  // 'P' Get the range of pins to test or watch
   uint8_t first_pin = PARSED_PIN_INDEX('P', 0),
           last_pin = parser.seenval('P') ? first_pin : NUMBER_PINS_TOTAL - 1;
 
   if (first_pin > last_pin) return;
 
+  // 'I' to ignore protected pins
   const bool ignore_protection = parser.boolval('I');
 
-  // Watch until click, M108, or reset
+  // 'W' Watch until click, M108, or reset
   if (parser.boolval('W')) {
     SERIAL_ECHOLNPGM("Watching pins");
-
     #ifdef ARDUINO_ARCH_SAM
-      NOLESS(first_pin, 2);  // don't hijack the UART pins
+      NOLESS(first_pin, 2); // Don't hijack the UART pins
     #endif
     uint8_t pin_state[last_pin - first_pin + 1];
     for (uint8_t i = first_pin; i <= last_pin; i++) {
       if (M43_NEVER_TOUCH(i) || (!ignore_protection && pin_is_protected(pin))) continue;
       pinMode(pin, INPUT_PULLUP);
       delay(1);
-      /*
+        /*
         if (IS_ANALOG(pin))
           pin_state[pin - first_pin] = analogRead(DIGITAL_PIN_TO_ANALOG_PIN(pin)); // int16_t pin_state[...]
         else
-      //*/
+        //*/
           pin_state[i - first_pin] = extDigitalRead(pin);
     }
 
         if (M43_NEVER_TOUCH(i) || (!ignore_protection && pin_is_protected(pin))) continue;
         const byte val =
           /*
-            IS_ANALOG(pin)
-              ? analogRead(DIGITAL_PIN_TO_ANALOG_PIN(pin)) : // int16_t val
-              :
+          IS_ANALOG(pin)
+            ? analogRead(DIGITAL_PIN_TO_ANALOG_PIN(pin)) : // int16_t val
+            :
           //*/
             extDigitalRead(pin);
         if (val != pin_state[i - first_pin]) {
       }
 
       #if HAS_RESUME_CONTINUE
-        if (!wait_for_user) {
-          KEEPALIVE_STATE(IN_HANDLER);
-          break;
-        }
+        if (!wait_for_user) { KEEPALIVE_STATE(IN_HANDLER); break; }
       #endif
 
       safe_delay(200);
     }
-    return;
   }
-
-  // Report current state of selected pin(s)
-  for (uint8_t i = first_pin; i <= last_pin; i++) {
-    pin_t pin = GET_PIN_MAP_PIN(i);
-    if (VALID_PIN(pin)) report_pin_state_extended(pin, ignore_protection, true);
+  else {
+    // Report current state of selected pin(s)
+    for (uint8_t i = first_pin; i <= last_pin; i++) {
+      pin_t pin = GET_PIN_MAP_PIN(i);
+      if (VALID_PIN(pin)) report_pin_state_extended(pin, ignore_protection, true);
+    }
   }
 }
 

Marlin/src/lcd/language/language_en.h

 #ifndef MSG_BLTOUCH_OD_MODE
   #define MSG_BLTOUCH_OD_MODE                 _UxGT("BLTouch OD Mode")
 #endif
+#ifndef MSG_BLTOUCH_MODE_STORE
+  #define MSG_BLTOUCH_MODE_STORE              _UxGT("BLTouch Mode Store")
+#endif
 #ifndef MSG_BLTOUCH_STOW
   #define MSG_BLTOUCH_STOW                    _UxGT("Stow BLTouch")
 #endif

Marlin/src/lcd/menu/menu_configuration.cpp

     MENU_ITEM(function, MSG_BLTOUCH_SW_MODE, bltouch._set_SW_mode);
     MENU_ITEM(function, MSG_BLTOUCH_5V_MODE, bltouch._set_5V_mode);
     MENU_ITEM(function, MSG_BLTOUCH_OD_MODE, bltouch._set_OD_mode);
+    MENU_ITEM(function, MSG_BLTOUCH_MODE_STORE, bltouch._mode_store);
     END_MENU();
   }
 

Marlin/src/module/endstops.cpp

     #endif
   #endif
   #if ENABLED(BLTOUCH)
-    bltouch._reset();
-    if (enabled_globally) bltouch._stow();
+    bltouch._reset_SW_mode();
   #endif
 } // Endstops::M119
 

Marlin/src/module/motion.cpp

   if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("Home 1 Fast:");
 
   #if HOMING_Z_WITH_PROBE && ENABLED(BLTOUCH)
-    // BLTOUCH needs to be deployed every time
-    if (axis == Z_AXIS && bltouch.deploy()) return;
+    if (axis == Z_AXIS && bltouch.deploy()) return; // The initial DEPLOY
   #endif
 
   do_homing_move(axis, 1.5f * max_length(
     ) * axis_home_dir
   );
 
-  #if HOMING_Z_WITH_PROBE && ENABLED(BLTOUCH)
-    // BLTOUCH needs to be stowed after trigger to rearm itself
-    if (axis == Z_AXIS) bltouch.stow();
+  #if HOMING_Z_WITH_PROBE && ENABLED(BLTOUCH) && DISABLED(BLTOUCH_HS_MODE)
+    if (axis == Z_AXIS) bltouch.stow(); // Intermediate STOW (in LOW SPEED MODE)
   #endif
 
   // When homing Z with probe respect probe clearance
     // Slow move towards endstop until triggered
     if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("Home 2 Slow:");
 
-    #if HOMING_Z_WITH_PROBE && ENABLED(BLTOUCH)
-      // BLTOUCH needs to be deployed every time
-      if (axis == Z_AXIS && bltouch.deploy()) return;
+    #if HOMING_Z_WITH_PROBE && ENABLED(BLTOUCH) && DISABLED(BLTOUCH_HS_MODE)
+      if (axis == Z_AXIS && bltouch.deploy()) return; // Intermediate DEPLOY (in LOW SPEED MODE)
     #endif
 
     do_homing_move(axis, 2 * bump, get_homing_bump_feedrate(axis));
 
     #if HOMING_Z_WITH_PROBE && ENABLED(BLTOUCH)
-      // BLTOUCH needs to be stowed after trigger to rearm itself
-      if (axis == Z_AXIS) bltouch.stow();
+      if (axis == Z_AXIS) bltouch.stow(); // The final STOW
     #endif
   }
 

Marlin/src/module/probe.cpp

 
     dock_sled(!deploy);
 
-  #elif HAS_Z_SERVO_PROBE && DISABLED(BLTOUCH)
-
-    MOVE_SERVO(Z_PROBE_SERVO_NR, servo_angles[Z_PROBE_SERVO_NR][deploy ? 0 : 1]);
+  #elif HAS_Z_SERVO_PROBE
+
+    #if DISABLED(BLTOUCH)
+      MOVE_SERVO(Z_PROBE_SERVO_NR, servo_angles[Z_PROBE_SERVO_NR][deploy ? 0 : 1]);
+    #elif ENABLED(BLTOUCH_HS_MODE)
+      // In HIGH SPEED MODE, use the normal retractable probe logic in this code
+      // i.e. no intermediate STOWs and DEPLOYs in between individual probe actions
+      if (deploy) bltouch.deploy(); else bltouch.stow();
+    #endif
 
   #elif ENABLED(Z_PROBE_ALLEN_KEY)
 
     }
   #endif
 
-  // Deploy BLTouch at the start of any probe
-  #if ENABLED(BLTOUCH)
-    if (bltouch.deploy()) return true;
+  #if ENABLED(BLTOUCH) && DISABLED(BLTOUCH_HS_MODE)
+    if (bltouch.deploy()) return true; // DEPLOY in LOW SPEED MODE on every probe action
   #endif
 
   // Disable stealthChop if used. Enable diag1 pin on driver.
     tmc_disable_stallguard(stepperZ, stealth_states.z);
   #endif
 
-  // Retract BLTouch immediately after a probe if it was triggered
-  #if ENABLED(BLTOUCH)
-    if (probe_triggered && bltouch.stow()) return true;
+  #if ENABLED(BLTOUCH) && DISABLED(BLTOUCH_HS_MODE)
+    if (probe_triggered && bltouch.stow()) return true; // STOW in LOW SPEED MODE on trigger on every probe action
   #endif
 
   // Clear endstop flags

config/examples/Anet/E16/_Statusscreen.h

   B11110000,B00000000,B00001111,
   B11111100,B00000000,B00111111,
   B11111110,B01101100,B01111111,
-  B11111111,B11111111,B11111111 
+  B11111111,B11111111,B11111111
 };
 
 //