Add a bed check: warn about bumps and flatness, pause PRINT_START on a failure

BED_SCAN_CHECK levels, scans and warns, without heating or touching the bed.
extras/mesh_check.py fits a smooth surface to the mesh and reports areas more
than 0.03 mm from it, and a range over 0.30 mm.

In PRINT_START a failed check pauses before the nozzle heats. Resume sets the
print file back to the PRINT_START line (M26), so it runs again as normal file
G-code. BED_CHECK_IGNORE lets the next failed check only warn.

Tested on saved scans and rendered macros only, not yet on the printer.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
mangavalkandClaude Opus 5.5 committed 2026-11-06 16:16:36 +01:00
1 parent e540e40cf7
commit 99b7109b5b
7 files changed
+358 -5

No files matched your search

+159
View File
@@ -0,0 +1,159 @@
# Checks the loaded bed mesh for bumps, dips and too much height range.
#
# The bed is naturally bowl-shaped, so a height range alone cannot tell dirt
# from normal shape. This fits a smooth surface (polynomial, degree 4) to the
# probed points, leaving out outliers, and looks at how far each point is from
# it. Measured on this printer's Beacon scans (33x35 points):
# clean plate, cold or hot: worst deviation 0.016 mm
# residue on the plate, 2026-11: 0.07 (bed 60C), 0.09 (bed 100C, at the old
# mesh edge), 0.30 mm (cold, mesh over it)
# Only reads the mesh: it moves nothing and changes nothing.
#
# Install: copy to ~/klipper/klippy/extras/mesh_check.py (install.sh links it)
# and add
#
# [mesh_check]
# bump_limit: 0.03 # mm from the smooth surface that counts as a bump or dip
# range_limit: 0.30 # mm between the highest and lowest point
#
# Commands:
# BED_MESH_CHECK [BUMP=<mm>] [RANGE=<mm>]
#
# Status (printer.mesh_check): result ('ok', 'fail', 'none' = no mesh or the
# check failed, 'not run'), range, worst, areas (number of bumps and dips),
# summary (no double quotes, usable in a macro's MSG="...")
import logging
import numpy as np
DEGREE = 4
MAX_AREAS = 5 # areas named in the report, biggest deviation first
MIN_POINTS = 40 # fewer points cannot carry a degree 4 surface reliably
def surface_residuals(z):
# Deviation of each point from a smooth surface. Refit without the points
# far from it, so a bump does not pull the surface towards itself.
ny, nx = z.shape
x, y = np.meshgrid(np.linspace(-1., 1., nx), np.linspace(-1., 1., ny))
terms = [x.ravel()**i * y.ravel()**j
for i in range(DEGREE + 1) for j in range(DEGREE + 1 - i)]
a = np.column_stack(terms)
values = z.ravel()
keep = np.ones(values.size, dtype=bool)
residuals = np.zeros(values.size)
for _ in range(5):
coeffs = np.linalg.lstsq(a[keep], values[keep], rcond=None)[0]
residuals = values - a.dot(coeffs)
spread = 1.4826 * np.median(
np.abs(residuals[keep] - np.median(residuals[keep])))
keep = np.abs(residuals) < max(3. * spread, 0.01)
return residuals.reshape(z.shape)
def find_areas(residuals, limit):
# Groups of touching points (diagonals too) beyond the limit, as
# (peak, row min, row max, column min, column max)
ny, nx = residuals.shape
over = np.abs(residuals) > limit
seen = np.zeros(over.shape, dtype=bool)
areas = []
for start in zip(*np.nonzero(over)):
if seen[start]:
continue
seen[start] = True
stack = [start]
points = []
while stack:
j, i = stack.pop()
points.append((j, i))
for dj in (-1, 0, 1):
for di in (-1, 0, 1):
nj, ni = j + dj, i + di
if (0 <= nj < ny and 0 <= ni < nx and over[nj, ni]
and not seen[nj, ni]):
seen[nj, ni] = True
stack.append((nj, ni))
peak = max((residuals[p] for p in points), key=abs)
rows = [p[0] for p in points]
cols = [p[1] for p in points]
areas.append((float(peak), min(rows), max(rows), min(cols), max(cols)))
areas.sort(key=lambda area: -abs(area[0]))
return areas
def analyse(matrix, mesh_min, mesh_max, bump_limit, range_limit):
# Returns the status dictionary. No Klipper objects, so it can be tested
# against saved scans.
z = np.array(matrix, dtype=float)
if z.ndim != 2 or z.size == 0:
return {'result': 'none', 'range': 0., 'worst': 0., 'areas': 0,
'summary': 'no bed mesh loaded'}
height_range = float(z.max() - z.min())
ny, nx = z.shape
if z.size < MIN_POINTS:
return {'result': 'none', 'range': height_range, 'worst': 0.,
'areas': 0,
'summary': 'mesh too small to check (%d points)' % (z.size,)}
residuals = surface_residuals(z)
worst = float(np.abs(residuals).max())
areas = find_areas(residuals, bump_limit)
step_x = (mesh_max[0] - mesh_min[0]) / float(nx - 1)
step_y = (mesh_max[1] - mesh_min[1]) / float(ny - 1)
problems = []
for peak, row0, row1, col0, col1 in areas[:MAX_AREAS]:
problems.append("%s %+.2f mm at X%.0f-%.0f Y%.0f-%.0f" % (
"bump" if peak > 0. else "dip", peak,
mesh_min[0] + col0 * step_x, mesh_min[0] + col1 * step_x,
mesh_min[1] + row0 * step_y, mesh_min[1] + row1 * step_y))
if len(areas) > MAX_AREAS:
problems.append("%d more" % (len(areas) - MAX_AREAS,))
too_wide = height_range > range_limit
if too_wide:
problems.append("range %.2f mm is over the limit of %.2f" % (
height_range, range_limit))
text = "range %.3f mm, worst deviation %.3f mm" % (height_range, worst)
if problems:
text = "%s: %s" % (text, ", ".join(problems))
return {'result': 'fail' if problems else 'ok', 'range': height_range,
'worst': worst, 'areas': len(areas), 'summary': text}
class MeshCheck:
def __init__(self, config):
self.printer = config.get_printer()
self.reactor = self.printer.get_reactor()
self.bump_limit = config.getfloat('bump_limit', 0.03, above=0.)
self.range_limit = config.getfloat('range_limit', 0.30, above=0.)
self.status = {'result': 'not run', 'range': 0., 'worst': 0.,
'areas': 0, 'summary': ''}
gcode = self.printer.lookup_object('gcode')
gcode.register_command('BED_MESH_CHECK', self.cmd_BED_MESH_CHECK,
desc="Check the loaded bed mesh for bumps, "
"dips and too much height range")
def cmd_BED_MESH_CHECK(self, gcmd):
bump = gcmd.get_float('BUMP', self.bump_limit, above=0.)
height_range = gcmd.get_float('RANGE', self.range_limit, above=0.)
# A failing analysis must not stop a print: it reports and goes on
try:
bed_mesh = self.printer.lookup_object('bed_mesh')
mesh = bed_mesh.get_status(self.reactor.monotonic())
self.status = analyse(mesh['probed_matrix'], mesh['mesh_min'],
mesh['mesh_max'], bump, height_range)
except Exception:
logging.exception("mesh_check: analysis failed")
self.status = {'result': 'none', 'range': 0., 'worst': 0.,
'areas': 0,
'summary': 'check failed, see klippy.log'}
msg = "Bed mesh check: %s" % (self.status['summary'],)
logging.info("mesh_check: %s (%s)", msg, self.status['result'])
gcmd.respond_info(msg)
def get_status(self, eventtime):
return dict(self.status)
def load_config(config):
return MeshCheck(config)