#!/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("= 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()