Setting up the ZED X One Monocular

This guide explains how to set up a ZED X One Monocular camera on an NVIDIA® Jetson™ platform and use it to retrieve image and inertial data.

Install the GMSL2 driver #

⚠️ Important: This procedure is valid only for ZED Box Orin, ZED Box Mini, or official NVIDIA® Jetson™ development kit platforms equipped with a ZED Link GMSL2 Capture Card. If you are using a different GMSL2 system, please refer to the specific installation instructions provided by your hardware manufacturer.

ZED X One cameras require a GMSL2 driver to operate correctly. This driver configures the GMSL2 device and is hardware-dependent.

Download the appropriate driver from the ZED X Driver download page.

📌 Note: Always verify the latest driver version available on the download page. We recommend installing the most recent version.

Select the driver matching your hardware configuration and install it:

sudo dpkg -i stereolabs-<board>_X.X.X-<deserializer>-L4TZZ.Z.Z_arm64.deb

Where:

X.X.X is the driver version
<board> is the board model
<deserializer> is the deserializer type
L4TZZ.Z.Z is the Jetson™ Linux version (corresponding to your JetPack version)

Example: For ZED X Driver v1.3.2 on L4T 36.4.0 (JetPack 6.2) with the Stereolabs ZED Link Duo GMSL2 Capture Card:

sudo dpkg -i stereolabs-zedlink-duo_1.3.2-LI-MAX96712-all-L4T36.4.0_arm64.deb

📌 Note: If the installation fails due to missing dependencies, install libqt5core5a:
sudo apt install libqt5core5a

After installation, reboot your NVIDIA® Jetson™ platform.

For troubleshooting, refer to the ZED Link troubleshooting guide.

Use the ZED X One with the ZED SDK #

The ZED SDK includes built-in support for data acquisition from a ZED X One monocular camera using the sl::CameraOne class, allowing you to open and manage the camera directly through the SDK without relying on external tools.

Install the ZED SDK #

The ZED SDK enables processing of image data from ZED X One cameras in monocular mode. The sl::CameraOne class provides the core functionality to retrieve raw and rectified images, as well as inertial data.

To get started, download and install the ZED SDK on your NVIDIA® Jetson™ platform.

Sample code to open and use the ZED X One monocular camera #

C++
Python

#include <sl/CameraOne.hpp>

using namespace sl;

// Set the input from stream
InitParametersOne init_parameters;

// Set any InitParametersOne as needed to configure the camera settings

sl::CameraOne zed_one;

// Open the camera
ERROR_CODE err = zed_one.open(init_parameters);
if (err != ERROR_CODE::SUCCESS)
    exit(-1);

Mat bgra;

while (!exit_app) {
    if (zed_one.grab() == ERROR_CODE::SUCCESS) {
        zed_one.retrieveImage(bgra); // Retrieve the BGRA image (default format)

        // Any processing
    }
}
// Close the camera
zed_one.close();

import pyzed.sl as sl

zed_one = sl.CameraOne()

# Set the input from stream
init = sl.InitParametersOne()

# Set any InitParametersOne as needed to configure the camera settings

# Open the camera
err = zed_one.open(init)
if err != sl.ERROR_CODE.SUCCESS:
    exit(1)

bgra = sl.Mat()

while not exit_app:
    if zed_one.grab() == sl.ERROR_CODE.SUCCESS:
        zed_one.retrieve_image(bgra)  # Retrieve the BGRA image (default format)
        # Any processing

# Close the camera
zed_one.close()

For more details on using the ZED SDK with monocular ZED X One cameras, refer to the ZED SDK API documentation.

Use the ZED X One with NVIDIA® Libargus Camera API #

The camera can be opened using the Libargus Camera API, the tools provided by NVIDIA® on Jetson™ to open cameras connected via GMSL2 and CSI.

Make sure the multimedia API is installed:

sudo apt install nvidia-l4t-jetson-multimedia-api

Then compile the camera sample:

cp -r /usr/src/jetson_multimedia_api/* ./
sudo apt install libgtk-3-dev
cd argus
mkdir build && cd build && cmake .. && make
cp apps/camera/ui/camera/argus_camera ./
./argus_camera

Use the ZED X One with GStreamer #

Use the Stereolabs `zedxonesrc` source element #

Please refer to the ZED GStreamer plugin documentation to leverage the full capabilities of the ZED X One camera.

Use the NVIDIA® `nvarguscamerasrc` source element #

To open the camera using the nvarguscamera GStreamer plugin, run:

gst-launch-1.0 nvarguscamerasrc sensor-id=0 ! 'video/x-raw(memory:NVMM), width=(int)1920, height=(int)1200, framerate=30/1' ! nvvidconv flip-method=0 ! 'video/x-raw, format=(string)I420' ! xvimagesink -e

Please refer to the NVIDIA® documentation for more information.

Use the ZED X One with the open source driver ZED X Open Capture #

To use the ZED X One capture open source API, go to https://github.com/stereolabs/zedx-one-capture.

Compile the library, then modify the sample to fit your application.

The library is based on the multimedia API from NVIDIA®.

📌 Note: Support for retrieving IMU data will be available in a future release.

Use the ZED X One with ROS 2 #

The ZED ROS 2 wrapper supports monocular ZED X One data publishing.

When launching the ZED ROS 2 node, set the camera_model parameter to one of the available models: zedxonegs, zedxone4k. For example:

ros2 launch zed_wrapper zed_camera.launch.py camera_model:=zedxonegs

ros2 launch zed_wrapper zed_camera.launch.py camera_model:=zedxone4k

For more details on using the ZED ROS 2 wrapper, refer to the ZED ROS 2 documentation.