Inertial Measurement Unit (IMU)

Inertial Measurement Unit (IMU)#

A diagram outlining the basic force relationships for the IMU sensor

Inertial Measurement Units (IMUs) are a type of sensor for measuring the acceleration of an object. These sensors are traditionally designed report linear accelerations and angular velocities, and function on similar principles to that of a digital scale: They report accelerations derived from net force acting on the sensor.

A naive implementation of an IMU would report a negative acceleration due to gravity while the sensor is at rest in some local gravitational field. This is not generally needed for most practical applications, and so most real IMU sensors often include a gravity bias and assume that the device is operating on the surface of the Earth. The IMU we provide in Isaac Lab includes a similar bias term, which defaults to +g. This means that if you add an IMU to your simulation, and do not change this bias term, you will detect an acceleration of \(+ 9.81 m/s^{2}\) anti-parallel to gravity acceleration.

Consider a simple environment with an Anymal Quadruped equipped with an IMU on each of its two front feet.

##
from isaaclab_assets.robots.anymal import ANYMAL_C_CFG  # isort: skip


@configclass
class ImuSensorSceneCfg(InteractiveSceneCfg):
    """Design the scene with sensors on the robot."""

    # 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))
    )

    # robot
    robot = ANYMAL_C_CFG.replace(prim_path="{ENV_REGEX_NS}/Robot")

    imu_RF = ImuCfg(prim_path="{ENV_REGEX_NS}/Robot/LF_FOOT", debug_vis=True)

    imu_LF = ImuCfg(prim_path="{ENV_REGEX_NS}/Robot/RF_FOOT", gravity_bias=(0, 0, 0), debug_vis=True)


def run_simulator(sim: sim_utils.SimulationContext, scene: InteractiveScene):

Here we have explicitly removed the bias from one of the sensors, and we can see how this affects the reported values by visualizing the sensor when we run the sample script

IMU visualized

Notice that the right front foot explicitly has a bias of (0,0,0). In the visualization, you should see that the arrow indicating the acceleration from the right IMU rapidly changes over time, while the arrow visualizing the left IMU points constantly along the vertical axis.

Retrieving values form the sensor is done in the usual way

def run_simulator(sim: sim_utils.SimulationContext, scene: InteractiveScene):
  .
  .
  .
  # Simulate physics
  while simulation_app.is_running():
    .
    .
    .
    # print information from the sensors
    print("-------------------------------")
    print(scene["imu_LF"])
    print("Received linear velocity: ", scene["imu_LF"].data.lin_vel_b)
    print("Received angular velocity: ", scene["imu_LF"].data.ang_vel_b)
    print("Received linear acceleration: ", scene["imu_LF"].data.lin_acc_b)
    print("Received angular acceleration: ", scene["imu_LF"].data.ang_acc_b)
    print("-------------------------------")
    print(scene["imu_RF"])
    print("Received linear velocity: ", scene["imu_RF"].data.lin_vel_b)
    print("Received angular velocity: ", scene["imu_RF"].data.ang_vel_b)
    print("Received linear acceleration: ", scene["imu_RF"].data.lin_acc_b)
    print("Received angular acceleration: ", scene["imu_RF"].data.ang_acc_b)

The oscillations in the values reported by the sensor are a direct result of of how the sensor calculates the acceleration, which is through a finite difference approximation between adjacent ground truth velocity values as reported by the sim. We can see this in the reported result (pay attention to the linear acceleration) because the acceleration from the right foot is small, but explicitly zero.

Imu sensor @ '/World/envs/env_.*/Robot/LF_FOOT':
        view type         : <class 'omni.physics.tensors.impl.api.RigidBodyView'>
        update period (s) : 0.0
        number of sensors : 1

Received linear velocity:  tensor([[ 0.0203, -0.0054,  0.0380]], device='cuda:0')
Received angular velocity:  tensor([[-0.0104, -0.1189,  0.0080]], device='cuda:0')
Received linear acceleration:  tensor([[ 4.8344, -0.0205,  8.5305]], device='cuda:0')
Received angular acceleration:  tensor([[-0.0389, -0.0262, -0.0045]], device='cuda:0')
-------------------------------
Imu sensor @ '/World/envs/env_.*/Robot/RF_FOOT':
        view type         : <class 'omni.physics.tensors.impl.api.RigidBodyView'>
        update period (s) : 0.0
        number of sensors : 1

Received linear velocity:  tensor([[0.0244, 0.0077, 0.0431]], device='cuda:0')
Received angular velocity:  tensor([[ 0.0122, -0.1360, -0.0042]], device='cuda:0')
Received linear acceleration:  tensor([[-0.0018,  0.0010, -0.0032]], device='cuda:0')
Received angular acceleration:  tensor([[-0.0373, -0.0050, -0.0053]], device='cuda:0')
-------------------------------
Code for imu_sensor.py
  1# Copyright (c) 2022-2026, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
  2# All rights reserved.
  3#
  4# SPDX-License-Identifier: BSD-3-Clause
  5
  6"""Launch Isaac Sim Simulator first."""
  7
  8import argparse
  9
 10from isaaclab.app import AppLauncher
 11
 12# add argparse arguments
 13parser = argparse.ArgumentParser(description="Example on using the IMU sensor.")
 14parser.add_argument("--num_envs", type=int, default=1, help="Number of environments to spawn.")
 15# append AppLauncher cli args
 16AppLauncher.add_app_launcher_args(parser)
 17# demos should open Kit visualizer by default
 18parser.set_defaults(visualizer=["kit"])
 19# parse the arguments
 20args_cli = parser.parse_args()
 21
 22# launch omniverse app
 23app_launcher = AppLauncher(args_cli)
 24simulation_app = app_launcher.app
 25
 26"""Rest everything follows."""
 27
 28import torch
 29import warp as wp
 30
 31import isaaclab.sim as sim_utils
 32from isaaclab.assets import AssetBaseCfg
 33from isaaclab.scene import InteractiveScene, InteractiveSceneCfg
 34from isaaclab.sensors import ImuCfg
 35from isaaclab.utils import configclass
 36
 37##
 38# Pre-defined configs
 39##
 40from isaaclab_assets.robots.anymal import ANYMAL_C_CFG  # isort: skip
 41
 42
 43@configclass
 44class ImuSensorSceneCfg(InteractiveSceneCfg):
 45    """Design the scene with sensors on the robot."""
 46
 47    # ground plane
 48    ground = AssetBaseCfg(prim_path="/World/defaultGroundPlane", spawn=sim_utils.GroundPlaneCfg())
 49
 50    # lights
 51    dome_light = AssetBaseCfg(
 52        prim_path="/World/Light", spawn=sim_utils.DomeLightCfg(intensity=3000.0, color=(0.75, 0.75, 0.75))
 53    )
 54
 55    # robot
 56    robot = ANYMAL_C_CFG.replace(prim_path="{ENV_REGEX_NS}/Robot")
 57
 58    imu_RF = ImuCfg(prim_path="{ENV_REGEX_NS}/Robot/LF_FOOT", debug_vis=True)
 59
 60    imu_LF = ImuCfg(prim_path="{ENV_REGEX_NS}/Robot/RF_FOOT", gravity_bias=(0, 0, 0), debug_vis=True)
 61
 62
 63def run_simulator(sim: sim_utils.SimulationContext, scene: InteractiveScene):
 64    """Run the simulator."""
 65    # Define simulation stepping
 66    sim_dt = sim.get_physics_dt()
 67    sim_time = 0.0
 68    count = 0
 69
 70    # Simulate physics
 71    while simulation_app.is_running():
 72        if count % 500 == 0:
 73            # reset counter
 74            count = 0
 75            # reset the scene entities
 76            # root state
 77            # we offset the root state by the origin since the states are written in simulation world frame
 78            # if this is not done, then the robots will be spawned at the (0, 0, 0) of the simulation world
 79            root_pose = wp.to_torch(scene["robot"].data.default_root_pose).clone()
 80            root_pose[:, :3] += scene.env_origins
 81            scene["robot"].write_root_link_pose_to_sim_index(root_pose=root_pose)
 82            root_vel = wp.to_torch(scene["robot"].data.default_root_vel).clone()
 83            scene["robot"].write_root_com_velocity_to_sim_index(root_velocity=root_vel)
 84            # set joint positions with some noise
 85            joint_pos, joint_vel = (
 86                wp.to_torch(scene["robot"].data.default_joint_pos).clone(),
 87                wp.to_torch(scene["robot"].data.default_joint_vel).clone(),
 88            )
 89            joint_pos += torch.rand_like(joint_pos) * 0.1
 90            scene["robot"].write_joint_position_to_sim_index(position=joint_pos)
 91            scene["robot"].write_joint_velocity_to_sim_index(velocity=joint_vel)
 92            # clear internal buffers
 93            scene.reset()
 94            print("[INFO]: Resetting robot state...")
 95        # Apply default actions to the robot
 96        # -- generate actions/commands
 97        targets = wp.to_torch(scene["robot"].data.default_joint_pos)
 98        # -- apply action to the robot
 99        scene["robot"].set_joint_position_target_index(target=targets)
100        # -- write data to sim
101        scene.write_data_to_sim()
102        # perform step
103        sim.step()
104        # update sim-time
105        sim_time += sim_dt
106        count += 1
107        # update buffers
108        scene.update(sim_dt)
109
110        # print information from the sensors
111        print("-------------------------------")
112        print(scene["imu_LF"])
113        print("Received linear velocity: ", scene["imu_LF"].data.lin_vel_b)
114        print("Received angular velocity: ", scene["imu_LF"].data.ang_vel_b)
115        print("Received linear acceleration: ", scene["imu_LF"].data.lin_acc_b)
116        print("Received angular acceleration: ", scene["imu_LF"].data.ang_acc_b)
117        print("-------------------------------")
118        print(scene["imu_RF"])
119        print("Received linear velocity: ", scene["imu_RF"].data.lin_vel_b)
120        print("Received angular velocity: ", scene["imu_RF"].data.ang_vel_b)
121        print("Received linear acceleration: ", scene["imu_RF"].data.lin_acc_b)
122        print("Received angular acceleration: ", scene["imu_RF"].data.ang_acc_b)
123
124
125def main():
126    """Main function."""
127
128    # Initialize the simulation context
129    sim_cfg = sim_utils.SimulationCfg(dt=0.005, device=args_cli.device)
130    sim = sim_utils.SimulationContext(sim_cfg)
131    # Set main camera
132    sim.set_camera_view(eye=[3.5, 3.5, 3.5], target=[0.0, 0.0, 0.0])
133    # design scene
134    scene_cfg = ImuSensorSceneCfg(num_envs=args_cli.num_envs, env_spacing=2.0)
135    scene = InteractiveScene(scene_cfg)
136    # Play the simulator
137    sim.reset()
138    # Now we are ready!
139    print("[INFO]: Setup complete...")
140    # Run the simulator
141    run_simulator(sim, scene)
142
143
144if __name__ == "__main__":
145    # run the main function
146    main()
147    # close sim app
148    simulation_app.close()