ZED Link MIPI Quad on AGX Thor with Holoscan Sensor Bridge

This tutorial will help you assemble the ZED Link MIPI Quad capture card on an NVIDIA® Holoscan Sensor Bridge (HSB), connect it to an NVIDIA® Jetson AGX Thor™ Developer Kit, and stream up to two ZED X One Core cameras.

How it works

On the AGX Orin Developer Kit, the ZED Link MIPI Quad plugs directly into the CSI connector of the carrier board. The Jetson AGX Thor™ Developer Kit does not expose a MIPI CSI-2 connector, so the capture card is instead mounted on an NVIDIA® Holoscan Sensor Bridge, which converts the MIPI streams into Camera-over-Ethernet (CoE) and sends them to the Thor over a 10 Gb Ethernet link. On the host, the frames are processed by NVIDIA’s SIPL hardware imaging engine and delivered to your application by the ZED SDK.

The full chain is:

Frames travel downward through this diagram. The installation, on the other hand, goes from the bottom up: the FPGA firmware of the bridge board first, then the driver, then the ZED SDK, which is the order of this guide.

Prerequisites

Hardware

Make sure that you have the following items before starting this guide:

• 1x NVIDIA® Jetson AGX Thor™ Developer Kit, with a QSFP+ port
• 1x NVIDIA® Holoscan Sensor Bridge, Lattice CPNX100-ETH-SENSOR-BRIDGE board (also referred to as HSB Lite by the NVIDIA® firmware tools)
• 1x ZED Link MIPI Quad capture card
• 1x or 2x ZED X One Core cameras
• 1x MIPI I-PEX cable per camera (one cable is included with each ZED X One Core)
• 1x QSFP+ to 4x SFP+ breakout cable
• 1x USB-C power supply for the Holoscan Sensor Bridge, or a free USB-C port on the Developer Kit (see Power up)
• 1x NVIDIA® power supply to power the Developer Kit (included with the devkit)

Software

You do not need CMake, the ZED SDK sources, the CUDA development packages, or the Holoscan SDK to complete this guide.

If you encounter any issues during the installation process, please refer to the MIPI Troubleshooting page, which has a section dedicated to the Holoscan Sensor Bridge, or contact support@stereolabs.com.

Step 1: Assemble the hardware

The Holoscan Sensor Bridge at a glance

Three interfaces of the bridge board are used in this guide: the Camera Connector, where the ZED Link MIPI Quad is mounted, the top SFP+ cage, which carries the video to the Jetson, and the USB-C power input.

Mount the capture card on the Holoscan Sensor Bridge

Align the 120-pin J10 Samtec connector on the bottom of the ZED Link MIPI Quad with the Camera Connector (J9) of the Holoscan Sensor Bridge, then press the card down firmly until the two connectors are fully mated. This is the only connector the capture card mates with, and it also powers the card.

The capture card sits over the right half of the bridge board, with its four camera connectors facing up.

Connect the cameras

Each camera channel of the ZED Link MIPI Quad uses a 30-pin, 0.4 mm pitch Micro I-PEX receptacle. Insert the plug of the MIPI I-PEX cable into the receptacle and press it down gently until it is fully seated, then connect the free end of the cable to the connector on the back of the ZED X One Core camera.

The four channels are silkscreened 4-Lane CH1 to 4-Lane CH4 on the front side of the card:

Connect the first camera to J1, and the second one, if any, to J2.

Then connect the free end of each cable to the camera:

Cable the bridge to the Jetson AGX Thor

The link between the bridge and the Jetson uses the top SFP+ cage of the bridge. The silkscreen labels of the two cages are printed on the board, just to the right of each of them.

On the Developer Kit, the QSFP+ cage is the wide port on the connection panel, between the power connector and the two USB-C ports:

1. Plug the QSFP+ end of the breakout cable into the QSFP+ port of the Jetson AGX Thor™ Developer Kit.

2. Plug the first SFP+ leg of the breakout cable into the top SFP+ port of the bridge, labeled J2/J3, shown in the board photo above.

The four legs of the breakout cable map to the mgbe0_0 to mgbe3_0 host interfaces, in order. This guide, and the camera configuration files shipped in the driver package, are written for mgbe0_0, which is the first leg. If you use a different leg, you must change the interface name accordingly in every command below.

Power up

Connect the USB-C power supply to the Holoscan Sensor Bridge, plug the NVIDIA® power supply of the Developer Kit, connect the optional HDMI, keyboard, and mouse, then power up both boards. The cameras are powered through the MIPI I-PEX cables, so they need no additional power supply.

Once cabled, the bridge board carries the SFP+ leg on its top cage and the USB-C power cable on the opposite side:

Step 2: Configure the host network

The bridge board has a fixed IP address of 192.168.0.2. Put the mgbe0_0 interface of the Jetson on the same subnet so that it can reach the board:

EN0=mgbe0_0
sudo nmcli con add con-name hololink-$EN0 ifname $EN0 type ethernet ip4 192.168.0.101/24
sudo nmcli connection modify hololink-$EN0 +ipv4.routes 192.168.0.2/32
sudo nmcli connection up hololink-$EN0

Then check that the board answers:

ping -c 3 192.168.0.2

If ping succeeds, the link is good. If it fails, check the interface name with ip link, verify that ip -br link reports mgbe0_0 as UP, and make sure no other network configuration overrides the IP address.

Step 3: Check the FPGA firmware version

The Holoscan Sensor Bridge runs its own FPGA firmware, called the HSB IP, which is completely independent from the software installed on the Jetson. It must be recent enough before anything can stream.

Build the Holoscan Sensor Bridge tools

hololink-enumerate, hololink-read, and hsb_flasher are NVIDIA® tools from the Holoscan Sensor Bridge project. They are not part of the StereoLabs driver package, so they must be built once on the Jetson. Only the small native C++ tools are needed, not the Holoscan SDK, so the build takes a couple of minutes.

Install the build dependencies:

sudo apt update
sudo apt install -y build-essential git cmake \
    libfmt-dev libssl-dev libcurl4-openssl-dev libyaml-cpp-dev python3-dev

Clone the release this guide is written against:

git clone --branch 2.7.0 --depth 1 \
    https://github.com/nvidia-holoscan/holoscan-sensor-bridge.git
cd holoscan-sensor-bridge

Configure a tools-only build and build the three tools:

cmake -B build \
    -DHOLOLINK_BUILD_ONLY_NATIVE=ON \
    -DHOLOLINK_BUILD_EXAMPLES=OFF \
    -DHOLOLINK_BUILD_TESTS=OFF \
    -DHOLOLINK_BUILD_PYTHON=OFF \
    -DHOLOLINK_BUILD_ROCE=OFF \
    -DHOLOLINK_BUILD_EMULATOR=OFF
cmake --build build -j$(nproc) \
    --target hololink-enumerate hololink-read hsb_flasher

The binaries are produced in the build tree, relative to the holoscan-sensor-bridge folder:

The two read-only tools are self-contained and can be installed system-wide:

sudo install -m 755 build/tools/enumerate/hololink-enumerate \
                    build/tools/read/hololink-read /usr/local/bin/

Read the current version

The bridge board broadcasts its identity once per second, so hololink-enumerate only needs to listen: no control connection is required and nothing has to be streaming.

hololink-enumerate -i mgbe0_0 -t 10

mac_id=48:B0:2D:EE:84:DA hsb_ip_version=0x2510 fpga_crc=0xffff ip_address=192.168.0.2
  fpga_uuid=889b7ce3-65a5-4247-8b05-4ff1904c3359 serial_number=1003003282811 interface=mgbe0_0 board=hololink-lite

hsb_ip_version is the value to check. The board=hololink-lite field confirms that the board is the Lattice CPNX100-ETH-SENSOR-BRIDGE.

On a board that already answers ping, the version register can also be read directly:

hololink-read -H 192.168.0.2 0x80    # HSB_IP_VERSION
hololink-read -H 192.168.0.2 0x84    # FPGA datecode

If hololink-enumerate prints nothing at all, no board is broadcasting: check that the bridge is powered, that ip -br link shows mgbe0_0 as UP, then redo Step 2.

Upgrade the firmware

hsb_flasher recognizes the board from its FPGA UUID and selects the right flash routine and images automatically, so no board-specific option is needed:

# 1. Confirm that the board is reachable
ping -c 3 192.168.0.2
# 2. Flash, from the holoscan-sensor-bridge folder. Omit -t to take the newest
#    firmware available, or pin the version validated by StereoLabs (hex, no 0x prefix)
./build/tools/hsb_flasher/hsb_flasher -H 192.168.0.2 -t 2510
# 3. POWER CYCLE the bridge board: the new image only takes effect after a full power-off
# 4. Confirm the new version
hololink-enumerate -i mgbe0_0 -t 10

Points to keep in mind before flashing:

• Nothing else may be talking to the board. The control plane accepts exactly one client, so close ZED Studio and any other tool first.
• The Jetson needs internet access. hsb_flasher downloads the CLNX and CPNX images from the NVIDIA® server and verifies their MD5 checksum. If the board is offline, fetch the two .bit files on another machine and pass them explicitly:

  ./build/tools/hsb_flasher/hsb_flasher -H 192.168.0.2 \
      --clnx fpga_clnx_v2510.bit --bitfile fpga_cpnx_v2510.bit
• If the board already runs the target version, the tool exits without doing anything. Add --reapply to force a reflash.
• Firmware older than 0x2407 is not handled by this flasher. Follow the NVIDIA® HSB 2.0 update procedure first, then come back to this step.

The complete upstream procedure is available in the NVIDIA® Holoscan Sensor Bridge documentation.

Step 4: Install the ZED Link MIPI driver

This package contains everything the Jetson needs to see the camera: the AR0234 sensor driver, the Camera-over-Ethernet transport driver, the camera configuration, and the ISP tuning. There is nothing to build and nothing to copy by hand.

Unpack the archive sent by StereoLabs and install the Debian package:

sudo dpkg -i sipl-uddf-drivers_<version>-R392_arm64.deb

Check that the five files are correctly installed:

dpkg -L sipl-uddf-drivers | grep -E '\.so$|\.json$|\.nito$'

/usr/lib/nvsipl_drv/libar0234_library.so
/usr/lib/nvsipl_drv/libhsb_transport_library.so
/var/nvidia/nvcam/settings/sipl/nova0_camera.json
/var/nvidia/nvcam/settings/sipl/nova1_camera.json
/var/nvidia/nvcam/settings/sipl/ZED_AR0234CS_HAWK.nito

If any of them is missing, the installation failed: run dpkg -i again and read its output.

To remove or upgrade the package later:

sudo dpkg -r sipl-uddf-drivers                          # remove
sudo dpkg -i sipl-uddf-drivers_<new-version>_arm64.deb  # upgrade in place

Step 5: Install the ZED SDK

The ZED SDK turns the SIPL pipeline into a regular ZED camera, accessible through the sl::CameraOne API, and it ships ZED Studio. Camera-over-Ethernet support is built into the v5.5 release.

Download the installer matching your Jetson Linux version from the StereoLabs developer page, then run it:

chmod +x ZED_SDK_Tegra_L4T39.2_v5.5.0.zstd.run
./ZED_SDK_Tegra_L4T39.2_v5.5.0.zstd.run

The L4T39.2 part of the filename must match the release reported by /etc/nv_tegra_release. Answer the prompts of the installer and accept the license; the optional AI models and the Python API are not required for this guide. The SDK is installed in /usr/local/zed/.

More details are available in the Install the ZED SDK on NVIDIA® Jetson guide.

Step 6: Verify the installation

Check that the cameras are detected:

ZED_Studio --list

Each connected ZED X One Core is listed with its serial number and an Input type: HOLOLINK field. ZED_Explorer --all lists them as well. If nothing is listed, see the MIPI Troubleshooting page.

Open ZED Studio to get a live view and select the camera in the device list:

ZED_Studio

The ISP tuning shipped in the driver package is applied automatically, so the image arrives fully processed, with auto exposure and auto white balance already running.

A camera can also be opened directly at a given resolution and framerate, using the serial number printed by --list:

ZED_Studio --camera <serial_number> HD1200 30
ZED_Studio --camera <serial_number> HD1080 60

In this configuration, the ZED X One Core supports the following video modes, each at 15, 30, or 60 fps:

Any other value falls back to the closest supported mode.

Multi-camera configuration

Only the J1 and J2 channels of the ZED Link MIPI Quad are wired through the Holoscan Sensor Bridge, so this configuration supports a maximum of two cameras.

The two cameras are hardware-synchronized by the FPGA of the capture card, with a precision of 15 µs, so no jumper or external wiring is required. They can be used as a virtual stereo camera in the ZED SDK, after calibration: see Setting up the ZED X One Stereo.

Quick reference

End-to-end command summary:

# 1. Host network
EN0=mgbe0_0
sudo nmcli con add con-name hololink-$EN0 ifname $EN0 type ethernet ip4 192.168.0.101/24
sudo nmcli connection modify hololink-$EN0 +ipv4.routes 192.168.0.2/32
sudo nmcli connection up hololink-$EN0
ping -c 3 192.168.0.2
# 2. FPGA firmware, must be 0x2510 or newer
hololink-enumerate -i mgbe0_0 -t 10
# only if too old: flash, then POWER CYCLE the bridge board
./build/tools/hsb_flasher/hsb_flasher -H 192.168.0.2 -t 2510
# 3. Camera driver package
sudo dpkg -i sipl-uddf-drivers_<version>-R392_arm64.deb
# 4. ZED SDK
chmod +x ZED_SDK_Tegra_L4T39.2_v5.5.0.zstd.run
./ZED_SDK_Tegra_L4T39.2_v5.5.0.zstd.run
# 5. Run
ZED_Studio --list       # confirm the detection
ZED_Studio              # live view

Troubleshooting

The troubleshooting checks for this configuration are gathered on the MIPI Troubleshooting page, alongside the ones shared with the AGX Orin Developer Kit:

• Common checks and commands, to list the cameras seen by the ZED SDK and inspect the capture pipeline.
• Holoscan Sensor Bridge on Jetson AGX Thor, for the symptoms specific to this setup: no device listed, a single camera detected, firmware too old, black live view, recovering the Ethernet connection, and cleaning up the SIPL log output.

🎉 Congratulations! You have successfully assembled your StereoLabs ZED Link MIPI Quad capture card on an NVIDIA® Holoscan Sensor Bridge and connected it to your NVIDIA® Jetson AGX Thor™ Developer Kit. Now that the cameras are up and running, it is time to start experimenting and building your projects. Happy coding!