simulation/modules/IsaacLab/scripts/demos/haply_teleoperation.py

# Copyright (c) 2022-2026, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
# All rights reserved.
#
# SPDX-License-Identifier: BSD-3-Clause

"""
Demonstration of Haply device teleoperation with a robotic arm.

This script demonstrates how to use a Haply device (Inverse3 + VerseGrip) to
teleoperate a robotic arm in Isaac Lab. The Haply provides:
- Position tracking from the Inverse3 device
- Orientation and button inputs from the VerseGrip device
- Force feedback

.. code-block:: bash

    # Usage
    ./isaaclab.sh -p scripts/demos/haply_teleoperation.py

    # With custom WebSocket URI
    ./isaaclab.sh -p scripts/demos/haply_teleoperation.py --websocket_uri ws://localhost:10001

    # With sensitivity adjustment
    ./isaaclab.sh -p scripts/demos/haply_teleoperation.py --pos_sensitivity 2.0

Prerequisites:
    1. Install websockets package: pip install websockets
    2. Have Haply SDK running and accessible via WebSocket
    3. Connect Inverse3 and VerseGrip devices
"""

"""Launch Isaac Sim Simulator first."""

import argparse

from isaaclab.app import AppLauncher

# add argparse arguments
parser = argparse.ArgumentParser(description="Demonstration of Haply device teleoperation with Isaac Lab.")
parser.add_argument("--num_envs", type=int, default=1, help="Number of environments to spawn.")
parser.add_argument(
    "--websocket_uri",
    type=str,
    default="ws://localhost:10001",
    help="WebSocket URI for Haply SDK connection.",
)
parser.add_argument(
    "--pos_sensitivity",
    type=float,
    default=1.0,
    help="Position sensitivity scaling factor.",
)

AppLauncher.add_app_launcher_args(parser)
parser.set_defaults(visualizer=["kit"])
args_cli = parser.parse_args()
app_launcher = AppLauncher(args_cli)
simulation_app = app_launcher.app

import numpy as np
import torch

import isaaclab.sim as sim_utils
from isaaclab.assets import Articulation, AssetBaseCfg, RigidObject, RigidObjectCfg
from isaaclab.controllers import DifferentialIKController, DifferentialIKControllerCfg
from isaaclab.devices import HaplyDevice, HaplyDeviceCfg
from isaaclab.scene import InteractiveScene, InteractiveSceneCfg
from isaaclab.sensors import ContactSensor, ContactSensorCfg
from isaaclab.utils.assets import ISAAC_NUCLEUS_DIR
from isaaclab.utils.configclass import configclass

from isaaclab_assets import FRANKA_PANDA_HIGH_PD_CFG  # isort: skip

# Workspace mapping constants
HAPLY_Z_OFFSET = 0.35
WORKSPACE_LIMITS = {
    "x": (0.1, 0.9),
    "y": (-0.50, 0.50),
    "z": (1.05, 1.85),
}


def apply_haply_to_robot_mapping(
    haply_pos: np.ndarray | torch.Tensor,
    haply_initial_pos: np.ndarray | list,
    robot_initial_pos: np.ndarray | torch.Tensor,
) -> np.ndarray:
    """Apply coordinate mapping from Haply workspace to Franka Panda end-effector.

    Uses absolute position control: robot position = robot_initial_pos + haply_pos (transformed)

    Args:
        haply_pos: Current Haply absolute position [x, y, z] in meters
        haply_initial_pos: Haply's zero reference position [x, y, z]
        robot_initial_pos: Base offset for robot end-effector

    Returns:
        robot_pos: Target position for robot EE in world frame [x, y, z]

    """
    # Convert to numpy
    if isinstance(haply_pos, torch.Tensor):
        haply_pos = haply_pos.cpu().numpy()
    if isinstance(robot_initial_pos, torch.Tensor):
        robot_initial_pos = robot_initial_pos.cpu().numpy()

    haply_delta = haply_pos - haply_initial_pos

    # Coordinate system mapping: Haply (X, Y, Z) -> Robot (-Y, X, Z-offset)
    robot_offset = np.array([-haply_delta[1], haply_delta[0], haply_delta[2] - HAPLY_Z_OFFSET])
    robot_pos = robot_initial_pos + robot_offset

    # Apply workspace limits for safety
    robot_pos[0] = np.clip(robot_pos[0], WORKSPACE_LIMITS["x"][0], WORKSPACE_LIMITS["x"][1])
    robot_pos[1] = np.clip(robot_pos[1], WORKSPACE_LIMITS["y"][0], WORKSPACE_LIMITS["y"][1])
    robot_pos[2] = np.clip(robot_pos[2], WORKSPACE_LIMITS["z"][0], WORKSPACE_LIMITS["z"][1])

    return robot_pos


@configclass
class FrankaHaplySceneCfg(InteractiveSceneCfg):
    """Configuration for Franka scene with Haply teleoperation and contact sensors."""

    ground = AssetBaseCfg(
        prim_path="/World/defaultGroundPlane",
        spawn=sim_utils.GroundPlaneCfg(),
    )

    dome_light = AssetBaseCfg(
        prim_path="/World/Light",
        spawn=sim_utils.DomeLightCfg(intensity=3000.0, color=(0.75, 0.75, 0.75)),
    )

    table = AssetBaseCfg(
        prim_path="{ENV_REGEX_NS}/Table",
        spawn=sim_utils.UsdFileCfg(
            usd_path=f"{ISAAC_NUCLEUS_DIR}/Props/Mounts/SeattleLabTable/table_instanceable.usd",
            scale=(1.0, 1.0, 1.0),
        ),
        init_state=AssetBaseCfg.InitialStateCfg(pos=(0.50, 0.0, 1.05), rot=(0.707, 0, 0, 0.707)),
    )

    robot: Articulation = FRANKA_PANDA_HIGH_PD_CFG.replace(prim_path="{ENV_REGEX_NS}/Robot")
    robot.init_state.pos = (-0.02, 0.0, 1.05)
    robot.spawn.activate_contact_sensors = True

    cube = RigidObjectCfg(
        prim_path="{ENV_REGEX_NS}/Cube",
        spawn=sim_utils.CuboidCfg(
            size=(0.06, 0.06, 0.06),
            rigid_props=sim_utils.RigidBodyPropertiesCfg(),
            mass_props=sim_utils.MassPropertiesCfg(mass=0.5),
            collision_props=sim_utils.CollisionPropertiesCfg(),
            physics_material=sim_utils.RigidBodyMaterialCfg(static_friction=0.5, dynamic_friction=0.5),
            visual_material=sim_utils.PreviewSurfaceCfg(diffuse_color=(0.2, 0.8, 0.2), metallic=0.2),
        ),
        init_state=RigidObjectCfg.InitialStateCfg(pos=(0.60, 0.00, 1.15)),
    )

    left_finger_contact_sensor = ContactSensorCfg(
        prim_path="{ENV_REGEX_NS}/Robot/panda_leftfinger",
        update_period=0.0,
        history_length=3,
        debug_vis=True,
        track_pose=True,
    )

    right_finger_contact_sensor = ContactSensorCfg(
        prim_path="{ENV_REGEX_NS}/Robot/panda_rightfinger",
        update_period=0.0,
        history_length=3,
        debug_vis=True,
        track_pose=True,
    )


def run_simulator(
    sim: sim_utils.SimulationContext,
    scene: InteractiveScene,
    haply_device: HaplyDevice,
):
    """Runs the simulation loop with Haply teleoperation."""
    sim_dt = sim.get_physics_dt()
    count = 1

    robot: Articulation = scene["robot"]
    cube: RigidObject = scene["cube"]
    left_finger_sensor: ContactSensor = scene["left_finger_contact_sensor"]
    right_finger_sensor: ContactSensor = scene["right_finger_contact_sensor"]

    ee_body_name = "panda_hand"
    ee_body_idx = robot.body_names.index(ee_body_name)
    # ``body_link_jacobian_w`` drops the fixed-root body row for fixed-base assets,
    # so the Jacobian-axis body index is ``body_idx - 1`` in that case.
    ee_jacobi_body_idx = ee_body_idx - 1 if robot.is_fixed_base else ee_body_idx

    joint_pos = robot.data.default_joint_pos.torch.clone()
    joint_pos[0, :7] = torch.tensor([0.0, -0.569, 0.0, -2.81, 0.0, 3.037, 0.741], device=robot.device)
    joint_vel = robot.data.default_joint_vel.torch.clone()
    robot.write_joint_position_to_sim_index(position=joint_pos)
    robot.write_joint_velocity_to_sim_index(velocity=joint_vel)

    for _ in range(10):
        scene.write_data_to_sim()
        sim.step()
        scene.update(sim_dt)

    # Initialize the position of franka
    robot_initial_pos = robot.data.body_pos_w.torch[0, ee_body_idx].cpu().numpy()
    haply_initial_pos = np.array([0.0, 0.0, 0.0], dtype=np.float32)

    ik_controller_cfg = DifferentialIKControllerCfg(
        command_type="position",
        use_relative_mode=False,
        ik_method="dls",
        ik_params={"lambda_val": 0.05},
    )

    # IK joints control arms, buttons control ee rotation and gripper open/close
    arm_joint_names = [
        "panda_joint1",
        "panda_joint2",
        "panda_joint3",
        "panda_joint4",
        "panda_joint5",
        "panda_joint6",
    ]
    arm_joint_indices = [robot.joint_names.index(name) for name in arm_joint_names]

    # Initialize IK controller
    ik_controller = DifferentialIKController(cfg=ik_controller_cfg, num_envs=scene.num_envs, device=sim.device)
    initial_ee_quat = robot.data.body_quat_w.torch[:, ee_body_idx]
    ik_controller.set_command(command=torch.zeros(scene.num_envs, 3, device=sim.device), ee_quat=initial_ee_quat)

    prev_button_a = False
    prev_button_b = False
    prev_button_c = False
    gripper_target = 0.04

    # Initialize the rotation of franka end-effector
    ee_rotation_angle = robot.data.joint_pos.torch[0, 6].item()
    rotation_step = np.pi / 3

    print("\n[INFO] Teleoperation ready!")
    print("  Move handler: Control pose of the end-effector")
    print("  Button A: Open | Button B: Close | Button C: Rotate EE (60°)\n")

    while simulation_app.is_running():
        if count % 10000 == 0:
            count = 1
            root_pose = robot.data.default_root_pose.torch.clone()
            root_pose[:, :3] += scene.env_origins
            robot.write_root_pose_to_sim_index(root_pose=root_pose)
            root_vel = robot.data.default_root_vel.torch.clone()
            robot.write_root_velocity_to_sim_index(root_velocity=root_vel)

            joint_pos = robot.data.default_joint_pos.torch.clone()
            joint_pos[0, :7] = torch.tensor([0.0, -0.569, 0.0, -2.81, 0.0, 3.037, 0.741], device=robot.device)
            joint_vel = robot.data.default_joint_vel.torch.clone()
            robot.write_joint_position_to_sim_index(position=joint_pos)
            robot.write_joint_velocity_to_sim_index(velocity=joint_vel)

            cube_pose = cube.data.default_root_pose.torch.clone()
            cube_pose[:, :3] += scene.env_origins
            cube.write_root_pose_to_sim_index(root_pose=cube_pose)
            cube_vel = cube.data.default_root_vel.torch.clone()
            cube.write_root_velocity_to_sim_index(root_velocity=cube_vel)

            scene.reset()
            haply_device.reset()
            ik_controller.reset()
            print("[INFO]: Resetting robot state...")

        # Get the data from Haply device
        haply_data = haply_device.advance()

        haply_pos = haply_data[:3]
        button_a = haply_data[7].item() > 0.5
        button_b = haply_data[8].item() > 0.5
        button_c = haply_data[9].item() > 0.5

        if button_a and not prev_button_a:
            gripper_target = 0.04  # Open gripper
        if button_b and not prev_button_b:
            gripper_target = 0.0  # Close gripper
        if button_c and not prev_button_c:
            joint_7_limit = 3.0
            ee_rotation_angle += rotation_step

            if ee_rotation_angle > joint_7_limit:
                ee_rotation_angle = -joint_7_limit + (ee_rotation_angle - joint_7_limit)
            elif ee_rotation_angle < -joint_7_limit:
                ee_rotation_angle = joint_7_limit + (ee_rotation_angle + joint_7_limit)

        prev_button_a = button_a
        prev_button_b = button_b
        prev_button_c = button_c

        # Compute IK
        target_pos = apply_haply_to_robot_mapping(
            haply_pos,
            haply_initial_pos,
            robot_initial_pos,
        )

        target_pos_tensor = torch.tensor(target_pos, dtype=torch.float32, device=sim.device).unsqueeze(0)

        current_joint_pos = robot.data.joint_pos.torch[:, arm_joint_indices]
        ee_pos_w = robot.data.body_pos_w.torch[:, ee_body_idx]
        ee_quat_w = robot.data.body_quat_w.torch[:, ee_body_idx]

        # get jacobian to IK controller. The DoF axis prepends ``num_base_dofs``
        # floating-base columns (0 for fixed-base, 6 for floating-base); shift the
        # actuated-joint ids by ``num_base_dofs`` to address the actuated columns.
        jacobi_joint_ids = [j + robot.num_base_dofs for j in arm_joint_indices]
        jacobian = robot.data.body_link_jacobian_w.torch[:, ee_jacobi_body_idx, :, jacobi_joint_ids]
        ik_controller.set_command(command=target_pos_tensor, ee_quat=ee_quat_w)
        joint_pos_des = ik_controller.compute(ee_pos_w, ee_quat_w, jacobian, current_joint_pos)

        joint_pos_target = robot.data.joint_pos.torch[0].clone()

        # Update joints: 6 from IK + 1 from button control (correct by design)
        joint_pos_target[arm_joint_indices] = joint_pos_des[0]  # panda_joint1-6 from IK
        joint_pos_target[6] = ee_rotation_angle  # panda_joint7 - end-effector rotation (button C)
        joint_pos_target[[-2, -1]] = gripper_target  # gripper

        robot.set_joint_position_target_index(target=joint_pos_target.unsqueeze(0))

        for _ in range(5):
            scene.write_data_to_sim()
            sim.step()

        scene.update(sim_dt)
        count += 1

        # get contact forces and apply force feedback
        left_finger_forces = left_finger_sensor.data.net_forces_w[0, 0]
        right_finger_forces = right_finger_sensor.data.net_forces_w[0, 0]
        total_contact_force = (left_finger_forces + right_finger_forces) * 0.5
        haply_device.push_force(forces=total_contact_force.unsqueeze(0), position=torch.tensor([0]))


def main():
    """Main function to set up and run the Haply teleoperation demo."""
    sim_cfg = sim_utils.SimulationCfg(device=args_cli.device, dt=1 / 200)
    sim = sim_utils.SimulationContext(sim_cfg)

    # set the simulation view
    sim.set_camera_view([1.6, 1.0, 1.70], [0.4, 0.0, 1.0])

    scene_cfg = FrankaHaplySceneCfg(num_envs=args_cli.num_envs, env_spacing=2.0)
    scene = InteractiveScene(scene_cfg)

    # Create Haply device
    haply_cfg = HaplyDeviceCfg(
        websocket_uri=args_cli.websocket_uri,
        pos_sensitivity=args_cli.pos_sensitivity,
        sim_device=args_cli.device,
        limit_force=2.0,
    )
    haply_device = HaplyDevice(cfg=haply_cfg)
    print(f"[INFO] Haply connected: {args_cli.websocket_uri}")

    sim.reset()

    run_simulator(sim, scene, haply_device)


if __name__ == "__main__":
    main()
    simulation_app.close()