[BUG] Multiple probing >2 produces incorrect mesh (ProUI probe.cpp bug)

[stratos1st]

Did you test the latest release build?

Yes, and the problem still exists.

Bug Description

When multiple_probing >= 3, mesh values become incorrect (nozzle prints too high).
multiple_probing = 1–2 works correctly.
multiple_probing = 3–4 produces increasingly wrong results.

What i think is the problem:
The ProUI probe implementation incorrectly reuses the 2-probe weighting formula for N>2 samples, causing invalid mesh values.
A suggested fix is to branch logic for mp >= 3 and use averaging / filtering just like the nonProUI version.
I think the problem is in Marlin/src/module/probe.cpp line 1004

// Return a weighted average of the fast and slow probes
    const float measured_z = (TERN(PROUI_EX, PRO_data, HMI_data).multiple_probing > 1) ?
    (probes_z_sum * 3.0f + z1 * 2.0f) * 0.2f : z1;

I suggest something like this

    // Raise to give the probe clearance
    motion.do_z_clearance(z1 + (Z_CLEARANCE_MULTI_PROBE));

    const uint8_t mp = TERN(PROUI_EX, PRO_data, HMI_data).multiple_probing;

    float measured_z;

    if (mp <= 1) {

      // Single probing: just use the fast probe result
      measured_z = z1;

    }
    else if (mp == 2) {

      // One additional slow probe
      if (TERN0(PROBE_TARE, tare())) return NAN;

      if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("Slow Probe:");
      if (try_to_probe(PSTR("SLOW"), z_probe_low_point, motion.z_probe_slow_mm_s, sanity_check)) return NAN;

      TERN_(MEASURE_BACKLASH_WHEN_PROBING, backlash.measure_with_probe());

      const float z2 = DIFF_TERN(HAS_DELTA_SENSORLESS_PROBING, motion.position.z, largest_sensorless_adj);

      if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("2nd Probe Z:", z2, " Discrepancy:", z1 - z2);

      // Keep the legacy fast/slow weighted average for 2 probes
      measured_z = (z2 * 3.0f + z1 * 2.0f) * 0.2f;

    }
    else {

      // 3+ probes: collect and sort all slow probes, then trim outliers
      float probes_z_sum = 0;
      float probes[10]; // enough for realistic UI-selected multiple probing counts

      const uint8_t slow_count = mp - 1;

      for (uint8_t p = 0; p < slow_count; p++) {
        if (TERN0(PROBE_TARE, tare())) return NAN;

        if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("Slow Probe:");
        if (try_to_probe(PSTR("SLOW"), z_probe_low_point, motion.z_probe_slow_mm_s, sanity_check)) return NAN;

        TERN_(MEASURE_BACKLASH_WHEN_PROBING, backlash.measure_with_probe());

        const float z = DIFF_TERN(HAS_DELTA_SENSORLESS_PROBING, motion.position.z, largest_sensorless_adj);

        // Insert into probes[] in ascending order
        uint8_t i = 0;
        for (; i < p; ++i)
          if (probes[i] > z) break;

        for (int8_t m = p; m > (int8_t)i; --m)
          probes[m] = probes[m - 1];

        probes[i] = z;

        // Small Z raise after all but the last slow probe
        if (p < slow_count - 1)
          motion.do_z_clearance(z + (Z_CLEARANCE_MULTI_PROBE));
      }

      // Use the median of the slow probes to decide which values are outliers
      const uint8_t n = slow_count;
      const uint8_t half = (n - 1) / 2;
      const float middle = probes[half];
      const float median = (n & 1) ? middle : (middle + probes[half + 1]) * 0.5f;

      // Trim one outlier (the value farthest from the median) when possible
      uint8_t min_avg_idx = 0, max_avg_idx = n - 1;
      if (n > 2) {
        if (ABS(probes[max_avg_idx] - median) > ABS(probes[min_avg_idx] - median))
          max_avg_idx--;
        else
          min_avg_idx++;
      }

      for (uint8_t i = min_avg_idx; i <= max_avg_idx; ++i)
        probes_z_sum += probes[i];

      const uint8_t kept = max_avg_idx - min_avg_idx + 1;

      // Blend the fast probe with the filtered slow-probe average
      const float slow_avg = probes_z_sum / kept;
      measured_z = (slow_avg * 3.0f + z1 * 2.0f) * 0.2f;

    }

The only major issue with this is float probes[10];, currently the UI allows to set multiple_probing up to 4 so that will probably work for a while but i guess its bad practice to leave this value hard coded, thats why i didnt do a pull request with the suggested fix.

Firmware File

Aquila_N32_UBL-ProUI-EX-MPC-03-15.bin

Printer Model

Voxelab Aquila

Model Type

OG

Your Mainboard or Chipset

Aquila N32

Other Mainboard Type

No response

Add-ons that could be involved

BL

ProUI-EX | Extra Features?

Yes

Bed Leveling

UBL - Unified Bed Leveling

Did you include your own configuration files?

• A ZIP file containing your Configuration.h and Configuration_adv.h.

Additional information & file uploads

No response

[classicrocker883]

well thank you for everything. i will work on testing and seeing how it all goes

[classicrocker883]

here is the updated code I am considering using, if you'd like to test it out and let me know

replace line ~932

#else // if DWIN_LCD_PROUI

  float Probe::run_z_probes(const bool sanity_check/*=true*/, const float z_min_point/*=Z_PROBE_LOW_POINT*/, const float z_clearance/*=Z_TWEEN_SAFE_CLEARANCE*/) {
    DEBUG_SECTION(log_probe, "Probe::run_z_probe", DEBUGGING(LEVELING));

    const float zoffs = SUM_TERN(HAS_HOTEND_OFFSET, -offset.z, motion.active_hotend_offset().z);

    auto try_to_probe = [&](PGM_P const plbl, const float z_probe_low_point, const feedRate_t fr_mm_s, const bool scheck) -> bool {
      constexpr float error_tolerance = Z_PROBE_ERROR_TOLERANCE;
      if (DEBUGGING(LEVELING)) {
        DEBUG_ECHOPGM_P(plbl);
        DEBUG_ECHOLNPGM("> try_to_probe(..., ", z_probe_low_point, ", ", fr_mm_s, ", ...)");
      }

      // Do a first probe at the fast speed
      const bool probe_fail = probe_down_to_z(z_probe_low_point, fr_mm_s),              // No probe trigger?
                 early_fail = (scheck && motion.position.z > zoffs + error_tolerance); // Probe triggered too high?
      #if ENABLED(DEBUG_LEVELING_FEATURE)
        if (DEBUGGING(LEVELING) && (probe_fail || early_fail)) {
          DEBUG_ECHOPGM(" Probe fail! - ");
          if (probe_fail) DEBUG_ECHOLNPGM("No trigger.");
          if (early_fail) DEBUG_ECHOLNPGM("Triggered early (above ", zoffs + error_tolerance, "mm)");
        }
      #else
        UNUSED(plbl);
      #endif
      return probe_fail || early_fail;
    };

    // Stop the probe before it goes too low to prevent damage.
    // For known Z probe below the expected trigger point, otherwise -10mm lower.
    const float z_probe_low_point = zoffs + z_min_point - float((!motion.axis_is_trusted(Z_AXIS)) * 10);
    if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("Probe Low Point: ", z_probe_low_point);

    // Double-probing does a fast probe followed by a slow probe

    // Attempt to tare the probe
    if (TERN0(PROBE_TARE, tare())) return NAN;

    // Do a first probe at the fast speed
    if (try_to_probe(PSTR("FAST"), z_probe_low_point, motion.z_probe_fast_mm_s, sanity_check)) return NAN;

    const float z1 = DIFF_TERN(HAS_DELTA_SENSORLESS_PROBING, motion.position.z, largest_sensorless_adj);
    if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("1st Probe Z:", z1);

    // Raise to give the probe clearance
    motion.do_z_clearance(z1 + (Z_CLEARANCE_MULTI_PROBE));

    const uint8_t mp = TERN(PROUI_EX, PRO_data, HMI_data).multiple_probing;

    // Return a weighted average of the fast and slow probes
    float measured_z;

    if (mp == 1) {
      // Use single probe result
      measured_z = z1;
    }
    else if (mp == 2) {
      // If the probe won't tare, return
      if (TERN0(PROBE_TARE, tare())) return NAN;

      // Probe downward slowly to find the bed
      if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("Slow Probe:");
      if (try_to_probe(PSTR("SLOW"), z_probe_low_point, motion.z_probe_slow_mm_s, sanity_check)) return NAN;

      TERN_(MEASURE_BACKLASH_WHEN_PROBING, backlash.measure_with_probe());

      const float z2 = DIFF_TERN(HAS_DELTA_SENSORLESS_PROBING, motion.position.z, largest_sensorless_adj);

      if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("2nd Probe Z:", z2, " Discrepancy:", z1 - z2);

      // Keep the legacy fast/slow weighted average for 2 probes
      measured_z = (z2 * 3.0f + z1 * 2.0f) * 0.2f;
    }
    else {
      // 3+ probes: Collect and sort all slow probes, then trim outliers
      float probes_z_sum = 0;
      float probes[10]; // UI-selected multiple probing counts

      const uint8_t slow_count = mp - 1;

      for (uint8_t p = 0; p < slow_count; p++) {
        if (TERN0(PROBE_TARE, tare())) return NAN;

        // Probe downward slowly to find the bed
        if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("Slow Probe:");
        if (try_to_probe(PSTR("SLOW"), z_probe_low_point, motion.z_probe_slow_mm_s, sanity_check)) return NAN;

        TERN_(MEASURE_BACKLASH_WHEN_PROBING, backlash.measure_with_probe());

        const float z = DIFF_TERN(HAS_DELTA_SENSORLESS_PROBING, motion.position.z, largest_sensorless_adj);

        for (uint8_t i = 0; i <= p; ++i) {                            // Iterate the saved Zs to insert the new Z
          if (i == p || probes[i] > z) {                              // Last index or new Z is smaller than this Z
            for (int8_t m = p; --m >= i;) probes[m + 1] = probes[m];  // Shift items down after the insertion point
            probes[i] = z;                                            // Insert the new Z measurement
            break;                                                    // Only one to insert. Done!
          }
        }

        // Small Z raise after all but the last slow probe
        if (p < slow_count - 1)
          motion.do_z_clearance(z + (Z_CLEARANCE_MULTI_PROBE));
      }

      // Take the center value (or average the two middle values) as the median
      const uint8_t half = (slow_count - 1) / 2;
      const float median = (slow_count & 1) ? probes[half] : (probes[half] + probes[half + 1]) * 0.5f;

      uint8_t min_avg_idx = 0, max_avg_idx = slow_count - 1;

      // Remove values farthest from the median
      if (slow_count >= 5) {
        min_avg_idx++;
        max_avg_idx--;
      }
      else if (slow_count > 2) {
        if (ABS(probes[max_avg_idx] - median) > ABS(probes[min_avg_idx] - median))
          max_avg_idx--;
        else
          min_avg_idx++;
      }

      // Return the average value of all remaining probes.
      for (uint8_t i = min_avg_idx; i <= max_avg_idx; ++i)
        probes_z_sum += probes[i];

      const uint8_t kept = (max_avg_idx - min_avg_idx) + 1;

      // Blend the fast probe with the filtered slow-probe average
      const float slow_avg = probes_z_sum / kept;
      measured_z = (slow_avg * 3.0f + z1 * 2.0f) * 0.2f;
    }

    return DIFF_TERN(HAS_HOTEND_OFFSET, measured_z, motion.active_hotend_offset().z);
  }