| |
| """Play one offline open-loop policy trajectory on the real RM65. |
| |
| No closed-loop inference while the arm is moving. Episode frames are fed to the |
| checkpoint with overlapping windows, the absolute joint commands are blended and |
| saved, the arm movej's to that episode's first encoder pose, then the saved |
| commands are streamed at dataset fps. |
| |
| Does not start policy_server / play_action_rm65. Those would add a second |
| command path and the 0.12° rate limit. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import math |
| import os |
| import queue |
| import sys |
| import threading |
| import time |
| from pathlib import Path |
|
|
| import numpy as np |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| CKPT = ROOT / "smolvla_rm65_stack_30ep_s1000" |
| DS = ROOT / "datasets/cleaned/rm65_stacking_blocks" |
| OUT = ROOT / "outputs/diag/stack_30ep_offline" |
| DEG2RAD = math.pi / 180.0 |
|
|
|
|
| |
| |
| |
| STRIDE = 4 |
| DECAY = 0.05 |
| |
| SMOOTH_MAX_STEP_DEG = 1.0 |
|
|
|
|
| def traj_path(episode: int, stride: int = STRIDE) -> Path: |
| return OUT / f"ep{episode:03d}_s{stride}_openloop_smooth.npy" |
|
|
|
|
| def ensemble_weights(horizon: int, stride: int, decay: float = DECAY) -> np.ndarray: |
| if horizon < 1 or stride < 1: |
| raise ValueError(f"horizon={horizon} stride={stride}") |
| k = np.arange(horizon, dtype=np.float64) |
| fade_in = np.minimum(1.0, (k + 1.0) / float(stride)) |
| fade_out = np.minimum(1.0, (horizon - k) / float(stride)) |
| return np.exp(-float(decay) * k) * fade_in * fade_out |
|
|
|
|
| def blend_predictions( |
| chunks: list[tuple[int, np.ndarray]], |
| n: int, |
| weights: np.ndarray, |
| ) -> np.ndarray: |
| acc = np.zeros((n, 7), dtype=np.float64) |
| wsum = np.zeros(n, dtype=np.float64) |
| for t0, chunk in chunks: |
| take = min(len(weights), chunk.shape[0], n - t0) |
| if take <= 0: |
| continue |
| w = weights[:take] |
| acc[t0 : t0 + take] += chunk[:take].astype(np.float64) * w[:, None] |
| wsum[t0 : t0 + take] += w |
| missing = np.flatnonzero(wsum <= 0) |
| if missing.size: |
| raise RuntimeError(f"frames with no prediction: {missing[:8].tolist()}") |
| return (acc / wsum[:, None]).astype(np.float32) |
|
|
|
|
| def grip_hysteresis(values: np.ndarray, low: float = 0.35, high: float = 0.65) -> np.ndarray: |
| out = np.empty(len(values), dtype=np.float32) |
| state: float | None = None |
| for i, value in enumerate(values): |
| v = float(value) |
| if state is None: |
| state = 1.0 if v >= 0.5 else 0.0 |
| elif state >= 0.5: |
| if v <= low: |
| state = 0.0 |
| elif v >= high: |
| state = 1.0 |
| out[i] = state |
| return out |
|
|
|
|
| def spread_large_steps(joints: np.ndarray, max_step: float = SMOOTH_MAX_STEP_DEG) -> np.ndarray: |
| """Follow the blended joints, but never faster than max_step per frame. |
| |
| A leftover seam becomes a short ramp. Once the blended curve slows down, |
| the command catches the original pose again. |
| """ |
| out = np.empty((len(joints), joints.shape[1]), dtype=np.float64) |
| out[0] = joints[0] |
| cap = float(max_step) |
| for i in range(1, len(joints)): |
| delta = np.asarray(joints[i], dtype=np.float64) - out[i - 1] |
| out[i] = out[i - 1] + np.clip(delta, -cap, cap) |
| return out.astype(np.float32) |
|
|
|
|
| def _step_stats(joints: np.ndarray) -> str: |
| steps = np.abs(np.diff(joints, axis=0)).max(axis=1) |
| if steps.size == 0: |
| return "无步长" |
| return ( |
| f"中位 {float(np.median(steps)):.2f}° " |
| f"p95 {float(np.quantile(steps, 0.95)):.2f}° " |
| f"最大 {float(steps.max()):.2f}° " |
| f">1° {int(np.sum(steps > 1.0))}/{len(steps)}" |
| ) |
|
|
|
|
| def load_episode(episode: int) -> dict: |
| info = json.loads((DS / "meta/info.json").read_text()) |
| tasks = {} |
| for line in (DS / "meta/tasks.jsonl").read_text().splitlines(): |
| if line.strip(): |
| row = json.loads(line) |
| tasks[int(row["task_index"])] = row["task"] |
| pq = DS / info["data_path"].format(episode_chunk=0, episode_index=episode) |
| import pandas as pd |
|
|
| df = pd.read_parquet(pq) |
| return { |
| "state": np.stack(df["observation.state"].to_numpy()).astype(np.float32), |
| "action": np.stack(df["action"].to_numpy()).astype(np.float32), |
| "task_index": df["task_index"].to_numpy().astype(np.int64), |
| "tasks": tasks, |
| "info": info, |
| "n": len(df), |
| "fps": float(info["fps"]), |
| } |
|
|
|
|
| def read_video_frames(path: Path, indices: list[int]) -> dict[int, np.ndarray]: |
| import av |
|
|
| want = set(int(i) for i in indices) |
| out: dict[int, np.ndarray] = {} |
| container = av.open(str(path)) |
| for i, frame in enumerate(container.decode(video=0)): |
| if i in want: |
| out[i] = frame.to_ndarray(format="rgb24") |
| if len(out) == len(want): |
| break |
| container.close() |
| missing = want - set(out) |
| if missing: |
| raise FileNotFoundError(f"{path} missing frames {sorted(missing)[:8]}") |
| return out |
|
|
|
|
| def generate(episode: int, stride: int = STRIDE) -> np.ndarray: |
| import os |
|
|
| os.environ["HF_HUB_OFFLINE"] = "1" |
| os.environ["TRANSFORMERS_OFFLINE"] = "1" |
| os.environ["HF_DATASETS_OFFLINE"] = "1" |
| sys.path.insert(0, str(ROOT)) |
| import torch |
|
|
| from lerobot.common.policies.smolvla.modeling_smolvla import SmolVLAPolicy |
| from lerobot.configs.policies import PreTrainedConfig |
| from lerobot.scripts.server.rm65_ckpt import load_dataset_stats_from_ckpt, trim_stats_to_config |
|
|
| data = load_episode(episode) |
| info = data["info"] |
| n = data["n"] |
| config = PreTrainedConfig.from_pretrained(str(CKPT)) |
| if not getattr(config, "use_relative_actions", False): |
| raise RuntimeError("checkpoint use_relative_actions is false; refuse to invent q+dq") |
| stats = trim_stats_to_config(load_dataset_stats_from_ckpt(CKPT), config) |
| policy = SmolVLAPolicy.from_pretrained(str(CKPT), config=config, dataset_stats=stats or None) |
| device = torch.device("cuda" if torch.cuda.is_available() else "cpu") |
| policy.to(device) |
| policy.eval() |
| horizon = int(policy.config.n_action_steps) |
| if stride > horizon: |
| raise RuntimeError(f"stride {stride} is longer than the action horizon {horizon}") |
| weights = ensemble_weights(horizon, stride) |
| starts = list(range(0, n, stride)) |
| front = read_video_frames( |
| DS / info["video_path"].format(episode_chunk=0, episode_index=episode, video_key="observation.images.front"), |
| starts, |
| ) |
| astra = read_video_frames( |
| DS / info["video_path"].format(episode_chunk=0, episode_index=episode, video_key="observation.images.astra"), |
| starts, |
| ) |
| chunks: list[tuple[int, np.ndarray]] = [] |
| print( |
| f"开环生成 ep{episode:03d} {n} 帧 每 {stride} 帧推理一次 " |
| f"重叠 {horizon} 步 device={device} 此阶段机械臂不动", |
| flush=True, |
| ) |
| with torch.no_grad(): |
| for fi, t0 in enumerate(starts): |
| policy.reset() |
| state_np = data["state"][t0, :7].copy() |
| task = data["tasks"][int(data["task_index"][t0])] |
| batch = { |
| "task": task, |
| "observation.state": torch.from_numpy(state_np).unsqueeze(0).to(device), |
| "observation.images.camera1": _rgb(front[t0], torch).to(device), |
| "observation.images.camera2": _rgb(astra[t0], torch).to(device), |
| } |
| chunk = policy.predict_action_chunk(batch)[0].detach().float().cpu().numpy() |
| chunks.append((t0, chunk[:horizon])) |
| if fi % 10 == 0 or fi + 1 == len(starts): |
| print( |
| f" {fi + 1}/{len(starts)} f={t0} grip0={float(chunk[0, 6]):.0f}", |
| flush=True, |
| ) |
| del batch |
| if device.type == "cuda" and fi % 10 == 0: |
| torch.cuda.empty_cache() |
| blended = blend_predictions(chunks, n, weights) |
| print(f"重叠平均后 {_step_stats(blended[:, :6])}") |
| pred = blended.copy() |
| pred[:, :6] = spread_large_steps(blended[:, :6]) |
| pred[:, 6] = grip_hysteresis(blended[:, 6]) |
| if not np.isfinite(pred).all(): |
| raise RuntimeError("open-loop trajectory has NaN") |
| print(f"大步摊开后 {_step_stats(pred[:, :6])}") |
| OUT.mkdir(parents=True, exist_ok=True) |
| path = traj_path(episode, stride) |
| np.save(path, pred) |
| demo = data["action"][:, :6] |
| mae = float(np.abs(pred[:, :6] - demo).mean()) |
| print(f"已保存 {path}") |
| print(f"与该条演示动作的关节平均差 {mae:.2f}° 时长 {n / data['fps']:.1f}s @ {data['fps']:.0f}Hz") |
| return pred |
|
|
|
|
| def _rgb(img: np.ndarray, torch): |
| return torch.from_numpy(img).permute(2, 0, 1).float().unsqueeze(0) / 255.0 |
|
|
|
|
| class _LiveCameras: |
| """Grab both real cameras on side threads and store one JPEG per playback frame. |
| |
| The 20 Hz command loop only copies the latest frame into a queue. Encoding |
| happens off that loop, so a slow disk does not stall movej_canfd. |
| """ |
|
|
| def __init__(self, front_dev: int, astra_dev: int, width: int, height: int, live: Path): |
| self.front_dev = front_dev |
| self.astra_dev = astra_dev |
| self.width = width |
| self.height = height |
| self.live = live |
| self.front_dir = live / "front" |
| self.astra_dir = live / "astra" |
| self._q: queue.Queue = queue.Queue(maxsize=120) |
| self.saved = 0 |
| self.dropped = 0 |
| self.snaps = 0 |
| self.repeat_front = 0 |
| self.repeat_astra = 0 |
| self.miss_front = 0 |
| self.miss_astra = 0 |
| self._ticks: list[dict] = [] |
| self._prev_front_seq = -1 |
| self._prev_astra_seq = -1 |
| self._cams: list[_Grabber] = [] |
| self._writer: threading.Thread | None = None |
| self._closed = False |
|
|
| def start(self) -> None: |
| import cv2 |
|
|
| cv2.setNumThreads(1) |
| self.front_dir.mkdir(parents=True, exist_ok=True) |
| self.astra_dir.mkdir(parents=True, exist_ok=True) |
| for old in list(self.front_dir.glob("frame_*.jpg")) + list(self.astra_dir.glob("frame_*.jpg")): |
| old.unlink() |
| opened: list[_Grabber] = [] |
| try: |
| for dev in (self.front_dev, self.astra_dev): |
| opened.append(_Grabber(dev, self.width, self.height)) |
| except Exception: |
| for cam in opened: |
| cam.close() |
| raise |
| self._cams = opened |
| self._writer = threading.Thread(target=self._write_loop, name="live_jpeg", daemon=True) |
| self._writer.start() |
|
|
| def wait_ready(self, timeout_s: float = 3.0) -> None: |
| for cam in self._cams: |
| cam.wait_first(timeout_s) |
| shapes = [cam.shape() for cam in self._cams] |
| print( |
| f"相机已出图 front /dev/video{self.front_dev} {shapes[0]} " |
| f"astra /dev/video{self.astra_dev} {shapes[1]}" |
| ) |
|
|
| def snap(self, index: int) -> None: |
| self.snaps += 1 |
| front, front_seq = self._cams[0].snapshot() |
| astra, astra_seq = self._cams[1].snapshot() |
| if front is None: |
| self.miss_front += 1 |
| front = np.zeros((self.height, self.width, 3), np.uint8) |
| elif front_seq == self._prev_front_seq: |
| self.repeat_front += 1 |
| if astra is None: |
| self.miss_astra += 1 |
| astra = np.zeros((self.height, self.width, 3), np.uint8) |
| elif astra_seq == self._prev_astra_seq: |
| self.repeat_astra += 1 |
| self._prev_front_seq = front_seq |
| self._prev_astra_seq = astra_seq |
| self._ticks.append({"i": index, "front_seq": front_seq, "astra_seq": astra_seq}) |
| self._submit(self.front_dir / f"frame_{index:06d}.jpg", front) |
| self._submit(self.astra_dir / f"frame_{index:06d}.jpg", astra) |
|
|
| def _submit(self, path: Path, frame: np.ndarray) -> None: |
| try: |
| self._q.put_nowait((str(path), frame)) |
| except queue.Full: |
| self.dropped += 1 |
|
|
| def _write_loop(self) -> None: |
| import cv2 |
|
|
| while True: |
| item = self._q.get() |
| try: |
| if item is None: |
| return |
| path, frame = item |
| if cv2.imwrite(path, frame, [int(cv2.IMWRITE_JPEG_QUALITY), 90]): |
| self.saved += 1 |
| finally: |
| self._q.task_done() |
|
|
| def close(self) -> None: |
| if self._closed: |
| return |
| self._closed = True |
| for cam in self._cams: |
| cam.close() |
| if self._writer is not None: |
| self._q.put(None) |
| self._q.join() |
| self._writer.join(timeout=5.0) |
|
|
| def finish(self, episode: int, fps: float, front_video: Path, astra_video: Path) -> None: |
| compare = self.live / "compare.mp4" |
| meta = { |
| "episode": episode, |
| "fps": fps, |
| "width": self.width, |
| "height": self.height, |
| "front_device": self.front_dev, |
| "astra_device": self.astra_dev, |
| "snaps": self.snaps, |
| "jpegs_saved": self.saved, |
| "jpeg_queue_drops": self.dropped, |
| "repeat_front": self.repeat_front, |
| "repeat_astra": self.repeat_astra, |
| "miss_front": self.miss_front, |
| "miss_astra": self.miss_astra, |
| "alignment": ( |
| "live frame i is the camera image at the moment command i was published; " |
| "dataset frame i is the recorded episode image at the same index" |
| ), |
| "compare_layout": "top dataset-front | live-front; bottom dataset-astra | live-astra", |
| "front_video": str(front_video), |
| "astra_video": str(astra_video), |
| "compare_video": str(compare), |
| } |
| (self.live / "meta.json").write_text(json.dumps(meta, indent=2) + "\n") |
| (self.live / "ticks.json").write_text(json.dumps(self._ticks) + "\n") |
| n = _write_compare_video( |
| compare, front_video, astra_video, self.front_dir, self.astra_dir, self.snaps, fps, self.width, self.height |
| ) |
| print(f"真实画面 {self.front_dir} 和 {self.astra_dir}") |
| print(f"并排对比 {compare} （{n} 帧，上：前相机 数据|真实，下：Astra 数据|真实）") |
| if self.dropped or self.miss_front or self.miss_astra: |
| print( |
| f"警告: 丢帧 {self.dropped} 前相机空帧 {self.miss_front} Astra空帧 {self.miss_astra}", |
| file=sys.stderr, |
| ) |
|
|
|
|
| class _Grabber: |
| def __init__(self, index: int, width: int, height: int): |
| import cv2 |
|
|
| self.index = index |
| self.width = width |
| self.height = height |
| self._cv2 = cv2 |
| self.cap = cv2.VideoCapture(index, cv2.CAP_V4L2) |
| if not self.cap.isOpened(): |
| self.cap.release() |
| self.cap = cv2.VideoCapture(index) |
| if not self.cap.isOpened(): |
| raise RuntimeError(f"打不开 /dev/video{index}，机械臂不会动") |
| self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, float(width)) |
| self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, float(height)) |
| self.cap.set(cv2.CAP_PROP_BUFFERSIZE, 1) |
| self._lock = threading.Lock() |
| self._frame: np.ndarray | None = None |
| self._seq = 0 |
| self._stop = threading.Event() |
| self._th = threading.Thread(target=self._loop, name=f"cam{index}", daemon=True) |
| self._th.start() |
|
|
| def _loop(self) -> None: |
| while not self._stop.is_set(): |
| ok, frame = self.cap.read() |
| if not ok or frame is None: |
| time.sleep(0.005) |
| continue |
| if frame.shape[1] != self.width or frame.shape[0] != self.height: |
| frame = self._cv2.resize(frame, (self.width, self.height)) |
| with self._lock: |
| self._frame = frame |
| self._seq += 1 |
|
|
| def wait_first(self, timeout_s: float) -> None: |
| deadline = time.time() + timeout_s |
| while time.time() < deadline: |
| with self._lock: |
| if self._frame is not None: |
| return |
| time.sleep(0.02) |
| raise RuntimeError(f"/dev/video{self.index} 在 {timeout_s:.0f}s 内没有画面，机械臂不会动") |
|
|
| def shape(self) -> tuple[int, int]: |
| with self._lock: |
| if self._frame is None: |
| return (0, 0) |
| return (int(self._frame.shape[1]), int(self._frame.shape[0])) |
|
|
| def snapshot(self) -> tuple[np.ndarray | None, int]: |
| with self._lock: |
| if self._frame is None: |
| return None, self._seq |
| return self._frame.copy(), self._seq |
|
|
| def close(self) -> None: |
| self._stop.set() |
| self._th.join(timeout=1.0) |
| if self.cap is not None: |
| self.cap.release() |
| self.cap = None |
|
|
|
|
| def _write_compare_video( |
| path: Path, |
| front_video: Path, |
| astra_video: Path, |
| front_dir: Path, |
| astra_dir: Path, |
| n: int, |
| fps: float, |
| width: int, |
| height: int, |
| ) -> int: |
| import av |
| import cv2 |
|
|
| def rgb_frames(video: Path): |
| container = av.open(str(video)) |
| try: |
| for frame in container.decode(video=0): |
| yield frame.to_ndarray(format="rgb24") |
| finally: |
| container.close() |
|
|
| blank = np.zeros((height, width, 3), np.uint8) |
| writer = cv2.VideoWriter( |
| str(path), |
| cv2.VideoWriter_fourcc(*"mp4v"), |
| float(fps), |
| (width * 2, height * 2), |
| ) |
| if not writer.isOpened(): |
| raise RuntimeError(f"写不了对比视频 {path}") |
| written = 0 |
| try: |
| paired = zip(rgb_frames(front_video), rgb_frames(astra_video)) |
| for i, (front_rgb, astra_rgb) in enumerate(paired): |
| if i >= n: |
| break |
| live_front = cv2.imread(str(front_dir / f"frame_{i:06d}.jpg")) |
| live_astra = cv2.imread(str(astra_dir / f"frame_{i:06d}.jpg")) |
| if live_front is None: |
| live_front = blank |
| if live_astra is None: |
| live_astra = blank |
| if live_front.shape[1] != width or live_front.shape[0] != height: |
| live_front = cv2.resize(live_front, (width, height)) |
| if live_astra.shape[1] != width or live_astra.shape[0] != height: |
| live_astra = cv2.resize(live_astra, (width, height)) |
| data_front = cv2.cvtColor(front_rgb, cv2.COLOR_RGB2BGR) |
| data_astra = cv2.cvtColor(astra_rgb, cv2.COLOR_RGB2BGR) |
| if data_front.shape[1] != width or data_front.shape[0] != height: |
| data_front = cv2.resize(data_front, (width, height)) |
| if data_astra.shape[1] != width or data_astra.shape[0] != height: |
| data_astra = cv2.resize(data_astra, (width, height)) |
| _stamp(data_front, "dataset front") |
| _stamp(live_front, "live front") |
| _stamp(data_astra, "dataset astra") |
| _stamp(live_astra, "live astra") |
| canvas = np.concatenate( |
| [ |
| np.concatenate([data_front, live_front], axis=1), |
| np.concatenate([data_astra, live_astra], axis=1), |
| ], |
| axis=0, |
| ) |
| writer.write(canvas) |
| written += 1 |
| finally: |
| writer.release() |
| return written |
|
|
|
|
| def _stamp(img: np.ndarray, text: str) -> None: |
| import cv2 |
|
|
| cv2.rectangle(img, (0, 0), (210, 28), (0, 0, 0), -1) |
| cv2.putText(img, text, (6, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.55, (255, 255, 255), 1, cv2.LINE_AA) |
|
|
|
|
| def _refuse_other_commanders() -> None: |
| import subprocess |
|
|
| bad = ("play_action_rm65.py", "policy_server.py", "robot_client.py", "record_state_test.py") |
| out = subprocess.check_output(["ps", "-eo", "args"], text=True, errors="replace") |
| hit = [name for name in bad if name in out] |
| if hit: |
| raise RuntimeError( |
| "仍有进程会抢关节或夹爪 SDK: " |
| + ", ".join(hit) |
| + "。先停掉推理脚本再回放。" |
| ) |
|
|
|
|
| def play(episode: int, pred: np.ndarray, max_step_deg: float) -> None: |
| import rclpy |
| from rclpy.node import Node |
| from rclpy.qos import HistoryPolicy, QoSProfile, ReliabilityPolicy |
| from rm_ros_interfaces.msg import Jointpos |
|
|
| sys.path.insert(0, str(ROOT / "scripts")) |
| from rm65_ready import movej_ready |
|
|
| data = load_episode(episode) |
| fps = data["fps"] |
| start = data["state"][0, :6].astype(np.float64) |
| grip0 = float(data["state"][0, 6]) |
| print( |
| f"回放 ep{episode:03d} {len(pred)} 帧 {len(pred) / fps:.1f}s " |
| f"{_step_stats(pred[:, :6])} 安全限幅 {max_step_deg:.1f}°" |
| ) |
| print(f"先 movej 到该条数据第 0 帧: {[round(float(v), 2) for v in start]}") |
| front_shape = data["info"]["features"]["observation.images.front"]["shape"] |
| cam_h, cam_w = int(front_shape[0]), int(front_shape[1]) |
| front_dev = int(os.environ.get("FRONT_DEV", "0")) |
| astra_dev = int(os.environ.get("ASTRA_DEV", "2")) |
| video_path = data["info"]["video_path"] |
| front_video = DS / video_path.format( |
| episode_chunk=0, episode_index=episode, video_key="observation.images.front" |
| ) |
| astra_video = DS / video_path.format( |
| episode_chunk=0, episode_index=episode, video_key="observation.images.astra" |
| ) |
| print(f"打开真实相机 /dev/video{front_dev} 和 /dev/video{astra_dev}。打不开则不会动臂。") |
| recorder = _LiveCameras(front_dev, astra_dev, cam_w, cam_h, OUT / f"ep{episode:03d}_live") |
| recorder.start() |
| interrupted = False |
| clips = 0 |
| try: |
| recorder.wait_ready() |
| print(f"回放过程按帧保存到 {recorder.live}。Ctrl+C 停止。不启动策略服务。") |
| print("3 秒后开始运动。") |
| time.sleep(3.0) |
|
|
| _refuse_other_commanders() |
| rclpy.init() |
| try: |
| movej_ready(speed=5, joints_deg=start.tolist(), pose_path=Path(f"episode_{episode:03d}_frame0")) |
| except Exception: |
| if rclpy.ok(): |
| rclpy.shutdown() |
| raise |
|
|
| from sendrobot.send_robot.dahuan_gripper import DahuanGripperModbus |
| from sendrobot.send_robot.rm_ik import RM65Kinematics |
|
|
| class _Log: |
| def info(self, msg: str) -> None: |
| print(msg) |
|
|
| def warning(self, msg: str) -> None: |
| print("警告:", msg, file=sys.stderr) |
|
|
| kin = RM65Kinematics(ip="192.168.73.18", port=8080) |
| kin.connect() |
| grip = DahuanGripperModbus(kin.robot) |
| grip.setup(_Log()) |
| grip.set_position_normalized(grip0, min_delta=0.0) |
| print(f"夹爪设到数据起点 norm={grip0:.2f}") |
|
|
| node = Node("rm65_openloop_play") |
| qos = QoSProfile(depth=10, reliability=ReliabilityPolicy.RELIABLE, history=HistoryPolicy.KEEP_LAST) |
| pub = node.create_publisher(Jointpos, "/rm_driver/movej_canfd_cmd", qos) |
| deadline = time.time() + 3.0 |
| while pub.get_subscription_count() == 0 and time.time() < deadline: |
| rclpy.spin_once(node, timeout_sec=0.05) |
| if pub.get_subscription_count() == 0: |
| kin.disconnect() |
| node.destroy_node() |
| rclpy.shutdown() |
| raise RuntimeError("rm_driver 未订阅 movej_canfd_cmd") |
|
|
| last = start.copy() |
| dt = 1.0 / fps |
| t_next = time.perf_counter() |
| try: |
| for i, row in enumerate(pred): |
| cmd = row[:6].astype(np.float64).copy() |
| delta = cmd - last |
| over = np.abs(delta) > max_step_deg |
| if np.any(over): |
| clips += 1 |
| delta = np.clip(delta, -max_step_deg, max_step_deg) |
| cmd = last + delta |
| msg = Jointpos() |
| msg.joint = [float(v) * DEG2RAD for v in cmd] |
| msg.follow = True |
| msg.expand = 0.0 |
| msg.dof = 6 |
| pub.publish(msg) |
| rclpy.spin_once(node, timeout_sec=0.0) |
| recorder.snap(i) |
| g = float(row[6]) |
| if abs(g - grip0) >= 0.5: |
| grip.set_position_normalized(1.0 if g >= 0.5 else 0.0, min_delta=0.0) |
| grip0 = 1.0 if g >= 0.5 else 0.0 |
| last = cmd |
| t_next += dt |
| delay = t_next - time.perf_counter() |
| if delay > 0: |
| time.sleep(delay) |
| else: |
| t_next = time.perf_counter() |
| if i % int(fps) == 0: |
| print(f"t={i / fps:.0f}s {[round(float(v), 1) for v in cmd]} grip={grip0:.0f}", flush=True) |
| finally: |
| kin.disconnect() |
| node.destroy_node() |
| if rclpy.ok(): |
| rclpy.shutdown() |
| except KeyboardInterrupt: |
| interrupted = True |
| print("回放中断，正在把已录画面写完") |
| finally: |
| recorder.close() |
| print(f"回放结束 超限步数 {clips}/{len(pred)}") |
| if recorder.snaps: |
| recorder.finish(episode, fps, front_video, astra_video) |
| if interrupted: |
| raise SystemExit(130) |
|
|
|
|
| def main() -> None: |
| p = argparse.ArgumentParser(description="Replay one offline open-loop policy trajectory") |
| p.add_argument("--episode", type=int, default=0) |
| p.add_argument("--stride", type=int, default=STRIDE, help="每隔多少帧重新推理一次") |
| p.add_argument("--generate-only", action="store_true") |
| p.add_argument("--replay-only", action="store_true", help="使用已保存的 npy，不再推理") |
| p.add_argument( |
| "--max-step-deg", |
| type=float, |
| default=1.5, |
| help="回放安全限幅。平滑后单步应不超过 1°，这项只拦住意外大步", |
| ) |
| args = p.parse_args() |
| if args.stride < 1: |
| raise SystemExit("--stride 必须 >= 1") |
| path = traj_path(args.episode, args.stride) |
| if args.replay_only: |
| if not path.is_file(): |
| raise SystemExit(f"没有已保存轨迹: {path}") |
| pred = np.load(path) |
| elif path.is_file() and not args.generate_only: |
| print(f"使用已有轨迹 {path} （要重算请先删掉这个文件）") |
| pred = np.load(path) |
| else: |
| print("正在离线开环生成，此阶段机械臂不动") |
| pred = generate(args.episode, args.stride) |
| if args.generate_only: |
| return |
| play(args.episode, pred, args.max_step_deg) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
