painting-vision-robotics-kit / controller_adapter.py
constructelligence's picture
Update code: real-machine G-code adapter, commissioning gate, machine_job runner, pump watchdog firmware, twin completion gate, realism and masking modules (card and weights unchanged)
4eecd03 verified
Raw History Blame Contribute Delete
34.7 kB
#!/usr/bin/env python3
"""The missing link: a supervised hardware.py job -> G-code a real motion controller runs, streamed under the supervisor.
``hardware.py`` stops at a command list in wall-plane millimetres. This module is the adapter docs/HARDWARE.md said was
"to build", for the cheapest machine that can actually put paint on a wall: a gantry or mast carriage on a GRBL /
FluidNC / grblHAL board (three axes: X along the wall, Z up the mast, Y towards the wall; tool outputs on M-codes).
ROS 2 or an industrial controller would want a different emitter; the program model here (one line, the commands it
carries out) is what they would share.
What it adds, beyond translating coordinates:
* **stations as stops.** Each base re-park is an ``M0`` pause with the station's wall range in the comment; streamed,
it is an operator callback (park, register, confirm), and the base move is never a G-code move.
* **tool engagement.** Contact tools plunge on Y to a press depth computed from the force target and the *measured*
nap stiffness (``measurements.py``), and retract between strokes; the spray opens ``trigger_lead_mm`` before the
stroke and closes ``release_lead_mm`` before its end, so the valve latency lands the fan on the line.
* **refuse, don't clip.** A move outside the machine's travel is a ``ProgramError``, never a clamped coordinate.
* **air-cut first.** ``dry_run=True`` emits the same motion with every output off and contact depth held
``aircut_clearance_mm`` short of the wall. A wet run of a program is refused until an air-cut of the *same program*
(by hash) has finished cleanly, and until commissioning (``commissioning.py``) says the machine is ready.
* **the supervisor stays live.** ``Streamer`` checks every wall-plane command a line carries through
``SafetySupervisor.check`` before the line is sent; status polls (``?``, answered even with the planner full) are the
heartbeat; an ``ALARM``, an ``error``, a silent controller, or a reported position the program never visits trips the
supervisor and sends feed-hold (``!``) then soft-reset (Ctrl-X, which drops spindle and coolant outputs on GRBL).
* **as-run, not as-planned.** Every status sample is logged; ``as_run_job`` turns the log back into a wall-plane job
that ``hardware.rasterize`` / ``coverage_loop`` can score, so coverage comes from where the machine went.
Not in this module, and not optional on a real machine: a hard-wired e-stop that cuts motor and pump power without
software, limit switches, and drive-level current limits. The supervisor is the software half (safety_supervisor.py).
Fixed-depth warning: GRBL holds position, not force. ``roller_physics`` shows a fixed-depth roller inside its force
window ~37 % of the time on a +-5 mm wall; mount contact tools on a compliant (spring or pneumatic, constant-force)
slide and set ``force_control: "compliant"`` in the machine file, or the plan's film numbers do not apply.
python3 controller_adapter.py gcode --job job.json --machine machine.json --out wall.nc [--dry-run]
python3 controller_adapter.py stream --job job.json --machine machine.json --port /dev/ttyUSB0 --gate gate.json --dry-run
python3 controller_adapter.py stream ... --sim # against the built-in simulated GRBL
"""
from __future__ import annotations
import argparse
import hashlib
import json
import math
import re
import time
from dataclasses import dataclass, field, asdict
from pathlib import Path
import hardware
import measurements
from safety_supervisor import SafeStop
HERE = Path(__file__).resolve().parent
RUNS_DIR = HERE / "artifacts" / "machine_runs"
class ProgramError(ValueError):
"""The job cannot be turned into a program this machine can run safely."""
@dataclass
class Machine:
name: str = "prototype"
platform: str = "mast_arm"
x_travel_mm: tuple = (0.0, 1200.0) # carriage travel along the wall at one station
x_origin_mm: float = 0.0 # machine X of the station's left edge: travel beyond the station on
# both sides is runway for the spray to open before a stroke
z_travel_mm: tuple = (150.0, 3200.0) # mast travel, machine Z = wall z - z_offset_mm
y_travel_mm: tuple = (0.0, 400.0) # towards the wall; 0 = fully retracted
z_offset_mm: float = 0.0 # wall z at machine Z = 0 (0: machine Z is height above the floor)
y_wall_mm: float | None = None # Y at which the tool face touches the wall (commissioning touch-off)
y_retract_mm: float = 0.0
spray_y_mm: float | None = None # Y for the spray standoff; default y_wall - standoff
press_mm: dict = field(default_factory=lambda: {"brush": 3.0, "sander": 2.0, "scorer": 2.0, "steamer": 2.0,
"scraper": 2.0, "smoother": 3.0, "taper": 2.0})
outputs: dict = field(default_factory=lambda: {"spray": ["M8", "M9"], "sander": ["M3 S1000", "M5"],
"steamer": ["M3 S1000", "M5"]})
plunge_feed_mm_min: float = 600.0
max_feed_mm_min: float = 90000.0
aircut_clearance_mm: float = 20.0
force_control: str = "fixed" # fixed | compliant (spring / pneumatic constant-force slide)
status_period_s: float = 0.1 # 10 Hz: the as-run path is only as fine as this (25 mm at 250 mm/s)
heartbeat_timeout_s: float = 1.0
position_tolerance_mm: float = 5.0
@classmethod
def load(cls, path=None, **over):
data = json.loads(Path(path).read_text(encoding="utf-8")) if path else {}
data.update(over)
known = {k: v for k, v in data.items() if k in cls.__dataclass_fields__}
for k in ("x_travel_mm", "z_travel_mm", "y_travel_mm"):
if k in known:
known[k] = tuple(known[k])
return cls(**known)
def roller_press_mm(tool):
"""Press depth that gives the middle of the force window at the (measured, else assumed) nap stiffness."""
import roller_physics
p = roller_physics.params()
return 0.5 * sum(tool["force_n"]) / p["nap_stiffness_n_mm"]
@dataclass
class Line:
text: str
commands: tuple = () # indices into job["commands"] this line carries out
kind: str = "motion" # motion | output | station | comment
station: int | None = None
target: tuple | None = None # machine (x, y, z) after this line
def _f(v):
return f"{v:.3f}".rstrip("0").rstrip(".")
def build_program(job, machine, dry_run=False):
"""Lines for one job. Raises ProgramError for anything the machine cannot do as planned."""
tool = job["tool"]
name = tool["name"]
platform = hardware.PLATFORMS[job["platform"]]
if machine.platform != job["platform"]:
raise ProgramError(f"job is for {job['platform']}, machine is a {machine.platform}")
if machine.y_wall_mm is None:
raise ProgramError("machine has no y_wall_mm: run the commissioning touch-off first")
reach = platform.reach_x_mm
if machine.x_origin_mm < machine.x_travel_mm[0] - 1e-6 or machine.x_origin_mm + reach > machine.x_travel_mm[1] + 1e-6:
raise ProgramError(f"carriage travel {machine.x_travel_mm} does not hold the {reach:.0f} mm station the job was "
f"compiled for (from X {machine.x_origin_mm:g}); recompile with the machine's reach")
contact = bool(tool["contact"])
if contact:
press = roller_press_mm(tool) if name == "roller" else machine.press_mm.get(name, 2.0)
y_work = machine.y_wall_mm + press
else:
y_work = machine.spray_y_mm if machine.spray_y_mm is not None else machine.y_wall_mm - tool["standoff_mm"]
if dry_run and contact:
y_work = machine.y_wall_mm - machine.aircut_clearance_mm
on, off = (machine.outputs.get(name) or [None, None]) # in an air-cut these become comments, motion unchanged
lines, warnings = [], []
if contact and machine.force_control != "compliant":
warnings.append(f"{name}: fixed-depth contact (no compliant slide); film and force numbers from the plan "
"assume a force loop (roller_physics: ~37 % in window at fixed depth on a +-5 mm wall)")
def check(x, y, z):
for axis, v, (lo, hi) in (("X", x, machine.x_travel_mm), ("Y", y, machine.y_travel_mm), ("Z", z, machine.z_travel_mm)):
if not lo - 1e-6 <= v <= hi + 1e-6:
raise ProgramError(f"{axis} {v:.1f} mm is outside the machine's travel [{lo:g}, {hi:g}]")
state = {"x": None, "z": None, "y": machine.y_retract_mm, "engaged": False, "station": None}
late = {"n": 0, "worst": 0.0}
def mach(c, station):
return c["x"] - station * reach + machine.x_origin_mm, c["y"] - machine.z_offset_mm
def move(x, z, feed, idx, kind="motion"):
check(x, state["y"], z)
state["x"], state["z"] = x, z
lines.append(Line(f"G1 X{_f(x)} Z{_f(z)} F{_f(min(feed, machine.max_feed_mm_min))}", tuple(idx), kind,
state["station"], (x, state["y"], z)))
def set_y(y, idx=()):
check(state["x"] if state["x"] is not None else machine.x_travel_mm[0], y,
state["z"] if state["z"] is not None else machine.z_travel_mm[0])
state["y"] = y
lines.append(Line(f"G1 Y{_f(y)} F{_f(machine.plunge_feed_mm_min)}", tuple(idx), "motion", state["station"],
(state["x"], y, state["z"])))
def output(text, comment):
if dry_run:
lines.append(Line(f"({comment}: {text} withheld, air-cut)", (), "comment", state["station"]))
else:
lines.append(Line(text, (), "output", state["station"]))
def engage(idx=()):
if not state["engaged"]:
set_y(y_work, idx)
if on:
output(on, f"{name} on")
state["engaged"] = True
def disengage():
if state["engaged"]:
if off:
output(off, f"{name} off")
set_y(machine.y_retract_mm)
state["engaged"] = False
lines.append(Line(f"({job['operation']} on {job['platform']}, wall {job['commands'][0].get('wall_id') if job['commands'] else None}"
f"{', AIR-CUT' if dry_run else ''})", (), "comment"))
lines.append(Line("G21 G90 G94", (), "comment"))
lines.append(Line(f"G1 Y{_f(machine.y_retract_mm)} F{_f(machine.plunge_feed_mm_min)}", (), "motion", None,
None))
cmds = job["commands"]
travel_idx, travel_to = [], None
feed_travel = 0.8 * platform.max_speed_mm_s * 60
def flush_travel():
nonlocal travel_idx, travel_to
if travel_to is not None:
disengage()
move(*travel_to, feed_travel, travel_idx)
travel_idx, travel_to = [], None
i = 0
while i < len(cmds):
c = cmds[i]
station = c.get("station", 0) or 0
if station != state["station"]:
flush_travel()
disengage()
lo = station * reach
state["station"] = station
state["x"] = state["z"] = None
lines.append(Line(f"M0 (park base at station {station}: wall x {lo:.0f}-{lo + reach:.0f} mm, register, resume)",
(), "station", station))
if not c["paint"]:
travel_idx.append(i)
travel_to = mach(c, station)
i += 1
continue
if c.get("dwell_s"):
flush_travel()
engage((i,))
lines.append(Line(f"G4 P{_f(c['dwell_s'])}", (i,), "motion", station, (state["x"], state["y"], state["z"])))
# the next command (paint off at the same spot) disengages through the travel path
i += 1
continue
# a stroke: consecutive paint commands
flush_travel()
start = (state["x"], state["z"])
if start[0] is None:
raise ProgramError(f"command {i} paints without a preceding position")
feed = (c.get("speed_mm_s") or job["speed_mm_s"]) * 60
lead = c.get("trigger_lead_mm") or 0.0
if lead and on and not contact:
x1, z1 = mach(c, station)
d = math.dist(start, (x1, z1)) or 1.0
ux, uz = (x1 - start[0]) / d, (z1 - start[1]) / d
room = lead
for v, u, (lo, hi) in ((start[0], ux, machine.x_travel_mm), (start[1], uz, machine.z_travel_mm)):
if u > 1e-9:
room = min(room, (v - lo) / u)
elif u < -1e-9:
room = min(room, (hi - v) / -u)
if room < lead - 0.5:
late["n"] += 1
late["worst"] = max(late["worst"], lead - room)
move(start[0] - ux * room, start[1] - uz * room, feed_travel, ()) # back off so the gun opens early
set_y(y_work)
output(on, f"{name} on, {lead:.0f} mm early for valve latency")
state["engaged"] = True
move(*start, feed, ())
else:
engage()
while i < len(cmds) and cmds[i]["paint"] and not cmds[i].get("dwell_s") and (cmds[i].get("station", 0) or 0) == station:
c = cmds[i]
x, z = mach(c, station)
release = c.get("release_lead_mm") or 0.0
if release and off and not contact:
d = math.dist((state["x"], state["z"]), (x, z)) or 1.0
f = max(0.0, 1 - release / d)
px, pz = state["x"] + (x - state["x"]) * f, state["z"] + (z - state["z"]) * f
move(px, pz, feed, (i,))
output(off, f"{name} off, {release:.0f} mm early")
state["engaged"] = False
move(x, z, feed, ())
set_y(machine.y_retract_mm)
else:
move(x, z, feed, (i,))
i += 1
flush_travel()
disengage()
lines.append(Line("M2", (), "comment"))
if late["n"]:
warnings.append(f"{name}: {late['n']} stroke(s) start at the end of carriage travel, so the gun opens up to "
f"{late['worst']:.0f} mm late (a thin start); give the carriage that much runway beyond the "
"station (x_travel_mm wider than the reach, x_origin_mm inside it)")
covered = sorted({j for ln in lines for j in ln.commands})
if covered != list(range(len(cmds))):
missing = sorted(set(range(len(cmds))) - set(covered))
raise ProgramError(f"{len(missing)} command(s) did not make it into the program (first: {missing[:5]})")
return {"lines": lines, "warnings": warnings, "dry_run": dry_run, "hash": program_hash(lines, ignore_outputs=True),
"tool": name}
def program_hash(lines, ignore_outputs=True):
"""Hash of the motion a program makes. Outputs and the air-cut depth are left out (``ignore_outputs``) so the
air-cut and the wet run of the same job share a hash; everything that moves the carriage in X and Z is in it."""
h = hashlib.sha256()
for ln in lines:
if ln.kind == "motion" and not re.match(r"G1 Y", ln.text):
h.update(ln.text.encode())
elif ln.kind == "station":
h.update(ln.text.encode())
elif not ignore_outputs:
h.update(ln.text.encode())
return h.hexdigest()[:16]
def program_envelope(program):
"""Per station, the X/Z box the program's motion stays inside: ``{station: [x_lo, x_hi, z_lo, z_hi]}``."""
env = {}
for ln in program["lines"]:
if ln.kind == "motion" and ln.target and ln.station is not None and None not in (ln.target[0], ln.target[2]):
x, _, z = ln.target
b = env.setdefault(str(ln.station), [x, x, z, z])
b[0], b[1], b[2], b[3] = min(b[0], x), max(b[1], x), min(b[2], z), max(b[3], z)
return env
def _inside(inner, outer, tol=1.0):
return all(k in outer and outer[k][0] - tol <= b[0] and b[1] <= outer[k][1] + tol and outer[k][2] - tol <= b[2]
and b[3] <= outer[k][3] + tol for k, b in inner.items())
def to_gcode(program):
return "\n".join(ln.text for ln in program["lines"]) + "\n"
# ------------------------------------------------------------------ transports
class SerialTransport:
"""A GRBL board on a serial port (needs pyserial)."""
def __init__(self, port, baud=115200):
import serial # imported here: only a real machine needs it
self.s = serial.Serial(port, baud, timeout=0.05)
time.sleep(2.0) # GRBL resets on open
self.s.reset_input_buffer()
def write(self, data: bytes):
self.s.write(data)
def readline(self, timeout=0.05):
self.s.timeout = timeout
raw = self.s.readline()
return raw.decode(errors="replace").strip() if raw else None
class SimGrbl:
"""A simulated GRBL for tests and rehearsal: executes moves instantly, answers ``ok`` and ``?``.
Faults to inject: ``alarm_after`` (ALARM:1 on that line, e.g. a hard limit), ``hang_after`` (stops answering
anything), ``drift_after`` (reported position jumps by ``drift_mm``, as after lost steps).
"""
def __init__(self, alarm_after=None, hang_after=None, drift_after=None, drift_mm=50.0, home=(0.0, 0.0, 0.0)):
self.pos = list(home) # where homing left the machine
self.flood = self.spindle = False
self.n = 0
self.alarm_after, self.hang_after, self.drift_after, self.drift_mm = alarm_after, hang_after, drift_after, drift_mm
self.out, self.received, self.state = [], [], "Idle"
self.feed_hold = self.reset = False
def write(self, data: bytes):
self.received.append(data)
if data == b"!":
self.feed_hold, self.state = True, "Hold"
return
if data == b"\x18":
self.reset, self.flood, self.spindle, self.state = True, False, False, "Alarm"
return
if data == b"~":
self.state = "Idle"
return
if self.hang_after is not None and self.n >= self.hang_after:
return
if data == b"?":
drift = self.drift_mm if self.drift_after is not None and self.n >= self.drift_after else 0.0
acc = ("S" if self.spindle else "") + ("F" if self.flood else "")
self.out.append(f"<{self.state}|MPos:{_f(self.pos[0] + drift)},{_f(self.pos[1])},{_f(self.pos[2])}|FS:0,0"
+ (f"|A:{acc}" if acc else "") + ">")
return
line = data.decode().strip()
self.n += 1
if self.alarm_after is not None and self.n >= self.alarm_after:
self.state = "Alarm"
self.out.append("ALARM:1")
return
code = line.split("(")[0].strip()
for axis, k in (("X", 0), ("Y", 1), ("Z", 2)):
m = re.search(axis + r"(-?[\d.]+)", code)
if m and code.startswith("G1"):
self.pos[k] = float(m.group(1))
if code.startswith("M8"):
self.flood = True
elif code.startswith("M9"):
self.flood = False
elif code.startswith("M3"):
self.spindle = True
elif code.startswith("M5"):
self.spindle = False
self.out.append("ok")
def readline(self, timeout=0.05):
if self.out:
return self.out.pop(0)
time.sleep(min(timeout, 0.01))
return None
# ------------------------------------------------------------------ the streamer
_STATUS = re.compile(r"<(\w+)[^|]*\|MPos:(-?[\d.]+),(-?[\d.]+),(-?[\d.]+)(.*)>")
class Streamer:
"""Send a program line by line, the supervisor checking each command first and the controller's status as heartbeat.
``on_station(k, line)`` is called at each ``M0`` (operator re-parks and registers the base); return False to stop.
Returns the run record: completed or stopped, why, the lines acknowledged, and the as-run status samples.
"""
def __init__(self, transport, supervisor, machine, job, clock=time.monotonic, on_station=None, watchdog=None,
operator=None):
self.t, self.sup, self.m, self.job, self.clock = transport, supervisor, machine, job, clock
self.watchdog, self.operator = watchdog, operator # pump_watchdog.WatchdogLink, already armed
self.on_station = on_station or (lambda k, line: True)
self.samples, self.acked, self.log = [], 0, []
self.last_seen = None
self._next_poll = 0.0
def _stop(self, reason):
if self.watchdog is not None:
self.watchdog.stop() # relay off and GRBL abort, independent of this port
for data in (b"!", b"\x18"): # feed hold, then soft reset (outputs off on GRBL)
try:
self.t.write(data)
except Exception: # a dead port must not stop us latching
pass
if not self.sup.latched:
self.sup.trip(reason, now=self.clock())
self.log.append({"t": self.clock(), "event": "safe_stop", "reason": reason})
raise SafeStop(reason)
def _bounds_ok(self, x, y, z):
tol = self.m.position_tolerance_mm
return all(lo - tol <= v <= hi + tol for v, (lo, hi) in
((x, self.m.x_travel_mm), (y, self.m.y_travel_mm), (z, self.m.z_travel_mm)))
def _handle(self, reply, waiting_ok, expected=None):
now = self.clock()
if reply.startswith("ALARM") or reply.startswith("error"):
self._stop(f"controller reported {reply}")
m = _STATUS.match(reply)
if m:
state, x, y, z, rest = m.group(1), float(m.group(2)), float(m.group(3)), float(m.group(4)), m.group(5)
self.last_seen = now
self.sup.heartbeat(now=now)
acc = re.search(r"\|A:([A-Z]*)", rest)
self.samples.append({"t": round(now, 3), "state": state, "x": x, "y": y, "z": z,
"outputs": acc.group(1) if acc else "", "station": self.station})
if state == "Alarm":
self._stop("controller is in Alarm")
if not self._bounds_ok(x, y, z):
self._stop(f"controller reports ({x:.1f}, {y:.1f}, {z:.1f}) mm, outside the travel the program uses: "
"lost steps, a crash, or the wrong machine file")
if expected is not None and state == "Idle" and math.dist((x, y, z), expected) > self.m.position_tolerance_mm:
self._stop(f"idle at ({x:.1f}, {y:.1f}, {z:.1f}) mm but the last line ended at "
f"({expected[0]:.1f}, {expected[1]:.1f}, {expected[2]:.1f}): position lost")
return False
if reply == "ok":
self.last_seen = now
self.sup.heartbeat(now=now)
return waiting_ok
return False
def _beat_watchdog(self):
if self.watchdog is not None:
try:
self.watchdog.beat()
except SafeStop as stop:
self._stop(str(stop))
def _wait_ok(self, expected=None):
while True:
self._beat_watchdog()
now = self.clock()
if now >= self._next_poll:
self.t.write(b"?")
self._next_poll = now + self.m.status_period_s
if self.last_seen is not None and now - self.last_seen > self.m.heartbeat_timeout_s:
self._stop(f"controller silent for {now - self.last_seen:.2f}s (limit {self.m.heartbeat_timeout_s:.2f}s)")
reply = self.t.readline(timeout=0.02)
if reply and self._handle(reply, True, expected):
return
def run(self, program):
self.station = None
self.dry_run = program["dry_run"]
self.last_seen = self.clock()
cmds = self.job["commands"]
last_target = None
try:
for n, ln in enumerate(program["lines"]):
for j in ln.commands: # the supervisor sees the wall-plane commands before the machine does
try:
self.sup.check(cmds[j], now=self.clock())
except SafeStop as stop:
self._stop(f"supervisor refused command {j}: {stop}")
if ln.kind == "station":
self.station = ln.station
self._wait_idle(last_target)
self.log.append({"t": self.clock(), "event": "station", "station": ln.station})
if self.watchdog is not None:
self.watchdog.pause() # pump power off while a person moves the base: not a fault
if not self.on_station(ln.station, ln.text):
self._stop(f"operator did not confirm station {ln.station}")
if self.watchdog is not None:
try:
self.watchdog.arm(self.operator)
except SafeStop as stop:
self._stop(str(stop))
self.last_seen = self.clock()
continue
if ln.kind == "comment" and ln.text.startswith("("):
continue
self.t.write((ln.text + "\n").encode())
self._wait_ok()
self.acked = n + 1
if ln.target and None not in ln.target:
last_target = ln.target
self._wait_idle(last_target)
return self.record(True, None)
except SafeStop as stop:
return self.record(False, str(stop))
def _wait_idle(self, expected, limit_s=600.0):
"""Block until the controller reports Idle (the planner has drained), checking the position it stops at."""
t0 = self.clock()
while self.clock() - t0 < limit_s:
self._beat_watchdog()
now = self.clock()
if now >= self._next_poll:
self.t.write(b"?")
self._next_poll = now + self.m.status_period_s
if self.last_seen is not None and now - self.last_seen > self.m.heartbeat_timeout_s:
self._stop(f"controller silent for {now - self.last_seen:.2f}s (limit {self.m.heartbeat_timeout_s:.2f}s)")
reply = self.t.readline(timeout=0.02)
if reply:
self._handle(reply, False, expected)
if reply.startswith("<Idle"):
return
self._stop(f"controller never went idle in {limit_s:.0f}s")
def record(self, completed, reason):
return {"completed": completed, "reason": reason, "dry_run": getattr(self, "dry_run", None),
"lines_acked": self.acked, "samples": self.samples,
"log": self.log, "supervisor": self.sup.status()}
# ------------------------------------------------------------------ run records and the wet-run interlock
def _runs_file(runs_dir=None):
d = Path(runs_dir) if runs_dir else RUNS_DIR
d.mkdir(parents=True, exist_ok=True)
return d / "runs.json"
def load_runs(runs_dir=None):
f = _runs_file(runs_dir)
return json.loads(f.read_text()) if f.exists() else []
def save_run(entry, runs_dir=None):
runs = load_runs(runs_dir)
runs.append(entry)
_runs_file(runs_dir).write_text(json.dumps(runs, indent=1))
return entry
def wet_run_allowed(program, machine, runs_dir=None, commissioning_record=None, test_panel=False, wall_id=None,
today=None, accept_sim=False):
"""Reasons a wet run of ``program`` must not start (empty list = allowed). ``test_panel``: the commissioning
test sheet, which needs everything but its own result."""
import commissioning
reasons = []
today = today or time.strftime("%Y-%m-%d")
env = program_envelope(program)
cuts = [r for r in load_runs(runs_dir) if r.get("dry_run") and r.get("completed") and (accept_sim or not r.get("sim"))
and r.get("machine") == machine.name]
same = any(r.get("hash") == program["hash"] for r in cuts)
# A touch-up is a new program every round; it may run without its own air-cut only if all of its motion lies
# inside what an air-cut of the same wall, with the same tool (another tool sticks out differently), on the same
# day (the base has not moved off it), already swept.
covered = wall_id is not None and any(r.get("wall_id") == wall_id and str(r.get("date", "")).startswith(today)
and r.get("tool") == program.get("tool")
and _inside(env, r.get("envelope") or {}) for r in cuts)
if not (same or covered):
reasons.append(f"no completed air-cut of this program ({program['hash']}) on {machine.name}, and none today of "
f"wall {wall_id!r} that contains its motion: run it with --dry-run first")
ready = commissioning.ready(machine.name, for_="test_panel" if test_panel else "wall", record=commissioning_record,
platform=machine.platform)
if not ready["ready"]:
reasons += [f"commissioning: {r}" for r in ready["missing"]]
return reasons
def as_run_job(job, run, machine):
"""The job the machine actually executed, from its status samples, in wall-plane mm for ``hardware.rasterize``.
A sample counts as tool-on when the controller reported the tool's output (A:F / A:S) or, for contact tools, when
Y was within 1 mm of working depth; samples taken in an air-cut never paint.
"""
reach = hardware.PLATFORMS[job["platform"]].reach_x_mm
contact = job["tool"]["contact"]
y_contact = (machine.y_wall_mm or 0.0) + (roller_press_mm(job["tool"]) if job["tool"]["name"] == "roller"
else machine.press_mm.get(job["tool"]["name"], 2.0))
commands = []
for s in run["samples"]:
if s.get("station") is None:
continue
on = (s["y"] >= y_contact - 1.0) if contact else bool(s.get("outputs"))
commands.append({"x": s["x"] - machine.x_origin_mm + s["station"] * reach, "y": s["z"] + machine.z_offset_mm, "t": s["t"],
"tool": job["tool"]["name"] if on else "travel", "paint": on and not run.get("dry_run")})
return {**job, "commands": commands, "as_run": True}
def main():
ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
sub = ap.add_subparsers(dest="cmd", required=True)
for name in ("gcode", "stream"):
p = sub.add_parser(name)
p.add_argument("--job", required=True, help="hardware.py --out job JSON")
p.add_argument("--machine", help="machine JSON (Machine fields); commissioning values are merged in")
p.add_argument("--dry-run", action="store_true", help="air-cut: all outputs off, contact tools held off the wall")
sub.choices["gcode"].add_argument("--out")
s = sub.choices["stream"]
s.add_argument("--port")
s.add_argument("--sim", action="store_true", help="stream to the simulated GRBL")
s.add_argument("--gate", help="safety_gate decision JSON for the wall (required to arm)")
s.add_argument("--runs-dir")
s.add_argument("--test-panel", action="store_true", help="this job is the commissioning test sheet")
s.add_argument("--watchdog-port", help="serial port of the pump watchdog board (firmware/pump_watchdog)")
s.add_argument("--operator", help="who is at the machine (arms the pump watchdog)")
a = ap.parse_args()
import commissioning
job = json.loads(Path(a.job).read_text())
machine = commissioning.machine_with_record(Machine.load(a.machine))
program = build_program(job, machine, dry_run=a.dry_run)
for w in program["warnings"]:
print("WARNING:", w)
if a.cmd == "gcode":
text = to_gcode(program)
if a.out:
Path(a.out).write_text(text)
print(f"{len(program['lines'])} lines -> {a.out} (program {program['hash']}{', air-cut' if a.dry_run else ''})")
else:
print(text)
return
wall_id = job["commands"][0].get("wall_id") if job["commands"] else None
if not a.dry_run:
reasons = wet_run_allowed(program, machine, a.runs_dir, test_panel=a.test_panel, wall_id=wall_id)
if not (a.watchdog_port or a.sim):
reasons.append("a wet run needs the pump watchdog board (--watchdog-port)")
if reasons:
print("refused:\n " + "\n ".join(reasons))
raise SystemExit(2)
decision = json.loads(Path(a.gate).read_text()) if a.gate else {"decision": "none", "reasons": ["no --gate decision"]}
width = max(c["x"] for c in job["commands"]) if job["commands"] else 0.0
height = max(c["y"] for c in job["commands"]) if job["commands"] else 0.0
sup = hardware.supervisor_for(width, height, job["platform"], limits={"heartbeat_timeout_s": machine.heartbeat_timeout_s})
sup.arm(decision, wall_id=job["commands"][0].get("wall_id") if job["commands"] else None, now=time.monotonic())
transport = (SimGrbl(home=(machine.x_travel_mm[0], machine.y_retract_mm, machine.z_travel_mm[0])) if a.sim
else SerialTransport(a.port))
def confirm(k, text):
return input(f"{text}\nType 'ok' when the base is parked and registered: ").strip().lower() == "ok"
import pump_watchdog
watchdog = None
if a.watchdog_port or (a.sim and not a.dry_run):
wd = pump_watchdog.SimWatchdog() if a.sim else SerialTransport(a.watchdog_port)
watchdog = pump_watchdog.WatchdogLink(wd)
watchdog.arm(a.operator or ("sim" if a.sim else ""))
run = Streamer(transport, sup, machine, job, on_station=(lambda k, t: True) if a.sim else confirm,
watchdog=watchdog, operator=a.operator or "sim").run(program)
if watchdog is not None and run["completed"]:
watchdog.pause()
entry = {"machine": machine.name, "hash": program["hash"], "dry_run": a.dry_run, "completed": run["completed"],
"wall_id": wall_id, "envelope": program_envelope(program), "tool": program["tool"],
"reason": run["reason"], "date": time.strftime("%Y-%m-%dT%H:%M:%S"), "sim": a.sim, "job": str(a.job),
"samples": len(run["samples"])}
save_run(entry, a.runs_dir)
print(json.dumps(entry, indent=1))
raise SystemExit(0 if run["completed"] else 1)
if __name__ == "__main__":
main()