算法与程序开发到一定程度后，需要发布初版产品供用户测试。其中部署算法时用到了 RDKx3 等嵌入式 Linux 开发板，如果逐一烧录并配置，效率过低。因此需要先定制好镜像，烧录后可以直接运行。

基础

对于树莓派之类的开发板，支持的镜像较多，常见的 如 rpiOS，ubuntu，archlinux 等均可，只需要下载对应架构的磁盘映像，就可以在此基础上进行编辑。

对于 RDK 系列，rk 系列等，程序需要使用板子附带的加速单元用来加速数据处理等，我们需要下载官方的系统磁盘映像进行定制。

我们使用 RDKx3，因此从 D-Robotics 下载系统镜像

下载下来后一般是一个 img.xz 的文件。

配置并挂载到主机

解压镜像

使用 xz 解压镜像，得到 img文件

1
2
3

mkdir -pv ~/workspace/packimg
cd ~/workspace/packimg
xz -d rdk.img.xz

映像扩容

官方提供的 img 镜像的大小恰好是系统所需的大小，直接挂载后修改，可能会遇到空间不足的问题，因此挂载之前需要先进行扩容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 添加 4G 到镜像文件
dd if=/dev/zero bs=1M count=4096 >> rdk.img

# 把根分区扩容
sudo parted rdk.img resizepart 2 100%

# 此时文件系统不知扩容，需要设置
# 先设置回环设备
sudo losetup -Pf --show rdk.img

# 检查根分区的文件系统
sudo e2fsck -f /dev/loop0p2

# 修改文件系统大小
sudo resize2fs /dev/loop0p2

挂载镜像

首先使用 fdisk 查看 rootfs， 将其挂载到主机，一般是更大的那个分区。假设是第二个分区

1

fdisk -l rdk.img

挂载回环设备（如果扩容时挂载，就不需要再次挂载）

1

sudo losetup -Pf rdk.img

挂载对应分区

1
2
3
4
5
6
7
8
9
10
11

mkdir -pv rootfs
sudo mount /dev/loop0p2 rootfs

# 挂载虚拟文件系统
sudo mount --bind /dev ./rootfs/dev
sudo mount --bind /proc ./rootfs/proc
sudo mount --bind /sys ./rootfs/sys
sudo mount --bind /dev/pts ./rootfs/dev/pts

# 如果需要修改启动的文件，可以把 boot 分区也挂载
sudo mount /dev/loop0p1 rootfs/boot/config

设置网络

/etc/resolv.conf 一般情况是指向/run/systemd/resolve/stub-resolv.conf 的软链接，由于我们后面使用 chroot 进入系统，没有运行 systemd， 因此没有这个源文件。需要手动设置

1
2

sudo mv rootfs/etc/resolv.conf{,.bak} # 备份原始链接
sudo cp /etc/resolv.conf rootfs/etc/resolv.conf # 复制主机DNS配置

QEMU 跨架构模拟器

由于板子是 arm64 ，主机是 x86_64， 因此 rootfs 中的程序不能直接运行，需要在主机安装 qemu 来运行

1
2

yay -S qemu-user-static
sudo cp /usr/bin/qemu-aarch64-static rootfs/usr/bin

进入系统

使用 chroot 进入系统

1

sudo chroot ./rootfs /bin/bash

设置系统

用户设置

创建用户

生产环境最好不要使用 root 用户，为了安全，也不要使用官方自带的用户。可以自己创建一个普通用户，并禁用 root 用户

1
2
3

/sbin/useradd -m -s /bin/bash newuser
/sbin/usermod -aG sudo newuser
echo "newuser:newpassword" | chpasswd

因为 useradd 命令在 /sbin，chroot 可能没有将其加入 PATH， 因此可以设置 PATH 或写完整路径。

SSH 设置

因为产品涉及网络服务，所以禁用密码登录，防止破解登入。在主机运行命令创建密钥并上传到客户机

1
2
3
4

mkdir -pv keys
ssh-keygen -t ed25519 -f ~/keys/prodimg_newuser
sudo mkdir -p rootfs/home/newuser/.ssh
cat ./keys/prodimg_newuser.pub | sudo tee rootfs/home/newuser/.ssh/authorized_keys

如果已经有了密钥，可以直接上传：

1
2

sudo mkdir -p rootfs/home/newuser/.ssh
echo "pub key" | sudo tee rootfs/home/newuser/.ssh/authorized_keys

之后在客户机中设置权限：

1
2
3
4
5
6
7
8
9
10

chown -R newuser:newuser /home/newuser/.ssh
chmod 700 /home/newuser/.ssh
chmod 600 /home/newuser/.ssh/authorized_keys

# 修改 SSH 配置 (禁用密码登录)
sed -i 's/#PasswordAuthentication yes/PasswordAuthentication no/' /etc/ssh/sshd_config
sed -i 's/PermitRootLogin yes/PermitRootLogin no/' /etc/ssh/sshd_config

# 禁用 root 密码 (锁定 root)
passwd -l root

部署程序

主程序

此步骤没有什么特殊的，使用 apt 和 pip 安装依赖，把代码/程序复制到客户机中。注意需要设置对应的权限，以便普通用户可以直接运行。

系统服务

把service文件上传，设置权限，并激活之

1
2

cp my_service.service /etc/systemd/system
systemctl enable my_service

测试

程序部署完成后，可以在 chroot 环境中直接再次测试，确保直接运行无虞

配网

本项目中，需要 RDK 创建 AP 热点，供其他模块连接通信并管理，所以需要创建配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

cat >> /etc/NetworkManager/system-connections/Hotspot.nmconnection << EOF
[connection]
id=Hotspot
uuid=aeefcaeb-f129-48cc-807a-d1150369246e
type=wifi
interface-name=wlan0
timestamp=1700600248

[wifi]
hidden=false
mode=ap
ssid=MyWifi

[wifi-security]
group=ccmp;
key-mgmt=wpa-psk
pairwise=ccmp;
proto=rsn;
psk=myappassword

[ipv4]
address1=192.168.179.1/24
method=shared

[ipv6]
addr-gen-mode=stable-privacy
method=ignore

[proxy]

EOF

sudo chmod 600 Hotspot.nmconnection
```

这个文件保险起见，可以不手写，而是从已经配置好的开发机上复制出来。

其他工作

如果程序的相关运行还需要其他配置，例如蓝牙设置等，可以继续进行设置

重新打包

清理空间

配置过程中安装的依赖、编译文件、临时文件、索引、缓存等，会占用大量空间，因此需要清理后再重新打包

1
2
3
4
5
6
7
8
9
10
11
12
13

# 先清理apt缓存等所有不需要使用的内容，如果使用了 pip 等包管理器安装了，也要清理对应的缓存
apt clean 
rm -rf /var/lib/apt/lists/*
rm /usr/bin/qemu-aarch64-static

# 把所有清理掉的空间填入 0, 这样 xz 会压缩掉这些区域
# 此处报错 `cat: 写入错误: 设备上没有空间` 是正常的，就是要全部填 0
cat /dev/zero > /zero.fill; sync; sleep 1; rm /zero.fill

exit # 退出 chroot

# 恢复原始的 DNS 配置文件
sudo mv rootfs/etc/resolv.conf{.bak,}

清理挂载

把所有的挂载点和回环设备卸载

1
2
3
4
5
6
7

sudo umount -l ./rootfs/dev/pts
sudo umount -l ./rootfs/dev
sudo umount -l ./rootfs/proc
sudo umount -l ./rootfs/sys
sudo umount -l ./rootfs

sudo losetup -d /dev/loop0

重新压缩镜像

1
2

# -9 最大压缩，-T0 多线程
xz -z -9 -T0 rdk.img

命名并上传

此部分只是这个项目的命名格式，仅供参考

文件命名

命名格式

rdk_x3-os_3.0.3-api_v1.2-inferer_v1.4-py-arm64.img.xz

其中需要体现信息：

• 适用平台：

  • rdk_x3
  • rdk_x5
  • raspi4b
  • …

• 基于官方系统的版本：os_x.x.x

• 运行的推理服务的版本： api_v1.2

• 运行的推理程序的版本：

  最终的推理程序主要用 C++ 改写，因此C++版本不带后缀，Python 版本需要后缀

  • inferer_v1.4-py：Python 推理程序
  • inferer_v1.0 : C++ 推理程序

• 系统架构：arm64

不同信息之间使用 hyphen - 连接，一个信息内部使用下划线 _

存放目录

镜像如果需要放在服务器上发布，供开发人员随时升降级，则下载中心的文件夹结构可以参考

1
2
3
4
5
6
7
8

/home/neolux/Cloud/olist_local/personal/ms365/e3/nlx.m3/projets/pseudomano/
├── os_images
│   └── rdk_x3
│       └── rdk_os_3.0.3-api_v1.2-inferer_v1.0-py-2026-03-26
│       ├── rdk_x3-os_3.0.3-api_v1.2-inferer_v1.0-py_arm64.img.xz
│       └── rdk_x3-os_3.0.3-api_v1.2-inferer_v1.0-py_arm64.img.xz.md5sum
│   └── rdk_x5
│       └── ...

烧录系统

SD Card

1
2
3
4
5
6
7

# xzcat 用来提取数据
# pv 展示进度
# dd 烧录
xzcat rdk-x3-ubuntu22-preinstalled-server-3.0.3-arm64.img.xz | pv | sudo dd of=/dev/sdb bs=4M

# 或者直接使用 dd 的进度展示
# xzcat rdk-x3-ubuntu22-preinstalled-server-3.0.3-arm64.img.xz | sudo dd of=/dev/sdb bs=4M status=progress

eMMC

参考官方文档 from d-robotiques: 1.2.1 RDK X3 | RDK DOC

远程登入

1
2

nmcli dev wifi connect MyWifi password myappassword
ssh -i ~/.ssh/id_ed25519_newuser newuser@192.168.179.1

刷机

下载刷机包

Google 原生 Android 下载地址

根据 Pixel 设备类型下载对应的 OTA 包

其他第三方下载类似，例如 LineageOS, GrapheneOS 等

解压

1
2

unzip panther-bp4a.251205.006-factory-4455f800.zip
cd panther-bp4a.251205.006

刷入完整系统

手机重启到 fastboot 模式，运行命令

1
2

adb reboot fastboot
./flash-all.sh

刷入后会自动重启

Root

首先获取 boot.img/init_boot.img

Android 12 以上使用的是 init_boot.img

可以直接通过系统镜像解压得到 init_boot.img，将其推送到手机（手机打开USB调试）

1
2

unzip image-panther-bp4a.251205.006.zip
adb push init_boot.img /sdcard/Download

然后下载一个 SU 管理器，例如

• Magisk
• KernelSU
• SukiSU

把管理器安装到手机

1

adb install KernelSu.apk

修补 boot.img/init_boot.img

在手机打开 KernelSU 软件，点击修补镜像，选中推送的镜像文件，开始修补

然后把修补好的镜像传到电脑

1

adb pull /sdcard/kernelsu-xxxxx.img .

然后重启到 fastboot 模式，刷入镜像后重启

1
2
3
4

adb reboot fastboot
fastboot flash init_boot kernelsu-xxxxx.img
fastboot flash init_boot_b kernelsu-xxxxx.img
fastboot reboot

重启后打开管理器，可以看到已经 root

嵌入式 Linux 开发板性能有限，于是在电脑配置交叉编译环境，编译出 ARM 架构的软件

但是对于 C++ 此类依赖系统 glibc、stdc++ 的项目，电脑直接配置需要整理 glibc、stdc++版本，否则即便编译成功也不能正常运行。因此记录一下直接使用官方镜像配置交叉编译环境，不需再关心版本问题。

本文使用 Docker 进行配置，也可使用 QEMU 配置

准备工作

需要准备以下文件：

1. raspberry pi 镜像/RDK镜像/……

需要安装以下环境

• Windows

  1. WSL
  2. Docker

• Linux

  1. Docker

配置 Docker

为 Docker 添加跨架构支持

1

docker run --rm --privileged tonistiigi/binfmt --install all

检查支持的架构

1

docker buildx ls | grep arm64

1

\_ default    \_ default       running   v0.0.0+unknown   linux/amd64 (+3), linux/arm64, linux/arm (+2), linux/ppc64le, (6 more)

打包镜像

查看镜像文件的分区

1

fdisk -l rdk-x3-ubuntu22-preinstalled-server-3.0.3-arm64.img

输出为

1
2
3
4
5
6
7
8
9
10

Disk rdk-x3-ubuntu22-preinstalled-server-3.0.3-arm64.img：7.19 GiB，7721713664 字节，15081472 个扇区
单元：扇区 / 1 * 512 = 512 字节
扇区大小(逻辑/物理)：512 字节 / 512 字节
I/O 大小(最小/最佳)：512 字节 / 512 字节
磁盘标签类型：dos
磁盘标识符：0xffc5da1c

设备                                                 启动   起点     末尾     扇区  大小 Id 类型
rdk-x3-ubuntu22-preinstalled-server-3.0.3-arm64.img1        8192   532479   524288  256M  c W95 FAT3
rdk-x3-ubuntu22-preinstalled-server-3.0.3-arm64.img2 *    532480 15081471 14548992  6.9G 83 Linux

其中类型为 Linux 的分区，是根分区，将其挂载到一个目录

1
2

sudo mkdir -pv /mnt/rdkx3_img
sudo mount -o loop,offset=$((512*532480)) rdk-x3-ubuntu22-preinstalled-server-3.0.3-arm64.img /mnt/rdkx3_img

然后把所有文件打包成一个 docker 镜像

1

sudo tar -C /mnt/rdkx3_img -c . | docker import --platform linux/arm64 - rdkx3-img:3.0.3

完成

检查测试

检查 docker 镜像存在

1

docker image ls

1
2
3
4
5

                                                                               i Info →   U  In Use
IMAGE                                               ID             DISK USAGE   CONTENT SIZE   EXTRA
moby/buildkit:buildx-stable-1                       fe0990fb85c4        227MB             0B
rdkx3-img:3.0.3                                     b1ab55e333ab       5.97GB             0B
tonistiigi/binfmt:latest                            6989522fc1e3       83.3MB             0B

交互模式运行之

1
2
3

docker run -it --platform linux/arm64 rdkx3-img:3.0.3 /bin/bash
root@784c454554d8:/# arch
aarch64

在此 Docker 容器中编译完成的包、可执行文件，可以直接复制到板子上运行

Code

For

For account-password-needed-only systems. Exempli gratia CJLU

Usage

1. Visit gateway website to login

2. F12 to open console, and switch to network page. clear all and refresh the page

   

3. Manually login with a wrong account-password (to have a easier test later without logout) A login request should occur in network page. Open it and check the header

   

4. Copy as cURL. And paste into the bash script, edit account and password.

   

   

5. Edit script path in school_net_web_login.service; Edit crontab config, run every 3 hour by default

6. Run bash script to login and enable systemd service and crontab task.

OpenWRT config

1. After editing script with your own cURL command, upload the script to the router

   1	scp /path/to/script root@ip.to.your.router:~/web_login.bash

2. Login to the dashboard of OpenWRT

3. Add crontab task

   

   1	00 */3 * * * /root/web_login.bash > /tmp/web_login_$(date --iso-8601=seconds).log

4. Add task on boot

   

5. Reboot the router or manually run script via SSH

前端时间在 Windows 11 中给我的三星手机平板刷港版系统，由于长时间不登入 Windows 系统，系统积攒了许多更新，Windows 更新完之后，重启发现 Windows 又变成了 EFI Boot 的第一启动条目，原来的 grub 启动条目不见了。

直接从硬盘上的另一个 EFI 条目启动，没有展示 grub 界面，而是直接进入了 grub rescue 的 shell,同时报错：

1

error: unknown filesystem

由于以往已经有了这种经验，于是尝试手动加载内核进行启动：

1
2
3
4
5

ls 
(hd0) (hd0,gpt1)...
# 由于启动分区 (hd1,gpt6), 于是
ls (hd1,gpt6)
error: unknown filesystem

这时，发现除了 EFI 分区的 FAT32 格式以外，所有分区均报这个错误。于是只能进入 Arch Live CD, 重新运行 grub-install

1
2
3
4
5
6
7

rmmod pcspkr # 主板声音打扰别人，吓到自己
mount ... # 挂载系统的各个分区
arch-chroot /mnt # 进入系统
grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=archlinux
grub-mkconfig -o /boot/grub/grub.cfg
exit
reboot

重启后正常恢复

最近老师购入一台工作站，老师要做一些分子动力学的仿真计算和深度学习，同时老师要我做这台机器的管理员，我自己可以在上面做一些我比较有兴趣的工作，比如灵巧手和机器人相关的仿真强化学习，或者一些用于当前项目的深度学习工作。因为老师用的 Ansys 和我使用的 SolidWorks、AutoDesk 等软件只有Windows版本，而做分子动力学的 VASP 又只有 Linux 版本，所以购买的工作站就安装了双系统。同时，为了能够尽可能地使机器长时间开机，便于远程连接或长时间计算，我决定在Linux中通过 KVM 和 QEMU 启动硬盘中的Windows, 以此实现Windows和Linux两个系统的软件能够同时使用。

设备配置

• CPU：单颗 Intel Xeon Scalable Platinum 8488C CPU,最新 Products
  formerly Sapphire Rapids 架构,共48个计算物理核心，96个线程
• RAM：三星服务器 128G DDR5 ECC 5600 GHZRegistered Shared Memory
• GPU：NVIDIA RTX5090 32G显存
• 硬盘：1块1TB，一块8TB

双系统安装

工作站发来前，已经由厂家安装了 Windows10 和提前列出的Windows平台软件，所以我们只需要安装 Linux 即可。本来我的计划是安装 Ubuntu22，但是最终还是选择了更加熟悉的 ArchLinux。因为厂家已经安装了Windows平台的一些软件，为了方便，我们就不删掉他们，而是直接在QEMU里面加载Windows。

KVM

基于内核的虚拟机（英语：Kernel-based Virtual Machine，缩写为KVM）是一种用于Linux内核中的虚拟化基础设施，可将Linux内核转化为一个虚拟机监视器。KVM于2007年2月5日被并入Linux 2.6.20核心中。KVM需要支持硬件虚拟化拓展特性的处理器。

详细介绍可以参考 Wikipedia/KVM

Linux系统启动后，查看设备可以看到有一个 kvm 设备：

为了能够让当前用户使用 kvm，需要将当前用户添加进 kvm 组

1
2
3
4

sudo usermod -aG kvm $(whoami)
# 注销后重新登入
id # 输出如下
uid=1000(username) gid=1000(username) groups=1000(username),967(docker),992(kvm),998(wheel)

QEMU

Installation

QEMU（Quick Emulator）是一款免费开源模拟器，由法布里斯·贝拉（Fabrice Bellard）等人编写。其与Bochs，PearPC类似，但拥有高速（配合KVM）、跨平台的特性。

详细介绍可查看 Wikipedia/QEMU

Arch Linux 安装 QEMU 命令：

1
2

paru extra/qemu-full -S # 完整安装
paru extra/edk2-ovmf -S # UEFI 固件，支持安全启动

直接安装全部软件包即可

Configuration

由于默认 QEMU 连接的是用户模式的机器，而我们把Windows运行在系统层级，以便所有用户均可访问，所以需要配置一下，让用户能够默认访问系统的 QEMU

1
2
3
4

mkdir -pv ${HOME}/.config/libvirt/
cat >> ${HOME}/.config/libvirt/libvirt.conf << EOF
uri_default = "qemu:///system"
EOF

Libvirt

Installation

libvirt是一套用于管理硬件虚拟化的开源API、守护进程与管理工具。[3]此套组可用于管理KVM、Xen、VMware ESXi、QEMU及其他虚拟化技术。libvirt内置的API广泛用于云解决方案开发中的虚拟机监视器编排层（Orchestration Layer）。

安装命令：

1
2

paru extra/libvirt -S # 安装 libvirt, 此时已经可以使用
paru extra/virt-manager -S # 这是一个图形化的 libvirt 管理工具，在配置初期是需要的

Configuration

需要把用户添加进 libvirt 组，同时启动 libvirtd 系统服务：

1
2

sudo systemctl enable --now libvirtd # 启动系统服务
sudo usermod -aG libvirt $(whoami) # 把用户添加入 libvirt 组

只有配置的管理员用户需要添加到 libvirt 组，最终连接的其他普通用户不需要添加到该组。

准备工作

Windows 10 ISO

为了防止虚拟机出现问题，损坏Windows的启动，我们在虚拟机中不使用 Windows 的 EFI, 只使用Windows的C，D盘，并重新生成一个新的 EFI 用于在虚拟机中启动 Windows。

这个新的 EFI 需要使用 Windows 的一个工具生成，该工具在 Windows ISO 中有，所以我们从 Windows 网站下载一个 Windows 10 的启动镜像。

下载地址

硬盘线性阵列排布

介绍

由于Arch Linux 安装时，在 1T 的硬盘分出一个分区用来安装系统，从 8T 硬盘分出一个分区用来存储软件、数据和用户目录，而同一块设备只能有一方在使用，因此我们需要手动重新排列分区，以分离各个分区，防止两方共同使用同一设备。我们可以使用 losetup 和 mdadm 重新排列硬盘分区成一个虚拟设备，并让虚拟机使用这个虚拟设备进行启动。

losetup命令用来设置循环设备，查看回环设备的状态。循环设备可把文件虚拟成区块设备，籍以模拟整个文件系统，让用户得以将其视为硬盘驱动器，光驱或软驱等设备，并挂入当作目录来使用。
原文链接：https://www.linuxcool.com/losetup

mdadm命令来自英文词组multiple devices admin的缩写，其功能是管理RAID设备。作为Linux系统下软RAID设备的管理神器，mdadm命令可以进行创建、调整、监控、删除等全套管理操作。
原文链接：https://www.linuxcool.com/mdadm

原始的硬盘排布为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

sudo fdisk -l /dev/nvme0n1 /dev/sda    
Disk /dev/nvme0n1: 931.51 GiB, 1000204886016 bytes, 1953525168 sectors
Disk model: Samsung SSD 980 1TB                     
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 16384 bytes / 131072 bytes
Disklabel type: gpt
Disk identifier: 5E0BA9DE-7C92-478F-ADE5-F178A7B6506B

Device              Start        End    Sectors   Size Type
/dev/nvme0n1p1       2048     206847     204800   100M EFI System
/dev/nvme0n1p2     206848     239615      32768    16M Microsoft reserved
/dev/nvme0n1p3     239616 1322747224 1322507609 630.6G Microsoft basic data
/dev/nvme0n1p4 1951893504 1953521663    1628160   795M Windows recovery environment
/dev/nvme0n1p5 1322747904 1323747327     999424   488M EFI System
/dev/nvme0n1p6 1323747328 1325893631    2146304     1G EFI System
/dev/nvme0n1p7 1325893632 1951893503  625999872 298.5G Linux root (x86-64)

Partition table entries are not in disk order.


Disk /dev/sda: 7.28 TiB, 8001563222016 bytes, 15628053168 sectors
Disk model: HGST HUS728T8TAL
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes
Disklabel type: gpt
Disk identifier: DAB5F193-5F0A-4513-AE7C-FC6AC785D92D

Device           Start         End    Sectors  Size Type
/dev/sda1           34       32767      32734   16M Microsoft reserved
/dev/sda2        32768  4890632191 4890599424  2.3T Microsoft basic data
/dev/sda3   4890632192 11333083135 6442450944    3T Linux filesystem
/dev/sda4  11333083136 15628053134 4294969999    2T Linux filesystem

Partition 1 does not start on physical sector boundary.

其中 /dev/nvme0n1p1 是 Windows 实际的 EFI 分区，我们保留不动，防止操作失误而导致无法启动。/dev/nvme0n1p3 是Windows的 C盘，/dev/sda2 是 Windows 的D盘。

根据 GPT 分区规范，我们可以创建一个新的线性阵列作为虚拟设备

但是！！！ 沟槽的厂家给 8T 硬盘第一个分区没有对齐扇区！！！

这种情况会导致后面分区工具自动计算比较麻烦，一般分区工具像是cfdisk会自动对齐扇区，导致我们线性阵列分区与实际分区的扇区错位，导致分区不可挂载。所以我们最终实际建立的线性阵列为

图中，C盘D盘以外的区域均为我们自己创建的全新的扇区。

准备扇区

假设qemu虚拟机的名称为 windows10，为了方便管理，我们把所有相关文件放在机器的文件夹中。首先创建文件夹

1
2
3
4

mkdir -pv /etc/libvirt/hooks/qemu.d/windows10/
cd /etc/libvirt/hooks/qemu.d/windows10/
mkdir -pv md0 md1 # for /dev/md0 and /dev/md1
cd md0 # 本文只写了 /dev/md0, /dev/md1 同样的流程

有上图，我们可以计算 Windows 的 EFI 分区和 GPT 分区表保留的分区共101M，C盘后面也应该留1M保留分区，于是我们可以使用 dd 创建这些扇区：

1
2
3

sudo dd if=/dev/zero of=loop-efi0 bs=1M count=101 # 前面的
sudo dd if=/dev/zero of=loop-efi1 bs=1M count=1   # 后面的
ls -lah

输出应该为

1
2
3
4
5
6
7
8
9
10
11

101+0 records in
101+0 records out
105906176 bytes (106 MB, 101 MiB) copied, 0.0641618 s, 1.7 GB/s
1+0 records in
1+0 records out
1048576 bytes (1.0 MB, 1.0 MiB) copied, 0.00157278 s, 667 MB/s
total 102M
drwxr-xr-x 1 root root   36 Jun 20 01:04 .
drwxr-xr-x 1 root root   80 Jun 20 01:00 ..
-rw-r--r-- 1 root root 101M Jun 20 01:04 loop-efi0
-rw-r--r-- 1 root root 1.0M Jun 20 01:04 loop-efi1

创建启动线性阵列的脚本 start-md0.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

cat << EOF | sudo tee start-md0.sh > /dev/null
#!/usr/bin/env bash

WIN_PART=/dev/nvme0n1p3 # Windows C盘设备
EFI_DIR="\$(cd "\$(dirname "\${BASH_SOURCE[0]}")" && pwd)" # 获取到这个脚本的路径
VDEV=/dev/md0 # 要创建的路径，应该符合 POSIX 规范，以数字结尾

# 检查是否已经运行了该脚本
if [[ -e \$VDEV ]]; then
        echo "\$VDEV already exists" > /dev/kmsg 2>&1
        exit 1
fi

# 检查 Windows 分区是否被mount，防止被两方同时使用
if mountpoint -q -- "\$WIN_PART"; then
        echo "Unmounting \$WIN_PART..." > /dev/kmsg 2>&1
        umount \$WIN_PART
fi

modprobe loop
modprobe linear
eval "EFI_DIR=\$EFI_DIR" # 立即解析路径变量
LOOP0=\$(losetup -f "\$EFI_DIR/loop-efi0" --show) # 1M Reserved
LOOP1=\$(losetup -f "\$EFI_DIR/loop-efi1" --show) # 1M reserved
mdadm --build --verbose \$VDEV --chunk=512 --level=linear --raid-devices=3 \$LOOP0 \$WIN_PART \$LOOP1 
chown \$USER:disk \$VDEV
echo "\$LOOP0 \$LOOP1" > "\$EFI_DIR/.win10-loop-devices"
EOF

sudo chmod +x ./start-md0.sh # 加权限
sudo ./start-md0.sh # 测试
ls /dev/md*

输出应该是

1
2

mdadm: array /dev/md0 built and started.
/dev/md0

再创建一个脚本用来停止线性阵列：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

cat << EOF | sudo tee stop-md0.sh > /dev/null
#!/usr/bin/env bash

EFI_DIR="\$(cd "\$(dirname "\${BASH_SOURCE[0]}")" && pwd)"
VDEV=/dev/md0

# 停止 RAID 设备
if [[ -e "\$VDEV" ]]; then
    mdadm --stop "\$VDEV"
else
    echo "Device \$VDEV not found. Maybe it's already stopped."
fi

# 卸载 loop 设备
LOOP_DEV_FILE="\$EFI_DIR/.win10-loop-devices"
if [[ -f "\$LOOP_DEV_FILE" ]]; then
    xargs -r losetup -d < "\$LOOP_DEV_FILE"
    rm -f "\$LOOP_DEV_FILE"
else
    echo "Loop device list \$LOOP_DEV_FILE not found."
fi
EOF

sudo chmod +x ./stop-md0.sh # 加权限
sudo ./stop-md0.sh # 测试
ls /dev/md* # 应该不会输出任何东西

输出应该是

1
2

mdadm: stopped /dev/md0
zsh: no matches found: /dev/md*

此时，我们需要参照 fdisk 输出的扇区信息，对 /dev/md0 进行分区

1
2
3
4
5
6
7
8
9
10
11
12
13
14

sudo parted /dev/md0
(parted) unit s # 单位换成扇区
(parted) mktable gpt # 创建 gpt 分区表
(parted) # mkpart primary 格式 起始 结束
(parted) mkpart primary fat32 2048 206847# 取决于loop-efi0文件大小，2048 + 204800 - 1
(parted) mkpart primary ntfs 206848 1322714456# 取决于Win10物理分区扇区数 206848 + 1322507609 - 1
(parted) set 1 boot on # 允许EFI分区启动
(parted) set 1 esp on # 设置 esp标签
(parted) set 2 msftdata on 
(parted) name 1 EFI 
(parted) name 2 Windows
(parted) quit

ls /dev/md0*

此时应该多出分区的设备

1

/dev/md0  /dev/md0p1  /dev/md0p2

此时确认一下分区是否正确。如果分的扇区正好对应了 Windows C盘的起始和结束扇区，那么不需格式化即可直接挂载。

1
2
3

sudo mount /dev/md0p2 /mnt
ls /mnt
sudo umount /mnt

应该是能够正常挂载读取的。如果挂载失败，大概率是扇区计算错误，重新使用 parted 或 cfdisk 进行分区

格式化 EFI

1
2

paru core/dosfstools -S
sudo mkfs.msdos -F 32 -n EFI /dev/md0p1

按照上述步骤继续操作，可以继续为 D 盘创建线性阵列。完成后应该是这样 （我最终是把两块硬盘上保留分区也添加了进来，但实际上保留分区是不需要的）

1
2

ls /dev/md*
/dev/md0  /dev/md0p1  /dev/md0p2  /dev/md0p3  /dev/md0p4  /dev/md1  /dev/md1p1

启动 libvirt

打开 virt manager，在首选项打开 XML 编辑

创建虚拟机

使用 ISO 文件创建虚拟机，并配置适当的CPU与内存，不需要为虚拟机启用存储！！ 因为我们直接使用了硬盘。

最后在安装前自定义设置

自定义设置

新建存储，设置为我们创建的线性阵列。可以把两个阵列都添加上去。

之后就可以启动虚拟机了。进入虚拟机后，不要进行安装操作，否则有可能会覆盖系统安装！！！

在这个界面使用 Shift + F10 打开 CMD

在 CMD 中输入命令

1
2
3
4
5
6
7

diskpart
DISKPART> list disk
DISKPART> select disk 0    # 选择/dev/md0在VM中对应的硬盘
DISKPART> list volume      # 在分区列表中记下EFI分区序号
DISKPART> select volume 2  # 选择EFI分区
DISKPART> assign letter=Z  # 为EFI分区分配驱动器号（Z:）
DISKPART> exit

如果这一步找不到正确的硬盘(Disk)或正确的卷(Volume)，大概率还是扇区分配不正确，回去重新计算，并尝试挂载

最后将驱动器C:中的系统启动信息写入到驱动器Z:（EFI分区）：

1

bcdboot C:\Windows /s Z: /f ALL /v

你需要观察上述 diskpart 中的 list volume 输出，根据分卷大小来确认Windows系统卷标。或者使用 dir 命令检查硬盘分区的内容，来确定 Windows 系统盘的分卷。

命令执行完成后，可以进入 Z: 检查内容，但是注意不要修改，否则要重新运行上述命令！

之后就可以退出安装程序，关闭虚拟机，进入虚拟机详情，修改启动顺序。

之后启动虚拟机，就能发现正是硬盘里安装的 Windows了

自动启停线性阵列

安装 libvirt qemu hook helper

这是个脚本，在 libvirt 启动、关闭虚拟机时自动运行 hook，安装命令：

1

paru aur/libvirt-hook-helper-git -S

Libvirt hook提供一种在libvirt服务某个生命周期执行特定脚本的能力，hook脚本放置在/etc/libvirt/hooks目录，关于VM管理的脚本入口文件是/etc/libvirt/hooks/qemu，其默认用法如下：

1

/etc/libvirt/hooks/qemu $vm_name $hook_name $sub_name $extra

更多信息请查阅：Libvirt文档。要使用这个hook，需要判断VM实例名称、hook名称、子动作名称等参数，颇为不便。我在这里使用VFIO-Tools Hook Helper对hook使用流程进行简化。Libvirt hook helper实际上是一个脚本，内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#!/usr/bin/env bash
#
# Author: SharkWipf
#
# Copy this file to /etc/libvirt/hooks, make sure it's called "qemu".
# After this file is installed, restart libvirt.
# From now on, you can easily add per-guest qemu hooks.
# Add your hooks in /etc/libvirt/hooks/qemu.d/vm_name/hook_name/state_name.
# For a list of available hooks, please refer to https://www.libvirt.org/hooks.html
#

GUEST_NAME="$1"
HOOK_NAME="$2"
STATE_NAME="$3"
MISC="${@:4}"

BASEDIR="$(dirname $0)"

HOOKPATH="$BASEDIR/qemu.d/$GUEST_NAME/$HOOK_NAME/$STATE_NAME"

set -e # If a script exits with an error, we should as well.

# check if it's a non-empty executable file
if [ -f "$HOOKPATH" ] && [ -s "$HOOKPATH" ] && [ -x "$HOOKPATH" ]; then
    eval \"$HOOKPATH\" "$@"
elif [ -d "$HOOKPATH" ]; then
    while read file; do
        # check for null string
        if [ ! -z "$file" ]; then
          eval \"$file\" "$@"
        fi
    done <<< "$(find -L "$HOOKPATH" -maxdepth 1 -type f -executable -print;)"
fi

简单来说就是优化了hook脚本的管理方式，安装完hook helper后重启libvirtd服务，即可通过如下结构管理VM hook：

1

/etc/libvirt/hooks/qemu.d/$vm_name/$hook_name/$sub_name/*

例如名称为windows10的VM，其prepare hook、begin子动作要执行的脚本是setup.sh，则将脚本放在如下位置：

1

/etc/libvirt/hooks/qemu.d/win10/prepare/begin/setup.sh

Hook数量不限，类型不限定是shell脚本，在hashbbang中指定任何解释器均可。较为重要的几个hook类型如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Before a VM is started, before resources are allocated:
/etc/libvirt/hooks/qemu.d/$vm_name/prepare/begin/*

# Before a VM is started, after resources are allocated:
/etc/libvirt/hooks/qemu.d/$vm_name/start/begin/*

# After a VM has started up:
/etc/libvirt/hooks/qemu.d/$vm_name/started/begin/*

# After a VM has shut down, before releasing its resources:
/etc/libvirt/hooks/qemu.d/$vm_name/stopped/end/*

# After a VM has shut down, after resources are released:
/etc/libvirt/hooks/qemu.d/$vm_name/release/end/*

以上述Windows10 VM为例，创建启动和停止hook，用来线性阵列启停操作自动化。

自动启停线性阵列 Hook

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#!/usr/bin/env bash
#
# Author: Neolux Lee (https://github.com/neoluxis)
#
# This file creates and distroys /dev/md0 and /dev/md1 for booting physical Windows drive.
#
echo "[HOOK] Triggered with args: $1 $2 $3" >> /tmp/hook.log
date >> /tmp/hook.log

VM_ACTION="$2/$3"
#SCRIPT=/etc/libvirt/hooks/qemu.d/win10
SCRIPT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

if [[ "$VM_ACTION" == "prepare/begin" ]]; then
        $SCRIPT/md0/start-md0.sh
        $SCRIPT/md1/start-md1.sh
elif [[ "$VM_ACTION" == "release/end" ]]; then
        $SCRIPT/md0/stop-md0.sh
        $SCRIPT/md1/stop-md1.sh
fi

整理 hook 结构

将创建的所有hooks整理一下，利用软链接的形式存放到Win10 VM对应的生命周期目录中，最后得到如下结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

tree -ahl          
[  72]  .
├── [ 419]  manage-vdisks.sh
├── [ 186]  md0
│   ├── [1.0M]  loop-efi0
│   ├── [1.0M]  loop-efi1
│   ├── [100M]  loop-winefi
│   ├── [795M]  loop-winrec
│   ├── [ 16M]  loop-winres
│   ├── [ 955]  start-md0.sh
│   ├── [ 199]  stop-md0.sh
│   └── [  55]  .win10-loop-devices
├── [ 120]  md1
│   ├── [1.0M]  loop-efi0
│   ├── [1.0M]  loop-efi1
│   ├── [ 696]  start-md1.sh
│   ├── [ 199]  stop-md1.sh
│   └── [  23]  .win10-loop-devices
├── [  10]  prepare
│   └── [  50]  begin
│       ├── [  22]  00-manage-vdisks.sh -> ../../manage-vdisks.sh
│       ├── [   9]  md0 -> ../../md0  [recursive, not followed]
│       └── [   9]  md1 -> ../../md1  [recursive, not followed]
└── [   6]  release
    └── [  50]  end
        ├── [  22]  00-manage-vdisks.sh -> ../../manage-vdisks.sh
        ├── [   9]  md0 -> ../../md0  [recursive, not followed]
        └── [   9]  md1 -> ../../md1  [recursive, not followed]

11 directories, 16 files

完成后，就可以启动关闭虚拟机进行测试。

1
2
3
4
5
6
7

# 测试启动 
virsh start windows10
ls /dev/md*

# 测试关机
virsh shutdown windows10
ls /dev/md*

使用开源工具 frp 进行内网穿透

Prerequisites

1. 一台具有公网IP 的服务器（以阿里云云服务器示例）

2. 一台本地的电脑或其他设备（以本地电脑ArchLinux 示例）

下载安装

从 GitHub 下载二进制文件

因为电脑和服务器均安装的是Linux操作系统，所以下载 Linux版本的二进制文件

解压后文件如下（如果是Windows就是对应的.exe 和 .ini 文件

其中 frpc 是客户端，用于服务运行的局域网的设备，frps是服务端，运行于具有公网IP的云服务器上。

把frps 和 frps.toml 使用scp或ftp发送到服务器：

（Optional）设置系统服务

Server

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# /etc/systemd/system/frps.service
[Unit]
# 服务名称，可自定义
Description = frp server
After = network.target syslog.target
Wants = network.target

[Service]
Type = simple
# 启动frps的命令，需修改为您的frps的安装路径
ExecStart = /root/fastrp/frps -c /root/fastrp/frps.toml

[Install]
WantedBy = multi-user.target

Client

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# /etc/systemd/system/frpc.service
[Unit]
Description = frp client
After = network.target network-online.target syslog.target
Wants = network-online.target

[Service]
Type = simple
# 启动frps的命令，需修改为您的frps的安装路径
ExecStart = /home/neolux/app/frp/frpc -c /home/neolux/app/frp/frpc.toml

[Install]
WantedBy = multi-user.target

配置

Server

在服务器修改 frps.toml ，设置开放端口，密钥，用户名密码等信息

1
2
3
4
5
6
7

auth.token = "XXXXXXX" # 可选的
# 默认为 127.0.0.1，如果需要公网访问，需要修改为 0.0.0.0。
webServer.addr = "0.0.0.0"
webServer.port = 7500
# dashboard 用户名密码，可选，默认为空
webServer.user = "username"
webServer.password = "password"

之后在管理后台把设置的端口打开

Client

在本机修改frpc.toml

1
2
3
4
5
6
7
8
9
10
11
12

serverAddr = "服务器IP"
serverPort = 7000

auth.token = "XXXXXXX" # 如果服务器设置了 token,每个客户端都必须设置同样的token

# 以本地的SSH穿透示例配置
[[proxies]]
name = "Archlinux SSH"
type = "tcp"
localIP = "127.0.0.1"
localPort = 22
remotePort = 3322

每一个穿透的远程端口都必须在服务器的防火墙开放，否则访问不到

运行

在服务器运行 frps，在本地运行frpc ；或者使用 systemd 启动

测试配置：

官方文档

https://gofrp.org/zh-cn/docs/

直接安装 ROS2 Humble

使用 Distrobox

多个 ROS 版本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

# ROS 环境初始化选择函数
function init_ros_noetic() {
    # ROS Noetic (Ubuntu 20.04)
    source /opt/ros/noetic/setup.bash
    # 可选：添加你的工作空间初始化
    # source ~/catkin_ws/devel/setup.bash
    echo "ROS Noetic 已初始化！"
}

function init_ros_foxy() {
    # ROS Foxy (Ubuntu 20.04)
    source /opt/ros/foxy/setup.bash
    # 可选：添加你的工作空间初始化
    # source ~/ros2_foxy/install/setup.bash
    echo "ROS Foxy 已初始化！"
}

# 只在交互式终端展示选择菜单
if [[ $- == *i* ]]; then
    echo "========================"
    echo "是否初始化 ROS 环境？"
    echo "1: 初始化 ROS Noetic (ROS1)"
    echo "2: 初始化 ROS Foxy (ROS2)"
    echo "其他: 跳过 ROS 初始化"
    echo "========================"
    
    read -p "请输入你的选择 (1/2/其他): " ros_choice
    
    case $ros_choice in
        1)
            init_ros_noetic
            ;;
        2)
            init_ros_foxy
            ;;
        *)
            echo "未初始化 ROS 环境"
            ;;
    esac
fi

下载源码

绿联的网卡是一个 USB 存储设备，里面存放了 Windows 的驱动程序。而 Linux 驱动需要下载源码编译

从这里下载对应驱动，解压到一个文件夹

编译

解压后有 Debian/Ubuntu 和其他 Linux 的编译文档，按照文档进行编译即可

编译可能遇到的问题

内核版本新，函数调用旧版本导致编译出错

解决方案：

找到 linux-headers 中，该函数的定义。如图该函数定义在 /usr/lib/modules/6.12.21-1-lts/build/include/net/cfg80211.h 的8794行。查看定义：

1

grep -A 10 "void cfg80211_cac_event" /usr/lib/modules/6.12.21-1-lts/build/include/net/cfg80211.h

再检查实际调用的格式，由输出看出该调用在aic8800_fdrv/rwnx_radar.c：

1

grep -A 10 "cfg80211_cac_event" aic8800_fdrv/rwnx_radar.c

可以看出少了一个 link_id 参数，可以手动补上 0

重新编译即可

重复定义宏

打开对应的文件，注释重复的宏即可

使用驱动

插入网卡，运行 ip addr，应该显示新网卡设备， 如wlan1

则已经可以使用

RDKx5 出现的问题

实际在 RDKx5 编译完成并安装后，插入网卡不能直接使用，经过排查有以下问题

1. 编译后的网卡驱动模块与板载模块有冲突，导致没能加载内核模块
2. 因为该网卡同时也是存储设备，RDKx5默认以存储设备加载，而不是网卡设备

内核模块冲突

查看加载的内核模块，发现编译后的模块并未加载。尝试手动加载：

发现是因为符号冲突，导致无法加载该模块

解决方案

屏蔽该模块，并重启

1

echo "blacklist aic8800_bsp" > /etc/modprobe.d/blacklist-aic8800_bsp.conf

重启后，再次检查模块，发现已经成功加载内核模块

加载设备类型有错

识别到 usb 设备但是没有网卡设备

查看 usb 设备类型，发现设备被加载成存储设备：、

解决方案：

添加 udev 规则，自动将设备类型改为网卡设备

首先确定网卡设备 id，如图为 a69c:5724

首先尝试手动修改设备模式

1

usb_modeswitch -v 0xa69c -p 0x5724 -M "5553424312345678000000000000061b000000020000000000000000000000"

如果执行后，查看有网卡设备，则可以继续，使之自动完成配置。

设置 usb modeswitch 配置

1
2
3
4
5
6

cat > "/etc/usb_modeswitch.d/a69c:5724" << EOF
# UGreen AIC8800 USB WiFi initial mode
TargetVendor=0xA69C
TargetProduct=0x5724
MessageContent="5553424312345678000000000000061b000000020000000000000000000000"
EOF

设置 udev 配置

1
2
3
4
5
6

cat > "/etc/udev/rules.d/99-ugreen_usb_aic8800.rules" << EOF
ACTION=="add", SUBSYSTEM=="usb", ATTR{idVendor}=="a69c", ATTR{idProduct}=="5724", RUN+="/usr/sbin/usb_modeswitch -v 0xa69c -p 0x5724 -c /etc/usb_modeswitch.d/a69c:5724"
EOF

udevadm control --reload-rules
udevadm trigger

重启后，重新插入网卡，可以发现能够正确识别设备，并连接网络

操作流程

1. 手写/搜索/OCR 得到目录信息
2. 通过目录信息整理成数据结构
3. 使用PyPDF2库添加大纲

已完成

• yaml 格式的配置
• 添加大纲
• 多任务

多任务定义

参数：

1
2
3
4

tasks: 任务列表
outline: 目录 yaml 文件
override: 是否直接覆盖源文件
pdf: 原始 PDF文件

目录配置文件

参数：

1
2
3
4
5
6

bias: PDF文件页码与书籍/目录中的页码的偏移量
max_recurse: 最大子层级目录
nobias: 页码不需要偏移的章节，一般用于封面、目录等
toc: 目录，可以参考书籍本身的目录，一般直接写标题和页码的键值对即可。如果需要子层级，则添加 pn 参数和 toc
pn: 子层级的根层级的页码
toc: 子层级的目录，如1.1, 1.2等

代码

GitHub地址

Keil 工具链只能在Windows下安装使用，对于 MacOS，Linux等平台，可以参考本文搭建通用的开发环境（同样也支持Windows）

编译器 - SDCC

官网地址：SDCC - Small Device C Compiler

从官网下载对应平台的安装包，安装到系统。

也可以使用包管理器进行安装，如 Arch Linux可使用 pacman 安装：

1

sudo pacman -S sdcc

安装完成后，确认 sdcc 在系统 PATH 里，可以通过以下命令确定

1
2
3

$ sdcc --version                   
SDCC : mcs51/z80/z180/r2k/r2ka/r3ka/sm83/tlcs90/ez80_z80/z80n/r800/ds390/pic16/pic14/TININative/ds400/hc08/s08/stm8/pdk13/pdk14/pdk15/mos6502/mos65c02 TD- 4.4.0 #14620 (Linux)
published under GNU General Public License (GPL)

项目管理工具

项目管理工具可以选用 Make，CMake 等。写51大部分情况是写 C 或汇编，使用 Make 方便一些。

使用包管理器或下载安装 Make

1

sudo pacman -S make

烧录工具

烧录工具也有很多选择：stcflash, bossa, stcgal等。我们选用 stcgal

Arch Linux 可以从 AUR 安装，其他系统可以从 GitHub 下载 grigorig/stcgal

这样一套开发环境就搭建完成了，下面讲一下如何使用

配置 51 单片机开发项目（C语言）

新建一个文件夹用来存储项目文件，并创建一个简单的项目结构

1
2
3
4

mkdir -pv ~/workspace/51project
cd ~/workspace/51project
mkdir -pv src/{core,periph/{inc,src}} build
touch Makefile

完成后，项目结构如下：

1
2
3
4
5
6
7
8
9
10
11

$ tree                                  
.
├── build
├── Makefile
└── src
    ├── core
    └── periph
        ├── inc
        └── src

7 directories, 1 file

core 文件夹存储主程序，periph 下存储相关外设的封装库，Makefile 是项目的构建配置

编辑 Makefile：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

# 编译器使用 sdcc
CC := sdcc
FLASH := stcgal

# 项目名称和生成目标名称
PROJECT_NAME := project
TARGET_NAME := target

CFLAGS := -mmcs51 -Isrc/core -Isrc/periph/inc
LDFLAGS := -mmcs51

# 构建目录和构建程序文件
BUILD_DIR := build
OBJ_DIR := $(BUILD_DIR)/obj
HEX_FILE := $(BUILD_DIR)/$(TARGET_NAME).hex

# 源码
SRC_DIR := src
# 用户程序源码
CORE_DIR := $(SRC_DIR)/core
# 外设驱动目录
PERIPH_DIR := $(SRC_DIR)/periph
# 外设源码
PERIPH_SRC := $(PERIPH_DIR)/src
# 外设头文件
PERIPH_INC := $(PERIPH_DIR)/inc

# 源码文件通配
CORE_SOURCES := $(wildcard $(CORE_DIR)/*.c)
PERIPH_SOURCES := $(wildcard $(PERIPH_SRC)/*.c)
ALL_SOURCES := $(CORE_SOURCES) $(PERIPH_SOURCES)

OBJ_FILES := $(patsubst %.c, %.rel, $(ALL_SOURCES))

all: $(HEX_FILE)
@echo Build completed

%.rel: %.c $(OBJ_DIR)
@echo Compiling $<
@$(CC) $(CFLAGS) -c -o $(OBJ_DIR)/$@ $<

$(HEX_FILE): $(OBJ_FILES)
@echo Linking
@$(CC) $(LDFLAGS) $(OBJ_FILES:%=$(OBJ_DIR)/%) \
-o $(OBJ_DIR)/$(TARGET_NAME).ihx
@cp $(OBJ_DIR)/$(TARGET_NAME).ihx $(HEX_FILE)

flash:
@if [ -e /dev/ttyUSB0 ]; then \
if [ -e $(HEX_FILE) ]; then \
@$(FLASH) -P stc89 $(HEX_FILE) -D; \
@echo Flash completed. ;\
else \
@echo Not built yet!; \
fi \
else \
echo "没有找到 USB 串口，停止烧录!"; \
fi


$(BUILD_DIR):
@mkdir -pv $@

$(OBJ_DIR): $(BUILD_DIR)
@mkdir -p $@
@mkdir -p $@/$(CORE_DIR)
@mkdir -p $@/$(PERIPH_DIR)
@mkdir -p $@/$(PERIPH_SRC)

clean:
@rm -fr $(BUILD_DIR)

.PHONY: clean all flash

之后就可以写代码了

测试

写程序测试

使用 make编译

最后把单片机连接到电脑，make flash 进行测试。

总结

使用SDCC进行配置，对于大部分51的学习已经足够，对于协会培训内容而言绝对足够。配置完成后，在任何平台不需要额外进行项目的配置，只需要 make 工具就可以在Windows，Linux，MacOS，甚至其他架构的计算机上编译烧录51程序，非常地方便。

示例工程以发布于 GitHub：https://github.com/neoluxis/SDCC_89C52

在撰写专利时，一般需要给专利设计的物品绘制3D模型，并保存线稿线框图在说明书中指出。一般工科类使用 SolidWorks 较多。但是我经常使用 Arch Linux, 无法直接安装 SolidWorks, 虚拟机安装又觉得麻烦，也不想要专门为了一张图反复重启电脑。因此，我一直在研究如何使用Blender 绘制这类线框图。

搜了很多资料，不管有用没用，都尝试过；而且也尝试着自己摸索一些方法，来制作线框图。

方案一：线框模式下预览并截图

1
2
3
4
5
6
7

graph LR

a[切换到线框模式]
--> rr[关闭透视]
--> b[设置世界背景颜色]
--> c[设置线条颜色]
--> d[截图保存]

新建一个文件，添加两个立方体，简单布局一下。

切换到线框模式，并关闭透视

打开叠加，取消勾选无用的信息，例如游标、坐标轴、网格等

打开着色方式，切换到视图，设置背景颜色

之后进行截图保存，进行编号即可

但是这种方法只能处理比较方正的形状。如果模型中有很多的面和边，线框也会把内部的线渲染出来。如图

方案二：使用遮挡并渲染 Freestyle 边

以上面的图为例，建模完成后，添加相机，调整好相机的位置

之后添加一个平面，调整该平面在镜头中，完全遮盖住所有物体

为该平面创建一个新的组

之后为这个组打开阻隔

然后在视图层设置里面，打开 Freestyle， 并设置希望线条的宽度

完成后，可以开始渲染图像

完成后保存图片，在 Krita、Photoshop、Gimp等软件中，添加白色背景即可

昨天在使用 Arch Linux 时， 我同时进行了

• 系统更新

  1	sudo pacman -Syu

• PyCharm 写视觉代码

• SSH 远程连接到开发板，并转发窗口到本机显示

同时，我使用的是 KDE Plasma Wayland 桌面环境。不知道什么原因，整个系统变得非常卡，而且即使我关掉 PyCharm, SSH，在 htop 中查看到的 CPU 占用仍然达到了 80% 以上，并且整个桌面开始时不时黑屏，卡死，不再相应键盘鼠标的输入……

于是，此时我忘记了系统还在更新，正在运行事务后钩子函数，长按电源键进行了关机。当重启的时候，问题开始出现：

问题 1：启动内核丢失

重启电脑后，Grub 配置还没有更新，所以 Grub 界面仍然正常，但是启动任何 Arch 的选项，都提示找不到启动镜像，需要指定镜像。

该问题是因为，在运行事务后处理钩子函数时，会把旧的 vmlinuz 文件、initramfs 文件删除后生成新的。由于我提前强制关机，导致旧的已经删除，新的尚未生成，所以没能找到启动镜像。

解决方案：我启动到 Windows 系统中，使用 rufus 重新制作了启动U盘，在 Arch Linux的 Live CD 中，使用 arch-chroot 进入系统，重新生成启动镜像文件。之后重启，即可正常启动进入系统

问题2：桌面展示异常

虽然 KDE Plasma 已经逐步更新到 Wayland 端，我更常用的还是 X11 版本。当我进入桌面环境，进入的速度比平时慢了很多；进入桌面后，原本设置浮动的底部应用 Dock 栏、顶部的菜单栏、以及应用的弹出菜单，都有了黑色的阴影。打开终端后，原本毛玻璃特效变成了透明特效。

我尝试运行 systemctl restart --user plasma-kwin_x11.service，在短暂的黑屏后，问题没能解决。

我最终没有办法，只能尝试 Wayland 版本。进入之后，Wayland 变得正常，于是我在 Wayland 下进行代码编写，SSH 调试等

问题 3：软件颜色反转

在 Wayland 下，打开 Chrome, 发现不论文字，图标，图片，视频，颜色发生混乱。在关闭 Chrome 硬件加速，重置 Chrome 设置，甚至重新安装 Chrome 后，问题没能解决。

我尝试写了 HTML 代码，查看颜色异常。发现是红蓝两色交换了，由RGB 变成了 BGR。查找了很多资料没能解决。切换回 X11 桌面后，该问题仍然存在

解决方案： 重新安装显卡驱动。我一开始意识到了这个问题，但是我头脑比较昏，竟然重新安装 cuda，结果一点用都没有。一直到今天，才想起来显卡驱动应该是 nvidia-dkms 而不是 cuda 包…… 重新安装 nvidia-dkms 并给内核打补丁后，重启后，问题2，3 都解决了

在使用 Linux 时，有时可能会误删除某些文件。一般而言，在命令行环境下使用 rm 删除的文件是无法恢复的，但是在一些情况下还是可以恢复的。

原理

当一个文件正在被某个进程使用时，Linux 下的进程也是文件的形式存在，该文件也会被链接到该进程的虚拟文件系统下，我们只需要获取到正在运行的进程的文件描述符，就可以恢复被删除的文件了。

下面来试验一下

实验

准备工作

首先生成一个文件 test.txt，我们将要删除并恢复这个文件

1
2
3
4

cat > test.txt << EOF
Hello This is a file 
to be removed and restored
EOF

接下来，我们写一个程序，这个程序将会占用 test.txt, 读取文件并输出其中的单词，输出时会等待按键，以此延迟程序退出。使用 gcc -o main main.c 编译程序运行正常。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

cat > main.c << EOF
#include "stdio.h"
int main() {
FILE*fp = fopen("./test.txt", "r");
    char key;
    char* word;
    while(fp != NULL) {
        key = getchar();
        if (key == 'q') {
            break;
        }
        else {
            fscanf(fp, "%s", word);
            printf("%s", word);
        }
    }
    fclose(fp);
}
EOF

删除文件

打开另一个终端，运行main，但是不要让程序退出；rm -fr test.txt 删除文件。

查找占用该文件的进程

1

lsof | grep -i deleted | grep test.txt

lsof命令来自英文词组 list opened files 的缩写，其功能是查看文件的进程信息。由于 Linux 系统中的一切都是文件，因此使用lsof命令查看进程打开的文件，或是查看文件的进程信息，都能帮助用户很好地了解相关服务的运行状态。

获取到的进程信息会列出文件状态和文件名， 因此使用 grep 找到被删除的（deleted）的 test.txt

这样就获取到了进程号

恢复文件

进入进程的目录

1

cd /proc/49864/fd

使用 ls -l 查看文件描述符，由此可见 文件描述符3就是被删除的文件了。使用 cat 即可恢复

总结

我们可以把这个操作打包成一个 Shell 函数，方便我们随时调用

1
2
3
4
5
6

cat >> ~/.bashrc << EOF
restore_rm() {
  N="$1" ; P=/proc/$(lsof +L1 | grep "$N" | awk '{print $2}')/fd ;
  ls -l $P | sed -rn "/$N/s/.*([0-9]+) ->.*/\1/p" | xargs -I_ cat $P/_ > "$N"
}
EOF

按照本文安装方法，实现

• Keil C51 和 Keil MDK 共存
• 最新版 Keil 配置 AC5 编译器
• 最新版 Keil 5 兼容 Keil 4/3/2 项目

下载所需的包

从协会网盘下载，下载后文件如下

安装 Keil C51

运行 1_C51Vxxx.exe 安装到系统，记住安装位置

安装 Keil MDK

运行 2_MDKxxx.exe 安装 Keil MDK 到C51的位置

安装完成后，查看 Keil 安装目录，应该既有 C51 文件夹，也有 ARM 文件夹

协会提供的版本高于 5.37，因此安装好之后，只有 AC6 编译器，但是编译标准库项目协会的一些示例需要使用 AC5 编译器，于是安装 3_AC5setup.exe

安装位置设置为 Keil安装目录\ARM\AC5

配置激活 Keil

激活 Keil

以管理员身份打开 Keil

静音以管理员身份打开 4_KeilMDK5Keygen.exe

打开 Keil 的激活管理器

可以看到已经激活了一个社区版许可证，在激活 Keil 之前，需要将这个许可证卸载

点击 Activate/Deactivate

将其卸载

之后进入 Floating License

复制 CID

粘贴进注册机

点击 Generate，将生成的注册码复制到 Keil

同理在注册机里把 target 改成 ARM，再次生成注册码，复制进 Keil 添加，完成后，证书管理器显示如下，均 2032 年到期

配置 AC5 编译器

关闭 Keil，直接双击打开（普通用户）

AC5 只用于 ARM平台编译，例如 STM32等

新建一个STM32 项目

Project/Manage/Pack Installer 搜索 STM32F1，安装 DFP 包

Project/New μVision Project，选择保存位置和芯片型号 （协会招新使用的是 STM32F103C8T6）

在这个页面保持默认 点击 OK

点开这个

找到安装的 AC5 文件夹，添加编译器

这样就实现了 AC5 和 AC6 的共存

新建方块类

添加方块和添加物品大同小异。

可以创建 block.ModBlocks 类并将方块放在这里

定义方块变量

1
2

public static final DeferredRegister<Block> BLOCKS =
    DeferredRegister.create(ForgeRegistries.BLOCKS, TutorialMod.MODID);

注册方块

方块的注册比物品多了几步：

1. 要把方块以物品形式进行一次注册，用来放入物品栏里面的材质
2. 将方块以方块形式注册一次，定义一些性质和信息

同样的定义几个辅助方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14

private static <T extends Block> RegistryObject<T> registerBlock(String name, Supplier<T> block, CreativeModeTab tab) {
    RegistryObject<T> toRet = BLOCKS.register(name, block);
    registerBlockItem(name, toRet, tab);
    return toRet;
}

private static <T extends Block> RegistryObject<Item> registerBlockItem(String name, RegistryObject<T> block, CreativeModeTab tab) {
    return ModItems.ITEMS.register(name, () -> new BlockItem(block.get(), new Item.Properties().tab(tab)));
}


public static void register(IEventBus eventBus) {
    BLOCKS.register(eventBus);
}

之后注册方块，为这个类增加成员

1
2
3
4
5
6

public static final RegistryObject<Block> BEAR_BLOCK = registerBlock(
        "bear_block",
        () -> new Block(BlockBehaviour.Properties.of(Material.STONE)
                .strength(1f).requiresCorrectToolForDrops()),
        ModCreativeTab.tutorialmod_tab
);

在这个方块中，方块的注册名称是 bear_block ，属性使用石头材料，硬度设置为 1，需要正确的工具才能让他有掉落物

最后在主类的构造方法中，注册方块

1

ModBlocks.register(modEventBus);

绑定材质

新建 blockstate/bear_block.json，写入

1
2
3
4
5
6
7

{
  "variants": {
    "": {
      "model": "tutorialmod:block/bear_block"
    }
  }
}

新建 models/block/bear_block.json 写入

1
2
3
4
5
6

{
  "parent": "block/cube_all",
  "textures": {
    "all": "tutorialmod:block/bear_block"
  }
}

这个文件把每个面都设置成同样的图片

新建 models/item/bear_block.json

1
2
3

{
  "parent": "tutorialmod:block/bear_block"
}

之后把材质图片放进 textures/block/bear_block.png

绑定翻译

在翻译文件中增加一条

1
2
3

{
    "block.tutorialmod.bear_block": "Bear Block"
}

中文同理

之后就可以启动了

下载

克隆仓库

1

git clone https://github.com/Fmstrat/winapps

Windows 10 ISO 文件

下载 Windows 10 ISO

VirtIO

从这个网址找到最新版，进入后下载 ISO 文件 （下图中画框的任选一个）

安装需要的包

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 安装需要的包
paru -Sy qemu-base libvirt virt-manager
paru -Sy freerdp2

# 添加权限给当前用户
sudo usermod  -a -G libvirt $USER

# 自动启用默认网络
systemctl enable --now libvirtd
systemctl enable virtlogd.socket
systemctl restart libvirtd.service
sudo pacman -S ebtables
sudo pacman -S dnsmasq
sudo pacman -S bridge-utils

配置 KVM 虚拟机

打开 Virt Manager 后，应该是这样子

如果报错（无法连接/权限错误），回到上一步配置权限

新建虚拟机

首先在 编辑 -> Preferences 勾选 启用 XML 编辑

之后点击 ➕，新建一个虚拟机

• 选择 本地安装介质 下一步

• 选择下载的 Windows 10 ISO 文件，他会自动检测操作系统

• 根据电脑可用 CPU 数和内存大小，设定虚拟机的CPU数量和内存大小

• 虚拟机大小可以保持默认，也可以修改；在不需要这么多空间时，虚拟磁盘不会占用这么多

• 将虚拟机命名为 RDPWindows，勾选 在安装前自定义配置

  

修改配置

1. CPU 设置

   在 CPU数 里面，勾选 复制主机 CPU 配置

2. 切换到 XML 编辑视图，在 <clock></clock> 中间的部分修改为：

   1 2 3 4

   <clock offset='localtime'> <timer name='hpet' present='yes'/> <timer name='hypervclock' present='yes'/> </clock>

   这个操作可以节省 CPU 占用

3. 内存界面，将当前分配设置为一个比较小的内存大小，可以设置成 1024M

4. 引导选项 中，勾选 主机引导时启动虚拟机

5. 修改 SATA 磁盘1 的磁盘总线为 VirtIO，左侧 SATA 磁盘1 会变成 VirtIO磁盘1

6. 在 NIC :xx:xx:xx 中，修改 设备型号 为 virtio

7. 添加硬件，存储设备，设备类型修改为 CDROM device，选择下载的 VirtIO 镜像文件

   

8. 配置完成，开始安装

安装系统

正常安装 Windows 10 专业版 即可，许可证界面选择我没有许可证，后面可以直接使用 KMS 等工具激活系统

在选择磁盘界面，会找不到磁盘，这是因为没有 virtio 驱动。加载驱动程序，选择带有 w10 的驱动（如果用的是 Windows 11，就选择 w11）

安装之后就能检测到磁盘，选中磁盘安装系统即可

系统配置

在联网的时候，选择没有网络连接并进行有限的配置，记住设置的用户名和密码，等待默认配置完成

进入系统后，打开 E:/ 找到 virt-win-gt-64.exe 安装

安装完成后，打开 https://github.com/Fmstrat/winapps/blob/main/install/RDPApps.reg 下载并合并到系统注册表

将电脑重命名为 RDPWindows，稍后重启

启用系统的 远程桌面功能

可以安装一个 Spice Guest Tools 启用 共享剪贴板（如果从Virt Manager 启动），RDP 会自带剪贴板和文件共享

现在可以重启虚拟机，也可以进行激活后重启

重启后，在 Linux 系统中创建一个 winapps.conf，软连接到 $HOME/.config/winapps/winapps.conf 里面内容：

1
2
3
4
5
6
7
8

RDP_USER="Username"
RDP_PASS="Password"
#RDP_DOMAIN="MYDOMAIN"
#RDP_IP="192.168.123.111"
#RDP_SCALE=100
#RDP_FLAGS=""
#MULTIMON="true"
#DEBUG="true"

保存后，在 克隆仓库根目录运行

1

bin/winapps check

如果确定已经启动，但是连接失败，那就吧 RDP_IP 设置一下，然后在虚拟机里面固定IP，再次测试应该就可以连接了

运行 installer.sh 即可把预定义的程序添加到 Linux 的开始菜单中

如果要添加自定义的其他程序，可以参考 apps 文件夹里面的，进行修改添加

基本概念

注册

所有 mod 的对象都要向游戏注册（物品，方块，声音等） 如果不进行注册，会报错或者导致莫名其妙的行为。

注册方法

• 延迟注册 DeferredRegister
• 注册事件 RegisterEvent
• 非 Forge 注册的注册

在使用到的时候详细说明

引用注册的对象

• 使用 RegistryObjects

详细内容可以参考 Forge 文档

新建物品类

创建一个软件包 item，在包里创建一个 Java 类 ModeItems

可以把 mod 中的所有物品从这个类文件中定义

定义物品变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

package cc.neolux.tutorialmod.item;

import cc.neolux.tutorialmod.TutorialMod;
import net.minecraft.world.item.CreativeModeTab;
import net.minecraft.world.item.Item;
import net.minecraftforge.eventbus.api.IEventBus;
import net.minecraftforge.registries.DeferredRegister;
import net.minecraftforge.registries.ForgeRegistries;
import net.minecraftforge.registries.RegistryObject;

public class ModItems {
    public static final DeferredRegister<Item> ITEMS =
            DeferredRegister.create(ForgeRegistries.ITEMS, TutorialMod.MODID);

    // 注册物品，添加到杂项分类中
    public static final RegistryObject<Item> BEAR = ITEMS.register("bear",
            () -> new Item(new Item.Properties().tab(CreativeModeTab.TAB_MISC)));

    public static void register(IEventBus eventBus) {
        ITEMS.register(eventBus);
    }
}

在本例中，我简单的把微信头像放到游戏中，当作一个物品。

之后在 Mod 的构造方法中注册这个类

1

ModItems.register(modEventBus);

添加材质

在 resources 文件夹里面创建目录结构如下：

1
2

cd src/main/resources
mkdir assets/tutorialmod/{blockstates,lang,models/{block,item},textures/{block,item}} -p

之后 resources 文件夹结构应该是这样

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

.
├── assets
│   └── tutorialmod
│       ├── blockstates
│       ├── lang
│       ├── models
│       │   ├── block
│       │   └── item
│       └── textures
│           ├── block
│           └── item
├── META-INF
│   └── mods.toml
└── pack.mcmeta

12 directories, 2 files

在 assets/tutorialmod/models/item 创建 bear.json

1
2
3
4
5
6

{
  "parent": "item/generated",
  "textures": {
    "layer0": "tutorialmod:item/bear"
  }
}

把材质放到 /assets/tutorialmod/textures/item/bear.png

添加翻译

在 assets/tutorialmod/lang 创建英文翻译文件和中文翻译文件 en_us.json, zh_cn.json

1
2
3

{
  "item.tutorialmod.bear": "Bear"
}

1
2
3

{
  "item.tutorialmod.bear": "熊"
}

运行 runClient，创建存档，在杂项里面可以找到这个物品

新物品栏

创建 cc.neolux.tutorialmod.item.ModCreativeTab 类

1
2
3
4
5
6
7
8
9
10
11
12
13

package cc.neolux.tutorialmod.item;

import net.minecraft.world.item.CreativeModeTab;
import net.minecraft.world.item.ItemStack;

public class ModCreativeTab {
    public static final CreativeModeTab tutorialmod_tab = new CreativeModeTab("tutorialmod_tab") {
        @Override
        public ItemStack makeIcon() {
            return new ItemStack(ModItems.BEAR.get());
        }
    };
}

之后修改 ModItems 类

1
2

public static final RegistryObject<Item> BEAR = ITEMS.register("bear",
            () -> new Item(new Item.Properties().tab(ModCreativeTab.tutorialmod_tab)));

为物品栏添加翻译

1
2
3
4

{
  "item.tutorialmod.bear": "熊",
  "itemGroup.tutorialmod_tab": "我的物品"
}

运行

本文使用 Minecraft 1.19 Forge 编写 mod

下载 JDK

对于 Minecraft 1.19, 所需 JDK 版本应该是 openjdk-17

1

sudo pacman -Sy jdk17-openjdk

下载 开发工具包 MDK

搜索 minecraft forge，从官网下载

下载 minecraft 1.19 的推荐版本的 MDK （地址）

下载后解压

保留圈出来的文件，其余的 .txt 文件都可删除

配置项目

手动构建

直接运行 gradlew 完成基本的构建

1

./gradlew

根据使用的开发工具，生成相应的 Runs（用于启动客户端、服务端）

1
2
3
4

# 任选其一即可
./gradlew genIntelljJRuns # 使用 IDEA 开发
./gradlew genVSCodeRuns # 使用 VSCode
./gradlew genEclipseRuns# 使用 Eclipse

我们使用 IDEA，所以直接运行相应的命令

生成 Runs 时，会自动下载所需的文件，显示 BUILD SUCCESSFUL 就是成功了。如果失败了的话，尝试更换网络环境之后，重新运行命令即可

之后就可以使用所选用的开发工具打开这个文件夹了

自动构建

使用 IDEA 打开时，会自动运行一次构建程序，所以解压之后可以直接使用 IDEA 打开

等到下方运行完成后，右边可以看到这个项目所有的任务

点击 forgegradle runs/genIntellijRuns 即可配置 IDEA 的 Runs,生成完毕后，在运行按钮处可以看到 runClient 和 runServer

修改基本信息

默认的 mod 是叫做 examplemod，添加了一个没有绑定材质的方块。为了方便起见，我们可以直接把 com.example.examplemod.ExampleMod 中相应内容删除，删除后的文件如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

package com.example.examplemod;

import com.mojang.logging.LogUtils;
import net.minecraft.client.Minecraft;
import net.minecraft.world.item.BlockItem;
import net.minecraft.world.item.CreativeModeTab;
import net.minecraft.world.item.Item;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.Blocks;
import net.minecraft.world.level.block.state.BlockBehaviour;
import net.minecraft.world.level.material.Material;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.eventbus.api.IEventBus;
import net.minecraftforge.eventbus.api.SubscribeEvent;
import net.minecraftforge.fml.InterModComms;
import net.minecraftforge.fml.common.Mod;
import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
import net.minecraftforge.fml.event.lifecycle.InterModEnqueueEvent;
import net.minecraftforge.fml.event.lifecycle.InterModProcessEvent;
import net.minecraftforge.event.server.ServerStartingEvent;
import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
import net.minecraftforge.registries.DeferredRegister;
import net.minecraftforge.registries.ForgeRegistries;
import net.minecraftforge.registries.RegistryObject;
import org.slf4j.Logger;

// The value here should match an entry in the META-INF/mods.toml file
@Mod(ExampleMod.MODID)
public class ExampleMod {
    // Define mod id in a common place for everything to reference
    public static final String MODID = "examplemod";
    // Directly reference a slf4j logger
    private static final Logger LOGGER = LogUtils.getLogger();

    public ExampleMod() {
        IEventBus modEventBus = FMLJavaModLoadingContext.get().getModEventBus();

        // Register the commonSetup method for modloading
        modEventBus.addListener(this::commonSetup);
        // Register ourselves for server and other game events we are interested in
        MinecraftForge.EVENT_BUS.register(this);
    }

    private void commonSetup(final FMLCommonSetupEvent event) {
        // Some common setup code
        LOGGER.info("HELLO FROM COMMON SETUP");
        LOGGER.info("DIRT BLOCK >> {}", ForgeRegistries.BLOCKS.getKey(Blocks.DIRT));
    }

    // You can use SubscribeEvent and let the Event Bus discover methods to call
    @SubscribeEvent
    public void onServerStarting(ServerStartingEvent event) {
        // Do something when the server starts
        LOGGER.info("HELLO from server starting");
    }

    // You can use EventBusSubscriber to automatically register all static methods in the class annotated with @SubscribeEvent
    @Mod.EventBusSubscriber(modid = MODID, bus = Mod.EventBusSubscriber.Bus.MOD)
    public static class ClientModEvents {
        @SubscribeEvent
        public static void onClientSetup(FMLClientSetupEvent event) {
            // Some client setup code
            LOGGER.info("HELLO FROM CLIENT SETUP");
            LOGGER.info("MINECRAFT NAME >> {}", Minecraft.getInstance().getUser().getName());
        }
    }
}

下面开始修改基本信息

在以下几处进行修改

之后运行 runClient，可以进入游戏就是配置成功，新建一个创造模式存档，用于测试。

OpenMV

OpenMV适合实现轻量级的计算机视觉任务，如颜色检测、形状识别，使用OpenMV 的 nn库可以运行简单的目标检测算法。

必学内容

• 基础图像处理：灰度转换、二值化、滤波和边缘检测等 图像处理流程，了解大部分转换的作用，在不同场景下的效果

• 颜色检测：了解 RGB，LAB，HSV 颜色空间，能够进行相互转换，并能够对图像中的颜色做到识别，

• 形状识别：直线，线段，矩形、圆形等简单几何图形的识别，对识别结果进行处理，能从库函数提供的结果中得到需要的信息

• ROI：会框定 ROI，在 ROI 内进行所需的操作

• 数据传输：了解如何将获取到的数据打包，了解OpenMV的串口收发与STM32的通讯

• 调试接口：学习留出调试接口，如LCD屏，串口屏，按键等，便于赛场调整颜色阈值等重要参数

• 特征检测&模板匹配：至少学会一种对复杂目标的检测方法，在没有办法利用算法流程检测目标时备用

提高内容

• 神经网络：掌握拍摄数据集，数据集处理，打标，训练，部署全流程，可以使用公开数据集走一遍流程，也可以自己拍摄数据（一般训练目标检测模型用的多一些）
• 分类器：HaarCascade 分类器的使用（ 星瞳科技 使用的是人脸识别）这个分类器是用OpenCV 相关软件训练出的，在 OpenMV 上面使用需要一层处理（参考 GitHub 代码 生成适用于 OpenMV 的分类器文件，之后进行部署；关于如何训练，参考 OpenCV 文档
• 文件读写：OpenMV 使用 MicroPython，具有文件系统，比单片机使用 Flash 保存参数方便，所以可学文件读写，在比赛场地的 30min 准备时间中，可以把环境参数保存下来（验收中途老师不一定允许继续调试）
• 矩阵运算：使用 OpenMV 已经实现的矩阵运算库，相较于自己写循环，可以加快一些计算过程。矩阵运算库是 ulab.numpy ，可以参照 Python 的矩阵运算库 numpy 来学习；

其他

• OpenMV 是一块 STM32，它也可以驱动 GPIO，IIC，SPI等，可以尝试用 OpenMV 做一些不止视觉的东西。

• 平常多使用，了解 OpenMV 的性能，处理各种常用流程的速度，在比赛时考虑性能决定算法，根据赛题和处理方案所需的速度，合理安排 OpenMV 的计算工作

• 多准备一些 SD卡，便于调试过程中尝试多个版本的代码

参考链接

OpenCV

基础必学

• 树莓派镜像烧录和备份：要会烧录镜像，会配置环境；将镜像备份起来，如果Linux系统被搞坏了可以恢复

• Linux：基本的 Linux 命令，重要的系统配置文件等；SSH 连接，SCP 文件传输等

• Python：包括但不限于：NumPy，Pillow，PySerial 等库

• 基础图像处理：灰度转换、二值化、滤波和边缘检测等 图像处理流程，了解大部分转换的作用，在不同场景下的效果

• 颜色检测：了解 RGB，LAB，HSV 颜色空间，能够进行相互转换，并能够对图像中的颜色做到识别，

• 形状识别：直线，线段，矩形、圆形等简单几何图形的识别，对识别结果进行处理，能从库函数提供的结果中得到需要的信息

• ROI：框定 ROI，了解不规则 ROI 处理的方法

• 数据传输：了解如何将获取到的数据打包，了解树莓派的串口收发与STM32的通讯

• YOLO：使用 YOLO 进行目标检测

提高内容

• 优化算法：了解一些常用的优化算法加快处理速度，如多线程和多进程、降采样、模型量化等
• GPU：Python 环境下利用ncnn 使用树莓派的 GPU 可以稍微加快一点速度，效果有限，可以尝试
• 项目结构：使用 OpenCV 写一些复杂的处理流程，可以适当安排项目结构，也能保证代码的可复用性
• 版本控制：如果系统坏了，或者误修改不能撤销，可以使用版本控制工具快速恢复
• 深度学习：学习 SciPy 和 sk-learn 相关的工具，在很多场景下神经网络不是唯一的选择；学习 PyTorch 框架，自己写神经网络用于一些任务（YOLO 一般会很慢）
• 分类器：使用 OpenCV 提供的 trainCascade 工具训练级联分类器并部署到树莓派

其他

• 阅读经典论文，了解经典算法，在树莓派部署了解性能
• YOLO 使用的是 PyTorch 框架，所以尽量直接学 PyTorch；而且 PyTorch 环境配置比 TensorFlow 要简单方便，不要浪费太多时间在配置环境上
• 如果想进一步加快运算速度，可以尝试使用 C++ 编写程序
• 树莓派是一个完整的 Linux 系统，灵活性很大，可以更加自由的尝试各种更复杂的算法，多尝试
• Vim 可学可不学，树莓派可以用 VS Code 做远程连接

参考链接

视觉的要求只有三个字 “快”、“准”、“稳”，全部实现也不难，到了赛场上，实际的影响因素并没有很多，比赛期间和验收的调试期间细心调试问题一般就不大。

预祝电协成员 2024年电赛取得圆满成功

这是一个最简单的 HelloWorld 程序

1
2
3
4
5

#include "stdio.h"
int main(){
    printf("Hello World!\n");
    return 0;
}

编译运行

1

gcc ver1.c -o ver1

运行就会输出 Hello World!

看看编译后的输出大小

1
2
3
4
5

ls -l ver1
-rwxr-xr-x 1 neolux neolux 15440  6月11日 22:38 ver1

ls -lh ver1
-rwxr-xr-x 1 neolux neolux 16K  6月11日 22:38 ver1

当我们把静态库一起编译到文件里后再来看看

1
2
3
4
5
6
7
8
9
10

gcc -static ver1.c -o ver1_static

./ver1_static
Hello World!

ls -l ver1_static
-rwxr-xr-x 1 neolux neolux 762680  6月11日 22:38 ver1_static

ls -lh ver1_static
-rwxr-xr-x 1 neolux neolux 745K  6月11日 22:38 ver1_static

程序一下子变得很大了
下面开始精简程序

使用编译参数优化空间

C语言代码不变，更改编译参数

1
2
3
4
5
6
7

gcc -static -Os -s ver1.c -o ver1_Os

ls -l ver1_Os
-rwxr-xr-x 1 neolux neolux 682456  6月11日 22:38 ver1_Os

ls -lh ver1_Os
-rwxr-xr-x 1 neolux neolux 667K  6月11日 22:38 ver1_Os

• 使用 -Os 优化代码的体积
• -s 移除调试信息，能够降低 elf 文件的体积

使用汇编

C 语言优化空间有限，通过使用汇编语言来尝试优化可执行文件的体积

1
2
3
4
5
6
7
8
9
10
11
12

.text

.global main

main:
mov $str_helloworld, %rdi
call puts
mov $0, %rax
ret

str_helloworld:
.string "Hello World!\n"

1
2
3
4
5
6
7

gcc -static -Os -s ver2.s -o ver2

ls -l ver2
-rwxr-xr-x 1 neolux neolux 682456  6月11日 22:41 ver2

ls -lh ver2
-rwxr-xr-x 1 neolux neolux 667K  6月11日 22:41 ver2

和刚才相比并没有减少字节，因为代码中仍然使用了 libc 的代码，下面尝试抛弃 libc

不使用 libc

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

.text
.global _start
_start:
  mov $1, %rax # syscall: 1(write)
  mov $1, %rdi # fd: 1(stdout)
  mov $str_helloworld, %rsi # buffer: str_helloworld
  mov $13, %rdx #count: 13(strlen)
  syscall

  # exit(0)
  mov $60, %rax
  mov $0, %rdi
  syscall

str_helloworld:
  .string "Hello World!\n"

• 不用 main() 做程序入口，而是使用 _start 符号作为程序入口
• 不使用 puts()、printf() 作为输出函数，而是直接调用 write 方法向 stdout 输出数据
• 手动调用 exit 推出程序

编译

1
2
3
4
5
6
7

gcc -static -s -nostdlib ver3.s -o ver3

ls -l ver3
-rwxr-xr-x 1 neolux neolux 4536  6月11日 22:45 ver3

ls -lh ver3
-rwxr-xr-x 1 neolux neolux 4.5K  6月11日 22:45 ver3

程序只剩下 4.5K 的大小

N Magic

来查看可执行文件的信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

readelf -S ver3
There are 5 section headers, starting at offset 0x1078:

节头：
  [号] 名称              类型             地址              偏移量
       大小              全体大小          旗标   链接   信息   对齐
  [ 0]                   NULL             0000000000000000  00000000
       0000000000000000  0000000000000000           0     0     0
  [ 1] .note.gnu.pr[...] NOTE             0000000000400158  00000158
       0000000000000030  0000000000000000   A       0     0     8
  [ 2] .note.gnu.bu[...] NOTE             0000000000400188  00000188
       0000000000000024  0000000000000000   A       0     0     4
  [ 3] .text             PROGBITS         0000000000401000  00001000
       000000000000003c  0000000000000000  AX       0     0     1
  [ 4] .shstrtab         STRTAB           0000000000000000  0000103c
       0000000000000037  0000000000000000           0     0     1
Key to Flags:
  W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
  L (link order), O (extra OS processing required), G (group), T (TLS),
  C (compressed), x (unknown), o (OS specific), E (exclude),
  D (mbind), l (large), p (processor specific)

.note.gnu.bu 从 00000188 开始，大小仅有 0x24, 而 .text 在 00001000， 这中间整整有 0x0E78 的空间都被浪费了，
因为默认情况下，.text 按照页对齐，有利于提升加载速度，我们可以关闭这个特性，使用 --nmagic

1
2
3
4
5
6
7

gcc -static -s nostdlib ver3.s -Wl,--nmagic -o ver3_nmagic

ls -l ver3_nmagic
-rwxr-xr-x 1 neolux neolux 808  6月11日 22:47 ver3_nmagic

ls -lh ver3_nmagic
-rwxr-xr-x 1 neolux neolux 808  6月11日 22:47 ver3_nmagic

文件只有 808 了，相比于 C语言链接静态库的体积已经减少了 99.89%

禁用 build-id

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79