Humanoid hand explodes on collision

Omniverse Isaac Sim
,
1

6.0.0
5.1.0
5.0.0
4.5.0
4.2.0
4.1.0
4.0.0
4.5.0
2023.1.1
2023.1.0-hotfix.1
Other (please specify):

Operating System

Ubuntu 24.04
Ubuntu 22.04
Ubuntu 20.04
Windows 11
Windows 10
Other (please specify):

GPU Information

  • Model: NVIDIA L40S
  • Driver Version:

Topic Description

Detailed Description

I have a model of the Booster T1 humanoid robot with Inspire RH56DFX hands. Whenever the robot falls onto its hands, the fingers start glitching around, accumulating force until the entire robot shoots into the air. The forces increase further and Isaac Sim crashes.

Steps to Reproduce

  1. Open this minimal example file with the robot in an empty scene with a plane: https://drive.google.com/file/d/1vsnkc9I31F3GAzvWn6snzEUm3KySf3oz/view?usp=sharing

  2. Start the simulation and watch the robot fall to the ground. It’s slightly rotated so that it should fall on its left hand.

  3. The fingers will start glitching with strong angular forces. In a few seconds, it will explode, Isaac Sim might crash.

What I’ve Tried

  • Playing around with damping and stiffness:
    • These parameters were originally set to 500 and 1000 for each finger joint. I decreased them to 0.1 and 1.7, which decreased the behavior somewhat, by delaying the explosion.
  • Joint Limits are set up correctly
  • Using the PGS solver instead of TGS stabilized the hands more. Before, they would crash Isaac Sim immediately upon a collision, but now they are more resistent
  • Break forces
    • I tried setting up break forces and torques for the finger joints to make them break when the robot falls over instead of glitching. However, the attributes did not seem to have any influcence, as even setting them to 0.001 did not make any finger break when hitting the ground.
  • Removing some fingers
    • Deactivating the joints of the middle 3 fingers seemed to help, improving even further with just having the thumb attached. Attaching only the index finger resulted in the same explosion behavior.
    • In the long run, all the fingers should obviously work.
  • Configuring inertia did not work, as the diagonal values would be too small for Isaac Sim (range of 1e-6)
    (Describe the issue in detail, including what you were trying to do, what you expected to happen, and what actually happened)
3

Hi, Thanks for sharing the minimal example. But seems the payload ./models/booster_t1_hands_limits.usd is missing and I cannot open it. Can you share the full assets?

4

I am very sorry, this file should be working!

5

Hi, your robot fingers are glitching because of PhysX solver instability caused by complex articulated hand collisions.

When the robot falls on its hands, the PhysX solver struggles with:

  1. Complex collision geometry - Multiple finger joints create many simultaneous contacts
  2. Insufficient solver iterations - Default solver can’t resolve all contacts in one timestep
  3. Poor contact/rest offsets - Fingers penetrate each other, accumulating constraint violations
  4. High joint stiffness without damping - Creates oscillations that amplify
  5. Small collision margins - Contacts aren’t detected early enough

The accumulated constraint violations create artificial forces that eventually “explode,” launching the robot.

Here’re some suggestions that you can try:

  • Increase Solver Iterations
  • Fix Contact and Rest Offsets
from isaacsim.core.prims import GeometryPrimView

#Get all finger collision geometry
finger_paths = ["/World/Robot/hand/finger1_collision", ...]  _Your finger_ paths
finger_geoms = GeometryPrimView(prim_paths_expr=finger_paths)

#Set_ contact offset (distance where contacts start being detected)
finger_geoms.set_contact_offsets(np.full(len(finger_paths), 0.02))  # 2cm

#Set rest_ offset (shapes rest at this distance from each other)
finger_geoms.set_rest_offsets(np.full(len(finger_paths), 0.0))  # Touch exactly
  • Add Joint Damping
from isaacsim.core.articulations import Articulation

robot = Articulation("/World/Robot")
robot.initialize()

#Get finger_ joint indices (example for fingers)
finger_joint_names = ["finger1_joint", "finger2_joint", "finger3_joint", ...]

#Set dam_ping to prevent oscillations
num_envs = 1
damping_values = np.full((num_envs, len(finger_joint_names)), 0.5)  _Start_ with 0.5
robot.set_gains(
    kds=damping_values,
    joint_names=finger_joint_names
)

#Lower_ stiffness if using position control
stiffness_values = np.full((num_envs, len(finger_joint_names)), 50.0)  _Reduce from_ high values
robot.set_gains(
    kps=stiffness_values,
    kds=damping_values,
    joint_names=finger_joint_names
)
  • Improve Collision Geometry
#Use simpler collision shapes for fingers
# Option_ A: Use fewer collision primitives
# Option B: Use convex decomposition instead of exact mesh

from pxr import UsdPhysics, PhysxSchema

for finger_path in finger_paths:
    collision_prim = stage.GetPrimAtPath(finger_path)
    
    # Enable convex decomposition for complex shapes
    mesh_collision = UsdPhysics.MeshCollisionAPI.Apply(collision_prim)
    mesh_collision.CreateApproximationAttr("convexDecomposition")
  • Disable Self-Collisions Between Adjacent Fingers
from pxr import PhysicsSchema

#Create_ filtered pairs to ignore specific collisions
scene_prim = stage.GetPrimAtPath("/physicsScene")
physx_scene = PhysxSchema.PhysxSceneAPI.Apply(scene_prim)

#Disable collisions between adjacent finger_ segments
filter_pairs = [
    ("/World/Robot/hand/finger1_link1", "/World/Robot/hand/finger1_link2"),
    ("/World/Robot/hand/finger2_link1", "/World/Robot/hand/finger2_link2"),
    # Add all adjacent pairs
]

for pair in filter_pairs:
    #This_ prevents interpenetration between connected links
    # Use XRDF editor or collision filtering
    pass
  • Global Physics Settings
    • Increase bounce threshold to reduce jitter
    • Enable CCD (Continuous Collision Detection) for fast-moving objects

The codes are just for reference values, you can tune those from GUI if that works better for you.

6

Thank you for the help. However, these things do not seem to work. Another important observation I made is that this issue persists even if collisions are turned off. The hand still glitches out, even when it does not have any collisions activated (and the robot just falls on its “hand stump”).

7

If the fingers glitch even with collisions disabled, the issue is joint instability from constraint violations, not collision-related. The problem is internal joint dynamics:

  1. Joint limit violations - Fingers exceed their position limits
  2. Insufficient joint damping - No energy dissipation causes oscillations
  3. High joint stiffness - Position control overshoots create oscillations
  4. Solver instability - Complex articulation chain can’t converge
  5. External forces - Gravity/contact reactions on the hand propagate through joints.