Comment configurer **NVIDIA Isaac Sim** : un guide pratique

En bref (TL;DR)

Installer Isaac Sim via Omniverse Launcher sur Ubuntu 22.04 avec une carte RTX
Importer des robots via des fichiers USD/URDF et configurer PhysX pour des physiques réalistes
Utiliser Replicator pour la génération de données synthétiques avec randomisation de domaine
Relier à ROS 2 Humble via les paquets isaac_ros
Exécuter en mode sans interface graphique sur des instances cloud avec Omniverse Nucleus

1. Installation et exigences système

Exigences matérielles

Isaac Sim nécessite :

GPU : NVIDIA série RTX 30/40 ou A100/H100 (minimum RTX 2080 Ti)
CPU : 8 cœurs ou plus (recommandé : Intel Xeon/AMD Ryzen)
RAM : 32 Go+ (64 Go pour des scènes complexes)
Stockage : 20 Go+ SSD (NVMe recommandé)

Prérequis logiciels

# Ubuntu 22.04 (testé)
sudo apt update
sudo apt install -y nvidia-driver-535 nvidia-cuda-toolkit
sudo apt install -y ros-humble-desktop ros-humble-isaac-ros

Étapes d’installation

Télécharger Omniverse Launcher

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-ubuntu2204.pin
sudo mv cuda-ubuntu2204.pin /etc/apt/preferences.d/cuda-repository-pin-600
sudo apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/3bf863cc.pub
sudo add-apt-repository "deb https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/ /"
sudo apt update
sudo apt install -y nvidia-omniverse-launcher

Installer Isaac Sim via le lanceur
- Ouvrir Omniverse Launcher
- Aller dans Exchange → Rechercher « Isaac Sim » → Installer la version 2023.1.1 (stable)

Vérifier l’installation

./isaac-sim.sh

Résultat attendu :

[Isaac Sim] Démarrage...
[Omniverse Kit] Lancement...

Erreurs courantes lors de l’installation

Erreur : Failed to initialize CUDA Solution : Vérifier l’installation des pilotes NVIDIA :
```
nvidia-smi
```
Doit afficher les informations de la carte graphique sans erreurs.
Erreur : ROS 2 Humble dependencies manquants Solution : Installer ROS 2 Humble :
```
sudo apt install ros-humble-isaac-ros
source /opt/ros/humble/setup.bash
```

2. Importation de robots et scènes USD

Formats de fichiers pris en charge

Format	Extension	Notes
Universal Scene Description	`.usd`	Format préféré pour Isaac Sim
URDF	`.urdf`	Convertir en USD via `isaac_ros`
SDF	`.sdf`	Format Gazebo (convertir via `ros2 run urdf_to_usd`)

Importation d’un robot URDF (exemple : Franka Emika Panda)

Télécharger le fichier URDF de Franka

mkdir -p ~/isaac_sim_ws/src
cd ~/isaac_sim_ws/src
git clone https://github.com/ros-industrial/franka_ros.git
colcon build --symlink-install

**Convertir URDF en USD

ros2 run urdf_to_usd urdf_to_usd --input franka_ros/urdf/franka_panda.urdf --output franka_panda.usd

**Charger dans Isaac Sim
- Lancer Isaac Sim :
```
./isaac-sim.sh
```
- Dans l’interface Isaac Sim :
  - Aller dans Fichier → Importer une scène
  - Sélectionner franka_panda.usd
  - Cliquer sur Ouvrir

Configuration des articulations et capteurs du robot

Modifier le fichier USD pour ajouter des capteurs (ex. : caméras, IMU) :

def Camera "right_hand_camera" (
    xformOp:transform = @right_hand_camera_xform
    sensor:camera = {
        focalLength = 24.0
        horizontalAperture = 10.0
        clippingRange = (0.01, 100.0)
    }
)

3. Simulation PhysX et modèles de capteurs

Configuration des propriétés physiques

Modifier le fichier USD du robot pour ajuster la physique :

def Xform "panda_link0" (
    xformOp:transform = @panda_link0_xform
    physics:collisionApproxConvexHull = {
        approxConvexHull = true
        collisionEnabled = true
    }
    physics:rigidBody = {
        mass = 0.5
        enableGravity = true
    }
)

Activation de capteurs réalistes

Ajouter un capteur caméra

def Camera "head_camera" (
    xformOp:transform = @head_camera_xform
    sensor:camera = {
        focalLength = 16.0
        horizontalAperture = 8.0
        clippingRange = (0.01, 50.0)
        resolution = (640, 480)
    }
)

Activer les capteurs de profondeur

# Dans un script Python (ex. : `simulation_app.py`)
from omni.isaac.sensor import Camera
camera = Camera(prim_path="/World/head_camera", resolution=(640, 480))
camera.enable_depth()

Randomisation de domaine pour le passage simulation-réel

Utiliser Replicator d’Isaac Sim pour la randomisation de domaine :

from omni.isaac.replicator import ReplicatorClient

# Initialiser Replicator
replicator = ReplicatorClient()

# Définir les paramètres de randomisation
randomization_params = {
    "physics": {
        "friction": {"min": 0.1, "max": 0.9},
        "mass": {"min": 0.5, "max": 2.0}
    },
    "lighting": {
        "intensity": {"min": 0.5, "max": 2.0}
    }
}

# Appliquer à une scène
replicator.randomize_scene(randomization_params)

4. Génération de données synthétiques avec Replicator

Création de jeux de données RGB-D

**Créer un pipeline Replicator

from omni.isaac.replicator import ReplicatorClient, Pipeline

# Initialisation
replicator = ReplicatorClient()

# Définir le pipeline
pipeline = Pipeline()
pipeline.add(Pipeline.create_camera_sensor("rgb_camera", resolution=(1280, 720)))
pipeline.add(Pipeline.create_camera_sensor("depth_camera", resolution=(1280, 720), depth=True))

# Ajouter la randomisation
pipeline.add(Pipeline.randomize_physics(friction=(0.1, 0.9)))

# Exporter les données
pipeline.add(Pipeline.write_to_disk("/data/rgb", format="png"))
pipeline.add(Pipeline.write_to_disk("/data/depth", format="exr"))

Exécuter le pipeline

python3 replicator_pipeline.py --headless

Résultat attendu

/data/
├── rgb/
│   ├── frame_000001.png
│   ├── frame_000002.png
│   └── ...
└── depth/
    ├── frame_000001.exr
    ├── frame_000002.exr
    └── ...

5. Intégration avec le pont ROS 2

Relier Isaac Sim à ROS 2 Humble

**Installer le pont ROS 2 Humble

sudo apt install ros-humble-isaac-ros-bridge

Lancer le pont

ros2 launch isaac_ros_bridge isaac_ros_bridge.launch.py

Publier un sujet d’état d’articulation

# Dans un script Python (ex. : `joint_publisher.py`)
from isaac_ros_bridge import IsaacRosBridge
bridge = IsaacRosBridge()
bridge.publish_joint_states("/franka_panda/joint_states")

**S’abonner à un sujet ROS 2

ros2 topic echo /franka_panda/joint_states

Problèmes courants avec ROS 2

Erreur : TF transform failed Solution : Vérifier que robot_state_publisher est en cours d’exécution :
```
ros2 run robot_state_publisher robot_state_publisher --ros-args -p use_sim_time:=true
```
Erreur : No such node /isaac_ros_bridge Solution : Vérifier que le pont est lancé :
```
ros2 node list
```

6. Exécution sans interface graphique et déploiement cloud

Exécuter Isaac Sim sans interface graphique

./isaac-sim.sh --headless --no-window --no-gui

Déploiement sur le cloud AWS

**Lancer une instance EC2
- Utiliser g5.2xlarge (GPU NVIDIA T4) ou g5.4xlarge (RTX 6000 Ada).
- AMI : Deep Learning AMI (Ubuntu 22.04).

**Installer Isaac Sim sur AWS

# Suivre les mêmes étapes d’installation que ci-dessus
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-ubuntu2204.pin
sudo apt install -y nvidia-omniverse-launcher

Exécuter une simulation sans interface graphique

nohup ./isaac-sim.sh --headless --no-window --no-gui > simulation.log 2>&1 &

Utiliser Omniverse Nucleus pour la collaboration multi-utilisateurs

**Démarrer le serveur Nucleus

omniverse-nucleus-server --headless --port 3000

Connecter les clients

./isaac-sim.sh --nucleus-host <IP_AWS> --nucleus-port 3000

Que faire ensuite ?

Tester votre configuration : Exécuter une tâche simple de préhension/dépose avec l’extension Manipulation d’Isaac Sim.
Générer des données synthétiques : Utiliser Replicator pour créer 10 000 images RGB-D destinées à l’entraînement.
Déployer sur le cloud : Scaler à 10+ robots en utilisant des instances AWS EC2 G5.

Pour des workflows avancés en Physical AI, explorez les outils de conseil en IA de Hyperion afin d’accélérer vos projets en robotique.

Comment configurer NVIDIA Isaac Sim : un guide pratique