Getting Started with NVIDIA Jetson Platform

From RidgeRun Developer Wiki

Follow Us On Twitter LinkedIn Email Share this page


Event Cameras Developer Guide from RidgeRun
Table of Contents [Sticky]

Jetson Orin NX + Prophesee GenX360

This guide explains how to build and deploy the Prophesee GenX360 driver for a Jetson Orin NX running JetPack 6.2.1.

These instructions target:

  • JetPack 6.2.1
  • Jetson Linux R36.4.4
  • Linux kernel 5.15.148-tegra
  • Jetson Orin NX (tegra234, P3767 family)

The overall process is:

  1. Download the NVIDIA Jetson Linux public kernel sources
  2. Apply the RidgeRun GenX360 kernel patch
  3. Build the kernel modules and device-tree blobs
  4. Copy the generated artifacts to the Jetson Orin NX and enable the camera overlay
  5. Build and install OpenEB with the RidgeRun OpenEB patch
  6. Configure the runtime environment
  7. Run a basic OpenEB application

For additional background, refer to:

Hardware Setup

Required Hardware

  • Prophesee GenX360 camera module
  • NVIDIA Jetson Orin NX Developer Kit flashed with JetPack 6.2.1
  • Linux host PC with Internet access for building the kernel
  • Ethernet or USB network connection between the host PC and the Jetson target

Setup

Connect the GenX360 camera module to the NVIDIA Jetson Orin NX Developer Kit using the Jetson 24-pin CSI connector and the appropriate MIPI CSI-2 cable.

When connecting the camera, verify the flex cable orientation against the developer kit documentation and keep the system powered off while making the connection.

Before continuing, make sure the Jetson Orin NX has already booted successfully with JetPack 6.2.1.

Software Installation

All kernel build steps in this section are executed on the host PC unless stated otherwise.

Step 1: Prepare the Host Build Environment

Install the basic host-side packages: 

sudo apt update
sudo apt -y install git-core build-essential bc wget patch

Before running the remaining commands in this guide, set the user-dependent variables for your environment: 

export JETSON_ORIN_NX_IP_ADDRESS="Your Jetson board IP address"
export RIDGERUN_GENX360_REPOSITORY_URL="https://github.com/RidgeRun/genx320-jetson.git"
export GENX360_KERNEL_PATCH_FILENAME="orin-nx/6.2.1_nx_genx320_v0.1.0.patch"
export RIDGERUN_OPENEB_PATCH_FILENAME="orin-nx/openeb-5.1.1-jetson.patch"

Set the build variables: 

export JP_VERSION="6.2.1"
export L4T_VERSION="36.4.4"
export L4T_TAG="jetson_36.4.4"

export TOOLCHAIN_ROOT="$HOME/l4t-gcc"
export TOOLCHAIN_PREFIX="$TOOLCHAIN_ROOT/aarch64--glibc--stable-2022.08-1/bin/aarch64-buildroot-linux-gnu-"

export SRC_DL_ROOT="$HOME/jetpack-${JP_VERSION}-kernel-src"
export L4T_SRC_ROOT="$HOME/jetpack-${JP_VERSION}-kernel"

export RIDGERUN_REPO_URL="$RIDGERUN_GENX360_REPOSITORY_URL"
export RIDGERUN_REPO_DIR="$HOME/genx360-jetson"
export KERNEL_PATCH="$GENX360_KERNEL_PATCH_FILENAME"
export OPENEB_PATCH="$RIDGERUN_OPENEB_PATCH_FILENAME"

export DRIVER_MODULE_NAME="nv_genx320"
export OVERLAY_DTBO_NAME="tegra234-p3767-camera-p3768-genx320-dual"
export SENSOR_COMPATIBLE="prophesee,genx360"

export TARGET_USER="nvidia"
export TARGET_IP="$JETSON_ORIN_NX_IP_ADDRESS"
export TARGET="${TARGET_USER}@${TARGET_IP}"

Step 2: Download and Extract the NVIDIA Toolchain

Download the Bootlin cross-toolchain used by Jetson Linux R36.4.4: 

mkdir -p "$TOOLCHAIN_ROOT"
cd "$TOOLCHAIN_ROOT"
wget https://toolchains.bootlin.com/downloads/releases/toolchains/aarch64/tarballs/aarch64--glibc--stable-2022.08-1.tar.bz2
tar xf aarch64--glibc--stable-2022.08-1.tar.bz2

Optional verification: 

test -x "${TOOLCHAIN_PREFIX}gcc" && "${TOOLCHAIN_PREFIX}gcc" --version

Step 3: Download the NVIDIA Kernel Sources

Download the Jetson Linux public sources package for JetPack 6.2.1 / Jetson Linux R36.4.4: 

mkdir -p "$SRC_DL_ROOT"
cd "$SRC_DL_ROOT"
wget https://developer.nvidia.com/downloads/embedded/l4t/r36_release_v4.4/sources/public_sources.tbz2
tar xf public_sources.tbz2

mkdir -p "$L4T_SRC_ROOT"
tar xf Linux_for_Tegra/source/kernel_src.tbz2 -C "$L4T_SRC_ROOT"
tar xf Linux_for_Tegra/source/kernel_oot_modules_src.tbz2 -C "$L4T_SRC_ROOT"
tar xf Linux_for_Tegra/source/nvidia_kernel_display_driver_source.tbz2 -C "$L4T_SRC_ROOT"

After extraction, the source tree should contain at least these directories:

  • kernel
  • nvidia-oot
  • hardware/nvidia/t23x/nv-public/overlay

Step 4: Apply the RidgeRun GenX360 Kernel Patch

Clone the RidgeRun repository that contains the Jetson patch: 

git clone "$RIDGERUN_REPO_URL" "$RIDGERUN_REPO_DIR"
test -f "$RIDGERUN_REPO_DIR/$KERNEL_PATCH"

Apply the kernel patch at the root of the NVIDIA source tree: 

patch -d "$L4T_SRC_ROOT" -p1 < "$RIDGERUN_REPO_DIR/$KERNEL_PATCH"

Step 5: Build the Kernel Modules and Device Trees

Set the common build environment: 

cd "$L4T_SRC_ROOT"
export CROSS_COMPILE="$TOOLCHAIN_PREFIX"
export KERNEL_HEADERS="$PWD/kernel/kernel-jammy-src"
export INSTALL_MOD_PATH="${PWD}/rootfs/"

Build the NVIDIA out-of-tree modules: 

cd "$L4T_SRC_ROOT"
make modules
mkdir -p rootfs
make modules_install

Build the DTBs and DTBOs: 

cd "$L4T_SRC_ROOT"
make dtbs

Expected output artifacts:

  • nvidia-oot/drivers/media/i2c/nv_genx320.ko
  • kernel-devicetree/generic-dts/dtbs/tegra234-p3767-camera-p3768-genx320-dual.dtbo

Step 6: Copy the Generated Artifacts to the Jetson Orin NX

Copy the module and overlay to the target board: 

cd "$L4T_SRC_ROOT"

scp nvidia-oot/drivers/media/i2c/nv_genx320.ko \
  "$TARGET:/tmp/nv_genx320.ko"

scp kernel-devicetree/generic-dts/dtbs/tegra234-p3767-camera-p3768-genx320-dual.dtbo \
  "$TARGET:/tmp/tegra234-p3767-camera-p3768-genx320-dual.dtbo"

Step 7: Install and Enable the Driver on the Jetson Orin NX

The following steps are executed on the Jetson Orin NX target.

Install the copied artifacts: 

sudo install -m 0644 /tmp/tegra234-p3767-camera-p3768-genx320-dual.dtbo \
  /boot/tegra234-p3767-camera-p3768-genx320-dual.dtbo

KERNEL_RELEASE="$(uname -r)"   # JetPack 6.2.1 default: 5.15.148-tegra

sudo install -D -m 0644 /tmp/nv_genx320.ko \
  /lib/modules/${KERNEL_RELEASE}/updates/drivers/media/i2c/nv_genx320.ko

sudo depmod -a

Enable the camera overlay with Jetson-IO: 

sudo /opt/nvidia/jetson-io/jetson-io.py

In Jetson-IO:

  1. Select Jetson 24pin CSI Connector
  2. Enable the overlay Jetson Camera GENX320 Dual
  3. Save the configuration
  4. Reboot the Jetson

Step 8: Validate the Driver on the Jetson Orin NX

If needed, install the required tools: 

sudo apt update
sudo apt -y install v4l-utils gstreamer1.0-tools gstreamer1.0-plugins-base

After reboot, validate that the driver and overlay are active: 

DT_BASE=/sys/firmware/devicetree/base
grep -RIlas "$SENSOR_COMPATIBLE" "$DT_BASE" || echo "compatible not found in active DT"

dmesg | grep -Ei "genx320|genx360|camera|i2c"

v4l2-ctl --list-devices
media-ctl -p

Run a basic GStreamer pipeline: 

gst-launch-1.0 v4l2src ! fakesink silent=false -v

If the pipeline is working correctly, fakesink should print continuous log messages, typically one line per received buffer.

Step 9: Build and Install OpenEB

The following steps are executed on the Jetson Orin NX target.

Install the required OpenEB dependencies: 

sudo apt update
sudo apt -y install apt-utils build-essential software-properties-common wget unzip curl git cmake
sudo apt -y install libopencv-dev libboost-all-dev libusb-1.0-0-dev libprotobuf-dev protobuf-compiler
sudo apt -y install libhdf5-dev hdf5-tools libglew-dev libglfw3-dev libcanberra-gtk-module ffmpeg

Clone OpenEB and the RidgeRun repository: 

export OPENEB_BRANCH="5.1.1"
export OPENEB_SRC_DIR="$HOME/openeb"

git clone https://github.com/prophesee-ai/openeb.git --branch "$OPENEB_BRANCH" "$OPENEB_SRC_DIR"
git clone "$RIDGERUN_REPO_URL" "$RIDGERUN_REPO_DIR"
test -f "$RIDGERUN_REPO_DIR/$OPENEB_PATCH"

Apply the RidgeRun OpenEB patch: 

patch -d "$OPENEB_SRC_DIR" -p1 < "$RIDGERUN_REPO_DIR/$OPENEB_PATCH"

Configure, build, and install OpenEB: 

mkdir -p "$OPENEB_SRC_DIR/build"
cd "$OPENEB_SRC_DIR/build"

cmake .. -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTING=OFF
cmake --build . --config Release -- -j 4
sudo cmake --build . --target install

Install the udev rules and refresh them: 

sudo cp "$OPENEB_SRC_DIR"/hal_psee_plugins/resources/rules/*.rules /etc/udev/rules.d
sudo udevadm control --reload-rules
sudo udevadm trigger

Step 10: Configure the Runtime Environment

Add the required environment variables to ~/.bashrc: 

cat <<'EOF' >> ~/.bashrc

# OpenEB / Prophesee runtime environment
export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/usr/local/lib"
export HDF5_PLUGIN_PATH="$HDF5_PLUGIN_PATH:/usr/local/hdf5/lib/plugin"
export MV_HAL_PLUGIN_PATH="${MV_HAL_PLUGIN_PATH:-/usr/local/lib/metavision/hal/plugins}"
export PSEE_VAR_V4L2_BSIZE=1
EOF

Reload the shell configuration: 

source ~/.bashrc

Running Basic Examples

Data Streaming

Once the driver is installed, the overlay is enabled, and OpenEB is available, you can launch the OpenEB viewer: 

metavision_viewer

Data Recording and Replay

Display the available command-line options: 

metavision_viewer -h

To record a RAW file: 

metavision_viewer -o test.raw

Press the space bar to start recording, and press it again to stop.

To replay a previously recorded file: 

metavision_viewer -i test.raw

Development with OpenEB

To start developing applications with OpenEB and the Metavision APIs, refer to:



Retrieved from "https://developer.ridgerun.com/wiki/index.php?title=Event_Cameras_Developer_Guide/Getting_Started/NVIDIA_Jetson_Platform&oldid=78403"