Orin Nano系列指南
JETSON ORIN 系列入门教程
本章节主要介绍Jetson Orin的基本配置、系统烧录和基础外设使用。
JETSON ORIN 系列入门教程
连接到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 系列入门教程
摄像头
- 接入摄像头后，您可以使用以下指令查看现有摄像头的编号。
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 系列入门教程
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
3 持久化GPIO配置
某些场景下可能需要开机自动配置引脚，除了配置开机脚本以外，还可以通过修改Pinmux配置表来完成。
3.1 获取Pinmux配置表和配置说明
可以在 Jetson Download Center 找到Jetson Orin NX Series and Jetson Orin Nano Series Pinmux 项目并下载，或者直接点击此处获取。
3.2 更改Pinmux配置并生成设备树描述文件
以GPIO11(PQ.06)为例，将其从默认的输入模式改成输出模式，并默认输出高电平。
更改后：
保存后点击上方的Generate DT File，excel可能会提示宏被禁用，在选项有关可信文件的内容中将该文件加入到可信列表即可。
3.3 替换设备树文件
将生成的Orin-jetson orin nano&nx pinmux hdmi-padvoltage-default.dtsi复制一份，并分别改名为
tegra234-mb1-bct-pinmux-p3767-dp-a03.dtsi
tegra234-mb1-bct-pinmux-p3767-hdmi-a03.dts
将Orin-jetson orin nano&nx pinmux hdmi-pinmux.dtsi也复制一份并分别改名为
tegra234-mb1-bct-padvoltage-p3767-hdmi-a03.dtsi
tegra234-mb1-bct-padvoltage-p3767-pd-a03.dtsi
最后连同Orin-jetson orin nano&nx pinmux hdmi-gpio-default.dtsi一起五个文件复制到./Linux_for_Tegra/bootloader/t186ref/BCT目录下
3.4 烧录新的Pinmux配置并开机验证
将开发板重启到恢复模式，执行下面指令刷入新的pinmux
sudo ./flash.sh -c bootloader/t186ref/cfg/flash_t234_qspi.xml --no-systemimg -k A_MB1_BCT jetson-orin-nano-devkit nvme0n1p1 重启后上电验证31号引脚的电平，或者直接使用万用表测量。
gpioget $(gpiofind "PQ.06")JETSON ORIN 系列入门教程
其他外设
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. CAN总线
C1901/C1902与C2401的连线形式不一样，请注意甄别。
C2401包括的部分为图示蓝框的部分，C1901/1902为红框所示的部分。
C1901/1902 未配置 CAN 收发芯片，仅输出CAN_TX, CAN_RX信号。
C2401设置有 CAN 收发芯片，通过总线通讯时，需要将拨码开关1调整至 ON 接入120Ω电阻，输出CAN_H, CAN_L信号。
CAN总线配置方法
1. 挂载相关内核模块
sudo modprobe can
sudo modprobe can_raw
sudo modprobe mttcan2. 安装CAN工具进行收发操作
sudo apt-get install can-utils3. 将CAN0波特率设置成10k
sudo ip link set down can0
sudo ip link set can0 type can bitrate 10000 #每次调整波特率前都需要先关闭端口
sudo ip link set up can04. 发送数据
cansend can0 123#00.00.00.00.11.11.11.115. 接收数据
candump can0 &查看can网络情况
jetson@jetson-desktop:~$ ifconfig
can0: flags=193<UP,RUNNING,NOARP> mtu 16
unspec 00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00 txqueuelen 10 (UNSPEC)
RX packets 2 bytes 16 (16.0 B)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 0 bytes 0 (0.0 B)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
device interrupt 110 或者
jetson@jetson-desktop:~$ ip -d link show can0
9: can0: <NOARP,UP,LOWER_UP,ECHO> mtu 16 qdisc pfifo_fast state UP mode DEFAULT group default qlen 10
link/can promiscuity 0 minmtu 0 maxmtu 0
can state ERROR-PASSIVE (berr-counter tx 128 rx 0) restart-ms 0
bitrate 10000 sample-point 0.875
tq 500 prop-seg 87 phase-seg1 87 phase-seg2 25 sjw 1
mttcan: tseg1 2..255 tseg2 0..127 sjw 1..127 brp 1..511 brp-inc 1
mttcan: dtseg1 1..31 dtseg2 0..15 dsjw 1..15 dbrp 1..15 dbrp-inc 1
clock 50000000 numtxqueues 1 numrxqueues 1 gso_max_size 65536 gso_max_segs 65535 CAN 网络在协议层面有以下 3 种状态：
-
Error Active (主动错误) - [正常]
-
这是健康状态。节点可以正常收发数据，如果发现总线错误，会发送“主动错误帧”（破坏总线电平）来通知其他节点。
-
-
Error Passive (被动错误) - [警告]
-
当错误计数器（RX/TX Error Counter）超过 127 时进入此状态。
-
节点依然可以收发数据，但发送错误帧时是被动的，以此避免干扰总线上的健康节点。
-
-
Bus Off (总线关闭) - [严重]
-
当发送错误计数器超过 255 时进入此状态。
-
CAN 控制器会将自己从物理总线上断开，彻底停止收发数据。
-
在 ifconfig 的表现: 可能会看到
RUNNING标志消失，或者只是发不出包。需要重启接口 (down然后up) 或配置自动重启 (restart-ms) 才能恢复。
-
5. RTC接口
实时时钟（Real-Time Clock, RTC）是一种独立计时设备，可在系统断电或主电源关闭时持续提供精确的时间和日期信息。当开发板在离线环境下运行，并且断电后仍需保持时间同步时，就需要使用到RTC。
官方套件不支持RTC功能
载板RTC电池连接器型号为MX1.25-2P，使用电池时，请确认好极性，禁止接反电池
- 检查系统时间是否正确
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 falseJetPack 配置说明
主要介绍JetPack系统的基础功能和配置方法
JetPack 配置说明
安装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 查看内置软件信息
JetPack 配置说明
安装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.
JetPack 配置说明
C1901/1902 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.shJetPack 配置说明
自定义启动LOGO
开机时，开发板会进入UEFI引导系统启动，期间会显示NVIDIA默认的LOGO背景，如果您需要自定义该图片，需要按照一下操作获取UEFI源码替换图片内容重新编译UEFI并刷入到开发板中。
一、安装docker环境
如果已安装docker可以跳过此步骤，但要确保当前用户添加到docker 用户组
sudo apt install docker.io将当前用户添加到docker 用户组后重启生效
sudo usermod -a -G docker ${USER}
sudo reboot设置变量
export EDK2_DEV_IMAGE="ghcr.io/tianocore/containers/ubuntu-22-dev:latest"
export EDK2_USER_ARGS="-v \"${HOME}\":\"${HOME}\" -e EDK2_DOCKER_USER_HOME=\"${HOME}\""
export EDK2_BUILD_ROOT="/build"
export EDK2_BUILDROOT_ARGS="-v \"${EDK2_BUILD_ROOT}\":\"${EDK2_BUILD_ROOT}\""
alias edk2_docker="docker run -it --rm -w \"\$(pwd)\" ${EDK2_BUILDROOT_ARGS} ${EDK2_USER_ARGS} \"${EDK2_DEV_IMAGE}\""拉取并验证环境
edk2_docker echo hello
二、拉取源码
初始化edk2环境
edk2_docker init_edkrepo_conf
edk2_docker edkrepo manifest-repos add nvidia https://github.com/NVIDIA/edk2-edkrepo-manifest.git main nvidia根据JetPack版本拉取uefi源码 (以JetPack6.2.1/r36.4.4为例)
edk2_docker edkrepo clone nvidia-uefi-r36.4.4 NVIDIA-Platforms r36.4.4-updates该过程会同步多个git项目，可能耗时较长。
同步完成后可以在以下目录找到默认的LOGO文件
cd nvidia-uefi-r36.4.4/edk2-nvidia/Silicon/NVIDIA/Assets/
您可以选择直接替换掉这三个分辨率的图片，也可以在下面的配置文件中更改引用的LOGO文件路径
cd nvidia-uefi-r36.4.0/edk2-nvidia/Platform/NVIDIA/NVIDIA.fvmain.fdf.inc
应该尽可能地控制文件大小，最后的编译出的uefi_xxx.bin不得超过3.5MB，否则刷入后开发板将无法启动。
三、编译
替换完成后，执行以下命令编译UEFI固件
cd nvidia-uefi-r36.4.4/
edk2_docker edk2-nvidia/Platform/NVIDIA/Jetson/build.sh
四、替换
五、刷入
JetPack 配置说明
网卡驱动
无线网卡
在 JetPack6 以后官方移除了自带的 Intel 8625NGW 驱动，同时为了能够使用性能更优的 Intel AX200 和 AX210 网卡我们需要自行手动安装 Intel 网卡驱动包。
1. 插入网卡，通电开机，并查看网卡状态
sudo lshw -C network若显示product: Wi-Fi 6 AX200，则硬件已经检测到，若看到UNCLAIMED字样则表明驱动未安装
2. 安装 iwlwifi 驱动
iwlwifi 是英特尔（Intel）为其无线网卡开发的开源驱动程序，专为 Linux 操作系统设计，用于支持英特尔全系列无线网络适配器（如 Centrino、Wi-Fi 6/6E/7 等芯片）在 Linux 环境下的高效运行。
sudo apt update
sudo apt install backport-iwlwifi-dkms 3. 重启开发板
sudo reboot4. 再次查看网卡状态
jetson@jetson-desktop:~$ sudo lshw -C network
[sudo] password for jetson:
*-network
description: Wireless interface
product: Wi-Fi 6 AX200
vendor: Intel Corporation
physical id: 0
bus info: pci@0001:01:00.0
logical name: wlan0
version: 1a
serial: ac:12:03:a0:4c:db
width: 64 bits
clock: 33MHz
capabilities: pm msi pciexpress msix bus_master cap_list ethernet physical wireless
configuration: broadcast=yes driver=iwlwifi driverversion=5.10.216-tegra firmware=59.601f3a66.0 cc-a0-59.ucode latency=0 link=no multicast=yes wireless=IEEE 802.11
resources: irq:55 memory:20a8000000-20a8003fff
*-networkdescription 字段显示为 Wireless interface /Ethernet interface 便可正常使用无线网卡
有线网卡
JetPack自带了RTL8111的驱动，对于RTL8125(2.5G)或以上网卡需要下载官方驱动安装。
使用官方驱动时，网口指示灯可能工作不正常，如果需要修改的驱动，请与客服联系。
1、获取驱动，点击此处转跳下载
2、将驱动上传到开发板并解压打开文件夹
cd r8125-9.016.01 #注意实际版本号3、运行安装脚本
sudo bash autorun.sh4、重启后运行命令查看网卡状态
jetson@jetson-desktop:~$ sudo lshw -C network
*-network
description: Ethernet interface
product: RTL8125 2.5GbE Controller
vendor: Realtek Semiconductor Co., Ltd.
physical id: 0
bus info: pci@0007:01:00.0
logical name: eth1
version: 05
serial: 86:b1:ce:38:66:80
size: 1Gbit/s
capacity: 1Gbit/s
width: 64 bits
clock: 33MHz
capabilities: pm msi pciexpress msix vpd bus_master cap_list ethernet phy sical tp 10bt 10bt-fd 100bt 100bt-fd 1000bt-fd autonegotiation
configuration: autonegotiation=on broadcast=yes driver=r8125 driverversio n=9.016.00-NAPI duplex=full ip=10.0.0.191 latency=0 link=yes multicast=yes port= twisted pair speed=1Gbit/s
resources: irq:59 ioport:200000(size=256) memory:3228000000-322800ffff me mory:3228010000-3228013fff
*-networkJetPack 配置说明
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 git bison flex libssl-dev zip libncurses-dev make git- 创建工具链放置目录
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/* ../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
连通性测试
JetPack 配置说明
基础镜像制作
环境准备
- 安装编译依赖工具
sudo apt install build-essential bc git bison flex libssl-dev zip libncurses-dev make git创建工具链放置目录
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 #根据实际目录进行修改- 同步源码
./source_sync.sh -k -t <release-tag> #<release-tag>替换为你自己的发行版本如 jetson_36.4.3修改添加设备树和驱动
Intel无线网卡
参考 网卡说明 在开发板安装驱动后进入 /usr/lib/modules/$(uname -r)/updates提取 ko驱动，
复制到固件缓存目录 Linux_for_Tegra/rootfs/lib/modules/5.15.148-tegra/updates/ 文件夹
realtek 8125网卡
将在开发板上编译安装好的ko驱动放入 Linux_for_Tegra/rootfs/lib/modules/5.15.148-tegra/updates/dkms
烧录完成进入系统后需要运行命令使能 r8125.ko
sudo depmod -a
sudo modprobe r81254G模块
需要改动内核镜像
支持HDMI 4K
修改
tegra234-dcb-p3737-0000.dtsi替换
nvidia,dcb-image 字段，对应的HDMI-dcb二进制串可在源码的 source/hardware/nvidia/t23x/nv-public/overlay/tegra234-dcb-p3767-0000-hdmi.dts 中找到。USB设备树
修改
tegra234-p3768-0000.dtsi的 padctl@3520000 节点 添加usb3-2相关设置
padctl@3520000 {
status = "okay";
pads {
usb2 {
lanes {
usb2-0 {
nvidia,function = "xusb";
status = "okay";
};
usb2-1 {
nvidia,function = "xusb";
status = "okay";
};
usb2-2 {
nvidia,function = "xusb";
status = "okay";
};
};
};
usb3 {
lanes {
usb3-0 {
nvidia,function = "xusb";
status = "okay";
};
usb3-1 {
nvidia,function = "xusb";
status = "okay";
};
usb3-2 {
nvidia,function = "xusb";
status = "okay";
};
};
};
};
ports {
/* recovery port */
usb2-0 {
mode = "otg";
vbus-supply = <&vdd_5v0_sys>;
status = "okay";
usb-role-switch;
};
/* hub */
usb2-1 {
mode = "host";
vbus-supply = <&vdd_1v1_hub>;
status = "okay";
};
/* M.2 Key-E */
usb2-2 {
mode = "host";
vbus-supply = <&vdd_5v0_sys>;
status = "okay";
};
/* hub */
usb3-0 {
nvidia,usb2-companion = <1>;
status = "okay";
};
/* J5 */
usb3-1 {
nvidia,usb2-companion = <0>;
status = "okay";
};
usb3-2 {
nvidia,usb2-companion = <2>;
status = "okay";
};
};
};
usb@3550000 {
status = "okay";
phys = <&{/bus@0/padctl@3520000/pads/usb2/lanes/usb2-0}>,
<&{/bus@0/padctl@3520000/pads/usb3/lanes/usb3-1}>;
phy-names = "usb2-0", "usb3-0";
};
usb@3610000 {
status = "okay";
phys = <&{/bus@0/padctl@3520000/pads/usb2/lanes/usb2-0}>,
<&{/bus@0/padctl@3520000/pads/usb2/lanes/usb2-1}>,
<&{/bus@0/padctl@3520000/pads/usb2/lanes/usb2-2}>,
<&{/bus@0/padctl@3520000/pads/usb3/lanes/usb3-0}>,
<&{/bus@0/padctl@3520000/pads/usb3/lanes/usb3-1}>,
<&{/bus@0/padctl@3520000/pads/usb3/lanes/usb3-2}>;
phy-names = "usb2-0", "usb2-1", "usb2-2", "usb3-0",
"usb3-1", "usb3-2";
};编译内核、设备树和树外设备
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 ../kernel/- 构建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/* ../kernel/dtb/刷写系统命令：
- 普通模式
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 internal- 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仅刷写QSPI命令：
- 普通模式
sudo ./flash.sh -c bootloader/t186ref/cfg/flash_t234_qspi.xml --no-systemimg jetson-orin-nano-devkit nvme0n1p1- super模式
sudo ./flash.sh -c bootloader/t186ref/cfg/flash_t234_qspi.xml --no-systemimg jetson-orin-nano-devkit-super nvme0n1p1JETSON ORIN 系列AI视觉教程
本章主要Jetson特色的视觉功能使用
JETSON ORIN 系列AI视觉教程
编译安装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 系列AI视觉教程
安装使用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 ~/miniconda3/bin/activate
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 文档
3. 手动编译安装Pytorch/torchvison
某些项目可能需要指定的pytorch版本，若官方没有提供编译完成的whl文件，也可以按照下面步骤进行手动编译。
JETSON ORIN 系列AI视觉教程
通过Jetson-container使用Comfy-UI
开始本节内容前请确定您的网络环境能正常拉取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 系列大模型教程
JETSON ORIN 系列大模型教程
安装使用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