Robot Freezes Despite Setting Target Joint Positions in create_scene.py

[rlsn]

Description:

Hello, I am testing desirable joint positions for the Unitree Go2 robot, but the robot does not move towards the specified target joint positions. The applied torque and joint velocity are nonzero, but the joint positions remain unchanged.

Everything works as expected with the cartpole model, but that is not the case with the robot.

Steps to Reproduce:

I made minimal modifications to the official tutorial example create_scene.py:

• Changed the robot model to Unitree Go2 (UNITREE_GO2_CFG)

from isaaclab_assets.robots.unitree import UNITREE_GO2_CFG
cartpole: ArticulationCfg = UNITREE_GO2_CFG.replace(prim_path="{ENV_REGEX_NS}/Robot")

• Changed control from random effort to fixed joint positions

joint_pos_target = robot.data.default_joint_pos.clone()
robot.set_joint_position_target(joint_pos_target)

• Added log prints for debugging

print(f"=========== count:{count} ===========")
print("joint_pos",robot.data.joint_pos)
print("joint_pos_target",robot.data.joint_pos_target)
print("joint_vel",robot.data.joint_vel)
print("applied_torque",robot.data.applied_torque)

Here is the full code create_scene.py:

# Copyright (c) 2022-2025, The Isaac Lab Project Developers.
# All rights reserved.
#
# SPDX-License-Identifier: BSD-3-Clause

"""This script demonstrates how to use the interactive scene interface to setup a scene with multiple prims.

.. code-block:: bash

    # Usage
    ./isaaclab.sh -p scripts/tutorials/02_scene/create_scene.py --num_envs 32

"""

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


import argparse

from isaaclab.app import AppLauncher

# add argparse arguments
parser = argparse.ArgumentParser(description="Tutorial on using the interactive scene interface.")
parser.add_argument("--num_envs", type=int, default=2, help="Number of environments to spawn.")
# append AppLauncher cli args
AppLauncher.add_app_launcher_args(parser)
# parse the arguments
args_cli = parser.parse_args()

# launch omniverse app
app_launcher = AppLauncher(args_cli)
simulation_app = app_launcher.app

"""Rest everything follows."""

import torch

import isaaclab.sim as sim_utils
from isaaclab.assets import ArticulationCfg, AssetBaseCfg
from isaaclab.scene import InteractiveScene, InteractiveSceneCfg
from isaaclab.sim import SimulationContext
from isaaclab.utils import configclass

##
# Pre-defined configs
##
from isaaclab_assets import CARTPOLE_CFG  # isort:skip
from isaaclab_assets.robots.unitree import UNITREE_GO2_CFG  # isort: skip

@configclass
class CartpoleSceneCfg(InteractiveSceneCfg):
    """Configuration for a cart-pole scene."""

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

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

    # articulation
    cartpole: ArticulationCfg = UNITREE_GO2_CFG.replace(prim_path="{ENV_REGEX_NS}/Robot")


def run_simulator(sim: sim_utils.SimulationContext, scene: InteractiveScene):
    """Runs the simulation loop."""
    # Extract scene entities
    # note: we only do this here for readability.
    robot = scene["cartpole"]
    # Define simulation stepping
    sim_dt = sim.get_physics_dt()
    count = 0

    joint_pos_target = robot.data.default_joint_pos.clone()
    # Simulation loop
    while simulation_app.is_running():
        # Reset
        if count % 5000 == 0:
            # reset counter
            count = 0
            # reset the scene entities
            # root state
            # we offset the root state by the origin since the states are written in simulation world frame
            # if this is not done, then the robots will be spawned at the (0, 0, 0) of the simulation world
            root_state = robot.data.default_root_state.clone()
            root_state[:, :3] += scene.env_origins
            robot.write_root_pose_to_sim(root_state[:, :7])
            robot.write_root_velocity_to_sim(root_state[:, 7:])
            # set joint positions with some noise
            joint_pos, joint_vel = robot.data.default_joint_pos.clone(), robot.data.default_joint_vel.clone()
            joint_pos += torch.rand_like(joint_pos) * 0.1
            robot.write_joint_state_to_sim(joint_pos, joint_vel)
            # clear internal buffers
            scene.reset()
            print("[INFO]: Resetting robot state...")

        # Apply random action
        # -- generate random joint efforts
        # efforts = torch.randn_like(robot.data.joint_pos) * 5.0
        # -- apply action to the robot
        # robot.set_joint_effort_target(efforts)

        # set joint position target
        robot.set_joint_position_target(joint_pos_target)
        print(f"=========== count:{count} ===========")
        print("joint_pos",robot.data.joint_pos)
        print("joint_pos_target",robot.data.joint_pos_target)
        print("joint_vel",robot.data.joint_vel)
        print("applied_torque",robot.data.applied_torque)

        # -- write data to sim
        scene.write_data_to_sim()
        # Perform step
        sim.step()
        # Increment counter
        count += 1
        # Update buffers
        scene.update(sim_dt)


def main():
    """Main function."""
    # Load kit helper
    sim_cfg = sim_utils.SimulationCfg(device=args_cli.device)
    sim = SimulationContext(sim_cfg)
    # Set main camera
    sim.set_camera_view([1.5, 0.0, 1.5], [0.0, 0.0, 0.0])
    # Design scene
    scene_cfg = CartpoleSceneCfg(num_envs=args_cli.num_envs, env_spacing=2.0)
    scene = InteractiveScene(scene_cfg)
    # Play the simulator
    sim.reset()
    # Now we are ready!
    print("[INFO]: Setup complete...")
    # Run the simulator
    run_simulator(sim, scene)


if __name__ == "__main__":
    # run the main function
    main()
    # close sim app
    simulation_app.close()

Run the modified create_scene.py script with:

./isaaclab.sh -p create_scene.py --num_envs 1

Observe that the robot does not move despite setting joint position targets.

Expected Behavior:

The robot should move toward the specified joint position targets.

Observed Behavior:

joint_pos_target is correctly set, but joint_pos does not change.
applied_torque and joint_vel are nonzero, but the robot remains frozen.

Relevant Logs:

=========== count:312 ===========
joint_pos tensor([[ 0.1419, -0.1115,  0.1922, -0.3208,  0.8091,  0.7616,  1.1385,  0.9764,
         -2.2846, -1.5892, -2.6048, -1.6317]], device='cuda:0')
joint_pos_target tensor([[ 0.1000, -0.1000,  0.1000, -0.1000,  0.8000,  0.8000,  1.0000,  1.0000,
         -1.5000, -1.5000, -1.5000, -1.5000]], device='cuda:0')
joint_vel tensor([[-0.0460,  0.0015, -0.3665, -0.2619,  0.1617, -0.0058,  0.3195,  0.1407,
          0.2343,  0.1201, -0.2871, -0.1107]], device='cuda:0')
applied_torque tensor([[-1.0244,  0.2862, -2.1205,  5.6511, -0.3082,  0.9624, -3.6230,  0.5194,
         19.4987,  2.1699, 23.5000,  3.3479]], device='cuda:0')
=========== count:313 ===========
joint_pos tensor([[ 0.1419, -0.1115,  0.1921, -0.3208,  0.8091,  0.7616,  1.1385,  0.9764,
         -2.2846, -1.5892, -2.6048, -1.6317]], device='cuda:0')
joint_pos_target tensor([[ 0.1000, -0.1000,  0.1000, -0.1000,  0.8000,  0.8000,  1.0000,  1.0000,
         -1.5000, -1.5000, -1.5000, -1.5000]], device='cuda:0')
joint_vel tensor([[-0.0461,  0.0015, -0.3666, -0.2620,  0.1618, -0.0058,  0.3196,  0.1407,
          0.2344,  0.1201, -0.2871, -0.1106]], device='cuda:0')
applied_torque tensor([[-1.0244,  0.2862, -2.1205,  5.6510, -0.3082,  0.9624, -3.6231,  0.5194,
         19.4988,  2.1699, 23.5000,  3.3479]], device='cuda:0')
=========== count:314 ===========
joint_pos tensor([[ 0.1419, -0.1115,  0.1921, -0.3208,  0.8091,  0.7616,  1.1385,  0.9764,
         -2.2846, -1.5892, -2.6048, -1.6317]], device='cuda:0')
joint_pos_target tensor([[ 0.1000, -0.1000,  0.1000, -0.1000,  0.8000,  0.8000,  1.0000,  1.0000,
         -1.5000, -1.5000, -1.5000, -1.5000]], device='cuda:0')
joint_vel tensor([[-0.0461,  0.0015, -0.3666, -0.2620,  0.1618, -0.0058,  0.3196,  0.1407,
          0.2344,  0.1201, -0.2871, -0.1106]], device='cuda:0')
applied_torque tensor([[-1.0243,  0.2862, -2.1204,  5.6511, -0.3083,  0.9624, -3.6231,  0.5194,
         19.4988,  2.1698, 23.5000,  3.3479]], device='cuda:0')

System Information:

Isaac Lab Version: 2.0.1
Issac Sim Version: 4.5.0
OS: Win11
GPU: RTX 4060 (8G VRAM)
Python Version: 3.10

Any help would be greatly appreciated! 🚀

[RandomOakForest]

Thank you for starting this discussion. This is very interesting. Have you seen a similar behavior with other robots? The team will take a closer look soon. Thanks.

[rlsn]

Thank you for your response. I've tested the provided script with both the Unitree A1 and Spot robots, and both exhibit the same issue. Given that these robots function correctly within reinforcement learning scripts, I suspect a configuration discrepancy in create_scene.py might be responsible for the observed behavior. It's worth noting that the Cartpole operates as expected, which further highlights the specificity of this problem.

[StrainFlow]

I don't see where you're assigning the joint DOFs so that you can control them. Here's a sample I'm working on that spawns a car and controls it in a direct environment, this might be easier to get going:

# Copyright (c) 2022-2024, The Isaac Lab Project Developers.
# All rights reserved.
#
# SPDX-License-Identifier: BSD-3-Clause

# Take Random Actions

from __future__ import annotations

import torch
from collections.abc import Sequence

from .Leatherback import LEATHERBACK_CFG

import omni.isaac.lab.sim as sim_utils
from omni.isaac.lab.assets import Articulation, ArticulationCfg
from omni.isaac.lab.envs import DirectRLEnv, DirectRLEnvCfg
from omni.isaac.lab.scene import InteractiveSceneCfg
from omni.isaac.lab.sim import SimulationCfg
from omni.isaac.lab.sim.spawners.from_files import GroundPlaneCfg, spawn_ground_plane
from omni.isaac.lab.utils import configclass

@configclass
class LeatherbackEnvCfg(DirectRLEnvCfg):
    
    # env
    decimation = 2              # Decimation (number of time steps between actions)
    episode_length_s = 5.0      # Max each episode should last in seconds
    action_space = 2            # Number of actions the neural network should return    
    observation_space = 1       # Number of observations fed into neural network
    state_space = 0             # Observations to be used in Actor-Critic training

    # simulation
    sim: SimulationCfg = SimulationCfg(dt=1 / 60, render_interval=decimation)

    # robot
    robot_cfg: ArticulationCfg = LEATHERBACK_CFG.replace(prim_path="/World/envs/env_.*/Robot")
    
    throttle_dof_name = [
        "Wheel__Knuckle__Front_Left",
        "Wheel__Knuckle__Front_Right",
        "Wheel__Upright__Rear_Right",
        "Wheel__Upright__Rear_Left",
    ]
    steering_dof_name = [
        "Knuckle__Upright__Front_Right",
        "Knuckle__Upright__Front_Left",
    ]

    # scene
    scene: InteractiveSceneCfg = InteractiveSceneCfg(num_envs=4096, env_spacing=4.0, replicate_physics=True)
    
class LeatherbackEnv(DirectRLEnv):
    cfg: LeatherbackEnvCfg

    def __init__(self, cfg: LeatherbackEnvCfg, render_mode: str | None = None, **kwargs):
        super().__init__(cfg, render_mode, **kwargs)

        self._throttle_dof_idx, _ = self.Leatherback.find_joints(self.cfg.throttle_dof_name)
        self._steering_dof_idx, _ = self.Leatherback.find_joints(self.cfg.steering_dof_name)

        self.previous_throttle = torch.zeros((self.num_envs,4), dtype=torch.float32, device=self.device)
        self.previous_steering = torch.zeros((self.num_envs,2), dtype=torch.float32, device=self.device)
        print("[DEBUG] Init Complete")

    def _setup_scene(self):
        self.Leatherback = Articulation(self.cfg.robot_cfg)
        
        # add ground plane
        spawn_ground_plane(prim_path="/World/ground", cfg=GroundPlaneCfg())

        # clone, filter, and replicate
        self.scene.clone_environments(copy_from_source=False)       # Clones child environments from parent environment
        self.scene.filter_collisions(global_prim_paths=[])          # Prevents environments from colliding with each other
        
        # add articulation to scene
        self.scene.articulations["leatherback"] = self.Leatherback
        
        # add lights
        light_cfg = sim_utils.DomeLightCfg(intensity=2000.0, color=(0.75, 0.75, 0.75))
        light_cfg.func("/World/Light", light_cfg)

    def _pre_physics_step(self, actions: torch.Tensor) -> None:
        
        throttle_scale = 0.01
        steering_scale = 0.01
        self.actions = actions.clone()
        
        self._throttle_action = actions[:, 0].repeat_interleave(4).reshape((-1, 4)) * throttle_scale
        self._throttle_action += self.previous_throttle
        self.previous_throttle = self._throttle_action

        self._steering_action = actions[:, 1].repeat_interleave(2).reshape((-1, 2)) * steering_scale
        self._steering_action += self.previous_steering
        self.previous_steering = self._steering_action

    def _apply_action(self) -> None:        
        self.Leatherback.set_joint_velocity_target(self._throttle_action, joint_ids=self._throttle_dof_idx)
        self.Leatherback.set_joint_position_target(self._steering_action, joint_ids=self._steering_dof_idx)

    def _get_observations(self) -> dict:
        obs = torch.zeros((self.num_envs,1), dtype=torch.float32, device=self.device)
        observations = {"policy": obs}

        return observations

    def _get_rewards(self) -> torch.Tensor:
        return torch.zeros((self.num_envs,), dtype=torch.float32, device=self.device)

    def _get_dones(self) -> tuple[torch.Tensor, torch.Tensor]:
        
        clean_termination = self.episode_length_buf >= self.max_episode_length - 1
        
        failure_termination = torch.zeros((self.num_envs,), dtype=torch.bool, device=self.device)
        print("get dones complete")
        return failure_termination, clean_termination

    def _reset_idx(self, env_ids: Sequence[int] | None):
        if env_ids is None:
            env_ids = self.Leatherback._ALL_INDICES
        super()._reset_idx(env_ids)

        num_reset = len(env_ids)
        
        ## Reset from config
        default_state = self.Leatherback.data.default_root_state[env_ids]        # first three are pos, next 4 quats, next 3 vel, next 3 ang vel
        leatherback_pose = default_state[env_ids, :7]                                  # proper way of getting default pose from config file
        leatherback_velocities = default_state[env_ids, 7:]                            # proper way of getting default velocities from config file
        joint_positions = self.Leatherback.data.default_joint_pos[env_ids]       # proper way to get joint positions from config file
        joint_velocities = self.Leatherback.data.default_joint_vel[env_ids]      # proper way to get joint velocities form config file

        leatherback_pose[:, :3] += self.scene.env_origins[env_ids]               # Adds center of each env position to leatherback position

        # Randomize Starting Position
        leatherback_pose[:, :2] += 2.0 * torch.rand((num_reset, 2), dtype=torch.float32, device=self.device)
        
        # Randomize starting Heading
        angles = torch.pi * torch.rand((num_reset,), dtype=torch.float32, device=self.device)
        
        # Isaac Sim quaternions are W-first (w, x, y, z) To rotate about the Z axis, we'll modify the W and Z values
        leatherback_pose[:, 3] = torch.cos(angles * 0.5)
        leatherback_pose[:, 6] = torch.sin(angles * 0.5)

        self.Leatherback.write_root_pose_to_sim(leatherback_pose, env_ids)
        self.Leatherback.write_root_velocity_to_sim(leatherback_velocities, env_ids)
        self.Leatherback.write_joint_state_to_sim(joint_positions, joint_velocities, None, env_ids)
        print("reset idx complete")

I add the following to launch.json so that I can run it in debug:

        {
            "name": "Leatherback 2",
            "type": "python",
            "request": "launch",
            "args" : ["--task", "Leatherback_2-Direct-v0", "--num_envs", "16"],
            "program": "${workspaceFolder}/source/standalone/environments/random_agent.py",
            "console": "integratedTerminal"
        },

If you're somewhat familiar with direct environments that's probably enough info, if not I can post more info on where to put the files and how to register the direct environment with gym. A few members of the community on Discord have this sample working and are helping others get it working. We meet every Wedensday at 11:30 PST for a study group and would love to have you join us.

[rlsn]

Thank you for your response. I apologize for the oversight; I should have clarified that the robots operate correctly in both manager-based and direct environments. My intention in using create_scene.py was to create a simplified simulation for direct manipulation and testing of robot configurations, free from the complexities of reinforcement learning logic.

I believe the DOF assignment you mentioned refers to the following operations in your example:

self._throttle_dof_idx, _ = self.Leatherback.find_joints(self.cfg.throttle_dof_name)
self._steering_dof_idx, _ = self.Leatherback.find_joints(self.cfg.steering_dof_name)
...
self.Leatherback.set_joint_velocity_target(self._throttle_action, joint_ids=self._throttle_dof_idx)
self.Leatherback.set_joint_position_target(self._steering_action, joint_ids=self._steering_dof_idx)

This appears necessary for your example due to the separate control of two actuator groups. In my case, with only a single actuator group, robot.set_joint_position_target(joint_pos_target) should be sufficient.

Thank you for the invitation to your study group. Unfortunately, the time difference makes it difficult for me to participate. However, I would be very interested in joining your Discord community.