项目开发背景

随着无人机技术的快速发展，其在农业监测、环境巡查、物流配送和紧急救援等领域的应用日益广泛。然而，传统无人机多依赖短距离通信方式，如Wi-Fi或无线电，限制了其在远距离或复杂地形下的操作范围与可靠性。这种局限性使得无人机难以在需要大范围覆盖或实时数据传输的场景中发挥最大效能，例如在偏远地区进行长期监测或跨城市物流任务中，通信中断风险较高，影响了整体效率与安全性。

为了解决上述挑战，本项目基于4G网络设计了一套无人机远程控制系统。4G网络具有覆盖广、传输稳定和低延迟的特点，能够为无人机提供可靠的长距离通信链路，确保远程控制中心与无人机之间实时交换数据。该系统不仅支持无人机通过4G模块上传GPS定位和飞行状态信息，还能接收来自控制中心的指令，实现精准的远程操控。同时，无人机内置自主飞行功能，如定点悬停和预设航线飞行，进一步增强了其在无人干预下的适应性与实用性。

在硬件层面，系统采用高性能STM32F407主控芯片，结合4G DTU模块、多传感器和动力组件，构建了一个高效稳定的飞行平台。这一设计不仅提升了无人机的数据处理与通信能力，还通过大容量电池保障了长时间任务执行。项目开发旨在推动无人机在工业与民用领域的创新应用，为远程监控、灾害响应和智能运输等场景提供更灵活的解决方案，同时降低操作成本与风险。

设计实现的功能

(1) 无人机通过4G网络与远程控制中心建立长距离通信链路。
(2) 远程控制中心可接收无人机回传的GPS定位信息与飞行状态数据。
(3) 远程控制中心可通过4G网络向无人机发送飞行控制指令。
(4) 无人机具备基本的自主飞行能力，如定点悬停、航线飞行。

项目硬件模块组成

（1）主控芯片：STM32F407系列（高性能，带DSP指令集）。
（2）通信模块：4G DTU（如SIM7600）模块。
（3）飞控传感：MPU6050六轴传感器、GPS定位模块、气压计。
（4）动力系统：无刷电机、电子调速器（电调）、螺旋桨。
（5）电源系统：大容量锂聚合物电池。

设计意义

该系统通过4G网络实现无人机与远程控制中心的长距离通信，克服了传统遥控方式在距离和障碍物遮挡方面的限制，使得无人机能够在城市、乡村甚至偏远地区进行稳定操作，扩展了应用范围。这种设计特别适用于需要广域覆盖的场景，如边境巡逻、大型基础设施监测和灾害应急响应。

远程控制中心能够实时接收无人机回传的GPS定位信息和飞行状态数据，包括位置、高度和姿态等，这为操作人员提供了全面的监控能力，便于及时评估任务进展和无人机健康状况。这种实时数据反馈机制增强了系统的安全性和可靠性，减少了人为误判的风险。

通过4G网络向无人机发送飞行控制指令，系统实现了灵活的远程操控，支持动态调整飞行路径或执行紧急命令。这种双向通信能力使得无人机能够适应多变的任务需求，例如在搜救行动中快速响应环境变化，提高了整体任务效率。

无人机具备基本的自主飞行能力，如定点悬停和航线飞行，这降低了操作人员的负担，并提升了任务的自动化水平。自主功能结合远程控制，使得系统适用于重复性或精细作业，如农业喷洒、航拍摄影和环境监测，从而优化资源利用并减少人工干预。

硬件模块的集成，包括高性能主控芯片、可靠通信组件和精确传感器，确保了系统的稳定运行和长续航能力。这种设计注重实用性和耐用性，为各类行业应用提供了坚实的基础，推动无人机技术在远程控制领域的普及和发展。

设计思路

该系统设计基于4G网络实现无人机的远程控制，核心思路是利用4G通信模块建立无人机与远程控制中心之间的稳定长距离链路。无人机端采用STM32F407作为主控芯片，负责整体逻辑处理和数据协调，确保系统高效运行。通信模块选用4G DTU（如SIM7600），通过插入SIM卡接入移动网络，实现与控制中心的双向数据传输，包括指令下发和状态回传。

无人机通过集成多种传感器实时采集飞行数据，GPS模块提供定位信息，MPU6050六轴传感器监测姿态和加速度，气压计辅助高度测量。这些数据由主控芯片整合后，通过4G网络主动发送至远程控制中心，便于操作人员监控无人机状态。控制中心可解析数据并生成飞行控制指令，如调整航向或速度，再通过4G网络下发至无人机。

无人机的自主飞行功能依赖于主控芯片的算法处理，结合传感器反馈实现定点悬停和预设航线飞行。STM32F407的高性能DSP指令集支持快速数据运算，确保飞行控制的实时性和稳定性。动力系统由无刷电机、电调和螺旋桨组成，主控芯片输出PWM信号驱动电调，从而调节电机转速，实现精确的飞行姿态调整。

整个系统的电源由大容量锂聚合物电池提供，需合理设计供电电路以确保各模块稳定工作，尤其是4G通信模块和动力系统的高功耗需求。硬件模块之间通过串口或SPI等接口连接，主控芯片统筹调度，实现通信、传感和动力系统的协同运作，最终达成远程控制与自主飞行的平衡。

框架图

+--------------------------------+          +--------------------------------+
|        无人机系统              |          |      远程控制中心             |
+--------------------------------+          +--------------------------------+
|                                |          |                                |
|  [主控芯片: STM32F407]         |          |  [控制软件]                   |
|        |                       |          |        |                      |
|        +-- [飞控传感器]        |          |        +-- 数据处理与显示       |
|        |   |-- MPU6050六轴传感器 |        |        |                      |
|        |   |-- GPS定位模块      |        |        +-- 指令生成            |
|        |   |-- 气压计           |        |                                |
|        |                       |          |  [通信接口]                   |
|        +-- [通信模块: 4G DTU]  |<---4G网络--->| 接收: GPS定位、飞行状态数据 |
|              |                 |          |  发送: 飞行控制指令           |
|              +-- 4G网络连接     |          |                                |
|                                |          |                                |
|  [动力系统]                    |          +--------------------------------+
|        |-- 无刷电机             |
|        |-- 电子调速器 (电调)    |
|        |-- 螺旋桨               |
|                                |
|  [电源系统: 锂聚合物电池]       |
|        (为所有模块供电)         |
+--------------------------------+

系统总体设计

该系统基于4G网络实现无人机的远程控制，无人机与远程控制中心通过4G通信模块建立稳定的长距离连接，确保数据传输的实时性和可靠性。无人机的核心由STM32F407主控芯片负责整体协调与数据处理，该芯片的高性能特性支持复杂的飞行控制算法和传感器数据融合。

硬件模块中，4G DTU模块（如SIM7600）负责网络通信，使无人机能够与远程控制中心进行双向数据交换；飞控传感器包括MPU6050六轴传感器用于姿态检测、GPS模块提供定位信息、气压计辅助高度测量，这些传感器数据被主控芯片采集并处理。动力系统由无刷电机、电子调速器和螺旋桨组成，执行飞行动作；电源系统采用大容量锂聚合物电池，为整个系统提供持续电力。

在功能实现上，远程控制中心通过4G网络接收无人机回传的GPS定位信息和飞行状态数据，如位置、速度和姿态，同时可向无人机发送飞行控制指令，例如调整航向或速度。无人机具备基本的自主飞行能力，主控芯片基于传感器输入实现定点悬停和预设航线飞行，确保在无人工干预时保持稳定运行。

整体上，系统通过硬件模块的紧密协作和4G网络的广覆盖，实现了远程监控与控制，满足长距离作业需求，同时自主飞行功能提升了系统的灵活性和实用性。

系统功能总结

设计的各个功能模块描述

主控芯片模块采用STM32F407系列高性能处理器，具备DSP指令集，负责整体系统的协调与控制。它处理来自传感器的数据，执行飞行控制算法，实现无人机的自主飞行功能，如定点悬停和航线飞行，同时管理通信和数据传输任务。

通信模块使用4G DTU设备，例如SIM7600模块，通过4G网络建立与远程控制中心的长距离通信链路。该模块负责发送无人机回传的GPS定位信息和飞行状态数据，并接收来自控制中心的飞行控制指令，确保实时双向通信的稳定性。

飞控传感模块集成了MPU6050六轴传感器、GPS定位模块和气压计，用于采集无人机的姿态、位置和高度数据。这些传感器提供准确的飞行状态信息，支持主控芯片进行实时调整，以实现稳定的飞行控制和数据回传功能。

动力系统模块包括无刷电机、电子调速器和螺旋桨，负责提供无人机的推力和机动能力。电子调速器根据主控芯片的指令调节电机转速，控制飞行方向和速度，确保无人机能够执行各种飞行任务。

电源系统模块采用大容量锂聚合物电池，为所有硬件组件提供可靠的电力供应。它确保系统在长时间飞行中保持稳定运行，支持通信、传感和动力模块的持续工作。

上位机代码设计

#include <iostream>
#include <string>
#include <vector>
#include <thread>
#include <chrono>
#include <mutex>
#include <atomic>
#include <sstream>
#include <iomanip>
#include <winsock2.h>
#include <ws2tcpip.h>

#pragma comment(lib, "ws2_32.lib")

// 无人机状态数据结构
struct DroneStatus {
    double latitude;
    double longitude;
    double altitude;
    double pitch;
    double roll;
    double yaw;
    double battery_level;
    int flight_mode;
    std::string timestamp;
};

// 飞行控制指令
struct FlightCommand {
    int command_type;  // 0:悬停 1:航线飞行 2:返航 3:紧急停止
    double target_lat;
    double target_lng;
    double target_alt;
    std::vector<std::pair<double, double>> waypoints;
};

class DroneControlSystem {
private:
    SOCKET control_socket;
    std::atomic<bool> is_connected;
    std::atomic<bool> is_running;
    std::thread data_receive_thread;
    std::thread command_send_thread;
    std::mutex status_mutex;
    std::mutex command_mutex;
    DroneStatus current_status;
    FlightCommand pending_command;
    
public:
    DroneControlSystem() : is_connected(false), is_running(false), control_socket(INVALID_SOCKET) {
        current_status = {0, 0, 0, 0, 0, 0, 100.0, 0, ""};
    }
    
    ~DroneControlSystem() {
        disconnect();
    }
    
    // 初始化网络连接
    bool initialize() {
        WSADATA wsaData;
        if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
            std::cerr << "WSAStartup failed" << std::endl;
            return false;
        }
        return true;
    }
    
    // 连接到无人机
    bool connectToDrone(const std::string& server_ip, int port) {
        control_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (control_socket == INVALID_SOCKET) {
            std::cerr << "Socket creation failed" << std::endl;
            return false;
        }
        
        sockaddr_in server_addr;
        server_addr.sin_family = AF_INET;
        server_addr.sin_port = htons(port);
        inet_pton(AF_INET, server_ip.c_str(), &server_addr.sin_addr);
        
        if (connect(control_socket, (sockaddr*)&server_addr, sizeof(server_addr)) == SOCKET_ERROR) {
            std::cerr << "Connection failed" << std::endl;
            closesocket(control_socket);
            control_socket = INVALID_SOCKET;
            return false;
        }
        
        is_connected = true;
        is_running = true;
        
        // 启动数据接收线程
        data_receive_thread = std::thread(&DroneControlSystem::dataReceiveLoop, this);
        // 启动指令发送线程
        command_send_thread = std::thread(&DroneControlSystem::commandSendLoop, this);
        
        std::cout << "Connected to drone successfully" << std::endl;
        return true;
    }
    
    // 断开连接
    void disconnect() {
        is_running = false;
        is_connected = false;
        
        if (data_receive_thread.joinable()) {
            data_receive_thread.join();
        }
        if (command_send_thread.joinable()) {
            command_send_thread.join();
        }
        
        if (control_socket != INVALID_SOCKET) {
            closesocket(control_socket);
            control_socket = INVALID_SOCKET;
        }
        
        WSACleanup();
        std::cout << "Disconnected from drone" << std::endl;
    }
    
    // 发送飞行控制指令
    void sendFlightCommand(const FlightCommand& cmd) {
        std::lock_guard<std::mutex> lock(command_mutex);
        pending_command = cmd;
    }
    
    // 获取当前无人机状态
    DroneStatus getCurrentStatus() {
        std::lock_guard<std::mutex> lock(status_mutex);
        return current_status;
    }
    
    // 定点悬停指令
    void hoverAtPosition(double lat, double lng, double alt) {
        FlightCommand cmd;
        cmd.command_type = 0; // 悬停
        cmd.target_lat = lat;
        cmd.target_lng = lng;
        cmd.target_alt = alt;
        sendFlightCommand(cmd);
        std::cout << "Hover command sent: Lat=" << lat << ", Lng=" << lng << ", Alt=" << alt << std::endl;
    }
    
    // 航线飞行指令
    void flyRoute(const std::vector<std::pair<double, double>>& waypoints, double altitude) {
        FlightCommand cmd;
        cmd.command_type = 1; // 航线飞行
        cmd.target_alt = altitude;
        cmd.waypoints = waypoints;
        sendFlightCommand(cmd);
        std::cout << "Route flight command sent with " << waypoints.size() << " waypoints" << std::endl;
    }
    
    // 返航指令
    void returnToHome() {
        FlightCommand cmd;
        cmd.command_type = 2; // 返航
        sendFlightCommand(cmd);
        std::cout << "Return to home command sent" << std::endl;
    }
    
    // 紧急停止指令
    void emergencyStop() {
        FlightCommand cmd;
        cmd.command_type = 3; // 紧急停止
        sendFlightCommand(cmd);
        std::cout << "Emergency stop command sent" << std::endl;
    }
    
    // 显示无人机状态
    void displayStatus() {
        DroneStatus status = getCurrentStatus();
        std::cout << "\n=== Drone Status ===" << std::endl;
        std::cout << "Position: " << std::fixed << std::setprecision(6) 
                  << status.latitude << ", " << status.longitude << std::endl;
        std::cout << "Altitude: " << status.altitude << " m" << std::endl;
        std::cout << "Attitude: Pitch=" << status.pitch << "°, Roll=" << status.roll 
                  << "°, Yaw=" << status.yaw << "°" << std::endl;
        std::cout << "Battery: " << status.battery_level << "%" << std::endl;
        std::cout << "Flight Mode: " << status.flight_mode << std::endl;
        std::cout << "Timestamp: " << status.timestamp << std::endl;
    }

private:
    // 数据接收循环
    void dataReceiveLoop() {
        char buffer[1024];
        int bytes_received;
        
        while (is_running && is_connected) {
            bytes_received = recv(control_socket, buffer, sizeof(buffer) - 1, 0);
            
            if (bytes_received > 0) {
                buffer[bytes_received] = '\0';
                processReceivedData(buffer);
            } else if (bytes_received == 0) {
                std::cout << "Connection closed by drone" << std::endl;
                is_connected = false;
                break;
            } else {
                std::cerr << "Receive error: " << WSAGetLastError() << std::endl;
                std::this_thread::sleep_for(std::chrono::milliseconds(100));
            }
            
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
        }
    }
    
    // 指令发送循环
    void commandSendLoop() {
        while (is_running && is_connected) {
            std::lock_guard<std::mutex> lock(command_mutex);
            
            // 构建指令字符串
            std::string command_str = buildCommandString(pending_command);
            if (!command_str.empty()) {
                send(control_socket, command_str.c_str(), command_str.length(), 0);
                // 清空待发送指令
                pending_command = FlightCommand();
            }
            
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }
    }
    
    // 处理接收到的数据
    void processReceivedData(const std::string& data) {
        // 解析无人机状态数据
        // 格式: STATUS,lat,lng,alt,pitch,roll,yaw,battery,mode,timestamp
        if (data.find("STATUS") == 0) {
            std::vector<std::string> tokens;
            std::stringstream ss(data);
            std::string token;
            
            while (std::getline(ss, token, ',')) {
                tokens.push_back(token);
            }
            
            if (tokens.size() >= 10) {
                std::lock_guard<std::mutex> lock(status_mutex);
                current_status.latitude = std::stod(tokens[1]);
                current_status.longitude = std::stod(tokens[2]);
                current_status.altitude = std::stod(tokens[3]);
                current_status.pitch = std::stod(tokens[4]);
                current_status.roll = std::stod(tokens[5]);
                current_status.yaw = std::stod(tokens[6]);
                current_status.battery_level = std::stod(tokens[7]);
                current_status.flight_mode = std::stoi(tokens[8]);
                current_status.timestamp = tokens[9];
            }
        }
    }
    
    // 构建指令字符串
    std::string buildCommandString(const FlightCommand& cmd) {
        std::stringstream ss;
        
        switch (cmd.command_type) {
            case 0: // 悬停
                ss << "HOVER," << cmd.target_lat << "," << cmd.target_lng << "," << cmd.target_alt;
                break;
            case 1: // 航线飞行
                ss << "ROUTE," << cmd.target_alt;
                for (const auto& wp : cmd.waypoints) {
                    ss << "," << wp.first << "," << wp.second;
                }
                break;
            case 2: // 返航
                ss << "RTH";
                break;
            case 3: // 紧急停止
                ss << "ESTOP";
                break;
            default:
                return "";
        }
        
        return ss.str();
    }
};

// 用户界面类
class UserInterface {
private:
    DroneControlSystem& control_system;
    
public:
    UserInterface(DroneControlSystem& system) : control_system(system) {}
    
    void run() {
        std::cout << "=== 4G无人机远程控制系统 ===" << std::endl;
        std::cout << "1. 连接到无人机" << std::endl;
        std::cout << "2. 显示状态" << std::endl;
        std::cout << "3. 定点悬停" << std::endl;
        std::cout << "4. 航线飞行" << std::endl;
        std::cout << "5. 返航" << std::endl;
        std::cout << "6. 紧急停止" << std::endl;
        std::cout << "7. 断开连接" << std::endl;
        std::cout << "8. 退出" << std::endl;
        
        int choice;
        while (true) {
            std::cout << "\n请选择操作: ";
            std::cin >> choice;
            
            switch (choice) {
                case 1:
                    connectToDrone();
                    break;
                case 2:
                    control_system.displayStatus();
                    break;
                case 3:
                    sendHoverCommand();
                    break;
                case 4:
                    sendRouteCommand();
                    break;
                case 5:
                    control_system.returnToHome();
                    break;
                case 6:
                    control_system.emergencyStop();
                    break;
                case 7:
                    control_system.disconnect();
                    break;
                case 8:
                    return;
                default:
                    std::cout << "无效选择" << std::endl;
            }
        }
    }
    
private:
    void connectToDrone() {
        std::string ip;
        int port;
        
        std::cout << "输入无人机IP地址: ";
        std::cin >> ip;
        std::cout << "输入端口号: ";
        std::cin >> port;
        
        if (control_system.initialize()) {
            control_system.connectToDrone(ip, port);
        }
    }
    
    void sendHoverCommand() {
        double lat, lng, alt;
        std::cout << "输入目标纬度: ";
        std::cin >> lat;
        std::cout << "输入目标经度: ";
        std::cin >> lng;
        std::cout << "输入目标高度: ";
        std::cin >> alt;
        
        control_system.hoverAtPosition(lat, lng, alt);
    }
    
    void sendRouteCommand() {
        int num_points;
        std::cout << "输入航点数量: ";
        std::cin >> num_points;
        
        std::vector<std::pair<double, double>> waypoints;
        for (int i = 0; i < num_points; ++i) {
            double lat, lng;
            std::cout << "航点 " << i + 1 << " 纬度: ";
            std::cin >> lat;
            std::cout << "航点 " << i + 1 << " 经度: ";
            std::cin >> lng;
            waypoints.push_back({lat, lng});
        }
        
        double altitude;
        std::cout << "输入飞行高度: ";
        std::cin >> altitude;
        
        control_system.flyRoute(waypoints, altitude);
    }
};

int main() {
    DroneControlSystem control_system;
    UserInterface ui(control_system);
    ui.run();
    return 0;
}

模块代码设计

#include "stm32f4xx.h"

// MPU6050寄存器定义
#define MPU6050_ADDR 0xD0
#define MPU6050_SMPLRT_DIV 0x19
#define MPU6050_CONFIG 0x1A
#define MPU6050_GYRO_CONFIG 0x1B
#define MPU6050_ACCEL_CONFIG 0x1C
#define MPU6050_ACCEL_XOUT_H 0x3B
#define MPU6050_GYRO_XOUT_H 0x43
#define MPU6050_PWR_MGMT_1 0x6B
#define MPU6050_WHO_AM_I 0x75

// GPS相关定义
#define GPS_BUFFER_SIZE 256

// 4G模块相关定义
#define AT_OK 0
#define AT_ERROR -1

// 传感器数据结构
typedef struct {
    int16_t accel_x;
    int16_t accel_y;
    int16_t accel_z;
    int16_t temp;
    int16_t gyro_x;
    int16_t gyro_y;
    int16_t gyro_z;
} MPU6050_Data;

typedef struct {
    float latitude;
    float longitude;
    float altitude;
    uint8_t fix_status;
} GPS_Data;

// 全局变量
volatile MPU6050_Data mpu_data;
volatile GPS_Data gps_data;
volatile uint8_t gps_buffer[GPS_BUFFER_SIZE];
volatile uint16_t gps_index = 0;

// I2C1初始化
void I2C1_Init(void) {
    // 使能GPIOB和I2C1时钟
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIOBEN;
    RCC->APB1ENR |= RCC_APB1ENR_I2C1EN;
    
    // PB6-I2C1_SCL, PB7-I2C1_SDA
    GPIOB->MODER |= (2 << 12) | (2 << 14);  // 复用功能
    GPIOB->OTYPER |= (1 << 6) | (1 << 7);   // 开漏输出
    GPIOB->OSPEEDR |= (3 << 12) | (3 << 14); // 高速
    GPIOB->PUPDR |= (1 << 12) | (1 << 14);   // 上拉
    GPIOB->AFR[0] |= (4 << 24) | (4 << 28);  // AF4
    
    // I2C配置
    I2C1->CR1 &= ~I2C_CR1_PE;  // 禁用I2C
    I2C1->CR2 = 42;            // 42MHz
    I2C1->CCR = 210;           // 100kHz
    I2C1->TRISE = 43;          // 最大上升时间
    I2C1->CR1 |= I2C_CR1_PE;   // 使能I2C
}

// I2C写字节
void I2C_Write(uint8_t dev_addr, uint8_t reg_addr, uint8_t data) {
    while(I2C1->SR2 & I2C_SR2_BUSY);
    
    // 启动条件
    I2C1->CR1 |= I2C_CR1_START;
    while(!(I2C1->SR1 & I2C_SR1_SB));
    
    // 发送设备地址(写)
    I2C1->DR = dev_addr;
    while(!(I2C1->SR1 & I2C_SR1_ADDR));
    (void)I2C1->SR2;
    
    // 发送寄存器地址
    I2C1->DR = reg_addr;
    while(!(I2C1->SR1 & I2C_SR1_TXE));
    
    // 发送数据
    I2C1->DR = data;
    while(!(I2C1->SR1 & I2C_SR1_BTF));
    
    // 停止条件
    I2C1->CR1 |= I2C_CR1_STOP;
}

// I2C读多个字节
void I2C_Read_Multi(uint8_t dev_addr, uint8_t reg_addr, uint8_t *data, uint8_t count) {
    while(I2C1->SR2 & I2C_SR2_BUSY);
    
    // 启动条件
    I2C1->CR1 |= I2C_CR1_START;
    while(!(I2C1->SR1 & I2C_SR1_SB));
    
    // 发送设备地址(写)
    I2C1->DR = dev_addr;
    while(!(I2C1->SR1 & I2C_SR1_ADDR));
    (void)I2C1->SR2;
    
    // 发送寄存器地址
    I2C1->DR = reg_addr;
    while(!(I2C1->SR1 & I2C_SR1_TXE));
    
    // 重新启动
    I2C1->CR1 |= I2C_CR1_START;
    while(!(I2C1->SR1 & I2C_SR1_SB));
    
    // 发送设备地址(读)
    I2C1->DR = dev_addr | 0x01;
    while(!(I2C1->SR1 & I2C_SR1_ADDR));
    (void)I2C1->SR2;
    
    // 读取数据
    for(uint8_t i = 0; i < count; i++) {
        if(i == count - 1) {
            I2C1->CR1 &= ~I2C_CR1_ACK;  // 最后一个字节不发送ACK
        }
        while(!(I2C1->SR1 & I2C_SR1_RXNE));
        data[i] = I2C1->DR;
    }
    
    // 停止条件
    I2C1->CR1 |= I2C_CR1_STOP;
    I2C1->CR1 |= I2C_CR1_ACK;  // 重新使能ACK
}

// MPU6050初始化
void MPU6050_Init(void) {
    I2C_Write(MPU6050_ADDR, MPU6050_PWR_MGMT_1, 0x80);  // 复位设备
    Delay(100);
    I2C_Write(MPU6050_ADDR, MPU6050_PWR_MGMT_1, 0x00);  // 唤醒
    I2C_Write(MPU6050_ADDR, MPU6050_SMPLRT_DIV, 0x07);  // 采样率1kHz
    I2C_Write(MPU6050_ADDR, MPU6050_CONFIG, 0x00);      // 禁用低通滤波
    I2C_Write(MPU6050_ADDR, MPU6050_GYRO_CONFIG, 0x08); // ±500dps
    I2C_Write(MPU6050_ADDR, MPU6050_ACCEL_CONFIG, 0x10); // ±8g
}

// 读取MPU6050数据
void MPU6050_ReadData(void) {
    uint8_t buffer[14];
    I2C_Read_Multi(MPU6050_ADDR, MPU6050_ACCEL_XOUT_H, buffer, 14);
    
    mpu_data.accel_x = (buffer[0] << 8) | buffer[1];
    mpu_data.accel_y = (buffer[2] << 8) | buffer[3];
    mpu_data.accel_z = (buffer[4] << 8) | buffer[5];
    mpu_data.temp = (buffer[6] << 8) | buffer[7];
    mpu_data.gyro_x = (buffer[8] << 8) | buffer[9];
    mpu_data.gyro_y = (buffer[10] << 8) | buffer[11];
    mpu_data.gyro_z = (buffer[12] << 8) | buffer[13];
}

// USART2初始化 (GPS)
void USART2_Init(void) {
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
    RCC->APB1ENR |= RCC_APB1ENR_USART2EN;
    
    // PA2-TX, PA3-RX
    GPIOA->MODER |= (2 << 4) | (2 << 6);
    GPIOA->AFR[0] |= (7 << 8) | (7 << 12);
    
    USART2->BRR = 42000000 / 9600;  // 42MHz, 9600bps
    USART2->CR1 = USART_CR1_TE | USART_CR1_RE | USART_CR1_RXNEIE | USART_CR1_UE;
    
    NVIC_EnableIRQ(USART2_IRQn);
}

// USART3初始化 (4G模块)
void USART3_Init(void) {
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIOCEN;
    RCC->APB1ENR |= RCC_APB1ENR_USART3EN;
    
    // PC10-TX, PC11-RX
    GPIOC->MODER |= (2 << 20) | (2 << 22);
    GPIOC->AFR[1] |= (7 << 8) | (7 << 12);
    
    USART3->BRR = 42000000 / 115200;  // 42MHz, 115200bps
    USART3->CR1 = USART_CR1_TE | USART_CR1_RE | USART_CR1_UE;
}

// USART发送字符串
void USART_SendString(USART_TypeDef* USARTx, char* str) {
    while(*str) {
        while(!(USARTx->SR & USART_SR_TXE));
        USARTx->DR = *str++;
    }
}

// GPS数据解析
void GPS_ParseData(char* gps_string) {
    // 简化的NMEA解析，实际需要完整解析GPRMC或GPGGA语句
    if(strstr(gps_string, "$GPRMC")) {
        // 解析经纬度、速度、航向等信息
        char* token = strtok(gps_string, ",");
        uint8_t field = 0;
        
        while(token != NULL) {
            switch(field) {
                case 3: // 纬度
                    // 解析纬度
                    break;
                case 5: // 经度
                    // 解析经度
                    break;
                case 7: // 速度
                    // 解析速度
                    break;
                case 8: // 航向
                    // 解析航向
                    break;
            }
            token = strtok(NULL, ",");
            field++;
        }
    }
}

// 4G模块初始化
void G4_Module_Init(void) {
    Delay(1000);
    USART_SendString(USART3, "AT\r\n");
    Delay(100);
    USART_SendString(USART3, "AT+CPIN?\r\n");
    Delay(100);
    USART_SendString(USART3, "AT+CSQ\r\n");
    Delay(100);
    USART_SendString(USART3, "AT+CGATT=1\r\n");
    Delay(100);
    USART_SendString(USART3, "AT+CSTT=\"CMNET\"\r\n");
    Delay(100);
    USART_SendString(USART3, "AT+CIICR\r\n");
    Delay(1000);
    USART_SendString(USART3, "AT+CIFSR\r\n");
}

// PWM初始化 (电机控制)
void TIM1_PWM_Init(void) {
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
    RCC->APB2ENR |= RCC_APB2ENR_TIM1EN;
    
    // PA8, PA9, PA10, PA11 - TIM1 CH1, CH2, CH3, CH4
    GPIOA->MODER |= (2 << 16) | (2 << 18) | (2 << 20) | (2 << 22);
    GPIOA->AFR[1] |= (1 << 0) | (1 << 4) | (1 << 8) | (1 << 12);
    
    TIM1->PSC = 83;        // 84MHz/84 = 1MHz
    TIM1->ARR = 19999;     // 50Hz PWM
    TIM1->CCR1 = 1000;     // 初始占空比
    TIM1->CCR2 = 1000;
    TIM1->CCR3 = 1000;
    TIM1->CCR4 = 1000;
    
    TIM1->CCMR1 = (6 << 4) | (1 << 3) | (6 << 12) | (1 << 11);  // PWM模式1
    TIM1->CCMR2 = (6 << 4) | (1 << 3) | (6 << 12) | (1 << 11);
    TIM1->CCER = TIM_CCER_CC1E | TIM_CCER_CC2E | TIM_CCER_CC3E | TIM_CCER_CC4E;
    TIM1->BDTR |= TIM_BDTR_MOE;
    TIM1->CR1 = TIM_CR1_CEN;
}

// 设置电机速度
void Motor_SetSpeed(uint8_t motor, uint16_t speed) {
    if(speed < 1000) speed = 1000;
    if(speed > 2000) speed = 2000;
    
    switch(motor) {
        case 0: TIM1->CCR1 = speed; break;
        case 1: TIM1->CCR2 = speed; break;
        case 2: TIM1->CCR3 = speed; break;
        case 3: TIM1->CCR4 = speed; break;
    }
}

// 系统时钟初始化
void SystemClock_Config(void) {
    // 启用HSE
    RCC->CR |= RCC_CR_HSEON;
    while(!(RCC->CR & RCC_CR_HSERDY));
    
    // 配置PLL: HSE(8MHz) * 336 / (8 * 2) = 84MHz
    RCC->PLLCFGR = (8 << 0) | (336 << 6) | (2 << 16) | (1 << 22) | RCC_PLLCFGR_PLLSRC_HSE;
    
    // 启用PLL
    RCC->CR |= RCC_CR_PLLON;
    while(!(RCC->CR & RCC_CR_PLLRDY));
    
    // 配置闪存延迟
    FLASH->ACR = FLASH_ACR_LATENCY_2WS | FLASH_ACR_ICEN | FLASH_ACR_DCEN | FLASH_ACR_PRFTEN;
    
    // 配置时钟分频
    RCC->CFGR |= RCC_CFGR_HPRE_DIV1 | RCC_CFGR_PPRE1_DIV4 | RCC_CFGR_PPRE2_DIV2;
    
    // 切换到PLL
    RCC->CFGR |= RCC_CFGR_SW_PLL;
    while((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_PLL);
}

// 延时函数
void Delay(uint32_t ms) {
    for(uint32_t i = 0; i < ms * 1000; i++) {
        __NOP();
    }
}

// USART2中断处理 (GPS数据接收)
void USART2_IRQHandler(void) {
    if(USART2->SR & USART_SR_RXNE) {
        uint8_t data = USART2->DR;
        
        if(gps_index < GPS_BUFFER_SIZE - 1) {
            gps_buffer[gps_index++] = data;
            
            if(data == '\n') {
                gps_buffer[gps_index] = '\0';
                GPS_ParseData((char*)gps_buffer);
                gps_index = 0;
            }
        } else {
            gps_index = 0;
        }
    }
}

// 主函数
int main(void) {
    SystemClock_Config();
    
    I2C1_Init();
    USART2_Init();
    USART3_Init();
    TIM1_PWM_Init();
    
    MPU6050_Init();
    G4_Module_Init();
    
    // 启动所有电机
    for(uint8_t i = 0; i < 4; i++) {
        Motor_SetSpeed(i, 1000);
    }
    
    while(1) {
        MPU6050_ReadData();
        
        // 姿态控制算法 (简化的PID)
        float pitch_error = 0 - (mpu_data.accel_x / 16384.0);  // 转换为g
        float roll_error = 0 - (mpu_data.accel_y / 16384.0);
        
        // 简单的电机控制
        uint16_t base_speed = 1100;
        Motor_SetSpeed(0, base_speed + (int)(pitch_error * 100));
        Motor_SetSpeed(1, base_speed - (int)(pitch_error * 100));
        Motor_SetSpeed(2, base_speed + (int)(roll_error * 100));
        Motor_SetSpeed(3, base_speed - (int)(roll_error * 100));
        
        // 发送状态数据到4G网络
        char status_msg[128];
        sprintf(status_msg, "GPS:%.6f,%.6f|ACC:%.2f,%.2f,%.2f\r\n",
                gps_data.latitude, gps_data.longitude,
                mpu_data.accel_x/16384.0, mpu_data.accel_y/16384.0, mpu_data.accel_z/16384.0);
        USART_SendString(USART3, status_msg);
        
        Delay(100);
    }
}

项目核心代码

#include "stm32f4xx.h"
#include "system_stm32f4xx.h"
#include <stdio.h>
#include <string.h>

// 硬件模块定义
#define GPS_USART USART2
#define DTU_USART USART3
#define MPU6050_I2C I2C1

// 飞行模式定义
typedef enum {
    MANUAL_MODE = 0,
    AUTO_HOVER,
    AUTO_WAYPOINT,
    RETURN_HOME
} FlightMode;

// 数据结构定义
typedef struct {
    float latitude;
    float longitude;
    float altitude;
    float speed;
    uint8_t satellites;
} GPS_Data;

typedef struct {
    float roll;
    float pitch;
    float yaw;
    float accel_x;
    float accel_y;
    float accel_z;
    float gyro_x;
    float gyro_y;
    float gyro_z;
} IMU_Data;

typedef struct {
    float voltage;
    float current;
    uint8_t percentage;
} Battery_Data;

// 全局变量
volatile GPS_Data gps_data = {0};
volatile IMU_Data imu_data = {0};
volatile Battery_Data battery_data = {0};
volatile FlightMode current_mode = AUTO_HOVER;
volatile uint32_t system_tick = 0;
volatile uint8_t dtu_connected = 0;

// 外部函数声明
extern void SystemClock_Config(void);
extern void GPIO_Init(void);
extern void USART_Init(void);
extern void I2C_Init(void);
extern void PWM_Init(void);
extern void TIM_Init(void);
extern void NVIC_Init(void);

extern void GPS_GetData(GPS_Data* data);
extern void MPU6050_GetData(IMU_Data* data);
extern void Battery_GetData(Battery_Data* data);
extern void DTU_SendData(uint8_t* data, uint16_t len);
extern uint8_t DTU_ReceiveData(uint8_t* buffer, uint16_t* len);
extern void FlightController_Update(void);
extern void Motor_SetSpeed(uint8_t motor_id, uint16_t speed);

// 系统滴答定时器中断
void SysTick_Handler(void) {
    system_tick++;
}

// 主定时器中断 - 用于飞控主循环
void TIM2_IRQHandler(void) {
    if(TIM2->SR & TIM_SR_UIF) {
        TIM2->SR &= ~TIM_SR_UIF;
        
        // 读取传感器数据
        GPS_GetData((GPS_Data*)&gps_data);
        MPU6050_GetData((IMU_Data*)&imu_data);
        Battery_GetData((Battery_Data*)&battery_data);
        
        // 运行飞控算法
        FlightController_Update();
    }
}

// DTU数据接收中断
void USART3_IRQHandler(void) {
    if(USART3->SR & USART_SR_RXNE) {
        static uint8_t rx_buffer[256];
        static uint16_t rx_index = 0;
        uint8_t data = USART3->DR;
        
        if(data == '\n') {
            // 解析控制指令
            ParseControlCommand(rx_buffer, rx_index);
            rx_index = 0;
        } else if(rx_index < sizeof(rx_buffer)-1) {
            rx_buffer[rx_index++] = data;
        }
    }
}

// 解析控制指令
void ParseControlCommand(uint8_t* cmd, uint16_t len) {
    if(len < 3) return;
    
    // 简单指令解析示例
    if(strncmp((char*)cmd, "MODE", 4) == 0) {
        uint8_t mode = cmd[5] - '0';
        if(mode <= RETURN_HOME) {
            current_mode = (FlightMode)mode;
        }
    }
    else if(strncmp((char*)cmd, "THR", 3) == 0) {
        // 油门控制指令
    }
    else if(strncmp((char*)cmd, "WP", 2) == 0) {
        // 航点设置指令
    }
}

// 发送遥测数据
void SendTelemetryData(void) {
    static uint32_t last_send_time = 0;
    
    if((system_tick - last_send_time) > 100) { // 100ms发送一次
        char telemetry[256];
        int len = snprintf(telemetry, sizeof(telemetry),
            "GPS:%.6f,%.6f,%.1f|IMU:%.2f,%.2f,%.2f|BAT:%.1f,%d|MODE:%d\n",
            gps_data.latitude, gps_data.longitude, gps_data.altitude,
            imu_data.roll, imu_data.pitch, imu_data.yaw,
            battery_data.voltage, battery_data.percentage,
            current_mode);
        
        if(len > 0) {
            DTU_SendData((uint8_t*)telemetry, len);
        }
        last_send_time = system_tick;
    }
}

// 系统状态监测
void SystemMonitor(void) {
    static uint32_t last_check_time = 0;
    
    if((system_tick - last_check_time) > 1000) { // 1s检查一次
        // 检查电池电量
        if(battery_data.percentage < 20) {
            // 低电量警告，执行返航
            current_mode = RETURN_HOME;
        }
        
        // 检查GPS信号
        if(gps_data.satellites < 6) {
            // GPS信号弱警告
        }
        
        last_check_time = system_tick;
    }
}

// 4G连接状态检查
void CheckDTUConnection(void) {
    static uint32_t last_check_time = 0;
    static uint8_t connection_retry = 0;
    
    if((system_tick - last_check_time) > 5000) { // 5s检查一次
        // 发送心跳包检查连接
        uint8_t heartbeat[] = "HEARTBEAT\n";
        DTU_SendData(heartbeat, sizeof(heartbeat)-1);
        
        if(!dtu_connected && connection_retry < 3) {
            // 尝试重新连接
            connection_retry++;
        }
        
        last_check_time = system_tick;
    }
}

// 系统初始化
void System_Init(void) {
    // 时钟配置
    SystemClock_Config();
    
    // 外设初始化
    GPIO_Init();
    USART_Init();
    I2C_Init();
    PWM_Init();
    TIM_Init();
    NVIC_Init();
    
    // 配置系统滴答定时器
    SysTick_Config(SystemCoreClock / 1000); // 1ms中断
    
    // 传感器初始化
    GPS_Init();
    MPU6050_Init();
    Battery_Init();
    DTU_Init();
    
    // 飞控初始化
    FlightController_Init();
}

int main(void) {
    // 系统初始化
    System_Init();
    
    // 启动主定时器 - 500Hz飞控频率
    TIM2->CR1 |= TIM_CR1_CEN;
    
    while(1) {
        // 发送遥测数据
        SendTelemetryData();
        
        // 系统状态监测
        SystemMonitor();
        
        // 检查4G连接
        CheckDTUConnection();
        
        // 低功耗处理
        __WFI();
    }
}

// 简单的延时函数
void Delay_ms(uint32_t ms) {
    uint32_t start_tick = system_tick;
    while((system_tick - start_tick) < ms);
}

总结

本无人机远程控制系统基于4G网络技术，实现了无人机与远程控制中心之间的长距离、可靠通信。该系统通过高效的网络连接，确保了远程监控和控制的实时性与稳定性，适用于各种复杂环境下的应用场景。

在功能方面，系统支持无人机通过4G网络与远程控制中心建立持久的通信链路，远程控制中心能够实时接收无人机回传的GPS定位信息和飞行状态数据，并可通过4G网络向无人机发送精确的飞行控制指令。此外，无人机还具备基本的自主飞行能力，如定点悬停和预设航线飞行，进一步提升了系统的自动化水平和操作便捷性。

硬件组成上，系统采用STM32F407系列主控芯片，提供高性能计算和DSP指令集支持，确保数据处理的高效性。通信模块选用4G DTU（如SIM7600），保障了网络连接的稳定与高速传输。飞控传感部分包括MPU6050六轴传感器、GPS定位模块和气压计，用于精确感知飞行姿态和位置信息。动力系统由无刷电机、电子调速器和螺旋桨组成，提供可靠的飞行推力，而电源系统则依赖大容量锂聚合物电池，确保系统能够长时间稳定运行。