> For clean Markdown of any page, append .md to the page URL. > For a complete documentation index, see https://docs.stereolabs.com/docs/integrations/isaac-ros/setup-and-installation/llms.txt. > For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.stereolabs.com/_mcp/server. # Setting up Isaac™ ROS 5 This guide explains how to install NVIDIA® Isaac™ ROS 5 and how to verify that it works. Two installation paths are available, [Docker](#docker-installation) and [Bare Metal](#bare-metal-installation): see [Install Isaac™ ROS 5](#install-isaac-ros-5) to choose the one that fits your use case. When Isaac™ ROS 5 is installed and tested, follow the [Use ZED with Isaac™ ROS](/docs/integrations/isaac-ros/use-zed-with-isaac-ros/) guide to add support for ZED cameras. > **Note** > > Using **Isaac™ ROS 3.2** with ROS 2 Humble? Follow the [legacy Isaac™ ROS 3 installation guide](/docs/integrations/isaac-ros/legacy/setup-and-installation/) instead. > **Note** > > A solid connection to the internet is required to download the NVIDIA® Isaac™ ROS packages. If you are using a Jetson™ device, we recommend using a wired connection for better stability and speed. ## Requirements | Platform | Hardware | Software | | ----------- | ------------------------------------------------------------------------------------------ | ---------------------------------------------------- | | **Jetson™** | Jetson™ Thor or Jetson™ Orin, 128+ GB NVMe SSD | JetPack 7.2 (L4T 39.2) | | **x86_64** | NVIDIA® GPU with Ampere architecture or newer and 8+ GB of VRAM, 32+ GB of free disk space | Ubuntu 24.04, NVIDIA® driver 595 or newer, CUDA 13.2 | This guide covers Jetson™ and x86_64 platforms. Refer to the [NVIDIA® Isaac™ ROS system requirements](https://nvidia-isaac-ros.github.io/getting_started/index.html#system-requirements) for the full list of supported platforms, including DGX Spark. ### Middleware requirement Isaac™ ROS 5 exchanges data between its nodes with [`rosidl::Buffer` buffer backends](https://nvidia-isaac-ros.github.io/concepts/rosidl_buffer/index.html), which are supported by two ROS 2 middleware implementations: * `rmw_fastrtps_cpp` (Fast DDS), the default of ROS 2 Lyrical. * `rmw_zenoh_cpp` (Zenoh), starting with v0.10.5. It is not installed by default: complete this guide first, then follow the [Use Zenoh with Isaac™ ROS 5](/docs/integrations/isaac-ros/setup-and-installation/zenoh/) guide to install, select, and test it. With other middleware implementations, such as `rmw_cyclonedds_cpp`, the Isaac™ ROS nodes start without errors, but the data they publish does not reach the subscribers running in other processes. Use the same middleware on all the machines and in all the terminals that run ROS 2 nodes communicating with Isaac™ ROS: the `RMW_IMPLEMENTATION` environment variable must be unset or set to `rmw_fastrtps_cpp` for Fast DDS, or set to `rmw_zenoh_cpp` for Zenoh. Check it with: ```bash echo ${RMW_IMPLEMENTATION:-rmw_fastrtps_cpp (default)} ``` > **Warning** > > If you configured Cyclone DDS, for example by following the [DDS and Network Tuning](/docs/integrations/ros-2/dds-and-network-tuning/) guide, remove the `export RMW_IMPLEMENTATION=rmw_cyclonedds_cpp` line from your `~/.bashrc` file before using Isaac™ ROS 5. ## Prepare the host The steps in this section are required by both installation paths. ### Set up the compute platform #### Jetson 1. Flash JetPack 7.2 on your Jetson™ device and confirm the installed version. The output must contain `R39 (release), REVISION: 2.0`: ```bash cat /etc/nv_tegra_release ``` 2. Set the power mode to the maximum (`MAXN`) and maximize the clocks. For the complete list of power modes and their power budgets, refer to the NVIDIA® power settings guide for [Jetson™ Thor](https://docs.nvidia.com/jetson/archives/r39.2/DeveloperGuide/SD/PlatformPowerAndPerformance/JetsonThor.html) or [Jetson™ Orin](https://docs.nvidia.com/jetson/archives/r39.2/DeveloperGuide/SD/PlatformPowerAndPerformance/JetsonOrinNanoSeriesJetsonOrinNxSeriesAndJetsonAgxOrinSeries.html). Set the `MAXN` power mode. On Jetson™ Thor and AGX Orin, `MAXN` is mode `0`; confirm the id for your device with `sudo nvpmodel -p --verbose`. The selected mode is saved and reapplied automatically at every boot: ```bash sudo nvpmodel -m 0 ``` Maximize the clocks for the current session: ```bash sudo jetson_clocks ``` > **Note** > > `jetson_clocks` does not persist across reboots. To apply it automatically at every boot, optionally install it as a `systemd` service that runs after `nvpmodel`: > > ```bash > sudo tee /etc/systemd/system/jetson-clocks.service > /dev/null <<'EOF' > [Unit] > Description=Maximize Jetson clocks > After=nvpmodel.service > [Service] > Type=oneshot > ExecStart=/usr/bin/jetson_clocks > [Install] > WantedBy=multi-user.target > EOF > sudo systemctl enable jetson-clocks.service > ``` 3. **Use a fast and large storage device.** The Isaac™ ROS Docker images and the Bare Metal dependencies are large. If you are using an NVIDIA® Jetson™ development kit, follow the [NVIDIA® Jetson™ storage setup guide](https://nvidia-isaac-ros.github.io/getting_started/compute/jetson_storage.html) to install an NVMe SSD. If you are using a StereoLabs [ZED Box Orin](https://www.stereolabs.com/store/products/zed-box-orin), [ZED Box Mini](https://www.stereolabs.com/store/products/zed-box-mini), [ZED Box 2](https://www.stereolabs.com/store/products/zed-box-2), [ZED Box 2 Max](https://www.stereolabs.com/store/products/zed-box-2-max-t5000), or a [Mini Carrier board](https://www.stereolabs.com/store/products/zed-carrier-mini), the preinstalled NVMe SSD is already configured for optimal performance and no further configuration is required. #### x86_64 1. Install the latest NVIDIA® GPU driver by following the [official Ubuntu instructions](https://ubuntu.com/server/docs/how-to/graphics/install-nvidia-drivers/). If the current driver was installed from the NVIDIA® CUDA Apt repository, the new Ubuntu driver packages can fail to install because of file conflicts with the driver packages of the CUDA repository, for example `libnvidia-egl-xcb1`. In this case, remove the conflicting packages, or upgrade the driver from the same repository you used to install it. 2. Check that the driver version, the CUDA version, and the GPU memory satisfy the [requirements](#requirements): ```bash nvidia-smi ``` ### Create the Isaac™ ROS workspace Create a ROS 2 workspace and store its location in the `ISAAC_ROS_WS` environment variable. The Isaac™ ROS CLI uses this variable to locate your workspace: ```bash mkdir -p ~/workspaces/isaac_ros-dev/src echo 'export ISAAC_ROS_WS="${ISAAC_ROS_WS:-${HOME}/workspaces/isaac_ros-dev/}"' >> ~/.bashrc source ~/.bashrc ``` > **Note** > > On a Jetson™ AGX Orin development kit with the system installed on the eMMC, create the workspace on the NVMe SSD instead, for example in `/mnt/ssd/workspaces/isaac_ros-dev/`. ### Configure the Isaac™ ROS Apt repository 1. Set the locale to UTF-8: ```bash locale # check for UTF-8 sudo apt-get update && sudo apt-get install locales sudo locale-gen en_US en_US.UTF-8 sudo update-locale LC_ALL=en_US.UTF-8 LANG=en_US.UTF-8 export LANG=en_US.UTF-8 locale # verify settings ``` 2. Install the dependencies: ```bash sudo apt-get update && sudo apt-get install curl gnupg sudo apt-get install software-properties-common sudo add-apt-repository universe ``` 3. Register the Isaac™ ROS repository key and package source. The following commands track the latest Isaac™ ROS 5 minor version: #### Jetson ```bash k="/usr/share/keyrings/nvidia-isaac-ros.gpg" curl -fsSL https://isaac.download.nvidia.com/isaac-ros/repos.key | sudo gpg --dearmor \ | sudo tee -a $k > /dev/null f="/etc/apt/sources.list.d/nvidia-isaac-ros.list" sudo touch $f s="deb [signed-by=$k] https://isaac.download.nvidia.com/isaac-ros/release-5 noble-jetpack main" grep -qxF "$s" $f || echo "$s" | sudo tee -a $f sudo apt-get update ``` #### x86_64 ```bash k="/usr/share/keyrings/nvidia-isaac-ros.gpg" curl -fsSL https://isaac.download.nvidia.com/isaac-ros/repos.key | sudo gpg --dearmor \ | sudo tee -a $k > /dev/null f="/etc/apt/sources.list.d/nvidia-isaac-ros.list" sudo touch $f s="deb [signed-by=$k] https://isaac.download.nvidia.com/isaac-ros/release-5 noble main" grep -qxF "$s" $f || echo "$s" | sudo tee -a $f sudo apt-get update ``` > **Note** > > To use the China CDN, replace `isaac.download.nvidia.com` with `isaac.download.nvidia.cn`. To pin a specific minor version, replace `release-5` with the version, for example `release-5.0`. See the [NVIDIA® Isaac™ ROS Getting Started guide](https://nvidia-isaac-ros.github.io/getting_started/index.html#configure-isaac-ros-apt-repository) for details. 4. Install the Isaac™ ROS CLI: ```bash sudo apt-get install isaac-ros-cli ``` ## Install Isaac™ ROS 5 The Isaac™ ROS CLI supports two installation paths. Both provide the same Isaac™ ROS packages, and both work with ZED cameras: choose the one that best fits your use case. ### Choose your installation path | | Docker | Bare Metal | | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- | | **Where Isaac™ ROS runs** | In a development container managed by the Isaac™ ROS CLI | Directly on the host system | | **Impact on the host** | Minimal: only Docker and the NVIDIA® container runtime are installed on the host; all the other dependencies are installed in the container | Installs ROS 2 Lyrical and the Isaac™ ROS dependencies in the system, and modifies the system Python packages | | **Setup effort** | Configure Docker and the NVIDIA® container runtime, then build the image | Configure the Apt repositories and resolve version conflicts with the packages already installed | | **Recommended for** | Most users, as recommended by NVIDIA® | Advanced users | #### Docker path **Advantages** * **Highest isolation**: the Isaac™ ROS dependencies are not installed on your host system, so they cannot break other applications, and you can reset the environment by rebuilding the image. * **Reproducible**: the same image runs on every machine, which makes it easy to share a development environment within a team. * **No version conflicts to solve**: NVIDIA® provides the base Isaac™ ROS image with all the dependencies in the versions tested by NVIDIA®. **Disadvantages** * **Larger disk usage and longer setup**: the Isaac™ ROS image with ZED support uses about 11 GB of storage on Jetson™ and about 6 GB on x86_64, and about 30 GB on Jetson™ with the [object detection example](/docs/integrations/isaac-ros/object-detection/). Building it locally takes about 20 minutes on a Jetson™ AGX Orin. Each rebuild keeps the previous images until you remove them, for example with `docker image prune`. * **Changes inside the container are not persistent**: packages installed with `apt-get` in the container are lost when the container is removed. To keep them, you must add them to a custom image layer. * **Extra configuration for the hardware**: devices, data folders, and libraries of the host must be explicitly shared with the container. The [Use ZED with Isaac™ ROS](/docs/integrations/isaac-ros/use-zed-with-isaac-ros/) guide provides a ready-to-use configuration for ZED cameras. #### Bare Metal path **Advantages** * **No container**: you use your usual shell and tools, with direct access to the cameras, the drivers, and the graphical applications of the host. * **Faster setup and lower disk usage**: no image to download or build, and the ZED SDK and TensorRT of the host are used directly. **Disadvantages** * **Modifies the host system**: Isaac™ ROS installs Python packages in the system Python environment, and requires specific versions of CUDA, OpenCV, and TensorRT. On Jetson™, the OpenCV version provided by JetPack must be removed, which can affect other applications. * **Harder to undo**: removing Isaac™ ROS does not restore the packages that were replaced or removed during the installation. > **Note** > > The Isaac™ ROS CLI also supports a **Virtual Environment** mode, a middle ground between the two paths: the Debian packages are installed on the host as in the Bare Metal installation, but the Python packages are installed in a dedicated virtual environment. Follow the Bare Metal installation steps and see the note at the end of that section. ### Docker installation > **Note** > > Skip this section if you prefer the [Bare Metal installation](#bare-metal-installation). #### Configure Docker 1. Install Docker and the NVIDIA® Container Toolkit: * **Jetson™**: follow the [Jetson™ AGX Thor Docker setup guide](https://docs.nvidia.com/jetson/agx-thor-devkit/user-guide/latest/setup_docker.html) or the [Jetson™ AGX Orin Docker setup guide](https://docs.nvidia.com/jetson/agx-orin-devkit/user-guide/latest/setup_docker.html). Complete all the steps of the guide, even if Docker is already installed: the NVIDIA® runtime must be the default Docker runtime. You can set it with the following commands: ```bash sudo apt-get install -y jq sudo jq '. + {"default-runtime": "nvidia"}' /etc/docker/daemon.json | \ sudo tee /etc/docker/daemon.json.tmp && \ sudo mv /etc/docker/daemon.json.tmp /etc/docker/daemon.json ``` * **x86_64**: install the [Docker Engine](https://docs.docker.com/engine/install/ubuntu/#install-using-the-repository), then [install](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html#with-apt-ubuntu-debian) and [configure](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html#configuring-docker) the NVIDIA® Container Toolkit. 2. Add your user to the `docker` group and restart Docker: ```bash sudo usermod -aG docker $USER newgrp docker sudo systemctl daemon-reload && sudo systemctl restart docker ``` 3. Check that Docker can access the GPU. The `Default Runtime` must be `nvidia` on Jetson™, and the last command must print `NVIDIA runtime OK`: ```bash docker info | grep -E "Runtimes|Default Runtime" docker run --rm hello-world docker run --rm --gpus all ubuntu:24.04 bash -lc 'echo "NVIDIA runtime OK"' ``` On Jetson™, the error `invoking the NVIDIA Container Runtime Hook directly (e.g. specifying the docker --gpus flag) is not supported` means that the NVIDIA® runtime is not the default Docker runtime: set it as described in step 1, then restart Docker with `sudo systemctl restart docker`. 4. Initialize the Isaac™ ROS CLI in Docker mode: ```bash sudo isaac-ros init docker ``` 5. Create the user configuration files and folders that the Isaac™ ROS CLI shares with the container, if they do not exist yet: ```bash touch ~/.gitconfig ~/.bash_history mkdir -p ~/.ssh ~/.aws ~/.cache ~/.config ``` > **Warning** > > If one of these files or folders is missing, Docker creates it as an empty folder owned by `root` when the container starts. A `~/.gitconfig` folder breaks `git` on the host with the error `unable to access '/home//.gitconfig': Is a directory`. To fix it, exit the container and replace the folder with a file: `sudo rmdir ~/.gitconfig && touch ~/.gitconfig`. 6. Start the Isaac™ ROS development container: ```bash isaac-ros activate ``` The first time, the Isaac™ ROS CLI downloads the prebuilt Isaac™ ROS image from the [NVIDIA® NGC catalog](https://catalog.ngc.nvidia.com/orgs/nvidia/teams/isaac/containers/ros). This may take some time :coffee: When the container is ready, the command prompt changes to the container shell. Your workspace `${ISAAC_ROS_WS}` is mounted in the container. Enter the command `exit` to leave the container. Run `isaac-ros activate` in a new terminal to open another shell in the running container. For any problems with the Docker setup, refer to the [NVIDIA® Isaac™ ROS troubleshooting documentation](https://nvidia-isaac-ros.github.io/troubleshooting/index.html) and to the [Isaac™ ROS development environment documentation](https://nvidia-isaac-ros.github.io/concepts/dev_env/index.html). Continue with [Test the installation](#test-the-installation). ### Bare Metal installation > **Note** > > Skip this section if you followed the [Docker installation](#docker-installation). > **Warning** > > NVIDIA® recommends the Bare Metal mode only for advanced users: it modifies your host system and, without proper care, it can break it. Read the [disadvantages of the Bare Metal path](#bare-metal-path) before continuing. #### Configure the host for Isaac™ ROS 1. Configure the CUDA Apt repository: #### Jetson ```bash wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/sbsa/cuda-keyring_1.1-1_all.deb sudo dpkg -i cuda-keyring_1.1-1_all.deb rm cuda-keyring_1.1-1_all.deb sudo apt-get update ``` #### x86_64 ```bash wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-keyring_1.1-1_all.deb sudo dpkg -i cuda-keyring_1.1-1_all.deb rm cuda-keyring_1.1-1_all.deb sudo apt-get update ``` 2. **x86_64 only**: add the NVIDIA® binary folders to your `PATH` and configure the Jetson™ Apt repository, which also provides packages for x86_64: ```bash echo 'export PATH="/usr/local/nvidia/bin:/usr/local/cuda/bin:/usr/src/tensorrt/bin:${PATH}"' >> ~/.bashrc source ~/.bashrc curl -fsSL https://repo.download.nvidia.com/jetson/jetson-ota-public.asc | sudo gpg --dearmor | sudo tee /etc/apt/keyrings/nvidia-jetson.gpg > /dev/null echo 'deb [signed-by=/etc/apt/keyrings/nvidia-jetson.gpg] https://repo.download.nvidia.com/jetson/x86_64/noble r39.2 main' | sudo tee /etc/apt/sources.list.d/nvidia-jetson-apt-source.list ``` On Jetson™, these settings are already part of JetPack. 3. Configure the Isaac™ ROS Buildfarm Apt repository. The public ROS 2 repository does not provide ROS 2 Lyrical for Ubuntu 24.04: NVIDIA® builds the required ROS 2 Lyrical packages and publishes them on the Isaac™ ROS Buildfarm: ```bash k="/usr/share/keyrings/nvidia-isaac-ros.gpg" f="/etc/apt/sources.list.d/nvidia-isaac-ros-buildfarm.list" sudo touch $f s="deb [arch=$(dpkg --print-architecture) signed-by=$k] https://isaac.download.nvidia.com/isaac-ros/ubuntu/main noble main" grep -qxF "$s" $f || echo "$s" | sudo tee -a $f ``` 4. Configure the standard ROS 2 Apt repository, which provides the development tools such as `colcon` and `rosdep`. Skip this step if the repository is already configured, for example because ROS 2 Jazzy is installed: check it with `dpkg -l ros2-apt-source`. ```bash sudo apt-get update sudo apt-get install -y curl ROS_APT_SOURCE_VERSION="1.2.0" curl -fsSL -o /tmp/ros2-apt-source.deb "https://github.com/ros-infrastructure/ros-apt-source/releases/download/${ROS_APT_SOURCE_VERSION}/ros2-apt-source_${ROS_APT_SOURCE_VERSION}.$(. /etc/os-release && echo ${UBUNTU_CODENAME:-${VERSION_CODENAME}})_all.deb" sudo dpkg -i /tmp/ros2-apt-source.deb ``` 5. Install ROS 2 Lyrical and the development tools: ```bash sudo apt-get update sudo apt-get install -y ros-lyrical-ros-base sudo apt-get install -y python3-colcon-common-extensions python3-rosdep ``` Run `apt-cache policy ros-lyrical-ros-base` to check that the packages come from the Isaac™ ROS Buildfarm. To visualize the data, also install RViz2 with `sudo apt-get install -y ros-lyrical-rviz2`. > **Warning** > > Do not install the `ros-lyrical-desktop` package: on Ubuntu 24.04, some of its packages depend on libraries that are not available, such as OpenCV 4.10, PCL 1.15, and PySide6, and the installation fails with unmet dependencies. 6. Source the ROS 2 environment and enable the `colcon` auto-completion in every new shell: ```bash echo "source /opt/ros/lyrical/setup.bash" >> ~/.bashrc echo "source /usr/share/colcon_argcomplete/hook/colcon-argcomplete.bash" >> ~/.bashrc source ~/.bashrc ``` > **Warning** > > Do not source another ROS 2 distribution, such as ROS 2 Jazzy or Humble, or a workspace built for it, in the same shell as ROS 2 Lyrical. If your `~/.bashrc` file already sources one, remove or comment those lines, then open a new terminal. With mixed distributions, `rosdep` does not install the Lyrical dependencies that it finds in the other distribution, and the ZED ROS 2 Wrapper is built against packages of the wrong distribution. ROS 2 reports this situation with the warning `ROS_DISTRO was set to '' before`. 7. Initialize `rosdep` and add the Isaac™ ROS `rosdep` definitions: ```bash sudo rosdep init sudo curl -o /etc/ros/rosdep/sources.list.d/nvidia-isaac.yaml \ https://raw.githubusercontent.com/NVIDIA-ISAAC-ROS/isaac-ros-cli/release-5.0/docker/rosdep/extra_rosdeps.yaml echo "yaml file:///etc/ros/rosdep/sources.list.d/nvidia-isaac.yaml" | sudo tee /etc/ros/rosdep/sources.list.d/00-nvidia-isaac.list rosdep update ``` If `rosdep` is already initialized, for example by a previous ROS 2 installation, `sudo rosdep init` reports that the default sources list file already exists: you can ignore this error and continue with the next commands. 8. Remove conflicting packages. Isaac™ ROS 5 is tested with CUDA 13.2, OpenCV 4.6.0, and TensorRT 10.16. If different versions of these packages are installed on your host, remove them. On Jetson™ with JetPack 7.2, OpenCV 4.8.0 is installed by default and must be removed: ```bash sudo apt-get purge -y "libopencv*" "opencv*" ``` OpenCV 4.6.0 is installed automatically later by the Isaac™ ROS packages that require it. 9. Initialize the Isaac™ ROS CLI in Bare Metal mode, then answer `y` when the CLI asks you to confirm: ```bash sudo isaac-ros init baremetal ``` 10. Activate the Isaac™ ROS environment: ```bash isaac-ros activate ``` For more details and for the options of each step, refer to the [NVIDIA® Isaac™ ROS Getting Started guide](https://nvidia-isaac-ros.github.io/getting_started/index.html#initialize-isaac-ros-cli). > **Note** > > If you prefer the **Virtual Environment** isolation mode, which installs the Python packages in a dedicated virtual environment instead of the system Python, follow the same steps and replace `baremetal` with `venv` in the `isaac-ros init` command. ## Test the installation This test checks that Isaac™ ROS 5 runs GPU-accelerated nodes in your environment, without any camera. The ROS 2 `image_publisher` node publishes a test image provided by the Isaac™ ROS packages, and the Isaac™ ROS [`ImageFormatConverterNode`](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_image_pipeline/isaac_ros_image_proc/index.html) converts the published images on the GPU from the `bgr8` to the `rgb8` format. Run all the commands in the Isaac™ ROS environment. With the Docker installation, run `isaac-ros activate` in each new terminal to open a shell in the running container. 1. Install the packages used by the test: ```bash sudo apt-get update sudo apt-get install -y ros-lyrical-isaac-ros-image-proc ros-lyrical-image-publisher ``` > **Note** > > With the Docker installation, the packages installed with `apt-get` in the container are lost when the container is removed. This is not a problem for this test. 2. In a first terminal, publish a test image at 30 Hz on the `/image_raw` topic: ```bash ros2 run image_publisher image_publisher_node \ /opt/ros/lyrical/share/isaac_ros_image_proc/test/test_cases/NVIDIAprofile.png \ --ros-args -p publish_rate:=30.0 ``` 3. In a second terminal, start an empty ROS 2 component container: ```bash ros2 run rclcpp_components component_container --ros-args -r __node:=isaac_ros_test_container ``` 4. In a third terminal, load the Isaac™ ROS image format converter in the container: ```bash ros2 component load /isaac_ros_test_container isaac_ros_image_proc \ nvidia::isaac_ros::image_proc::ImageFormatConverterNode \ -p encoding_desired:=rgb8 \ -r image_raw:=/image_raw \ -r image:=/image_rgb8 ``` The command prints `Loaded component 1 into '/isaac_ros_test_container' container node`, and the container terminal must not report errors. 5. Check that the converted images are published at the same rate as the input images, about 30 Hz. Stop the command with `Ctrl+C`: ```bash ros2 topic hz /image_rgb8 ``` 6. Check that the images are converted: ```bash ros2 topic echo --once --field encoding /image_rgb8 ``` The output must be `rgb8`. If `/image_raw` is published but `/image_rgb8` is not, check that all the terminals use the same supported middleware, as described in [Middleware requirement](#middleware-requirement). Your Isaac™ ROS 5 installation works. Stop all the commands with `Ctrl+C`, then follow the [Use ZED with Isaac™ ROS](/docs/integrations/isaac-ros/use-zed-with-isaac-ros/) guide to add support for ZED cameras. To use Zenoh instead of the default Fast DDS middleware, follow the [Use Zenoh with Isaac™ ROS 5](/docs/integrations/isaac-ros/setup-and-installation/zenoh/) guide. For any problem, refer to the [NVIDIA® Isaac™ ROS troubleshooting documentation](https://nvidia-isaac-ros.github.io/troubleshooting/index.html). ## Docs - [Use Zenoh with Isaac™ ROS 5](https://docs.stereolabs.com/docs/integrations/isaac-ros/setup-and-installation/zenoh.md)