"""Tic-tac-toe robot server: JSON lines over TCP. Runs in the Isaac Lab venv (strands_robots on PYTHONPATH). --mock : pure numpy backend (teleports tokens, synthetic top-down renders) — CPU only, no Kit. default: Isaac Lab backend (ttt_isaac.IsaacBackend) — Franka + DiffIK pick/place, RTX cameras. Requests (one JSON object per line) -> one JSON reply per line: {"cmd":"ping"} -> {"ok":true,"backend":...} {"cmd":"reset"} -> tokens back to trays, robot home, board {"cmd":"state"} -> {"board":[9], "vision":{...}, "tokens":[...]} {"cmd":"place","mark":"X","cell":0,"task":"..."} -> {"ok","grasp_ok","place_err_m","cell_detected",...} {"cmd":"render","path":"/x/y"} -> writes _overhead.png, _front.png {"cmd":"record_open","root":..,"repo_id":..} -> strands DatasetRecorder (1 place = 1 episode) {"cmd":"record_close"} -> finalize {"cmd":"video_open","path":"x.mp4","every":2} / {"cmd":"video_close"} -> overhead|front side-by-side {"cmd":"shutdown"} """ from __future__ import annotations import argparse import json import os import socket import sys import time import traceback HERE = os.path.dirname(os.path.abspath(__file__)) sys.path.insert(0, HERE) import numpy as np # noqa: E402 import ttt_game as G # noqa: E402 import ttt_vision as V # noqa: E402 JOINTS = [f"panda_joint{i}" for i in range(1, 8)] + ["panda_finger_joint1", "panda_finger_joint2"] ACTIONS = [f"target.{j}" for j in JOINTS] class Recorder: """strands DatasetRecorder wrapper: one pick-place move = one episode.""" def __init__(self, root: str, repo_id: str, fps: int, cams: dict[str, tuple[int, int]]): import shutil from strands_robots.dataset_recorder import DatasetRecorder shutil.rmtree(root, ignore_errors=True) os.makedirs(os.path.dirname(os.path.abspath(root)), exist_ok=True) self.cams = list(cams) self.rec = DatasetRecorder.create( repo_id=repo_id, fps=fps, robot_type="franka_panda", joint_names=JOINTS, action_names=ACTIONS, camera_keys=self.cams, camera_dims=cams, extra_state_specs=[("ee_pos", ["x", "y", "z"]), ("gripper_cmd", ["close"]), ("board", [f"{c}.{m}" for c in G.CELL_NAMES for m in ("X", "O")])], task="play tic-tac-toe", root=root, use_videos=True, overwrite=True, ) self.root, self.repo_id, self.episodes, self.frames = root, repo_id, 0, 0 self.buf: list = [] def frame(self, q, target, ee, grip, board, imgs, task): ob = {n: float(q[k]) for k, n in enumerate(JOINTS)} oh = np.zeros(18, np.float32) for i, v in enumerate(board): if v == "X": oh[2 * i] = 1 elif v == "O": oh[2 * i + 1] = 1 ob.update(ee_pos=np.asarray(ee, np.float32), gripper_cmd=np.asarray([grip], np.float32), board=oh) ob.update({k: imgs[k] for k in self.cams}) self.buf.append((ob, {n: float(target[k]) for k, n in enumerate(ACTIONS)}, task)) def end_episode(self, keep: bool = True): if keep and self.buf: for ob, ac, task in self.buf: self.rec.add_frame(ob, ac, task=task, camera_keys=self.cams) self.rec.save_episode() self.episodes += 1 self.frames += len(self.buf) self.buf = [] def close(self): self.rec.finalize() return {"root": self.root, "episodes": self.episodes, "frames": self.frames} class Video: def __init__(self, path: str, fps: int, every: int = 2): import imageio.v2 as iio os.makedirs(os.path.dirname(os.path.abspath(path)), exist_ok=True) self.w = iio.get_writer(path, fps=max(1, fps // every), codec="libx264", quality=7, macro_block_size=8) self.every, self.n, self.path = every, 0, path def frame(self, imgs): if self.n % self.every == 0: self.w.append_data(np.concatenate([imgs["overhead"], imgs["front"]], 1)) self.n += 1 def close(self): self.w.close() return {"path": self.path, "frames": self.n // self.every} # ----------------------------------------------------------------------------- mock backend (CPU) class MockBackend: """No physics: tokens teleport with a small random placement error; images are synthetic top-down.""" name = "mock" fps = 30 def __init__(self, width=320, height=240, seed=0): self.W, self.H = width, height self.rng = np.random.default_rng(seed) self.hooks: list = [] self.reset() def tray_xy(self, mark, k): return (0.35 + 0.07 * k, 0.28 if mark == "X" else -0.28) def reset(self): self.tokens = [{"mark": m, "k": k, "xy": list(self.tray_xy(m, k)), "z": 0.02, "used": False} for m in ("X", "O") for k in range(5)] self.q = np.array([0, -0.569, 0, -2.81, 0, 3.037, 0.741, 0.04, 0.04]) return {"board": self.board()} def board(self): b = [" "] * 9 for t in self.tokens: c = G.xy_to_cell(*t["xy"]) if t["z"] < 0.05 else None if c is not None: b[c] = t["mark"] if b[c] == " " else "?" return b # world(x,y) -> overhead pixel (image top = +x, image left = +y), 1.0 m wide view centred at (0.5, 0) def px(self, x, y): s = self.W / 0.9 return (self.W / 2 - (y - 0.0) * s, self.H / 2 - (x - 0.5) * s) def cell_px(self): return [self.px(*G.cell_xy(i)) for i in range(9)] def images(self): im = np.full((self.H, self.W, 3), 170, np.uint8) s = self.W / 0.9 for i in range(9): u, v = self.px(*G.cell_xy(i)) h = 0.085 * s / 2 im[int(v - h):int(v + h), int(u - h):int(u + h)] = 225 for t in self.tokens: u, v = self.px(*t["xy"]) h = 0.02 * s col = (200, 30, 30) if t["mark"] == "X" else (30, 60, 210) im[max(0, int(v - h)):int(v + h), max(0, int(u - h)):int(u + h)] = col return {"overhead": im, "front": im[::-1, ::-1].copy()} def place(self, mark, cell, task, frame_cb): tok = next((t for t in self.tokens if t["mark"] == mark and not t["used"]), None) if tok is None: return {"ok": False, "error": f"no {mark} tokens left"} cx, cy = G.cell_xy(cell) start = np.array(tok["xy"]) err = self.rng.normal(0, 0.004, 2) goal = np.array([cx, cy]) + err for f in range(30): a = (f + 1) / 30 tok["xy"] = list(start + (goal - start) * a) tok["z"] = 0.02 + 0.1 * np.sin(np.pi * a) self.q = self.q + 0.01 * np.sin(f / 5) frame_cb(self.q, self.q, [tok["xy"][0], tok["xy"][1], tok["z"] + 0.1], float(0 < f < 29), self.images()) tok["z"], tok["used"] = 0.02, True e = float(np.hypot(*(np.array(tok["xy"]) - [cx, cy]))) return {"ok": True, "grasp_ok": True, "place_err_m": round(e, 4), "token_xy": tok["xy"], "sim_s": 1.0, "frames": 30, "attempts": 1} # ----------------------------------------------------------------------------- server loop def serve(backend, port: int, log): rec: Recorder | None = None vid: Video | None = None srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM) srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) srv.bind(("127.0.0.1", port)) srv.listen(4) log(f"READY port={port} backend={backend.name}") print(f"[ttt] READY port={port}", flush=True) def observe(): imgs = backend.images() vis = V.classify(imgs["overhead"], backend.cell_px()) return imgs, vis def handle(req): nonlocal rec, vid cmd = req.get("cmd") if cmd == "ping": return {"ok": True, "backend": backend.name, "fps": backend.fps} if cmd == "reset": r = backend.reset() return {"ok": True, **r} if cmd == "state": imgs, vis = observe() b = backend.board() return {"ok": True, "board": b, "vision": vis, "agree": vis["board"] == b, "status": G.status(b)} if cmd == "place": mark, cell = req["mark"], int(req["cell"]) b0 = backend.board() if b0[cell] != " ": return {"ok": False, "error": f"cell {G.CELL_NAMES[cell]} is occupied by {b0[cell]}"} task = req.get("task") or f"place {mark} in the {G.CELL_NAMES[cell]} cell" t0 = time.time() def frame_cb(q, target, ee, grip, imgs): if rec is not None: rec.frame(q, target, ee, grip, b0, imgs, task) if vid is not None: vid.frame(imgs) r = backend.place(mark, cell, task, frame_cb) b1 = backend.board() imgs, vis = observe() det = b1[cell] r.update(cell=cell, cell_name=G.CELL_NAMES[cell], cell_detected=det, board=b1, vision=vis, agree=vis["board"] == b1, wall_s=round(time.time() - t0, 2), task=task) r["success"] = bool(r.get("ok") and det == mark and sum(x != y for x, y in zip(b0, b1)) == 1) if rec is not None: rec.end_episode(keep=bool(r.get("ok"))) return r if cmd == "render": import imageio.v2 as iio imgs, vis = observe() p = req["path"] os.makedirs(os.path.dirname(os.path.abspath(p)), exist_ok=True) for k, im in imgs.items(): iio.imwrite(f"{p}_{k}.png", im) return {"ok": True, "files": [f"{p}_{k}.png" for k in imgs], "vision": vis, "board": backend.board()} if cmd == "record_open": rec = Recorder(req["root"], req.get("repo_id", "local/ttt"), backend.fps, {k: v.shape[:2] for k, v in backend.images().items()}) return {"ok": True} if cmd == "record_close": out = rec.close() if rec else None rec = None return {"ok": True, "recorder": out} if cmd == "video_open": vid = Video(req["path"], backend.fps, int(req.get("every", 2))) return {"ok": True} if cmd == "video_close": out = vid.close() if vid else None vid = None return {"ok": True, "video": out} if cmd == "debug" and hasattr(backend, "debug"): return {"ok": True, **backend.debug(req)} if cmd == "shutdown": return {"ok": True, "bye": True} return {"ok": False, "error": f"unknown cmd {cmd!r}"} while True: conn, _ = srv.accept() f = conn.makefile("rwb") try: for line in f: req = json.loads(line) try: rep = handle(req) except Exception as e: # noqa: BLE001 rep = {"ok": False, "error": f"{type(e).__name__}: {e}", "tb": traceback.format_exc()[-2000:]} log(json.dumps({"req": req, "rep": {k: v for k, v in rep.items() if k != "vision"}}, default=str)[:3000]) f.write((json.dumps(rep, default=lambda o: o.tolist() if hasattr(o, "tolist") else str(o)) + "\n").encode()) f.flush() if rep.get("bye"): if rec: rec.close() if vid: vid.close() conn.close() return except (ConnectionResetError, BrokenPipeError): pass finally: try: conn.close() except Exception: # noqa: BLE001 pass def main(): ap = argparse.ArgumentParser() ap.add_argument("--port", type=int, default=8765) ap.add_argument("--mock", action="store_true") ap.add_argument("--log", default=os.path.join(HERE, "..", "runs", "server.log")) ap.add_argument("--width", type=int, default=320) ap.add_argument("--height", type=int, default=240) a, rest = ap.parse_known_args() lf = open(a.log, "a", buffering=1) def log(s): lf.write(f"{time.strftime('%H:%M:%S')} {s}\n") if a.mock: serve(MockBackend(a.width, a.height), a.port, log) else: import ttt_isaac ttt_isaac.run(a, rest, lambda backend: serve(backend, a.port, log), log) if __name__ == "__main__": main()