TWIST_CALIBRATE: axis twist calibration from Mainsail
scripts/twist_check.py runs on the Pi and measures or verifies the nozzle vs Beacon offset; windows explain each step, show progress and give a verdict, with an HTML report in config/twist_data/. It refuses to start during a print, stops on unexpected readings and never changes printer.cfg. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
2c1fd27dc6
commit
92d86d6bfd
6 files changed
+852
-2
No files matched your search
@@ -1,3 +1,9 @@
|
||||
# Scripts
|
||||
|
||||
`twist_check.py` is the axis twist calibration: start it with the macro
|
||||
`TWIST_CALIBRATE` in Mainsail, or see the top of the file for the shell
|
||||
commands. The rest of this page is about the firmware scripts.
|
||||
|
||||
# MCU firmware update scripts
|
||||
|
||||
| Script | Does |
|
||||
|
||||
@@ -0,0 +1,719 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Nozzle vs Beacon offset across the bed (axis twist compensation).
|
||||
|
||||
Beacon sits 20 mm behind the nozzle (y_offset 20). If the toolhead rolls as
|
||||
it moves (X rail twist), Beacon's proximity reading and the nozzle disagree
|
||||
by an amount that depends on X (and a little on Y). Beacon meshes and QGL
|
||||
inherit that error; Klipper's [axis_twist_compensation] corrects it.
|
||||
|
||||
Normally started from Mainsail with the macro TWIST_CALIBRATE, which explains
|
||||
each step (macros/calibration/twist_check.cfg). From a shell on the Pi:
|
||||
|
||||
python3 ~/klipper-macros/scripts/twist_check.py measure
|
||||
python3 ~/klipper-macros/scripts/twist_check.py verify
|
||||
python3 ~/klipper-macros/scripts/twist_check.py analyse <file.jsonl>
|
||||
|
||||
Modes:
|
||||
measure ~25 min. Proximity (nozzle at x, y-20, so Beacon sees bed x,y), then
|
||||
Beacon contact with the nozzle moved onto x,y. Rows y 55/175/295
|
||||
and a Y line at x=175. Works with or without compensation active:
|
||||
Beacon adds the same correction to proximity and contact, so
|
||||
contact - proximity is the raw error. New values replace the old
|
||||
ones. Result: apply, leave it, or re-run. It never changes
|
||||
printer.cfg; a ready block is saved in twist_suggested.cfg.
|
||||
verify ~17 min. Proximity (compensated), then BDP_TOUCH at x,y (bd_pressure,
|
||||
Z from the stepper, not compensated), then Beacon contact. Rows
|
||||
y 175/295. With good compensation, bdp - proximity is flat along X.
|
||||
|
||||
Both: BED_MESH_CLEAR (the active mesh only; saved profiles stay), nozzle 150C,
|
||||
HOME, QGL, contact Z, 2 passes (second in reverse order to cancel slow drift),
|
||||
then Z10 and nozzle off. The bed heater is not touched.
|
||||
|
||||
Safety: refuses to start when Klipper is not ready, a print runs or another
|
||||
run is active. Travel moves run under the nozzle guard. Every reading is
|
||||
checked before the nozzle goes low, and anything unexpected stops the run. A
|
||||
stop (TWIST_STOP, Ctrl-C, an error) lifts the nozzle and switches its heater
|
||||
off, except when a print has started: then it leaves the printer alone.
|
||||
|
||||
Writes twist_<mode>_<date>.jsonl and .html (report with charts) in
|
||||
~/printer_data/config/twist_data/, plus twist_run.log with all messages.
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import datetime
|
||||
import html
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import signal
|
||||
import statistics as st
|
||||
import sys
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.parse
|
||||
import urllib.request
|
||||
|
||||
XS = [25, 75, 125, 175, 225, 275, 325]
|
||||
YS = [55, 95, 135, 175, 215, 255, 295]
|
||||
PASSES = 2
|
||||
TRIGGER = 2.0 # [beacon] trigger_distance: proximity result - 2 = bed
|
||||
BDP_ABOVE = 0.15 # BDP_TOUCH start height above the expected bed
|
||||
|
||||
# Result checks (mm)
|
||||
# Set so the good 2026-11-02 runs pass: rows 0.012, residual 0.012, one point
|
||||
# with pass spread 0.031 (the next 0.012, median 0.004), verify flat 0.022.
|
||||
ROWS_AGREE = 0.015 # each X row vs the mean: else X and Y are not separable
|
||||
RESIDUAL = 0.015 # worst error left by the X+Y model
|
||||
PASS_SPREAD = 0.02 # same point in the two passes: dirty nozzle or bed when
|
||||
PASS_OUTLIERS = 1 # more points than this are above it,
|
||||
PASS_WORST = 0.04 # or any point above this
|
||||
MIN_CHANGE = 0.01 # smaller differences to the active values: leave it
|
||||
MAX_COMP = 0.3 # larger: something is mechanically wrong, do not correct
|
||||
FLAT_GOOD = 0.025 # verify: bdp - proximity range along one row
|
||||
FLAT_MAX = 0.035
|
||||
|
||||
# Reading checks during the run (mm); outside these the run stops
|
||||
PROX_LIMIT = 0.5 # bed height from Beacon vs Z 0: something on the bed?
|
||||
CONTACT_LIMIT = 0.25 # nozzle contact vs Beacon: blob on the nozzle?
|
||||
BED_WARN = 40 # C: all reference runs were on a cold bed
|
||||
|
||||
DATA_DIR = os.path.expanduser("~/printer_data/config/twist_data")
|
||||
LOG = None
|
||||
|
||||
|
||||
class Problem(Exception):
|
||||
"""Something the user has to look at; the run stops."""
|
||||
|
||||
|
||||
class Stopped(Exception):
|
||||
"""TWIST_STOP or Ctrl-C."""
|
||||
|
||||
|
||||
def log(text):
|
||||
line = "%s %s" % (time.strftime("%H:%M:%S"), text)
|
||||
print(line, flush=True)
|
||||
if LOG:
|
||||
LOG.write(line + "\n")
|
||||
LOG.flush()
|
||||
|
||||
|
||||
def clean(text):
|
||||
# Double quotes end a G-code parameter and ; starts a comment
|
||||
return str(text).replace('"', "'").replace(";", ",")
|
||||
|
||||
|
||||
class Printer:
|
||||
def __init__(self, host):
|
||||
self.host = host
|
||||
|
||||
def get(self, path, timeout=10):
|
||||
try:
|
||||
with urllib.request.urlopen(self.host + path,
|
||||
timeout=timeout) as r:
|
||||
return json.load(r)["result"]
|
||||
except (OSError, ValueError, KeyError) as e:
|
||||
raise Problem("No answer from Moonraker at %s (%s)"
|
||||
% (self.host, e))
|
||||
|
||||
def query(self, *objects):
|
||||
path = "/printer/objects/query?" + "&".join(
|
||||
urllib.parse.quote(o) for o in objects)
|
||||
return self.get(path)["status"]
|
||||
|
||||
def gcode(self, script, timeout=900):
|
||||
t0 = time.time()
|
||||
url = (self.host + "/printer/gcode/script?script="
|
||||
+ urllib.parse.quote(script))
|
||||
req = urllib.request.Request(url, method="POST")
|
||||
try:
|
||||
urllib.request.urlopen(req, timeout=timeout).read()
|
||||
except urllib.error.HTTPError as e:
|
||||
raise Problem(self.error_text(e, script))
|
||||
except OSError as e:
|
||||
raise Problem("Lost the connection during %s (%s)" % (script, e))
|
||||
store = self.get("/server/gcode_store?count=40")["gcode_store"]
|
||||
return [e["message"] for e in store
|
||||
if e["time"] >= t0 - 1 and e["type"] == "response"]
|
||||
|
||||
def error_text(self, e, script):
|
||||
try:
|
||||
text = json.load(e)["error"]["message"]
|
||||
except (ValueError, KeyError, TypeError):
|
||||
text = "HTTP %d" % e.code
|
||||
return "%s failed: %s" % (script.split()[0], text)
|
||||
|
||||
def say(self, text):
|
||||
log(text)
|
||||
self.gcode('RESPOND MSG="Twist: %s"' % clean(text), timeout=60)
|
||||
|
||||
def dialog(self, title, lines, buttons=()):
|
||||
# Mainsail shows this as a window (needs [respond])
|
||||
out = ["action:prompt_begin " + title]
|
||||
out += ["action:prompt_text " + line for line in lines]
|
||||
out += ["action:prompt_button %s|%s|%s" % b for b in buttons]
|
||||
out += ["action:prompt_footer_button Close|_TWIST_CLOSE|secondary",
|
||||
"action:prompt_show"]
|
||||
self.gcode("\n".join('RESPOND TYPE=command MSG="%s"' % clean(m)
|
||||
for m in out), timeout=60)
|
||||
|
||||
def state(self, running, mode=None, done=None, total=None):
|
||||
cmd = "SET_GCODE_VARIABLE MACRO=_TWIST_STATE VARIABLE=%s VALUE=%s"
|
||||
out = [cmd % ("running", running)]
|
||||
if mode is not None:
|
||||
out.append(cmd % ("mode", "\"'%s'\"" % mode))
|
||||
if done is not None:
|
||||
out.append(cmd % ("done", done))
|
||||
if total is not None:
|
||||
out.append(cmd % ("total", total))
|
||||
return "\n".join(out)
|
||||
|
||||
def logo(self, status):
|
||||
# The Stealthburner logo: visible from across the room
|
||||
objects = self.get("/printer/objects/list")["objects"]
|
||||
if status == "error":
|
||||
if "gcode_macro _STATUS_FLASH" in objects:
|
||||
return "_STATUS_FLASH STATE=error"
|
||||
elif "gcode_macro _STATUS" in objects:
|
||||
return "_STATUS STATE=" + status
|
||||
return ""
|
||||
|
||||
|
||||
def num(lines, pattern, what):
|
||||
for line in reversed(lines):
|
||||
m = re.search(pattern, line)
|
||||
if m:
|
||||
return float(m.group(1))
|
||||
raise Problem("%s gave no reading (expected %s in the answer)"
|
||||
% (what, pattern))
|
||||
|
||||
|
||||
def print_active(p):
|
||||
s = p.query("print_stats", "pause_resume", "virtual_sdcard")
|
||||
return (s["print_stats"]["state"] in ("printing", "paused")
|
||||
or s["pause_resume"]["is_paused"]
|
||||
or s["virtual_sdcard"]["is_active"])
|
||||
|
||||
|
||||
def check_ready(p):
|
||||
info = p.get("/printer/info")
|
||||
if info["state"] != "ready":
|
||||
raise Problem("Klipper is not ready (%s): %s"
|
||||
% (info["state"], info.get("state_message", "").strip()))
|
||||
|
||||
|
||||
def preflight(p, mode):
|
||||
check_ready(p)
|
||||
if print_active(p):
|
||||
raise Problem("A print is running or paused. Try again afterwards.")
|
||||
objects = p.get("/printer/objects/list")["objects"]
|
||||
settings = p.query("configfile")["configfile"]["settings"]
|
||||
missing = [m for m in ("HOME", "_NOZZLE_CONTACT_TEMP", "_TWIST_STATE")
|
||||
if "gcode_macro " + m not in objects]
|
||||
missing += [s for s in ["beacon"] + (["bdp_touch"] * (mode == "verify"))
|
||||
if s not in settings]
|
||||
if missing:
|
||||
raise Problem("Not found in Klipper: %s. Is klipper-macros up to "
|
||||
"date and Klipper restarted?" % ", ".join(missing))
|
||||
if p.query("gcode_macro _TWIST_STATE")[
|
||||
"gcode_macro _TWIST_STATE"]["running"]:
|
||||
raise Problem("Another twist run is active. TWIST_STOP stops it (and "
|
||||
"clears this flag if that run has died).")
|
||||
bed = p.query("heater_bed")["heater_bed"]["temperature"]
|
||||
if bed > BED_WARN:
|
||||
p.say("Note: bed at %d C. The reference runs were on a cold bed."
|
||||
% bed)
|
||||
|
||||
|
||||
def bar(done, total, width=20):
|
||||
n = width * done // total if total else 0
|
||||
return "[%s%s]" % ("=" * n, "." * (width - n))
|
||||
|
||||
|
||||
def eta(start, done, total):
|
||||
if not done:
|
||||
return ""
|
||||
left = (time.time() - start) / done * (total - done)
|
||||
return ", ~%d min left" % (left // 60 + 1)
|
||||
|
||||
|
||||
def travel(p, x, y):
|
||||
# Nothing may touch the nozzle here: an object on the bed stops Klipper
|
||||
p.gcode("_GUARD_ON PHASE=twist_travel\nG1 X%d Y%d Z5 F9000\n_GUARD_OFF"
|
||||
% (x, y))
|
||||
|
||||
|
||||
def measure_point(p, mode, x, y):
|
||||
r = {"x": x, "y": y, "t": time.time()}
|
||||
travel(p, x, y - 20)
|
||||
r["prox"] = num(p.gcode("PROBE PROBE_METHOD=proximity"),
|
||||
r"z=(-?[\d.]+)", "Beacon proximity")
|
||||
bed = r["prox"] - TRIGGER
|
||||
if abs(bed) > PROX_LIMIT:
|
||||
raise Problem("Beacon sees the bed at %+.3f mm at x=%d y=%d (limit "
|
||||
"%.1f). Is something on the bed, or the plate not "
|
||||
"seated?" % (bed, x, y, PROX_LIMIT))
|
||||
p.gcode("G1 Z5 F600")
|
||||
travel(p, x, y)
|
||||
if mode == "verify":
|
||||
p.gcode("G1 Z%.3f F300" % (bed + BDP_ABOVE))
|
||||
r["bdp"] = num(p.gcode("BDP_TOUCH FLOOR=0.7"), r"fit z (-?[\d.]+)",
|
||||
"BDP_TOUCH")
|
||||
p.gcode("G1 Z5 F600")
|
||||
r["contact"] = num(p.gcode("PROBE PROBE_METHOD=contact SAMPLES=1"),
|
||||
r"z=(-?[\d.]+)", "Beacon contact")
|
||||
p.gcode("G1 Z5 F600")
|
||||
if abs(r["contact"] - bed) > CONTACT_LIMIT:
|
||||
raise Problem("Nozzle and Beacon differ by %.3f mm at x=%d y=%d (limit"
|
||||
" %.2f). Clean the nozzle; if it stays, check the "
|
||||
"toolhead and Beacon mount."
|
||||
% (abs(r["contact"] - bed), x, y, CONTACT_LIMIT))
|
||||
return r
|
||||
|
||||
|
||||
def run_points(p, mode, path):
|
||||
if mode == "measure":
|
||||
pts = [(x, y) for y in (55, 175, 295) for x in XS]
|
||||
pts += [(175, y) for y in YS if y not in (55, 175, 295)]
|
||||
else:
|
||||
pts = [(x, y) for y in (175, 295) for x in XS]
|
||||
total = len(pts) * PASSES
|
||||
p.gcode(p.state(1, mode, 0, total))
|
||||
p.gcode("M117 Twist %s: heating, homing, QGL" % mode)
|
||||
p.say("%s started: heating the nozzle to 150C, homing, levelling" % mode)
|
||||
p.gcode("BED_MESH_CLEAR")
|
||||
p.gcode("_NOZZLE_CONTACT_TEMP WAIT=1")
|
||||
p.gcode("HOME")
|
||||
p.gcode("QUAD_GANTRY_LEVEL")
|
||||
p.gcode("G28 Z METHOD=CONTACT CALIBRATE=1")
|
||||
p.gcode("G90")
|
||||
p.say("%d points, %d passes. The nozzle will touch the bed at each one."
|
||||
% (len(pts), PASSES))
|
||||
done = 0
|
||||
start = time.time()
|
||||
with open(path, "w") as out:
|
||||
for rep in range(PASSES):
|
||||
for (x, y) in (pts if rep == 0 else pts[::-1]):
|
||||
check_ready(p)
|
||||
if print_active(p):
|
||||
raise Problem("A print started during the run.")
|
||||
r = measure_point(p, mode, x, y)
|
||||
r["rep"] = rep
|
||||
out.write(json.dumps(r) + "\n")
|
||||
out.flush()
|
||||
done += 1
|
||||
text = "%s %d%% %s%s" % (mode, 100 * done // total,
|
||||
bar(done, total, 10),
|
||||
eta(start, done, total))
|
||||
p.gcode(p.state(1, done=done) + "\nM117 Twist " + clean(text))
|
||||
log("%d/%d %s" % (done, total, r))
|
||||
if done % 10 == 0:
|
||||
p.say(text)
|
||||
|
||||
|
||||
def load(path):
|
||||
groups = {}
|
||||
with open(path) as f:
|
||||
for line in f:
|
||||
r = json.loads(line)
|
||||
groups.setdefault((r["x"], r["y"]), []).append(r)
|
||||
return groups
|
||||
|
||||
|
||||
def mean(groups, key, fn):
|
||||
out = {}
|
||||
for k, rs in groups.items():
|
||||
v = [fn(r) for r in rs if r.get(key) is not None
|
||||
and r.get("prox") is not None]
|
||||
if v:
|
||||
out[k] = (st.mean(v), max(v) - min(v))
|
||||
return out
|
||||
|
||||
|
||||
def noisy_passes(spreads):
|
||||
return (max(spreads) > PASS_WORST
|
||||
or sum(v > PASS_SPREAD for v in spreads) > PASS_OUTLIERS)
|
||||
|
||||
|
||||
def analyse_verify(groups):
|
||||
rows = sorted({y for x, y in groups}, reverse=True)
|
||||
prox = mean(groups, "bdp", lambda r: r["bdp"] - (r["prox"] - TRIGGER))
|
||||
cont = mean(groups, "bdp", lambda r: r["bdp"] - r["contact"])
|
||||
spreads = [v[1] for v in prox.values()] + [v[1] for v in cont.values()]
|
||||
spread = max(spreads)
|
||||
flat = {y: max(prox[(x, y)][0] for x in XS)
|
||||
- min(prox[(x, y)][0] for x in XS) for y in rows}
|
||||
worst = max(flat.values())
|
||||
res = {"mode": "verify", "rows": rows,
|
||||
"series": {y: [prox[(x, y)][0] for x in XS] for y in rows},
|
||||
"contact": {y: [cont[(x, y)][0] for x in XS] for y in rows},
|
||||
"block": None}
|
||||
facts = ["Flat along X: worst row varies %.3f mm (good: up to %.3f)."
|
||||
% (worst, FLAT_GOOD),
|
||||
"Same point between passes: up to %.3f mm." % spread]
|
||||
if noisy_passes(spreads):
|
||||
res.update(level="bad", title="Verify: run it again", lines=facts + [
|
||||
"The two passes disagree: clean the nozzle and bed, then run "
|
||||
"Verify again."], retry="verify")
|
||||
elif worst <= FLAT_GOOD:
|
||||
res.update(level="good", title="Verify: compensation is good",
|
||||
lines=facts + ["Nothing to do. PRINT_START makes a new "
|
||||
"mesh by itself."])
|
||||
elif worst <= FLAT_MAX:
|
||||
res.update(level="warn", title="Verify: acceptable", lines=facts + [
|
||||
"Slightly more than ideal but usable. Check a first layer."])
|
||||
else:
|
||||
res.update(level="bad", title="Verify: compensation is off",
|
||||
lines=facts + ["Run Measure again and apply the new "
|
||||
"values. If it stays, check the X rail, "
|
||||
"belts and Beacon mount."], retry="measure")
|
||||
return res
|
||||
|
||||
|
||||
def analyse_measure(groups, current):
|
||||
full = mean(groups, "contact",
|
||||
lambda r: r["contact"] - (r["prox"] - TRIGGER))
|
||||
d = {k: v[0] for k, v in full.items()}
|
||||
spreads = [v[1] for v in full.values()]
|
||||
spread = max(spreads)
|
||||
xrows = [y for y in (55, 175, 295) if all((x, y) in d for x in XS)]
|
||||
if not xrows or not all((175, y) in d for y in YS):
|
||||
raise Problem("Not all points were measured; nothing to conclude.")
|
||||
rel = {y: [d[(x, y)] - d[(175, y)] for x in XS] for y in xrows}
|
||||
xprof = [st.mean(rel[y][i] for y in xrows) for i in range(len(XS))]
|
||||
yprof = [d[(175, y)] - d[(175, 175)] for y in YS]
|
||||
agree = max(abs(rel[y][i] - xprof[i]) for y in xrows
|
||||
for i in range(len(XS)))
|
||||
worst = 0.
|
||||
for y in xrows:
|
||||
for i, x in enumerate(XS):
|
||||
left = d[(x, y)] - d[(175, 175)] - xprof[i] - yprof[YS.index(y)]
|
||||
worst = max(worst, abs(left))
|
||||
biggest = max(abs(v) for v in xprof + yprof)
|
||||
change = None
|
||||
if current and (current.get("z_compensations") or [])[:1] != []:
|
||||
old_x = current.get("z_compensations") or []
|
||||
old_y = current.get("zy_compensations") or []
|
||||
if len(old_x) == len(XS) and len(old_y) == len(YS):
|
||||
change = max(abs(a - b) for a, b in zip(xprof + yprof,
|
||||
old_x + old_y))
|
||||
fmt = lambda vals: ", ".join("%.4f" % (v + 0.) for v in vals)
|
||||
block = """[axis_twist_compensation]
|
||||
# Measured %s with scripts/twist_check.py measure:
|
||||
# nozzle contact vs Beacon proximity, 0 at 175,175
|
||||
calibrate_start_x: %d
|
||||
calibrate_end_x: %d
|
||||
calibrate_y: 175
|
||||
z_compensations: %s
|
||||
compensation_start_x: %d
|
||||
compensation_end_x: %d
|
||||
calibrate_start_y: %d
|
||||
calibrate_end_y: %d
|
||||
calibrate_x: 175
|
||||
zy_compensations: %s
|
||||
compensation_start_y: %d
|
||||
compensation_end_y: %d
|
||||
""" % (datetime.date.today().isoformat(), XS[0], XS[-1], fmt(xprof), XS[0],
|
||||
XS[-1], YS[0], YS[-1], fmt(yprof), YS[0], YS[-1])
|
||||
res = {"mode": "measure", "xprof": xprof, "yprof": yprof, "rel": rel,
|
||||
"block": None, "suggested": block}
|
||||
facts = [
|
||||
"Largest error: %.3f mm. The rows agree within %.3f (limit %.3f)."
|
||||
% (biggest, agree, ROWS_AGREE),
|
||||
"Left after correction: %.3f (limit %.3f). Passes: up to %.3f."
|
||||
% (worst, RESIDUAL, spread)]
|
||||
if noisy_passes(spreads):
|
||||
res.update(level="bad", title="Measure: run it again", lines=facts + [
|
||||
"The two passes disagree: clean the nozzle and bed, then run "
|
||||
"Measure again. Nothing changed."], retry="measure")
|
||||
elif biggest > MAX_COMP:
|
||||
res.update(level="bad", title="Measure: do not apply", lines=facts + [
|
||||
"This error is too large to correct safely. Check the X rail, "
|
||||
"belts, toolhead and Beacon mount. Nothing changed."])
|
||||
elif agree > ROWS_AGREE or worst > RESIDUAL:
|
||||
res.update(level="bad", title="Measure: do not apply", lines=facts + [
|
||||
"The error does not split into an X and a Y part, so this "
|
||||
"compensation cannot correct it. Check the mechanics first. "
|
||||
"Nothing changed."])
|
||||
elif change is not None and change < MIN_CHANGE:
|
||||
res.update(level="good", title="Measure: no change needed",
|
||||
lines=facts + ["The active values are still right (largest"
|
||||
" difference %.3f mm). Nothing to do."
|
||||
% change])
|
||||
else:
|
||||
how = ("Largest difference to the active values: %.3f mm." % change
|
||||
if change is not None else "No compensation is active yet.")
|
||||
res.update(level="warn", title="Measure: new values recommended",
|
||||
block=block, lines=facts + [
|
||||
how,
|
||||
"1. Open twist_data/twist_suggested.cfg in Mainsail "
|
||||
"(Machine, config files) and copy it.",
|
||||
"2. In printer.cfg replace the [axis_twist_compensation"
|
||||
"] block with it (a backup copy of printer.cfg first).",
|
||||
"3. Save and Restart, then run Verify here."])
|
||||
return res
|
||||
|
||||
|
||||
def analyse(path, current=None):
|
||||
groups = load(path)
|
||||
if any("bdp" in r for rs in groups.values() for r in rs):
|
||||
res = analyse_verify(groups)
|
||||
else:
|
||||
res = analyse_measure(groups, current)
|
||||
res["file"] = os.path.basename(path)
|
||||
return res
|
||||
|
||||
|
||||
def report_console(res):
|
||||
print()
|
||||
if res["mode"] == "verify":
|
||||
print("bdp fit - proximity (flat = compensation good):")
|
||||
for y in res["rows"]:
|
||||
print("y=%3d " % y + " ".join("%+.3f" % v
|
||||
for v in res["series"][y]))
|
||||
print("bdp fit - Beacon contact (shows Beacon's contact correction):")
|
||||
for y in res["rows"]:
|
||||
print("y=%3d " % y + " ".join("%+.3f" % v
|
||||
for v in res["contact"][y]))
|
||||
else:
|
||||
print("contact - proximity, each row minus its own x=175:")
|
||||
for y, vals in res["rel"].items():
|
||||
print("y=%3d " % y + " ".join("%+.3f" % v for v in vals))
|
||||
print("X profile:", " ".join("%+.4f" % v for v in res["xprof"]))
|
||||
print("Y profile:", " ".join("%+.4f" % v for v in res["yprof"]))
|
||||
print("\n" + res["title"].upper())
|
||||
for line in res["lines"]:
|
||||
print(" " + line)
|
||||
if res["block"]:
|
||||
print("\n" + res["block"])
|
||||
|
||||
|
||||
COLORS = ["#2a78c6", "#d95f02", "#1b9e77", "#7570b3"]
|
||||
|
||||
|
||||
def chart(title, xs, series, xlabel):
|
||||
# series: list of (name, values); a plain SVG line chart in mm
|
||||
w, h, ml, mr, mt, mb = 640, 300, 62, 16, 54, 44
|
||||
vals = [v for _, vs in series for v in vs]
|
||||
lo, hi = min(vals + [-0.02]), max(vals + [0.02])
|
||||
pad = (hi - lo) * 0.1
|
||||
lo, hi = lo - pad, hi + pad
|
||||
px = lambda x: ml + (x - xs[0]) * (w - ml - mr) / (xs[-1] - xs[0])
|
||||
py = lambda v: mt + (hi - v) * (h - mt - mb) / (hi - lo)
|
||||
out = ['<svg viewBox="0 0 %d %d" role="img" aria-label="%s">'
|
||||
% (w, h, html.escape(title)),
|
||||
'<text x="%d" y="20" class="t">%s</text>' % (ml, html.escape(title))]
|
||||
step = 0.01 if hi - lo < 0.08 else (0.02 if hi - lo < 0.16 else 0.05)
|
||||
v = int(lo / step) * step
|
||||
while v <= hi:
|
||||
if v >= lo:
|
||||
out.append('<line x1="%d" x2="%d" y1="%.1f" y2="%.1f" class="%s"/>'
|
||||
% (ml, w - mr, py(v), py(v),
|
||||
"z" if abs(v) < step / 2 else "g"))
|
||||
out.append('<text x="%d" y="%.1f" class="l" text-anchor="end">'
|
||||
'%+.2f</text>' % (ml - 6, py(v) + 4, v + 0.))
|
||||
v += step
|
||||
for x in xs:
|
||||
out.append('<text x="%.1f" y="%d" class="l" text-anchor="middle">%d'
|
||||
'</text>' % (px(x), h - mb + 16, x))
|
||||
out.append('<text x="%d" y="%d" class="l" text-anchor="middle">%s (mm)'
|
||||
'</text>' % ((ml + w - mr) // 2, h - 8, xlabel))
|
||||
for i, (name, vs) in enumerate(series):
|
||||
c = COLORS[i % len(COLORS)]
|
||||
pts = " ".join("%.1f,%.1f" % (px(x), py(v)) for x, v in zip(xs, vs))
|
||||
out.append('<polyline points="%s" fill="none" stroke="%s" '
|
||||
'stroke-width="2"/>' % (pts, c))
|
||||
out += ['<circle cx="%.1f" cy="%.1f" r="3" fill="%s"><title>%s, %d: '
|
||||
'%+.3f mm</title></circle>'
|
||||
% (px(x), py(v), c, html.escape(name), x, v)
|
||||
for x, v in zip(xs, vs)]
|
||||
out.append('<text x="%d" y="%d" class="l" fill="%s" style="fill:%s">'
|
||||
'%s</text>' % (ml + i * 70, 40, c, c, html.escape(name)))
|
||||
out.append("</svg>")
|
||||
return "\n".join(out)
|
||||
|
||||
|
||||
def report_html(res, path):
|
||||
if res["mode"] == "verify":
|
||||
charts = [
|
||||
chart("bdp fit - proximity: should be a flat line", XS,
|
||||
[("y=%d" % y, res["series"][y]) for y in res["rows"]], "X"),
|
||||
chart("bdp fit - Beacon contact: minus the correction", XS,
|
||||
[("y=%d" % y, res["contact"][y]) for y in res["rows"]], "X")]
|
||||
else:
|
||||
charts = [
|
||||
chart("Error along X, per row: lines should overlap", XS,
|
||||
[("y=%d" % y, v) for y, v in res["rel"].items()]
|
||||
+ [("mean", res["xprof"])], "X"),
|
||||
chart("Error along Y at x=175", YS, [("Y", res["yprof"])], "Y")]
|
||||
block = res["block"] or res.get("suggested") or ""
|
||||
page = """<!doctype html>
|
||||
<html><head><meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<title>Twist %s</title>
|
||||
<style>
|
||||
:root{--bg:#fff;--fg:#1c2024;--dim:#5f6b76;--grid:#e3e6e8;--box:#f4f5f6}
|
||||
@media (prefers-color-scheme:dark){:root{--bg:#16191c;--fg:#e6e8ea;
|
||||
--dim:#98a2ab;--grid:#2c3136;--box:#212529}}
|
||||
body{margin:0 auto;max-width:720px;padding:16px;background:var(--bg);
|
||||
color:var(--fg);font:16px/1.5 system-ui,sans-serif}
|
||||
.v{padding:12px 16px;border-radius:8px;border-left:6px solid;
|
||||
background:var(--box);margin:12px 0}
|
||||
.good{border-color:#1b9e77}.warn{border-color:#e6a100}.bad{border-color:#d62728}
|
||||
h1{font-size:1.3em;margin:0 0 6px}p{margin:4px 0}svg{width:100%%;margin:12px 0}
|
||||
.t{font-size:14px;font-weight:600;fill:var(--fg)}
|
||||
.l{font-size:12px;fill:var(--dim)}.g{stroke:var(--grid)}.z{stroke:var(--dim)}
|
||||
pre{background:var(--box);padding:12px;overflow-x:auto;font-size:13px}
|
||||
small{color:var(--dim)}
|
||||
</style></head><body>
|
||||
<div class="v %s"><h1>%s</h1>%s</div>
|
||||
%s
|
||||
%s
|
||||
<small>%s, written %s</small>
|
||||
</body></html>
|
||||
""" % (res["mode"], res["level"], html.escape(res["title"]),
|
||||
"".join("<p>%s</p>" % html.escape(s) for s in res["lines"]),
|
||||
"\n".join(charts),
|
||||
("<pre>%s</pre>" % html.escape(block)) if block else "",
|
||||
html.escape(res["file"]),
|
||||
datetime.datetime.now().strftime("%Y-%m-%d %H:%M"))
|
||||
with open(path, "w", encoding="utf-8") as f:
|
||||
f.write(page)
|
||||
|
||||
|
||||
def cleanup(p):
|
||||
# Never fight a print that has started, and do not raise from here
|
||||
try:
|
||||
check_ready(p)
|
||||
if print_active(p):
|
||||
log("A print is active: leaving the printer alone.")
|
||||
return True
|
||||
homed = p.query("toolhead")["toolhead"]["homed_axes"]
|
||||
p.gcode("_GUARD_OFF", timeout=120)
|
||||
if "z" in homed:
|
||||
p.gcode("G90\nG1 Z10 F600", timeout=120)
|
||||
p.gcode("M104 S0", timeout=120)
|
||||
return True
|
||||
except Exception as e:
|
||||
log("Could not finish cleanly: %s" % e)
|
||||
log("Check the printer: the nozzle heater may still be on until "
|
||||
"Klipper restarts.")
|
||||
return False
|
||||
|
||||
|
||||
def on_signal(signum, frame):
|
||||
raise Stopped()
|
||||
|
||||
|
||||
def run(mode, host):
|
||||
global LOG
|
||||
os.makedirs(DATA_DIR, exist_ok=True)
|
||||
LOG = open(os.path.join(DATA_DIR, "twist_run.log"), "a")
|
||||
p = Printer(host)
|
||||
stamp = datetime.datetime.now().strftime("%Y%m%d_%H%M")
|
||||
path = os.path.join(DATA_DIR, "twist_%s_%s.jsonl" % (mode, stamp))
|
||||
report = path[:-len(".jsonl")] + ".html"
|
||||
log("=== %s, writing %s" % (mode, path))
|
||||
failure = None
|
||||
res = None
|
||||
started = False
|
||||
signal.signal(signal.SIGTERM, on_signal)
|
||||
signal.signal(signal.SIGINT, on_signal)
|
||||
if hasattr(signal, "SIGHUP"):
|
||||
# A closed SSH window must not end the run halfway
|
||||
signal.signal(signal.SIGHUP, signal.SIG_IGN)
|
||||
try:
|
||||
preflight(p, mode)
|
||||
started = True
|
||||
p.gcode(p.logo("calibrating_z") or "M400")
|
||||
run_points(p, mode, path)
|
||||
res = analyse(path, p.query("configfile")["configfile"]["settings"]
|
||||
.get("axis_twist_compensation"))
|
||||
except Stopped:
|
||||
failure = ("Stopped", ["Stopped on request. The result is not used "
|
||||
"and nothing changed."])
|
||||
except Problem as e:
|
||||
failure = ("Twist %s stopped" % mode, [
|
||||
str(e), "Nothing changed in the configuration. "
|
||||
"Fix this, then start again with TWIST_CALIBRATE."])
|
||||
signal.signal(signal.SIGTERM, signal.SIG_IGN)
|
||||
signal.signal(signal.SIGINT, signal.SIG_IGN)
|
||||
if started:
|
||||
cleanup(p)
|
||||
if res:
|
||||
report_console(res)
|
||||
report_html(res, report)
|
||||
if res["block"]:
|
||||
with open(os.path.join(DATA_DIR, "twist_suggested.cfg"), "w") as f:
|
||||
f.write(res["block"])
|
||||
log(res["title"])
|
||||
return finish(p, res, failure, os.path.basename(report), started)
|
||||
|
||||
|
||||
def finish(p, res, failure, report_name, started):
|
||||
# Klipper may be down here; the log and the shell keep the message
|
||||
try:
|
||||
if res:
|
||||
buttons = []
|
||||
if res.get("retry"):
|
||||
buttons.append(("Run %s again" % res["retry"],
|
||||
"_TWIST_CHECKLIST MODE=%s" % res["retry"],
|
||||
"primary"))
|
||||
elif res["level"] == "warn" and res["mode"] == "measure":
|
||||
buttons.append(("Run Verify (after restart)",
|
||||
"_TWIST_CHECKLIST MODE=verify", "primary"))
|
||||
p.gcode(p.state(0))
|
||||
logo = p.logo("error" if res["level"] == "bad" else "ready")
|
||||
p.gcode(logo or "M400")
|
||||
p.gcode("M117 %s" % clean(res["title"]))
|
||||
for line in res["lines"]:
|
||||
p.say(line)
|
||||
p.dialog(res["title"], res["lines"] + [
|
||||
"Report with charts: twist_data/" + report_name], buttons)
|
||||
else:
|
||||
title, lines = failure
|
||||
# Refused at the start: an active run or print keeps its flag,
|
||||
# status line and logo
|
||||
if started:
|
||||
p.gcode(p.state(0))
|
||||
logo = p.logo("error" if title != "Stopped" else "ready")
|
||||
p.gcode(logo or "M400")
|
||||
p.gcode("M117 %s" % clean(title))
|
||||
p.dialog(title, lines)
|
||||
except Exception as e:
|
||||
log("Could not show the result in Mainsail: %s" % e)
|
||||
if failure:
|
||||
log(failure[0] + ": " + " ".join(failure[1]))
|
||||
return 1
|
||||
return 0 if res["level"] != "bad" else 2
|
||||
|
||||
|
||||
def main():
|
||||
ap = argparse.ArgumentParser(
|
||||
description="Measure and verify axis twist compensation (nozzle vs "
|
||||
"Beacon). Normally started with the macro TWIST_CALIBRATE.")
|
||||
ap.add_argument("mode", choices=("measure", "verify", "analyse"))
|
||||
ap.add_argument("file", nargs="?", help="analyse: a saved .jsonl")
|
||||
ap.add_argument("--host", default="http://localhost:7125",
|
||||
help="Moonraker (its own port: nginx ends requests after "
|
||||
"60 s)")
|
||||
a = ap.parse_args()
|
||||
if a.mode != "analyse":
|
||||
return run(a.mode, a.host.rstrip("/"))
|
||||
if not a.file:
|
||||
ap.error("analyse needs a file")
|
||||
current = None
|
||||
try:
|
||||
current = Printer(a.host.rstrip("/")).query("configfile")[
|
||||
"configfile"]["settings"].get("axis_twist_compensation")
|
||||
except Problem:
|
||||
print("Printer not reachable: not comparing with the active values")
|
||||
res = analyse(a.file, current)
|
||||
report_console(res)
|
||||
report = os.path.splitext(a.file)[0] + ".html"
|
||||
report_html(res, report)
|
||||
print("\nReport:", report)
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
Reference in new issue
Block a user