akatsuki kaze's blogs

doc_for_fresh_man

2026-08-05T12:22:43.000Z

1. 算法入门

1.1 先认识什么是算法组

其实对于“算法组”而言，叫他算法组是不太恰当的。但是如果叫他“视觉组”，那么其误解就更大了。首先，我们来认识什么是算法组。以及在robocon当中，算法组大体上需要完成什么任务。
以目前的RC趋势而言，自动机器人的重要性是逐年增加的。对于自动机器人，他需要进行复杂的感知，决策，控制。因此，应运而生专精于上位机的算法组。传统rm队伍当中，算法组一般叫做“视觉组”，视觉组主要负责装甲板自瞄，烧饼导航规划，雷达算法等。但是由于rc差异化更大，以及潜在需求更加多样，私以为视觉组这个名称对于实际任务已经不太妥当，因此我认为目前嵌入式linux任务统称为算法组更为合适。
在rc中，不仅只有视觉识别，导航规划，还有运动控制算法（足式多见），部分方案也有以上位机控制为主。在目前robotic到智能硬件，上下位机之间任务差距也在逐渐缩小。尤其是运动控制算法，已经基本上迁移到上位机进行。一方面是因为单片机成本逐渐增加（stm32系列都在涨价），另一方面运控基本普及的强化学习算法基本上直接输出电机控制参数，因此在使用强化学习的队伍中已经很少见单片机控制了。
接下来，由于笔者本人技术栈限制，本文将不会涉及运控方面的内容，想了解运控方面内容请移步loco wiki继续阅读，loco wiki由Lain维护。
（文章最底下有个音乐播放器，可以边听歌边读哦）

1.2 算法组的任务

上面提到，算法组将会主要负责视觉识别，导航规划内容。本文也将会从比赛角度，尽量不涉及专业数学计算对上位机任务进行解读。
以下是本文可能涉及的部分内容：

电脑硬件
可能使用的传感器
串口通信协议
视觉识别
导航规划
运动控制（参考loco wiki）
首先我们将会从计算机基本原理进行解读。对于一些专业化内容，本文将会援引外部链接，不会进行详细解读。

2. 计算机硬件组成

这一节只讲四样东西：CPU、内存、硬盘、GPU，以及它们之间是怎么协作的。理解了这四样，你对计算机硬件就有了基本的认知。

2.1 CPU

CPU（中央处理器，Central Processing Unit） 是计算机的核心芯片，负责执行指令。所谓指令，就是告诉 CPU 该做什么的一串二进制数字，比如做一次加法、读取一个数据、把结果写回去。

CPU 的工作就是不断重复以下循环：

取指（Fetch）：从内存中读取一条指令
译码（Decode）：解析这条指令要做什么操作
执行（Execute）：完成这个操作
写回（Write Back）：把运算结果存回寄存器或内存

这个循环称为指令周期，CPU 一秒钟能完成几十亿次。所有程序，无论是你写的 Python 脚本还是原神，最终都会被编译成这种最基础的指令，被 CPU 一条条地执行。

CPU 有几个关键参数：

核心数（Core）：CPU 内部独立的运算单元，每个核心可以同时执行一个指令流。多核心意味着可以真正并行处理多个任务。比如 4 核 CPU 可以同时跑视觉识别、导航规划、串口通信，互不干扰
主频（Clock Speed）：CPU 的工作频率，单位是 GHz。3.0GHz 表示每秒执行 30 亿次时钟周期。主频越高，单条指令执行越快

2.2 内存

内存（RAM，Random Access Memory，随机存取存储器） 是 CPU 直接访问的存储空间。程序要运行，必须先从硬盘加载到内存里，因为 CPU 只能直接读写内存，不能直接读写硬盘。

内存有两个重要特点：

断电即丢失：内存是易失性存储，关机后数据就没了，所以写文档要记得保存到硬盘
速度快但容量小：读取速度远快于硬盘，但容量通常只有 8GB~64GB

在算法组的场景下，内存大小直接决定了能处理的图像分辨率和并发任务数。跑深度学习模型时，模型参数要全部加载到内存（如果用 GPU 跑则是加载到显存）里，不够就会直接报错。

2.3 硬盘

硬盘是永久存储数据的设备，断电不丢。主要分两类：

机械硬盘（HDD，Hard Disk Drive）：内部有物理磁盘在高速旋转，通过磁头读写数据。容量大、价格便宜，但读取速度慢（约 100~200MB/s），而且有机械结构，怕震动。比赛机器人的上位机一般不用 HDD，因为机器人运动时的震动可能导致磁头划伤磁盘导致硬盘报废。但是由于价格美丽，经常有人会将其作为数据存储使用。

固态硬盘（SSD，Solid State Drive）：没有机械结构，纯电子存储（本质是闪存芯片）。速度快（约 500~7000MB/s），抗震动，但价格更贵。现在笔记本基本都用 SSD。

2.4 GPU

GPU（图形处理器，Graphics Processing Unit） 最初是为了渲染 3D 画面发明的，但后来人们发现它的架构特别适合做并行计算–也就是同时执行大量简单的运算。

CPU 和 GPU 的设计取向不同。CPU 的核心少但每个核心都很强，擅长处理复杂的逻辑判断和串行任务；GPU 的核心多但每个核心都比较简单，擅长同时处理大量结构相同的运算。

深度学习本质上就是海量的矩阵乘法运算，正好是 GPU 擅长的场景。所以训练神经网络、跑模型推理时，GPU 是必需品。

GPU 有一个关键参数：显存（VRAM，Video RAM），也就是 GPU 专用的内存。模型越大、图像分辨率越高，需要的显存越大。跑 YOLOv8神经网络视觉识别模型通常需要 2GB 以上。

2.5 它们是怎么协作的

把这四样东西串起来，计算机的工作流程是这样的：

程序和数据的”老家”在硬盘里，长期存储
你双击运行程序时，程序代码和所需数据从硬盘加载到内存里
CPU 从内存中逐条读取指令并执行，中间结果存在内存里
如果遇到深度学习这类大规模并行计算任务，CPU 会把数据转交给 GPU，GPU 用自己的显存暂存数据，算完再把结果返回给 CPU
程序运行结束后，如果要保存结果，数据从内存写回硬盘

所以你会发现，这几个部件构成了一个层次结构：硬盘容量最大但最慢，内存居中，CPU 缓存最快但最小。数据从慢的逐级搬运到快的，CPU 才能高效工作。这也是为什么程序需要”加载”才能运行，为什么内存不够会卡顿，为什么有 GPU 跑深度学习会快很多。

2.7 关于CUDA技术

上一节说到 GPU 擅长并行计算，但 GPU 原本是为了画图设计的，直接用图形 API 来做通用计算非常不方便。为了让开发者能用类似写 C 语言的方式来调用 GPU，NVIDIA 推出了 CUDA（Compute Unified Device Architecture，统一计算设备架构）。

简单来说，CUDA 是 NVIDIA 提供的一套软件平台和编程模型，让你可以写代码直接控制 GPU 做通用计算，而不仅仅是画图。你在写 PyTorch、TensorFlow 时，底层调用的就是 CUDA。

这里有一个前提：CUDA 只支持 NVIDIA 的 GPU。如果你买的是 AMD 显卡或者 Intel 核显，是无法使用 CUDA 的，只能走 OpenCL 或 ROCm 等替代方案，但这些方案在深度学习生态中的支持远不如 CUDA 完善。这也是为什么算法组选电脑时首选 NVIDIA 显卡。

不过截止本文攥写时，Rocm已经被不少人验证其性能并不弱于cuda。

2.8 算法组如何挑选电脑

首先说一个暴论：MacBook绝对是算法组的最佳选择（笑）。
首先，mac有以下优点：

类linux操作逻辑，也支持ros2
续航优秀，重量较轻
性能相对于续航，重量而言较高
工具链齐全，写电控也没问题。
至于缺点，贵是我的缺点不是他的（x）

但是在MacBook大幅涨价的现在，MacBook neo的性价比都已经不如8845笔记本。在这个现状下，最优选基本上是带有4060显卡的上一代笔记本了。

挑选电脑的第一原则：轻。不要买你接受不了天天端着跑的电脑，不然调车会比较享福。
第二：尽量选择可加装内存硬盘的电脑，不然在你没有额外存储设备的情况下，你的存储会爆炸的。
第三：别碰那个不能说的品牌，homo系统啥都干不了。
第四：最好不要对二手有歧视，别人调好的人妻说不定更温柔，不要有处女情结。

综上，目前市场行情下个人最推荐梯度：

第一：MacBook Air系列二手，华硕天选，拯救者7000系列
第二：MacBook neo系列二手，机械革命，天选和拯救者二手机
第三：MacBook neo和Air系列新机，机械革命二手机，其他品牌新机
由于大部分家长确实不太接受二手电脑，上述顺序自行剔除二手机即可。若家里人非得买那个品牌，首先尝试劝说能否购买荣耀笔记本，若还是不能则选择win11系统的旧款电脑。真买了也别着急认栽，也别拆封直接转手，然后自行购入AMD7840 CPU的笔记本。

2.9 电脑到手该做什么

首先，需要确认是否是新机或者无故障暗病的二手机。全程录制开箱视频，不要着急充电。首先我们来进行新机开箱：
新机就不要学网上花里胡哨的，首先检查快递盒有无严重变形，然后拆封后看电脑包装是否八角尖尖，查看封条贴纸是否有拆封痕迹（是否有胶痕就能看出来）。若正常，拆封进入下一步。首先拿出电脑，检查外壳磕碰，屏幕是否有落灰。若正常，继续下一步。接下来，打开电脑，正常没充电过按下开机键时是没反应的，如果开机了趁着还没激活，申请退换货吧。在运输模式下，未充电应该是不能开机的。在这一步正常后，插电开机进入系统，若正常为激活界面，直接照着电脑走流程即可，其余不用操作。进入系统后右键底下任务栏空白处，找到任务管理器，性能页面，检查存储，内存，cpu，显卡是否是自己购买的型号。若都正确，则安全下车。
对于二手机：录制开箱视频，然后下载图吧工具箱，使用甜甜圈和cpuz进行跑分测试，若在误差范围内，安全下车。二手机建议在老二道贩子处购买，价格适当，也没那么多个人卖家的扯皮，确保安全。

然后，现在你已经进入系统了，首先下载一个图吧工具箱，然后先进入系统设置搜索BitLocker，关闭它。如果不关，你电脑哪天不开机了就只能重装系统了。接下来，进入图吧工具箱，打开diskgenuis，把一个盘分一个卷，乱七八糟的分卷统统不要，不然以后空余空间这里一点那里一点，会非常难受。届时你就像个无能的丈夫一样看着空间一点一点被吞你啥都干不了。好了，现在你想干嘛都行，先去下个steam开始打游戏吧，玩爽了记得回来把这个文档读完。

3. 算法前期准备

3.1 环境搭建

首先，目前很多算法都是基于ubuntu构建的，因此先尽量尝试拥有一个安全的ubuntu环境。ubuntu是一个linux操作系统，它基于debian发行版，提供了一个安全、稳定、易用的环境。关于Ubuntu系统介绍援引以上视频，本文不做过多介绍。总之，Ubuntu系统将会是很多ROS开发的硬性要求，根据电脑自己的情况可以考虑虚拟机，WSL或者双系统。个人最推荐双系统，有两块物理硬盘的同学可以酌情考虑自行搜索教程安装双系统。其次就是WSL，直接运行在windows下的子系统，但是在一些环境兼容性上可能会有问题。接着就是虚拟机，性能损耗会大点，但是十分安全，不怕带着win系统一起炸了。
目前ubuntu版本选择多样，个人建议Ubuntu22.04和24.04，性能较高的算法都是基于这两个版本的兼容性。尤其是ubuntu22.04，截止本文攥写时兼容性最佳。

安装完ubuntu，接着就需要准备好你的python环境了。python是一个解释型语言，它有丰富的库和工具，可以快速开发出各种应用。目前很多导航和建图算法都是基于python的，因此需要先准备好python环境。近几年最常用的版本是3.10-3.12，建议安装一个3.10版本的python。部分ubuntu版本自带python，可以直接使用，但是要注意版本检查。

接下来，需要安装ros2环境了。这里推荐小鱼的一键安装脚本wget http://fishros.com/install -O fishros && . fishros跟着脚本一步到位即可。

按需自行根据教程安装conda或者直接使用venv（建议），他会创建虚拟环境，防止你库下太多主环境爆炸。同时虚拟环境也像一个杯子，里面需要的东西随时可以端走，十分方便。

Ubuntu系统可能缺失PIP（一种python包管理工具），需要手动安装。

sudo apt updatesudo apt install python3-pip

即可安装pip。

3.2 部分基本素养介绍

算法最重要的就是编程，编程并不是开个shell再开个记事本就能完成的。虽然确实有人纯靠VIM就能编写一个C语言项目，但是能达到这个水平的人绝对不会来读这个文档。
对于算法，C语言基础和python基础都是必须的。python不建议作为第一门语言学习，虽然他可以培养很好的格式习惯（python对缩进格式有严格要求）但是它并不能很好的培养你的代码习惯。具体原因学习到一定程度就能理解。因此这里建议先学习C语言，再学习python。C语言学习无须精通，可以学会基础语法格式，如何调用库，如何封装自己的库即可。python同理。接下来很多语法细节通过开源代码或者一些教程网站如菜鸟教程，还有bilibili等渠道自行学习即可。

其次，就是对于系统架构的把控。这个功能和这个功能是否该放在一个文件下？main文件该放什么？这些都需要根据具体的情况来判断。如果是一个简单的算法，那么main文件就可以直接放所有代码。但是如果是一个复杂的算法，那么就需要将代码拆分成多个文件，每个文件负责一个功能。甚至在我的开源项目中，你就可以看到我把文件分为了HAL（硬件抽象层）和基础功能层。在26赛季的R2上位机代码中，GUI执行更是直接将UI，动作组，执行层解耦实现灵活变更。对于系统架构优化清晰，不论是在agent进行vibecoding时还是自己进行古法编程时都是有利的。ai编程不会帮你把控系统架构，因此只能靠自己进行把控。关于ai编程，本文最后会提到。

正视ai编程，ai是一个很好用的高效率工具而不是洪水猛兽。但是在进行ai编程时需要注意盯好思考过程和代码修改。全流程一定要注意把关好，否则高低要给你整点大活。而AI编程最需要的，则是你的表达能力。如何准确，简洁，直接的说出你的需求。事实上，和其他人沟通最高效的语句反而是最优的promote。语言表达能力，组织架构能力都是ai时代ai编程很重要的一环。至于ai思考的时候你能做什么，那就见仁见智了。

除去软件部分，传感器，硬件也是需要了解的。算法常见的传感器，例如相机根据调用方式分类有USB相机，工业相机（需要使用专门SDK），还有激光雷达（需要使用专门驱动），IMU（需要使用专门SDK）等可以直接读取的传感器。当然，关节电机的力矩，3508的电流等也可以近似作为力传感器。后面将会对部分我所了解的传感器做专门介绍。

既然已经进入机器人开发，对于机器人整体也是需要有所认知的。机械，电控，硬件，算法在机器人系统中起到什么角色，各自开发都做了什么，了解这些将会更加有利于整体合作流程。机器人是脱离不开硬件的，任何sim不谈real都是耍流氓。对于硬件理解越加深入，排查问题时越能对症下药。

3.3算法学习路径

首先，先把C艹或者python学清楚。尽管本人真的十分不推荐先学python，但是不可否认在AI coding趋势下C艹语言各种复杂的api可以依靠AI进行处理，甚至可以让python调用C艹语言的库。而python的大部分高性能的库更是主要由c语言编写的。并且实际在ROS开发中跨语言是很常见的事。C语言个人建议在bilibili或者菜鸟教程中，尝试跟进部分小项目进行学习。这样快速掌握C语言语法基础后，再开始准备python的学习。尽管python有很多语法和c有较大差距，但是c语言的大部分编程习惯很容易迁移到py中。接下来在学习py的时候，只需要注意最核心的一件事——py和c的区别。
c语言就像很多教材教的那样，作为一个高级语言是需要编译为计算机语言的。在很多教材中，通常会用翻译的例子。c语言的运行过程就像是邮件，需要翻译为计算机能看懂的语言后运行。而py则是解释器语言，解释器逐行翻译py给计算机执行。这也带来一个问题，第一就是由于python需要运行解释器，因此py的运行速度普遍比c慢很多，部分简单项目甚至能达到十倍级的速度差。而c虽然经常因为语法问题被人吐槽诸多，但是其高性能和高速扩张时期的红利使其长时间内也难以被取代。具体需要使用哪种语言，可以通过任务区别进行选择。
对两种基础编程语言有概念后，就该继续学习如何成为调包侠了。首先尝试学习ROS的相关库，以及ros有一些很方便的用法，然后就可以尝试调用rosbag进行数据回放。rosbag是记录了ros话题数据的一种文件，可以在硬件设备不足的情况下进行算法的调试和学习工作。

3.4算法组建议时间安排

基础的语言基础建议花上两个月好好沉淀一下。毕竟人不是只能打比赛，还是需要管好课内成绩。一不小心开了无敌模式那就往死里干吧

大一八月，建议自行安装好vscode，尝试学习python和c艹语言的基础语法。顺便，好好享受最后的暑假。
大一九月，开始了解纳新安排，学习纳新课程，直到十月都不需要额外学习新的内容。
大一十月，可以尝试自行安装双系统了。比较建议的是双系统+WSL的配置，WSL相对方便，而双系统才能提供较好的开发环境。
大一十一月，着手准备校内赛。一般而言校内赛难度不会很高，但是也是一个小小的完成项目的机会。
大一十二月，此时可以接触到学长代码了，不要去读代码，让AI对代码进行总结架构，然后去了解各个模块的内容。对于AI如何使用后文会提及。
大一次年一月到七月，可以开始辅助学长备赛同时，尝试学习opencv和pytorch，熟悉常用的slam算法，熟悉这两项将会是后续开发的基础。
接下来你是大二了，该敲定选用的算法方案了。到这里你应该就有自己的备赛节奏了。

4. 基础传感器知识

本文章最重要的饺子醋

4.1 图像传感器

图像传感器，大部分都是相机，比如常用的USB免驱相机，帧率和分辨率以及各种图像参数不方便调整，但是稳定性很高。其次就是需要使用专业SDK的工业相机，经典的就是海康威视的工业相机，从帧率和参数可调上都是深入开发的最佳选择。
相机一般由多个部分组成，包括传感器，镜头，外围电路。传感器分为堆栈式和背照式，堆栈式读出速度较快，不容易触发明显果冻效应
相机传感器是逐行扫描的：曝光时从第一行开始逐行读出，这种曝光方式称为卷帘快门（Rolling Shutter）。因为每一行的曝光时刻有先后，当画面中存在高速运动的物体时，先曝光和后曝光的行拍到的位置不同，物体就会出现倾斜、扭曲，这就是常说的果冻效应（Jello Effect）。与之对应的是全局快门（Global Shutter），所有像素在同一时刻曝光，高速运动场景下画面不会变形，很多工业高速相机采用的就是全局快门。

要理解这些现象，需要从传感器的硬件原理说起。图像传感器的核心是一块感光芯片，最常见的是 CMOS（Complementary Metal Oxide Semiconductor，互补金属氧化物半导体） 传感器。芯片表面排列着密密麻麻的感光单元，也就是像素（Pixel）。每个像素本质上是一个光电二极管：光线照射后，光子被转换为电子并积累起来，积累的电荷量就代表这一点的亮度；随后电荷经过放大和 ADC（模数转换）变成数字信号，再按行读出，最终组合成一幅完整的图像。分辨率指的就是像素阵列的大小，比如 1920×1080 表示水平 1920 个像素、垂直 1080 个像素。

根据内部结构，CMOS 传感器还可以分为前照式、背照式和堆栈式：

前照式（FSI，Front-Side Illuminated）：电路层位于感光层上方，光线必须穿过电路层才能到达感光二极管，进光效率有损失，暗光下噪点较多
背照式（BSI，Back-Side Illuminated）：把感光层翻转放到上方，光线直接照射感光二极管，进光效率大幅提升，暗光表现更好
堆栈式（Stacked）：在背照式的基础上，把图像处理电路堆叠到感光芯片的下方，读出速度更快，果冻效应更轻，还能集成缓存等电路

因此在选型时，堆栈式或背照式传感器通常是优先考虑的方向。

除了芯片结构，传感器尺寸同样重要。常见尺寸有 1/3”、1/2.5”、1/1.8”、1” 等，尺寸越大，同等分辨率下单像素面积越大，单个像素能接收的光子越多，噪点越少、动态范围越好。这也是为什么同样的分辨率，大底相机的画质明显更好。

曝光参数方面，图像亮度主要由三个量决定：快门时间（曝光时间）、增益（ISO） 和光圈。快门时间越长进光越多，但运动物体更容易模糊；增益提高可以提亮画面，但会放大噪点；光圈由镜头控制，决定进光口径。在算法组的场景下，比赛场地光线变化大，通常需要根据环境动态调整曝光时间与增益，保证图像不过曝、不欠曝，识别算法才有稳定的输入。

最后是镜头。镜头决定相机的视场角与成像质量：焦距越短，视场越广，能看到更大的范围，但远处的物体在图像里更小；焦距越长，视场越窄，等效于”拉近”。镜头的畸变也是需要注意的，普通的广角镜头存在桶形畸变，画面边缘的直线会向外弯曲，如果要做像素坐标和物理坐标的映射，一般需要先做相机标定来矫正畸变。

4.2 IMU 传感器

本小节作者：uwvwko-zzz

IMU（惯性测量单元）是机器人上最常用的传感器之一，用来测量载体自身的角速度和加速度，进而解算出姿态和运动状态。可以说，只要是会动的东西——无人机、平衡车、四足机器人、人形机器人——上面几乎都有一颗 IMU。

IMU 一般由加速度计和陀螺仪组成，两者各三个轴，合称 6 轴；再加上三轴磁力计就是 9 轴（俗称 AHRS 参考系统）。加速度计感受比力（静止时能读到重力大小和方向），陀螺仪感受角速度，两者互补：陀螺仪短期精度高但会漂移，加速度计长期不漂但动态响应差、振动干扰大，所以工程上几乎总是用互补滤波或卡尔曼滤波把两者融合起来，得到稳定的姿态角。

从芯片原理上讲，消费级 IMU 基本都是 MEMS（微机电系统）工艺：在硅片上刻蚀出微米级的悬浮机械结构。加速度计的核心是一个由弹性梁支撑的检测质量块，加速度使质量块相对基座发生位移，带动梳齿状电极的极距/正对面积变化，通过差分电容检测把机械位移转成电信号；陀螺仪则利用科氏效应工作，先驱动质量块沿某个方向做持续微振动，芯片一旦旋转，质量块就会受到垂直于振动方向的科氏力，引起检测模态的位移，同样由电容变化读出，其大小正比于角速度。单芯片内还集成了温度传感器（用于温漂补偿）和 ADC，直接输出数字量。MEMS 器件体积小、集成度高、耐冲击、便宜，但相比光纤、激光陀螺噪声和零偏大得多，这是消费级 IMU 必须做滤波和标定的根本原因。

入门最经典的是 MPU6050，便宜、资料多，I2C 接口直接读原始数据，适合第一次写驱动和理解数据处理流程，但它的噪声和温漂比较大，并且鉴于其作为初代六轴芯片早已停产，不建议用在任何正式设计上，只适合学习。做机器人项目常用 BMI088 和 ICM 系列（如 ICM-42688），噪声密度低、支持 SPI 高采样率。如果不想自己写姿态解算，也可以直接买维特智能 WT901/达妙imu 这类成品模块，通过封装好的串口/ros2模块直接输出欧拉角和四元数，上手快。

使用 IMU 时要重点关注三个参数：量程、噪声密度和零偏稳定性。量程按应用选，平衡车 ±2g 够用，无人机会摔会翻滚，一般选 ±16g、±2000°/s；噪声决定了姿态解算的最终精度；零偏（bias）则是温漂的主要来源，高精度场合要做全温标定。使用前必须做静止校准：陀螺仪去零偏，加速度计校水平。安装上也有讲究，IMU 要尽量刚性固定在机体上、远离电机和振动源，实在避不开就加软垫减振，否则陀螺仪会被振出虚假角速度，这是四足机器人和无人机上非常常见的坑。

数据读取方面，I2C 适合低速场合（400kHz 下 100~200Hz 够用），SPI 适合高采样率（1kHz 以上，飞控和腿部姿态估计常用）；输出的是原始值，要乘以分辨率转换系数才得到物理单位。拿到数据后，典型处理流程是：校准去零偏 → 低通或陷波滤波去振动 → 与其他传感器（编码器里程计、相机、激光）做融合。

在上位机上使用 IMU 一般有三条路线。最底层的是直读裸芯片：按寄存器手册通过 I2C/SPI 读出原始值，乘以分辨率系数得到物理量，再自己写 Mahony/Madgwick 或 EKF 做姿态解算，适合吃透原理；成品模块走串口更省事，模块内部已经解算好姿态，通过 USB 转 TTL（CH340/CP2102）按固定协议帧输出，例如维特智能的 0x55 帧头系列，每帧携带欧拉角/角速度/加速度等字段，上位机用 pyserial 按”帧头 + 长度 + 数据 + 校验和”解析字节流即可；ROS2 中则把解析封装成节点，将数据填入 sensor_msgs/Imu 发布到 /imu/data 话题，轴向定义要对齐 REP 103/REP 145，并且要在收到数据的当下打时间戳（而不是用处理或转发时刻），否则下游 EKF 融合的时序会错乱。之后交给 robot_localization 的 EKF 节点，IMU 提供姿态和角速度，编码器提供速度，最终输出稳定的 odom→base_link 里程计。达妙、维特这类成品模块官方一般都提供 ROS2 驱动包，拿来即用。

以上方案主要用于导航定位。而在四足机器人强化学习部署中，IMU 的用法不太一样：它不再服务于 EKF 里程计，而是直接为策略模型提供本体状态观测。典型流程是：策略在 Isaac Gym/Isaac Lab 中训练时，观测里就包含机体系角速度和投影重力向量（即重力单位向量旋转到机体坐标系下的表示，训练日志里的 proj_gravity，它隐含了机体的俯仰和横滚姿态）；部署到实机时，IMU 以足够高的频率（通常 200Hz 以上）输出角速度和四元数，上位机用四元数把世界系重力向量旋转到机体系得到投影重力向量，再经过和训练时一致的缩放与截断，拼进 obs 送入网络推理，控制频率一般 50Hz。这套链路对延迟非常敏感——IMU 采样到关节指令下发每多 10ms，机器人在快速步态下就多一点打滑和摔跤的倾向，所以实机上往往绕开 ROS 话题，直接在控制进程里读 IMU。另外要注意观测一致性：训练时通常对角速度和投影重力加了噪声做 domain randomization，如果实机 IMU 噪声特性差异过大，需要重新标定或调大训练噪声，否则会出现仿真里能跑、实机上抖动甚至站不稳的 sim2real 落差。

4.3 激光雷达（LiDAR）

激光雷达（LiDAR，Light Detection and Ranging）是机器人感知距离的主力传感器。和相机”被动感光”不同，激光雷达主动发射激光：激光器发出脉冲，遇到物体反射回来，接收器测量光从发出到返回的时间差，乘以光速再除以 2 就得到距离。因为光速恒定，这种 TOF（Time of Flight，飞行时间）测距 精度很高，而且不依赖环境光照——漆黑的夜晚、逆光、炫光环境下相机可能直接导致数据不可用，而激光雷达照样稳定输出。

激光雷达输出的是一帧点云（Point Cloud）：每个点包含三维坐标（x，y，z）和一个反射强度（intensity），强度值反映了物体表面的反射率。一帧点云就相当于告诉你”这周围哪里有障碍物、分别在哪个方向、多远”，非常适合建图、定位和避障。不过由于没有rgb信息，通常而言激光雷达难以分辨物体种类。但是结合点云语义分割也是可以识别出一些特定特征的。

按扫描机构的不同，激光雷达主要分为机械式旋转激光雷达和固态/半固态激光雷达两大类。下面用两款最经典的雷达说明结构差异。

VLP-16（机械式，重复线扫描的代表）

VLP-16 是 Velodyne 的经典 16 线机械雷达，早期自动驾驶和 SLAM 研究几乎人手一台。它的结构非常直观：16 对激光收发器竖直排列在电机底座上，每对收发器对应一个固定的垂直仰角，从 -15° 到 +15° 均匀分布（垂直视场 30°，相邻两线夹角 2°）。工作时电机带动整组收发器绕竖直轴高速旋转，一边转一边发射激光，于是扫出水平 360° 的点云。值得一提的是vlp并没有使用滑环达到交换数据和电源，而是使用电磁感应进行数据交换。这也使得其使用寿命几乎不受零件老化影响。

关键参数：点率 300,000 点/秒；水平角分辨率取决于转速，10Hz 转速下约 0.2°；量程约 100m。电机每转一圈，16 条激光就扫出 16 圈”圆环”，而且这个扫描图案每一圈、每一帧都一模一样，这就是重复线扫描（Repetitive Scanning）。

Mid-360（棱镜式，非重复扫描的代表）

Mid-360 是 Livox 的混合固态雷达，内部没有旋转电机，靠的是 Risley 棱镜：四线激光穿过两个以不同角速度旋转的楔形棱镜，出射方向被连续折射改变，光斑在视场内走出李萨如（Lissajous）花瓣形轨迹。三个棱镜模组围成一圈，拼接出水平 360°、垂直 -7°~+52°（共 59°）的视场；点率 200,000 点/秒，量程约 70m，近处盲区只有 10cm。

棱镜式雷达的扫描轨迹每一时刻都在变化，每一帧的图案都不重复，这就是非重复扫描（Non-Repetitive Scanning）。随着扫描时间增加，视场内的覆盖越来越密、盲区越来越少，官方描述就是”每帧扫描轨迹均不重复，随着扫描时长增加，视野盲区逐渐减少”。具体积分时间对应扫描率可以在官网查询。

重复线扫描 vs 非重复线扫描

对比项	重复线扫描（VLP-16）	非重复线扫描（Mid-360）
扫描轨迹	每帧固定：16 条圆环	每帧不同：花瓣形轨迹持续填充视场
帧间一致性	高，帧与帧图案完全相同	低，轨迹时刻在变
视场覆盖	线与线之间有固定间隙，细长物（电线、杆子）可能漏检	随时间累积覆盖趋于完整，细小物体识别更好
近距盲区	旋转机构体积大，盲区较大	棱镜式结构紧凑，Mid-360 盲区仅 10cm
运动畸变校正	相对简单，逐线时间戳固定	更困难，轨迹不规则
SLAM 算法	经典算法直接可用（ALOAM、LIO-SAM、NDT 等）	需要专门适配（FAST-LIO、LIO-Livox、Point-LIO）
典型场景	室外大范围建图、自动驾驶	室内/近距导航、移动机器人、手持扫描

一句话总结：重复线扫描”稳”——帧间关系好、算法成熟；非重复线扫描”密”——覆盖全、细节好，但算法要专门适配。

实战层面，算法组做导航时：室外场地建图可以选 VLP-16 这类机械雷达，走经典的 LOAM 系算法；室内或近距避障更推荐 Mid-360，配合 FAST-LIO 系列（FAST-LIO2 官方就有 Livox 适配）。点云处理用 PCL，ROS2 下用 livox_ros_driver2 驱动直接输出 sensor_msgs/PointCloud2，接进自己的导航栈即可。

4.4 接触式传感器

以上提到的传感器，都是不需要和探测物体产生接触的，并且有部分直接支持和上位机通信，这一小节中介绍的一些传感器大部分都不支持与上位机直接通信，因此在后续的一些章节将会介绍具体用法，这里只介绍传感器用途和原理。

关节电机

关节电机（Joint Motor）是一种用于控制机器人运动的电机，通常用于机器人人的关节处。关节电机的输出力可以控制机器人的运动，也因此关节电机本身就是个丰富的传感器，包括位置检测，力矩检测，速度检测等都可以实现。

气压计（Barometer）

一般接入气路当中，用于测量环境压力。

微动开关（Microswitch）

用于检测物体是否触摸到传感器，通常用于触发事件。例如在2026MTI的R2夹爪原定就是使用微动开关进行检测的。

霍尔传感器（Hall Sensor）

霍尔传感器是一种用于检测磁场的传感器，通常用于检测转动副的位置。霍尔传感器的输出信号是模拟信号，需要通过模数转换（ADC）转换为数字信号。进阶用法也可以检测到速度。

5. 嵌入式软硬件基础

你可能会疑惑，为什么需要嵌入式基础？这不是算法文档吗？事实上，算法拥有一定的嵌软能力甚至是个加分项。毕竟甚至有一部分算法可以在单片机上运行，而且算法基础也基本适用于单片机，因此单片机基础也是值得花上一点时间来玩的。
目前主流的单片机有两个方向，一个是以stm为代表的arm单片机，在几乎所有比赛队伍中都是arm单片机较为常见。另一种则是以esp32为代表的riscv单片机，其实也只有esp用的比较多。arm指令集由于较为精简，其处理器低功耗和实时性都较为优秀，开发工具链成熟，是目前使用较多的单片机。而riscv则是今年兴起的单片机，主力就是esp32.esp系列由于较高的性能加上自带射频控制器，能够简单的就调用wifi和蓝牙，也因此成为个人爱好者和部分智能家居青睐的芯片。
按照目前的趋势来看，arm单片机仍然是主流，而riscv单片机则是在快速成长中。因此个人建议按照喜欢的功能去选择即可。本文将会尽量少涉及技术细节，以防止在学习过程中造成阻碍。
首先，单片机都有各自成熟的开发工具链，例如stm32的keil，esp32的vscode等。当然也不乏第三方工具链，比如stm32也可以选择通过插件在vscode中编译烧录，而esp32还有arduinoIDE高度硬件抽象化和platformIO插件进行开发的选择。在一些简单项目中，也不必要使用上位机进行开发。很多时候mcu其实足以处理各种工作。尤其是一些在边缘计算运行视觉和神经网络的平台。具体该如何取舍需要根据项目抉择。
对于单片机的学习路径，个人推荐是找感兴趣的开源项目进行复刻，然后深入修改项目。在修改项目过程中即可学习相关技术细节。在后续需要一些传感器验证的时候，拥有嵌软开发能力可以极大的方便验证甚至完成开发。
同理，在硬件中，也需要寻找开源项目，了解芯片，电路选型，电路走线等等基础内容。事实上很多技术栈不用很深入，只需要有一定基础就已经可以独立完成很多东西了。能够独自快速完成全链路测试，才能更好的排查问题而不是甩锅。

6. 如何使用ai编程

本文章第二重要的饺子醋

CURC-ROBOCON2026 R2代码

2026-07-31T16:03:12.000Z

CURC-ROBOCON2026 R2代码解析

Robocon 2026 “功夫探秘”主题赛 — R2上位机代码

硬件平台

项目	型号	说明
LiDAR	Livox MID-360	360°×59° 非重复扫描，40m 量程，内置 IMU
深度相机	Intel RealSense D415	RGB-D，用于视觉检测与测距
USB 相机	任意 USB 相机	OpenCV 采集，自动重连
底盘	全向轮（地沟哎A板下位机）	CH340 USB 串口，115200 baud
计算平台	9300H + 1650	Ubuntu 24.04, ROS2 Jazzy

顶层目录结构

├── src/                          # ROS2 功能包│   ├── spark_fast_lio/           # FAST-LIO2 LiDAR-IMU 里程计│   ├── omni_chassis_bridge/      # 全向轮底盘串口桥接（Nav2 → STM32）│   ├── usb_cam_node/             # USB 相机节点│   ├── registration/             # 点云配准与全局重定位│   │   ├── KISS-Matcher/         # 全局点云匹配（FPFH + TEASER++）│   │   └── global_relocalization_kiss_matcher/│   └── kfs_core/                 # KFS 推理核心（C++ ONNX YOLO）├── launch/                       # 一键启动脚本├── config/                       # 配置文件（LiDAR / Nav2 / URDF）├── maps/                         # 建图输出（map.pgm + map.yaml）├── scripts/                      # 工具脚本└── docs/                         # 文档

ROS2 功能包（`src/`）

spark_fast_lio — FAST-LIO2 里程计

基于 MIT-SPARK 的 FAST-LIO2，使用 ESIKF（误差状态迭代卡尔曼滤波）结合 ikd-Tree 实现轻量级 LiDAR-IMU 里程计。核心算法（IKFoM、ikd-Tree、点云去畸变）保持原版不变，在预处理、后处理、配置和 Nav2 集成层面进行了大量定制。

输入：/livox/lidar（Livox CustomMsg，xfer_format=1）+ /imu/data（经 mid360_imu_converter.py 从 g 转换为 m/s²）
输出：/cloud_registered（世界帧配准点云）+ map → base TF + /odometry（含 twist 速度）
三套 Launch 配置：

模式	Launch 文件	配置文件	用途
`mapping`	`mapping_mid360.launch.yaml`	`mid360.yaml`	建图，累积点云，Ctrl-C 自动导出 PCD
`loc`	`mapping_mid360_loc.launch.yaml`	`mid360_loc.yaml`	加载先验 PCD 到 ikd-Tree，ICP 匹配纯定位
`odom`	`mapping_mid360_odom.launch.yaml`	`mid360_odom.yaml`	里程计模式，发布 `odom → base` TF，供 KISS-Matcher 全局重定位

代码架构

spark_fast_lio.h 中的 SPARKFastLIO2 类继承自 rclcpp::Node，核心成员：

Preprocess（preprocess.h）：Livox CustomMsg 解析、点云去畸变、方向性盲区过滤、时间同步
ImuProcess（imu_processing.hpp）：IMU 前向传播、ESIKF 预测步骤
KD_TREE（ikd_Tree.h）：增量 kd-tree，支持动态插入、删除和重平衡
esekfom::esekf（esekfom.hpp）：误差状态迭代卡尔曼滤波器

主循环（1ms wall timer → main()）：syncPackages() 同步 LiDAR-IMU 数据 → IMU 前向传播 → 点云去畸变 + 降采样 → 滤波链（见下文）→ lasermapFovSegment() 提取局部地图 → calcHModel() 计算观测模型 → EKF 迭代更新 → mapIncremental() 增量更新 ikd-Tree。

50Hz 独立 odom 发布：主循环只在收到 LiDAR 帧时触发，但 Nav2 和动作组控制回路需要稳定的 odom 流。为此新增了 odom_timer_（20ms 周期），独立于主循环以 50Hz 持续发布最新的 map → base TF 和 odometry，避免下游控制回路更新频率过低。

数据预处理链路

FAST-LIO 的输入数据在到达主循环之前需要经过两个外部节点：

MID-360 硬件 ──CustomMsg──→ livox_ros_driver2 ──/livox/lidar──→ FAST-LIO                                 └── /livox/imu ──→ mid360_imu_converter ──/imu/data──→ FAST-LIO

mid360_imu_converter.py：MID-360 内置 IMU 的加速度输出单位是 g（重力加速度），而 FAST-LIO 需要 m/s²。这个 35 行的节点纯粹做单位转换——订阅 /livox/imu，将 linear_acceleration 三轴分量乘以南京本地重力加速度 G = 9.7949 m/s²，重新发布到 /imu/data。代码中直接修改入参对象以复用内存，避免 200Hz IMU 流产生不必要的分配开销：

def cb(self, msg: Imu):    msg.linear_acceleration.x *= G  # g → m/s²    msg.linear_acceleration.y *= G    msg.linear_acceleration.z *= G    self.pub.publish(msg)

与原版 MIT-SPARK 的主要差异

1. Livox MID-360 传感器适配

预处理新增方向性盲区参数 blind_front（建图 0.85m / 定位 0.30m）和 blind_rear（建图 0.35m / 定位 0.50m），根据点的 X 坐标方向选择不同盲区距离——前方用小盲区保留障碍物检测，后方用大盲区过滤机器人自身结构
is_from_pilot_zone() 新增 "livox" 模式，过滤动态点云和操作人员干扰（blind_for_human_pilots: 0.45）
配置 MID-360 专用外参：extrinsic_T = [0.011, 0.02329, -0.04412]（来自 MID-360 用户手册，IMU 相对 LiDAR 光心位置）
每套 Launch 文件通过 static_transform_publisher 硬编码 MID-360 安装位姿：
- 建图模式：base → livox_frame 无偏移（x=0, z=0, pitch=0, yaw=0），便于直接从地图原点开始建图
- 定位/里程计模式：base → livox_frame（x=-0.324, z=0.324, pitch=45°, yaw=180°），对应实际安装位姿

2. 先验地图重定位（Loc 模式）

原版 MIT-SPARK 不具备此功能，在 spark_fast_lio.cpp 的构造函数中实现：

启动时通过 prior_map_path 加载 PCD 先验地图，经体素降采样（prior_map_voxel: 0.3m）后直接 ikd_tree_.Build() 初始化
坐标系转换：PCD 保存在 map（base 世界帧 W_b），而 ICP 匹配的实时点云在 IMU 世界帧 W_i。加载时通过 offset_R_B_I = offset_R_L_I × lidar_R_wrt_base⁻¹ 将 PCD 点转换到 W_i 帧，才能与实时扫描正确匹配
/initialpose 回调：将 Nav2 提供的 map 系位姿转换为 IMU 系位姿，膨胀 EKF 协方差（pos=0.25m, rot=0.1rad），让 ICP 在初始猜测附近收敛
定位模式下关闭所有非必要发布（scan_publish_en: false, dense_publish_en: false, path_en: false），节省 CPU 和网络带宽

3. 四种点云滤波器

原版完全没有这些滤波器，全部为本地新增：

滤波器	实现方式	参数	适用场景
动态点滤波	多帧一致性检测：维护最近 N 帧体素化历史，只保留至少在 K 帧中出现的体素	`dyn_filter.{num_frames:5, min_hits:3, voxel_size:0.3}`	建图时关闭（低纹理场景会过度删除），导航时可用
去顶滤波	Z 轴 PassThrough 滤波，去除 z > 3.0m 的天花板点	`ceiling_filter.{enabled:true, max_z:3.0}`	室内场地常开
离群点滤波	RadiusOutlierRemoval，搜索半径内邻居不足则移除	`radius_filter.{enabled:false, radius:0.3, min_neighbors:2}`	建图时关闭（稀疏场景易误删），复杂地形可开启
机器人本体滤波	在 livox_frame 坐标系中定义盒体，盒内点直接丢弃	`robot_body_filter.{x:[-0.75,0.05], y:[-0.30,0.30], z:[-0.32,0.08]}`	常开

滤波调用顺序：机器人本体滤波（body帧）→ 转世界帧 → 去顶 + 离群点滤波 → 动态点滤波 → 加入 ikd-Tree

此外，lidar_body_filter_node.py 还提供了一个独立的 Python ROS2 节点，使用 numpy 向量化在 livox_frame 中做相同的盒式过滤，发布 /livox/lidar_filtered 和 /robot_body_box（RViz Marker 可视化），可独立于 FAST-LIO 运行。

4. Nav2 集成适配

Odometry 发布中新增 twist（速度）计算：线速度由位姿差分得到并转换到 base 帧，角速度由四元数差计算——Nav2 的 DWB 规划器依赖 twist 数据
PCD 保存坐标系改为 base 世界帧（W_b = "map"），与 odometry 发布的 TF 保持一致
析构函数 flush：Ctrl-C 退出时自动将累积点云写入 PCD，同时修复了原版 interval <= 0 时不累积的 bug

5. 工程改进

timediff_lidar_wrt_imu 类型从 double（秒）改为 int64_t（纳秒），提高时间同步精度
IMU 时间戳回环检测增强：回环时重置 kf_for_preintegration_ 并禁用时间同步偏移
支持多帧点云发布：/cloud_registered（世界帧）、/cloud_registered_lidar（livox_frame）、/cloud_registered_body（imu 帧）、/cloud_registered_base（base 帧），方便调试不同坐标系下的点云形态
通过 pcl_verbose: false 关闭 PCL 控制台输出，减少日志噪音

6. 配置参数对比

参数	原版 MIT-SPARK	本地版本	说明
`lidar_type`	2/3/4（Velodyne/Ouster）	1（AVIA/Livox）	MID-360 CustomMsg
`scan_line`	16/64	6	MID-360 扫描模组数
`blind`	0.3	0.4	近距离噪声适配
`blind_front/rear`	无	0.85/0.35（建图）	新增方向性盲区
`det_range`	300.0	40.0	MID-360 量程
`extrinsic_T`	Velodyne/Ouster	[0.011, 0.02329, -0.04412]	MID-360 手册值
`prior_map_path`	无	有（loc 模式）	新增先验地图重定位
`pcd_save.interval`	-1	100	修复原版不累积 PCD 的 bug
`gravity_alignment`	默认开启	关闭	否则静止时永远不发 TF
`filter_size_map`	0.5	0.3	更精细的体素分辨率

omni_chassis_bridge — 底盘桥接

原定功能为将 Nav2 的 /cmd_vel（Twist）转换为 23 字节串口协议帧，发送给 STM32 下位机。后因方案变更，该功能主要为动作组服务。

# 全向映射vx（前后）→ ch1  # 28~228, 中位 128vy（左右）→ ch2  # 28~228, 中位 128ω （旋转）→ ch3  # 11~245, 中位 128

特性：

自动检测 /dev/ttyUSB0，不存在则进入模拟模式
50 Hz 发送频率
13 字节回传帧解析（帧头 0xAC + 数据 + 帧尾 0xAB）
调试 UI 已迁移至独立的 PyQt5 进程（见下文 GUI 调试界面）

registration — 点云配准与全局重定位

包含两个子包：

KISS-Matcher：无初值全局粗配准

FPFH 特征描述子 + TEASER++ 鲁棒估计 + small_gicp 精配准
支持 C++ 和 Python 绑定（pybind11）

global_relocalization_kiss_matcher：ROS2 封装

累积 FAST-LIO 输出的 /cloud_registered 点云
与先验 PCD 地图进行全局匹配
成功后持续发布 map → odom TF
支持任意位置开机自动定位

在实际导航中，首先通过 KISS-Matcher 获得一个初始位姿，随后再进行后续导航动作。

kfs_core — KFS 推理核心

C++ 编写的 ROS2 节点，封装 ONNX Runtime + YOLO 检测：

// 话题接口// 订阅: ~/enable (Bool)          - 推理使能// 服务: ~/trigger (Trigger)      - 触发单次推理// 发布: ~/result (InferResults)   - 检测结果数组//       ~/debug_image (Image)     - 标注画面

支持 USB 相机和 RealSense 两种输入，可通过 rqt_reconfigure 动态调节置信度、IOU 阈值等参数。本节点的推理部分由其他队员（leezoneline）完成，实际运行使用 yolo11s 模型，显存占用不到 1G，在 1650 显卡下性能开销优秀。

usb_cam_node — USB 相机节点

基于 OpenCV V4L2 后端，发布 sensor_msgs/Image：

自动扫描 /dev/video*
断开后每 2 秒自动重连
相机不可用时发布黑色测试图以保持话题活跃
支持 OpenCV 实时预览窗口

SLAM 与导航

建图

python3 launch/start_mid360_fastlio_mapping.py

流程：MID-360 驱动 → IMU 转换 → FAST-LIO2 建图 → Ctrl-C 导出 PCD → 投影为 2D 占用栅格

导航（两种定位方案）

方案 A — FAST-LIO 先验地图定位（固定位置开机，不推荐使用）：

map ← FAST-LIO(loc) ← base ← livox_frame

需在 RViz 中手动设置初始位姿，偏差较大。

方案 B — KISS-Matcher 全局重定位（推荐，任意位置开机）：

map ← KISS-Matcher ← odom ← FAST-LIO ← base ← livox_frame

自动累计点云与先验地图全局匹配，无需手动设置初始位姿，偏差取决于配准算法误差，实际运行中误差极小。

一键启动脚本

脚本	功能
`start_mid360_fastlio_mapping.py`	建图 + 自动导出 Nav2 地图
`start_mid360_fastlio_loc.py`	纯定位（不建图）
`start_mid360_nav2_loc.py`	定位 + 导航全栈（方案 A）
`start_mid360_nav2_kiss.py`	定位 + 导航全栈（方案 B）+ UI 调试界面
`start_mid360_preview.py`	点云预览

Launch 编排系统（Stage 模式）

所有 start_mid360_*.py 启动脚本共用一套自实现的 Stage 类来编排多进程 ROS2 系统，替代了 ROS2 原生的 launch 文件。核心设计思想是 分阶段启动 + 话题就绪检查 + 并行启动 + 优雅停止。

每个 Stage 封装一个子进程及其就绪条件：

class Stage:    name: str          # 日志标签    cmd: List[str]     # 启动命令    ready: Callable    # 就绪条件函数（如 topic_exists('/odometry')）    ready_timeout: float  # 就绪超时（默认 25s）    proc: Popen        # 子进程句柄    log_file: File     # 独立日志文件

启动流程（以 start_mid360_nav2_kiss.py 为例）：

1. cleanup_existing() 并行清理旧进程（pkill 所有已知节点名）2. Group 1 并行启动: driver + chassis（无依赖）3. Group 2: imu-conv（依赖 /livox/imu）4. Group 3: fast-lio-odom（依赖 /imu/data）5. Group 4 并行启动: 其余所有（kfs-infer + debug-executor + debug-ui + rviz + standby-trigger）

每个 Stage 启动后阻塞等待其就绪条件（通过 ros2 topic info 检查话题存在性或 tf2_echo 检查 TF），超时则抛出异常。无依赖的 Stage 通过 _start_group() 并行启动，减少总启动时间。

优雅停止：Ctrl-C 后逆序遍历 stages 列表，先发送 SIGINT（5s 超时），若进程未退出则 SIGKILL。每个 Stage 通过 os.setsid 创建独立进程组，os.killpg() 确保子进程的子进程也被一并杀死。

日志系统：每个 Stage 的 stdout/stderr 写入独立日志文件（logs/debug_stack/20250101_120000/stage_name.log），同时实时输出到终端（带彩色标签）。所有包含 ERROR、FATAL、TRACEBACK 等关键字的行自动汇总到 _errors.log，方便赛后排查。

环境变量模块化：所有模块默认开启，通过环境变量选择性关闭：

环境变量控制

变量	默认	作用
`NO_RVIZ=1`	开 RViz	关闭 RViz
`NO_CHASSIS=1`	开底盘	关闭底盘桥接
`NO_LOGIC=1`	开主逻辑	关闭航点逻辑
`NO_UI=1`	开调试 UI	关闭 PyQt 调试界面
`LOGIC_DELAY`	`5.0`	主逻辑启动前等待秒数

串口通信协议

23 字节定长帧，50 Hz 发送频率：

索引	含义	值范围
0	帧头	保密
1	ch1 左右平移	28~228 / 128
2	ch2 前后平移	28~228 / 128
3	ch3 自转	11~245 / 128
4	ch4 抬升/机械臂	0~255 / 0
5	校验位	保密
6-9	吸盘/夹爪/灵足	0/1
14	校验位	保密
15-18	滑轨/幅度/视觉切换	0/1
19	校验位	保密
20-21	灵足角度	int16
22	2006 电机位置	0~255

构建与运行

# 编译source /opt/ros/jazzy/setup.bashcolcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Releasesource install/setup.bash# 建图python3 launch/start_mid360_fastlio_mapping.py# 导航（方案 B，推荐）python3 launch/start_mid360_nav2_kiss.py# 调试：仅 SLAM + Nav2，不动底盘NO_CHASSIS=1 NO_LOGIC=1 NO_UI=1 python3 launch/start_mid360_nav2_kiss.py

GUI 调试界面

基于 PyQt5 的 ROS2 调试界面，采用三层解耦架构：

UI 层（PyQt5 QWidgets）    ↕ Qt 信号/槽ROS2Bridge（QObject）    ↕ rclpy 订阅/发布ROS2 执行层（debug_executor_node）

核心设计理念是 UI 与执行层完全解耦：UI 进程（debug_ui_node.py）只负责显示和发布控制请求，动作组执行由独立的 debug_executor_node.py 完成。即使 UI 卡死，已启动的动作也不会被终止。

项目结构

ros2_debug_gui/├── main.py                    # 程序入口├── requirements.txt           # 依赖├── config/│   └── config_manager.py      # 配置管理（JSON 持久化）├── ros_interface/│   └── ros_bridge.py          # ROS2 桥接层（Qt 信号 ↔ ROS2 话题）├── styles/│   └── themes.py              # 主题样式（淡色/深色 + 透明度）└── ui/    ├── main_window.py         # 主窗口（QMainWindow）    └── tabs/        ├── main_tab.py        # 主界面（里程计 + 动作组 + 诊断 + 日志）        ├── test_tab.py        # 测试（开环测试 + PID 调参）        ├── vision_tab.py      # 视觉（实时画面 + 手动控制 + 录制）        ├── motor_tab.py       # 电机（实时力矩/位置曲线）        ├── topics_tab.py      # 话题（话题列表 + 节点关系图）        └── preferences_tab.py # 首选项（主题/背景/透明度/强调色）

窗口结构

MainWindow（QMainWindow, 1200×750, 最小 900×600）├── 菜单栏: 文件（退出 Ctrl+Q）/ 视图（首选项 Ctrl+,）/ 帮助（关于）├── QTabWidget（6 个选项卡）│   ├── 主界面（MainTab）      - 动作组 + 里程计 + 诊断 + 日志│   ├── 测试（TestTab）         - 开环测试 + PID 调参 + 机械臂/灵足/2006 控制│   ├── 视觉（VisionTab）       - 实时画面 + 3×3 手动方向控制 + 视觉触发 + 视频录制│   ├── 电机（MotorTab）        - 力矩/位置曲线 + 峰值统计│   ├── 话题（TopicsTab）       - 话题列表 + 节点-话题关系图 + 话题详情│   └── 首选项（PreferencesTab） - 主题/背景/透明度/强调色/背景图片├── 状态栏: "就绪"└── paintEvent: 支持背景图片（可调不透明度）

选项卡功能详解

主界面 Tab（main_tab.py）：水平 QSplitter 分左右两栏，支持拖拽调整大小并自动保存

左栏：里程计状态（x/y/z/yaw）+ 里程计归零 + 动作组选择（单选按钮，选中后显示详细步骤描述）+ 执行/停止/急停按钮
右栏：节点诊断面板（节点状态、更新频率、机械臂、灵足、2006 电机、灵足力矩等 9 项，500ms 刷新）+ 实时日志（按级别着色：INFO 蓝 / WARN 橙 / ERROR 红，带时间戳）

测试 Tab：开环测试 + PID 实时调参

开环控制：前进/后退/左转/右转（速度 × 时长）+ 机械臂高度/灵足角度/2006 电机/夹爪/吸盘/气阀/继电器

5 组 PID 参数，运行时通过 /debug_ui/open_loop 话题发送 type=set_pid;... 格式化字符串到执行端动态修改：

控制对象	参数	默认值
机械臂	KP / KD / MaxRate / RxTol	80 / 1.0 / 60 / 7
灵足	KP / KD / MaxRate / RxTol	12 / 0.5 / 120 / 0.1
底盘前进	KP / KD	1.2 / 0.05
底盘旋转	KP / KD	2.0 / 0.03
2006 电机	KP / KD / MaxRate	50 / 1.0 / 100

“应用 PID” 立即生效，”保存 PID” 持久化到 JSON config。

视觉 Tab（vision_tab.py）：左侧控制面板 + 右侧实时识别画面

3×3 手动方向控制：十字布局（前进 ↑ / 后退 ↓ / 左移 ← / 右移 → / 旋左 ↺ / 旋右 ↻），使用 HoldButton（按住移动、松开停止），速度 ch 128±80（平移 0.397m/s）/ 128±100（旋转 0.93rad/s）
键盘控制：WSAD 前后左右 + QE 左右旋转，通过 eventFilter 拦截，支持多键同时按下合并速度
2006 电机：步进按钮（±10）
夹爪切换：ON/OFF 按钮，颜色联动（红色 = ON / 灰色 = OFF）
视觉识别控制：
- KFS 识别 / Weapon 识别：独立触发按钮，发布到 /kfs_infer_node/trigger_kfs 和 /kfs_infer_node/trigger_weapon
- 连续推理：模型选择（KFS / Weapon / Both）+ 开关按钮，控制 /kfs_infer_node/enable 和 /kfs_infer_node/set_continuous_mode
- 相机重连：在线程中调用 /kfs_infer_node/reconnect_camera 服务
视频录制：支持录制原始图像 / 识别图像 / 同时录制，保存为 mp4（mp4v 编码，30fps），按时间戳命名到 logs/vision_recordings/

电机 Tab（motor_tab.py）：自绘 CurveCanvas（QPainter + 滑动时间窗口）

灵足力矩曲线（红色，-2~10 N·m，仅 |力矩| ≥ 2 时绘制）
位置数据曲线（可选灵足角度/机械臂/2006 电机），最多 5000 点滑动窗口
峰值统计：力矩 > 4N 时记录，显示最近 10 秒峰值

话题 Tab：话题列表 + 节点-话题关系图（QGraphicsView 绘制，支持拖拽平移 + Ctrl+滚轮缩放）+ 话题详情（类型/频率/发布者/订阅者）

首选项 Tab：淡色/深色主题（themes.py 中的 ThemeManager，使用 rgba 透明度实现亚克力效果）、自定义背景颜色/图片（支持不透明度调节）、强调色、UI 透明度。设置自动保存到 ~/.ros2_debug_gui/config.json，下次启动恢复。

ROS2 桥接层

ros_bridge.py 中的 ROS2Bridge(QObject) 是实现 UI 与 ROS2 解耦的关键，通过 Qt 信号与 UI 通信保证线程安全。

发布话题（UI → 执行端）：

话题	类型	用途
`/debug_ui/trigger`	String	触发动作组（内容为动作组名或 “stop”）
`/debug_ui/open_loop`	String	开环/PID/手动/夹爪指令（`type=xxx;value=xxx;duration=xxx`）
`/cmd_vel_smoothed`	Twist	底盘速度（BEST_EFFORT, depth=1）
`/chassis/aux`	UInt8MultiArray	辅助通道 [arm, foot_hi, foot_lo, m2006, gripper, relay]
`/kfs_infer_node/trigger_kfs`	Bool	单次 KFS 推理
`/kfs_infer_node/trigger_weapon`	Bool	单次 Weaponhead 推理
`/kfs_infer_node/enable`	Bool	连续推理开关
`/kfs_infer_node/set_continuous_mode`	String	连续推理模型选择（kfs/weapon/both）
`/initialpose`	PoseWithCovarianceStamped	触发 KISS-Matcher 全局重定位

订阅话题（执行端 → UI）：

话题	信号	用途
`/odometry`	`odom_signal(x, y, z, yaw)`	位姿反馈（支持显示归零偏移）
`/debug_executor/status`	`diagnostic_signal(dict)`	执行端诊断（忙碌/空闲/进度/桥接状态）
`/chassis/status`	内部状态	桥接状态（real/sim）
`/standby_trigger/status`	`standby_signal(dict)`	待命状态（phase/remaining/action/team/switches）
`/kfs_infer_node/debug_image`	`image_signal(cv_img)`	识别标注画面（cv_bridge 转换）
`/kfs_infer_node/raw_image`	`raw_image_signal(cv_img)`	原始画面（用于视频录制）

通信机制

connect_ros() 创建独立 ROS2 节点 debug_gui_client_{pid}，启动 daemon 线程循环执行 rclpy.spin_once()
ROS2 回调通过 pyqtSignal.emit() 将数据传到 UI 线程，保证线程安全
两个 QTimer 定时刷新：话题列表（1000ms）+ 诊断信息（500ms）
rclpy 导入失败时自动进入模拟模式：用 QTimer 模拟里程计数据、话题列表和节点图
断开时严格按顺序清理：停止所有 QTimer → 等待 spin 线程退出 → 发布零速停止 → 销毁节点 → shutdown rclpy

动作组系统

action_groups.py 定义了 14 个预设动作组，UI 和执行层共用此文件，避免界面描述与实际动作不同步。每个动作组是步骤序列，支持子动作组嵌套（通过 action_group 步骤类型引用其他动作组）。

动作组	关键流程
红方启动	纠正前进 → 左转 90° + 机械臂 100 + 灵足 178° → 纠正到 (0.18, 0.75, 90°) → 视觉夹取 → 对接准备 → 捡取下一组
蓝方启动	纠正前进 → 右转 90° + 机械臂 100 + 灵足 178° → 纠正到 (0.4, -0.9, -90°) → 视觉夹取 → 对接准备 → 捡取下一组 → 蓝方梅林准备识别
对接准备	夹爪关闭 → 后退 65cm → 旋转 180° + 灵足 180° → 机械臂 85→72 → 灵足 255° + 夹爪闭合 → 等待力矩 > 6.5N → 松开
视觉夹取	2006 视觉对准（12px 容差，增益 0.5，连续 2 帧）→ 机械臂降 5 → 夹爪闭合 → 机械臂升 30
捡取下一组	左转 180° + 灵足 178° → 左移 20cm → 前进 65cm → 开环前进 2s → 视觉夹取 → 对接准备
归零	机械臂 → 60 → 气阀关 → 灵足 → 275° → 机械臂 → 0（跳过互锁）→ 2006 → 0
蓝方梅林准备	纠正到 (2m, 0.45m, 0°) → 机械臂 → 110 + 灵足 → 200° + 2006 → 128
蓝方梅林准备识别	识别姿态 → KFS 扫描 1s → 若 T 则拿取（臂 → 80 + 足 → 90° → 吸盘气阀 → 继电器 → 前进堵转）
红方梅林准备	纠正到 (2m, -0.45m, 0°) → 机械臂 → 110 + 灵足 → 200° + 2006 → 128
红方梅林准备识别	同蓝方对称，识别姿态 → KFS 扫描 → 若 T 则拿取
红方上梅林	2006 中位 → 横移堵转到边缘 → 机械臂 40 + 灵足 180 + 归零 → 前进直到上坡（Z + 10cm）
蓝方上梅林	同红方对称，横移方向相反（ch=178）
上梅林	通用版：2006 中位 → 机械臂 40 + 灵足 180 + 归零 → 前进直到上坡
下梅林	以 ch=103 后退，直到 Z 下降 ≥ 10cm 且车身水平
前进下梅林	以 ch=143 前进，直到 Z 下降 ≥ 10cm 且车身水平
高 200KFS 获取	机械臂 120→110 + 灵足 200 + 2006→128 → KFS 扫描 → 若 T 则前进堵转 + 臂 180 + 吸盘气阀 + 降臂至力矩 0.7N·m + 抬升返回
拿取高 200KFS	前进 0.6m → 继电器伸长 → 前进堵转 → 臂 180 + 2006 中位 → 降臂至力矩 → 吸盘气阀 → 臂 200 + 足 270 → 臂归零 → 返回
识别高 200KFS	机械臂 → 120→110 + 灵足 200 + 2006→128 → KFS 扫描 1s
识别低 200KFS	机械臂 → 120 → 继电器伸长 → 机械臂 → 110 + 灵足 130 + 2006→128 → KFS 扫描 1s
武器对接测试	机械臂 85→62 → 灵足 255° + 夹爪闭合 → 等待力矩 > 6.5N 后回落 → 松开夹爪
蓝方动作组	全流程组合：蓝方启动 → 视觉夹取 → 对接准备 → 梅林准备 → 识别（含横向移动 2.4m + 二次识别）

红蓝方对称设计：红方和蓝方的启动动作、梅林准备、上梅林等动作组通过镜像坐标和方向实现对称场地适应（红方目标 (0.18, 0.75, 90°) vs 蓝方 (0.40, -0.90, -90°)，上梅林横移方向相反）。

支持的步骤类型（共 18 种）：

步骤类型	说明	示例
`forward/backward/strafe`	PID 控制平移（距离 + 容差 + 超时）	`{'forward': 0.65, 'desc': '前进 0.65m'}`
`left/right`	PID 控制旋转（角度 + 容差），支持并行机械臂/灵足	`{'left': 180.0, 'arm': 100, 'foot_angle': 178.0}`
`arm`	机械臂位置控制（支持串口反馈容差、慢速模式、互锁跳过）	`{'arm': 85, 'use_rx_feedback': True, 'arm_slow': True}`
`arm_delta`	机械臂相对位移	`{'arm_delta': 40, 'desc': '抬升 40'}`
`foot_angle`	灵足角度控制（支持串口反馈校正）	`{'foot_angle': 255.0, 'use_rx_feedback': True}`
`m2006_pos`	2006 电机位置控制	`{'m2006_pos': 128, 'use_rx_feedback': True}`
`open_forward`	开环前进（通道值 + 时长）	`{'open_forward': 148, 'open_duration': 2.0}`
`correct_pose`	全向 PID 位置纠正（支持相对/绝对模式、禁止后退）	`{'correct_pose': True, 'target_x': 2.0, 'target_yaw': 0.0}`
`forward_until_level`	前进直到上坡（Z 上升检测 + pitch/roll 水平判断）	`{'forward_until_level': True, 'z_thresh': 0.10}`
`backward_until_level`	后退直到下坡	`{'backward_until_level': True, 'ch_val': 103}`
`forward_until_stall`	前进直到堵转（位移停滞检测 + 俯仰保护）	`{'forward_until_stall': True, 'ch_val': 148, 'stall_time': 2.0}`
`strafe_until_stall`	横移直到堵转（顶到边缘检测，限制最大距离）	`{'strafe_until_stall': True, 'ch_val': 108, 'max_dist': 3.0}`
`wait_torque_drop`	力矩对接检测（等待力矩超过阈值后回落）	`{'wait_torque_drop': True, 'torque_high': 6.5}`
`arm_lower_until_torque`	机械臂下降直到灵足力矩达标（接触桌面检测）	`{'arm_lower_until_torque': 0.3, 'rate': 10.0}`
`align_2006`	视觉对齐：2006 电机对准目标中心（连续 n 帧稳定）	`{'align_2006': True, 'align_tol_px': 12, 'align_gain': 0.5}`
`kfs_scan`	KFS 识别扫描（采集标签）	`{'kfs_scan': True, 'duration': 1.0}`
`skip_if_label_not`	条件跳过：KFS 结果不匹配则跳过后续步骤	`{'skip_if_label_not': 'T'}`
`gripper/suction/valve/relay`	夹爪/吸盘/气阀/继电器控制	`{'gripper': 1, 'suction': 1, 'valve': 1}`
`wait`	等待指定秒数	`{'wait': 0.3}`
`action_group`	子动作组嵌套调用	`{'action_group': '对接准备'}`

执行层

debug_executor_node.py 中的 ControlNode 类：

50Hz 控制回路（_loop timer），按步骤顺序执行动作组
PID 控制系统：底盘前进/旋转（带累积 yaw 跟踪解决 ±π 翻转问题）、机械臂（支持慢速模式 + 互锁保护）、灵足角度、2006 电机
底盘死区补偿：MIN_LIN_CH=15（0.034m/s）、MIN_ANG_CH=15（0.045rad/s），末端蹭进模式（误差 < 3×TOL 时以恒定最低速度推进）
串口回传反馈（/chassis/rx）：抬升高度、灵足真实角度、灵足力矩、2006 电机位置，用作闭环容差判断
视觉反馈：订阅 /kfs_infer_node/result（InferResults），align_2006 步骤通过检测框中心像素误差驱动 2006 电机
桥接失联保护：/chassis/status 使用独立 ReentrantCallbackGroup + MultiThreadedExecutor，避免串口阻塞反向波及 ROS spin 线程
诊断发布：200ms 周期发布 /debug_executor/status（含 busy/progress/desc/bridge/rx_lift/rx_m2006/rx_foot/rx_torque 等字段）
外部触发接口：/debug_ui/trigger（String）+ /debug_ui/open_loop（String），允许任意外部节点控制

互锁保护

机械臂下降到 < 45 时，灵足必须 < 215°
灵足旋转时，机械臂必须 ≥ 35

待命触发节点

standby_trigger_node.py 是比赛中的”最后一公里”——它连接了下位机遥控器与上位机自动执行，让操作手无需触碰电脑即可触发动作组。

工作原理：监控 STM32 回传帧 /chassis/rx 中的三个预留位，检测边沿变化：

预留位	索引	功能
预留位 1	`raw[3]`	触发启动：0→1 边沿触发倒计时（3s），结束后自动执行动作组
预留位 2	`raw[4]`	动作组选择：0 = 红/蓝方启动动作，1 = 上梅林（红方/蓝方自动适配）
预留位 3	`raw[5]`	暂停/恢复：0→1 暂停当前动作，1→0 归零恢复初始状态

阵营识别通过 raw[2]（0=红方, 1=蓝方）自动适配。

倒计时与状态发布：10Hz timer（_tick）实时计算剩余时间，通过 /standby_trigger/status 发布给 UI 显示倒计时进度。倒计时期间若预留位 1 变回 0 则取消。倒计时归零后通过 /debug_ui/trigger 发布动作组名到执行层，与 UI 手动触发走完全相同的通道。

对外接口：

话题	方向	用途
`/chassis/rx`	订阅	下位机回传帧（UInt8MultiArray）
`/standby_trigger/status`	发布	倒计时状态（phase/remaining/action/team/switches）
`/debug_ui/trigger`	发布	触发动作组（String，复用 UI 的执行通道）

这个节点在比赛中的实际意义是：操作手通过遥控器拨动开关即可触发完整的自动流程（启动 → 视觉夹取 → 对接准备 → 梅林识别），无需触碰电脑，大幅降低了操作复杂度。节点独立于 UI 运行，即使 PyQt 界面未启动也能正常工作。不过得益于传奇机械组减重能力，我最终还是用了一台 MacBook neo 运行 VNC 控制 R2 启动。这也导致我并没有写任何手动梅林方案

yolo-starter

2025-12-24T13:34:09.000Z

如何迅速，方便的使用和训练YOLO

YOLO是什么

YOLO意思为“you only look once”，是一种经典的深度学习神经网络视觉识别算法。目前YOLO主要是ultralytics公司在维护，这个公司也为整个系列后续代码更新提供了不晓得进步。接下来少废话直接进训练。

YOLO的版本

目前可以看到，yolo已经更新到了26版本。但是不同版本的yolo之间有少许差异，以下只列举部分版本：

yolov5：这是最经典，最多人使用的yolo版本。并且需求的算力也比较低。但是各类模型精度普遍比后续新模型要低一些。其中yolov5-6.0是早已经停止维护的旧版本仓库，新版已经迁移到ultralytics仓库。
yolov8：v5后的又一个经典，在识别速度，精度上有不少进步。
yolo11：作为v8的迭代版本，代码差异与v8很小，性能略微提升。
yolo12：官方：“我们不建议在任何场景使用”,我尝试训练发现不仅非常吃算力而且时长超级久，遂放弃。
yolo13：清华提出的模型，目前我还未做验证.
yolo26：新推出的针对端到端场景的优化推理速度的模型

如何使用yolo仓库

首先在ultralytics官方网站中点击快速入门，接下来对着pip安装即可，这会自动安装所需的依赖，并且建议自行重新检查torch版本是否符合要求。
接下来前往ultralytics的git仓库，将main分支下载到本地，接着打开本地目录，放下自己的训练脚本，我个人的脚本是

# -*- coding: utf-8 -*-import warningswarnings.filterwarnings('ignore')from ultralytics import YOLOif __name__ == '__main__':    # model.load('yolo11n.pt') # 加载预训练权重,改进或者做对比实验时候不建议打开,因为用预训练模型整体精度没有很明显的提升    model = YOLO(model=r'F:\ultralytics-R2\ultralytics\cfg\models\26\yolo26s.yaml')    model.train(data=r'train.yaml',                imgsz=640,                epochs=300,#训练轮数                batch=64,#一次训练张数                degrees=180, # 在指定的角度范围内随机旋转图像，提高模型识别各种方向物体的能力。                mixup = 1, # 混合两个图像及其标签，创建一个合成图像。通过引入标签噪声和视觉变化，增强模型的泛化能力。                workers=0,                device='0',                optimizer='SGD',                close_mosaic=10,                resume=False,                project='runs/train',                name='exp',                single_cls=False,                cache=False,                )

其中所有的相关参数均在这篇ultralytics官方文章的训练设置中提到，可以自行添加。
添加完成后，直接命令行python train.py即可开始训练。

pytorch调用

python作为轮椅一般的语言，虽然其运行效率十分堪忧，但是在易用性和快速原型验证上仍然有不错的表现。因此训练完的模型先用pytorch跑一次验证确实是不错的方案。
这里引用我开源代码节选：

    # 推理参数    predict_config = {        'conf_thres': 0.6,        'iou_thres': 0.2,        'imgsz': 640,        'line_width': 2,        'device': 'cuda:0' if torch.cuda.is_available() else 'cpu'    }    # 加载 YOLO 模型    model = YOLO(model_config['model_path']).to(predict_config['device'])    # 读取摄像头的帧    frame1 = rgb.copy()    # 使用 YOLO 模型进行推理,并传入置信度和 IoU 阈值    results1 = model(frame1, conf=0.5, iou=0.7)    detect_len = len(results1[0].boxes)  #获取检测结果的长度    # 获取检测结果的坐标并绘制检测框        boxes1 = []    if detect_len != 0:        for r in results1:            for box in r.boxes:                xyxy = box.xyxy[0].cpu().numpy().astype(int)                boxes1.append(xyxy)                cv2.rectangle(frame1, (xyxy[0], xyxy[1]), (xyxy[2], xyxy[3]), (0, 255, 0), 2)                center1 = np.array([x_center1, y_center1])    else:        print("未检测到目标")

其中model_config参数为自定义参数，会自动选择cuda或者cpu推理（前提是正确安装cuda，具体可以参考本站的cuda安装）。

3D-print

2025-11-26T12:52:09.000Z

基于拓竹打印机的3D打印教程

序言

起因是想给小登做个ppt讲解关于3D打印背后的原理，但是发现对于大部分人而言光是了解打印机就已经够费劲心思了，更别提对于其原理和维护的深入。因此我决定写下这篇文章，以个人理解方式写下一些3D打印技术的原理和打印机的维护。Let’s start it.

增材制造

在现代制造中，常见的有3种制造方式，一种是等材制造，它主要依赖于铸造、锻造等工艺，将原材料通过模具或其他工具塑造成所需的形状。在这个过程中，材料的总量是几乎不变的（理想状况下，因为损耗总是会有）。就像橡皮泥一样捏成需要的形状。第二种则是从古至今都很重要的减材制造，顾名思义，就是将耗材切削等方式减去特定量的耗材实现的制造方式。最常见的就是CNC，以及各种切割方式，只要从原料到成品有损耗则可以视为减材制造。
而我们最主要讨论的，则是近些年随着3D打印技术蓬勃发展的增材制造技术。3D打印技术目前在民间比较常用的有熔融沉积（FDM）、光固化（SLA）、尼龙烧结，金属烧结等工艺。本文将仅针对FDM做出解析。
要理解FDM是怎么工作的，只需要了解一个最基本的概念——顾名思义，熔融沉积就是将塑料热熔后一点一点的涂在上一层塑料上。

(灵魂画手抽象之作)
因此会带来一些诸如材料输入流量，喷嘴温度，冷却风扇温度等问题，后续章节我们会逐步揭晓。

现代3D打印机

现代的3D打印机较为常见的有2种结构，CoreXY和Prusa i3。而三角洲（Delta）结构打印机曾经是高速打印的代表，如今已经逐渐淡出桌面级打印机视野。CoreXY与i3结构的区别非常显著：最直接的判断方式便是看结构，i3打印机类似于龙门架，而CoreXY则是比较明显的箱式结构。

(i3常见结构)

(cxy结构)
而Ultimaker，Hbot等结构相对于cxy和i3而言，在目前的3d打印市场没有那么受欢迎（仅以销量和热度而言），因此也不做解析。

现代3D打印机常见的品牌比以前多了很多，笔者在初中时期（2019年）还是以自组机为主，而24年则选择了方便快捷的成品机。目前市面上较为常见的FDM打印机品牌例如拓竹，创想三维，爱乐酷等都有较好的性能。不过若是经济有限则自组也可以选择i3等开源资料丰富的结构。

3D打印准备

在拿到一台3d打印机后，首先我们先从机器的准备开始。一台打印机有热床，喷嘴等零件，i3打印机则是以热床，喷头的xy轴皮带，光轴为主要零件；而CoreXY则是一整根XY皮带绕组，XY轴光轴为主要零件。二者的共同点则是z轴主要为步进电机带动丝杆做出的抬升，可以保证极高的精度。
开始打印前，需要先确认耗材类型，在下一小结会讲到。确认好耗材后，通过打印机自带的进料功能挂载耗材丝。输入耗材丝后，检查打印板表面是否有残留耗材或异物，可快拆打印板检查是否安装到位，随后就可以开始打印了，这部分不做过多赘述。

耗材丝种类有什么

目前的桌面级耗材可谓是五花八门，粗略分类则可以分为容易打印的普通耗材和性能优异的工程耗材。工程耗材需要极高的打印要求，但是带来的收益也比常规耗材高很多。目前常见的耗材有PETG，PLA。

PLA作为早期沿用到现在的传统耗材，打印简单，过程毒性较小，气味香甜（？），同时也是食品级材料。但是其缺点也显而易见，就是作为有机耗材，会在紫外线下发生严重的光解，具体表现为变脆，无法使用。
PETG是相对新兴的耗材，密度与PLA相近（都是1.2），缺点则是容易受潮，但是烘干后可以恢复。PETG相对PLA在熔融状态下更为粘稠，因此容易糊嘴，会导致一系列打印失败问题。但是在一些稳定的机器上通常不会发生，不过建议时刻关注PETG耗材打印状态。
ABS作为较为早期的工程材料，打印需要较高的环境温度，因此建议使用带封箱的机器打印。ABS有独特的臭味，对身体危害较大，必须放置在通风环境。但是ABS强度也显著高于PLA，因此在早期也是较为高级的耗材。
PC，一款高强度的工程材料，极易吸水受潮。价格较贵
尼龙，极易吸水受潮，但是耐温和强度极高，机械性能也十分优秀。
PPA,一款高强度耗材，其碳纤维耗材作为打印耗材中顶尖的性能的存在，拥有几乎完美的性能，接近低碳钢的强度。
CF类耗材，是普通耗材加了一定含量的短碳纤维。5%含量可以改善材料表面质感，15%含量可以对刚度拥有较高的改善，同时PPA-CF和PA6-CF作为顶级工程材料其性能也是极高的。但是是否使用CF以及GF耗材请慎重考虑。

耗材丝会过期吗

很显然FDM 3D打印耗材基本上是塑料，并不会存在过期一说。但是PLA耗材以及会受潮的耗材确实对存放条件有严格要求。正如前文所说，PLA在光解后几乎无法使用，因此严格要求干燥阴凉处存放。光解的表现则是耗材变脆，一扯就碎。
PETG等耗材则是及其容易吸水受潮，尤其是南方。FDM 3D打印是将耗材热熔后从喷嘴挤出，因此材料的粘稠程度会导致有耗材残留在喷嘴处溢出。耗材受潮后会加重粘稠程度，导致打印质量变差甚至失败。而受潮严重的耗材甚至会在加热时产生气泡，导致打印表面十分粗糙并且大幅增加打印失败风险。

打印首层

如前文所说，FDM打印是将耗材一层一层堆叠上去。因此耗材和打印板的接触十分重要。打印首层时，若挤出不足或打印板不干净都会造成打印可能失败。
耗材在热熔后也会受到热胀冷缩影响，因此打印上层时若首层与打印板接触不牢则很容易会被上层扯起来，造成翘边问题。若发生翘边问题，打印平面将会有不同程度变形，轻则打印误差增大,重则撞坏喷嘴造成长时间的打印机停摆。

打印件翘边

打印板被带起
（图源Evan76）

若发生翘边，还是尽快停止打印并且检查参数为上。
发现翘边现象，首先检查底板温度——这是最容易排查的参数之一。底板温度不够也会导致容易产生翘边现象。对于冬天，PLA建议75度，PETG建议85度热床。若打印仍然不理想，则可以考虑封箱或使用专用胶水进行处理。

打印墙，填充

3D打印的时，我们能发现打印零件并非实心。一方面是因为实心太过于消耗材料，另一方面是因为实心对于强度并没有甚至是有反向提升。
打印件在一层的剖面结构，大致可以分成内墙，外墙，填充
外墙是影响打印件观感的第一因素，而内墙质量则会间接影响外墙。事实上，打印速度，耗材类型，喷嘴温度，流量等因素都会直接导致外墙的质量。而在薄壁打印件中由于内墙只有一层，因此稀疏填充的纹路也可能影响外墙观感。

（图源Evan76）
内外墙

（图源Evan76）
填充
对于低强度的打印，2层墙15填充的默认参数足以应付。而对于需要更高的强度，请优先调整墙厚度——推荐在2-6层之间调整。而填充率则是在15%-60%之间调整。

流量

FDM打印中对于喷嘴的流量有十足的讲究。因为不合适材料的流量将会造成打印质量的下降。
因此，部分拓竹打印机有动态流量设置。
动态流量也可以叫压力提前，线性提前，K 值，主要是在高速打印中，用于补偿挤出压力的滞后问题从而提升打印质量。挤出压力滞后是指耗材被挤出时，喷嘴内的压力需要一段时间才能实现稳定出料。在加速阶段，压力滞后可能导致挤出不足，出现线条过细或缺料；在减速阶段，剩余的压力可能造成多余耗材被挤出，出现堆料或拉丝。这些现象在高速度下更加明显。在加速时，动态流量算法通过略微增加挤出率，使压力更快升高以弥补挤出不足；在减速时，动态流量算法通过减少或反向挤出耗材，以释放残余压力，防止材料溢出。

（图源Evan76）

支撑

由于需要一层一层的将耗材涂抹，因此3D打印机对重力要求很高。这也造成一些类似T形的零件难以打印。这个时候就需要使用支撑。常见的支撑有普通支撑和树状支撑。普通支撑适合大平面支撑，树状支撑适合小面积悬空。支撑一般可以使用自动生成算法，但是遇到细高零件也可以通过手动添加支撑达到增大接触面积的做法让打印成功率增加。

悬垂

打印件成型过程中，总是不可避免地会有各种的倾斜面产生。对于那些向外倾斜到一定角度的，我们即可称之为悬垂。悬垂面打印一直是打印圈中热议的话题之一：不论是其导致的打印失败，还是致力于提升悬垂质量。
悬垂的调整一直都是难以触碰到的进阶技巧，我们需要多次反复尝试才能取得最佳悬垂参数。其中典型参数有喷嘴温度和冷却风扇速度以及喷嘴速度。并且大角度悬垂通常会使用支撑保证成功打印。一般而言，支撑距离悬垂越近，打印质量越高。但是若紧贴悬垂则会难以拆卸支撑，因此在有ams的情况下一般都会尽量尝试多材料打印：一种材料作为主体，另一种作为支撑。并且有条件也可以选择水溶支撑进行打印。

堵头

导致打印失败的原因有很多，但是其中最常见的之一就是堵头。顾名思义，堵头发生的表现就是喷嘴被堵住，材料无法正常流出。众所周知，打印使用耗材并非纯塑料，会参杂其他种类耗材塑料或者色母用于改善性能或者上色。因此可能导致材料中有及其细小的颗粒。相对于大部分0.4mm孔喷嘴来说这些颗粒足够大，但是仍然会有堵塞的可能。不只是耗材杂质，耗材本身也可能导致堵头问题。比如在无意中持续高温加热喷嘴而不打印时，会有耗材因为持续高温碳化，产生碳颗粒从而堵塞喷嘴。
遇到堵头问题，其表现为空打等。首先停止打印，然后使用拓竹工具中附赠的钢丝（或者吉他E弦）捅进去，到一定深度后拔出，再次挤出材料。一般而言即可完成疏通。若无法疏通，则考虑更换喷嘴。

进料与退料

在打印开始前，首先需要确认挂载耗材是否是自己想要的耗材或者挂载耗材是否受潮。如果需要更换挂载耗材，则需要执行进料退料操作。

进料：将耗材推进喷嘴中
退料：将耗材从喷嘴中退出

进料前，先点击打印机按钮，选择进料。接下来根据打印机提示操作即可。退料同理。但是退料过程值得一提；点击退料后，我们会观察到打印机通过切刀将耗材切断，随后会先向下挤出再退出材料。一方面这是为了尽量减少喷嘴中的残留耗材。另一方面，这是为了防止直接抽出耗材导致下方加热耗材被抽出时造成大量冷却后难以变形的细丝，阻碍下次进料。
在退出耗材后一定要记得，将耗材丝的头留出来，卡在料盘上！否则会极其容易造成卡料。耗材头是不知道自己要去哪里的，十分容易打结。

本文持续更新中，详细教程也可以参考Evan76攥写的更为详细的关于拓竹3D打印机的教程：教程链接所有引用的图均经过Evan76本人同意引用

realsense

2025-11-23T08:32:32.000Z

英特尔realsense D400系列深度相机简易说明

序

本文仅针对D415，D435，D455以及D410相机使用，意图为简述realsense相机工作原理以及使用方式。

关于相机本身

正常来说，从正面看向realsense D400系列相机，可以在黑色的正面看见三个或四个开孔。这些开孔对应的是左右红外摄像头以及红外补光灯，最旁边的则是RGB摄像头。D415的最近工作距离为30cm，435/455暂时不明。Realsense的基本工作原理为基于双目摄像头的测距，但是疑似也可以通过红外补光灯的结构光进行测距。这也使得realsense拥有无与伦比的泛用性。强太阳光下结构光普遍失效时realsense仍然可以通过双目测距，而黑暗环境也可以使用红外补光进行双目测距或结构光测距，泛用性不可谓不广。

相机开发

使用realsense相机需要安装realsense SDK:下载地址戳这里，若使用python开发则需要
pip install pyrealsense2
本文着重于python环境下realsense的开发使用。

python环境配置

首先着重确认python opencv，无特殊版本要求，只需要
pip install opencv-python pyrealsense2
即可。
随后新建一个python文件即可开始开发

相机配置

首先import pyrealsense2 as rs，下文rs全部指代pyrealsense2
调用realsense时首先需要对深度视频流和RGB视频流进行配置,其中rs.stream.depth和rs.stream.color分别代表深度与彩色图像的配置，接下来是分辨率，彩色流最高支持1080p30，深度流最高支持720p90。

# 配置深度和颜色流self.pipeline = rs.pipeline()self.config = rs.config()# 配置流的分辨率和格式self.config.enable_stream(rs.stream.depth, 640, 480, rs.format.z16, 60)self.config.enable_stream(rs.stream.color, 640, 480, rs.format.bgr8, 60)

随后启动视频流

# 启动流self.profile = self.pipeline.start(self.config)

配置深度图像标尺，创建对齐对象

# 获取深度传感器的深度标尺self.depth_sensor = self.profile.get_device().first_depth_sensor()self.depth_scale = self.depth_sensor.get_depth_scale()# 创建对齐对象（将深度框与彩色框对齐）self.align_to = rs.stream.colorself.align = rs.align(self.align_to)# 获取内参self.intrinsics = None# 保存内参（首次调用时）if self.intrinsics is None:    self.intrinsics = color_frame.profile.as_video_stream_profile().intrinsics

而在设置完后，需要获取图像并且转为numpy数组方便opencv调用

# 等待一对连贯的帧frames = self.pipeline.wait_for_frames()# 对齐深度帧与颜色帧aligned_frames = self.align.process(frames)# 获取颜色帧color_frame = aligned_frames.get_color_frame()# 转换为numpy数组并返回return np.asanyarray(color_frame.get_data())

接下来可以选择获取深度图像

"""获取深度图像帧，并只显示指定深度范围内的内容参数:    min_depth: 最小深度值（米）    max_depth: 最大深度值（米）    返回:    彩色映射的深度图像"""# 等待一对连贯的帧frames = self.pipeline.wait_for_frames()# 对齐深度帧与颜色帧aligned_frames = self.align.process(frames)# 获取对齐的深度帧aligned_depth_frame = aligned_frames.get_depth_frame()if not aligned_depth_frame:    return None# 转换为numpy数组depth_image = np.asanyarray(aligned_depth_frame.get_data())# 将深度值转换为米depth_in_meters = depth_image * self.depth_scale# 创建掩码，只保留指定深度范围内的像素mask = (depth_in_meters >= min_depth) & (depth_in_meters <= max_depth)depth_image_masked = depth_image.copy()depth_image_masked[~mask] = 0# 深度图像的可视化depth_colormap = cv2.applyColorMap(    cv2.convertScaleAbs(depth_image_masked, alpha=0.03),     cv2.COLORMAP_JET)return depth_colormap

或者直接选择获取像素点距离

"""获取指定像素点的三维坐标和距离参数:    x: 像素点的x坐标    y: 像素点的y坐标    返回:    包含三维坐标和距离的字典，或None（如果获取失败）"""# 等待一对连贯的帧frames = self.pipeline.wait_for_frames()# 对齐深度帧与颜色帧aligned_frames = self.align.process(frames)# 获取对齐的深度帧和颜色帧aligned_depth_frame = aligned_frames.get_depth_frame()color_frame = aligned_frames.get_color_frame()if not aligned_depth_frame or not color_frame:    return None    # 保存内参（首次调用时）if self.intrinsics is None:    self.intrinsics = color_frame.profile.as_video_stream_profile().intrinsics# 检查坐标是否在有效范围内color_image = np.asanyarray(color_frame.get_data())if x < 0 or x >= color_image.shape[1] or y < 0 or y >= color_image.shape[0]:    print("像素坐标超出图像范围")    return None# 获取深度值（米）depth = aligned_depth_frame.get_distance(x, y)if depth <= 0:    print("无法获取有效深度值")    return None# 将像素坐标转换为三维坐标depth_point = rs.rs2_deproject_pixel_to_point(self.intrinsics, [x, y], depth)x3d, y3d, z3d = depth_pointreturn {    'x': x3d,    'y': y3d,    'z': z3d,    'distance': depth  # z坐标与距离在这个场景下是相同的}

结束程序时需要停止相机流并释放程序

"""停止相机流并释放资源"""self.pipeline.stop()

以上就是建议的realsense使用方法
本文为晓风原创，未经允许请勿转载。

cuda_install

2025-11-20T16:43:30.000Z

关于如何安装CUDA相关的神经网络环境

序言

其实关于如何安装，网上不论是简单还是方便的做法都已经有很多了。之所以写这篇文章主要是为了方便自己留档以及给小登传阅——不管怎么说有一个统一的资料存放总是很方便的，遂书写此教程送给我们可爱的小登们。

电脑常识普及

首先，要参与神经网络，强化学习相关的东西，肯定是要对电脑有点基础的。因此正确认识电脑是非常必要的，这一章可能会非常长，花大量篇幅来讲述电脑相关的知识和常识。毕竟大部分学生高中毕业前都没碰过电脑啊！ 所以对于电脑常识的普及会是非常重要的，接下来让我们娓娓道来。

对于很多人而言，电脑和手机一样都是按下开机键就会亮起来的东西。但是你是否清楚，在按下开机按键后发生了什么？在你打游戏，听音乐的时候，你的电脑又在做什么？

首先，我们要从——当然不太可能是第一台电脑说起——计算器说起。电脑从诞生之初就是为了辅助我们完成复杂的运算准备的。1+1=2，这是还没出生的小朋友都知道的。但是，一堆数不清的1+1，2+2，就需要大量的时间去运算。因此人类创造了计算机来帮我们自动化的完成一些复杂的或者重复的工作。当然，以前的计算机和现在的计算机差别十分甚至九分的大，就不展开讨论了。现代的计算机，其功能性也远高于以前的计算机，但是总体原理并没有太大变化。
对于计算机而言，既然他是负责进行计算的设备，那么首先它需要有一个能够进行计算的单元，而对于这个很重要的计算单元，我们称之为CPU——Center Processing Unit。CPU在计算机中的作用，主要是负责大部分计算，一个CPU一次只能处理一条计算任务，但是得益于一些后来技术的提升，CPU已经可以承担大部分计算工作了。
那么，CPU既然要进行超高速的计算，就需要对大量数据进行处理。但是处理完的数据会存放在哪里呢？简单来说，其实就放在RAM里，也就是常说的“内存条”。就像工具永远是放在手边拿起来用最快，但是放在手边你总得把他放回架子上——RAM的速度很快，但是断电后会清除数据。因此，对于重要的计算结果，就需要一个能够长时间储存的地方——硬盘
硬盘就是常说的存储，存储空间不够了也就是说硬盘需要加钱扩容咯！
然而，随着时代发展，一项新的技术和需求出现了——三维渲染。虽然CPU计算速度和能力很强，但是三维的计算有一个特点——如果没有同时的大范围的渲染，三维的图像将会变得很卡，因为CPU只有线性的处理能力，并不能同时处理大量工作。因此，一项新的技术应运而生，那就是GPU——Graphics Processing Unit，GPU有一个特点就是可以进行大量的同时运算，因此很适合图像处理。但是同时，适合图像处理也意味着另外一件事——神经网络这种需要大量并行计算的算法。
让我们回顾一下，CPU适合高速线性运算，GPU适合并行计算。然后就是关于CPU和GPU常见的厂家，CPU领域英特尔，AMD；GPU领域英伟达，AMD。其中我们着重讲述英伟达的GPU——RTX（GTX）系列显卡。
大部分同学的电脑上应该都有一个绿色的GeForce小贴纸，这意味着你的电脑搭载了新型的英伟达游戏显卡。而英伟达十分重视AI领域发展，其深知GPU的并行计算优势，为了方便开发，他早有准备，做好了工具箱放在你手上，其名为CUDA Toolkit 。后文称工具集。

环境安装

确定版本

我们常用的onnx，pytorch框架都将会依赖于工具集和英伟达神经网络运行库cudnn。下文将以win和Ubuntu环境分别讲述安装。
首先，确认好你需要进行安装的电脑的显卡驱动，一般而言都是安装好的，如图则是安装了驱动，若没有请按顺序阅读文章安装。

首先，前往英伟达官网寻找适合自己的驱动，下载安装好以后，按win，在搜索框输入power，找到power shell，打开。

输入nvidia-smi，找到CUDA Version，记下后面的版本号，这代表你能安装的最高的工具集版本。但是请注意！根据你所需要的项目安装正确的版本！而不是一味的跟着教程！
接下来，打开工具集下载链接,找到合适的版本，点击进入，不能超过上述的nvidia-smi获取的版本。

下载完成后

双击打开安装程序，设置好安装路径。个人建议直接按照默认路径，若不为默认路径则需要记下安装路径后续安装需要用到。
接下来一路安装即可

选择自定义安装

全部勾选。新版本cuda有更新，多出来的选项可选可不选。

记住你的cuda安装路径！如果是默认路径一般是C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/你的cuda版本
安装完成后重启电脑，命令行输入nvcc -V,如果有如下图信息则是安装成功

安装cudnn

cudnn是英伟达显卡运行神经网络最重要的工具，并且与cuda版本严格对应。首先打开cudnn下载，首次使用可能需要注册账号，注册完根据自己的cuda版本下载cudnn库。下载时选择对应的zip压缩包，下载完后解压，会出现三个文件夹：将这三个文件夹的内容物复制到前文提到的cuda安装文件夹的同名文件夹内即可

为cuDNN添加环境变量：
找到环境变量-系统变量-path，分别将如下三个变量添加进去，完成安装。

ubuntu下安装

其实仅一点不同：ubuntu安装cuda可以直接借助sh命令行安装按照最下面两行命令，按下ctrl+alt+t唤起终端后分别输入就安装成功了。同样输入nvidia-smi，找到CUDA Version，参考上述步骤就可以完成安装。由于使用ubuntu系统默认已经有不少计算机基础以及独立搜索解决问题的能力，因此本篇不再赘述，只引用一篇优秀的文章：文章链接其中gcc相关问题可以先不做解决，安装失败再处理。在ubuntu进行操作只需要记住：永远不要动你的内核，尽量不要动系统组件，否则后果自负。
若对文章有疑惑可联系本人，侵权联系删除。

the_past_of_curc_robocon

2025-11-20T10:43:25.000Z

RC往事

rc历史上可能是第一个记录了“技术大佬”们鲜活日常的仓库

coworkers_for_KFS

2025-11-20T10:11:15.000Z

KFS数据集共创计划

[TOC]

前言

PS. 本文项目现已刊登至比赛组委会官方公众号原文链接

在2026赛季的robocon比赛中，我们可以发现机器人在功夫卷轴上完成识别几乎是硬性需求，但是功夫卷轴种类繁多，光凭借一个队伍的视觉ldx和xdx，每种50张工作量也是巨大的。因此，本人决定发起一个数据集标注活动，将每种图片规定好标签等，然后汇总到github仓库，并且通过一些开源中附带的小工具针对不同队伍需求进行数据格式转换。同时保留了原始数据文件夹供各个队伍自行决定。由于采用yolo模型的人数较多，因此本人倡议使用yolo数据集格式（即txt坐标文件+原始图像+一个标签文件）。本项目不要求区分train和val，只需要标注完成后上传即可。希望Rc比赛可以有更好的开源氛围以及共创氛围。

20251110更新：增加了马术分支，但是由于本人精力有限，目前需要助手帮助维护更新马术分支

一、数据采集注意事项

由于比赛过程中，我们可能需要面对复杂的场景以及灯光干扰，因此本人建议在数据集中尽可能涉及大块纯色色块（绿色、红色或者蓝色）。可以考虑加入一些天花板为背景的图片作为应对灯光的抗干扰。若觉得模型数据仍然不理想，可以参考我校排球开源中的灯光抗干扰方案，但是未经验证不知可行性。数据集采集时，可以通过录制1080p30帧的视频，然后导入剪辑软件中。剪辑软件设置为导出640*640（yolo默认格式）视频，随后在格式工厂（或者其他工具中）导出为帧，然后摇两个小登开始标数据。

注：关于剪辑软件说明

个人推荐：
达芬奇(专业，免费的剪辑软件，适合让运营兼职的同时学习，也适合想要学习新技能的同学。同时本身也有强大的各种工具。如果有需要本人后续会录制简单说明)

剪映(相对达芬奇，简单易上手，专业性并没有差很多，十分适合所有视觉组成员学习一下)

finalcut(macOS专用，但是本人用的不多)

PR为付费软件，处于支持正版角度考虑不建议购买使用，并且对于新手没有达芬奇好上手。必剪，本人不是很推荐的一款软件，但是如果有会使用的同学可以考虑使用。其余软件本人使用不多，是否采用还是以个人习惯为主看，本人仅以高中以及大一时期融媒体工作流相关经验提出观点。

二、数据集标注要求

（一）标签要求

标签从零到一到32开始，并且每张图最好只出现一类标签！标注时，请框选整个KFS（若条件有限则只框选有颜色的部分）。标签顺序如图标注：上为甲骨、下为小篆，内容一致：武林至尊戈刀弓矢力德王帝天日月
左上角的数字代表标签顺序（本来应从零开始，但是由于外包疏忽以及理解方便还是标注为1开始计数），标签建议在制作数据集之前就提前创建好或者使用本项目下的标签文件（targets文件夹内）。接下来会规范每一个标签的命名，从第一个开始：

R_R1B_R1T_03T_04T_05T_06T_07T_08T_09T_10T_11T_12T_13T_14T_15T_16T_17F_18F_19F_20F_21F_22F_23F_24F_25F_26F_27F_28F_29F_30F_31F_32

本意是可以让网络识别到单个字体，后续通过标签来判断真假。标注时请注意类别一定要全部添加，后续整理合并数据集时才不会混乱。

（二）关于数据集

如前文所说，本人倡议使用yolo数据集格式，因为本人接触到的队伍大多都使用yolo作为主要识别模型，因此本项目推荐使用yolo格式。若有其他格式需求可以使用转换工具。如果有需求，可以单独开设数据集格式文件夹以供使用。数据集最小数量要求为50张。

三、标注完成

（一）整理数据集

将您的数据集标签与图片放置于同一文件夹下，命名为贵校缩写或者战队英文名（例如FJUT，MTI等），然后上传至对应的文件夹下。

（二）上传文件

提交PR至对应文件夹，文件夹结构如下

--+--labeled  |  +--orignal_datas  |  +--tools

labeled为数据集对应存放处，打开即可看见多种数据集名字。请按照上述要求创建好学校名字文件夹后提交您的pr。如果发现pr没有及时采用请私聊骚扰本人。如果您有需求也可以通过悬赏提出issue，也请各位创作时注意数据集的均衡性，尽量保证r2的每一种方块数据数量是相等的。

四、下载数据集

（一）下载

您可以通过各种方式下载，这里不再赘述

（二）使用

在本项目的tools文件夹下会有各种文件处理工具，具体使用说明请参阅tools下的readme文档。由于部分工具可能非本人上传，因此请谨慎使用或检查源码自行评估使用。上传的工具必须为c源码或python的py程序，上传工具源码必须可见！这是根本原则！
在进行完数据集合并后，我建议您自行半随机抽取图像进行数据集的划分，因为不同学校拍摄环境不同，训练效果也不同，若均匀分配则可以使模型泛化能力更强。具体如何操作看您设计。

五、如何参与

获取联系方式或参与讨论：

添加个人联系方式：1652107474（QQ）或者进入QQ群1065597020。

参与协作：

将您标注的数据集的图片（总览）以及数据集通过邮箱发给本人（1652107474@qq.com）,若您介意，只需要发送标注好的部分图像也可，本人将会在三个工作日内完成审核并且邀请您加入私有仓库协作，请在发送邮件时注明学校以及参加KFS标注协作，若审核不及时请在群内艾特一下本人。

六、碎碎念

由于这是多人共创项目，并且由于加入时间先后，队员数量等原因必然会产生各个学校上传数据集不同等的现象。例如本人队伍目前只有本人一位正式的视觉组成员，因此产出数据集必然是不同等的，如果您需要根据已有总量评估，请联系本人，我也会尽量配合您进行数据集数量评估。我也并未强制要求您将所有数据集上传，仅需要上传您认为值得上传的部分，希望参与本项目的学校可以对此做好心理准备
我仍然衷心希望RC可以是一个开放包容的比赛氛围。对于贡献较高的队伍在比赛时我们将会为其准备一些神秘小礼品以示心意。本项目仍然在完善阶段，欢迎踊跃参与。

MTI_volleyball_opensource

2025-11-19T07:43:35.000Z

MTI战队视觉方案开源

前言

在初步研究了排球比赛的规则之后，我们组内成员偏向于认为视觉方案在这次比赛中可能会有一个比较重要的作用。但是在实际比赛中，我们发现部分队伍因为灯光影响而放弃视觉方案。部分学校则是采取了风格特异的抗干扰方案排除灯光影响。例如某大学是采取了现场标记数据集，而另一个大学则是数据集一开始就使用蓝色为主的排球，由此达成抗干扰效果。尽管由于其他问题我们的视觉识别并未起到作用，但是鉴于实地测试表现我决定仍然将其开源。电控部分代码则开源在这个仓库。本代码在这里开源,在闲鱼购买请联系原作者1652107474@qq.com

一、代码功能综述

本代码结构为d415_ubuntu.py作为主程序，anti_light.py作为抗灯光部分，Serial_akatsuki_simple.py作为串口通讯相关的函数处理（包括数据内容以及编码发送），pid_akatsuki.py是用于跟踪的pid控制器。run.bat是为win环境准备的启动程序（win版本主程序为d415）。

本代码不依赖ros，需求python版本3.9及以上，3.10经过测试稳定运行。要求库已经内置在requirementa.txt中。ubuntu需要使用python命令启动。程序启动时需要接入xinput支持的手柄，realsense d4系列带rgb摄像头（d410可以使用深度摄像头传输rgb流，d430不行），以及ch340（我们的方案是自带ch340的nrf24射频）

二、主函数代码解析

12行开始代码部分

pipeline = rs.pipeline()  #定义流程pipelineconfig = rs.config()   #定义配置configconfig.enable_stream(rs.stream.depth, 640, 480, rs.format.z16, 60)  #配置depth流config.enable_stream(rs.stream.color, 640, 480, rs.format.bgr8, 60)   #配置color流profile = pipeline.start(config)  #流程开始align_to = rs.stream.color  #与color流对齐align = rs.align(align_to)

以上是realsense相关的初始化

# 全局变量,用于存储模型和摄像头对象model = Nonecap = Nonetrack = 0act_model = 0  # 用于控制动作的变量X,Y,RIGHT_X,RIGHT_Y= 0,0,0,0    # 控制移动的变量# 设置模型配置script_dir = Path(__file__).parentfile_path = script_dir / 'model' / 'yolo11s.pt'model_config = {    'model_path': str(file_path),    'download_url': 'https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11n.pt'}# 推理参数predict_config = {    'conf_thres': 0.6,    'iou_thres': 0.2,    'imgsz': 640,    'line_width': 2,    'device': 'cuda:0' if torch.cuda.is_available() else 'cpu'}def init_inference(confidence, iou):    global model    # 加载 YOLO 模型    model = YOLO(model_config['model_path']).to(predict_config['device'])    return True

这里是关于yolo推理部分的初始化，其中X,Y,RIGHT_X,RIGHT_Y= 0,0,0,0会在稍后作为传入信息数组的变量，提前进行全局声明和初始化。model_config是模型的路径，仍然保留了网络下载路径，但是实际代码中没有相关功能。init_inference函数用于初始化模型，若初始化成功会返回true。

接下来直接转到识别部分

    global frame1,rgb,center1    # 读取摄像头的帧    frame1 = rgb.copy()    # 使用 YOLO 模型进行推理,并传入置信度和 IoU 阈值    results1 = model(frame1, conf=0.5, iou=0.7)    detect_len = len(results1[0].boxes)  #获取检测结果的长度    # 获取检测结果的坐标并绘制检测框        boxes1 = []    if detect_len != 0:        for r in results1:            for box in r.boxes:                xyxy = box.xyxy[0].cpu().numpy().astype(int)                boxes1.append(xyxy)                cv2.rectangle(frame1, (xyxy[0], xyxy[1]), (xyxy[2], xyxy[3]), (0, 255, 0), 2)                center1 = np.array([x_center1, y_center1])    else:        print("未检测到目标")        center1 = np.array([320, 5])

这段代码对应yolo的识别部分。由于anti_light代码在nuc上，后续会惊醒补充。

接下来来到代码的主函数部分，108行开始：

    global actX,act_dis    x_center1 = 320    y_center1 = 240    center1 = np.array([x_center1, y_center1])    actX = pid.ProportionalPID(        kd= 260,        ki= 0,        kp= 180,        deadband= 0.01    )    act_dis = pid.ProportionalPID(        kd= 220,        ki= 0,        kp= 160,        deadband= 0.001    )

提前声明部分变量，实例化需要用到的两个pid控制器（对应水平和竖直方向）

接下来是串口选择部分，这个部分目前只有win版本有效，ubuntu版本已经删除。选择串口时，用手柄的hat（十字键）进行选择，上下为加减5，左右加减1（ubuntu版本功能为上下加减1）。选择完成后，按下手柄A按键确定串口。

170行的asyncio.run(detect()) #协程推理使用了asyncio库进行协程，达到优化推理产生的控制延迟的效果。实际上发现在一定程度上也优化了推理性能。

173行开始的这段代码中

    x = int(center1[0])    y = int(center1[1])    #(x, y)点的真实深度值    dis = aligned_depth_frame.get_distance(x, y)      #(x, y)点在相机坐标系下的真实值,为一个三维向量。其中camera_coordinate[2]仍为dis,camera_coordinate[0]和camera_coordinate[1]为相机坐标系下的xy真实距离。    camera_coordinate = rs.rs2_deproject_pixel_to_point(depth_intrin, [x, y], dis)      if camera_coordinate != (0.0,0.0,0.0):        last_coordinate = camera_coordinate        print(camera_coordinate)    else:        print(last_coordinate)

这段代码会对像素坐标进行获取。由于深度摄像头在距离过近的目标识别会输出0，0，0的坐标值，因此会对目标最后的位置进行检测，决定是否写入坐标值

接下来是198行，对应动作组

    # 执行动作组    if sc.joystick.get_button(13) == 1:        if camera_coordinate[2] !=0.0:            act_group = 1        else:            act_group = 2    else:        act_group = 0    action_group(act_group)    act_group = 0

这段代码在手柄左摇杆按下时会进入自动跟踪状态，同时通过目标不同状态选择动作组。在执行程序action_group结束后act_group会归为0，防止动作重复执行。

    sc.time.sleep(0.01)    robot.send()

这段为发送所有的数据组，sleep为阻塞线程，防止串口发送频率太快导致报错