Skip to content

Zed2i Camera

Jump to bottom
Simran Cheema edited this page Aug 18, 2026 · 2 revisions

ZED2i Overview

The ZED2i is a stereo camera that provides high-definition 3D video and neural depth perception. Its core capabilities include depth sensing, positional tracking, object detection, and more.

To use these features, the ZED SDK must be installed. The SDK is the underlying library that enables access to the camera's full feature set. Any system used with the ZED2i must meet the SDK's system requirements, documented in the ZED documentation.

The compiled system requirements for ZED SDK v4.x are:

Component Requirement
OS Ubuntu 18.04 (Legacy), 20.04, 22.04 / Windows 10, 11
CUDA Version 11.x or 12.x
GPU NVIDIA GPU with Compute Capability ≥ 5.0 (Pascal or newer)
RAM 4 GB minimum (8 GB+ recommended)
CPU Quad-core or better
USB USB 3.0

Note: ZED SDK v5.x adds Ubuntu 24.04 support on desktop. On Jetson, the SDK runs inside Docker regardless of the host OS, so Ubuntu version compatibility is handled by the container image rather than the host.

Running the ZED2i on the Jetson (Docker, ROS 2 Jazzy)

On the Jetson, the ZED SDK and the ROS 2 wrapper run inside a Docker container rather than being installed directly on the host. This is the recommended and officially supported approach from StereoLabs, and it also resolves an important compatibility constraint explained below.

Why Docker on the Jetson?

There is a version mismatch between what JetPack currently provides and what ROS 2 Jazzy requires:

  • JetPack 6.x (the current Jetson OS) is based on Ubuntu 22.04, not 24.04.
  • ROS 2 Jazzy has Tier 1 support only on Ubuntu 24.04. Running the wrapper inside a Docker container sidesteps this entirely. The container provides Ubuntu 24.04 + Jazzy + the ZED SDK as a self-contained environment, while the Jetson host remains on JetPack 6.x as normal. The ZED SDK Docker images for Jetson are based on NVIDIA's L4T (Linux for Tegra) base image, which has direct access to the Jetson's GPU and camera hardware through the NVIDIA container runtime.

Prerequisites on the Jetson Host

Before pulling or building any container, verify the following on the Jetson itself:

  1. JetPack is installed — check the version with:
   sudo apt-cache show nvidia-jetpack | grep Version

Note the L4T version (r36.x.x), as it must match the Docker image tag.

  1. NVIDIA Container Runtime is available — it ships with JetPack. Confirm with:
   sudo docker info | grep nvidia

You should see nvidia listed under Runtimes. If not, install it:

   sudo apt install nvidia-container-runtime
  1. Docker is installed:
   docker --version

Pulling the ZED SDK Image for Jetson

StereoLabs provides pre-built Docker images tagged by ZED SDK version and L4T version. These are hosted on DockerHub.

The Jetson image tag format is:

stereolabs/zed:<sdk_version>-<variant>-l4t-r<l4t_version>

For example, for ZED SDK 5.3 on JetPack 6.x (L4T r36.5):

docker pull stereolabs/zed:5.3-devel-l4t-r36.5

Important: The L4T version in the image tag must match the L4T version running on the Jetson host. A mismatch will cause GPU and camera access to fail inside the container.

Available variants:

  • runtime — minimum dependencies for running ZED applications (production use)
  • devel — includes CUDA headers, static libraries, and compilation tools (development use)
  • tools-devel — most complete; includes ZED SDK sample tools on top of devel

Building the ZED ROS 2 Wrapper Image

StereoLabs provides build scripts in the zed-ros2-wrapper repository that generate a Dockerfile for the correct combination of L4T version, ZED SDK version, and ROS 2 distro.

Clone the wrapper repository:

git clone --recursive https://github.com/stereolabs/zed-ros2-wrapper.git
cd zed-ros2-wrapper/docker

Then run the Jetson build script, substituting your L4T and ZED SDK versions:

# Example: JetPack 6.2 (L4T r36.4.0) + ZED SDK 5.0
./jetson_build_dockerfile_from_sdk_and_l4T_version.sh l4t-r36.4.0 zedsdk-5.0.0
 
# Example: JetPack 6.0 (L4T r36.3.0) + ZED SDK 4.2.5
./jetson_build_dockerfile_from_sdk_and_l4T_version.sh l4t-r36.3.0 zedsdk-4.2.5

This will build an image that contains the ZED SDK, the ROS 2 wrapper (compiled against Jazzy), and all required dependencies.

If the zed-ros2-interfaces submodule was not cloned automatically during the initial clone:

git submodule update --init --recursive

Running the Container

Once the image is built, start the container with access to the GPU and camera:

docker run -it --runtime nvidia --privileged \
  -v /tmp/.X11-unix:/tmp/.X11-unix \
  -e DISPLAY \
  <image_name>
  • --runtime nvidia activates the NVIDIA container runtime for GPU access.
  • --privileged grants the container access to the USB-connected ZED2i camera.
  • The -v /tmp/.X11-unix and -e DISPLAY flags are only needed for GUI tools like ZED Explorer. To persist the workspace and avoid re-downloading neural network models on every container start, mount volumes for those directories:
docker run -it --runtime nvidia --privileged \
  -v ~/ros2_ws:/ros2_ws \
  -v /usr/local/zed/resources:/usr/local/zed/resources \
  <image_name>

Verifying the Setup Inside the Container

Once inside the container, confirm the ZED SDK can see the camera:

# Check camera USB connection from inside the container
lsusb | grep STEREOLABS
 
# Source the ROS 2 workspace
source /ros2_ws/install/setup.bash
 
# Confirm ROS 2 Jazzy is active
ros2 --version

Additional Resources

UVic Rover 2027 Wiki

Clone this wiki locally