awfufu

NVIDIA Orin NX/Nano 初始化

Tue, 17 Mar 2026 00:00:00 GMT

import { Aside, Tabs, TabItem } from 'astro-pure/user'

前言

不常用的流程及指令容易遗忘，而有些流程是低频却必要的，比如新设备的初始化。本文记录 NVIDIA Orin NX/Nano 系统的安装以及初步配置流程以便查阅。

一、 WSL2配置

仅供 Windows 用户参考，原生 Ubuntu 用户可直接跳到系统安装在 ~/.wslconfig 下加入如下配置：

[wsl2]
# 刷机需要与设备处于同一物理局域网，所以使用镜像网络。
networkingMode=mirrored

# 可选：仅在开启代理软件的 TUN 模式（如 Clash/Mihomo 虚拟网卡），且导致 WSL2 镜像网络启动异常
# （例如 `ip a` 只有 `lo`）时再配置。将 TUN 网卡加入黑名单后，WSL2 仍可正常克隆物理网卡。
# 这里的 `Mihomo` 是你的 TUN 网卡名称。
ignoredNetworkAdapters=Mihomo

# 关闭自动代理，避免 WSL 内部环境变量与宿主机 TUN 路由互相干扰。
autoProxy=false

二、系统安装

2.1 GUI 安装

SDK Manager下载：NVIDIA SDK Manager 之后基本就是傻瓜式操作了，详细教程见官方文档

2.2 CLI安装

对 Jetson Orin NX / Nano 而言，NVIDIA 官方当前推荐的命令行刷机路线是 initrd flashing。依据见 Flashing Support 与 Quick Start。

2.2.1 安装前提

先下载两个官方包：BSP release package 和 sample rootfs，下载入口在 Jetson Linux 下载页。
**Orin NX / Nano 默认记 initrd flash**而不是 flash.sh。

2.2.2 环境准备

官方准备步骤如下：

# 解压 Jetson Linux BSP 包
tar xf ${L4T_RELEASE_PACKAGE}
# 将 sample rootfs 解压到 Linux_for_Tegra/rootfs
sudo tar xpf ${SAMPLE_FS_PACKAGE} -C Linux_for_Tegra/rootfs/
cd Linux_for_Tegra/
# 安装刷机依赖
sudo ./tools/l4t_flash_prerequisites.sh
# 应用 NVIDIA 提供的二进制组件
sudo ./apply_binaries.sh

这里的 ${L4T_RELEASE_PACKAGE} 和 ${SAMPLE_FS_PACKAGE} 指的就是刚下载的那两个官方包。
顺序是：先解包 rootfs，再跑前置依赖，最后 apply_binaries.sh。

2.2.3 Force Recovery Mode

对于 Jetson Orin Nano Developer Kit，Quick Start 给出的进入 Force Recovery Mode 的方式如下：

断开电源，确保开发板处于关机状态。
在 12-pin button header 上短接 REC 和 GND。
重新接上电源。

可以在主机上直接执行：

# 主机侧确认 Recovery Mode 识别结果
lsusb

如果能看到类似下面这一行，才说明板子确实进了恢复模式：

Bus 001 Device 025: ID 0955:7523 NVIDIA Corp. APX

2.2.4 命令行刷写

Quick Start 给出的 Jetson Orin Nano Developer Kit 官方示例如下：

其中：

--external-device nvme0n1p1：目标系统写入的外部介质分区。
-c tools/kernel_flash/flash_l4t_t234_nvme.xml：外部介质布局配置文件。
-p "-c bootloader/generic/cfg/flash_t234_qspi.xml"：QSPI 启动介质配置。
--showlogs：输出详细刷机日志。
--network usb0：通过 USB 虚拟网卡完成刷机过程中的网络通信。
jetson-orin-nano-devkit internal：目标板型与刷写模式参数。

--network usb0 不能漏。Flashing Support 提到，initrd flash 过程中工具会通过 IPv6 地址空间 fc00:1:1::/48 使用 NFS 和 SSH。

2.2.5 启动介质确认

第一次启动时，要在 UEFI 菜单里选对刚刷进去的启动介质。
比如刷的是 NVMe，启动项也应指向 NVMe。

2.2.6 参考资料

后面如果又忘了细节，优先翻这几个官方页面和官方论坛贴：

三、初次配网

3.1 Headless下无路由器后台权限获取Nano局域网IP

适用范围：板卡已连接工作机同一局域网，但没有显示器、没有路由器后台权限。

# 1. 查看本机 IPv4，确认当前网段（本文示例为 192.168.1.0/24）
ipconfig

# 2. 只扫描开放 22 端口的主机
nmap -p 22 --open 192.168.1.0/24

# 3. 根据扫描结果尝试 SSH，确认目标地址
ssh nvidia@192.168.1.20

其中：

nmap -p 22 --open 用于只保留开放 SSH 端口的主机，候选更少。
Nano 安装系统后 sshd 默认开启，因此可先用 22 端口做一轮筛选。
本机实测在 192.168.1.0/24 下可正常筛出 192.168.1.20，其 MAC 厂商会显示为 Nvidia。
拿到候选地址后，再用 ssh nvidia@<ip> 做最终确认。

本文写作时，本机使用 Nmap 7.98 + Npcap 1.87，nmap -sn 192.168.1.0/24 可正常执行。

3.2 配置 mDNS 访问

具体配置过程见《NVIDIA Orin 环境配置》的对应章节，这里不再重复展开。

四、SSH 扫盲

进入远程开发阶段后，SSH 基本就是你和 Orin Nano 交互的默认入口。无论是工业研发团队，还是高校计算平台，成熟做法都相当一致：以 SSH 作为默认控制面，以公钥认证作为默认鉴权手段，再用主机别名和端口转发把日常开发流程固化下来。

4.1 第一次连接

如果这台 Nano 还没配好 mDNS，就先用刚扫出来的 IP 登录：

ssh nvidia@192.168.1.20

第一次连接时，终端通常会提示你确认主机指纹，输入 yes 即可。登录成功后，建议先记住下面几条最常用的确认命令：

hostname      # 当前主机名
hostname -I   # 当前 IP
whoami        # 当前登录用户

4.2 用 `~/.ssh/config` 给设备起别名

如果每次都手动输入 ssh nvidia@192.168.x.x，很快就会烦。更实用的做法是在开发机的 ~/.ssh/config 里给每台设备起一个固定别名。

Host nrc17-via-jump
    HostName 192.168.1.20              # Nano 在内网中的地址
    User nvidia                        # Nano 登录用户
    IdentityFile ~/.ssh/id_ed25519     # 登录 Nano 使用的私钥
    IdentitiesOnly yes                 # 只使用指定私钥
    ProxyJump jump-lab                 # 先跳到 jump-lab，再转发到目标主机
    ConnectTimeout 5                   # 避免跳板链路异常时卡太久
```

其中 Host 后面的名字是你自己定义的别名。这样以后直接执行：

ssh nrc17

即可登录对应设备。
如果跳板链路不止一层，ProxyJump 也支持继续写成 jump-a,jump-b 这种链式形式。

4.3 免密登录

工程上更推荐把公钥提前配好，避免每次输密码：

# 本机生成 ed25519 密钥；如果已有 ~/.ssh/id_ed25519，可跳过
ssh-keygen -t ed25519

# 将本机公钥复制到目标设备
ssh-copy-id nrc17

# 验证免密是否生效
ssh nrc17

这一步在多机调试、频繁重连、脚本化部署时尤其省事。

4.4 常用的几种 SSH 命令

远程执行命令

# 指定私钥、连接超时和 SSH 端口；登录后在远端执行巡检命令
ssh -i ~/.ssh/id_ed25519 -o ConnectTimeout=5 -p 22 nrc17 \
  "hostname && hostname -I && systemctl is-active ssh"

常用参数：

-p：指定端口，如 ssh -p 2222 nrc17
-i：指定私钥文件，如 ssh -i ~/.ssh/id_ed25519 nrc17
-L：本地端口转发
-J：通过跳板机连接，等价于 ProxyJump
-o：临时指定配置项，如 -o ConnectTimeout=5

传文件

# 指定私钥、端口和压缩，将本机文件上传到 Nano
scp -i ~/.ssh/id_ed25519 -P 22 -C ./config.yaml nrc17:~/config.yaml

# 递归拉回远端目录
scp -i ~/.ssh/id_ed25519 -P 22 -r nrc17:~/logs ./logs

常用参数：

-P：指定端口，注意这里是大写 P
-i：指定私钥文件
-r：递归复制目录
-C：启用压缩，适合弱网环境
-o：透传 SSH 配置项，如 -o ConnectTimeout=5

端口转发

如果某个服务只监听在 Nano 本机回环地址上，可以用 ssh -L 把端口转到自己的电脑。例如 Nano 上某个 WebSocket 或 Web 服务监听在 8765 端口：

# 指定私钥与端口，只建立隧道、不打开 shell，并放到后台运行
ssh -i ~/.ssh/id_ed25519 -p 22 -N -f \
  -L 8765:localhost:8765 \
  nrc17

连上后，本机访问 localhost:8765，实际就等于访问 Nano 的 localhost:8765。
这种方式并不局限于 foxglove_bridge，在 Jupyter、TensorBoard 等交互式服务上也普遍采用同样的 SSH 隧道模式。

常用参数：

-L [本机端口]:[远端地址]:[远端端口]：本地端口转发
-N：只建立隧道，不执行远程命令
-f：放到后台运行，通常和 -N 搭配
-p：指定 SSH 端口
-J：通过跳板机建立隧道

4.5 关于 `ForwardAgent`

ForwardAgent 能让远端主机借用你本地 ssh-agent 中已经加载的密钥，在某些需要从 Nano 再访问 Git 仓库的场景里会很方便。但这一项要谨慎使用，建议只对明确受信任的主机单独开启，不要写成 Host * 的全局默认值。

Host nrc17
    HostName nrc17.local
    User nvidia
    ForwardAgent yes                   # 允许远端借用本机 ssh-agent；仅建议对受信任主机开启

如果你并不需要在 Nano 上继续跳转到别的 SSH 服务，那么这一项完全可以不配。

五、常用服务与配置文件

容易忘的。

5.1 系统层

核心服务

| 条目 | 作用 | 最小示例 | | ---------------------- | ----------------------------------------------------------------------- | ------------------------------------------ | | ssh.service | 远程登录入口。系统刷好以后，后续大多数终端操作都从它开始。 | sudo systemctl enable --now ssh | | avahi-daemon.service | 提供 .local 形式的 mDNS 主机发现，便于在局域网内用主机名访问 Nano。 | sudo systemctl enable --now avahi-daemon |

核心配置文件

| 条目 | 作用 | 最小示例 | | ------------------------------ | ------------------------------------------------------------------- | ----------------------- | | /etc/ssh/sshd_config | sshd 的主配置文件。常改的通常是认证方式、端口与登录策略。 | Port 22 | | /etc/avahi/avahi-daemon.conf | avahi-daemon 的配置文件。和 mDNS、主机名发布相关。 | publish-addresses=yes | | /etc/hostname | 机器主机名。配合 mDNS 后，常直接对应 nrc17.local 这种访问方式。 | nrc17 | | /etc/hosts | 本地静态主机名解析表。改主机名或做本地别名映射时经常一起看。 | 127.0.1.1 nrc17 |

Ubuntu 常用配置文件

| 条目 | 作用 | 最小示例 | | -------------------------------- | ------------------------------------------------------------------ | ---------------------------------------------------------------- | | /etc/apt/sources.list | apt 软件源主配置。换镜像、检查发行版源时最常看。 | deb http://ports.ubuntu.com/ubuntu-ports jammy main restricted | | /etc/apt/sources.list.d/*.list | 第三方仓库配置目录。Jetson、Docker、ROS 这类额外源通常会落在这里。 | docker.list | | /etc/netplan/*.yaml | Ubuntu 的网络配置文件。静态 IP、DNS、网卡名映射通常从这里改。 | renderer: NetworkManager | | /etc/fstab | 开机自动挂载表。挂载 NVMe 分区、数据盘或外设时常会改。 | UUID=xxxx /data ext4 defaults 0 2 | | /etc/environment | 系统级环境变量文件。需要对所有用户生效的环境变量可以写在这里。 | HTTP_PROXY=http://127.0.0.1:7890 | | ~/.bashrc | 用户级 shell 初始化文件。别名、PATH、代理变量等更常写在这里。 | export PATH=$PATH:/usr/local/bin |

自定义自启动

| 条目 | 作用 | 最小示例 | | ------------------------------- | --------------------------------------------------------------------------------------------- | -------------------------------------- | | /etc/systemd/system/*.service | 自定义 systemd 服务单元目录。后续如果要让节点、脚本或容器开机自启，通常就在这里写服务文件。 | ExecStart=/usr/bin/docker compose up |

`.service` 模板

后面如果要把脚本、节点或容器做成开机自启，通常会在 /etc/systemd/system/ 下写一个 .service 文件。最小模板如下：

[Unit]
Description=My Startup Service
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=nvidia
WorkingDirectory=/home/nvidia
ExecStart=/usr/bin/bash /home/nvidia/start.sh
Restart=always
RestartSec=3

[Install]
WantedBy=multi-user.target

其中：

After / Wants：声明启动依赖，常见是等网络起来。
User：指定以哪个用户身份运行。
WorkingDirectory：脚本或程序的工作目录。
ExecStart：真正执行的命令。
Restart / RestartSec：异常退出后的重启策略。
WantedBy=multi-user.target：表示在常规多用户启动阶段拉起。

NVIDIA Orin NX/Nano 环境配置与搭建

Fri, 13 Mar 2026 00:00:00 GMT

import { Aside } from 'astro-pure/user'

一、项目概述

本项目在 NVIDIA Jetson Orin NX/Nano 平台上部署一系列无人机上位机所需的ROS2包，下称 AADCL_UAV_UGV。为简化开发流程，并支持后续批量配置集群的需求，本项目通过容器化技术（Docker + Compose）部署，并利用 mDNS 协议简化集群组网。

二、基础环境配置

本文适用于已预装基础系统的 Jetson Orin Nano。配置前需确保开发板已联网且可通过终端（SSH、屏幕或远程桌面）访问。

前提条件：稳定的局域网环境、已知开发板 IP 以及 SSH 客户端。

首先进行网络配置。

2.1 连接 WiFi

要把 nano 连上开发/生产环境的局域网，最常用的办法是使用 nmcli 指令。

扫描附近的 WiFi：
```
nmcli device wifi list
```

连接到你的 SSID：

# 把 Your_SSID 和 Your_Password 换成实际的
sudo nmcli device wifi connect "Your_SSID" password "Your_Password"

确认连接成功：

nmcli connection show  # 看到有绿色的一行就说明连上了

2.2 抛弃静态 IP：配置 mDNS 访问

在多机协同的环境下，记住每台车/无人机的 IP 地址是非常麻烦的。我们通过配置 mDNS，让你能在局域网内直接用 nrcXX.local 这种名字访问 nano，不管它的 IP 怎么变。如上文所说，我们进入了 Orin Nano 的终端，在终端下输入如下指令：

给 nano 命名：

# 比如第 17 号机，就叫它 nrc17
sudo hostnamectl set-hostname nrc17

配置并启动服务 (Avahi)：安装 Avahi 并确保它在运行。注意：修改主机名后必须重启 Avahi 服务才能让新名字在局域网生效。
```
sudo apt update && sudo apt install -y avahi-daemon
sudo systemctl restart avahi-daemon
sudo systemctl enable avahi-daemon
```
验证一下：在你的开发机（比如笔记本）上执行 ping nrc17.local。如果能通，以后你只需要记住这个名字就行了。

2.3 生产环境对齐：基于 SSH 的 Headless 开发

在无人机集群开发中，给每台 Orin Nano 配备显示器是不现实的。更核心的原因在于：运行图形界面 (GUI) 会消耗昂贵的 CPU/GPU 资源，在 Orin Nano 这种算力受限的平台上，每一分资源都应该留给 ROS 管道和 AI 推理。

因此，建议采用 Headless 开发模式：

性能最大化：关闭桌面环境可节省数百 MB 显存及 CPU 周期。
环境一致性：开发环境与最终飞行场景完全一致，避免图形驱动导致的性能抖动。
远程可视化：通过 foxglove_bridge 等工具建立 WebSocket 通道，将原始数据流高效转发到你的电脑桌面上，使用 Foxglove Studio 进行低延迟的可视化调试。

配置你的开发机 (推荐)：为了不用每次都输 IP 甚至不用输密码，建议在你的电脑（Linux/Mac/Win）的 ~/.ssh/config 中加入如下配置：
```
Host nrc17
    HostName nrc17.local
    User nvidia
```
这样便相当于用 ssh nrc17 代替了 ssh nvidia@192.168.1.17。

免密登录 (可选)：在你的开发机终端执行：

ssh-keygen -t ed25519  # 生成你的密钥（如果已经有了就跳过）
ssh-copy-id nrc17      # 把你的公钥“递给”nano

完成后，ssh nrc17 便可直连（这在 vibe coding 时非常实用）。

2.4 容器环境：Docker 与 NVIDIA Toolkit

为了不把 nano 的原始系统环境搞乱，建议全量使用容器。除了 Docker，最关键的是要安装 NVIDIA 的转发工具（Toolkit），这样容器里的算法才能用到 Orin 的 GPU 算力。

安装 Docker 引擎与 Compose V2 插件：由于 Ubuntu 22.04 的官方源不含 Compose V2 (即 docker compose 指令)，我们需要添加 Docker 官方软件源：

# 1. 安装基础依赖
sudo apt-get update
sudo apt-get install -y ca-certificates curl gnupg

# 2. 添加 Docker 官方 GPG 密钥 (使用 .asc 格式最稳妥，避免转换报错)
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# 3. 添加 Docker 软件源列表
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 4. 更新并安装 V2 插件
sudo apt-get update
sudo apt-get install -y docker-compose-plugin

# 5. 权限补丁：将当前用户加入 docker 组
sudo usermod -aG docker $USER
# 注意：执行后需重新登录，或输入 `newgrp docker` 立即生效

配置 NVIDIA 软件源并安装 Toolkit：由于 Ubuntu 官方源不含此工具，必须手动添加 NVIDIA 的仓库：

# 账户预检
sudo apt-get update && sudo apt-get install -y curl

# 1. 导入 GPG 密钥（如果文件已存在，执行此指令会自动覆盖）
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor --yes -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg

# 2. 添加软件源列表
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

# 3. 更新并安装
sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit

# 4. 重启 Docker 生效
sudo systemctl restart docker

三、获取源码：克隆仓库

3.1 选择访问方式

本项目仓库位于 gitfub.cv，支持以下两种访问方式：

生产环境（推荐）：由于本仓库已设置为公开，在内地环境可直接裸连 HTTPS 地址进行克隆，无需登录，也无需配置 SSH Key。
开发环境：如果你需要向仓库提交代码，建议配置 SSH Key 以获得推送权限。

3.2 生产环境：快速克隆（HTTPS）

直接执行以下指令进行全量同步：

cd ~
# 1. 克隆主架构 (仓库公开，内地直接访问)
git clone https://gitfub.cv/iodinot/AADCL_UAV_UGV.git
cd AADCL_UAV_UGV

# 2. 关键：拉取所有依赖的算法源码和硬件驱动
git submodule update --init --recursive

# 3. 补丁：修正 livox_ros_driver2 的 package.xml
[ -f src/drivers/livox_ros_driver2/package_ROS2.xml ] && cp src/drivers/livox_ros_driver2/package_ROS2.xml src/drivers/livox_ros_driver2/package.xml

如果是生产环境，下一步可直接跳到五、容器配置、编排与启动。

3.3 开发环境：SSH 配置（仅需提交代码时执行）

如果你需要提交代码，请按以下步骤配置 Gitea 访问权限：

生成密钥对：ssh-keygen -t ed25519 -C "your_email"
添加公钥：复制 ~/.ssh/id_ed25519.pub 内容，前往 Gitea SSH 设置添加。
克隆地址：使用 git@gitfub.cv:iodinot/AADCL_UAV_UGV.git。

四、 AADCL_UAV_UGV 目录结构

代码按照“单一职责”原则划分为五个顶级目录：

~/AADCL_UAV_UGV
├── .env                # 机器硬件配置 (单一事实来源)
├── config/             # 算法逻辑配置 (*.yaml)
├── src/
│   ├── main/           # 系统编排层 (TF/Launch)
│   ├── drivers/        # L1 硬件驱动层
│   ├── core/           # L2 核心感知层
│   ├── apps/           # L3 业务应用层
│   └── sim/            # 仿真工具层
├── compose.yaml        # 多容器编排声明
└── README.md

此目录结构采用Scheme C的架构标准。对于开发环境，此目录包含必要的也就是可能进行二次开发的代码的源码；对于生产环境，此目录包含必要的配置文件。

五、容器配置、编排与启动

先进入刚刚 pull 下来的代码目录（其目录结构见四、 AADCL_UAV_UGV 目录结构）。

cd ~/AADCL_UAV_UGV

此时并不能直接起 docker 容器，还需要编辑配置文件，我们采用 SSOT (单一事实来源) 原则，通过 .env 文件来管理机器之间的差异。

5.1 设备配置文件 (.env)

仓库里已经包含了一个 .env.example 模板。它规定了这台车需要哪些硬件参数。

复制模板：
```
cp .env.example .env
```
参数配置：编辑 .env。由于无人机的外设配置例如飞控串口路径（比如 MAVLink 用的 /dev/ttyTHS1）和系统 ID 不确定，需要结合实际情况进行修改。

5.2 离线数据集安装 (MAVROS 必备)

MAVROS 在启动时需要特殊的地理坐标数据集（Geoids）。如果在启动日志里看到 GeographicLib exception 报错，请执行以下指令进行一键安装：

mkdir -p ~/AADCL_UAV_UGV/data/geographiclib
# 启动一个临时容器进行下载（约 100MB）
docker run --rm -v ~/AADCL_UAV_UGV/data/geographiclib:/usr/share/GeographicLib robot_stack_base:humble /opt/ros/humble/lib/mavros/install_geographiclib_datasets.sh

5.3 初次启动系统

本项目使用 Docker V2（docker compose）进行一键编排。

对于新机器，我们提供两种部署方案：方案 A（本地构建） 适用于需要深度定制底层依赖的场景；方案 B（云端拉取） 适用于追求一键快速部署的情况。

方案 A：本地手动构建 (初次耗时 30-50 分钟)

这一步会从头安装 ROS2 Humble、PCL、OpenCV 等数 GB 的依赖。

docker compose build l1-hardware

方案 B：从 Gitea 容器仓库拉取

如果你已熟悉编译流程或只想进行快速部署，直接执行以下指令即可跳过漫长的编译过程（该仓库为公开，内地裸连且无需登录）：

# 1. 拉取镜像
docker pull gitfub.cv/iodinot/aadcl_uav_ugv/base:latest
docker pull gitfub.cv/iodinot/aadcl_uav_ugv/l3_planner:latest
docker pull gitfub.cv/iodinot/aadcl_uav_ugv/l3_yolo:latest

# 2. 关联标签 (让 compose 能识别)
docker tag gitfub.cv/iodinot/aadcl_uav_ugv/base:latest robot_stack_base:humble
docker tag gitfub.cv/iodinot/aadcl_uav_ugv/l3_planner:latest l3_planner:humble
docker tag gitfub.cv/iodinot/aadcl_uav_ugv/l3_yolo:latest l3_yolo:humble

启动全量系统

镜像就绪后（无论通过 A 还是 B），执行：

docker compose up -d

启动视觉模块：如果你需要跑 YOLO 目标检测。
```
docker compose --profile apps up -d l3-yolo-demo
```
启动监控桥接：为了用 Foxglove 远程看数据。
```
docker compose --profile viz up -d visualization-bridge
```

5.4 `ros2c` 脚本的配置

Docker 的环境隔离虽然安全，但调试很不方便：每次查看节点都要用 docker exec 进入容器。为此，本项目提供了一个增强版 ros2c (ROS2 in Container) 脚本，支持 自动容器探测，实现透明化的容器操作体验。

请在 宿主机（Nano 终端） 直接执行以下“一键安装”指令：

curl -sSL https://gitfub.cv/iodinot/AADCL_UAV_UGV/raw/branch/main/scripts/install_ros2c.sh | bash

其核心功能及实现方案如下：

自动容器感知：脚本会自动检测 l1_hardware、l2_capability 或 l3 系列正在运行的容器，并将其作为当前执行目标，人员无需关心具体容器 ID。
环境全自动注入：每次执行均会自动在容器内 source ROS2 Humble 原生路径及项目自身的 install/setup.bash，彻底解决“找不到消息类型”或“找不到节点”的问题。
TTY 鲁棒性：智能判断当前终端是否为交互式，自动处理 -it 参数，使其无缝支持 SSH 脚本控制、自动流水线调用及手动调试。
极简指令入口：将复杂的 docker exec -it ... bash -lc \"...\" 包装为极简的 ros2c [command]，使开发者在操作容器时获得与原生 ROS 环境一致的操作体验。

Tab 补全：你可以输入 ros2c -c [Tab][Tab]，系统会自动联想出当前正在运行的容器名称。
指定容器：如果你想针对特定容器执行指令，可以使用 -c 参数，例如：
```
ros2c -c l3_yolo_demo node list
```
默认逻辑：若不带 -c，脚本会按 l1 -> l2 -> l3 的优先级自动寻找第一个活跃容器执行。

常用指令：

ros2c node list           # 列出所有节点
ros2c topic list          # 列出所有话题
ros2c                     # 不带参数：直接进入默认容器的 Shell

六、集群部署

当你有了一台完整配置好的机型（如 nrc17），为同型号的新机器（如 nrc18）配置环境时，无需再重复耗时的编译过程。

6.1 方案 A：通过容器注册表同步 (推荐)

这是最标准且高效的方法。只需在新机器上重复 5.3 节中的方案 B 即可：

拉取镜像：docker pull gitfub.cv/iodinot/aadcl_uav_ugv/base:latest ...
打标签：docker tag ... robot_stack_base:humble ...
启动：docker compose up -d。

由于 Gitea 仓库是公开的且内地直连极速，这种方式比拷贝文件更可靠。

6.2 方案 B：离线镜像迁移 (离线/无网络场景)

如果在无法连接注册表的情况下，可使用 Docker 的导出功能进行物理迁移：

在“母机”导出：

docker save robot_stack_base:humble | gzip > ~/AADCL_UAV_UGV_base.tar.gz

拷贝至新机：

scp ~/AADCL_UAV_UGV_base.tar.gz nvidia@nrc18.local:~

在新机导入：

docker load < ~/AADCL_UAV_UGV_base.tar.gz

七、系统功能验证

程序跑起来后，需确认各项模块是否正常运行。以下提供三项关键验证指标：

节点全不全？：执行 ros2c node list，你应该能看到 mavros、fast_lio 和 ego_planner 等一众核心节点都在线。
定位有输出吗？：执行 ros2 topic echo /Odometry。如果屏幕上数据在跳，说明算法已经闭环并在解算定位。
视觉有反应吗？：如果启动了 YOLO，执行 ros2 topic echo /yolo/detections。如果有人或物体出现在镜头里，你会看到识别结果。

附录：硬件网口配置（优化高频点云传输稳定性）

Livox MID360 雷达的数据量较大，若直接在默认网口传输，高频点云包可能会干扰 WiFi 或 SSH 链路的稳定性。建议将雷达绑定至独立的物理网口：

看看雷达插在哪个口了：

nmcli device  # 找一下那个显示“以太网”连接的口，比如叫 enP8p1s0

给这个口设个固定 IP：注意：雷达不需要网关，我们只要在这个口上配置 192.168.10.x 网段就行。

# 假设网口名是 enP8p1s0，给 nano 分配 192.168.10.50
sudo nmcli connection add type ethernet con-name lidar-link ifname enP8p1s0 ipv4.method manual ipv4.addresses 192.168.10.50/24
sudo nmcli connection up lidar-link

查一下生效没：执行 ip addr show enP8p1s0，看到 192.168.10.50 就说明搞定了。

CSS Flex 布局

Mon, 24 Nov 2025 20:00:00 GMT

flex 布局

块级元素和行内元素

块级元素：独占一行（前后会自动换行），自动填满父容器的宽度。它们的 display 属性为 block。行内元素：与其他行内元素排在一行内，宽高由内容决定。它们的 display 属性为 inline。

大部分 html 元素都是块级元素或行内元素。

下面是一个例子，一个 container 中装了 3 个 item。

<div class="container">
  <div class="item">1</div>
  <div class="item">2</div>
  <div class="item">3</div>
</div>

这里的 item 都是块级元素，它们都独占一行，自上而下排列。

为了方便展示，示例中的 container 容器使用红色边框，其中的 item 项目使用蓝色方块。

flex 容器和 flex 元素

在容器元素的 CSS 中添加 display: flex，它就会变为 flex 容器。

flex 容器的直接子项目都是 flex 元素。

.container {
  display: flex;
}

可以看到，flex 容器中的 item 项目会自动排列在一行内。

flex 容器的主轴

flex 布局的主轴默认为水平方向，主轴方向由 flex-direction 属性控制，默认为 row。

.container {
  display: flex;
  flex-direction: row;
}

如果将主轴方向 flex-direction 设为 row-reverse（翻转），那么元素则会反方向排列。

.container {
  display: flex;
  flex-direction: row-reverse;
}

沿轴线方向对齐

沿主轴对齐

flex 容器内的元素会沿着主轴方向排列，在 flex 容器上使用 justify-content 属性可以控制容器内元素在主轴上的位置。justify-content 有以下几个常用的取值。

start：对齐主轴起点，这是默认行为。

.container {
  display: flex;
  justify-content: start;
}

end：对齐主轴终点。

.container {
  display: flex;
  justify-content: end;
}

center：在主轴上居中。

.container {
  display: flex;
  justify-content: center;
}

space-between：均匀分配每个 item 的间隙（item 之间）。

.container {
  display: flex;
  justify-content: space-between;
}

两侧不留间隙，只在 item 之间均匀分配。

space-around：均匀分配每个 item 两侧的空间（周围）。

.container {
  display: flex;
  justify-content: space-around;
}

item 之间的间隙是侧边的两倍。

space-evenly：均匀分配每个 item 的间隙（包括侧边的）。

.container {
  display: flex;
  justify-content: space-evenly;
}

两侧留出间隙，所有间隙都均匀分配。

gap：手动设置间隙

手动指定 flex 元素之间的间隙。

.container {
  display: flex;
  gap: 20px;
}

沿交叉轴对齐

交叉轴垂直于主轴，使用 align-items 属性可以调整元素在交叉轴上的对齐方式。

为了方便展示纵向对齐，这里增加了容器边框的高度。

对齐交叉轴起点

align-items 的默认值也是 start。

.container {
  display: flex;
  align-items: start;
}

对齐交叉轴终点

.container {
  display: flex;
  align-items: end;
}

居中对齐

.container {
  display: flex;
  align-items: center;
}

同时使用 justify-content: center 和 align-items: center，可以轻松让元素水平垂直居中。

.container {
  display: flex;
  justify-content: center;
  align-items: center;
}

旋转主轴方向

设置 flex-direction 为 column，可以将主轴方向设为纵向，交叉轴方向同时变为横向。

.container {
  display: flex;
  flex-direction: column;
}

由于现在的交叉轴是横向的，所以此时要让元素水平居中，应该调整 align-content 而不是 justify-content。

.container {
  display: flex;
  flex-direction: column;
  align-items: center;
}

而 justify-content 现在调整的是纵向的主轴，即垂直方向的对齐方式。

.container {
  display: flex;
  flex-direction: column;
  justify-content: center;
}

多行布局

flex 自动换行

给 flex 容器使用 flex-wrap 属性，可以控制 flex 元素是否自动换行。

flex-wrap 的默认值为 nowrap，当容器空间不足（比如手机屏幕，横向空间较小）时，会压扁（收缩）其中的元素。如果元素无法被压缩，会直接溢出容器。

.container {
  display: flex;
  gap: 40px;
  flex-wrap: nowrap;
}

如果你正在使用电脑浏览这个页面，你可以试试拖动浏览器窗口右侧，改变页面宽度，观察下面的元素会发生什么。

将 flex-wrap 设为 wrap，元素会自动在空间不足时换行。

.container {
  display: flex;
  flex-wrap: wrap;
  gap: 40px;
  max-width: 400px; /* 限制宽度方便展示换行 */
}

多行布局下的对齐方式

就像主轴上有 justify-content 属性一样，交叉轴上也有 align-content属性，它可以控制交叉轴上整体的对齐方式。

现在有以下示例，在一个 flex 容器中装了 9 个元素，让它们自动换行，现在不使用 gap。

.container {
  display: flex;
  flex-wrap: wrap;
  max-width: 320px;
  height:450px;
}

align-content 默认为 stretch，所以可以发现即使不使用 gap，元素在垂直方向上依然有间隙。

align-content 同样也有 start、end 和 center 取值，让元素整体在交叉轴上对齐。比如，下面使用 align-content: center 让元素在交叉轴上居中对齐。

.container {
  /* ... */
  align-content: center;
}

前面说过，align-items 也是用来调整交叉轴上的对齐方式的，那么它和 align-content 的区别是什么呢？

尝试用 align-items 替代 align-content：

.container {
  /* ... */
  align-items: center;
}

.container {
  /* ... */
  align-items: end;
}

.container {
  /* ... */
  align-items: start;
}

结合上面三个例子不难看出，align-items 控制的 start、end 和 center 让元素对齐了它们各自的交叉轴。

其实在 wrap 自动换行后，每一行（如果设置了纵向主轴则是列）元素都有它们自己独立的主轴和交叉轴。此时 align-items 调整的是各行元素在自身的交叉轴上的对齐方式，而 align-content 调整的是多行元素整体在交叉轴上的对齐方式。

所以，如果要将元素完全居中对齐，我们应该在 flex 容器上设置以下三个 center 值：

.container {
  /* ... */
  justify-content: center;
  align-items: center;
  align-content: center;

  /* 这里适当添加 gap，看起来更美观 */
  gap: 10px;
}

拉伸和收缩元素

自动拉伸

如果想要让元素自动拉伸以填满容器的剩余空间，可以使用 flex-grow 属性。

flex-grow 的默认值为 0，即禁用自动拉伸。

.item {
  flex-grow: 0;
}

当 flex-grow 设为 1 时，元素将会自动拉伸以填满容器空间。注意 flex-grow 属性是加在 item 元素身上的，而不是 flex 容器上。

.item {
  flex-grow: 1;
}

也可以指定拉伸其中某个元素，其他不拉伸，比如只在第二个元素上添加 flex-grow: 1。

.item {
  flex-grow: 0;
}

#item-2 {
  flex-grow: 1;
}

自动收缩

flex 容器中的元素在空间不足时会自动收缩，自动收缩由 flex-shrink 属性控制，其默认值为 1，即：

.item {
  flex-shrink: 1;
}

注意 flex-shrink 属性是加在元素身上的，而不是 flex 容器上。

如果要禁用自动压缩，可以设置 flex-shrink: 0。

.item {
  flex-shrink: 0;
}

按比例拉伸或收缩

在同时存在多个 item 时，flex-grow 和 flex-shrink 的数值是有意义的，通过给它们设置不同的值，可以实现按比例拉伸或收缩。

<div class="container">
  <div class="item" style="flex-grow:1;">1</div>
  <div class="item" style="flex-grow:3;">2</div>
  <div class="item" style="flex-grow:5;">3</div>
</div>

这样每个元素被拉伸的空间比例为 1:3:5。注意：这并不是说元素占用的空间是 1:3:5，而是它们被拉伸的空间是按这个比例分配的。

按比例收缩同理，数值越大被压缩的越多。

<div class="container">
  <div class="item" style="flex-shrink:1;">1</div>
  <div class="item" style="flex-shrink:3;">2</div>
  <div class="item" style="flex-shrink:5;">3</div>
</div>

C指针和结构体

Sat, 11 Jun 2022 21:01:00 GMT

:::tip 阅读本文之前，读者应该拥有至少一门其他的编程语言基础，了解少许的 Linux 命令。 :::

import { Card } from 'astro-pure/user'

C语言快速入门

指针类型

什么是指针

指针是 C 语言的精髓，指针也是一种变量，可以存储变量在内存中的地址。

&: 取地址运算符
*: 寻址运算符（解引用）

#include <stdio.h>

int main() {
  int var = 20;
  int* p = &var; // * 表示这是一个 int 类型的指针，将 var 的地址赋值给 p

  printf("&var: %p\n", &var); // %p 打印地址
  // &var: 0x7ffe56d638dc
  printf("p: %p\n", p);
  // p: 0x7ffe56d638dc
  printf("*p: %d\n", *p);
  // *p: 20

  return 0;
}

这里的指针变量 p 存储了 var 变量所在的内存块的地址。使用 *p 可以从这个地址访问 var，并获取 var 的值。

import PointerDiagram from './PointerDiagram.astro';

通过指针，我们可以直接访问和操作内存，这使得 C 语言非常强大且高效，但也需要小心使用以避免错误（如空指针、野指针）。

空指针和野指针

字面意思，空指针就是指向空地址（地址为零）的指针；野指针就是指向无意义地址或非法地址的指针。

在 stddef.h 头文件中，定义了 NULL，它可以用来表示空指针。

#define NULL ((void *)0)

int* p1 = NULL; // 空指针：指向0
int* p2;        // 野指针：未初始化，内容随机

这种指针要小心使用，一旦对它们进行解引用操作，就会导致未定义行为。比如访问 *p1 时，程序会尝试访问零地址处的内存，这通常会导致程序崩溃。

#include <stdio.h>

int main() {
  int* p = NULL;
  printf("%d\n", *p); // segmentation fault // [!code error]
  return 0;
}

在访问指针之前，必须小心谨慎，确保指针被正确地初始化了且不为空。

#include <stdio.h>

int main() {
  int a = 10;
  int* p = &a;

  if (!p) { // [!code ++]
    printf("p is null!\n"); // [!code ++]
    return 1; // [!code ++]
  } // [!code ++]

  printf("%d\n", *p);
  return 0;
}

指针的大小

指针本身也是个变量，所以它也需要占用内存空间来存储。在 32 位（bit）系统上，指针的大小是 4 字节，在 64 位系统上则是 8 字节。这里的“位”指的是地址总线的位数，现代机器通常是 64 位。

在 64 位机器上，可以给 gcc 命令添加 -m32 参数来生成 32 位的可执行文件进行测试。

#include <stdio.h>

int main() {
  int* p = NULL;
  printf("sizeof(p): %zu\n", sizeof(p));
  return 0;
}

在 32 位系统上：

gcc main.c -m32 -o main
./main                 
# sizeof(p): 4

在 64 位系统上：

gcc main.c -m64 -o main
./main                  
# sizeof(p): 8

指针的作用

在函数内部定义的变量称为局部变量。它们通常存储在栈（Stack）上，其生命周期仅限于函数执行期间。当函数执行完后，这些变量会被销毁，内存会被回收。

#include <stdio.h>

void foo(int x) {
  x = 100; // 修改数值 // [!code hl]
  printf("foo: x = %d\n", x);
}

int main() {
  int x = 10;
  foo(x);
  printf("main: x = %d\n", x);
  return 0;
}

// Output:
// foo: x = 100
// main: x = 10

因为 C 语言是按值传递（Pass by Value）的，直接传递变量只会拷贝一份副本。如果想在函数内部修改函数外部定义的变量，则需要传递变量的地址（指针），这样函数就可以通过地址直接操作原始数据。

#include <stdio.h>

// 交换两个整数的值 使用指针
void swap(int* a, int* b) {
  int temp = *a;
  *a = *b;
  *b = temp;
}

int main() {
  int x = 5, y = 10;

  printf("Before: x = %d, y = %d\n", x, y);
  swap(&x, &y); // 传递地址 // [!code hl]
  printf("After:  x = %d, y = %d\n", x, y);

  return 0;
}

数组和指针

数组名即指针

数组名在大多数表达式中会“退化”为指向数组第一个元素的指针。

int arr[5] = {10, 20, 30, 40, 50};
int* p = arr; // = &arr[0]

printf("p:       %p\n", p);
printf("arr:     %p\n", arr);
printf("&arr[0]: %p\n", &arr[0]);

// Output:
// p:       0x7ffe56d638dc
// arr:     0x7ffe56d638dc
// &arr[0]: 0x7ffe56d638dc

在上面的示例中，p 的值等于 arr 的值等于 &arr[0] 的值。

printf("arr[0] = %d\n", arr[0]);
printf("*p     = %d\n", *p);

// Output:
// arr[0] = 10
// *p     = 10

arr[0] 和 *p 都可以访问数组的第一个元素。

指针的运算

指针可以进行加减运算，加法运算会将指针移动到下一个元素的位置，减法运算会将指针移动到前一个元素的位置。

printf("arr[1]   = %d\n", arr[1]);
printf("*(p + 1) = %d\n", *(p + 1));
printf("p[1]     = %d\n", p[1]);

// Output:
// arr[1]   = 20
// *(p + 1) = 20
// p[1]     = 20

对 int 类型的指针 p 执行 p + 1 会将指针移动到下一个 int 的位置。指针 p 也可以当作一个 int 数组进行下标访问，这里的 p[1] 等价于 *(p + 1)。

你可以尝试不同类型的指针，比如 char*，你会发现指针移动的步长是 1。

char arr[] = {'a', 'b', 'c', 'd', 'e'};
char* p = arr;

printf("p: %p\n", p);
printf("p + 1: %p\n", p + 1);
printf("p - 1: %p\n", p - 1);

字符串

之前说过，字符串实际上就是字符数组，并且以空字符 \0 结尾。

char str[] = "hello"; 
char* p = str;

printf("str: %s, p: %s\n", str, p);
// str: hello, p: hello

p[0] = 'H';
printf("str: %s, p: %s\n", str, p);
// str: Hello, p: Hello

操作字符串

C 标准库提供了一些用于操作字符串的函数，这些函数都定义在 string.h 头文件中。

#include <stdio.h>
#include <string.h>

int main() {
  char str1[10] = "hello";
  char str2[10];

  printf("strlen(str1): %zu\n", strlen(str1));
  strcpy(str2, str1);
  printf("str2: %s\n", str2);

  return 0;
}

使用指针，我们可以高效地实现 strcpy 函数。

char* strcpy(char* dest, const char* src) {
  char* p = dest;
  while (*dest++ = *src++);
  return p;
}

你可以通过 string.h 文档学习更多接口。

函数指针

函数名即指针

就像数组名是数组第一个元素地址的指针一样，函数名也是指向函数地址的指针。我们可以定义一个指针变量来存储函数的地址，这就是函数指针。

#include <stdio.h>

void say_hello() {
  printf("Hello World!\n");
}

int add(int a, int b) {
  return a + b;
}

int main() {
  // 定义指向 say_hello 的指针
  void (*func_ptr)(); // [!code hl]
  func_ptr = say_hello;
  
  // 通过指针调用函数
  func_ptr(); // 或 (*func_ptr)(); // [!code hl]

  // 定义指向 add 的指针
  int (*add_ptr)(int, int) = add;
  printf("2 + 3 = %d\n", add_ptr(2, 3));
  return 0;
}

回调函数

不像其他高级语言，C 语言没有类似 lambda 表达式或闭包的语法糖，但是我们可以通过函数指针来实现类似的功能。

函数指针的一个主要用途是实现回调函数（Callback Function）。回调函数是指将一个函数指针作为参数传递给另一个函数，由另一个函数在适当的时候调用这个函数。

#include <stdio.h>

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }

// 接受函数指针作为参数
void compute(int (*op)(int, int), int a, int b) {
  int result = op(a, b);
  printf("Result: %d\n", result);
}

int main() {
  compute(add, 10, 5); // Result: 15
  compute(sub, 10, 5); // Result: 5
  return 0;
}

C 语言标准库中的 qsort 就是一个典型的例子，它允许用户自定义比较逻辑。

#include <stdio.h>
#include <stdlib.h>

int compare(const void* a, const void* b) {
  return (*(int*)a - *(int*)b);
}

int main() {
  int arr[] = {5, 2, 9, 1, 5, 6};
  int size = sizeof(arr) / sizeof(arr[0]);

  qsort(arr, size, sizeof(int), compare); // [!code hl]

  for (int i = 0; i < size; i++) {
    printf("%d ", arr[i]);
  }
  printf("\n");
  
  return 0;
}

结构体

结构体类型

结构体（Structure）是 C 语言中一种用户自定义的数据类型，允许将不同类型的数据组合成一个单一的类型。

#include <stdio.h>
#include <string.h>

// 定义一个结构体类型
struct Person {
  char   name[50];
  int    age;
  double height;
};

int main() {
  // 声明一个结构体变量
  struct Person person;

  // 访问和修改成员并赋值
  strcpy(person.name, "Alice"); // 注意：字符串赋值不能直接使用 =，需要使用 strcpy
  person.age = 20;
  person.height = 1.65;

  printf("Name: %s, Age: %d, Height: %.2f\n", person.name, person.age, person.height);
  return 0;
}

结构体指针

当我们将结构体的地址传递给指针时，如果我们想通过指针访问结构体的成员，可以使用 -> 运算符。

通常情况下，解引用指针并访问成员的语法是 (*p).member，但这写起来比较麻烦（因为 . 的优先级高于 *，必须加括号）。C 语言提供了一个简写方式：p->member。

#include <stdio.h>
#include <string.h>

struct Person {
  char   name[50];
  int    age;
};

int main() {
  struct Person person;
  struct Person* p = &person;

  // 使用指针访问成员
  strcpy(p->name, "Bob"); // 等价于 (*p).name
  p->age = 30;            // 等价于 (*p).age

  printf("Name: %s, Age: %d\n", p->name, p->age);
  return 0;
}

结构体的大小

结构体的大小并不总是其所有成员大小之和，因为编译器为了提高 CPU 访问内存的效率，会对结构体成员进行“内存对齐”（Memory Alignment）。

对齐规则：每个成员的偏移量（Offset）必须是该成员大小的整数倍（或者是编译器默认对齐数的较小值）。结构体的总大小必须是其内部最大成员（基本类型）大小的整数倍。如果不足，会在末尾填充字节。

让我们详细分析一下 struct Pack 的内存布局：

struct Pack {
  char c;   // 1 byte
  int i;    // 4 bytes
};

成员 c (char) 占用 1 字节。放置在偏移量 0 处。
成员 i (int) 占用 4 字节。根据对齐规则，它的起始地址必须是 4 的倍数。当前的偏移量是 1（c 之后），不是 4 的倍数。
编译器会在 c 后面插入 3 个字节的填充（Padding），使偏移量变为 4。
i 从偏移量 4 开始存储，占用第 4-7 字节。
此时结构体总大小为 8 字节。8 是最大成员大小 (4) 的整数倍，符合整体对齐规则。

最终的内存布局：

import StructMemoryLayout from './StructMemoryLayout.astro';

#include <stdio.h>

int main() {
  printf("sizeof(struct Pack) = %zu\n", sizeof(struct Pack));
  // Output: sizeof(struct Pack) = 8
  return 0;
}

因此，在计算结构体大小时，务必使用 sizeof 运算符，而不要简单地将成员大小相加。有时通过调整成员的定义顺序（例如将所有 char 放在一起），可以减少填充字节，从而减小结构体的大小。

自定义类型

在 C 语言中，可以使用 typedef 关键字来定义自定义类型。

#include <stdio.h>

typedef int MyInt; // [!code hl]

int main() {
  MyInt a = 10;
  printf("a = %d\n", a);
  return 0;
}

同样的，可以把一个复杂类型定义为自定义类型。

#include <stdio.h>

typedef struct Point { // [!code hl]
  int x; // [!code hl]
  int y; // [!code hl]
} Point; // [!code hl]

int main() {
  Point p; // [!code hl]
  p.x = 10;
  p.y = 20;
  printf("p.x = %d, p.y = %d\n", p.x, p.y);
  return 0;
}

C语言快速入门

Fri, 10 Jun 2022 21:00:00 GMT

:::tip 阅读本文之前，读者应该拥有至少一门其他的编程语言基础，了解少许的 Linux 命令。 :::

开发环境

任意文本编辑器以及 C 编译器。本文选择 gcc 在 Linux 上开发和调试。

安装 gcc

使用包管理器安装 gcc。某些发行版可能已经自带 gcc。

import { Tabs, TabItem } from 'astro-pure/user';

# Redhat / CentOS / Fedora
sudo dnf install gcc

# Arch Linux / Manjaro
sudo pacman -S gcc
```

文本编辑器

你可以使用任意文本编辑器，推荐 VSCode。

Hello World

创建 main.c 文件并编辑。

#include <stdio.h>

int main() {
  printf("Hello, World!\n");
  return 0;
}

编译代码，运行程序。

gcc main.c -o main
./main
# Hello, World!

include 预处理指令

在 C 语言中，以 # 开头的行是预处理器指令。#include <stdio.h> 告诉编译器：在编译之前先包含标准输入输出库（Standard Input Output）的信息，这样我们就可以使用 printf 等函数。

main 函数

main 函数是程序的入口点。C 程序执行时，从这里开始。

int main() {
  // 代码逻辑
  return 0; // 程序结束，返回 0 表示成功
}

基本类型

变量和类型

变量是用于存储数据的容器，C 语言以以下的方式定义或声明变量。

int a = 10; // 定义并初始化为 10
int b;      // 声明但不初始化，仅分配一块内存

常见的变量类型有：

int: 整数，如 10, -5，现代计算机上通常为 32 位
float: 单精度浮点数，例如 3.14
double: 双精度浮点数，精度更高
char: 单个字符，例如 'A', 'z'

float 和 double 的区别在于精度，float 通常为 32 位，double 通常为 64 位。其二进制存储方式遵循 IEEE 754 标准，你可以在IEEE 754 Visualizer直观地了解其存储原理。

#include <stdio.h>

int main() {
  int a = 10;
  double b = 3.14159;
  char c = 'A';

  // %d 格式化打印整数，%f 格式化打印浮点数，%c 格式化打印字符
  printf("a = %d, b = %f, c = %c\n", a, b, c);
  // a = 10, b = 3.141590, c = A
  return 0;
}

更多基本类型信息可以参考 C 标准。

数组和字符串

数组是存储多个相同类型数据的容器。C 语言中没有专门的字符串类型，而是使用字符数组。数组下标从 0 开始。

#include <stdio.h>

int main() {
  int arr[5] = {1, 2, 3, 4, 5};
  char str[] = "Hello";

  printf("arr[2] = %d, str = %s\n", arr[2], str);
  // arr[2] = 3, str = Hello
  return 0;
}

C 语言规定字符串必须以空字符 \0（数值为零的字符）结尾。不像其他高级语言对字符串的封装，C 语言中的字符串只是一个 char[] 数组，程序并不能直接得到数组的长度（之后会提到为什么），因此通过遍历字符直到 \0 来确定字符串在哪里结束。

在定义 char str[] = "Hello"; 时，C 语言会自动在字符串末尾添加 \0，因此虽然只有 5 个字符，但 str 的长度为 6。

printf("%zu\n", sizeof(str));
// 6

如果字符串不以 \0 结尾，程序可能无法正确识别字符串的结束位置，继续连续遍历其后内存，导致未定义行为。

逻辑控制

条件分支

if ... else 根据条件执行不同的代码块。

int num = 10;
if (num > 0) {
  printf("正数\n");
} else if (num < 0) {
  printf("负数\n");
} else {
  printf("零\n");
}

:::tip C 语言中没有原生的布尔类型，数值为 0 为逻辑假，非 0 为逻辑真。逻辑运算的结果都是整数。 :::

选择分支

switch 用于多条件判断。

char grade = 'B';
switch (grade) {
  case 'A':
    printf("优秀\n");
    break; // 跳出 switch，如果不加会继续向下执行
  case 'B':
    printf("良好\n");
    break;
  default:
    printf("其他\n");
}

结构

当我们知道循环次数时可以使用 for 循环。

for (int i = 0; i < 5; i++) {
  printf("i = %d\n", i);
}

需要重复执行直到达成某个条件，不知道具体次数时，可以用 while 循环。

int i = 0;
while (i < 5) {
  printf("i = %d\n", i);
  ++i;
}

函数

函数是一组一起执行一个任务的语句。每个 C 程序都至少有一个函数，即 main 函数。

定义与调用

函数由返回类型、函数名、参数列表和函数体组成。

#include <stdio.h>

// 函数定义：返回 int，接收两个 int 参数
int add(int x, int y) {
  return x + y;
}

int main() {
  int result = add(5, 3); // 函数调用
  printf("result: %d\n", result);
  return 0;
}

声明

不同于其他语言，C 语言在调用函数时，该函数必须被声明过。尝试下面的示例，我们把 add 函数移动到 main 下方，代码就不能通过编译了。

#include <stdio.h>

int main() {
  int result = add(5, 3); // 错误：隐式声明函数‘add’ [-Wimplicit-function-declaration] // [!code error]
  printf("result: %d\n", result);
  return 0;
}

int add(int x, int y) {
  return x + y;
}

为了解决这个问题，我们可以在调用函数之前先声明函数。下面这个代码可以正常编译。

#include <stdio.h>

// 函数声明：不需要函数体，以分号结尾
int add(int x, int y); // [!code ++]

int main() {
  int result = add(5, 3);
  printf("result: %d\n", result);
  return 0;
}

// 函数定义
int add(int x, int y) {
  return x + y;
}

import { Card } from 'astro-pure/user'

C指针和结构体

awfufu

NVIDIA Orin NX/Nano 初始化

前言

一、 WSL2配置

二、 系统安装

2.1 GUI 安装

2.2 CLI安装

2.2.1 安装前提

2.2.2 环境准备

2.2.3 Force Recovery Mode

2.2.4 命令行刷写

2.2.5 启动介质确认

2.2.6 参考资料

三、初次配网

3.1 Headless下无路由器后台权限获取Nano局域网IP

3.2 配置 mDNS 访问

四、SSH 扫盲

4.1 第一次连接

4.2 用 ~/.ssh/config 给设备起别名

4.3 免密登录

4.4 常用的几种 SSH 命令

远程执行命令

传文件

端口转发

4.5 关于 ForwardAgent

五、常用服务与配置文件

5.1 系统层

核心服务

核心配置文件

Ubuntu 常用配置文件

自定义自启动

.service 模板

NVIDIA Orin NX/Nano 环境配置与搭建

一、 项目概述

二、 基础环境配置

2.1 连接 WiFi

2.2 抛弃静态 IP：配置 mDNS 访问

2.3 生产环境对齐：基于 SSH 的 Headless 开发

2.4 容器环境：Docker 与 NVIDIA Toolkit

三、 获取源码：克隆仓库

3.1 选择访问方式

3.2 生产环境：快速克隆（HTTPS）

3.3 开发环境：SSH 配置（仅需提交代码时执行）

四、 AADCL_UAV_UGV 目录结构

五、 容器配置、编排与启动

5.1 设备配置文件 (.env)

5.2 离线数据集安装 (MAVROS 必备)

5.3 初次启动系统

方案 A：本地手动构建 (初次耗时 30-50 分钟)

方案 B：从 Gitea 容器仓库拉取

启动全量系统

5.4 ros2c 脚本的配置

六、 集群部署

6.1 方案 A：通过容器注册表同步 (推荐)

6.2 方案 B：离线镜像迁移 (离线/无网络场景)

七、 系统功能验证

附录：硬件网口配置（优化高频点云传输稳定性）

CSS Flex 布局

flex 布局

块级元素和行内元素

flex 容器和 flex 元素

flex 容器的主轴

沿轴线方向对齐

沿主轴对齐

沿交叉轴对齐

旋转主轴方向

多行布局

flex 自动换行

多行布局下的对齐方式

拉伸和收缩元素

自动拉伸

自动收缩

按比例拉伸或收缩

C指针和结构体

指针类型

什么是指针

空指针和野指针

指针的大小

指针的作用

数组和指针

二、系统安装

4.2 用 `~/.ssh/config` 给设备起别名

4.5 关于 `ForwardAgent`

`.service` 模板

一、项目概述

二、基础环境配置

三、获取源码：克隆仓库

五、容器配置、编排与启动

5.4 `ros2c` 脚本的配置

六、集群部署

七、系统功能验证