7. Isaac Orbit (Preview)

7.1. Overview

../_images/isaac_orbit_tasks.jpg

Isaac Sim Orbit (or orbit in short) is an open-sourced unified and modular framework for robot learning. It offers a modular design to easily and efficiently create robot learning environments with photo-realistic scenes, and fast and efficient simulation. It aims to provide a ‘batteries-included’ experience for roboticists and researchers to quickly get started with robot learning in Isaac Sim. To achieve this, Orbit provides a set of pre-built components that can be used to create environments, and a set of tools to easily configure and run these environments.

Some of its core features include:

  • Concept of actuator models and groups to configure complex articulations such as mobile manipulators

  • CPU and GPU based implementations of motion generators

  • Modular configuration system to easily create and configure environments

  • Suite of robot learning environments with photo-realistic scenes for training and evaluation

7.2. User Guide

7.2.1. Installation

A complete installation guide can be found here . We include a summary of the installation steps below for convenience.

7.2.1.1. Installing Isaac Sim

Orbit is built on top of Isaac Sim, and requires a working installation of Isaac Sim to run. Please follow the instructions to install Isaac Sim.

7.2.1.2. Configuring environment variables

Isaac Sim is shipped with its own Python interpreter which bundles in the extensions released with it. To simplify the setup, we recommend using the same Python interpreter. Alternately, it is possible to setup a virtual environment following the instructions here.

Please locate the Python executable in Isaac Sim by navigating to Isaac Sim root folder. In the remaining of the documentation, we will refer to its path as ISAACSIM_PYTHON_EXE.

Note

On Linux systems, by default, this should be the executable python.sh in the directory ${HOME}/.local/share/ov/pkg/isaac_sim-*, with * corresponding to the Isaac Sim version.

To avoid the overhead of finding and locating the Isaac Sim installation directory every time, we recommend exporting the following environment variables to your ~/.bashrc or ~/.zshrc files:

# Isaac Sim root directory
export ISAACSIM_PATH="${HOME}/.local/share/ov/pkg/isaac_sim-2022.2.0"
# Isaac Sim python executable
export ISAACSIM_PYTHON_EXE="${ISAACSIM_PATH}/python.sh"

7.2.1.3. Installing Orbit

  • Install dependencies using apt:

    sudo apt install cmake build-essential
    
  • Clone the orbit repository into your workspace:

    # Option 1: SSH
    git clone git@github.com:NVIDIA-Omniverse/orbit.git
    # Option 2: HTTPS
    git clone https://github.com/NVIDIA-Omniverse/Orbit.git
    
  • Set up a symbolic link between the installed Isaac Sim root folder and _isaac_sim in the orbit` directory. This makes it convenient to index the python modules and look for extensions shipped with Isaac Sim.

    # enter the cloned repository
    cd orbit
    # create a symbolic link
    ln -s ${ISAACSIM_PATH} _isaac_sim
    
  • Build the included extensions and install learning frameworks:

    # install the extensions
    ./orbit.sh --install
    # install the learning frameworks (optional)
    ./orbit.sh --extra
    

7.2.2. Example

The following snippet provides an example on how to create a simple environment with quadrupedal robots and make them stand in simulation. The associated script play_quadrupeds.py can be found in the source/standalone/demo directory of the orbit repository.

import torch

from omni.isaac.core.simulation_context import SimulationContext
from omni.isaac.core.utils.viewports import set_camera_view

import omni.isaac.orbit.utils.kit as kit_utils
from omni.isaac.orbit.robots.config.anymal import ANYMAL_B_CFG, ANYMAL_C_CFG
from omni.isaac.orbit.robots.config.unitree import UNITREE_A1_CFG
from omni.isaac.orbit.robots.legged_robot import LeggedRobot

# load kit helper
sim = SimulationContext(physics_dt=0.005, rendering_dt=0.005, backend="torch")
set_camera_view(eye=[2.5, 2.5, 2.5], target=[0.0, 0.0, 0.0])

# create robot instance
robot_a = LeggedRobot(cfg=UNITREE_A1_CFG)
robot_b = LeggedRobot(cfg=ANYMAL_B_CFG)
robot_c = LeggedRobot(cfg=ANYMAL_C_CFG)
# spawn the robot
robot_a.spawn("/World/A1", translation=(1.0, 0, 0.42))
robot_b.spawn("/World/AnymalB", translation=(0.0, -0.5, 0.65))
robot_c.spawn("/World/AnymalC", translation=(0.0, 0.5, 0.65))
# spawn ground
# Ground-plane
kit_utils.create_ground_plane(
    "/World/defaultGroundPlane",
    static_friction=0.5,
    dynamic_friction=0.5,
    restitution=0.8,
    improve_patch_friction=True,
)

# play the simulation
sim.reset()
# configure physics handles
for robot in [robot_a, robot_b, robot_c]:
    # initialize the robot
    robot.initialize()
    # reset buffers
    robot.reset_buffers()

# create zero actions
actions = torch.zeros(robot_a.count, robot_a.num_actions, device=robot_a.device)

# run the simulation
for _ in range(1000):
    # step the robot
    for robot in [robot_a, robot_b, robot_c]:
        robot.apply_action(actions)
    # step the simulation
    sim.step()
    # update buffers
    for robot in [robot_a, robot_b, robot_c]:
        robot.update_buffers(dt=sim.get_physics_dt())

On execution, the following environment should be created:

../_images/isaac_orbit_demo.png

More examples and tutorials can be found in the orbit repository. Please refer to its documentation for more information.

7.3. Further Reading

For more background and full documentation of Isaac Orbit, please see the following external references: