📚 课程目录第4章地面站核心框架

4. 地面站核心框架

说实话，做多无人机地面站，选对框架就等于成功了一半。我这些年折腾过不少方案，从早期的 MFC 到后来的 C# WPF，最后彻底倒向了 Qt。为什么？因为 Qt 的跨平台能力、信号与槽机制，以及成熟的多线程支持，简直就是为无人机地面站这种实时控制场景量身定做的。

这一章，我们就来聊聊怎么用 PySide6（Qt6 的 Python 绑定）搭起地面站的核心骨架。我会把我在实际项目中踩过的坑、总结的经验，都揉进这里。

4.1 为什么是 PySide6 而不是 PyQt6？

很多新手会问这个问题。我的答案是：许可证。PySide6 是 Qt 官方支持的，采用 LGPL 协议，商用更友好。PyQt6 虽然功能几乎一样，但 GPL 协议在某些场景下会有限制。

当然，从开发体验上说，两者差别不大。我个人习惯用 PySide6，因为它的 API 更贴近 C++ 原版 Qt，文档也跟得上。

核心选择标准：

PySide6：LGPL 协议，官方维护，API 与 C++ Qt 一致
PyQt6：GPL 协议，第三方维护，部分 API 有 Python 化封装
我的建议：商业项目选 PySide6，个人学习两者皆可

4.2 地面站界面框架搭建

地面站的界面，说白了就是一块大画布，上面摆满了各种控件。但怎么摆、怎么组织，是有讲究的。

我习惯用 QMainWindow 作为主窗口，配合 QDockWidget 实现可拖拽面板。这样用户可以根据自己的习惯，把地图、日志、无人机列表等面板拖到任意位置。

from PySide6.QtWidgets import QMainWindow, QDockWidget, QListWidget, QTextEdit
from PySide6.QtCore import Qt

class GroundStationWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("多无人机地面站协同控制系统")
        self.setMinimumSize(1280, 800)

        # 创建中央部件——地图区域
        self.map_widget = QWidget()  # 实际项目中会用地图库
        self.setCentralWidget(self.map_widget)

        # 创建可停靠面板：无人机列表
        self.uav_dock = QDockWidget("无人机列表", self)
        self.uav_list = QListWidget()
        self.uav_dock.setWidget(self.uav_list)
        self.addDockWidget(Qt.LeftDockWidgetArea, self.uav_dock)

        # 创建可停靠面板：日志输出
        self.log_dock = QDockWidget("系统日志", self)
        self.log_output = QTextEdit()
        self.log_output.setReadOnly(True)
        self.log_dock.setWidget(self.log_output)
        self.addDockWidget(Qt.BottomDockWidgetArea, self.log_dock)

嗯，这里要注意：QDockWidget 的布局策略。如果你有多个面板，建议用 tabifyDockWidget() 把它们叠起来，节省空间。我在第一个项目中没注意这个，结果界面被面板占了一大半，地图缩在角落里，被用户吐槽了好久。

4.3 多线程架构设计：别让 UI 卡成 PPT

地面站最怕什么？UI 卡死。你想啊，无人机在天上飞，你这边界面点不动，那得多慌。

根源在于：Qt 的主线程负责 UI 刷新，如果你在 UI 线程里做耗时操作（比如解析 MAVLink 数据、写日志），界面就会卡住。

解决方案？多线程。但 Qt 的多线程有它自己的脾气。

我曾经踩过的坑：

早期我直接在子线程里更新 UI 控件，结果程序随机崩溃。后来才明白，Qt 的 UI 控件不是线程安全的，所有 UI 操作必须在主线程执行。

正确的做法是：工作线程处理数据，通过信号与槽把结果发回主线程更新 UI。

下面是我常用的多线程架构模式：

from PySide6.QtCore import QThread, Signal, QObject
import time

class UAVWorker(QObject):
    """无人机数据采集工作器，运行在子线程"""
    data_received = Signal(dict)  # 数据信号，发射给主线程
    connection_status = Signal(bool)

    def __init__(self, uav_id):
        super().__init__()
        self.uav_id = uav_id
        self.running = True

    def run(self):
        """模拟无人机数据采集循环"""
        while self.running:
            # 模拟从串口/网络读取数据
            data = {
                "uav_id": self.uav_id,
                "latitude": 39.9042,
                "longitude": 116.4074,
                "altitude": 100.0,
                "battery": 85.0,
                "timestamp": time.time()
            }
            # 通过信号发射数据，自动跨线程传递
            self.data_received.emit(data)
            time.sleep(0.1)  # 10Hz 更新频率

    def stop(self):
        self.running = False

class UAVController(QObject):
    """无人机控制器，运行在主线程，管理子线程"""
    def __init__(self, uav_id):
        super().__init__()
        self.uav_id = uav_id
        self.thread = QThread()
        self.worker = UAVWorker(uav_id)
        self.worker.moveToThread(self.thread)

        # 连接信号
        self.worker.data_received.connect(self.on_data_received)
        self.thread.started.connect(self.worker.run)

    def start(self):
        self.thread.start()

    def on_data_received(self, data):
        """主线程中更新 UI——安全操作"""
        # 这里可以安全地更新 UI 控件
        print(f"无人机 {data['uav_id']} 位置: {data['latitude']}, {data['longitude']}")

个人经验：

每个无人机实例对应一个独立的 QThread + Worker 组合。这样一架无人机卡住了，不会影响其他无人机的数据流。我曾经用这个架构同时控制过 12 架无人机，稳得很。

4.4 信号与槽机制：无人机控制的神经中枢

信号与槽，是 Qt 最核心的机制。说白了，就是一个对象发出信号，另一个对象的槽函数自动响应。这个过程是松耦合的，发射者不需要知道谁在监听。

在无人机控制中，这个机制简直太好用了。举个例子：

无人机状态变化 → 发射信号 → 地图控件更新位置
用户点击"起飞"按钮 → 发射信号 → 指令编码器生成 MAVLink 指令
电池电量过低 → 发射信号 → 日志系统记录 + 弹窗警告

看一个实际的控制链路：

from PySide6.QtCore import Signal, QObject

class UAVCommandCenter(QObject):
    """无人机指令中心——信号发射器"""
    takeoff_command = Signal(int, float)  # 无人机ID, 目标高度
    land_command = Signal(int)
    goto_command = Signal(int, float, float, float)  # ID, lat, lon, alt
    return_home = Signal(int)

    def __init__(self):
        super().__init__()
        self.uav_controllers = {}

    def command_takeoff(self, uav_id, altitude):
        """发出起飞指令"""
        print(f"指令发出: 无人机 {uav_id} 起飞至 {altitude}米")
        self.takeoff_command.emit(uav_id, altitude)

class UAVCommandExecutor(QObject):
    """无人机指令执行器——槽函数"""
    def __init__(self, uav_id):
        super().__init__()
        self.uav_id = uav_id

    def execute_takeoff(self, uav_id, altitude):
        if uav_id != self.uav_id:
            return
        print(f"无人机 {self.uav_id}: 执行起飞，目标高度 {altitude}米")
        # 实际会调用 MAVLink 协议发送指令

# 连接信号与槽
command_center = UAVCommandCenter()
executor_1 = UAVCommandExecutor(1)
command_center.takeoff_command.connect(executor_1.execute_takeoff)

# 一键起飞
command_center.command_takeoff(1, 50.0)

为什么信号与槽适合无人机控制？

解耦：UI 层不需要知道底层通信细节
线程安全：跨线程信号自动排队，不会崩溃
一对多：一个信号可以触发多个槽，比如"紧急降落"信号同时触发日志、UI、通信模块
类型安全：编译期检查参数类型，减少运行时错误

4.5 整体架构图：看看这些模块怎么配合

下面这张图，是我在实际项目中总结出来的地面站核心架构。你仔细看，信号与槽就像一条条虚线，把各个模块串联起来。

4.6 避坑指南：多线程 + 信号与槽的常见陷阱

理论说完了，来点实战经验。这些坑我基本都踩过，你提前知道，能省不少调试时间。

陷阱	现象	解决方案
在子线程直接更新 UI	程序随机崩溃、界面闪烁	所有 UI 操作通过信号发射到主线程执行
忘记调用 moveToThread()	Worker 仍在主线程运行，界面卡死	创建 Worker 后必须 `worker.moveToThread(thread)`
信号连接了耗时槽函数	信号阻塞，后续信号排队延迟	耗时操作放到子线程，槽函数只做轻量 UI 更新
线程退出时未清理	程序退出时崩溃或内存泄漏	重写 `closeEvent`，先停止所有线程再退出
信号参数类型不匹配	连接失败或运行时错误	使用 `@Slot()` 装饰器明确声明参数类型

我曾经踩过的一个大坑：

有一次做 8 架无人机的编队控制，我偷懒把所有 Worker 放在同一个线程里。结果一架无人机的通信阻塞，导致所有无人机数据都延迟了。编队队形直接乱掉，差点炸机。从那以后，我坚持一架无人机一个独立线程，再也没出过类似问题。

4.7 小结：这一章你带走了什么

嗯，内容不少，我们捋一捋核心点：

PySide6 是地面站的首选框架，许可证友好，API 规范
QMainWindow + QDockWidget 搭建可定制界面
多线程架构：每个无人机独立 QThread，通过信号与槽与主线程通信
信号与槽是无人机控制的神经中枢，解耦、安全、灵活
避坑：别在子线程碰 UI，记得 moveToThread，退出时清理线程