在实际嵌入式开发和机器人竞赛中，地面小车与空中无人机协同完成复杂任务，正成为一个极具挑战性和前沿性的研究方向。2026年电赛若出现“空地协同小车巡线”这类题目，将综合考察参赛者对嵌入式控制、机器视觉、无线通信、路径规划和多智能体协同等多项核心技术的掌握程度。这类题目不再是单一模块的堆砌，而是要求参赛者构建一个能够感知、决策、通信和执行的完整系统。

本文旨在为有志于挑战此类综合赛题的开发者提供一个从零到一的技术实现框架。我们将围绕一个模拟场景展开：一辆地面小车负责沿预设的黑色引导线行驶，而一架无人机则在空中提供全局视野，识别复杂路况（如岔路口、障碍物），并通过无线通信将导航指令发送给小车，引导其完成更复杂的巡线任务。整个过程将涉及OpenCV图像处理、ROS通信框架、CoppeliaSim仿真环境以及STM32/树莓派等嵌入式平台。通过本文，你将理解空地协同系统的核心架构，并能够搭建一个可运行、可调试的仿真原型，为实际参赛或项目开发打下坚实基础。

1. 理解空地协同巡线系统的核心架构

在开始动手之前，必须厘清整个系统的信息流和控制逻辑。一个典型的空地协同巡线系统并非简单地将两个独立设备连接起来，而是需要构建一个分层、解耦的软硬件体系。

1.1 系统组成与角色分工

系统主要由三大部分构成：空中单元、地面单元和通信链路。每个单元承担不同的职责，共同完成巡线任务。

• 空中单元（无人机/机载计算机）：通常由一台运行ROS的机载计算机（如Jetson Nano/Xavier NX、树莓派4B）和摄像头组成。它是系统的“眼睛”和“大脑”，负责：
  • 全局感知：从高空俯拍，获取包含整个或大部分巡线路径的图像。
  • 高级决策：识别路径类型（直线、弯道、十字/丁字路口）、检测地面障碍物、计算小车的全局位置。
  • 指令生成：根据识别结果，生成高级导航指令，例如“前方左转”、“路口直行”、“发现障碍，绕行”。
• 地面单元（巡线小车）：通常基于STM32、Arduino或树莓派等微控制器，配备电机、巡线传感器和本地摄像头。它是系统的“手脚”，负责：
  • 局部感知与稳定控制：通过底部的红外或灰度传感器阵列，实现高频率、高精度的线路跟踪，保持小车紧贴引导线行驶。这是小车最基础、最核心的能力。
  • 指令执行：接收并解析来自空中单元的高级指令，将其转化为具体的电机控制动作（如特定角度的转弯、停车等待）。
  • 状态反馈：将自身的状态（如速度、位置估算、电池电压）反馈给空中单元。
• 通信链路：连接空中与地面的桥梁。鉴于电赛环境通常对通信距离和稳定性有要求，Wi-Fi（基于TCP/UDP的ROS通信或自定义协议）是最常见的选择。它需要保证指令和状态信息能够低延迟、可靠地传输。

1.2 信息流与控制逻辑

理解了分工，再看它们如何协作。整个系统的运行遵循“感知-决策-执行”的循环，但决策权被分配在了不同层级。

1. 初始化与标定：系统启动后，空中单元首先需要识别小车在图像中的初始位置，并可能进行简单的坐标系标定（将图像像素坐标与小车的实际运动建立粗略关联）。
2. 常态巡线（地面主导）：在无非预设复杂路况的直线或缓弯路段，地面小车完全依靠自身的巡线传感器进行PID控制，自主、高速地沿黑线行驶。此时空中单元仅进行监视，不发送控制指令。
3. 复杂路况处理（空地协同）：
   • 空中单元感知：无人机摄像头识别到前方出现岔路口、断线或障碍物。
   • 决策与指令下发：空中单元的图像处理算法分析路况，决定小车应采取的行动（如“在下一个路口左转”），并将该指令通过Wi-Fi发送给地面小车。
   • 地面单元执行：小车收到指令后，可能暂时“覆盖”或“修改”其基于局部传感器的PID控制逻辑。例如，在接近指令指定的路口时，小车会主动寻找转向分支，而非继续直行。
4. 状态同步：地面小车在执行指令或遇到异常（如跟丢线）时，将状态反馈给空中单元。空中单元可根据反馈调整后续策略。

这种架构的优势在于，将需要全局信息的复杂决策（路径选择）与要求快速响应的底层控制（电机调速）解耦，提高了系统的鲁棒性和可扩展性。

2. 开发环境与核心工具链准备

工欲善其事，必先利其器。为了高效开发和调试，建议搭建以下环境。我们将采用“仿真先行，实物验证”的策略，先在CoppeliaSim中构建虚拟世界和机器人模型，再逐步迁移到实物平台。

2.1 软件环境清单

下表列出了开发所需的核心软件及其推荐版本：

2.2 核心工具安装与配置

1. 安装ROS Noetic在Ubuntu 20.04上，按照ROS官网指引执行安装命令。完成后，务必初始化rosdep并配置环境变量。

sudo apt update sudo apt install ros-noetic-desktop-full echo "source /opt/ros/noetic/setup.bash" >> ~/.bashrc source ~/.bashrc sudo rosdep init rosdep update

2. 创建ROS工作空间所有自定义代码和仿真模型都将放在这个工作空间中。

mkdir -p ~/catkin_ws/src cd ~/catkin_ws/ catkin_make echo "source ~/catkin_ws/devel/setup.bash" >> ~/.bashrc source ~/.bashrc

3. 安装CoppeliaSim与ROS接口从CoppeliaSim官网下载Linux版本并解压。关键一步是安装其ROS接口插件，这允许ROS节点直接控制仿真中的模型。

• 在CoppeliaSim安装目录下，找到programming/ros_packages。
• 将其中的sim_ros_interface包复制或软链接到你的ROS工作空间src目录下。
• 回到工作空间根目录，运行catkin_make编译。编译成功后，启动CoppeliaSim时会自动加载该接口。

4. 验证OpenCVROS桌面完整版通常已包含OpenCV。可以通过Python快速验证：

import cv2 print(cv2.__version__)

如果报错ModuleNotFoundError: No module named 'cv2'，则需要安装：

sudo apt install python3-opencv

3. 在CoppeliaSim中构建仿真世界

在编写一行控制代码前，先在仿真中搭建舞台。这能极大降低开发成本，并允许你安全地测试各种极端情况。

3.1 设计巡线场景

1. 启动CoppeliaSim：从终端启动，确保其能加载ROS接口。
2. 创建地面与引导线：
   • 从模型浏览器中添加一个大的平面作为地面。
   • 使用“添加 -> 路径”工具，在地面上绘制一条黑色的闭合或不闭合的曲线作为巡线路径。你可以设计包含直线、S弯、十字路口、丁字路口的复杂路线。
   • 选中该路径，在对象属性中，将其颜色改为纯黑，并适当增加宽度（如0.02米），使其在仿真中清晰可见。
3. 添加视觉标记：在关键位置（如路口中心）放置不同颜色或形状的小物体（立方体、圆柱体），作为空中视觉识别的辅助标记。

3.2 导入与配置机器人模型

1. 地面小车：可以从CoppeliaSim自带的模型库中找一个差速驱动小车模型（如Pioneer p3dx），或从社区下载。关键是要确保它有两个独立控制的驱动轮和一个或多个万向轮。为小车模型添加一个“视觉传感器”（Vision Sensor），将其安装在小车前方，模拟向下的摄像头，用于局部巡线（虽然我们主要用仿真中的“接近传感器”阵列来模拟红外对管，但视觉传感器可用于更复杂的图像算法测试）。
2. 无人机模型：从模型库添加一个四旋翼无人机模型（如Quadcopter）。为其添加一个指向地面的“视觉传感器”，调整其焦距和分辨率，使其能完整地拍摄到包含小车和路径的区域。
3. 关联ROS接口：这是最关键的一步。你需要为小车和无人机的每个执行器（电机、螺旋桨）和传感器（视觉传感器、IMU）在CoppeliaSim中配置ROS话题或服务。
   • 对于小车的两个驱动轮，分别添加一个“关节控制”对象，并为其配置ROS发布者（Publisher）来接收速度指令（类型为std_msgs/Float32），话题名可为/left_wheel_speed和/right_wheel_speed。
   • 为小车的“视觉传感器”配置ROS发布者，将图像数据发布到话题如/ground_camera/image_raw。
   • 为无人机的“视觉传感器”配置ROS发布者，将图像发布到话题如/uav_camera/image_raw。
   • 为无人机的位置控制器配置ROS订阅者（Subscriber），接收来自你自主控制节点的位姿指令。

完成场景搭建后，保存场景文件（.ttt）到你的项目目录。

4. 地面小车巡线控制实现

地面小车的核心是稳定、快速的线路跟踪。我们首先实现一个不依赖空中指令的、基于仿真传感器的PID巡线节点。

4.1 仿真传感器数据读取

在CoppeliaSim中，我们常用一排“接近传感器”（Proximity Sensor）来模拟红外巡线模块。每个传感器返回其检测到黑线的距离（或无检测）。创建一个ROS节点来读取这些数据。

首先，创建一个ROS包：

cd ~/catkin_ws/src catkin_create_pkg ground_control rospy std_msgs sensor_msgs geometry_msgs cd ~/catkin_ws catkin_make

然后，编写传感器读取节点line_sensor_node.py：

#!/usr/bin/env python3 import rospy from sensor_msgs.msg import Range import numpy as np class LineSensor: def __init__(self): rospy.init_node('line_sensor_node', anonymous=True) # 假设有5个接近传感器，话题名为 /line_sensor0, /line_sensor1 ... self.sensor_topics = ['/line_sensor{}'.format(i) for i in range(5)] self.sensor_values = [0.0] * 5 # 存储传感器读数，0表示无线，1表示有线（经过处理） self.sensor_subs = [] for i, topic in enumerate(self.sensor_topics): # 为每个传感器创建订阅者，回调函数传入索引i以区分 sub = rospy.Subscriber(topic, Range, self.sensor_callback, callback_args=i) self.sensor_subs.append(sub) def sensor_callback(self, msg, sensor_index): # 简化处理：如果检测到物体（黑线）且在有效范围内，则认为传感器在线条上 # msg.range 是检测到的距离，我们设定一个阈值 if 0 < msg.range < 0.05: # 假设5cm内检测到即为在线 self.sensor_values[sensor_index] = 1 else: self.sensor_values[sensor_index] = 0 # rospy.loginfo("Sensor {}: {}".format(sensor_index, self.sensor_values[sensor_index])) def get_line_position(self): """计算线条相对于小车中心的位置，用于PID控制""" # 简单加权平均法计算偏差 # 假设传感器从左到右索引为0到4，中心位置为2 weights = [-2, -1, 0, 1, 2] weighted_sum = sum(w * v for w, v in zip(weights, self.sensor_values)) total = sum(self.sensor_values) if total == 0: return 0 # 没有检测到线，返回0或特殊值 return weighted_sum / total # 偏差值，负为偏左，正为偏右 if __name__ == '__main__': ls = LineSensor() rospy.spin()

4.2 PID控制器与电机驱动

获取到线条位置偏差后，使用PID控制器计算左右轮的速度差，实现纠偏。

创建电机控制节点motor_control_node.py：

#!/usr/bin/env python3 import rospy from std_msgs.msg import Float32 class PIDController: def __init__(self, kp, ki, kd): self.kp = kp self.ki = ki self.kd = kd self.prev_error = 0 self.integral = 0 def compute(self, error, dt): self.integral += error * dt derivative = (error - self.prev_error) / dt if dt > 0 else 0 output = self.kp * error + self.ki * self.integral + self.kd * derivative self.prev_error = error return output class MotorControlNode: def __init__(self): rospy.init_node('motor_control_node') # 发布左右轮速度指令 self.left_pub = rospy.Publisher('/left_wheel_speed', Float32, queue_size=10) self.right_pub = rospy.Publisher('/right_wheel_speed', Float32, queue_size=10) self.pid = PIDController(kp=0.5, ki=0.01, kd=0.05) # PID参数需实际调试 self.base_speed = 2.0 # 基础前进速度（仿真单位） self.last_time = rospy.Time.now().to_sec() # 定时控制循环 self.control_timer = rospy.Timer(rospy.Duration(0.05), self.control_loop) # 20Hz def control_loop(self, event): # 此处应从 line_sensor_node 获取偏差，简单模拟为全局变量或通过ROS话题 # 假设通过一个全局变量或服务获取，这里简化为一个函数调用 line_error = self.get_line_error_from_sensor() # 需要实现此函数或通过话题订阅 current_time = rospy.Time.now().to_sec() dt = current_time - self.last_time self.last_time = current_time pid_output = self.pid.compute(line_error, dt) # 差速控制：根据PID输出调整左右轮速度 left_speed = self.base_speed - pid_output right_speed = self.base_speed + pid_output # 发布速度指令 self.left_pub.publish(Float32(left_speed)) self.right_pub.publish(Float32(right_speed)) # rospy.loginfo("Error: {:.2f}, PID out: {:.2f}, L: {:.2f}, R: {:.2f}".format(line_error, pid_output, left_speed, right_speed)) def get_line_error_from_sensor(self): # 这里应该通过ROS服务调用或订阅话题从 line_sensor_node 获取实时偏差 # 为简化示例，我们返回一个模拟值或0。实际项目中需要建立节点间通信。 return 0.0 if __name__ == '__main__': try: mcn = MotorControlNode() rospy.spin() except rospy.ROSInterruptException: pass

注意：上述代码是一个高度简化的框架。在实际项目中，line_sensor_node和motor_control_node需要通过ROS话题或服务进行通信。例如，line_sensor_node可以发布一个包含偏差值的自定义消息，motor_control_node订阅该消息。

4.3 本地巡线测试

1. 在CoppeliaSim中加载你的场景。
2. 分别运行两个节点（需要先实现节点间通信）：

   rosrun ground_control line_sensor_node.py rosrun ground_control motor_control_node.py

3. 在CoppeliaSim中启动仿真。观察小车是否能沿着黑线稳定行驶，并尝试调整PID参数（kp,ki,kd）和base_speed以获得最佳效果。良好的PID控制应使小车在弯道平滑过渡，在直线上偏差很小。

5. 空中视觉识别与决策

当地面小车能独立巡线后，我们为无人机赋予“智慧之眼”，使其能理解全局场景并做出决策。

5.1 无人机视角图像获取与预处理

创建一个ROS节点订阅无人机摄像头的图像话题，并使用OpenCV进行处理。

创建ROS包并编写节点uav_vision_node.py：

#!/usr/bin/env python3 import rospy from sensor_msgs.msg import Image from cv_bridge import CvBridge import cv2 import numpy as np class UAVVisionNode: def __init__(self): rospy.init_node('uav_vision_node') self.bridge = CvBridge() # 订阅无人机摄像头图像 self.image_sub = rospy.Subscriber('/uav_camera/image_raw', Image, self.image_callback) # 可以发布处理后的图像或识别结果 # self.image_pub = rospy.Publisher('/uav_vision/processed_image', Image, queue_size=10) self.cv_image = None def image_callback(self, msg): try: # 将ROS图像消息转换为OpenCV格式 self.cv_image = self.bridge.imgmsg_to_cv2(msg, 'bgr8') self.process_image(self.cv_image) except Exception as e: rospy.logerr("Image conversion error: %s", e) def process_image(self, image): if image is None: return # 1. 转换为灰度图 gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # 2. 高斯模糊去噪 blurred = cv2.GaussianBlur(gray, (5, 5), 0) # 3. 阈值化，提取黑线 _, binary = cv2.threshold(blurred, 50, 255, cv2.THRESH_BINARY_INV) # 黑线为白色 # 4. 形态学操作，去除小噪点，连接断线 kernel = np.ones((3,3), np.uint8) binary = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel) binary = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel) # 现在 binary 图像中，白色部分即为我们感兴趣的巡线路径 # 可以在此图像上进行后续分析，如路径提取、路口检测等。 self.detect_path_and_intersection(binary, image) def detect_path_and_intersection(self, binary_img, original_img): # 使用轮廓查找来识别路径 contours, _ = cv2.findContours(binary_img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) # 过滤掉太小的轮廓（可能是噪声） min_contour_area = 500 large_contours = [cnt for cnt in contours if cv2.contourArea(cnt) > min_contour_area] for cnt in large_contours: # 计算轮廓的近似多边形，用于判断形状 epsilon = 0.02 * cv2.arcLength(cnt, True) approx = cv2.approxPolyDP(cnt, epsilon, True) vertices = len(approx) # 根据顶点数初步判断 if vertices >= 6: # 可能是复杂的交叉路口（如十字路口有多个分支） cv2.drawContours(original_img, [cnt], -1, (0, 255, 0), 2) # 绿色画出 cv2.putText(original_img, 'Intersection', (cnt[0][0][0], cnt[0][0][1]), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,255,0), 2) # 此处可以计算路口中心点，并判断小车相对于路口的位置和方向 self.handle_intersection(cnt, original_img) else: # 可能是直线或简单弯道 cv2.drawContours(original_img, [cnt], -1, (255, 0, 0), 2) # 蓝色画出 # 可以计算路径的中心线，用于全局导航 self.calculate_global_guidance(cnt, original_img) # 显示处理结果（调试用） cv2.imshow('UAV Processed View', original_img) cv2.waitKey(1) def handle_intersection(self, contour, img): # 计算轮廓的最小外接矩形或中心点 M = cv2.moments(contour) if M['m00'] != 0: cx = int(M['m10'] / M['m00']) cy = int(M['m01'] / M['m00']) # 这里可以添加逻辑来判断是十字路口还是丁字路口，并决定小车转向 # 例如，通过分析轮廓的凸包或Hough直线检测来判断分支方向 # 简化：发布一个包含路口类型和位置的ROS消息 rospy.loginfo("Intersection detected at ({}, {})".format(cx, cy)) # self.intersection_pub.publish(...) def calculate_global_guidance(self, contour, img): # 计算路径的中心线或方向，为小车提供粗略的导航建议 # 例如，可以拟合一条直线，计算其与图像底部的交点，作为目标点 pass if __name__ == '__main__': uvn = UAVVisionNode() rospy.spin() cv2.destroyAllWindows()

5.2 路口识别与指令生成

在detect_path_and_intersection方法中，我们初步区分了简单路径和复杂路口。对于路口，需要更精细的分类（左转、右转、十字路口）和决策。一个更健壮的方法是结合轮廓分析和Hough直线变换。

def classify_intersection(self, binary_img, contour): """分类路口类型""" # 1. 获取路口的ROI区域 x, y, w, h = cv2.boundingRect(contour) roi = binary_img[y:y+h, x:x+w] # 2. 使用Hough直线检测 lines = cv2.HoughLinesP(roi, 1, np.pi/180, threshold=50, minLineLength=30, maxLineGap=10) if lines is None: return "Unknown" # 3. 分析直线方向，聚类 horizontal = 0 vertical = 0 for line in lines: x1, y1, x2, y2 = line[0] angle = np.arctan2(y2 - y1, x2 - x1) * 180 / np.pi if -45 < angle < 45: horizontal += 1 elif 45 < angle < 135 or -135 < angle < -45: vertical += 1 # 4. 根据直线数量判断路口类型 if horizontal >= 2 and vertical >= 2: return "Cross" elif horizontal >= 2: return "T_LeftRight" # 可能需要进一步判断开口方向 elif vertical >= 2: return "T_TopBottom" else: return "Curve"

识别出路口类型后，决策逻辑需要结合小车当前的位置和任务目标。例如，如果任务是“在第三个路口左转”，那么空中节点需要维护一个路口计数器，并在识别到对应路口时，生成“TURN_LEFT”指令。

5.3 通过ROS服务或话题下发指令

决策完成后，空中节点需要将指令发送给地面小车。我们可以定义一个简单的自定义消息。

在ground_control包中创建msg文件夹，并新建NavigationCommand.msg文件：

string command # 指令，如 "GO_STRAIGHT", "TURN_LEFT", "TURN_RIGHT", "STOP" int32 param # 可选参数，如转弯角度、目标路口ID

在CMakeLists.txt和package.xml中添加消息生成依赖，并编译。

空中节点的指令发布部分：

from ground_control.msg import NavigationCommand # ... 在 UAVVisionNode 的 __init__ 中添加 self.cmd_pub = rospy.Publisher('/uav_navigation_cmd', NavigationCommand, queue_size=10) # 在 handle_intersection 或决策逻辑中发布指令 def decide_and_publish(self, intersection_type, car_position): cmd = NavigationCommand() if intersection_type == "Cross" and self.intersection_count == 2: # 假设第二个十字路口左转 cmd.command = "TURN_LEFT" cmd.param = 90 # 转弯90度 self.cmd_pub.publish(cmd) self.intersection_count += 1 elif ... # 其他决策逻辑

地面小车节点需要订阅/uav_navigation_cmd话题，并在其控制逻辑中引入一个“指令模式”。当收到有效指令时，小车从“自主巡线模式”切换到“指令执行模式”，例如，忽略局部传感器，执行一个固定时间的转弯动作，完成后恢复自主巡线。

6. 系统集成与联合调试

当空中和地面节点都能独立运行后，最后的挑战是将它们无缝集成，并处理通信延迟、指令冲突等实际问题。

6.1 启动与通信测试

编写一个Launch文件cooperative.launch，一键启动所有节点：

<launch> <!-- 启动地面小车控制节点 --> <node pkg="ground_control" type="line_sensor_node.py" name="line_sensor" output="screen"/> <node pkg="ground_control" type="motor_control_node.py" name="motor_control" output="screen"/> <node pkg="ground_control" type="command_receiver_node.py" name="cmd_receiver" output="screen"/> <!-- 启动空中视觉与决策节点 --> <node pkg="uav_vision" type="uav_vision_node.py" name="uav_vision" output="screen"/> <node pkg="uav_vision" type="decision_maker_node.py" name="decision_maker" output="screen"/> </launch>

使用roslaunch启动整个系统，并使用rostopic list和rostopic echo命令检查所有话题是否正常通信。

6.2 调试与性能优化

联合调试中常见问题及解决思路：

6.3 从仿真到实物的关键调整

仿真成功只是第一步，移植到实物平台需要考虑更多工程细节：

1. 传感器替换：将CoppeliaSim中的“接近传感器”替换为真实的红外对管或灰度传感器阵列。需要编写对应的STM32/Arduino驱动，并通过串口或ROS串行节点将数据发布到ROS网络。
2. 电机驱动：将发布到仿真关节的速度指令，替换为通过PWM控制实际直流电机或步进电机的驱动板指令（如通过ROS节点控制Arduino，再由Arduino输出PWM）。
3. 视觉系统：无人机上的摄像头需要标定，以校正镜头畸变。图像处理算法可能需要针对真实光照条件（阴影、反光）进行增强，例如使用自适应阈值或更高级的特征提取方法。
4. 通信：实物中使用Wi-Fi，需确保网络稳定，并考虑使用roscore的多机配置，让空中和地面设备连接到同一个ROS Master。
5. 坐标系与定位：在实物中，空中视觉识别的小车位置（像素坐标）需要更精确地映射到地面坐标系。可以考虑使用AprilTag或Aruco码贴在小车上，进行视觉定位，提高精度。

7. 常见问题排查与进阶方向

7.1 典型问题排查清单

在开发过程中，如果系统行为异常，可以按以下顺序排查：

1. 检查仿真环境：CoppeliaSim场景中的传感器、执行器是否与ROS话题正确关联？模型物理属性（质量、摩擦）是否合理？
2. 检查ROS网络：所有节点是否都成功启动？rosnode list是否齐全？话题通信是否正常？rostopic echo /your_topic是否有数据？
3. 检查数据流：图像数据是否成功从CoppeliaSim发布？OpenCV回调函数是否被触发？处理后的图像能否正常显示？
4. 检查控制逻辑：地面小车的传感器读数是否准确反映了黑线位置？PID输出值是否在合理范围内？速度指令是否成功发送给仿真模型？
5. 检查协同逻辑：空中节点是否准确识别了预设路况？决策逻辑是否按预期触发？指令消息是否被地面节点接收并正确解析？
6. 检查时序与同步：是否存在因处理延迟导致的指令滞后？小车状态反馈是否及时？是否需要引入时间戳进行同步？

7.2 扩展与优化方向

完成基础功能后，可以从以下方向提升系统性能：

1. 多车协同：扩展系统，支持一架无人机引导多辆小车，并解决路径冲突问题。
2. 动态避障：在巡线基础上，让无人机识别动态障碍物，并为小车规划临时绕行路径。
3. SLAM建图与定位：让无人机同时进行场景建图，并为小车提供更精确的全局定位，而不仅仅是相对指令。
4. 强化学习决策：使用强化学习训练空中节点的决策模型，使其能在复杂、未知的路径网络中做出最优路径规划。
5. 全实物部署：将仿真中的每一个模块逐步替换为实物，并解决实物中特有的电源管理、通信延迟、机械误差等问题。

空地协同巡线项目是一个微缩的多智能体系统，它强迫开发者从系统层面思考问题，而不仅仅是编写孤立的算法。通过仿真先行、模块化开发、逐步集成和严谨调试的策略，你可以将复杂的系统拆解为可管理、可测试的单元，最终构建出一个稳定、智能的协同机器人系统。这个过程中积累的系统思维、调试经验和多技术栈整合能力，其价值远超过比赛本身。