| |
| """SONIC walks to the WalkGrab object on a planner reference, then reaches. |
| |
| The action term tracks the GEAR planner clip in SONIC's ``g1`` mode and hands |
| over to wrist teleop by itself, so this script just holds a neutral action |
| while it walks and then runs the same reach / close / lift schedule as the |
| standing manip smoke. |
| |
| Generate the reference first (matched to the object xy): |
| |
| ./jobs/gen_walk_reference.sh --target 1.5 -0.35 |
| ./jobs/sonic_walkgrab_play.sh --headless --video |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import os |
| import pathlib |
| import sys |
| import traceback |
|
|
| _PROJECT = pathlib.Path(__file__).resolve().parents[2] |
| _SIM_SRC = _PROJECT / "simulation" / "source" |
| if str(_SIM_SRC) not in sys.path: |
| sys.path.insert(0, str(_SIM_SRC)) |
|
|
| from isaaclab.app import AppLauncher |
|
|
| parser = argparse.ArgumentParser( |
| description="SONIC whole-body walk to the WalkGrab object, then wrist reach." |
| ) |
| parser.add_argument("--task", default="V2D-G1-SonicWalkGrab-Play-v0") |
| parser.add_argument( |
| "--clip", |
| default="20200709_141754_836212060125", |
| help="reconstruction/runs/<clip> whose exported object.urdf goes on the table.", |
| ) |
| parser.add_argument("--num_envs", type=int, default=1) |
| parser.add_argument("--max_steps", type=int, default=0, help="0 = one full episode.") |
| parser.add_argument("--video", action="store_true") |
| parser.add_argument( |
| "--video_length", |
| type=int, |
| default=0, |
| help="Recorded steps; 0 = whole run. Used when --video is set.", |
| ) |
| parser.add_argument( |
| "--reach-xy", |
| type=float, |
| default=None, |
| help="Override the pelvis-object xy range at which the term stops tracking the " |
| "planner reference and hands over to the wrist.", |
| ) |
| AppLauncher.add_app_launcher_args(parser) |
| args_cli = parser.parse_args() |
| os.environ["V2D_SONIC_WALKGRAB_CLIP"] = args_cli.clip |
| if args_cli.video: |
| args_cli.enable_cameras = True |
|
|
| app_launcher = AppLauncher(args_cli) |
| simulation_app = app_launcher.app |
|
|
| import gymnasium as gym |
| import torch |
| from isaaclab.utils.dict import print_dict |
| from isaaclab_tasks.utils import parse_env_cfg |
|
|
| import v2d_sim.tasks.g1_sonic_walkgrab |
|
|
| _GRAV, _WRIST, _OBJ, _DELTA = ( |
| slice(0, 3), |
| slice(3, 6), |
| slice(6, 9), |
| slice(9, 12), |
| ) |
|
|
|
|
| def _t(x): |
| return x.torch if hasattr(x, "torch") else x |
|
|
|
|
| def main() -> None: |
| env_cfg = parse_env_cfg(args_cli.task, device=args_cli.device, num_envs=args_cli.num_envs) |
| if args_cli.reach_xy is not None: |
| env_cfg.actions.wrist.arrive_xy = args_cli.reach_xy |
| env = gym.make( |
| args_cli.task, |
| cfg=env_cfg, |
| render_mode="rgb_array" if args_cli.video else None, |
| ) |
|
|
| episode_steps = int(env.unwrapped.max_episode_length) |
| n = args_cli.max_steps or episode_steps |
| video_length = args_cli.video_length or n |
| print( |
| f"[sonic-walkgrab] task={args_cli.task} clip={args_cli.clip} " |
| f"episode={episode_steps} running={n} recording={video_length}", |
| flush=True, |
| ) |
| print( |
| "[sonic-walkgrab] SONIC g1 mode tracks the GEAR planner walk reference, then " |
| f"hands over to wrist teleop inside {env_cfg.actions.wrist.arrive_xy:.2f} m pelvis xy.", |
| flush=True, |
| ) |
|
|
| if args_cli.video: |
| out_dir = _PROJECT / "simulation" / "runs" / "sonic_walkgrab" / args_cli.clip |
| out_dir.mkdir(parents=True, exist_ok=True) |
| video_kwargs = { |
| "video_folder": str(out_dir), |
| "step_trigger": lambda step: step == 0, |
| "video_length": video_length, |
| "disable_logger": True, |
| } |
| print("[sonic-walkgrab] recording video", flush=True) |
| print_dict(video_kwargs, nesting=4) |
| env = gym.wrappers.RecordVideo(env, **video_kwargs) |
|
|
| inner = env.unwrapped |
| wrist_term = inner.action_manager.get_term("wrist") |
| acfg = env_cfg.actions.wrist |
| lo = torch.tensor( |
| [acfg.wrist_x[0], acfg.wrist_y[0], acfg.wrist_z[0]], device=inner.device |
| ) |
| hi = torch.tensor( |
| [acfg.wrist_x[1], acfg.wrist_y[1], acfg.wrist_z[1]], device=inner.device |
| ) |
| center, half = (lo + hi) / 2.0, (hi - lo) / 2.0 |
|
|
| obs_dict, _ = env.reset() |
| obs = obs_dict["policy"] |
| robot = inner.scene["robot"] |
| obj = inner.scene["object"] |
| rest_z = float(env_cfg.scene.object.init_state.pos[2]) |
| n_env = inner.num_envs |
| reach_start = torch.full((n_env,), -1, device=inner.device, dtype=torch.long) |
|
|
| min_root_z = float("inf") |
| min_hand_obj = float("inf") |
| max_root_x = float("-inf") |
| max_lift = 0.0 |
| settle = 10 |
| obj_z0 = rest_z |
|
|
| hold = torch.zeros(n_env, 4, device=inner.device) |
| hold[:, 2] = 1.0 |
| hold[:, 3] = -1.0 |
|
|
| for step in range(n): |
| if not simulation_app.is_running(): |
| break |
| obj_xy = torch.linalg.norm(obs[:, _OBJ][:, :2], dim=1) |
| |
| |
| arrived = torch.as_tensor(~wrist_term.walking, device=inner.device) |
| reach_start[(reach_start < 0) & arrived] = step |
| in_reach = reach_start >= 0 |
| action = hold.clone() |
| if bool(in_reach.any()): |
| local = (step - reach_start.clamp(min=0)).float() |
| horizon = max(1.0, float(n - int(reach_start[in_reach].min()))) |
| frac = (local / horizon).clamp(0.0, 1.0) |
| want = obs[:, _OBJ].clone() |
| want[:, 2] = want[:, 2] + 0.06 * (1.0 - frac) |
| want[:, 2] = want[:, 2] + torch.where( |
| frac > 0.60, 0.12 * (frac - 0.60) / 0.40, torch.zeros_like(frac) |
| ) |
| grip = torch.where( |
| frac < 0.45, |
| torch.full_like(frac, -1.0), |
| torch.where( |
| frac < 0.60, |
| -1.0 + 2.0 * (frac - 0.45) / 0.15, |
| torch.ones_like(frac), |
| ), |
| ) |
| a = torch.clamp((want - center) / half, -1.0, 1.0) |
| reach_action = torch.cat([a, grip.unsqueeze(-1)], dim=1) |
| action[in_reach] = reach_action[in_reach] |
| obs_dict, _, terminated, truncated, _ = env.step(action) |
| obs = obs_dict["policy"] |
|
|
| root = _t(robot.data.root_pos_w)[0] |
| obj_pos = _t(obj.data.root_pos_w)[0] |
| min_root_z = min(min_root_z, float(root[2])) |
| max_root_x = max(max_root_x, float(root[0])) |
| if step == settle: |
| obj_z0 = float(obj_pos[2]) |
| max_lift = max(max_lift, float(obj_pos[2]) - obj_z0) |
| hand_obj = float(torch.linalg.norm(obs[0, _DELTA])) |
| min_hand_obj = min(min_hand_obj, hand_obj) |
| if step % 50 == 0 or step == n - 1: |
| mode = "reach" if bool(in_reach[0]) else "walk" |
| print( |
| f" step {step}/{n} {mode} root_xy=({float(root[0]):.3f},{float(root[1]):.3f}) " |
| f"root_z={float(root[2]):.3f} object_xy=({float(obj_pos[0]):.3f},{float(obj_pos[1]):.3f}) " |
| f"pelvis-obj_xy={float(obj_xy[0]):.3f} hand-obj={hand_obj:.3f} " |
| f"done={int(bool(terminated[0] or truncated[0]))}", |
| flush=True, |
| ) |
|
|
| print(f"[sonic-walkgrab] min root_z={min_root_z:.3f} max root_x={max_root_x:.3f}", flush=True) |
| print(f"[sonic-walkgrab] min hand-object (pelvis frame)={min_hand_obj:.3f} m", flush=True) |
| print(f"[sonic-walkgrab] peak object lift above rest={max_lift:+.3f} m", flush=True) |
| env.close() |
|
|
|
|
| if __name__ == "__main__": |
| code = 0 |
| try: |
| main() |
| except Exception: |
| traceback.print_exc() |
| code = 1 |
| finally: |
| simulation_app.close() |
| os._exit(code) |
|
|
