日月星辰の个人博客

超实用,不踩坑! Nano Pi R4S安装Openwrt教程

Sat, 08 Aug 2026 00:00:00 GMT

超实用,不踩坑! Nano Pi R4S安装Openwrt教程

一、前言

笔者安装过多次Openwrt, 也踩过不少坑, 也体验到了Openwrt的强大和它丰富的功能，这次笔者将分享Nano Pi R4S安装Openwrt的教程, 以及它的一些使用技巧，希望能帮助到大家。

二、准备工作

16G以上的TF卡与读卡器
科学上网环境
TP-Link路由器
NanoPi R4S 配套散热风扇（可选）
USB SSD（可选，用来制作nas和个人网盘）

我这是将NanoPi R4S连接上家里的光猫的交换机上(或者学校寝室中的路由器上)，然后插上一个2T USB SSD准备做NAS和个人网盘，最后接上一个散热风扇，防止NanoPi R4S过热。

还需要接上一个TP-Link路由器，用于广播WiFi信号，方便手机、平板、笔记本等设备连接上网。

三、安装Openwrt——ImmortalWrt固件系统

安装配套散热风扇 (可选)

买的就是这种PWM控制的散热风扇，不占用USB接口，风扇安装教程，据说还不支持温控。

构建需要安装的镜像

打开NanoPi R4S 构建 immortalwrt 镜像网站，选择 R4S，版本选择 24.10.6

24.10.6这个版本是最后一个能支持opkg安装软件包的版本，后续的版本就迁移使用apk安装包，不再支持opkg安装软件包了，为了良好的兼容性，建议还是使用有opkg安装包的版本(24.10.6也支持使用apk安装)。
在预安装软件包后面添加一个主题luci-theme-argon，点击请求构建
下载镜像，选择 SYSUPGRADE (EXT4) 格式的，方便后续/overlay的扩容

如果选择 SYSUPGRADE (SQUASHFS)，默认的/overlay分区只有300MB，安装大量软件包后会经常不够用。
使用rpi-imager或者win32diskimager将镜像写入TF卡，写入完成后将TF卡继续插在电脑上，准备进行overlay分区扩容。

overlay分区扩容

这里使用gparted工具进行分区扩容，gparted是一个开源的分区管理工具，支持Linux、Windows和MacOS系统。

sudo gparted

调整了根目录的空间后，剩余的分给了/overlay分区，就足足差不多有32GB的空间了

开机打开web管理界面

开机后，有线连接NanoPi R4S和电脑，打开192.168.1.1的web管理界面，默认用户名密码为root/空密码

如果你出现502无法访问web界面的问题，但是能curl访问192.168.1.1，关闭梯子软件或者手动设置系统的梯子代理即可

进来就可以看到熟系的界面了

设置风扇开启自转脚本

在系统-启动项-本地启动脚本中添加一下内容，保存即可

# NanoPi R4S fan fixed speed (90%)

PWM=/sys/class/pwm/pwmchip1

[ -d "$PWM/pwm0" ] || echo 0 > "$PWM/export"

sleep 1

echo 0 > "$PWM/pwm0/enable"
echo 50000 > "$PWM/pwm0/period"
echo 45000 > "$PWM/pwm0/duty_cycle"
echo 1 > "$PWM/pwm0/enable"

四、安装软件包

进入系统管理-软件包，点击更新列表，等待更新完成
在软件包搜索栏中输入你想安装的软件包名称，点击安装即可，这里我推荐几个安装
- luci-app-argon-config: 主题设置
- luci-app-openlist: 开源的网盘openlist
- luci-app-filebrowser-go: 文件管理器
- luci-app-docker: docker
- luci-app-samba4: NAS
- luci-app-netdata: 网络监控
- luci-app-ddns-go: DDNS
- luci-app-ttyd: 终端工具
- luci-app-sqm: 智能队列管理

安装openclash

现在自己电脑上打开https://github.com/vernesong/OpenClash/releases，下载最新版的ipk
使用scp指令将ipk文件传到NanoPi R4S的/tmp目录下，scp指令如下：
```
scp luci-app-openclash_0.47.133_all.ipk root@192.168.1.1:/tmp
```

ssh登录NanoPi R4S，执行以下命令安装ipk包：

opkg install /tmp/luci-app-openclash_0.47.133_all.ipk

安装完成后，退出openwrt web管理界面重新登录一下，就可以在服务-OpenClash中看到OpenClash的设置界面了，刚开始会提示安装clash内核，安装即可。

在插件设置-外部控制中，可以修改clash的web管理界面(如zashborad)的密码，保存设置，然后应用设置

配置filebrowser

在openwrt上安装部署filebrowser也超简单，在软件包中安装filebrowser后，退出重登openwrt就可以在服务中看到filebrowser了。

在这里我仿照《绝区零》的风格编写了一套美化的css，在全局设置-品牌信息文件夹路径添加上文件夹路径，配置好后好看多了。

开源链接：https://github.com/riyuexingchennnn/filebrowser-zzz-style

五、系统配置总览

安装好系统、装好软件包之后，笔者再来分享一下目前的完整配置，给大家一个参考。

硬件与系统

硬件：NanoPi R4S（4GB 内存版，RK3399，aarch64）
系统：ImmortalWrt 24.10.6 (r33869)
根分区：29.3GB（overlay 扩容后，安装大量软件包也不慌）
存储：2TB USB SSD（/mnt/nas，做 NAS 和个人网盘）

登录后就是这个熟悉的界面了，可以看到系统状态、CPU 负载、内存占用等实时信息。

目前安装的常用软件包

笔者目前的装机清单（按用途分类）：

主题美化：luci-theme-argon + luci-app-argon-config（Argon 主题设置）
容器：luci-app-docker + luci-app-dockerman（Docker 管理面板）
网盘：luci-app-openlist（OpenList 网盘聚合）
文件管理：luci-app-filebrowser-go（FileBrowser）
内网穿透：luci-app-frpc、luci-app-ddns-go（DDNS）、luci-app-easytier（EasyTier 组网）、luci-app-tailscale-community（Tailscale）
代理：luci-app-openclash
NAS：luci-app-samba4（SMB 共享）
监控：luci-app-netdata、luci-app-statistics
网络优化：luci-app-sqm（智能队列管理）
工具：luci-app-ttyd（网页终端）、luci-app-cpufreq（CPU 调频）、adguardhome（DNS 广告过滤）

小技巧：如果软件包列表更新慢，可以在"系统-软件包"里先点"更新列表"，再搜索安装，速度会快很多。

六、Docker 实战：把服务都装进容器

装了 luci-app-dockerman 之后，管理容器就非常方便了，图形化界面一目了然。

笔者目前跑着 6 个容器，全部是实战级应用：

容器	用途	端口
`vaultwarden`	自托管密码管理器（Bitwarden 兼容）	18080
`pdfjs`	自建 PDF 在线查看器（支持页面间距切换）	8088
`qinglong`	青龙面板（定时任务）	-
`homeassistant`	智能家居中枢	-
`xiaomiqiu-arm64`	小米球内网穿透（VIP 节点）	-
`xiaomiqiu-arm64-free`	小米球内网穿透（免费节点）	-

部署一个容器（以 Vaultwarden 为例）

docker run -d \
  --name vaultwarden \
  --restart unless-stopped \
  -p 18080:80 \
  -v /mnt/nas/docker/vaultwarden:/data \
  vaultwarden/server:latest

注意：数据目录记得放到 NAS 盘（/mnt/nas）上，这样重刷系统不丢数据。另外容器数据目录的权限要给对（chown 1000:1000），不然容器会报 "unable to open database file"。

七、开机自启动

风扇固定转速

在"系统-启动项-本地启动脚本"中保留风扇脚本，开机自动调速：

# NanoPi R4S fan fixed speed (90%)
PWM=/sys/class/pwm/pwmchip1
[ -d "$PWM/pwm0" ] || echo 0 > "$PWM/export"
sleep 1
echo 0 > "$PWM/pwm0/enable"
echo 50000 > "$PWM/pwm0/period"
echo 45000 > "$PWM/pwm0/duty_cycle"
echo 1 > "$PWM/pwm0/enable"

开机自动启动所有 Docker 容器

虽然容器都设置了 --restart unless-stopped，但为了保险，笔者在 rc.local 里加了一段"遍历启动所有容器"的脚本，双保险：

# Auto-start all Docker containers on boot
if command -v docker >/dev/null 2>&1; then
    # Wait for the Docker daemon to become ready (max 30s)
    i=0
    while [ $i -lt 30 ]; do
        docker info >/dev/null 2>&1 && break
        sleep 1
        i=$((i+1))
    done
    # Start every stopped container
    for cid in $(docker ps -aq); do
        state=$(docker inspect -f '{{.State.Running}}' "$cid" 2>/dev/null)
        if [ "$state" = "false" ]; then
            docker start "$cid" >/dev/null 2>&1
        fi
    done
fi

为什么要加这段？因为 Docker 守护进程启动比 rc.local 慢，直接执行 docker 命令可能失败，所以先循环等待 daemon 就绪，再遍历启动所有容器。实测软路由断电重启后，6 个容器全部自动拉起，非常稳。

八、内网穿透全家桶

R4S 当软路由，最实用的场景之一就是内网穿透，笔者目前同时用了四套方案，各司其职：

方案	用途
frpc	稳定穿透 HTTP/HTTPS 服务（配合 DDNS 使用）
ddns-go	动态域名解析，让穿透域名永不失效
Tailscale	异地组网，手机/电脑随时连回家（WireGuard 协议）
EasyTier	轻量级组网，和 Tailscale 互为备份
小米球（xiaomiqiu）	ngrok 类内网穿透，VIP + 免费双节点

服务列表一览

在"服务"菜单里可以看到所有已安装的服务，OpenClash、DDNS、EasyTier、FileBrowser、FRPC、Tailscale 等都集中在这里管理，非常方便。

小提示：Tailscale 和 EasyTier 都是组网工具，功能有重叠，如果只用其中一个，可以把另一个停掉，省一点内存。

九、总结

经过这一整套配置，NanoPi R4S 已经从"一台小路由器"进化成了"家庭服务器全家桶"：

✅ 科学上网（OpenClash）
✅ 自建网盘（OpenList + FileBrowser + Samba NAS）
✅ 密码管理（Vaultwarden）
✅ 智能家居（Home Assistant）
✅ 内网穿透（frpc + DDNS + Tailscale + EasyTier + 小米球）
✅ 在线 PDF 查看（pdfjs）
✅ 定时任务（青龙）
✅ 广告过滤（AdGuard Home）

一台 300 块的 R4S，能干的事情远超它的价格。如果大家有什么好玩的玩法，欢迎在评论区交流！

本文会持续更新，如果后面笔者又折腾了新功能，会继续补充到这篇教程里。

【开源】Groot2风格行为树可视化监控软件，能展示20个节点以上

Sun, 29 Mar 2026 00:00:00 GMT

前言

项目地址：https://github.com/riyuexingchennnn/BehaviorTreeMonitor

在ROS2机器人项目里，行为树是非常常见的任务组织方式。实际调试时，我们经常需要实时看到每个节点的状态变化，尤其是 subtree 内部节点。

我这次开源了一个基于 BehaviorTree.CPP Groot2 协议的监控工具，目标很直接：

实时可视化行为树状态
能稳定展示 20 个以上节点
对 subtree 内部节点也能完整显示

项目效果

核心能力

1. Groot2 协议兼容

项目通过 BT.CPP 的 Groot2Publisher 对接，能够直接接入已有行为树执行器，不需要改动太多业务代码。

2. 大节点量可视化

实际可展示 20+ 节点状态，包含 subtree 内部节点，适合中等复杂度以上的行为树调试。

3. 桌面应用 + Web 前端的混合架构

使用 Python 负责协议桥接和桌面承载，使用 Vue 3 + TypeScript 负责交互可视化，兼顾开发效率与可维护性。

架构设计

Python (PySide6 + aiohttp)          Vue 3 + TypeScript
┌─────────────────────┐           ┌──────────────────┐
│  Qt WebEngineView   │──HTTP──►  │  前端 (dist/)     │
│  aiohttp Server     │◄─WS───►   │  WebSocket 客户端 │
│  ZMQ Bridge         │◄─ZMQ──►   │                  │
└─────────────────────┘           └──────────────────┘
						    ▲
						    │ ZMQ REQ/REP
						    ▼
					    BT.CPP 执行器
					    (Groot2Publisher)

数据流可以理解为三层：

BT.CPP 执行器通过 ZMQ 与 Python 桥接层通信
Python 侧通过 aiohttp 提供 WebSocket，将状态推给前端
Qt WebEngineView 加载前端页面，形成完整桌面体验

项目结构

BehaviorTreeMonitor/
├── main.py                 # 入口
├── bt_monitor/
│   ├── protocol.py         # BT.CPP Groot2 协议
│   ├── server.py           # aiohttp WebSocket/ZMQ 桥接
│   └── app.py              # Qt WebEngine 窗口
├── frontend/               # Vue 3 + TypeScript
│   ├── src/
│   │   ├── App.vue
│   │   ├── components/
│   │   ├── composables/
│   │   ├── stores/
│   │   ├── types/
│   │   └── styles/
│   └── ...
└── bt_monitor.spec         # PyInstaller 配置

快速开始

环境

uv（Python 包管理）
Node.js 18+
pnpm

安装依赖

# Python 依赖
uv sync

# 前端依赖
cd frontend && pnpm install

本地运行

# 先构建前端
cd frontend
pnpm build

# 回到项目根目录后启动
uv run python main.py

构建发布

# 1. 构建前端
cd frontend && pnpm install && pnpm build

# 2. PyInstaller 打包
uv run --group dev pyinstaller --clean --noconfirm bt_monitor.spec

输出文件位于：dist/BehaviorTreeMonitor

下载使用

如果你不想自己构建，可以直接在 Release 页面下载编译版本：

https://github.com/riyuexingchennnn/BehaviorTreeMonitor/releases

Ubuntu 下首次运行需要先给可执行文件增加权限。

sudo chmod +x BehaviorTreeMonitor.behaviortreemonitor

结语

这个项目的初衷是解决Groot2监控行为树超过20个节点需要license的问题。如果本项目对你有用，欢迎在 GitHub 上点个 Star，或者在评论区留言交流！

解决ubuntu系统外界显示器卡顿掉帧率问题

Fri, 06 Mar 2026 00:00:00 GMT

最近重装笔记本的ubuntu显卡驱动后，突然发现本来好好的外接显示器变得卡顿掉帧率了，尤其是使用浏览器看视频的时候，画面、鼠标移动非常卡顿，但是声音播放没什么问题。

经过一番排查，发现是因为外接显示器没有正确使用独立显卡导致的。终端输入一下指令：

glxinfo | grep "OpenGL renderer"

如果看到

Mesa Intel Graphics

那说明 整个桌面和浏览器都在用核显。

核心做法

sudo prime-select nvidia
sudo reboot

重启后再次输入

glxinfo | grep "OpenGL renderer"

就能看到

OpenGL renderer string: NVIDIA GeForce RTX 4070 Laptop GPU/PCIe/SSE2

另外，打开显卡设置界面就可以看到显卡已经接上外界显示器了，

sudo apt install nvidia-settings
nvidia-settings

同时还可以在显卡设置这里修改显卡功率一达到更好的性能表现。

rm软件组客户端开发快速引导

Mon, 01 Dec 2025 00:00:00 GMT

rm软件组

26赛季起，Robomaster鼓励制作自定义客户端，rm软件组开发自定义客户端，要设计更多客制化功能和UI，以提高操作手对战场的把控能力。

我们的任务

自定义客户端 ( ⭐⭐⭐ )
1. 由于官方不支持在联盟赛使用自定义客户端，所以不考虑联盟赛的自定义客户端
2. 到分区赛或者明年正式上线自定义客户端
上场可以通过与官方电脑连接网线共享ip地址的形式，让操作手携带的装有自定义客户端的电脑也能连接上裁判系统(规则是否允许，有待商榷)
视觉仿真软件 ( ⭐⭐ )
1. 为能量机关和雷达站提供仿真视频
2. 为自瞄提供仿真环境
我的开源：https://fyt-vision.coding.net/p/fyt2025/d/rm_unity/git

rv仿真开源：https://gitlab.com/rm_vision/rm_vision_simulator
数据分析工具软件 (⭐)
1. 行为树状态可视化工具（解决Groot2不能监控超过20个行为树节点的问题）
我的开源：https://github.com/riyuexingchennnn/BehaviorTreeMonitor

自定义客户端要有多自定义

上方显示敌方机器人血量 ( ⭐⭐⭐ )
- 方案一：使用yolo算法对图传帧处理，识别敌方机器人，在上方绘制血量UI
- 方案二：利用视觉计算的敌方机器人位置透视变换到图传视角，在上方绘制血量UI
超级赛场回放 ( ⭐⭐⭐ )

自定义客户端不仅要录制操作手图传画面，还要录制实时赛场的各种状态信息、机器人信息，还要按照视频帧录制操作手鼠标键盘事件，以便操作手复盘

我们为什么使用Unity游戏引擎来开发

为什么采用Unity这种游戏引擎来开发客户端而不是使用Vue或者React这种web框架打包客户端呢？

对于两种方法我只能说各有优劣，我本人也比较熟悉Vue3+TypeScript开发，前端web的做法确实很优美，简单，轻量。但是对于这种交互性很强的软件来说，是不是就不合适了呢？

我询问了很多AI，都给出了选择Unity的答案。这里我采用Gemini的回答(之前没有任何提问历史，没有任何上下文，单纯就是这个问题)

什么人推荐加入rm软件组

计算机or软工专业，想学习计算机客户端软件设计的原理，了解网络请求，业务处理的流程。
准备找工作的同学，此项目完全对标dji的rm专招通道的客户端开发岗位，并且提供转正机会，机不可失。
学习过unity游戏开发的，做过Android Studio项目或者开发过某种客户端的同学。

快速开始

只学习一个开发工具，一种语言，快速上手客户端开发

环境配置

Unity配置

Unity6.3LTS官方文档

windows

windows安装比较简单，unity适配也比较好，较推荐，适合新手。

如果你不喜欢windows做开发，使用ubuntu也是可以的。
ubuntu
1. 按顺序安装好unityhub，安装好Unity6.3 LTS(6000.3.12f1) Editor, 注册好unity账户，添加Personal License
  
  如果在下载unity编辑器的时候出现了下载失败: Validation Failed，检查clash有没有开TUN虚拟网卡模式。安装推荐使用美国节点，全局代理模式，亲测有效。
2. 安装一个unity的linux补丁工具，解决引擎卡顿问题。
```
sudo apt-get install unity-tweak-tool
```
  如果依然卡顿，检查nvidia-smi显示的功率，查看unity是否使用显卡。
3. 打开引擎新建一个项目，选择 Edit->Preferences->External Tools->External Scripts Editor，选成你想要的vscode编辑器

Vscode 配置

安装3个插件即可

打开unity项目和对应的vscode代码，等待vscode输出框安装完所有环境后打开代码，检查是否有代码补全提示和语法报错提醒，有即为正常

制作第一款2D平台跳跃游戏

推荐学习B站up主 秦无邪OvO 的入门开发课程

我的开源: https://github.com/riyuexingchennnn/Unity_demo

重点关注：

unity 引擎使用
C# 代码编写
UGUI
Input System

少量关注：

ShaderGraph
Animator

如果你有良好的编程习惯和基础，unity引擎对你而言，就和玩具差不多

Mock调试

目前收集的开源有:

[RM2026][江南大学霞客湾校区]自定义客户端模拟数据发送&MQTT可视化数据面板开源 https://bbs.robomaster.com/article/1296480?source=1
RMMock-自定义客户端协议的第三方后端实现开源https://bbs.robomaster.com/article/1296451 代码：https://github.com/stydxm/RMMock

可以先使用开源，推荐使用第一个，然后在此基础上逐步建立我们自己的rm_mock仓库

SharkDataSever开源

如果你很熟悉Vue，你可以不用采取我的方法，直接跳过此部分教学

使用鱼香ROS一键安装，选择数字6 NodeJS环境
```
wget http://fishros.com/install -O fishros && . fishros
```
然后使用node --version查看nodejs版本，我的版本是v18.20.8

如何使用和我一样的版本？安装node版本管理工具nvm，安装18选择18

然后依次安装cnpm、pnpm

npm install -g cnpm --registry=https://registry.npmmirror.com
cnpm install -g pnpm

安装，运行mqtt可视化Vue界面
```
pnpm install
pnpm run mqtt-visual
```
运行图传视频流

将目标视频文件通过openshot转成h265格式的视频，播放更流畅，帧率稳定。放入VideoSource文件夹中。
```
pnpm run udp
```

我们自己的rm_mock仓库

根据SharkDataSever开源改造，适配最新版的官方通信协议。请用我们自己的仓库开发：https://cnb.cool/fyt-vision/rm_mock

Protocol Buffers 入门

官方文档是最好的学习资料：https://protobuf.com.cn/overview/

检查自己电脑的proto编译器的版本
```
sudo apt install -y protobuf-compiler
protoc --version
```
如果你的电脑显示的版本为libprotoc 3.12.4。请注意这是非常老的版本，这个通常是由apt安装的，可以选择安装新版本protoc(旧的可以不用卸载)
安装最新的protoc (⚠️实测不推荐，unity不支持新版)

https://github.com/protocolbuffers/protobuf/releases

解压后复制到/user/local目录中去
```
sudo cp bin/protoc /usr/local/bin/
sudo cp -r include/* /usr/local/include/
```
/usr/local/bin 的优先级高于 /usr/bin 所以你的系统会自动使用新的 protoc

再次检查版本，就可以看到libprotoc 33.2

⚠️ 注意：不推荐使用export路径的方式加到bashrc里去，因为这只对shell环境有用，容易出其他问题。
Protocol Buffer 基础：C#

官方文档

下载我整理好的rm_messages.proto文件

运行下面指令，会得到一个RmMessages.cs的文件
```
protoc --csharp_out=. rm_messages.proto
```

Unity 与 mqtt protobuf

刚刚导入的RmMessages.cs会遇到一个Google.Protobuf依赖不匹配的问题，推荐到Nuget上下载对应3.12.4版本的dll库(选用老版本保证兼容性)

方法一：使用Nuget包管理工具安装dll库 (⭐推荐)

unity安装Nuget包管理工具
- 先到这个链接下载最新的unitypackage文件 https://github.com/GlitchEnzo/NuGetForUnity/releases 拖入unity中import
- 重启unity后，引擎上方会多一个Nuget选项
打开 Nuget Manager，搜索Google.Protobuf，选择对应3.12.4版本，然后install，新安装的dll会出现在Assets/Packages里

同理安装MQTTnet 4.3.3.952

方法二：第三方安装

https://nuget.info/packages/Google.Protobuf/3.12.4

然后下载下来，拖到unity中Assets/Plugins目录下即可

https://nuget.info/packages/MQTTnet/4.3.3.952

同理，下载MQTTnet.dll，放到unity的Assets/Plugins目录

官方项目解包

开发客户端必须要UI美术资源，这里我们作为程序员只能利用盗用官方UI资源。

推荐使用RipperAsset进行解包

解包后的项目，有全部的UI和C#代码，但是缺少关键的xuml文件，加上2025年官方没有使用到mqtt和protobuf，所以仍需自己重头开发。

我的解包(如果你需要，请联系我)：https://gitee.com/caimingchen0602/export-project

这种解包再复刻项目的过程叫做逆向开发

正式开发

前置知识

熟练使用unity
了解web三件套程序的编写
了解http、mqtt、websocket通信协议流程，知道TCP/UDP通信原理

UI Toolkit

为什么选择UI Toolkit而不选择UGUI？

UI Toolkit更符合客户端开发，性能好(UGUI每个UI都是一个GameObject，因此会有大量的GameObject)，代码清晰。而UGUI更符合game-only

示例：编写第一个页面开始界面

方法一：在Project中create一个UIDocument，双击点开进入UIBuilder，直接通过UIBuilder可视化界面编辑UI界面。UI元素的标签和样式全都自动生成到uxml文件之中，新手友好，但是不直观。
方法二：创建一个uxml文件(相当于xml)和uss文件(相当于css文件)，直接编写标签和样式代码。新手不友好，各种样式类选择器优先级复杂难记，相对直观，容易管理。

编写StartMenuController.cs代码，拖放到UIDocument物体上。

(页面设计十分类似安卓原生开发)

using UnityEngine;
using UnityEngine.UIElements;
using UnityEngine.SceneManagement;

public class StartMenuController : MonoBehaviour
{
    private void OnEnable()
    {
        var root = GetComponent<UIDocument>().rootVisualElement;

        Button startButton = root.Q<Button>("start-button"); // 使用按钮的名字或 class

        startButton.clicked += StartGame;
    }

    void StartGame()
    {
        Debug.Log("游戏开始！");
        // 例如：加载场景
        SceneManager.LoadScene("level 1");
    }
}

关于显示器分辨率和DPI缩放的问题，在你的UI Document使用的全局Panel Setting中找到这个Scale mode，修改成这样，把默认的分辨率调成你开发时使用的分辨率就好了。这下不管显示器是1080p还是2K还是QHD分辨率的，都能适用，图标大小不会变异。

MQTT通信

示例：编写第一个MQTT接口 GameStatus

参考Robomaster官方附录三，利用MQTTnet库编写一个脚本main.cs

运行unity，打开Mock测试端，发送GameStatus消息。如果在unity中看到有收到这个话题消息，即为成功

UDP 图传视频流

FFmpeg

服务器发送的是 HEVC (H.265) 编码的视频流，不是 JPEG。每个 UDP 包有 8 字节的自定义协议头。

Unity 原生不支持 HEVC 解码，我们可以使用 FFmpeg 可执行文件，通过启动 FFmpeg 进程来解码 HEVC 流

linux ffmpeg下载: https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-amd64-static.tar.xz

windows ffmpeg下载：https://www.gyan.dev/ffmpeg/builds/ 下载 ffmpeg-release-essentials.zip 解压后找到 bin/ffmpeg.exe

先确保赋有权限

chmod +x rm_custom_client/Assets/StreamingAssets/RockVR/FFmpeg/linux/ffmpeg

// FFmpeg 参数：从 stdin 读取 HEVC，输出 RGB24 原始数据到 stdout
string arguments = $"-f hevc -i pipe:0 -f rawvideo -pix_fmt rgb24 -s {videoWidth}x{videoHeight} pipe:1";

像这样直接带上参数开一个进程运行ffmpeg二进制文件

UDP

根据官方说明，我们接受udp数据包，要按顺序拼接组装帧数据

所以最终的流程是：

把接收到的 HEVC 数据通过管道传给 FFmpeg
FFmpeg 解码后输出原始 RGB 数据
把 RGB 数据写入 Texture2D 显示

Unity ai with yolov5

在unity6.3LTS中，已经弃用了Sentis库，改成com.unity.ai.inference

打开Package Manager > 选择左上角加号 > 选择Add > 输入com.unity.ai.inference

依旧官方文档

我已经在Unity6.3中测试过com.unity.ai.inference，使用yolov5s推理，自己编写好模型的预处理和后处理。方案有了初步的可行性

实测效果：检测到 5 个目标 | 推理: 2.8ms | 总计: 75.6ms

unity ai绕过了nvidia cuda深度学习框架，使用的是GPU计算图的方式加速AI推理和unity的shader类似。使得用户不需要安装CUDA深度学习环境，只需要安装过显卡驱动就行了。

注意事项

Q：为什么Unity6.3总是下载失败？

A：最好的方法依然是使用Unity Hub下载，尽量减少要安装的组件，降低安装失败的概率，选择美国节点，检查一下我上面的说的clash配置，如果配置正确下载失败，切换节点多试几次。

Q：为什么使用Unity 6000.3.12f1版本？

A：这是官方目前最新推荐的LTS版本，之前有测试过6000.3.1f1版本，和6000.3.10f1版本。据说6000.3.10f1版本inputsystem插件有签名问题以及功能bug。

Q：

vscode插件推荐

Tue, 10 Dec 2024 00:00:00 GMT

计算机视觉深度学习入门

Wed, 27 Nov 2024 00:00:00 GMT

前言

FYT视觉组培训，针对RoboMaster的深度学习速成课。

预备知识：

学习完前面的C++培训知识，有基本的编程能力。
掌握Python的基本语法。

参考书籍：

Deep Learning with Python Second Edition (主要讲tensorflow)
DIVE INTO DEEP LEARNING (主要讲pytorch)
了解CV与RoboMaster视觉组 (视觉组圣经)

讲解人

计科2205 蔡明辰

1. 计算机视觉深度学习入门

计算机视觉是深度学习最早也是最重要的成功案例。当时一类叫做卷积神经网络(Convolutional Neural Network, CNN)的神经网络模型在图像分类任务上取得了非常优秀的性能，从此计算机视觉领域进入了深度学习时代。卷积神经网络是计算机视觉领域最常用的深度学习模型，也是我们主要学习的内容。

1.1 从认识一个卷积神经网络(CNN)开始

我们先来看一个简单的卷积神经网络模型示例，用语对MNIST数据集进行分类。虽然在上一讲我们已经用密链接网络做过，当时的测试精度约为97%，但现在我们用卷积神经网络来做，效果会更好。

import torch
import torch.nn as nn

class LeNet(nn.Module):
    def __init__(self, num_classes=10):
        super(LeNet, self).__init__()
        # 卷积层1
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, stride=1, padding=2)
        # 池化(汇聚)层1
        self.pool1 = nn.MaxPool2d(kernel_size=2)
        # 卷积层2
        self.conv2 = nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5, stride=1)
        # 池化(汇聚)层2
        self.pool2 = nn.MaxPool2d(kernel_size=2)
        # 展开
        self.flatten = nn.Flatten()
        # 三个全连接层
        self.fc1 = nn.Linear(in_features=16 * 5 * 5, out_features=120)
        self.fc2 = nn.Linear(in_features=120, out_features=84)
        self.fc3 = nn.Linear(in_features=84, out_features=num_classes)
        # 声明两个激活函数
        self.act = nn.ReLU(inplace=True)
        self.softmax = nn.Softmax(dim=1)

    def forward(self, x):
        y = self.act(self.conv1(x))
        y = self.pool1(y)
        y = self.act(self.conv2(y))
        y = self.pool2(y)
        y = self.flatten(y)
        y = self.act(self.fc1(y))
        y = self.act(self.fc2(y))
        y = self.fc3(y)
        y = self.softmax(y)
        return y

from torchsummary import summary

# 创建模型实例
model = LeNet(num_classes=10)

# 将模型放到设备上 (CPU 或 GPU)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

# 使用 torchsummary 显示模型摘要
summary(model, input_size=(1, 28, 28))

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1            [-1, 6, 28, 28]             156
              ReLU-2            [-1, 6, 28, 28]               0
         MaxPool2d-3            [-1, 6, 14, 14]               0
            Conv2d-4           [-1, 16, 10, 10]           2,416
              ReLU-5           [-1, 16, 10, 10]               0
         MaxPool2d-6             [-1, 16, 5, 5]               0
           Flatten-7                  [-1, 400]               0
            Linear-8                  [-1, 120]          48,120
              ReLU-9                  [-1, 120]               0
           Linear-10                   [-1, 84]          10,164
             ReLU-11                   [-1, 84]               0
           Linear-12                   [-1, 10]             850
          Softmax-13                   [-1, 10]               0
================================================================
Total params: 61,706
Trainable params: 61,706
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.00
Forward/backward pass size (MB): 0.11
Params size (MB): 0.24
Estimated Total Size (MB): 0.35
----------------------------------------------------------------

1.1.1 卷积运算

在数学中，卷积的定义为：

$$ (f*g)(t) = \int_{-\infty}^{\infty} f(t-\tau)g(\tau)d\tau $$

严格来说，卷积层是个错误的说法，因为它所表示的运算其实是互相关运算，而不是卷积运算。

二维互相关运算：0 x 0 + 1 x 1 + 3 x 2 + 4 x 3 = 19

所以，输出大小等于输入大小 $n_h \times n_w$ 减去卷积核大小 $k_h \times k_w$（边界效应），即：

$$ (n_h - k_h + 1) \times (n_w - k_w + 1) $$

填充：为了不让图像因为边缘效应经过深度网络层层越卷越小，通常会在图像边缘补零，即在图像边缘添加一些额外的像素，使得图像边缘的像素值与图像中心的像素值相等。

卷积层当中也有偏置项，偏置项和卷积核内的参数都是需要训练的(~~下面要考~~)。

1.1.2 图像卷积

Dense 层与卷积层的根本区别在于，Dense 层从输入特征空间中学到的是全局模式（比如对于 MNIST 数字，全局模式就是涉及所有像素的模式），而卷积层学到的是局部模式（对于图像来说，局部模式就是在输入图像的二维小窗口中发现的模式）。

卷积网络的两个重要特性：

卷积神经网络学到的模式具有平移不变性。
卷积神经网络可以学到模式的空间层次结构(局部性)。

在MNIST的实例中，第一个卷积层接收的特征图是(1,28,28)，并输出尺寸为(6,28,28)的特征图。这是为什么呢？

self.conv1 = nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, stride=1, padding=2)

先分析一下这段代码的含义：

in_channels=1 表示输入图像的通道数为1
out_channels=6 表示输出图像的通道数为6
kernel_size=5 表示卷积核的大小为5x5
stride=1 表示卷积步长为1
padding=2 表示填充2个像素

一共有6个卷积核，每个卷积核都要分别对输入图像卷积运算一次，所以输出图像的通道数为6。

这就是特征图这一术语的含义：深度轴上每个维度都是一个特征(卷积核或叫滤波器filter)。

因为卷积核大小为5x5，由于边界效应，输出的特征图的边框会比输入图像小2个像素。但是因为又在周围填充了2个像素，所以输出的特征图的大小还是原来的大小。

所以输出尺寸为(6,28,28)。

理解了图像卷积的过程，我们现在还可以看看为什么第一层卷积的参数量是156。

卷积核数量为6，卷积核的尺寸为(1,5,5)，所以参数量为5x5x1x6=150。
还有偏置项，偏置项的数量为6，所以参数量为6。
所以一共为5x5x1x6+6=156。

1.1.3 一个特殊的卷积核 1x1卷积

1×1 卷积核丧失了影响高度和宽度的能力，但是它可以影响通道数。

我们可以将 1×1 卷积层看作在每个像素位置应用的全连接层，以 $c_i$ 个输入值转换为 $c_o$ 个输出值。因为这仍然是一个卷积层，所以跨像素的权重是一致的。

当以每像素为基础应用时，1×1 卷积层相当于全连接层。
1×1 卷积层通常用于调整网络层的通道数量和控制模型复杂性。

1.1.4 最大汇聚运算

在上面那个卷积神经网络的例子中，你可能注意到每经过一次MaxPool2d层，输出图像的尺寸就会缩小一半。

这就是汇聚层(有的地方也叫池化层)的作用：主动对特征图进行下采样。

但是为什么一定要下采样，直接用原图，保留较大特征图不好吗？

减少需要处理的特征图的元素个数，减少参数量，防止过拟合。
让连续卷积层的观察窗口越来越大，从而引起空间滤波器的层次结构。

self.pool1 = nn.MaxPool2d(kernel_size=2)

一个池化窗口为2的池化层。

平均池化(Average Pooling)，最大池化(Max Pooling)都是池化层的一种。

但是往往最大池化(Max Pooling)的效果更好，因为它能够保留更多的特征，特征的最大值能够保留更多的信息。

1.1.3 详解LeNet-5

看到这里，其实上面那个LeNet-5模型的结构已经很清晰了。

LeNet-5是深度学习之父，Yann LeCun于1998年提出的最早的卷积神经网络，当时是用来解决手写体数字识别问题，其网络结构图如下所示，从LeNet-5开始，CNN就形成了若干个（卷积、池化）层+（用于特定任务的全连接层）的范式

在经过层层卷积池化后，最后连接一个flatten层，将二维特征图拉平，形成一条直线，最后输入到特定的全连接神经网络中。

self.flatten = nn.Flatten()

拉平后，先后输入120个神经元，84个神经元和10个神经元的密连接层中。

self.fc1 = nn.Linear(in_features=16 * 5 * 5, out_features=120)
self.fc2 = nn.Linear(in_features=120, out_features=84)
self.fc3 = nn.Linear(in_features=84, out_features=num_classes)

最后用softmax函数，求出每个输出的权重。

在RoboMaster中，FYT视觉组用的识别装甲板数字的模型就是基于LeNet5的。LeNet5模型结构简单，参数少，适合在嵌入式设备上运行。

【Minecraft】红石卷积神经网络——原理

1.2 AlexNet改变世界的神经网络

在LeNet-5的年代，深度学习并没有受到机器学习研究者的重视，理由是深度学习需要大量的计算量，参数多，需要大量的数据集供于训练。2012年，Alex Krizhevsky，Ilya Sutskever和Yoshua Bengio提出了AlexNet，并在同年的ImageNet图像分类竞赛上以压倒性的优势夺得了冠军。AlexNet获得成功的关键是

ImageNet2012提供了大量的已标注数据集，使得大规模的网络有足够的数据进行学习
利用CUDA技术，Alex Krizhevsky和Ilya Sutskever实现了可以在GPU硬件上运行的深度卷积神经网络，而神经网络这种基于矩阵运算的模型能够在GPU上快速运算，突破了深度网络训练的瓶颈。

下图为LeNet-5（左）和AlexNet（右）的对比，AlexNet任然保留了N个卷积池化+全连接层的形式。

1.3 "猫狗大战"——VGG16

首先下载Kaggle数据集，下载网址，点击Download -> 点击Download as Zip。

博客链接

VGG16是2014年ImageNet图像分类竞赛的冠军，其结构如下图所示：

就如 LeNet 和 AlexNet，卷积神经网络可以简化为的形式：

$$ \text{神经网络} = N * (n * Conv + MaxPool) + DetectionHead\text{(检测头)} $$

VGG 网络就是这样，他们将 $(n * Conv + MaxPool)$ 作为一个基本模块（VGG 块），通过不同模块的拼接，设计了 VGG-16、VGG-19 等不同的网络，都取得了不错的效果。

2. 计算机视觉深度学习进阶

2.1 三项基本的计算机视觉任务

2.1.1 图像分类

为图像指定一个或多个标签。它既可以是单标签分类（一张图像只能属于一个类别，不属于其他类别），也可以是多标签分类（找出一张图像所属的所有类别）

例如：识别一张图片是猫还是狗(二分类)、识别一张手写数字图片是数字几(多分类)、识别一张RM机器人车辆图片是什么兵种什么阵营(多分类多标签)。

2.1.2 图像分割

将图像“分割”或“划分”成不同的区域，每个区域通常对应一个类别

2.1.3 目标检测

在图像中感兴趣的目标(ROI)周围绘制矩形（称为边界框）并给出每个矩形对应的类别。

例如，检测相机采样的照片帧中，RM机器人车辆在二维图片中的位置和机器人的种类。如YOLO算法。

2.2 现代卷积神经网络的架构模式

2.2.1 模型架构

模型架构往往会决定成败。如果你选择了不合适的架构，那么模型可能会被次优指标拖累，再多的训练数据也无法改进它。相反，良好的模型架构可以加速学习过程，让模型可以有效利用训练数据，并降低对大型数据集的需求。一个良好的模型架构可以减小搜索空间，或者更容易收敛到搜索空间的良好位置。就像特征工程和数据收集一样，模型架构就是为了能够利用梯度下降更轻松地解决问题。

模型架构更像是一门艺术，而不是一门科学。经验丰富的机器学习工程师能够在第一次尝试时就凭直觉拼凑出高性能的模型，而初学者往往很难构建出一个可用于训练的模型。这里的关键词是直觉：没人可以向你清楚地解释什么有效、什么无效。

可解释性差，黑盒

2.2.2 残差连接

传话游戏：y = f4(f3(f2(f1(x))))

如果函数链太长，那么这些噪声会盖过梯度信息，反向传播就会停止工作，模型也就根本无法训练。这就是**梯度消失（vanishing gradient）**问题。

当人们发现深度卷积网络能有效从图片中提取特征时，人们就致力于设计更深更大的神经网络。但是人们发现，深层的神经网络往往难以训练，其中最主要的原因就是梯度消失（某一层的梯度≈0）和梯度爆炸（某一层的梯度≈无穷大）。曾经，人们认为像VGG-19这样的网络已经是网络深度的极限了，这样的网络足以被称为深度卷积神经网络，直到Kaiming He, Shaoqing Ren and Jian Sun带着他们的ResNet以难以置信的1202层、1940万参数（19.4M）炸裂登场。(中国人何恺明，他还发明了暗通道去雾算法)

残差连接是一种常用的网络结构，它能够帮助深度神经网络更好地收敛，并减少梯度消失或爆炸的问题。残差连接的基本思想是，如果一个层的输出可以被其输入直接预测，那么就不要再加一层全连接层，而是直接将其输出作为下一层的输入。

下图为resnet-18结构图

利用残差连接，你可以构建任意深度的神经网络，而无须担心梯度消失问题。

2.2.3 批量规范化

**规范化（normalization）**包含多种方法，旨在让机器学习模型看到的不同样本之间更加相似，这有助于模型学习，还有助于更好地泛化到新数据。

虽然原始论文指出，批量规范化的作用是“减少内部协变量偏移”，但没有人能真正确定批量规范化为何有效。有各种假说，但没有确定的说法。你会发现，深度学习中的许多事情是这样的——深度学习不是一门精确的科学，而是一组不断变化、根据经验得出的最佳工程实践，其中夹杂着不可靠的表述。

2.2.4 深度可分离卷积

如果我告诉你，有一种层可以替代 Conv2D 层，并可以让模型变得更加轻量（可训练权重参数更少）、更加精简（浮点运算更少），还可以将模型性能提高几个百分点，你觉得怎么样？我说的正是深度可分离卷积（depthwise separable convolution）层的作用（Keras 中的 SeparableConv2D 层）。这种层对输入的每个通道分别进行空间卷积，然后通过逐点卷积（1×1 卷积）将输出通道混合。

深度可分离卷积：深度卷积 + 逐点卷积

与普通卷积相比，深度可分离卷积的参数更少，计算量也更小，同时具有相似的表示能力。它得到的是更小的模型，其收敛速度更快，更不容易出现过拟合。如果只用有限的数据从头开始训练一个小模型，这些优点就变得尤为重要。

以GoogleNet为代表的深度神经网络架构，其卷积层都采用深度可分离卷积。

Inception块

在GoogLeNet中，基本的卷积块被称为Inception块（Inception block）
GoogLeNet

3. YOLOv5实战

yolov5-5.0训练完整步骤

4. 有关深度学习的社区

作业

1. 使用C++部署手写数字识别的模型

训练过程随意，训练模型架构随意，可以使用MLP或LeNet-5。主要考验模型的部署和使用。

要求：

使用C++部署，模型转成onnx格式。
在Gitee中提交C++部署代码，以及输入一张手写数字图片的运行结果截图(证明你跑通了)。

截止日期：12月7日（周六）

2. YOLO动手操练(选做，可做可不做)

YOLO目标检测是每个RMer小白学习的必经之路，请同学们自学YOLOv5算法的部署，部署YOLOv5目标检测算法。

要求：

在自己电脑上配置好深度学习环境，要求使用GPU推理。
使用官方模型权重
在Gitee中提交随意一个推理视频

截止日期：12月7日（周六）

深度学习基础

Wed, 27 Nov 2024 00:00:00 GMT

前言

FYT视觉组培训，针对RoboMaster的深度学习速成课。

预备知识：

学习完前面的C++培训知识，有基本的编程能力。
掌握Python的基本语法。

参考书籍：

Deep Learning with Python Second Edition (主要讲tensorflow)
DIVE INTO DEEP LEARNING (主要讲pytorch)
了解CV与RoboMaster视觉组 (视觉组圣经)

往年的深度学习文档：https://github.com/CSU-FYT-Vision/Vision-Tutorial

讲解人

计科2205 蔡明辰

1. 初识深度学习

1.1 什么是深度学习

深度学习（Deep Learning）是机器学习的一种方法，它利用多层神经网络对数据进行学习，并通过反向传播算法进行梯度下降，从而使得神经网络能够自动学习到数据的特征，并对未知数据进行预测。

1.2 RoboMaster与深度学习

在RoboMaster中，有许多需要使用到深度学习的地方，如图像识别、目标检测等。

装甲板检测：可以使用实时目标检测装甲板的位置，准确有效击打装甲板。
装甲数字识别：使用一个简单的图像分类网络，识别数字。
雷达：目标检测赛场上的各种敌我车辆，显示小地图，发动易伤buff。

所以RMer视觉也要掌握深度学习的基本知识。

1.3 机器学习与深度学习

1.3.1 机器学习

机器学习的主要任务是从数据中学习，并利用这些知识对未知数据进行预测或决策。机器学习的算法有监督学习、无监督学习、半监督学习、强化学习等。

输入数据。机器学习的输入数据可以是图像、文本、声音、视频等。
预期输出示例。机器学习的预期输出可以是分类、回归、聚类、排序等。
衡量算法效果的方法。衡量结果是一种反馈信号，用于调整算法。这个调整的步骤就是我们说的学习。

机器学习和深度学习的核心问题在于有意义地变换数据。换句话说，在于学习输入数据的有用表示——这种表示可以让数据更接近预期输出。

了解了学习的概念后，看看深度学习的特别之处。

1.3.2 深度学习之“深度”

深度学习是机器学习的一个分支，它利用多层神经网络对数据进行学习。

可以将深度神经网络看做一个多级的信息蒸馏：信息穿过多层过滤器，其纯度越来越高。

1.4 机器学习算法

本小节了解即可。

1.4.1 监督学习

监督学习擅长在“给定输入特征”的情况下预测标签。

监督学习的学习过程一般可以分为三大步骤：

从已知大量数据样本中随机选取一个子集，为每个样本获取真实标签。有时，这些样本已有标签（例如，患者是否在下一年内康复？）；有时，这些样本可能需要被人工标记（例如，图像分类）。这些输入和相应的标签一起构成了训练数据集；
选择有监督的学习算法，它将训练数据集作为输入，并输出一个“已完成学习的模型”；
将之前没有见过的样本特征放到这个“已完成学习的模型”中（测试集），使用模型的输出作为相应标签的预测。

回归问题：输出是数值类型

举例：通过各种影响因素预测房价、预测用户对一部电影的评分可以被归类为一个回归问题
分类问题：输出是类别的分类问题的常见损失函数被称为 交叉熵 （cross-entropy）

举例：从手写数据集中区分0~9（类别问题）、以下图片是否是毒蘑菇（二分类问题）

模型通常给出的是一个概率：比如输入以上蘑菇，分类器可能输出0.8 可以这样理解：分类器90%确定图像描绘的是一只猫

1.4.2 无监督学习

监督学习要向模型提供巨大数据集：每个样本包含特征和相应标签值。

相反，如果工作没有十分具体的目标，就需要“自发”地去学习了。比如，老板可能会给我们一大堆数据，然后要求用它做一些数据科学研究，却没有对结果有要求。这类数据中不含有“目标”的机器学习问题通常被为 无监督学习（unsupervised learning）

聚类（clustering）问题：没有标签的情况下，我们是否能给数据分类呢？比如，给定一组照片，我们能把它们分成风景照片、狗、婴儿、猫和山峰的照片吗？同样，给定一组用户的网页浏览记录，我们能否将具有相似行为的用户聚类呢？
主成分分析（principal component analysis）问题：我们能否找到少量的参数来准确地捕捉数据的线性相关属性？比如，一个球的运动轨迹可以用球的速度、直径和质量来描述。再比如，裁缝们已经开发出了一小部分参数，这些参数相当准确地描述了人体的形状，以适应衣服的需要。另一个例子：在欧几里得空间中是否存在一种（任意结构的）对象的表示，使其符号属性能够很好地匹配?这可以用来描述实体及其关系，例如“罗马” − “意大利” + “法国” = “巴黎”。
因果关系（causality）和概率图模型（probabilistic graphical models）问题：我们能否描述观察到的许多数据的根本原因？例如，如果我们有关于房价、污染、犯罪、地理位置、教育和工资的人口统计数据，我们能否简单地根据经验数据发现它们之间的关系？
生成对抗性网络（generative adversarial networks）：为我们提供一种合成数据的方法，甚至像图像和音频这样复杂的非结构化数据。潜在的统计机制是检查真实和虚假数据是否相同的测试，它是无监督学习的另一个重要而令人兴奋的领域。

1.4.3 半监督学习

半监督学习（Semi-Supervised Learning, SSL）是一种介于监督学习和无监督学习之间的机器学习方法。它利用少量标注数据和大量未标注数据共同训练模型，目标是提高模型的性能，同时减少对标注数据的依赖。半监督学习方法在标注数据获取成本较高或数据标注较困难的场景中非常有用，例如医学影像分析、自然语言处理和计算机视觉等领域。

标记样本少的类别：可以用聚类算法来标记样本少的类别。
标记样本多的类别：可以用生成模型来标记样本多的类别。

1.4.4 强化学习

强化学习（Reinforcement Learning）是机器学习的一种方法，它通过与环境的互动来学习。

强化学习的目标是产生一个好的策略（policy）。

模型根据对环境的观察产生一定的动作，将这个动作应用到环境当中，模型从环境中获得奖励

举例：AlphaGo

本科毕设非嵌入式离线强化学习制作皇室战争AI与8000分人机的获胜对局

1.4 用三张图理解深度学习的工作原理

1.5 深度学习的硬件

CPU、GPU、TPU(张量处理器)

【硬核科普】从零开始认识显卡

2007年，NVIDIA推出了CUDA，它是一种基于GPU的并行编程模型，可以让程序员编写并行代码，并在GPU上运行。

1.6 深度学习的历史与发展

1.6.1 神经网络的核心关键原则：

线性和非线性处理单元的交替
通常称为层（layers）。
使用链式规则（也称为反向传播 Backpropagation）
一次性调整网络中的全部参数。

1.6.2深度学习的提出历史：

一些中流砥柱的模型：
- 多层感知机（McCulloch and Pitts, 1943）
- 卷积神经网络（LeCun et al., 1998）
- 长短期记忆网络（Graves and Schmidhuber, 2005）
- Q学习（Watkins and Dayan, 1992）
曾因对休眠期和当时技术限制被搁置一段时间后，过去十年被重新发现。

1.6.3 为什么最近十几年深度学习才重新“热门”？

网络和图像传感器的发展使得数据的获取变得廉价
- 大量图片、视频和用户数据信息使得大规模数据集变得触手可及。
运算设备的算力发展
- GPU的普及，使大规模算力唾手可得。
深度学习框架在传播想法方面发挥了至关重要的作用
- 例如，PyTorch 和 TensorFlow。
- 在2014年之前，对卡内基梅隆大学机器学习博士生来说，训练全性能回归模型曾是一个复杂的作业问题。而现在，这项任务只需不到10行代码即可完成。

2. 神经网络的基本数学概念

2.1 张量 (Tensor) 介绍

张量是多维数组的泛化，用于表示标量、向量、矩阵及更高维数据。

标量 (Scalar)
标量是零维张量，仅表示一个数值，例如：
```
x = np.array(5)  # 标量
```
向量 (Vector)
向量是一维张量，例如：
```
x = np.array([1, 2, 3])  # 向量
```
矩阵 (Matrix)
矩阵是二维张量，例如：
```
x = np.array([[1, 2], [3, 4]])  # 矩阵
```
张量 (Tensor)
张量是更高维度的数组

2.2 张量运算的导数——梯度 (Gradient)

导数这一概念可以应用于任意函数，只要函数所对应的表面是连续且光滑的。张量运算（或张量函数）的导数叫作梯度（gradient）。梯度就是将导数这一概念推广到以张量为输入的函数，张量函数的梯度表示该函数所对应多维表面的曲率（curvature）。

2.3 链式求导（Chain Rule）

链式求导是神经网络梯度计算的核心工具，用于计算复合函数的导数。

如果函数 $z = f(g(x))$，则导数计算为：

$$ \frac{\partial z}{\partial x} = \frac{\partial z}{\partial g} \cdot \frac{\partial g}{\partial x} $$

在神经网络中，每一层的输出是上一层的输入，链式求导用于将输出误差逐层反传以更新权重。

2.4 随机梯度下降 (Stochastic Gradient Descent)

给定一个可微函数，理论上可以用解析法找到它的最小值，找到所有导数为0的点，然后比较函数在其中哪个点的取值最小。将这一方法应用于神经网络，就是用解析法求出损失函数最小值对应的所有权重值。但在实际中，求解析解往往是不可行的。

一个两个参数求解析解还好说，但是神经网络的参数不会少于几千个，而且经常有上千万个。

SGD的步骤：

抽取训练样本 x 和对应目标 y_true 组成的一个数据批量。
在 x 上运行模型，得到预测值 y_pred。这一步叫作前向传播。
计算模型在这批数据上的损失值，用于衡量 y_pred 和 y_true 之间的差距。
计算损失相对于模型参数的梯度。这一步叫作反向传播（backward pass）。
将参数沿着梯度的反方向移动一小步，比如 W -= learning_rate* gradient，从而使这批数据上的损失值减小一些。学习率（learning_rate）是一个调节梯度下降“速度”的标量因子。

⼀维损失函数曲线的随机梯度下降	⼆维损失表⾯的梯度下降

如你所见，直观上来看，learning_rate 因子的取值很重要。如果取值太小，那么沿着曲线下降需要很多次迭代，而且可能会陷入局部极小点（鞍点）。如果取值过大，那么更新权重值之后可能会出现在曲线上完全随机的位置。

局部最⼩点的解决办法：动量。

更新参数 w 不仅要考虑当前梯度值，还要考虑上⼀次参数更新。

w(新) = w(旧) + momentum(动量因⼦) * velocity - learning_rate * gradient

2.5 反向传播 (Backpropagation)

反向传播是通过链式法则计算神经⽹络梯度的算法。

反向传播的⼯作流程：

前向传播：从输⼊层到输出层计算⽹络的预测值。
损失计算：通过损失函数衡量预测值与真实值的误差。
反向传播：利⽤链式求导从输出层逐层计算梯度。
参数更新：使⽤优化器更新权重和偏置。

2.6 优化器 (Optimizer)

优化器是用于最小化损失函数的算法，通过梯度更新神经网络的参数。

常见优化器

随机梯度下降 (SGD)

批量随机梯度下降，随机梯度下降，小批量随机梯度下降

AdaGrad

适合处理稀疏数据，但学习率可能逐渐变小。

RMSProp

通过均方根调整学习率，适合非平稳目标。

Adam
综合了动量法和 RMSProp：

2.7 用计算图看正向传播和反向传播

前向传播的过程比较简单，从输入层开始，逐层计算每一层的输出，直到得到最终的预测值。

“如果反过来看？”

对该图应用链式法则，可以计算出我们想要的梯度（损失函数相对于参数的梯度偏导）：

grad(loss_val,w) = 1 x 1 x 2 = 2
grad(loss_val,b) = 1 x 1 = 1

然后，我们就可以用这些梯度来更新参数w和b了。

3. 从线性回归到神经网络

3.1 主要目的

学习如何⽤PyTorch编程。

3.2 任务目标

线性回归的式⼦满⾜：y = w*x + b，其中w和b均为参数，x，y可以理解成特征值和⽬标值，在程序中我们指定x，w，b，⽬标值y也随之确定了下来。然后将x通过神经⽹络进⾏训练，我们希望通过训练，使得随机初始化的参数w和b能够逼近⼀开始我们指定的w，b，使得预测值pred和实际的⽬标值y能够⽆限接近。

3.3 损失函数 (Loss Function)

损失函数⽤于衡量模型预测值与真实值的差距。通常我们会选择⾮负数作为损失，且数值越⼩表⽰损失越⼩，完美预测时的损失为0。回归问题中最常⽤的损失函数是平⽅误差函数。

$$ l^{(i)}(\mathbf{w}, b) = \frac{1}{2} \left( \hat{y}^{(i)} - y^{(i)} \right)^2 $$

$\frac{1}{2}$并不会带来本质上的区别，只是为了求导简单

我们需要计算在训练集n个样本上的损失均值：

$$ L(\mathbf{w}, b) = \frac{1}{n} \sum_{i=1}^{n} l^{(i)}(\mathbf{w}, b) = \frac{1}{n} \sum_{i=1}^{n} \frac{1}{2} \left( \mathbf{w}^\top \mathbf{x}^{(i)} + b - y^{(i)} \right)^2. $$

3.4 代码实现

import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt

# 1. 生成数据
# 创建一些模拟数据，假设 y = 3x + 2 + 噪声
torch.manual_seed(42)  # 设置随机种子
x = torch.linspace(0, 10, 100).unsqueeze(1)  # 输入数据 (100, 1)
y = 3 * x + 2 + torch.randn(100, 1) * 2  # 输出数据带噪声 (100, 1)

# 2. 定义一个简单的线性回归模型
class LinearRegressionModel(nn.Module):
    def __init__(self):
        super(LinearRegressionModel, self).__init__()
        self.linear = nn.Linear(1, 1)  # 输入特征维度1，输出特征维度1

    def forward(self, x):
        return self.linear(x)

model = LinearRegressionModel()

# 3. 定义损失函数和优化器
criterion = nn.MSELoss()  # 均方误差损失
optimizer = optim.SGD(model.parameters(), lr=0.01)  # 随机梯度下降优化器

# 4. 训练模型
epochs = 100  # 迭代次数
losses = []  # 记录损失

for epoch in range(epochs):
    model.train()  # 设置为训练模式
    optimizer.zero_grad()  # 清空梯度

    predictions = model(x)  # 模型预测
    loss = criterion(predictions, y)  # 计算损失
    loss.backward()  # 反向传播计算梯度
    optimizer.step()  # 更新模型参数

    losses.append(loss.item())  # 记录损失

    # 每100次输出一次训练信息
    if (epoch + 1) % 10 == 0:
        print(f"Epoch {epoch+1}/{epochs}, Loss: {loss.item():.4f}")

# 5. 可视化训练结果
# 绘制损失曲线
plt.figure(figsize=(10, 5))
plt.plot(range(epochs), losses)
plt.title("Loss Curve")
plt.xlabel("Epochs")
plt.ylabel("MSE Loss")
plt.show()

# 绘制预测结果
model.eval()  # 设置为评估模式
with torch.no_grad():
    predicted = model(x)  # 模型预测

plt.figure(figsize=(10, 5))
plt.scatter(x.numpy(), y.numpy(), label="Ground Truth")  # 原始数据
plt.plot(x.numpy(), predicted.numpy(), color="red", label="Predicted")  # 预测结果
plt.legend()
plt.title("Linear Regression Result")
plt.show()


损失曲线	预测结果

学习链接：详解使⽤pytorch实现线性回归

4. 机器学习基础知识

4.1 机器学习的目标

泛化：模型在未见过的数据上的表现。

4.1.1 ⽋拟合和过拟合

根据泛化的定义，我们希望模型在我们没有训练过的数据上也取得很好的效果，⽽不是只在训练集上有很好的效果。

欠拟合：模型在训练集和测试集上表现都很差。
过拟合：模型在训练集上表现很好，但在测试集上表现很差。

其实很好理解，训练开始时，模型还没有对训练数据中的所有相关模式建模。因此，模型在训练集和测试集上的表现都很差，这就是欠拟合。

训练到一定程度后，模型开始仅学习和训练数据有关的模式，并且开始学习训练数据中的噪声和细节，但对新数据而言，这些噪声和细节是不相关的。这就是过拟合。

4.1.2 嘈杂的训练数据

MNIST数据集中就有很多异常值。

如果模型将这些异常值(噪声)全部考虑进去，那么它的泛化性能将会下降

左边是稳健拟合，右边是过拟合

4.2 评估机器学习的性能

优化和泛化之间的矛盾，欠拟合和过拟合之间的矛盾

4.2.1 训练集、验证集和测试集

简单的留出验证
- 一般验证集占数据集的20%
K折交叉验证
- 有时候验证集很少，无法在统计学上代表数据

4.2.2 评估模型的注意事项

数据的代表性
数据冗余

4.3 改进模型拟合

调节关键梯度下降参数
- 学习率
- 批量大小
利用更好的模型架构
提高模型的容量(大小)

4.4 提高模型的泛化能力

数据集管理
提前终止，防止过拟合
模型正则化
- 缩减模型容量
- 权重正则化
- Dropout

5. 多层感知机（MLP）从入门到实践

在上⾯的线性神经⽹络中我们了解很多深度学习的概念，那现在我们要深⼊对于深度神经⽹络的探索。

5.1 隐藏层 (Hidden Layer)

隐藏层是神经⽹络的核⼼，它可以帮助我们学习⾮线性关系。

在线性⽹络中我们描述了仿射变换，这在深度学习种是⼀种线性变换，如果我们的输⼊输出满⾜线性关系，那么这样就⾜够了，但是线性是⼀个很强的假设；线性模型是很容易出错的，因为我们⽆法保证线性相关的关系。

举例：

我们尝试预测⼀个⼈是否会还贷，我们可以认为，在其他条件不变的情况下，收⼊较⾼的申请⼈⽐收⼊较低的申请⼈更有可能偿还贷款。但是，虽然收⼊与还款概率存在单调性，但它们不是线性相关的。收⼊从0增加到5万，可能⽐从100万增加到105万带来更⼤的还款可能性。
我们想要根据体温预测死亡率。对体温⾼于37摄⽒度的⼈来说，温度越⾼⻛险越⼤。然⽽，对体温低于37摄⽒度的⼈来说，温度越⾼⻛险就越低。

我们可以通过在⽹络中加⼊⼀个或多个隐藏层来克服线性模型的限制，使其能处理更普遍的函数关系类型。最简单的⽅法就是将多个全连接层连接到⼀起，这种架构通常称为多层感知机（multilayer perceptron），通常缩写为 MLP。

这是⼀个两层的⽹络
对于这种输入和输出的每个节点都相连的层，我们一般称为全连接层或稠密层
全连接层的开销⾮常⼤，需要权衡性能和参数规模

仿射变换=权重*参数+偏置

仿射变换的组合还是仿射变换

那么这个模型还是线性的，依然没有解决上述线性模型表达能⼒弱的问题，我们需要有⼀个函数使他变成⾮线性的：激活函数

如果没有激活函数，那么每个隐藏层仅仅只是⼀个仿射函数，与线性模型并⽆区别，为了避免多层感知机模型退化成线性模型，我们需要引⼊激活函数。

5.2 激活函数 (Activation Function)

激活函数引⼊⾮线性特性，使神经⽹络能够拟合复杂的函数。

常见激活函数

Sigmoid

$$ \sigma(x) = \frac{1}{1 + e^{-x}} $$

将输出映射到 (0, 1)，适⽤于概率预测。
容易引发梯度消失问题。

Tanh $$ \tanh(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}} $$
ReLU (Rectified Linear Unit)

$$ \text{ReLU}(x) = \max(0, x) $$

当输⼊为负时，ReLU函数的导数为0，⽽当输⼊为正时，ReLU函数的导数为1。
注意，当输⼊值精确等于0时，ReLU函数不可导。在此时，我们默认使⽤左侧的导数，即当输⼊为0时,导数为0。但我们可以忽略这个问题，在⼯程实际中，⼏乎是永远不可能为0的。

Softmax

$$ \text{Softmax}(x_i) = \frac{e^{x_i}}{\sum_{j=1}^n e^{x_j}} $$

⽤于多分类任务，将输出转化为概率分布。

5.3 softmax分类

softmax分类器是多分类问题中常用的分类器，它将输入的特征映射到一个概率分布，使得每个类别的概率之和为1。

现在经过上面三个公式（等于是三个单独的线性回归）的计算，我们已经得到了三个数；为了得到最后预测结果是啥，我们选择最大概率的标签为预测结果。

假设输出为0.1，0.8，0.1，那么我们预测的类别就是2

5.4 MLP实战——MNIST⼿写数字识别

MNIST数据集包含60,000个训练样本和10,000个测试样本，每个样本是一个28x28像素的灰度图像，表示一个手写数字（0-9）。目标是训练一个模型，能够准确地识别这些手写数字。

CSDN博客：keras⼊⻔实例(MNIST数字分类)

Pytorch加载数据集

import torch
from torchvision import datasets, transforms

# 数据预处理
transform = transforms.Compose([
    transforms.ToTensor(),  # 转为 PyTorch 的 Tensor 格式
    transforms.Normalize((0.5,), (0.5,))  # 对数据进行归一化，均值和标准差为 0.5
])

# 加载训练集和测试集
train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)

# 数据加载器
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)

print(f"训练集样本数: {len(train_dataset)}")
print(f"测试集样本数: {len(test_dataset)}")

神经网络可视化

5. Linux下配置深度学习环境

5.1 安装显卡驱动

强烈建议通过ubuntu22.04的官⽅GUI软件 软件和更新 安装显卡驱动。(Linux官⽅把nvidia驱动已经做的相当好了，安装起来也很⽅便。但是NVIDIA驱动其实还会有各式各样的BUG，包括Linux之⽗Linus Torvalds曾经说过的那样：“NVIDIA是最难伺候的硬件制造商，也是我们接触过最糟糕的公司，没有之⼀，~~SO NVIDIA FUCKNVIDIA YOU~~”.)

图标⻓这样(有时候它是灰⾊的),

安装成功后在终端使⽤nvidia-smi可以看到GPU信息，看到就算安装成功

nvidia-smi

这⾥显⽰的CUDA版本是最⾼⽀持版本，安装个⽐这低的就⾏(但是也不能太低，下⾯会讲)。

如果想要更改显卡驱动，也可以在这⾥改。

显卡驱动安装需要谨慎对待，尽量安装recommend版本，否则可能会导致ubuntu桌⾯不显⽰、开机不了、电脑副屏幕不显⽰等问题。

装错显卡驱动时，不到万不得已，不要使⽤sudo apt autoremove，这是下下策。

5.2 安装CUDA

显卡驱动版本和CUDA版本有⼀定的对应关系。

CUDA版本：CUDA Toolkit Archive

CUDA版本和驱动版本的对应关系可以看: 不同版本cuda对应的NVIDIA驱动版本

但是CUDA版本也不⼀定是越新越好，某些较新的CUDA版本可能没有pytorch的适配版本，所以安装时要注意。(这其实是配环境很常⻅的事情，不同软件由不同公司⼚家开发，进度各有快慢，版本兼容性也不⼀样，所以需要注意。)

不要下载deb格式的，下载runfile！！！！

Cuda的⼀个安装教程： https://yinguobing.com/install-cuda11-with-runfile/

nvcc -V

如果显⽰了这个代表安装成功。这⾥显⽰的CUDA版本是11.5，同学们也可以下载这个版本的CUDA。

5.3 安装Python环境

我们要使⽤pip⼯具安装深度学习的⼀些包，有numpy、tensorflow、keras、pytorch等

pip install numpy tensorflow keras torch torchvision -i https://pypi.tuna.tsinghua.edu.cn/simple

后⾯的 https://pypi.tuna.tsinghua.edu.cn/simple 是清华⼤学的镜像源地址，下载速度⽐较快。

如果不想安装tensorflow，可以只安装pytorch。把 tensorflow keras 去掉。

这⾥的安装命令是安装最新版本适配你电脑python环境的包，如果想安装特定版本的包，可以加上版本号。

如果发现还是下载不了，也可以在官⽹上找到你想要torch和torchvision的版本，然后⼿动下载安装。

官⽹下载：torch版本⼤全

然后使⽤pip安装。

pip install *.whl

最后，检查⼀下pytorch是否安装成功。是否能使⽤cuda。

python
import torch
torch.cuda.is_available()

如果能输出True，那么恭喜你安装成功。

5.4 安装Anaconda

Anaconda是⼀个python包管理虚拟环境（可装可不装，不过还是建议装上）

官⽹： https://zhuanlan.zhihu.com/p/459607806

可以参考的国内教程： https://zhuanlan.zhihu.com/p/459607806

官⽹安装教程： https://docs.anaconda.com/free/anaconda/install/linux/

因为ubuntu22.04默认安装了python3.10.7，正常就是ROS2 Humble需要的python版本，所以可以直接使⽤本机的python版本。

如果有需要使⽤某些Qt程序，⽐如PyQt5，可能需要利⽤Anacoda安装python的3.9版本才能使⽤Qt。正常使⽤时来回切换python版本即可。

conda create -n XXX python=3.9
conda activate XXX # 进入虚拟环境

conda deactivate # 退出虚拟环境

如果配置有困难的同学可以先使⽤Google Colab进⾏深度学习实验。但是配环境是每⼀个RoboMaster 视觉组新⼿⼩⽩都需要的基本能⼒，建议⼤家都掌握。

作业

重新实现课上的MNIST⼿写数字识别分类的例子。

要求：

使用PyTorch实现。
要求使用多层感知机MLP模型。
在Gitee中提交python代码或或ipynb文件和训练结果(曲线图)。

截止日期：12月7日（周六）

树莓派+Openwrt连接校园网，打破校园网设备限制

Wed, 17 Apr 2024 00:00:00 GMT

前言

因为本校学生校园网只允许最多三个设备登录，对于同时拥有多个联网设备的我十分不友好，而且大多单片机如esp32的wifi模块是只允许一般的WPA/WPA2认证的，是不支持校园网的portal认证。所以我决定搞一个路由器。

然后我上网买了一个TP-Link的路由器，首先尝试将插一根网线到宿舍座位上的墙口上，然后发现根本就没有网络(我们学校有的宿舍可以)。然后我尝试无线连接校园网，将路由器MAC改成了我连过校园网的手机/电脑的MAC，无果。于是最后我就决定自己用手头上的树莓派搭建一个软路由。

参考链接：https://www.bilibili.com/read/cv4211352/

准备工作

所需物资

树莓派4B(最好带散热器)
USB无线网卡一个
网线
sd卡与读卡器
路由器一个(可选，我用的是TP-Link)

烧录Openwrt

我采用的烧录软件是win32disk，上网下载树莓派4B的Openwrt的镜像文件。下面是文件链接:

https://openwrt.cc/releases/targets/bcm27xx/bcm2711/

下载这个然后解压，烧录，插入树莓派，开机。

正式开始

配置好Openwrt

首先，要插入准备好的USB无线网卡，然后连一根网线到树莓派和你的电脑(可以检查一下树莓派有线网口上的指示灯亮没亮)。

等待树莓派开好机后，在浏览器中输入192.168.1.1，输入默认密码password

点击网络--无线，然后点机你树莓派4B的无线网卡的扫描，找到校园网连接，后面的参数全是默认的，保存提交即可。

找到你的有线网卡，调成像我这样的Openwrt

重启树莓派，打开手机wifi，看看手机上能不能识别到Openwrt这个wifi,因为我这里已经弄好了，正常你们看到的Openwrt应该是不可上网

校园网认证

这是最重要的部分

用你电脑打开校园网认证地址，在这里我们要找到那个登录的请求URL。按下F12，复制下来你的请求URL

这里放个插曲(因为下面你可能会遇到)，如果你发现，校园网认证网址(比如这个https://portal.csu.edu.cn/)打开后，网页很快的就反应了无法连接，而校园网wifi是连接上的，多半是DNS解析出了错(原因暂时不知，推测是校园网发现了你是路由器)。把网址改成10.1.1.1我们直接替它DNS解析好。

现在让我们来分析一下这个URL，别的学校应该也差不多

我们需要关注的就这几个东西，这里的IP地址，就是校园网分配个你电脑的IP地址，我们用在树莓派上也是ok的，随机数感兴趣的话可以看看前端的js脚本是怎么写的，这里也不用管。把这这个url保存好，待会用。

SSH链接树莓派

在你电脑上cmd窗口输入

ssh root@192.168.1.1

连上校园网后，先ping一下portal.csu.edu.cn，发现ping不通，ping一下10.1.1.1，可以ping通，就是我上面说的那个DNS的问题。

C:\Users\LEGION>ssh root@192.168.1.1
/root/.zcompdump:145: unmatched '

# root @ OpenWrt in ~ [13:21:15]
$ ping portal.csu.edu.cn
ping: bad address 'portal.csu.edu.cn'

# root @ OpenWrt in ~ [13:21:27] C:1
$ ping 10.1.1.1
PING 10.1.1.1 (10.1.1.1): 56 data bytes
64 bytes from 10.1.1.1: seq=0 ttl=63 time=6.838 ms
64 bytes from 10.1.1.1: seq=1 ttl=63 time=5.550 ms
64 bytes from 10.1.1.1: seq=2 ttl=63 time=2.374 ms
64 bytes from 10.1.1.1: seq=3 ttl=63 time=4.579 ms
^C
--- 10.1.1.1 ping statistics ---
4 packets transmitted, 4 packets received, 0% packet loss
round-trip min/avg/max = 2.374/4.835/6.838 ms

然后用curl指令发送请求，-k是忽略不安全访问。

curl -k "你的请求URL"

如果成功了的话，通常会得到一个respond有认证成功的。如果不成功，就要自己找原因了。

在这次登录以后，校园网已经记住了树莓派的MAC。我就可以直接通过其他设备连接软路由WIFI，然后输入10.1.1.1就可以认证校园网了。

Openwrt计划任务

参考链接: https://blog.csdn.net/ET1131429439/article/details/128200042

你可以写个计划任务，让软路由自动登录校园网。也是上面的那个命令。

网络加速

这个是我用的USB无线网卡，能用但是很拉胯，通常使用来做实验用的。后面我给树莓派网线接上了一个TP-Link路由器，让路由器转发路由。这样我后来连接的都是路由器SSID名的WIFI，其实就等同于连接了Openwrt。

这是我后来的网速，勉勉强强

后记

也许有的同学觉得让手机连校园网再开热点，让电脑连校园网再开热点就行了。但是自己搓出来的软路由对我来说更有成就感(然后对比了一下同学的网速，自己的网速更快，成就感更高了)。此外软路由还有其他非常棒的用途(比如我给树莓派接了一个1TB的移动硬盘，下载易有云插件，就成为了一个小型的NAS主机)，请自行搜索。

每个人总要踏出自己的舒适圈，要积极尝试，然后用知识改变命运。

用手机NFC复制校园一卡通

Wed, 06 Sep 2023 00:00:00 GMT

前言

NFC是Near Field Communication缩写，即近距离无线通讯技术。

校园卡一般是感应式CPU卡，是一种加密卡。

如果只有一个带nfc功能的安卓手机，那么手机只能复制校园卡的第0块第0扇区，类似于nfc卡的卡号或者有点像是nfc的名字。

加密部分都不能被读取出来。一般关于钱的部分都被加密了。

所以想完完整整的复制校园卡需要自己在淘宝购买解码器，或者去校园外的锁业打听，一般锁业需要本人带着自己的饭卡和身份证才能帮你复制。

复制好了之后，原来的饭卡和复制出来的饭卡里面的钱可以通用，在一个卡里面花钱了，另一张卡里面钱就同步也减少了，极少部分学校的一卡通复制之后金钱不同步，如果遇到这个情况建议不要贪财，应该直接向有关部门反映，也贪不了多少钱，犯不上冒着被处分的风险钻这个漏洞。

如果不想这么麻烦，不想涉及到金钱，只想用手机nfc刷门禁的同学可以继续往下看！

小编是中南大学本科生。就以中南大学校园卡来举例。

本文参考资料：https://www.zhihu.com/question/308487617/answer/1753667726

入门教程 —— 直接利用手机NFC创建虚拟校园卡

手机只能复制校园卡的第0块第0扇区，而一般的门禁也基本上只读取校园卡的第0块第0扇区，所以手机自带的nfc可以刷开学校的门禁。

小编用的是华为 Hi nova 9 Pro 的手机，在手机可以找到华为手机自带的应用“钱包”，打开后点击卡包，点击右上角的加号“➕”，选择钥匙，选择门禁卡。

然后“模拟实体门禁卡”即可复制校园卡，注意这里并不能复制校园卡中饭卡和水卡涉及金额的部分，这些都是有加密的。

如果你还有华为手表的话，一般能用蓝牙和手机连接的华为手表也可以复制校园卡门禁。(^_^)

基础教程 —— 将校园卡0扇区序列号复制到CUID卡中

这种方法和上面手机类似，这个方法是将0扇区的信息复制到我们平常用的那种小蓝色门禁钥匙里。

准备工作

没有安卓手机的同学借一个带nfc功能的安卓手机，需要下载一个app，名字是mifare classic tool，应用商店可能没有这个app，大家百度一下这个名字会有很多网站分享这个软件的安装包，下载好软件安装包后，发送到安卓手机上面，直接安装到手机上即可。
淘宝随便买几张CUID卡(注意一定是CUID卡)。这里我要多说几句，我在大一时玩嵌入式开发，那个arduino套装中RC522模块中自带的一张白卡和小蓝钥匙是IC卡，不是CUID卡。IC卡的0扇区是不可擦写的。关于IC，ID，UID，FUID，CUID，CPU卡的区别，请移步到这里知乎https://zhuanlan.zhihu.com/p/351266514。

正式开始

打开app

选择“读标签”,全选密钥文件，将校园卡放在手机下(手机NFC一般是在摄像头附近)，调整好位置，发现屏幕底下显示了卡片的序列号，拿笔记下你的序列号，这个序列号是非常重要的，然后点击“开始映射并读取标签”。

如果这里因为标签失连(可能是因为加密卡的原因)读取中途失败也没有关系，退出来点击“写标签”。点击“克隆UID”，“打开UID克隆工具”，勾选“显示选项”，看到里面的块0的其余部分和块0的写密码。

接下来详细讲一下写标签的两种方法：

用刚刚读标签的方法，再对你的CUID卡用一次，观察读取的标签。

可以观察到，最上面一排紫色的是UID和厂家信息，密钥A和密钥B分别是其下面的绿色的和深绿色的，看扇区0就好。

记下密钥，填写到克隆UID那里，把CUID卡放好，然后点击“计算块0并克隆UID”，火速搞定。

直接写块。

这里的数据就就要想想了，这里要求填16字节，一个字节就是两位16进制，所以要填写32个16进制数。可是刚刚数了一数那个块0剩余部分只有22位，加上8位序列数就是30位，还差2位什么？

通过查阅资料知道0扇区0块是这种构成。

在序列号和厂商信息之间夹有一个校验数，通常是序列号的异或值，这里我们可以偷懒用MCT这个软件工具里的BCC计算器来输入序列号算校验数。

然后就凑齐了32位，一顿输出即可。

全选密钥文件，这里的密钥文件就有很多密钥，几乎可以涵盖所有情况。

大功告成！

进阶教程 —— CUID+PCB升级校园卡

这个部分就有点难了，请各位看情况自行撤退。

小编采用嘉立创EDA画板子。上淘宝买到cuid的芯片(不是卡了)，和0603LED灯珠。

这个线圈是画在PCB板子里面，然后并联几个0603灯珠，焊上CUID芯片，就OK了

开源链接https://oshwhub.com/heiliheili/qi-sheng-shao-huan-fan-ka-DIY

也给原作者点个赞吧，我修改了一下打印了出来。

然后就可以带着这张卡去学校教室打卡机面前社死装逼了

后记

另外，还可以在安卓手机上下载个NFC Tools Pro这个软件，将你想存入的信息写如到上面的卡中，比如我把我的个人博客网址写进卡中https://wangchuanfu294.github.io/，这样别人用手机NFC一扫就可以打开了。

最后，本项目以学习为目的，请勿用于其他用途，还请各位同学们保管好自己的校园卡哟。

日月星辰の个人博客

超实用,不踩坑! Nano Pi R4S安装Openwrt教程

超实用,不踩坑! Nano Pi R4S安装Openwrt教程

一、前言

二、准备工作

三、安装Openwrt——ImmortalWrt固件系统

安装配套散热风扇 (可选)

构建需要安装的镜像

overlay分区扩容

开机打开web管理界面

设置风扇开启自转脚本

四、安装软件包

安装openclash

配置filebrowser

五、系统配置总览

硬件与系统

目前安装的常用软件包

六、Docker 实战：把服务都装进容器

部署一个容器（以 Vaultwarden 为例）

七、开机自启动

风扇固定转速

开机自动启动所有 Docker 容器

八、内网穿透全家桶

服务列表一览

九、总结

【开源】Groot2风格行为树可视化监控软件，能展示20个节点以上

前言

项目效果

核心能力

1. Groot2 协议兼容

2. 大节点量可视化

3. 桌面应用 + Web 前端的混合架构

架构设计

项目结构

快速开始

环境

安装依赖

本地运行

构建发布

下载使用

结语

解决ubuntu系统外界显示器卡顿掉帧率问题

rm软件组客户端开发快速引导

rm软件组

我们的任务

自定义客户端要有多自定义

我们为什么使用Unity游戏引擎来开发

什么人推荐加入rm软件组

快速开始

环境配置

Unity配置

Vscode 配置

制作第一款2D平台跳跃游戏

Mock调试

SharkDataSever开源

我们自己的rm_mock仓库

Protocol Buffers 入门

Unity 与 mqtt protobuf

方法一：使用Nuget包管理工具安装dll库 (⭐推荐)

方法二：第三方安装

官方项目解包

正式开发

前置知识

UI Toolkit

示例：编写第一个页面 开始界面

MQTT通信

示例：编写第一个MQTT接口 GameStatus

UDP 图传视频流

FFmpeg

UDP

Unity ai with yolov5

注意事项

vscode插件推荐

计算机视觉深度学习入门

前言

1. 计算机视觉深度学习入门

1.1 从认识一个卷积神经网络(CNN)开始

1.1.1 卷积运算

1.1.2 图像卷积

1.1.3 一个特殊的卷积核 1x1卷积

示例：编写第一个页面开始界面