Jetson Carrier

Introduction

Jetson Carrier is an entry-level development board tailored for AI beginners, built on the NVIDIA® Jetson series hardware platform. Boasting core advantages of high cost-effectiveness, user-friendliness, and abundant resources, it helps you effortlessly bridge the gap between AI theory and practice, and quickly get hands-on with development and practical projects.

High Cost-Effectiveness with Powerful Computing Power

  • Compatible with Jetson Xavier™ NX, Jetson TX2™ NX, and Jetson Nano™ core boards, with AI computing power ranging from 472 GFLOPS to 21 TOPS
  • Easily handle various tasks from basic image classification to complex generative AI
  • Low price threshold, enabling every learner to get started with ease

Rich Interfaces for Flexible Expansion

  • Image Acquisition: Supports 2 dual-channel + 1 quad-channel MIPI-CSI interfaces, compatible with up to 4K cameras
  • Peripheral Connection: 40-pin GPIO compatible with the Raspberry Pi ecosystem, easily connecting servos, LEDs, various sensors, etc.
  • Communication and Control: Supports multiple communication protocols including PWM, I2C, SPI, UART
  • High-Speed Transmission: Equipped with 4 USB 3.0 ports, a Gigabit Ethernet port, and HDMI 2.0 output
  • Storage and Network Expansion: Supports M.2 Key-M (NVMe SSD), MicroSD card, and M.2 Key-E (Wi-Fi/Bluetooth module)
  • Reliable Power Supply: DC power interface + PD protocol support for stable operation
  • System Debugging: Integrated DEBUG and system flashing interfaces for more convenient development

Stable Design for Diverse Scenarios

  • Compact PCB layout, with reverse insertion protection and ESD protection design for interfaces, ensuring safe usage
  • Widely supports typical AI applications:
    • Real-time face recognition and target tracking
    • ROS robot development
    • Edge-side deployment of generative AI models

Technical Specifications

  • Compatible Modules: Jetson Xavier™ NX, Jetson TX2™ NX, Jetson Nano™
  • Power Input:
    • Supports PD 60W protocol power supply
    • Supports DC 12V–24V power interface
  • Image Acquisition Interfaces:
    • 2-channel MIPI-CSI × 2
    • 4-channel MIPI-CSI × 1
  • External Interfaces:
    • USB 3.0 × 4
    • Gigabit Ethernet port
    • HDMI 2.0
  • Storage Expansion:
    • M.2 Key-M (supports NVMe SSD)
    • MicroSD card slot
  • Wireless Expansion:
    • M.2 Key-E (for installing Wi-Fi/Bluetooth modules)
  • Debugging and System Flashing:
    • Dedicated DEBUG interface
  • General-Purpose Interfaces:
    • 40Pin GPIO
  • Product Dimensions: 75mm × 120mm

Interface Layout

image

Product Dimensions

image

System Installation

NVIDIA SDK Manager

NVIDIA Software Development Kit (SDK) Manager is an all-in-one tool that bundles developer software and provides an end-to-end development environment setup solution for NVIDIA SDKs.

SDK Manager provides you with:

  • Support for different NVIDIA hardware development platforms.
  • Ability to flash different operating systems.
  • A central hub for all your software development needs.
  • Fast, easy, and straightforward setup of your development environment.
  • Coordination of SDK, library, and driver combinations, as well as any required compatibility or dependencies.
  • Software update notifications to keep your system up to date.

Download and Run SDK Manager

The latest version of the NVIDIA SDK Manager can be downloaded from the following URL:

https://developer.nvidia.com/nvidia-sdk-manager

Offline

Download SDK Manager via NVONLINE using one of the following two methods:

  1. Open the activity filter by enabling the Show Groups Only option, then click the hyperlink for NVIDIA SDK Manager.
  2. In the search field, type "SDK Manager" and click "Search". Locate and click the hyperlink for NVIDIA SDK Manager.

Install SDK Manager

  1. From the terminal, install SDK Manager using one of the following methods.

    • Ubuntu Host: Install the Debian package.

      Ubuntu 16.04, 18.04, 20.04, or 22.04:

      sudo apt install ./sdkmanager_[version]-[build#]_amd64.deb

    • CentOS / Red Hat Enterprise Linux Host: Install the RPM package.

      CentOS / Red Hat Enterprise Linux 8.0 or 8.2:

      sudo dnf install ./sdkmanager_[version]-[build#].x86_64.rpm

      CentOS / Red Hat Enterprise Linux 7.6:

      sudo yum install ./sdkmanager_[version]-[build#].x86_64.rpm
      Note: On CentOS 8.0 and 8.2, you may encounter the following installation error:Failed to download metadata for repo 'AppStream'In this case, check the functionality of the repository and switch to another mirror if necessary.

  2. You can launch SDK Manager using one of the following two methods

    • Launch SDK Manager from the Ubuntu launcher.

    • Open a terminal and launch SDK Manager with the following command:

      sdkmanager
Log in to SDK Manager

  1. Select the appropriate login tab for your account type and installation.

    • NVIDIA Developer — developer.nvidia.com

      a. In your browser, enter your email address and click Sign In.

      b. On the SDK Manager login page, enter the password for your NVIDIA Developer account and click Login.

      c. Once completed, SDK Manager will launch.

      image

    • QR Code Login Option:

      a. Click the QR code icon in the login panel.

      b. When the QR code image appears, scan the code with a camera app on another device.

      c. Enter the credentials for your NVIDIA Developer account on that device.

      d. Once completed, SDK Manager will launch.

      image

    • NVONLINE — partners.nvidia.com

      Enter the credentials for your NVONLINE account and click LOGIN.

      image

    • Offline — Install an SDK that was previously downloaded and available from a local folder or installed drive. For details, refer to

      image

  2. Before proceeding, select whether to enable data collection.

Install Jetson Software Using SDK Manager

This section is designed to help you successfully configure your development environment using the NVIDIA SDK Manager GUI

Step 1: Equipment Preparation

  1. Jetson Carrier motherboard.
  2. Ubuntu 18.04 virtual machine (or computer host).
  3. 5V 4A power adapter.
  4. USB data cable (Micro USB interface, capable of data transmission).

Step 2: Hardware Configuration (Enter Recovery Mode)

  1. Connect the "DBUG&Recovery" interface of the motherboard with a Type-C data cable (note: it must be a data cable)

    image

  2. Move the switch to the Recovery end

    image

  3. Press and hold the REC button, then connect the power supply to power on the board

    image

Step 3: Set Up the Development Environment

  1. From the Step 01 Development Environment window, select the following:

    • From the Product Category panel, select Jetson.

    • From the Hardware Configuration panel, select the host and target hardware.

      image

      If one Jetson device is connected (or multiple Jetson devices are connected), SDK Manager will automatically select it in the target hardware drop-down list. If your device is not detected automatically, click Refresh. You can hover your mouse over the message to display detailed information about the detected hardware.

      image

      image

    • From the Target Operating System panel, select the operating system and JetPack version.

    • If applicable, select any Additional SDKs you wish to install.

      An ellipsis (...) in the bottom right corner of a category box indicates multiple options are available. Click the ellipsis to display a drop-down menu of available options.

      image

      Note: Your display may differ from the one shown here. The information on this screen is populated based on your NVIDIA user account access and permissions. If your product category is not visible in the available options, confirm that your NVIDIA account is registered for the required program.

  2. Click Continue to proceed to the next step.

Step 4: View Components and Accept the License

  1. In Step 02 Details and License, you can expand the Host Components and Target Components panels to view the components that will be installed on your system.

    image

    Note: Checking both may result in download failure due to insufficient EMMC space.

  2. To view the license, click license agreements at the bottom of the page.

  3. Enable the checkbox to accept the terms and conditions of the license agreement.

  4. If you want the SDK Manager to download all installation files to a location other than the default path, go to the Download and Install options at the bottom of the screen, then select the path you wish to use.

    image

    For more information about the Download and Install options, refer to Offline Installation.

  5. Select Continue to proceed to the next step.

Step 5: Installation

  1. Before installation starts, the SDK Manager will prompt you to enter your sudo password.

    image

  2. The display shows the progress of software download and installation.

    image

    Select Pause / Resume to toggle the download and installation process.

  3. At the top, you can switch between the Details and Terminal tabs. The Terminal tab displays detailed information about the download and installation, and highlights any errors.

  4. On the Terminal tab, you can use the Filter text field to filter and search for specific information.

  5. When the SDK Manager is ready to flash your target device, it will open a dialog box. The prompt provides instructions for preparing the device for flashing.

    Note: The instructions in the flashing dialog box vary depending on your host and target environment settings.
    Note: Jetson Nano Developer Kit users need to insert a microSD card into the slot at the bottom of the Jetson Nano module; otherwise, the flashing process will fail.

    The SDK Manager supports two options for putting the Jetson target into Force Recovery Mode:

    • Automatic setup: Set the target to Force Recovery Mode via remote commands. This requires the device to be flashed and currently running. Follow the instructions in the flashing dialog box.

      image

    • Manual setup: Set the target to Force Recovery Mode through manual operation.

      image

      You can also choose whether to preconfigure the OEM configuration.

    • Pre-Config: The SDK Manager will flash the target with predefined configurations, and there is no need to complete the system configuration wizard after flashing.

      image

    • Runtime: No default configuration is set on the target, and you need to manually complete the system configuration wizard after flashing.

      Starting from JetPack version 4.6, Jetson AGX Xavier and Orin modules can be flashed to external storage. According to the available options in the flashing dialog box, select the external storage to flash to (EMMC, SDCard, NVMe, USB, or Custom).

  6. After the SDK Manager completes the flashing process, the display connected to the Jetson system will show initial setup prompts.

    • As part of the initial setup process, set a username and password for the Jetson system.

    • After the initial setup process is completed, the Jetson system boots to the Linux desktop.

    • Enter the same username and password you created during Jetson configuration in the post-flash installation dialog box of the SDK Manager.

      image

      The SDK Manager will now complete the installation of software libraries. Skipping this step will not install any SDK components on your target hardware, leaving a clean operating system on your device.

Step 6: Complete the Setup

  1. In Step 04 Summary Finalization, there is a summary of the installed components, as well as any warnings or errors encountered.

  2. The Export Debug Logs link creates a ZIP file containing all log files generated during installation. This ZIP file is located in the same folder path where the SDK Manager installer downloads all components. Alternatively, click the menu icon ("⋮") in the upper right corner of the window, then select Export Debug Logs from the drop-down menu in the upper right corner.

    image

  3. For information about any errors you may encounter, refer to Error Messages.

  4. Click Finish and Exit to complete the installation.

Repair and Uninstallation

To update or uninstall the SDK on your system, launch the SDK Manager again.

  1. Under the installation step number in Step 1, click the Repair/Uninstall hyperlink.

    image

  2. The Manage NVIDIA SDKs screen displays what is installed on your system. You can choose to repair a corrupted installation, update an existing SDK, or uninstall the SDK.

    image

Recommended Recovery Steps

Various installation errors can have many causes. The following is a list of common installation issues to help you recover from a corrupted installation.

  1. Check the summary table to identify which component failed.

    a. Expand the group with a status of "Error".

    b. When you find the failed component, click the details icon to the right of Install Error to redirect to the Terminal tab, which will display the exact error.

    image

  2. If the error is related to an environmental issue (e.g., a corrupted apt repository or missing prerequisites), try to fix it manually, then click the Retry Failed Items button.

    image

  3. You can also retry the installation in two other ways:

    a. Start from Step 1, use the Repair/Uninstall button to access the Manage NVIDIA SDKs page. If needed, expand the SDK with a status of "Broken", then click Repair for the relevant section (Host or Target).

    image

  4. In Step 1, select the desired SDK and run the installation again.

  5. Finally, try uninstalling and reinstalling the relevant SDK.

USB Boot (Copy the System from eMMC)

Equipment Preparation

  1. Jetson Nano motherboard.
  2. USB flash drive or portable hard disk (USB3.0 is recommended).
  3. Power adapter.

System Installation

  1. Connect the USB flash drive to the Jetson Nano and check the device number of the USB flash drive (e.g., sda). Open the Jetson Nano terminal and enter:

    ls /dev/sd*

  2. Format the USB flash drive.

    sudo mkfs.ext4 /dev/sda

    Only sda remains, as shown in the figure below:

    image

  3. Modify the boot path:

    sudo vi /boot/extlinux/extlinux.conf

    Locate the line: APPEND ${cbootargs} quiet root=/dev/mmcblk0p1 rw rootwait rootfstype=ext4 console=ttyS0,115200n8 console=tty0, change mmcblk0p1 to sda and save.

  4. Mount the USB flash drive:

    sudo mount /dev/sda /mnt

  5. Copy the system to the USB flash drive (no information will be printed during this process, please wait patiently):

    sudo cp -ax / /mnt

  6. Unmount the USB flash drive after copying (do not unplug the USB flash drive):

    sudo umount /mnt/

  7. Restart the system:

    sudo reboot

Usage Tutorial

Your First Jetson Container

What is a Container?

A container is an executable unit of software where an application and its runtime dependencies are all packaged into a single entity. Since everything the application needs is packaged with the application itself, containers provide a degree of isolation from the host, and applications can be easily deployed and installed without worrying about the host environment and application dependencies.

What is Docker?

Docker is an open-source platform for creating, deploying, and running containers. Docker is included in JetPack, so running containers on Jetson is easy and requires no additional installation.

What is NGC?

NVIDIA NGC is a hub for GPU-optimized deep learning, machine learning, and high-performance computing (HPC) software. NGC hosts containers for top-tier AI and data science software—all tuned, tested, and optimized by NVIDIA. Containers on NGC deliver powerful, easy-to-deploy software proven to deliver results quickly, enabling users to build solutions from tested frameworks.

Visit the NGC portal for more information at https://www.nvidia.com/en-us/gpu-cloud/.

Jetson Containers on NGC

Several containers for Jetson are hosted on NVIDIA NGC. Visit the Jetson Cloud Native page for a list of Jetson containers hosted on NGC.

Using Containers

Downloading a Container

To download a container, you need to use the "docker pull" command.

Usage：

docker pull [OPTIONS] NAME[:TAG|@DIGEST]

For more details, refer to the docker pull documentation.

Follow the example below to download the L4T-base container from NGC:

sudo docker pull nvcr.io/nvidia/l4t-base:r35.1.0

Note that nvcr.io/nvidia/l4t-base is the name of the container, and r35.1.0 is the tag. Tags provide a way to version containers.

Listing Containers

You can view the list of containers pulled into your developer kit using the "docker image ls" command.

Usage：

sudo docker image ls [OPTIONS] [REPOSITORY[:TAG]]

For more details, refer to the docker image ls documentation.

Running a Container

Containers are run using the docker run command.

Usage：

sudo docker run [OPTIONS] IMAGE[:TAG|@DIGEST] [COMMAND] [ARG...]

For more details, refer to the docker run documentation.

Follow the example below to run the L4T-base container:

sudo docker run -it --rm --net=host --runtime nvidia -e DISPLAY=$DISPLAY -v /tmp/.X11-unix/:/tmp/.X11-unix nvcr.io/nvidia/l4t-base:r35.1.0

Visit the L4T-base Container Page for explanations of the above docker run command.

Congratulations on running your first container on Jetson!

Use the following command to exit the current container:

exit

Setting Up VNC

What is VNC?

VNC (Virtual Network Computing) enables you to control your Jetson Developer Kit from another computer on the same network by viewing and interacting with the Developer Kit's desktop from the other computer. To learn more about VNC, click here.

Note:

Your Jetson Developer Kit and the other computer need to be on the same network. A fairly fast network connection is required. A slower connection will degrade the desktop interaction experience.

Setting Up the VNC Server on Jetson Nano

  1. Make the VNC server start every time you log in

    If you have a Jetson Nano 2GB Developer Kit (running LXDE):

    mkdir -p ~/.config/autostart
cp /usr/share/applications/vino-server.desktop ~/.config/autostart/.

    For all other Jetson Developer Kits (running GNOME):

    cd /usr/lib/systemd/user/graphical-session.target.wants
sudo ln -s ../vino-server.service ./.

  2. Configure the VNC server

    gsettings set org.gnome.Vino prompt-enabled false
gsettings set org.gnome.Vino require-encryption false

  3. Set a password to access the VNC server

    # Replace thepassword with your desired password
gsettings set org.gnome.Vino authentication-methods "['vnc']"
gsettings set org.gnome.Vino vnc-password $(echo -n 'thepassword'|base64)

  4. Restart the system for the settings to take effect

    sudo reboot

    The VNC server is only available after you log in to Jetson locally. If you want the VNC to be available automatically, use the System Settings app on the Developer Kit to enable automatic login.

Setting Up the VNC Server on Jetson TX2 NX

When there is no display, you need to use remote desktop login to access the desktop of Jetson TX2 NX. (It is recommended to use a display as VNC has a certain delay)

Jetson TX2 NX uses vino as the default VNC server, but the default settings need to be modified.

  1. Configure the VNC Server

    gsettings set org.gnome.Vino require-encryption false
gsettings set org.gnome.Vino prompt-enabled false
gsettings set org.gnome.Vino authentication-methods "['vnc']"
gsettings set org.gnome.Vino lock-screen-on-disconnect false
gsettings set org.gnome.Vino vnc-password $(echo -n "mypassword"|base64)
    • Note that you should not run the above commands with sudo, and "mypassword" is the password for connecting to VNC.

  2. Set the desktop to start automatically at boot, and create a new autostart file in the .config directory

    mkdir -p .config/autostart
sudo vim ~/.config/autostart/vino-server.desktop

  3. Check which display manager is currently in use

    cat /etc/X11/default-display-manager

  4. Edit the file

    sudo vim /etc/gdm3/custom.conf

  5. Uncomment the following three lines, and modify the AutomaticLogin line to your own username.

    WaylandEnable=false
AutomaticLoginEnable = true
AutomaticLogin = waveshare

  6. Restart Jetson TX2 NX

    sudo reboot

Connecting to the VNC Service from Another Computer

You need to know the IP address of your Jetson Developer Kit to connect from another computer. Run the ifconfig command on your Developer Kit and note down the IP address assigned to the eth0 interface (if using Ethernet), wlan0 interface (if using wireless), or l4tbr0 (if using USB device mode Ethernet connection).

WINDOWS

  • Step 1: Download and install VNC Viewer from here
  • Step 2: Launch VNC Viewer and enter the IP address of your Developer Kit
  • Step 3: Provide the VNC password if you have configured the VNC server for authentication

MACOS

The example below uses the Screen Sharing app that comes with macOS. However, any vnc client you prefer should also work fine.

  • Step 1: Open Finder and select Go | Go to Folder from the menu bar.
  • Step 2: Enter "/System/Library/CoreServices/Applications" and click Go
  • Step 3: Open the app named Screen Sharing and enter the connection information. For example: username@
  • Step 4: Click Connect.
  • Step 5: Provide the VNC password if you have configured the VNC server for authentication.

LINUX

The example below uses gvncviewer, but any vnc client you prefer should also work fine. A popular alternative is remmina.

  • Step 1: Install gvncviewer by executing the following commands:

    sudo apt update
sudo apt install gvncviewer

  • Step 2: Launch gvncviewer

    gvncviewer

  • Step 3: Provide the VNC password if you have configured the VNC server for authentication

Note: These instructions can also be found in the README-vnc.txt file on the L4T-README volume included in the system image. You can access the contents of this volume by mounting it on the Developer Kit.

The volume can also be accessed from other computers via the Developer Kit's USB device mode feature:

  • Power on your Developer Kit
  • Connect another computer to the Micro-USB port of your Developer Kit (the front USB-C connector if it is a Jetson AGX Xavier Developer Kit)
  • The L4T-README volume will be mounted on the other computer, including files such as README-vnc.txt.

Connecting a Bluetooth Speaker

The Jetson Nano 2GB Developer Kit does not have built-in Bluetooth. To connect a Bluetooth audio device to the Developer Kit, you need to use a USB Bluetooth adapter.

Follow the steps below to enable Bluetooth audio on the Developer Kit.

Bluetooth Adapter Requirements

The Bluetooth adapter must support the Linux operating system, and you need to have access to the drivers for the Bluetooth adapter.

Connecting Bluetooth Audio

  1. Install any required drivers for the Bluetooth adapter on the Developer Kit. Follow the instructions from the Bluetooth adapter manufacturer.

    After installing the drivers, you may have to restart the Developer Kit for the system to enable it.

  2. Connect the Bluetooth adapter (if you did not connect it while installing the drivers)

  3. Navigate to this file:

    /lib/systemd/system/bluetooth.service.d/nv-bluetooth-service.conf

  4. Use a text editor to change this line...

    ExecStart=/usr/lib/bluetooth/bluetoothd -d --noplugin=audio,a2dp,avrcp

    to the following content:

    ExecStart=/usr/lib/bluetooth/bluetoothd -d

    That is, remove the ‑‑noplugin switch and all its values.

  5. Enter these commands in the terminal to update the package list and install the PulseAudio package:

    $ sudo apt-get 更新
$ sudo apt-get install pulseaudio-module-bluetooth

  6. Enter this command to restart the Jetson device:

    $ sudo reboot

  7. After the restart is complete, pair and connect any Bluetooth headphones/speakers

    LXPanel Menu -> Preferences -> Bluetooth Manager

Taking Your First Photo with a CSI or USB Camera

This guide will show you how to get CSI and USB cameras up and running quickly. By following this guide, you will be able to:

  1. Start capturing and previewing the display on the screen
  2. Take photos and save them to disk
  3. Capture videos and save them to disk
  4. How to use cameras with containers

Supported Cameras

The Jetson Developer Kit has multiple interfaces for connecting cameras, including USB, Ethernet, and MIPI CSI-2. Popular cameras are supported out of the box, and the Jetson ecosystem partners support a wide range of add-on cameras.

Popular cameras supported out of the box include the IMX219 camera module (such as the Raspberry Pi Camera Module V2), Intel Realsense, and StereoLabs Zed 3D cameras, as well as standard USB webcams.

CSI Camera

For information on how to connect the ribbon cable for MIPI CSI-2 cameras, refer to the Jetson Nano 2GB Developer Kit User Guide.

Start Capturing and Previewing on the Screen

To check if the CSI camera is working properly, you can run the following command, which will start capturing and previewing the display on the screen.

nvgstcapture-1.0

This example command rotates the image 180 degrees (vertically flipped):

nvgstcapture-1.0 --orientation 2
Taking Photos and Saving to Disk

Runtime Command-Line Options

  1. nvgstcapture-1.0

  2. Press "j" to capture an image.

  3. Press "q" to exit.

Automatic Command-Line Options

nvgstcapture-1.0 --automate --capture-auto

Note: Use "nvgstcapture-1.0 --help" to refer to the supported command-line options.

Capturing Videos and Saving to Disk

Runtime Command-Line Options

  1. nvgstcapture-1.0

  2. Press "1" to start recording video.

  3. Press "0" to stop recording video.

  4. Press "q" to exit.

Automatic Command-Line Options

bash

nvgstcapture-1.0 --mode=2 --automate --capture-aut

Note: Use "nvgstcapture-1.0 --help" to refer to the supported command-line options.

Using the Camera in Docker

The commands are the same; you just need to add this option to the command line when starting the container with "docker run":

--volume /tmp/argus_socket:/tmp/argus_socket

USB Camera

Start Capturing and Previewing on the Screen

You need to tell nvgstcapture where to find your USB camera device (instead of the default CSI camera).

# V4L2 USB camera (where <N> is the /dev/videoN node)
nvgstcapture-1.0 --camsrc=0 --cap-dev-node=<N>
Taking Photos and Saving to Disk

Runtime Command-Line Options

  1. nvgstcapture-1.0 --camsrc=0 --cap-dev-node=<N> (where N is the /dev/videoN Node)

  2. Press "j" to capture an image.

  3. Press "q" to exit.

Automatic Command-Line Options

nvgstcapture-1.0 --camsrc=0 --cap-dev-node=<N> --automate --capture-auto (where N is the /dev/videoN Node)

Note: Use "nvgstcapture-1.0 --help" to refer to the supported command-line options.

Capturing Videos and Saving to Disk

Runtime Command-Line Options

  1. nvgstcapture-1.0 --mode=2 --camsrc=0 --cap-dev-node=<N> (where N is the /dev/videoN Node)

  2. Press "1" to start recording video.

  3. Press "0" to stop recording video.

  4. Press "q" to exit.

Automatic Command-Line Options

nvgstcapture-1.0 --mode=2 --camsrc=0 --cap-dev-node=<N> --automate --capture-auto (where N is the /dev/videoN Nod
Using the Camera in Docker

When you start the container with "docker run", mount the corresponding /dev/video* device by adding the following option to the command line:

--device /dev/video0

The above assumes your V4L2 USB camera is /dev/video0.

Useful Resources

Hardware Control

Jetson TX1, TX2, AGX Xavier, and Nano development boards include a 40-pin GPIO header, similar to the 40-pin header in the Raspberry Pi.

GPIO

  • The digital input and output of these GPIOs can be controlled using the Python library provided in the Jetson GPIO library package.

  • The Jetson GPIO library provides all the public APIs provided by the RPi.GPIO library. The use of each API is discussed below:

    1. To import the Jetson.GPIO module, use:

      import Jetson.GPIO as GPIO

    2. Pin Numbering

      • The Jetson GPIO library provides four methods for numbering I/O pins.

      • The first two correspond to the modes provided by the RPi.GPIO library, namely BOARD and BCM, which refer to the pin numbers of the 40-pin GPIO header and the Broadcom SoC GPIO numbers, respectively.

      • The remaining two modes, CVM and TEGRA_SOC, use strings instead of numbers, corresponding to the signal names on the CVM/CVB connector and the Tegra SoC, respectively.

      • To specify the mode you are using (mandatory), use the following function call:

      • To check the mode that has been set, you can call:

        mode = GPIO.getmode()

        The mode must be one of GPIO.BOARD, GPIO.BCM, GPIO.CVM, GPIO.TEGRA_SOC, or None.

    3. If the GPIO detects that a pin has been set to a non-default value, you will see a warning message.

      • You can disable warnings with the following code:

        GPIO.setwarnings(False)

    4. Setting Up Channels

      • GPIO channels must be set up before being used as inputs or outputs. To configure a channel as an input, call:

        # (where channel is based on the pin numbering mode discussed above)
GPIO.setup(channel, GPIO.IN)

      • To set a channel as an output, call:

        GPIO.setup(channel, GPIO.OUT)

      • You can also specify an initial value for the output channel:

        GPIO.setup(channel, GPIO.OUT, initial=GPIO.HIGH)

      • When setting channels as outputs, you can also set multiple channels at the same time:

        # add as many as channels as needed. You can also use tuples: (18,12,13)
channels = [18, 12, 13]
GPIO.setup(channels, GPIO.OUT)

    5. Input

      • To read the value of a channel, use:

        GPIO.input(channel)
This will return GPIO.LOW or GPIO.HIGH.

    6. Output

      • To set the value of a pin configured as an output, use:

        GPIO.output(channel, state)
where state can be GPIO.LOW or GPIO.HIGH.

      • You can also output to a list or tuple of channels:

        channels = [18, 12, 13] # or use tuples
GPIO.output(channels, GPIO.HIGH) # or GPIO.LOW
# set first channel to LOW and rest to HIGH
GPIO.output(channel, (GPIO.LOW, GPIO.HIGH, GPIO.HIGH))

    7. Cleanup

      • At the end of the program, it is best to clean up the channels so that all pins are set to their default states. To clean up all used channels, call:

        GPIO.cleanup()

      • If you do not want to clean up all channels, you can also clean up a single channel or a list/tuple of channels:

        GPIO.cleanup(chan1) # cleanup only chan1
GPIO.cleanup([chan1, chan2]) # cleanup only chan1 and chan2
GPIO.cleanup((chan1, chan2))  # does the same operation as previous statement

    8. Jetson Board Information and Library Version

      • To get information about the Jetson module, use/read:

        GPIO.JETSON_INFO

        This provides a Python dictionary with the following keys: P1_REVISION, RAM, REVISION, TYPE, MANUFACTURER, and PROCESSOR. All values in the dictionary are strings except for P1_REVISION, which is an integer.

      • To get information about the library version, use/read:

        GPIO.VERSION

        This provides a string in XYZ version format.

    9. Interrupts

      In addition to busy polling, the library provides three additional methods to monitor input events:

      • wait_for_edge() Function

      • This function blocks the calling thread until the provided edge is detected. The function can be called as follows:

        GPIO.wait_for_edge(channel, GPIO.RISING)

      • The second parameter specifies the edge to detect, which can be GPIO.RISING, GPIO.FALLING, or GPIO.BOTH. If you only want to limit the wait to a specified time, you can optionally set a timeout:

        # timeout is in milliseconds
GPIO.wait_for_edge(channel, GPIO.RISING, timeout=500)

        The function returns the channel where the edge was detected, or None if a timeout occurs.

      • event_detected() Function

      • This function can be used to periodically check if an event has occurred since the last call. The function can be set up and called as follows:

        # set rising edge detection on the channel
GPIO.add_event_detect(channel, GPIO.RISING)
run_other_code()
if GPIO.event_detected(channel):
    do_something()

        As before, you can detect events for GPIO.RISING, GPIO.FALLING, or GPIO.BOTH.

      • Callback Functions Run When an Edge is Detected

      • This feature can be used to run a second thread for the callback function. Therefore, the callback function can run concurrently with your main program in response to edges. This feature can be used as follows:

        # define callback function
def callback_fn(channel):
    print("Callback called from channel %s" % channel)

# add rising edge detection
GPIO.add_event_detect(channel, GPIO.RISING, callback=callback_fn)

      • If needed, multiple callbacks can also be added as follows:

        def callback_one(channel):
    print("First Callback")

def callback_two(channel):
    print("Second Callback")

GPIO.add_event_detect(channel, GPIO.RISING)
GPIO.add_event_callback(channel, callback_one)
GPIO.add_event_callback(channel, callback_two)

        In this case, the two callbacks run sequentially, not simultaneously, because only one thread runs all callback functions.

      • To prevent multiple calls to the callback function by merging multiple events into one, you can optionally set a bounce time:

        # bouncetime set in milliseconds
GPIO.add_event_detect(channel, GPIO.RISING, callback=callback_fn,
bouncetime=200)

      • If edge detection is no longer needed, it can be removed as follows:

        GPIO.remove_event_detect(channel)

    10. Checking GPIO Channel Functions

      • This function allows you to check the function of the provided GPIO channel:

        GPIO.gpio_function(channel)
This function returns GPIO.IN or GPIO.OUT.
Lighting an LED

  • Example Program

    import Jetson.GPIO as GPIO
import time as time

LED_Pin = 11

GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(LED_Pin, GPIO.OUT)

while (True):
   GPIO.output(LED_Pin, GPIO.HIGH)
   time.sleep(0.5)
   GPIO.output(LED_Pin, GPIO.LOW)
   time.sleep(0.5)
Using the Sample Programs

  • For the jetson.gpio library, the official also provides some simple sample programs.

  • First, download jetson-gpio：

    git clone https://github.com/NVIDIA/jetson-gpio

  • After the download is complete, we can use the sample programs inside, for example, simple_input.py can read the state of the pins:

    cd /opt/nvidia/jetson-gpio/samples/
sudo python3 simple_input.py

I2C

  1. First, install I2Ctool by entering the following in the terminal:

    sudo apt-get update
sudo apt-get install -y i2c-tools
sudo apt-get install -y python3-smbus

  2. Check the installation status by entering the following in the terminal:

    apt-cache policy i2c-tools

    The following output indicates a successful installation:

    i2c-tools:
已安装：4.0-2
候选： 4.0-2
版本列表：
*** 4.0-2 500
500 http://ports.ubuntu.com/ubuntu-ports bionic/universe arm64 Packages
100 /var/lib/dpkg/status
i2cdetect

  • Query I2C devices:

     sudo i2cdetect -y -r -a 0

    image

    • Parameters: -y executes directly ignoring interactive prompts, -r is the SMBus read byte command, -a means all addresses, and 0 refers to SMBus 0.

  • Scan register data:

    sudo i2cdump -y 0 0x68

  • Register Data Writing:

    sudo i2cset -y 0 0x68 0x90 0x55

    • Parameters:

      Parameter Meaning
      0 Represents the I2C device number
      0x68 Represents the I2C device address
      0x90 Represents the register address
      0x55 Represents the data written to the register

  • Register Data Reading:

    sudo i2cget -y 0 0x68 0x90

    • Parameters:

      Parameter Meaning
      0 Represents the I2C device number
      0x68 Represents the I2C device address
      0x90 Represents the register address

SDK Installation

JetPack mainly includes system images, libraries, APIs, developer tools, examples, and some documents. In the SDK Manager software, what we install first is the OS (i.e., the system image), and the uninstalled part is the SDK, as shown in the figure below. You can install it directly using commands or via SDK Manager:

image

The SDK includes TensorRT, cuDNN, CUDA, Multimedia API, Computer Vision, and Developer Tools.

  • TensorRT: A high-performance deep learning inference runtime for neural networks used in image classification, segmentation, and object detection. It accelerates the speed of deep learning inference and reduces the runtime memory footprint of convolutional and deconvolutional neural networks.
  • cuDNN: The CUDA Deep Neural Network Library provides high-performance primitives for deep learning frameworks. It includes support for convolution, activation functions, and tensor transformations.
  • CUDA: The CUDA Toolkit provides a comprehensive development environment for C and C++ developers building GPU-accelerated applications. The toolkit includes compilers for NVIDIA GPUs, mathematical libraries, and tools for debugging and optimizing application performance.
  • Multimedia API: The Jetson Multimedia API provides low-level APIs for flexible application development.
  • Computer Vision: VPI (Vision Programming Interface) is a software library that provides computer vision/image processing algorithms implemented on PVA1 (Programmable Vision Accelerator), GPU, and CPU. Among them, OpenCV is the leading open-source library for computer vision, image processing, and machine learning, now with GPU-accelerated capabilities for real-time operations; VisionWorks2 is a software development kit for computer vision (CV) and image processing.
  • Developer Tools: The CUDA Toolkit (part of Developer Tools) provides a comprehensive development environment for C and C++ developers building GPU-accelerated applications. The toolkit includes compilers for NVIDIA GPUs, mathematical libraries, and tools for debugging and optimizing application performance.

The above are some functions of the SDK. Only the basic system was installed during the initial system setup; other JetPack SDK components (such as CUDA) need to be further installed after the system starts normally. Here are the step-by-step instructions for installing the SDK. If you want to install these components, ensure that the TF card or USB flash drive is used as the main system, as the downloaded content may cause the EMMC disk to run out of space.

Installation via SDK Manager

Note: This method is overly cumbersome, so it is recommended to use the commands below for installation (i.e., operate on the development board with network connectivity).

When installing the SDK via SDK Manager, there is no need to set the Nano to recovery mode.

  • Power on and start the Nano normally
  • After the Jetson Nano boots into the system normally, connect the Micro USB port of the Jetson Nano to the Ubuntu host using a USB data cable
  • Run the sdkmanager command on the Ubuntu host to open SDK Manager (SDK Manager needs to be installed first)
  • Similar to the previous system flashing operation, the difference is that in the second step, do not check the OS option, but check the SDK option, then click Continue to proceed with the installation
  • After downloading the resources, a pop-up window will prompt you to enter the username and password; just fill in the username and password of the Nano system
  • Wait for the SDK installation to complete

Installation via Commands

Users who do not have Ubuntu or a virtual machine can choose to install it directly on the Jetson Nano using the following commands:

sudo apt update
sudo apt install nvidia-jetpack

If you only have a small amount of reserved space, do not install using the above commands (it will cause insufficient space), and do not install components via SDK Manager either. Please use the following two commands instead:

sudo apt update
apt depends nvidia-jetpack | awk '{print $2}' | xargs -I {} sudo apt install -y {}

NVIDIA Official Resources

Software

Back to Top