Skip to content

Latest commit

 

History

History
executable file
·
53 lines (35 loc) · 4.94 KB

MOVEMENT.md

File metadata and controls

executable file
·
53 lines (35 loc) · 4.94 KB
Raw

Movement control

There are two main aspects: ROS and Physics.

You can control the movement with or without ROS and with or without Physics.

In general, including ROS implies having physics.

With "With ROS" we mean that ROS is involved in the input. Clearly, you can always publish ROS information from the simulation.

When using joints, the system will essentially always use physics in some way. Clearly, as in Gazebo, you can disable gravity, collisions etc to your convenience.

An important thing to remember is that by being physics enabled implies that joints will be affected by the mass of the object to which those are attached. Clearly, even with teleport this might be true. In practice, not being physically enabled requires you to disable gravity of the object and collisions. To disable gravity, do so by changing the property (if exists) of the asset, similarly to what we do for the collision here. With the exception of options 2 and 4 (which are pretty much equivalent) of the Without ROS case.

With ROS

  1. Attach a joint publisher/listener to the robot (link) and directly publish a joint_commands ROS message either on your own link, using our 6DOF joint controller link, through MoveIt (see the tutorial).
  2. Use an embedded controller provided by IsaacSim and publish cmd_vel commands dependending on your use case.
  3. Use ROS to publish setpoints in some ways, listen to the topic within the simulation loop, and fall back to the "without ROS" section.

Without ROS

  1. Move the robot by sending joint position/velocity setpoints directly from IsaacSim. This will output physics and will abide the settings that you use for your joints (mass, force...). The implementations within IsaacSim is through a PD control. An example of this has been implemented here. Although the implementation there is different (it assume a set of predefined checkpoints) the concept is the same. To learn about stiffness and damping, please check this or this. Note that this has some issues in the 2022.2.1 version of the engine. Clearly, using this you can write your own controller.
import omni.kit.commands
from pxr import Sdf

omni.kit.commands.execute('ChangeProperty',
	prop_path=Sdf.Path('/World/robot/.../PrismaticJoint.drive:linear:physics:targetPosition'),
	value=10,
	prev=0)

import omni.kit.commands
from pxr import Sdf

omni.kit.commands.execute('ChangeProperty',
	prop_path=Sdf.Path('/World/Cone/PrismaticJoint.drive:linear:physics:targetVelocity'),
	value=10,
	prev=0.0)

  1. Use a strategy like the one we use for the flying objects adding translation and rotation animations (also scale is possible). However, this does NOT include physics, collision or anything similar whatsoever. In this case the trajectory is followed blindly and interpolated based on your settings.

  2. Use teleporting. For this see replay experiment code. Note that running the physics steps will imply that the robot will be affected by physics (e.g. collisions, gravity etc)

  3. Create a spline, animation sequence, or whatever and saving that to the USD file itself. Once loaded, the robot will behave as an animated object. Again, this won't follow physics low. It will still be affected by physics (accel, velocities) but not to collisions, gravity, etc. See here and related resources. Similar to #2.

  4. Directly set joint status as done in replay experiment from within the simulation itself, although this is quite similar to do #1.