JETSON ORIN NX系列说明
Jetson Orin NX 资料集
JETSON ORIN NX系列入门教程
本章节主要介绍Jetson Orin NX的基本配置、系统烧录和基础外设使用。
JETSON ORIN NX系列入门教程
一、产品介绍
1. 简介
Jetson Orin NX 是Jetson Orin系列的中端产品，提供 8GB 和 16GB 两种内存组合，AI算力高达 70 TOPS/100 TOPS，在super模式下至高 117 TOPS/157 TOPS，同时其拥有丰富的接口资源，并且兼容NVIDIA的软件生态，是AI机器人，AI大模型和计算机视觉开发的得力工具。
| Orin NX 8GB | Orin NX 16GB | |
| AI算力 (INT8) | 117 TOPS |
157TOPS |
| GPU | 1024 核 CUDA核心 32 个 Tensor Core GPU@1020MHz | 1796 核 CUDA核心 32 个 Tensor Core GPU@1020MHz |
| CPU | 8x A78 @ 2GHz | 8x A78 @ 2GHz |
| 内存 | LPDDR5 8GB | LPDDR5 16GB |
| 功率 | 10W | 15W | 25W | 40W | 10W | 15W | 25W | 40W |
2. 外观
3. 接口
| 接口类型 | 规格详情 |
|---|---|
| CSI 摄像头接口 | •2x MIPI CSI-2 22 针摄像头连接器 |
| PCIe 接口 | •M.2 Key M 插槽，支持 x4 PCIe 3.0 •M.2 Key M 插槽，支持 x2 PCIe 3.0 •M.2 Key E 插槽（已预装网卡） |
| USB 接口 |
• 4 x USB 3.2 Gen 2 (10Gbps) 接口 • USB Type-C UFP |
| 网络接口 | • 1 个千兆以太网 (GbE) 接口 |
| 显示输出 | •1x DisplayPort 1.2 (+MST) 连接器 |
| 存储接口 |
• 支持外部 NVMe 存储 • 支持SD卡 |
| 扩展接口 |
• 40 针扩展接头： • 12 针调试接口 • DC电源接口 |
| 无线连接 |
• 支持WLAN 802.11ac • 支持蓝牙5.0 |
- 12Pin调试接口定义如下
4. 注意事项
开发板允许电源为 9~19V 5A MAX，请使用官方原装电源接入开发板，以免损坏载板和核心卡。
请确认核心卡的散热器工作状态，以免模组过热导致性能下降。确保散热器安装稳固且无杂物阻碍，如有需要可定期清理灰尘以保障散热效果。
在上电开机前请确保开发板已经接入 USB/固态硬盘/eMMC/内存卡等存储介质。
JETSON ORIN NX系列入门教程
二、刷机教程
1. 安装ubuntu虚拟机
1.1 下载VMware Workstation
- 通过百度网盘下载此文件：VMware-workstation-full-16.2.5-20904516.exe
链接: https://pan.baidu.com/s/1xopblFgG29dYZXoNfwa5ZA 提取码: frjy
1.2 安装VMware Workstation
- 打开VMware-workstation-full-16.2.5-20904516.exe
- 选项保持默认即可，点下一步
- 输入激活码，请自行百度搜索：vmware16密钥
1.3安装ubuntu系统
推荐使用20.04和22.04版本，这里以20.04为例。
- 下载ubuntu20.04_desktop_amd64.iso镜像，若下载速度较慢，推荐使用清华源或中科大源。
- 打开VMware Workstation Pro，新建虚拟机
- 选择典型配置
- 选择刚才下载的ISO镜像
- 输入用户名与密码
- 输入虚拟机名字与选择存放虚拟机文件的路径
- 虚拟机可用的存储空间，建议最少给300G
- 点击完成
- 等待安装完成
- 出现以下画面表示安装完成
2.安装NVIDIA SDK Manager
2.1 下载安装包
- 进入虚拟机打开浏览器，进入 Jetson SDK，下载 .deb ubuntu 安装包。
2.2 安装SDK Manager
- 打开 文件管理器 进入 Downloads 文件夹，确认 sdkmanager_xxxxx_amd64.deb 存在，在当前目录下打开命令行窗口执行以下命令安装。
sudo apt update
sudo dpkg -i sdkmanager_2.3.0-12617_amd64.deb # 需要根据实际版本修改包名
sudo apt install --fix-broken
3.使用NVIDIA SDK Manager进行刷机
3.1 设置VMware的USB模式
- 将USB连接模式设置为
将设备连接到前台虚拟机，避免刷机中途开发板重启导致失败。
3.2 进入恢复模式
-
-
使用跳线帽短接开发板上的 FC REC 和 GND 针脚。
-
使用 USB to Tpye-C 数据线将开发板连接到电脑。
-
接通开发板的 DC 电源。
成功进入恢复模式后， SDK Manager 会自动检测到核心卡类型，并提示选择套件类型，同时散热器风扇不会工作。
-
进入恢复模式后一段时间内不操作会重启进入系统，请注意操作时机。
3.3 配置SDK
- 取消Host Machine，并点击CONTINUE
- 只勾选Jetson Linux
3.4 等待下载完成
3.5 配置刷机参数
Pre-Config，预设账号密码
Runtime，开机后自行配置账号密码
Storage Device，系统刷入的介质，根据不同设备自行选择 (内存卡/固态硬盘/U盘)。
- 选择
developer kit version。
- 耐心等待刷机完成，大约10~20分钟。
刷入过程中开发板可能会多次与主机重新连接，请勿途中拔开数据线或切断开发板电源，可以在识别到开发板类型以后就拔掉跳线帽。
- 刷入完成后，拔掉跳线帽，上电正常进入系统桌面或初始化设置页面即刷机成功。
4.使用命令行刷入super固件
此操作需依赖官方固件环境，请先通过SDK Manager完成至少一次完整的烧录以创建固件缓存。
4.1 进入恢复模式
- 使用跳线帽短接FC REC和GND针脚，使用Tpye-C型数据线连接至电脑并接通开发板电源，使开发板进入恢复模式。
4.2 使用官方固件进行命令行刷机
操作前请关闭正在运行的SDK Manager软件，刷入过程约为10~20分钟
- JetPack6.2版本刷入指令：
cd /home/ubuntu/nvidia/nvidia_sdk/JetPack_6.2.1_Linux_JETSON_ORIN_NANO_TARGETS/Linux_for_Tegra #仅供参考，需要根据实际版本和路径进行修改
sudo ./tools/kernel_flash/l4t_initrd_flash.sh --external-device nvme0n1p1 \
-c tools/kernel_flash/flash_l4t_t234_nvme.xml -p "-c bootloader/generic/cfg/flash_t234_qspi.xml" \
--showlogs --network usb0 jetson-orin-nano-devkit-super internal- JetPack5.1.5版本刷入指令：
cd /home/ubuntu/nvidia/nvidia_sdk/JetPack_5.1.5_Linux_JETSON_ORIN_NANO_TARGETS/Linux_for_Tegra #仅供参考，需要根据实际版本和路径进行修改
sudo ./tools/kernel_flash/l4t_initrd_flash.sh --external-device nvme0n1p1\
-c tools/kernel_flash/flash_l4t_external.xml -p "-c bootloader/t186ref/cfg/flash_t234_qspi.xml"\
--showlogs --network usb0 jetson-orin-nano-devkit-super internal
4.3 验证是否处于super模式
- 开发板上电开机完成用户配置后在桌面右上角可以选择电源模式，25W & MAXN SUPER为super模式独有，普通模式只有 7W 和 15W 两档。
JETSON ORIN NX系列入门教程
三、摄像头
- 接入摄像头后，您可以使用以下指令查看现有摄像头的编号。
jetson@jetson-desktop:~$ ls /dev/video*
/dev/video0 /dev/video1 1. CSI摄像头
尽量避免带电操作，接入CSI摄像头时注意FPC排线金属触点一面朝下
1.1 使用gst-launch打开摄像头
- 确认CSI摄像头正确连接后，分别在两个命令行窗口运行以下命令打开摄像头。
gst-launch-1.0 nvarguscamerasrc sensor-id=0 ! "video/x-raw(memory:NVMM), width=(int)1920, height=(int)1080,format=(string)NV12, framerate=(fraction)30/1" ! nvvidconv ! xvimagesink sync=false
gst-launch-1.0 nvarguscamerasrc sensor-id=1 ! "video/x-raw(memory:NVMM), width=(int)1920, height=(int)1080,format=(string)NV12, framerate=(fraction)30/1" ! nvvidconv ! xvimagesink sync=false #打开另一个命令行窗口运行-
sensor-id：指定摄像头物理接口 ID，双摄使用
sensor-id=0和sensor-id=1。 -
memory：使用 NVIDIA GPU 内存（NVMM），减少延迟。
-
width, height：设置分辨率，需硬件支持，例如 1080p。
-
format：像素格式为
NV12（NVIDIA 编码器原生支持）。 -
framerate：设置帧率，例如
30/1（30 FPS）。 -
sync：
false禁用音视频同步，减少延迟。
2. USB摄像头
- Cheese是一款简单易用的摄像头应用，它允许用户在Ubuntu系统中轻松地进行拍照、录像以及连拍等操作。运行以下命令以安装Cheese软件。
sudo apt install cheese
将USB摄像头连接至开发板USB接口，并打开cheese软件
- Guvcview是一款开源的图形用户界面软件，它为用户提供了简单直观的方式来捕捉视频。运行以下命令以安装guvcview软件。
sudo apt install guvcview
您也仍然可以使用nvgstcapture来打开USB摄像头
# V4L2 USB camera (where <N> is the /dev/videoN node)
sudo nvgstcapture --cap-dev-node 2 #0,1默认为CSI摄像头
更详细的说明可参考NVIDIA Developer
JETSON ORIN NX系列入门教程
四、GPIO控制
GPIO（General-purpose input/output ）是一种通用型输入输出接口，其脚位可由使用者编程控制。根据实际需要，这些脚位可以被设置为通用输入（GPI）、通用输出（GPO），或兼具输入输出功能（GPIO）。
Jetson Orin Nano系列的40PIN GPIO引脚定义如下：
1 在JetPack 5系统中使用GPIO
1.1 使用命令行控制GPIO
获取GPIO口的引脚名称与编号
以31号引脚为例，454为GPIO口编号，PQ.06为引脚名称
- 提升至root权限，启用GPIO口
sudo bash
echo 454 > /sys/class/gpio/export- 设置GPIO为输入模式
echo in > /sys/class/gpio/PQ.06/direction- 获取GPIO当前状态，返回值1为高电平，0为低电平
cat /sys/class/gpio/PQ.06/value- 设置GPIO为输出模式
echo out > /sys/class/gpio/PQ.06/direction- 设置GPIO输出，1为高电平，0为低电平
echo 1 > /sys/class/gpio/PQ.06/value您也可以使用以下脚本进行测试
#!/bin/bash
trap 'echo PQ.06 > /sys/class/gpio/unexport; echo "GPIO PQ.06 is released"' EXIT
echo "setting GPIO PQ.06"
echo PQ.06 > /sys/class/gpio/export 2>/dev/null
# set Pin output mode
echo out > /sys/class/gpio/PQ.06/direction
# blink
while true
do
echo 0 > /sys/class/gpio/PQ.06/value
sleep 0.5
cat /sys/class/gpio/PQ.06/value
sleep 0.5
echo 1 > /sys/class/gpio/PQ.06/value
sleep 0.5
cat /sys/class/gpio/PQ.06/value
sleep 0.5
done
1.2 使用python控制GPIO
1.2.1 安装JETSON.GPIO包
- 如果您不确定您的环境是否正常，或者您尝试使用conda环境运行脚本请执行以下指令安装Jetson官方的GPIO库
pip install JETSON.GPIOJetson GPIO库提供了四种给I / O引脚编号的方法。
- BOARD：物理引脚编号（40针接口顺序）。
- BCM：Broadcom SoC 的 GPIO 编号（常用）。
- CVM：CVM/CVB 连接器的信号名称。
- TEGRA_SOC：Tegra SoC 信号名称。
import time
import RPi.GPIO as GPIO
# define pin number
output_pin = 31
# set pin as BOARD mode
GPIO.setmode(GPIO.BOARD)
# set pin mode
GPIO.setup(output_pin, GPIO.OUT)
print("Press CTRL+C to exit")
curr_value = GPIO.HIGH
try:
while True:
time.sleep(1)
print("pin {} now is {}".format(output_pin, curr_value))
GPIO.output(output_pin, curr_value)
# blink
curr_value ^= GPIO.HIGH
finally:
GPIO.cleanup()其他具体用法和例程可参考项目官网
1.3使用C/C++控制GPIO
- 安装libgpio-dev
sudo apt install libgpio-dev参考例程：
/**
* License - MIT.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <gpiod.h>
#define GPIO_CHIP "/dev/gpiochip0"
#define GPIO_LED 3
int main()
{
int ret = 0;
struct gpiod_chip *gpiochip;
struct gpiod_line *gpioline;
// Open driver.
gpiochip = gpiod_chip_open(GPIO_CHIP);
if (NULL == gpiochip) {
printf("Error in gpiod_chip_open.\n");
ret = -1;
goto out1;
}
// Get gpio.
gpioline = gpiod_chip_get_line(gpiochip, GPIO_LED);
if (NULL == gpioline) {
printf("Error in gpiod_chip_get_line.\n");
ret = -1;
goto out2;
}
// Set gpio direction.
ret = gpiod_line_request_output(gpioline, "gpio", 0);
if (ret != 0) {
printf("Error in gpiod_line_request_output.\n");
ret = -1;
goto out2;
}
// Blink.
for (int i = 0; i < 10; i++) {
printf("%d times.\n", i);
gpiod_line_set_value(gpioline, 1);
sleep(1);
gpiod_line_set_value(gpioline, 0);
sleep(1);
}
// Release.
gpiod_line_release(gpioline);
out2:
gpiod_chip_close(gpiochip);
out1:
return ret;
}- 编译源文件
g++ test_gpio.cc -o test_gpio -lgpiod- 执行测试程序
./test_gpio2 在JetPack 6系统中使用GPIO
2.1使用libgpiod控制GPIO
在 JetPack 6.2/r36.4.3 中，NVIDIA已经移除了传统的 sysfs GPIO 接口（/sys/class/gpio）不建议再使用 sysfs 来控制 GPIO。推荐使用Linux统一的 libgpiod 管理 GPIO
- 安装前置软件包
sudo apt-get install busybox automake autoconf libtool- 验证安装是否成功
jetson@jetson-desktop:~$ gpioinfo
gpiochip0 - 164 lines:
line 0: "PA.00" "regulator-vdd-3v3-sd" output active-high [used]
line 1: "PA.01" unused input active-high
line 2: "PA.02" unused input active-high
line 3: "PA.03" unused input active-high
line 4: "PA.04" unused input active-high
line 5: "PA.05" unused input active-high
line 6: "PA.06" unused input active-high
line 7: "PA.07" unused input active-high
line 8: "PB.00" unused input active-high
line 9: "PC.00" unused input active-high
...........- 读取 GPIO 状态
gpioget $(gpiofind "PQ.06")- 将 GPIO 设置为输出模式
sudo busybox devmem 0x2430070 w 0x004各个引脚对应的寄存器地址从 官方文档 中可以查询到
- 保持高电平：
gpioset --mode=wait `gpiofind "PQ.06"`=1- 保持低电平：
gpioset --mode=wait `gpiofind "PQ.06"`=02.2 使用python控制GPIO
在JetPack6 系统中仍需要修改寄存器内容来更改引脚GPIO模式以使用高级语言控制GPIO
- 将 PQ.06 引脚设置为输出模式
sudo busybox devmem 0x2430070 w 0x004- 如果您尝试使用 conda 环境运行脚本请执行以下指令安装 Jetson 官方的 GPIO 库
pip install JETSON.GPIO- 建议执行以下指令，重新安装系统自带的 JETSON.GPIO 库
sudo rm -rf /usr/lib/python3*/dist-packages/Jetson
sudo rm -rf /usr/local/lib/python3*/dist-packages/Jetson
git clone https://github.com/NVIDIA/jetson-gpio.git
cd jetson-gpio
sudo pip3 install .Jetson GPIO 库提供了四种给I / O引脚编号的方法。
- BOARD：物理引脚编号（40针接口顺序）。
- BCM：Broadcom SoC 的 GPIO 编号（常用）。
- CVM：CVM/CVB 连接器的信号名称。
- TEGRA_SOC：Tegra SoC 信号名称。
import time
import RPi.GPIO as GPIO
# define pin number PQ.06
output_pin = 31
# set pin as BOARD mode
GPIO.setmode(GPIO.BOARD)
# set pin mode
GPIO.setup(output_pin, GPIO.OUT)
print("Press CTRL+C to exit")
curr_value = GPIO.HIGH
try:
while True:
time.sleep(1)
print("pin {} now is {}".format(output_pin, curr_value))
GPIO.output(output_pin, curr_value)
# blink
curr_value ^= GPIO.HIGH
finally:
GPIO.cleanup()其他具体用法和例程可参考项目官网
2.3使用C/C++控制GPIO
在JetPack6 系统中仍需要修改寄存器内容来更改引脚GPIO模式以使用高级语言控制GPIO
- 将 PQ.06 引脚设置为输出模式
sudo busybox devmem 0x2430070 w 0x004- 安装libgpio-dev
sudo apt install libgpiod-dev参考例程：
/**
* License - MIT.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <gpiod.h>
#define GPIO_CHIP "/dev/gpiochip0"
#define GPIO_LED 106
int main()
{
int ret = 0;
struct gpiod_chip *gpiochip;
struct gpiod_line *gpioline;
// Open driver.
gpiochip = gpiod_chip_open(GPIO_CHIP);
if (NULL == gpiochip) {
printf("Error in gpiod_chip_open.\n");
ret = -1;
goto out1;
}
// Get gpio.
gpioline = gpiod_chip_get_line(gpiochip, GPIO_LED);
if (NULL == gpioline) {
printf("Error in gpiod_chip_get_line.\n");
ret = -1;
goto out2;
}
// Set gpio direction.
ret = gpiod_line_request_output(gpioline, "gpio", 0);
if (ret != 0) {
printf("Error in gpiod_line_request_output.\n");
ret = -1;
goto out2;
}
// Blink PQ.06
for (int i = 0; i < 30; i++) {
printf("%d times.\n", i);
gpiod_line_set_value(gpioline, 1);
sleep(1);
gpiod_line_set_value(gpioline, 0);
sleep(1);
}
// Release.
gpiod_line_release(gpioline);
out2:
gpiod_chip_close(gpiochip);
out1:
return ret;
}- 编译源文件
g++ test_gpio.cc -o test_gpio -lgpiod- 执行测试程序
./test_gpioPADCTL基地址与GPIO口偏移量
我们从官方文档中查找摘取了以下信息供您参考，您也可以自行查阅官方Pinmux和TRM文档。
PADCTL_A0(PADCTL_G3) 0x02430000
PADCTL_A4(PADCTL_G4) 0x02434000
PADCTL_A16(PADCTL_EDP) 0x02440000
PADCTL_A24(PADCTL_G7) 0x02448000
7号 GPIO09 PADCTL_G7_SOC_GPIO59_0 0x30 gpio-492 PAC.06 0x02448030
15号 GPIO12 PADCTL_EDP_SOC_GPIO39_0 0x20 gpio-433 PN.01 0x02440020
29号 GPIO01 PADCTL_G3_SOC_GPIO32_0 0x68 gpio-453 PQ.05 0x02430068
31号 GPIO11 PADCTL_G3_SOC_GPIO33_0 0x70 gpio-454 PQ.06 0x02430070
32号 GPIO07 PADCTL_G4_SOC_GPIO19_0 0x80 gpio-389 PG.06 0x02434080
33号 GPIO13 PADCTL_G4_SOC_GPIO21_0 0x40 gpio-391 PH.00 0x02434040
JETSON ORIN NX系列入门教程
五、其他外设
1. UART接口
1.1使用 cutecom 操作UART
cutecom 是一个跨平台的串口终端程序，它提供了一个简洁直观的图形用户界面，允许用户通过串口接口发送和接收数据。运行以下命令以安装 cutecom
sudo apt install cutecom
官方默认开启的UART接口为 ttyTHS1 即 40pin GPIO中的 pin8 (TX) 和 pin10( RX) 引脚。
- 使用一根条线短接8和10引脚
- 更改串口权限（临时授权）
sudo chmod 777 /dev/ttyTHS1- 运行如下语句将当前用户加入到用户组。（可选，永久授权）
sudo usermod -aG dialout $USER- 打开 cutecom，选择 ttyTHS1 并打开。
- 输入文本并回车，可以看到下方接收区显示有内容。
1.2 使用 python 操作 UART
- 更改串口权限
sudo chmod 777 /dev/ttyTHS1- 安装pyserial库
pip install pyserial- 运行以下脚本进行测试
import serial
import time
PORT = "/dev/ttyTHS1"
BAUDRATE = 115200
ENCODING = "UTF-8"
MESSAGE = "hello,jetson\r\n"
try:
with serial.Serial(PORT, BAUDRATE, timeout=2) as se:
print(f"Serial port {PORT} opened: {se.is_open}")
while True:
se.write(MESSAGE.encode(ENCODING))
print(f"Sent: {MESSAGE.strip()}")
try:
line = se.readline().decode(ENCODING).strip()
if line:
print(f"Received: {line}")
except Exception as e:
print(f"Read error: {e}")
time.sleep(1)
except serial.SerialException as e:
print(f"Serial error: {e}")
except KeyboardInterrupt:
print("\nExit by user.")
2. SPI接口
- 查看开发板spi资源
jetson@ubuntu:~/Downloads$ lsmod | grep -i spi
spidev 28672 0
spi_tegra114 32768 02.1使用C/C++进行SPI通讯
以SPI0为例，使用条线短接19()，20号针脚
- 下载SPI例程
git clone https://github.com/rm-hull/spidev-test- 编译源文件
cd spidev-test
gcc spidev_test.c -o spidev_test- 运行例程
sudo modprobe spidev #启动官方spi驱动
./spidev_test -D /dev/spidev0.0 -s 100000 -p "\x11\x22\x33" -v正确测试结果如下：
jetson@ubuntu:~/spidev-test$ ./spidev_test -D /dev/spidev0.0 -s 100000 -p "\x11\x22\x33" -v
spi mode: 0x0
bits per word: 8
max speed: 100000 Hz (100 KHz)
TX | 11 22 33 __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ | ."3
RX | 11 22 33 __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ | ."32.1使用python进行SPI通讯
- 安装spidev库
pip install spidev- 运行测试脚本
import spidev
import time
spi = spidev.SpiDev()
spi.open(0, 0)
spi.max_speed_hz = 1_000_000
spi.mode = 0
TEST_DATA = [
[11], [22], [33]
]
for data in TEST_DATA:
resp = spi.xfer2(data)
print(f"recived:{resp}")
time.sleep(0.1)
spi.close()正确测试结果如下：
(test) jetson@ubuntu:~/Downloads$ python test_spi.py
recived:[11]
recived:[22]
recived:[33]3. I2C接口
- 安装i2c工具
sudo apt install i2c-tools- 查看开发板可用的i2c的总线：
jetson@jetson-desktop:~$ i2cdetect -l
i2c-0 i2c 3160000.i2c I2C adapter
i2c-1 i2c c240000.i2c I2C adapter
i2c-2 i2c 3180000.i2c I2C adapter
i2c-4 i2c Tegra BPMP I2C adapter I2C adapter
i2c-5 i2c 31b0000.i2c I2C adapter
i2c-7 i2c c250000.i2c I2C adapter
i2c-9 i2c NVIDIA SOC i2c adapter 0 I2C adapter- 查看连接到对应总线的i2c设备：
jetson@jetson-desktop:~$ i2cdetect -y -r -a 7
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: 00 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- - 正确接入i2c设备后：
i2cdetect -y -r -a 7
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- 3c -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 4. RTC接口
实时时钟（Real-Time Clock, RTC）是一种独立计时设备，可在系统断电或主电源关闭时持续提供精确的时间和日期信息。当开发板在离线环境下运行，并且断电后仍需保持时间同步时，就需要使用到RTC。
官方套件不支持RTC功能
- 检查系统时间是否正确
timedatectl status- 同步网络时间
sudo apt install ntpdate
sudo ntpdate cn.pool.ntp.org- 设置时区
sudo timedatectl set-timezone Asia/Shanghai- 同步系统时间到RTC硬件
sudo hwclock --systohc --utc --rtc /dev/rtc0 --noadjfile- 检查RTC硬件时间
sudo hwclock --show --utc --rtc /dev/rtc0 --noadjfile- 设置开机自动同步RTC时间
1. 打开文件
sudo vi /lib/systemd/system/hwrtc.service 2.写入以下内容
[Unit]
Description=Synchronise System clock to hardware RTC
DefaultDependencies=no
After=systemd-modules-load.service
Before=systemd-journald.service systemd-fsck-root.service time-sync.target sysinit.target shutdown.target
Conflicts=shutdown.target
[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/sbin/hwclock --hctosys --utc --rtc /dev/rtc0 --noadjfile
RestrictRealtime=yes
[Install]
WantedBy=sysinit.target 3.设置开机自启动服务
sudo systemctl enable hwrtc.service- 手动RTC硬件同步到系统时间
sudo hwclock --hctosys --utc --rtc /dev/rtc0 --noadjfile- 关闭网络同步时间
sudo timedatectl set-ntp falseJETSON ORIN NX系列入门教程
Orin Nano/NX USB配置说明
一、Jetson Orin Nano配置方法
1. JetPack 5.1.5配置方法
1. 1刷入JetPack 5.1.5系统。
参考官方固件刷机流程
1.2 将设备树文件下载到开发板
设备正常开机后，打开终端命令行，将修改后的设备树文件下载到开发板。
git clone https://gitee.com/kongyuantech/document.git
cd document/AN002\ Orin\ Nano\ NX\ USB配置/5.1.4/1.3 使用命令行替换设备树。
选择执行以下命令替换DTB设备树文件并重启设备。
- Jetson Orin Nano 4G 请使用以下代码
sudo cp /boot/dtb/kernel_tegra234-p3767-0004-p3768-0000-a0.dtb /boot/dtb/kernel_tegra234-p3767-0004-p3768-0000-a0.dtb.backup # 备份原设备树文件
sudo cp kernel_tegra234-p3767-0004-p3768-0000-a0.dtb /boot/dtb
sudo chown 0:0 /boot/dtb/kernel_tegra234-p3767-0004-p3768-0000-a0.dtb
sudo chmod 644 /boot/dtb/kernel_tegra234-p3767-0004-p3768-0000-a0.dtb
sudo reboot- Jetson Orin Nano 8G 请使用以下代码
sudo cp /boot/dtb/kernel_tegra234-p3767-0003-p3768-0000-a0.dtb /boot/dtb/kernel_tegra234-p3767-0003-p3768-0000-a0.dtb.backup # 备份原设备树文件
sudo cp kernel_tegra234-p3767-0003-p3768-0000-a0.dtb /boot/dtb
sudo chown 0:0 /boot/dtb/kernel_tegra234-p3767-0003-p3768-0000-a0.dtb
sudo chmod 644 /boot/dtb/kernel_tegra234-p3767-0003-p3768-0000-a0.dtb
sudo reboot
2. JetPack 6.2.1配置方法
2.1 刷入JetPack 6.2.1系统。
参考官方固件刷机流程
2.2 将设备树文件下载到开发板
- 设备正常开机后，打开终端命令行，将修改后的设备树文件下载到开发板。
git clone https://gitee.com/kongyuantech/document.git
cd document/AN002\ Orin\ Nano\ NX\ USB配置/6.2/1.3 使用命令行替换设备树。
选择执行以下命令增加DTB设备树文件并重启设备。
- Jetson Orin Nano 4G 请执行以下代码
sudo cp orin_nano_4g.dtb /boot/dtb
sudo sed -i 's#console=tty0#console=tty0\n FDT /boot/dtb/orin_nano_4g.dtb#g' /boot/extlinux/extlinux.conf
sudo reboot
- Jetson Orin Nano 8G 请执行以下代码
sudo cp orin_nano_8g.dtb /boot/dtb
sudo sed -i 's#console=tty0#console=tty0\n FDT /boot/dtb/orin_nano_8g.dtb#g' /boot/extlinux/extlinux.conf
sudo reboot二、Jetson Orin NX配置方法
1. JetPack 5.1.5配置方法
1. 1刷入JetPack 5.1.5系统。
参考官方固件刷机流程
1.2 将设备树文件下载到开发板
- 设备正常开机后，打开终端命令行，将修改后的设备树文件下载到开发板。
git clone https://gitee.com/kongyuantech/document.git
cd document/AN002\ Orin\ Nano\ NX\ USB配置/5.1.4/1.3 使用命令行替换设备树。
选择执行以下命令替换DTB设备树文件并重启设备。
- Jetson Orin NX 8G 请执行以下代码
sudo cp /boot/dtb/kernel_tegra234-p3767-0001-p3768-0000-a0.dtb /boot/dtb/kernel_tegra234-p3767-0001-p3768-0000-a0.dtb.backup # 备份原设备树文件
sudo cp kernel_tegra234-p3767-0001-p3768-0000-a0.dtb /boot/dtb
sudo chown 0:0 /boot/dtb/kernel_tegra234-p3767-0001-p3768-0000-a0.dtb
sudo chmod 644 /boot/dtb/kernel_tegra234-p3767-0001-p3768-0000-a0.dtb
sudo reboot- Jetson Orin NX 16G 请执行以下代码
sudo cp /boot/dtb/kernel_tegra234-p3767-0000-p3768-0000-a0.dtb /boot/dtb/kernel_tegra234-p3767-0000-p3768-0000-a0.dtb.backup # 备份原设备树文件
sudo cp kernel_tegra234-p3767-0000-p3768-0000-a0.dtb /boot/dtb
sudo chown 0:0 /boot/dtb/kernel_tegra234-p3767-0000-p3768-0000-a0.dtb
sudo chmod 644 /boot/dtb/kernel_tegra234-p3767-0000-p3768-0000-a0.dtb
sudo reboot
2. JetPack 6.2.1配置方法
2.1 刷入JetPack 6.2.1系统。
参考官方固件刷机流程
2.2 将设备树文件下载到开发板
- 设备正常开机后，打开终端命令行，将修改后的设备树文件下载到开发板。
git clone https://gitee.com/kongyuantech/document.git
cd document/AN002\ Orin\ Nano\ NX\ USB配置/6.2/2.3 使用命令行替换设备树。
选择执行以下命令增加DTB设备树文件并重启设备。
- Jetson Orin NX 8G 请使用以下代码
sudo cp orin_nx_8g.dtb /boot/dtb
sudo sed -i 's#console=tty0#console=tty0\n FDT /boot/dtb/orin_nx_8g.dtb#g' /boot/extlinux/extlinux.conf
sudo reboot
- Jetson Orin NX 16G 请使用以下代码
sudo cp orin_nx_16g.dtb /boot/dtb
sudo sed -i 's#console=tty0#console=tty0\n FDT /boot/dtb/orin_nx_16g.dtb#g' /boot/extlinux/extlinux.conf
sudo reboot检测配置结果
替换设备树后，4个USB3.0端口（C1901为3个）可正常工作，Type-C端口系统默认处于关闭状态
可使用以下命令查看USB端口工作情况。
lsusb -t- 未替换设备树前：
- 替换设备树成功后：
您也可以自行使用DISK工具或dd指令测试读写速率是否达到USB3.0的标准。
三、配置Tpye-C端口模式
- 配置Type-C端口为Device模式
注意：此命令为临时启用，重启会失效。
sudo bash -c 'echo device > /sys/class/usb_role/usb2-0-role-switch/role'设置后，使用Type-C端口连接到PC主机时，具有以下功能
- COM口，设备的终端命令行
- 虚拟网卡，设备ip地址默认为：192.168.55.1
- NCM (Network Control Model)，设备可通过PC主机联网，仅支持Linux、Mac
- 开机默认配置Type-C端口为Device模式（永久有效）
sudo sed -i 's#exit 0#echo device > /sys/class/usb_role/usb2-0-role-switch/role\nexit 0#g' /opt/nvidia/l4t-usb-device-mode/nv-l4t-usb-device-mode-start.shJETSON ORIN NX系列入门教程
连接到Jetson系统
Jetson拥有一个HDMI/DP视频输出接口、RJ45网口、Type-C接口和UART调试接口，下面我们将使用上面这四种方法连接到Jetson开发板系统。
1. 连接显示器
使用功能正常的 DP/HDMI 线材连接到功能正常的显示器，接通开发板电源就能正常进入桌面。接入鼠标键盘后即可如普通桌面PC一样操作。
2. 远程登陆
此方法需要提前使用SDK Maneger写入用户名和密码
2.1将开发板连接到路由器，并接通电源开机
2.2-1通过路由器后台获取到开发板ip地址
不同品牌的路由器存在较大差异，请按照设备制造商的指引进行查询
2.2-2使用advanced ip scanner软件扫描同网段下的设备
在刷入官方固件时，制造商信息为 NVIDIA Corporation 的设备即为开发板。
2.3 下载安装 putty 或 MobaXterm 等连接工具（下面以MobaXterm为例）
2.4 点击 session 创建一个会话
2.5 点击 SSH
2.6 输入刚刚查询到的 IP 地址和刷入系统时或者自定义的用户名，完成后点击OK保存
2.7 输入密码（命令行不显示），完成后回车即可登录到系统。
3. 通过type-c连接到SSH
3.1 在开发板正常上电开机
在默认模式下连接到主机后，Jetson默认作为主机，其IP地址为 192.168.55.1
3.2 使用 putty 或 MobaXterm 等连接工具，连接到开发板
参考 2.3 节进行操作
4. 远程连接到Jetson桌面环境
在无显示器模式下建议使用HDMI/DP诱骗器确保桌面环境正常
4.1 使用 NoMachine
NoMachine 是一款功能强大、跨平台的远程桌面软件，专注于提供高速、高画质的远程访问体验。其核心基于 NX 协议，通过高效压缩和加密技术实现低延迟传输，特别适合图形密集型任务（如视频编辑、3D 渲染）和多场景协作。
- 主机下载安装NoMachine
- Jetson端下载安装NoMachine （下载页面参考： NoMachine–arm_version）
- 通过scp等方式上传到开发板（也可尝试复制下载链接通过命令行使用 wget 命令下载）
- 命令行安装deb软件包
sudo dpkg -i nomachine_9.1.24_6_arm64.deb #随软件的更新包名可能发生变化- 主机和开发板都安装成功后将其连接到同一局域网下，在主机打开NoMachine便可自动搜索到Jetson服务端
- 输入用户名和密码，点击OK
- 成功连接到桌面
- 点击软件显示区域右上角可以进入设置调节画质、显示画幅和编码模式等选项
4.2 使用 VNC
VNC（虚拟网络计算机）是一种基于图形界面的远程控制技术，允许用户通过网络（互联网或局域网）实时访问并操作另一台计算机的桌面环境。其核心协议为 RFB（Remote Framebuffer Protocol），通过传输屏幕帧缓冲区的像素数据实现跨平台远程控制
- 下载安装主机端
- 在Jetson上进行如下设置
- 设置VNC服务为开机自启
cd /usr/lib/systemd/user/graphical-session.target.wants sudo ln -s ../vino-server.service ./.
- 配置VNC服务
gsettings set org.gnome.Vino prompt-enabled false gsettings set org.gnome.Vino require-encryption false
- 设置VNC登录密码
# 将 <密码> 替换为你要设置的密码 gsettings set org.gnome.Vino authentication-methods "['vnc']" gsettings set org.gnome.Vino vnc-password $(echo -n '密码'|base64) - 重启系统生效
sudo reboot
- 设置VNC服务为开机自启
- 在主机的 VNC 软件中新建连接并输入 Jetson 的局域网 IP 并按回车确认
- 输入密码并确认
可参考英伟达官方说明 Setting Up VNC | NVIDIA Developer
JETSON ORIN NANO 进阶教程
本章主要Jetson特色的AI功能使用
JETSON ORIN NANO 进阶教程
新页面
JETSON ORIN NANO 进阶教程
安装jtop
jtop 是英伟达专为 Jetson 系列边缘计算设备开发的交互式系统监控工具。
1 安装jtop
- 安装jtop需要的依赖库
sudo apt update
sudo apt install python3
sudo apt install python3-pip- 安装jtop
sudo pip3 install -U pip -i https://pypi.tuna.tsinghua.edu.cn/simple
sudo pip3 install jetson-stats -i https://pypi.tuna.tsinghua.edu.cn/simple
sudo systemctl restart jtop.service2 jtop的使用
- 安装完成后在控制台中输入
jtop打开主界面
2.1 监视各个模块的工作信息
2.2 控制风扇
2.3 查看内置软件信息
JETSON ORIN NANO 进阶教程
安装CUDA
Jetson CUDA是NVIDIA为边缘AI设计的并行计算平台，基于ARM的Jetson系列硬件，支持GPU加速深度学习与实时推理，低功耗高性能。
安装CUDA JETSON SDK
sudo apt update
sudo apt install nvidia-jetpack
对开发板进行压力测试
以下测试仅在 JetPack 6.1 (rev1) 和 JetPack 5.1.5 版本中通过验证
调整功耗上限：
sudo nvpmodel -m 2 #nano 模式2为super
sudo jetson_clocks --fancpu压力测试：
sudo apt install stress
stress --cpu 8 --io 4 --vm 2 --vm-bytes 128M --hdd 1 --hdd-bytes 1024M
gpu压力测试：
git clone https://github.com/anseeto/jetson-gpu-burn/
cd jetson-gpu-burn
make
./gpu_burn 100000状态查询：
sudo jtop
Orin Nano 整机最大功率为30W.
Orin NX 整机最大功率为40W.
JETSON ORIN NANO 进阶教程
编译安装opencv with cuda
JetPack预装的opencv没有启用cuda，需要自行编译安装。
1. 脚本一键安装
#!/bin/bash
# opencv_install.sh
# Modified from https://github.com/AastaNV/JEP/blob/master/script/install_opencv4.10.0_Jetpack6.1.sh
version="4.10.0"
folder="workspace"
remove_old=""
set -e
# Parse command-line arguments
for arg in "$@"; do
case $arg in
--version=*)
version="${arg#*=}"
;;
--folder=*)
folder="${arg#*=}"
;;
--remove-old=*)
remove_old="${arg#*=}"
;;
--help|-h)
echo "Usage: $0 [--version=4.x.x] [--folder=dir] [--remove-old=yes/no]"
exit 0
;;
*)
echo "Unknown parameter: $arg"
echo "Usage: $0 [--version=4.x.x] [--folder=dir] [--remove-old=yes/no]"
exit 1
;;
esac
done
# Create installation directory if it doesn't exist
if [ ! -d "$folder" ]; then
echo "Creating directory: $folder"
mkdir -p "$folder"
fi
cd "$folder" || exit
# Old OpenCV removal logic
if [ -z "$remove_old" ]; then
read -rp "Do you want to remove system-installed OpenCV? (yes/no): " remove_old
fi
case "$remove_old" in
[yY] | [yY][eE][sS])
echo "** Removing system OpenCV packages"
sudo apt -y purge *libopencv*
sudo apt -y autoremove
;;
*)
echo "** Skipping system OpenCV removal"
;;
esac
echo "------------------------------------"
echo "** Installing dependencies (1/4)"
echo "------------------------------------"
sudo apt-get update
sudo apt-get install -y build-essential cmake git libgtk2.0-dev pkg-config \
libavcodec-dev libavformat-dev libswscale-dev libgstreamer1.0-dev \
libgstreamer-plugins-base1.0-dev python3-dev python3-numpy libtbb2 \
libtbb-dev libjpeg-dev libpng-dev libtiff-dev libv4l-dev v4l-utils qv4l2 curl
# Verify essential dependencies installed
for dep in g++ cmake git pkg-config; do
if ! command -v "$dep" > /dev/null; then
echo "Error: $dep installation failed"
exit 1
fi
done
echo "------------------------------------"
echo "** Downloading OpenCV ${version} (2/4)"
echo "------------------------------------"
# Check if source files already exist
download_opencv=false
download_contrib=false
if [ ! -f "opencv-${version}.zip" ]; then
echo "Downloading opencv-${version}.zip"
wget -O opencv-${version}.zip https://github.com/opencv/opencv/archive/${version}.zip || {
echo "Download failed! Check your internet connection or verify the version exists"
exit 1
}
download_opencv=true
else
echo "opencv-${version}.zip exists, skipping download"
fi
if [ ! -f "opencv_contrib-${version}.zip" ]; then
echo "Downloading opencv_contrib-${version}.zip"
wget -O opencv_contrib-${version}.zip https://github.com/opencv/opencv_contrib/archive/${version}.zip || {
echo "Download failed! Check your internet connection or verify the version exists"
exit 1
}
download_contrib=true
else
echo "opencv_contrib-${version}.zip exists, skipping download"
fi
# Unpack source files
if [ ! -d "opencv-${version}" ] || $download_opencv; then
if [ -d "opencv-${version}" ]; then
echo "Removing existing opencv-${version} directory"
rm -rf "opencv-${version}"
fi
echo "Unpacking opencv-${version}.zip"
unzip -q opencv-${version}.zip || {
echo "Extraction failed! File may be corrupt"
exit 1
}
fi
if [ ! -d "opencv_contrib-${version}" ] || $download_contrib; then
if [ -d "opencv_contrib-${version}" ]; then
echo "Removing existing opencv_contrib-${version} directory"
rm -rf "opencv_contrib-${version}"
fi
echo "Unpacking opencv_contrib-${version}.zip"
unzip -q opencv_contrib-${version}.zip || {
echo "Extraction failed! File may be corrupt"
exit 1
}
fi
# Clean up zip files after successful extraction
if [ $? -eq 0 ]; then
rm -f opencv-${version}.zip opencv_contrib-${version}.zip
fi
cd opencv-${version} || exit
echo "------------------------------------"
echo "** Building OpenCV ${version} (3/4)"
echo "------------------------------------"
mkdir -p release
cd release
# Auto-detect CUDA architecture
cuda_arch=""
if command -v nvidia-smi &> /dev/null; then
gpu_name=$(nvidia-smi --query-gpu=name --format=csv,noheader | head -n1)
if [[ $gpu_name == *"Orin"* ]] || [[ $gpu_name == *"Jetson"* ]]; then
cuda_arch="8.7"
elif [[ $gpu_name == *"A100"* ]]; then
cuda_arch="8.0"
fi
fi
cmake_cmd="cmake -D WITH_CUDA=ON -D WITH_CUDNN=ON -D OPENCV_GENERATE_PKGCONFIG=ON "
cmake_cmd+="-D OPENCV_EXTRA_MODULES_PATH=../../opencv_contrib-${version}/modules "
cmake_cmd+="-D WITH_GSTREAMER=ON -D WITH_LIBV4L=ON -D BUILD_opencv_python3=ON "
cmake_cmd+="-D BUILD_TESTS=OFF -D BUILD_PERF_TESTS=OFF -D BUILD_EXAMPLES=OFF "
cmake_cmd+="-D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local "
# Add CUDA architecture if detected
if [ -n "$cuda_arch" ]; then
echo "Detected NVIDIA GPU: ${gpu_name}, using CUDA_ARCH_BIN=${cuda_arch}"
cmake_cmd+="-D CUDA_ARCH_BIN=${cuda_arch} -D CUDA_ARCH_PTX=\"\" "
else
echo "No supported GPU detected, skipping CUDA architecture flags"
fi
# Execute CMake configuration
echo "CMake command: $cmake_cmd .."
$cmake_cmd .. || {
echo "CMake configuration failed"
exit 1
}
# Parallel build (leave one core for system stability)
cpu_cores=$(($(nproc) - 1))
[ $cpu_cores -lt 1 ] && cpu_cores=1
echo "Building with ${cpu_cores} CPU cores"
make -j${cpu_cores} || {
echo "Compilation failed"
exit 1
}
echo "------------------------------------"
echo "** Installing OpenCV ${version} (4/4)"
echo "------------------------------------"
sudo make install || {
echo "Installation failed"
exit 1
}
# Add environment variables to .bashrc (only if not already present)
bashrc=~/.bashrc
env_lines=(
"export LD_LIBRARY_PATH=/usr/local/lib:\$LD_LIBRARY_PATH"
"export PYTHONPATH=/usr/local/lib/python3.10/site-packages/:\$PYTHONPATH"
)
for line in "${env_lines[@]}"; do
if ! grep -Fxq "$line" "$bashrc"; then
echo "Adding to .bashrc: $line"
echo "$line" >> "$bashrc"
else
echo "Environment variable already exists: $line"
fi
done
source ~/.bashrc
echo "** OpenCV ${version} installation completed"
echo "Verification commands:"
echo " pkg-config --modversion opencv4"
echo " python3 -c 'import cv2; print(cv2.__version__)'"
echo "** Installation successful!"2. 手动安装
2.1 卸载自带opencv
sudo apt-get purge libopencv*
sudo apt autoremove
sudo apt-get update2.2 安装前置软件包
sudo apt-get update
sudo apt-get install -y build-essential cmake git libgtk2.0-dev pkg-config libavcodec-dev libavformat-dev libswscale-dev
sudo apt-get install -y libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev python3.10-dev python3-numpy
sudo apt-get install -y libtbb2 libtbb-dev libjpeg-dev libpng-dev libtiff-dev libv4l-dev v4l-utils qv4l2
sudo apt-get install -y curl2.3 获取opencv源码(以4.10.0版本为例)
version=4.10.0
wget -O "opencv-${version}.zip" "https://github.com/opencv/opencv/archive/${version}.zip"
wget -O "opencv_contrib-${version}.zip" "https://github.com/opencv/opencv_contrib/archive/${version}.zip"
unzip "opencv-${version}.zip"
unzip "opencv_contrib-${version}.zip"
rm "opencv-${version}.zip" "opencv_contrib-${version}.zip"
cd "opencv-${version}/"2.4 编译源码
此步骤至少需要半小时以上。
中途可能会下载第三方软件包，建议提前确认网络环境。
mkdir build
cd build/
cmake -D WITH_CUDA=ON -D WITH_CUDNN=ON -D CUDA_ARCH_BIN="8.7" -D CUDA_ARCH_PTX="" -D OPENCV_GENERATE_PKGCONFIG=ON -D OPENCV_EXTRA_MODULES_PATH=../../opencv_contrib-${version}/modules -D WITH_GSTREAMER=ON -D WITH_LIBV4L=ON -D BUILD_opencv_python3=ON -D BUILD_TESTS=OFF -D BUILD_PERF_TESTS=OFF -D BUILD_EXAMPLES=OFF -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local ..
make -j$(nproc)2.5 安装
sudo make install
echo 'export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH' >> ~/.bashrc
echo 'export PYTHONPATH=/usr/local/lib/python3.10/site-packages/:$PYTHONPATH' >> ~/.bashrc
source ~/.bashrc三、验证测试
#--test_cuda.cpp
#include <opencv2/opencv.hpp>
#include <opencv2/core/cuda.hpp>
#include <opencv2/cudaarithm.hpp>
#include <iostream>
#include <chrono>
// CPU 矩阵乘法
void cpu_matrix_mult(cv::Mat& a, cv::Mat& b, cv::Mat& result) {
for (int i = 0; i < 50; i++) {
result = a * b;
}
}
// GPU 矩阵乘法
void gpu_matrix_mult(cv::cuda::GpuMat& d_a, cv::cuda::GpuMat& d_b, cv::cuda::GpuMat& d_result) {
cv::cuda::Stream stream;
for (int i = 0; i < 50; i++) {
cv::cuda::gemm(d_a, d_b, 1.0, cv::cuda::GpuMat(), 0, d_result, 0, stream);
stream.waitForCompletion();
}
}
int main() {
try {
std::cout << "--- OpenCV CUDA Matrix Multiplication Test ---\n";
// 创建两个 1000x1000 的随机矩阵
cv::Mat mat_a(1000, 1000, CV_32FC1);
cv::Mat mat_b(1000, 1000, CV_32FC1);
cv::randu(mat_a, 0.0f, 1.0f);
cv::randu(mat_b, 0.0f, 1.0f);
cv::Mat cpu_result;
// CPU 测试
auto start_cpu = std::chrono::high_resolution_clock::now();
cpu_matrix_mult(mat_a, mat_b, cpu_result);
auto end_cpu = std::chrono::high_resolution_clock::now();
double cpu_time = std::chrono::duration_cast<std::chrono::milliseconds>(end_cpu - start_cpu).count();
// GPU 测试
cv::cuda::GpuMat d_mat_a, d_mat_b, d_result;
d_mat_a.upload(mat_a);
d_mat_b.upload(mat_b);
auto start_gpu = std::chrono::high_resolution_clock::now();
gpu_matrix_mult(d_mat_a, d_mat_b, d_result);
auto end_gpu = std::chrono::high_resolution_clock::now();
double gpu_time = std::chrono::duration_cast<std::chrono::milliseconds>(end_gpu - start_gpu).count();
// 下载结果进行验证
cv::Mat gpu_result;
d_result.download(gpu_result);
// 计算误差(一般为空)
double diff = cv::norm(cpu_result, gpu_result, cv::NORM_L2);
std::cout << "Result difference: " << diff << "\n";
std::cout << "Performance Results:\n"
<< " - CPU time: " << cpu_time << " ms\n"
<< " - GPU time: " << gpu_time << " ms\n"
<< " - Speedup: " << cpu_time / gpu_time << "x\n";
std::cout << "\n✅ CUDA matrix multiplication test completed\n";
return 0;
} catch (const cv::Exception& e) {
std::cerr << "OpenCV Error (" << e.err << "): " << e.what() << "\n";
return -1;
} catch (const std::exception& e) {
std::cerr << "Standard Error: " << e.what() << "\n";
return -2;
}
}编译运行
jetson@jetson-desktop:~/work$ g++ test_cuda.cpp -o test_cuda `pkg-config --cflags --libs opencv4`
jetson@jetson-desktop:~/work$ ./test_cuda
--- OpenCV CUDA Performance Test ---
Performance Results:
- CPU time: 2451 ms
- GPU time: 918 ms
- Speedup: 2.66993x
✅ CUDA performance test completed
JETSON ORIN NANO 进阶教程
安装使用pytorch和torchvision
PyTorch 是 Python 中最流行、最易用的深度学习框架之一。它让开发者能够像操作普通 Python 代码一样，直观、灵活地设计和训练复杂的神经网络模型。其简洁的 API 设计和强大的 GPU 加速支持，使得从研究想法到实际部署的开发过程都极其高效便捷，广受开发者青睐。
NVIDIA 为 Jetson 系列设备专门适配了对应的软件包，其版本依赖关系如下：
下面教程以 JetPack6.2.1 cuda12.6 版本为例
1.安装torch工具包
1.1下载并安装torch , torchvison
wget https://pypi.jetson-ai-lab.io/jp6/cu126/+f/62a/1beee9f2f1470/torch-2.8.0-cp310-cp310-linux_aarch64.whl
wget https://pypi.jetson-ai-lab.io/jp6/cu126/+f/907/c4c1933789645/torchvision-0.23.0-cp310-cp310-linux_aarch64.whl
pip install torch-2.8.0-cp310-cp310-linux_aarch64.whl torchvision-0.23.0-cp310-cp310-linux_aarch64.whl -i https://pypi.tuna.tsinghua.edu.cn/simple1.2 检测是否正确安装
使用python执行下面三个语句
jetson@jetson-desktop:~$ python
Python 3.10.16 (main, Dec 11 2024, 16:18:56) [GCC 11.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import torch
>>> print(torch.__version__)
2.8.0
>>> print(torch.cuda.is_available())
True2. 运行YOLO11
YOLO 是一种实时目标检测算法，它将目标检测视为单阶段回归问题，通过将图像划分为网格并直接预测边界框与类别概率，实现高速且高精度的检测。YOLO系列因开源易用、部署灵活，广泛应用于自动驾驶、安防监控、工业质检等领域。
2.1 安装miniconda
curl -L https://repo.anaconda.com/miniconda/Miniconda3-py310_25.3.1-1-Linux-aarch64.sh | bash
source ~/.bashrc
conda --version 2.2 conda换源
conda config --add channels https://mirrors.ustc.edu.cn/anaconda/pkgs/main/
conda config --add channels https://mirrors.ustc.edu.cn/anaconda/pkgs/free/
conda config --add channels https://mirrors.ustc.edu.cn/anaconda/cloud/conda-forge/
conda config --add channels https://mirrors.ustc.edu.cn/anaconda/cloud/msys2/
conda config --set show_channel_urls yes2.3创建conda环境
conda create -n jetson-ai python=3.102.4 进入conda环境
conda activate jetson-ai2.5 安装torch和torchvison
wget https://pypi.jetson-ai-lab.io/jp6/cu126/+f/62a/1beee9f2f1470/torch-2.8.0-cp310-cp310-linux_aarch64.whl
wget https://pypi.jetson-ai-lab.io/jp6/cu126/+f/907/c4c1933789645/torchvision-0.23.0-cp310-cp310-linux_aarch64.whl
pip install torch-2.8.0-cp310-cp310-linux_aarch64.whl torchvision-0.23.0-cp310-cp310-linux_aarch64.whl -i https://pypi.tuna.tsinghua.edu.cn/simple2.6 安装ultralytics
pip install ultralytics -i https://pypi.tuna.tsinghua.edu.cn/simple2.7 运行摄像头视频推理例程
接入摄像头，并在上面创建的环境中运行如下程序。
import cv2
import time
from ultralytics import YOLO
from ultralytics import YOLOWorld
# Load the YOLO model
model = YOLO("yolo11s.pt")
# Open the video file
video_path = 0
cap = cv2.VideoCapture(video_path)
# Loop through the video frames
while cap.isOpened():
# Read a frame from the video
success, frame = cap.read()
start = time.time()
if success:
# Run YOLO inference on the frame
results = model(frame)
inf_time = time.time() - start
# Visualize the results on the frame
annotated_frame = results[0].plot()
fps = 1.0 / inf_time if inf_time > 0 else 0
# show FPS
cv2.putText(annotated_frame, f"FPS: {fps:.2f}", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,255,0), 2)
cv2.imshow("YOLO Inference", annotated_frame)
# Break the loop if 'q' is pressed
if cv2.waitKey(1) & 0xFF == ord("q"):
break
else:
# Break the loop if the end of the video is reached
break
# Release the video capture object and close the display window
cap.release()
cv2.destroyAllWindows()
更多信息可参考Ultralytics YOLO11 -Ultralytics YOLO 文档
JETSON ORIN NANO 进阶教程
安装使用ollama
1. 运行以下指令安装ollama
curl -fsSL https://ollama.com/install.sh | sh2. 检查是否正确安装
jetson@jetson-desktop:~$ ollama -v
ollama version is 0.9.63. 下载并运行deepseek-r1 1.5b模型
ollama run deepseek-r1:1.5b
JETSON ORIN NANO 进阶教程
安装使用Jetson-container
开始本节内容前请确定您的网络环境能正常拉取docker镜像
Jetson-container是NVIDIA为Jetson设备打造的轻量Docker环境，预装CUDA、cuDNN、TensorRT，快速部署AI边缘应用。
本节以 Jetson Orin NX 16GB，JetPack6.2.1 运行 Comfy-UI 为例进行展示。您也可以参考官方示例
Comfy-UI 是一款专业的节点式Stable Diffusion图形界面，拖拽连接即可构建文生图工作流，支持LoRA、ControlNet、视频扩散，低代码、易扩展等应用及特性。
1. 下载编译jetson-container环境
git clone https://github.com/dusty-nv/jetson-containers.git
cd jetson-containersbash
jetson-containers/install.sh2. 拉取docker镜像并运行
jetson-containers run dustynv/comfyui:r36.4.33. 成功运行后命令行窗口输出如下
4. 打开对应服务的GUI网页
若在Jetson设备上打开则访问 http://0.0.0.0:8188
若在局域网内的其他设备则输入 http://<jetson设备IP>:8188
5. 设定映射路径，将开发板里下载好的模型映射到容器内部目录
jetson-containers run ~/models/:/opt/ComfyUI/models/checkpoints dustynv/comfyui:r36.4.36. 按照需求搭建工作流并调整参数生成图像
关于ComfyUI的使用教程请参考其官网 ComfyUI | 用AI生成视频、图像、音频
JETSON ORIN NANO 进阶教程
使用TensorRT加速
c++
python绑定
JETSON ORIN NANO 进阶教程
网卡驱动
JETSON ORIN NANO 进阶教程
4G模块使用说明
移远通信LTE Standard EM05系列是一款专为IoT/M2M应用而设计的LTE Cat 4模块。采用节省空间的M.2（NGFF）封装类型，超薄、紧凑的设计使其更易于嵌入到小尺寸产品中。
EM05系列支持最大下行速率150 Mbps，最大上行速率50 Mbps,包含三个型号：EM05-CN、EM05-E和EM05-G。支持LTE-FDD、LTE-TDD、DC-HSDPA、HSPA+、HSDPA、HSUPA、WCDMA和CDMA等多种网络制式。
要在Jetson系列上使用EM-05模块需要重新编译系统内核并刷入新编译的系统。
方法一：替换新内核
1.1 拉取编译好的资料
1.2 修改设备树配置文件
1.3 移动内核和驱动到指定位置
1.4 应用更改并重启验证
方法二：编译刷入完整系统
2.1 获取源码和工具链
- 安装编译依赖工具
sudo apt install build-essential bc
sudo apt-get install git bison flex libssl-dev zip libncurses-dev make git
sudo apt-get install build-essential bc- 创建工具链放置目录
mkdir $HOME/l4t-gcc-toolchain
cd $HOME/l4t-gcc-toolchain- 下载并解压交叉编译工具链
wget https://developer.nvidia.com/downloads/embedded/l4t/r36_release_v3.0/toolchain/aarch64--glibc--stable-2022.08-1.tar.bz2
tar xf aarch64--glibc--stable-2022.08-1.tar.bz2- 进入到缓存好的刷机固件目录
cd $HOME/nvidia/nvidia_sdk/JetPack_6.2.1_Linux_JETSON_ORIN_NANO_TARGETS/Linux_for_Tegra/source #根据实际目录进行修改- 根据 release tag 拉取源码。Jetson Linux Archive | NVIDIA Developer
./source_sync.sh -k -t <release-tag> #<release-tag>替换为你自己的发行版本如 jetson_36.4.32.2 修改内核源码
本部分内容可参考移远Linux&Andriod驱动技术手册
Jetson Orin Nano配置文件路径：arch/arm64/configs/defconfig
- 配置USB转串口驱动添加如下内容
CONFIG_USB_SERIAL=y
CONFIG_USB_SERIAL_WWAN=y
CONFIG_USB_SERIAL_OPTION=y
CONFIG_USB_NET_DRIVERS=y
CONFIG_USB_USBNET=y
CONFIG_USB_NET_QMI_WWAN=y
CONFIG_USB_WDM=y- 修改 drivers/usb/serial/option.c，向USB转串口驱动添加VID和PID
static const struct usb_device_id option_ids[] = {
#if 1 // 2025-04-24 Added by Quectel
{ USB_DEVICE(0x2C7C, 0x0125) },
#endif
... ...
}- 使用USBNet驱动，文件路径：drivers/usb/serial/option.c
static int option_probe(struct usb_serial *serial,
const struct usb_device_id *id)
{
... ...
#if 1 // 2025-04-24 Added by Quectel
if (serial->dev->descriptor.idVendor == cpu_to_le16(0x2C7C)) {
__u16 idProduct = le16_to_cpu(serial->dev->descriptor.idProduct);
struct usb_interface_descriptor *intf = &serial->interface->cur_altsetting->desc;
if (intf->bInterfaceClass != 0xFF || intf->bInterfaceSubClass == 0x42) {
//ECM, RNDIS, NCM, MBIM, ACM, UAC, ADB
return -ENODEV;
}
if ((idProduct&0xF000) == 0x0000) {
//MDM interface 4 is QMI
if (intf->bInterfaceNumber == 4 && intf->bNumEndpoints == 3
&& intf->bInterfaceSubClass == 0xFF && intf->bInterfaceProtocol == 0xFF)
return -ENODEV;
}
}
#endif
/* Store the device flags so we can use them during attach. */
usb_set_serial_data(serial, (void *)device_flags);
return 0;
}
- 添加零包机制，文件路径：drivers/usb/serial/usb_wwan.c
static struct urb *usb_wwan_setup_urb(struct usb_serial_port *port,
int endpoint,
int dir, void *ctx, char *buf, int len,
void (*callback) (struct urb *))
{
... ...
usb_fill_bulk_urb(urb, serial->dev,
usb_sndbulkpipe(serial->dev, endpoint) | dir,
buf, len, callback, ctx);
#if 1 //2025-04-24 Added by Quectel for zero packet
if (dir == USB_DIR_OUT) {
struct usb_device_descriptor *desc = &serial->dev->descriptor;
if (desc->idVendor == cpu_to_le16(0x2C7C))
urb->transfer_flags |= URB_ZERO_PACKET;
}
#endif
return urb;
}- 添加Reset-resume机制（休眠唤醒）文件路径：drivers/usb/serial/option.c
static struct usb_serial_driver option_1port_device = {
... ...
#ifdef CONFIG_PM
.suspend = usb_wwan_suspend,
.resume = usb_wwan_resume,
#if 1 //2025-04-24 Added by Quectel
.reset_resume = usb_wwan_resume,
#endif
#endif
};- 添加QMI_WWAN驱动
移远提供了QMI_WWAN驱动源文件qmi_wwan_q.c，将其复制到 drivers/net/usb/ 目录下。同时修改drivers/net/usb/Makefile，使其能编译 qmi_wwan_q.c
#Makefile
# must insert qmi_wwan_q.o before qmi_wwan.o
obj-${CONFIG_USB_NET_QMI_WWAN} += qmi_wwan_q.o
obj-${CONFIG_USB_NET_QMI_WWAN} += qmi_wwan.o 2.3 编译内核
此步骤可能需要进行半个小时以上
- 创建输出目录
cd ../../
mkdir kernel_out - 编译安装内核
export CROSS_COMPILE=$HOME/l4t-gcc-toolchain/aarch64--glibc--stable-2022.08-1/bin/aarch64-buildroot-linux-gnu- #设置交叉编译工具
make -C kernel #构建 Jetson Linux 内核镜像
sudo -E make install -C kernel #安装内核模块和树内模块- 将内核镜像复制到刷机目录下
cp kernel/kernel-jammy-src/arch/arm64/boot/Image ../Linux_for_Tegra/kernel/Image- 构建NVIDIA树外模块（驱动程序）
export CROSS_COMPILE=$HOME/l4t-gcc-toolchain/aarch64--glibc--stable-2022.08-1/bin/aarch64-buildroot-linux-gnu-
export KERNEL_HEADERS=$PWD/kernel/kernel-jammy-src
make modules- 安装到刷机目录下
export INSTALL_MOD_PATH=$HOME/nvidia/nvidia_sdk/JetPack_6.2.1_Linux_JETSON_ORIN_NANO_TARGETS/Linux_for_Tegra/rootfs/ #根据实际目录进行修改
sudo -E make modules_install- 开始构建DTB
export CROSS_COMPILE=$HOME/l4t-gcc-toolchain/aarch64--glibc--stable-2022.08-1/bin/aarch64-buildroot-linux-gnu-
export KERNEL_HEADERS=$PWD/kernel/kernel-jammy-src
make dtbs- 将生成的dtb文件拷贝到刷机目录
cp kernel-devicetree/generic-dts/dtbs/* /Linux_for_Tegra/kernel/dtb/2.4 刷入系统
- 进入刷机固件缓存目录
cd $HOME/nvidia/nvidia_sdk/JetPack_6.2.1_Linux_JETSON_ORIN_NANO_TARGETS/Linux_for_Tegra/source #根据实际目录进行修改使用命令行刷机：
- super模式
sudo ./tools/kernel_flash/l4t_initrd_flash.sh --external-device nvme0n1p1 -c tools/kernel_flash/flash_l4t_t234_nvme.xml -p "-c bootloader/generic/cfg/flash_t234_qspi.xml" --showlogs --network usb0 jetson-orin-nano-devkit-super internal- 普通模式
sudo ./flash.sh jetson-orin-nano-devkit-nvme internal2.5 开机验证
- 将Quectel_Qconnectmanager上传到开发板
- 解压并编译
unizp Quectel_QConnectManager_Linux_V1.6.5.zip
cd Quectel_QConnectManager_Linux_V1.6.5
make成功运行便可4G拨号上网
jetson@jetson-desktop:~/Downloads/Quectel_QConnectManager_Linux_V1.6.5$ sudo ./quectel-CM
[08-08_11:39:04:415] QConnectManager_Linux_V1.6.5
[08-08_11:39:04:416] Find /sys/bus/usb/devices/1-2.2 idVendor=0x2c7c idProduct=0x125, bus=0x001, dev=0x007
[08-08_11:39:04:416] Auto find qmichannel = /dev/cdc-wdm0
[08-08_11:39:04:417] Auto find usbnet_adapter = wwan0
[08-08_11:39:04:417] netcard driver = qmi_wwan_q, driver version = V1.2.6
[08-08_11:39:04:417] Modem works in QMI mode
[08-08_11:39:04:447] cdc_wdm_fd = 7
[08-08_11:39:04:523] Get clientWDS = 5
[08-08_11:39:04:557] Get clientDMS = 1
[08-08_11:39:04:589] Get clientNAS = 2
[08-08_11:39:04:620] Get clientUIM = 1
[08-08_11:39:04:653] Get clientWDA = 1
[08-08_11:39:04:684] requestBaseBandVersion EM05CNFDR08A03M1G_ND
[08-08_11:39:04:812] requestGetSIMStatus SIMStatus: SIM_READY
[08-08_11:39:04:876] requestGetProfile[pdp:1 index:1] ctnet///0/IPV4V6
[08-08_11:39:04:908] requestRegistrationState2 MCC: 460, MNC: 11, PS: Attached, DataCap: LTE
[08-08_11:39:04:940] requestQueryDataCall IPv4ConnectionStatus: DISCONNECTED
[08-08_11:39:04:941] ip addr flush dev wwan0
[08-08_11:39:04:947] ip link set dev wwan0 down
[08-08_11:39:05:003] requestSetupDataCall WdsConnectionIPv4Handle: 0x8723e530
[08-08_11:39:05:132] ip link set dev wwan0 up
[08-08_11:39:05:141] No default.script found, it should be in '/usr/share/udhcpc/' or '/etc//udhcpc' depend on your udhcpc version!
[08-08_11:39:05:142] busybox udhcpc -f -n -q -t 5 -i wwan0
udhcpc: started, v1.30.1
udhcpc: sending discover
udhcpc: sending select for 10.21.181.66
udhcpc: lease of 10.21.181.66 obtained, lease time 7200
[08-08_11:39:05:282] ip -4 address flush dev wwan0
[08-08_11:39:05:286] ip -4 address add 10.21.181.66/30 dev wwan0
[08-08_11:39:05:292] ip -4 route add default via 10.21.181.65 dev wwan0查看网卡信息
jetson@jetson-desktop:~$ ifconfig wwan0
wwan0: flags=193<UP,RUNNING,NOARP> mtu 1500
inet 10.21.181.66 netmask 255.255.255.252
inet6 fe80::5804:41ff:feda:ce83 prefixlen 64 scopeid 0x20<link>
ether 5a:04:41:da:ce:83 txqueuelen 1000 (Ethernet)
RX packets 9 bytes 2304 (2.3 KB)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 22 bytes 1854 (1.8 KB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
连通性测试
