✅ 博主简介：擅长数据搜集与处理、建模仿真、程序设计、仿真代码、论文写作与指导，毕业论文、期刊论文经验交流。

 ✅ 具体问题可以私信或扫描文章底部二维码。

（1）无人机集群系统建模与协同机制设计

无人机集群系统作为一种分布式自主协同系统，其路径规划需要同时考虑个体最优和集群整体最优。本研究首先建立了多无人机系统的数学模型，包括单机运动学模型和集群动力学模型。单机模型考虑了无人机的最大飞行速度、爬升率、转弯半径、续航时间等物理约束，特别是对于旋翼无人机和固定翼无人机的不同飞行特性进行了区分建模。在三维空间离散化方面，采用了八叉树结构对飞行空间进行分层表示，在障碍物密集区域使用细粒度划分，在空旷区域使用粗粒度划分以减少计算负担。威胁环境建模包括静态威胁如建筑物、山体、禁飞区，以及动态威胁如敌方雷达探测区、防空火力覆盖区，每个威胁区域设置不同的威胁等级和时变特性。

集群协同机制的设计是本研究的核心创新点。建立了基于虚拟领航者的编队保持模型，通过设定虚拟领航点和期望编队构型，各无人机在完成各自任务的同时保持相对队形。引入了通信拓扑网络模型，考虑到实际通信距离限制和信息传输延迟，设计了分层通信架构，将集群划分为若干子群，子群内部采用全连接通信保证信息实时共享，子群之间通过领队无人机进行信息中继。针对任务分配问题，提出了基于市场机制的分布式任务分配算法，各无人机根据自身状态对任务进行竞标，通过多轮协商达成任务分配共识。在冲突消解方面，设计了基于优先级和几何避让相结合的策略，当检测到潜在碰撞时，优先级低的无人机主动调整航迹，同时采用速度协调机制确保编队不会因避让而过度分散。建立了能量管理模型，实时监测各无人机的剩余电量，当某架无人机电量不足时触发任务重分配和返航规划，确保集群任务的连续性。

（2）粒子群算法的多目标协同优化改进

传统粒子群算法在处理高维多约束的集群路径规划问题时存在早熟收敛和全局搜索能力不足的问题。本研究提出了一套系统性的改进策略。首先在粒子编码方面，采用了混合编码方式，每个粒子代表整个集群的一组路径解，粒子的维度等于无人机数量乘以路径关键节点数量，通过这种编码方式能够同时优化多架无人机的路径。在参数自适应调整方面，设计了非线性时变的惯性权重，初期采用较大惯性权重增强全局探索能力，后期减小惯性权重强化局部搜索精度。学习因子也采用动态调整策略，个体学习因子随迭代逐渐减小而社会学习因子逐渐增大，这种变化模式促使算法从初期的多样性探索逐步转向后期的协同收敛。

针对多目标优化问题，本研究构建了综合评价函数，包括路径总长度、飞行时间、能耗、威胁暴露度、编队保持度、任务完成度等多个指标。采用加权求和法和帕累托支配关系相结合的方式处理多目标冲突，权重系数根据任务类型和优先级动态调整。引入了混沌搜索机制，当算法陷入局部最优时，利用混沌序列的遍历性和随机性对部分粒子进行扰动，帮助种群跳出局部最优区域。设计了精英保留与变异相结合的策略，每代迭代保留若干最优粒子直接进入下一代，同时对部分粒子进行变异操作以维持种群多样性。在约束处理方面，采用了惩罚函数法和修复机制相结合的方法，对于违反约束的解施加惩罚降低其适应度，同时尝试通过局部调整将不可行解修复为可行解。

引入了协同进化机制，将整个粒子群分为多个子群，每个子群负责优化一部分无人机的路径，子群之间定期交换信息并进行合作评估。这种分治策略既降低了单次优化的维度，又保持了整体协同性。设计了基于梯度信息的混合优化策略，在粒子群迭代的基础上，对当前最优解周围进行局部梯度搜索，结合全局随机搜索和局部确定性搜索的优势。在收敛准则方面，不仅考虑目标函数值的变化，还监测种群多样性指标，当多样性过低时主动引入扰动防止过早收敛。针对大规模集群问题，实现了并行计算架构，将适应度评估和位置更新分配到多个计算节点并行执行，显著提升了算法的计算效率。

（3）动态环境下的实时重规划与容错机制

考虑到实际飞行环境的动态性和不确定性，本研究设计了完善的在线重规划和容错机制。建立了基于滚动时域的动态规划框架，将整个飞行过程划分为多个时间窗口，在每个窗口内进行局部优化，当无人机飞行到窗口末端时，基于最新环境信息规划下一个时间窗口的路径。这种滚动优化策略既保证了规划的实时性，又能够及时响应环境变化。在威胁规避方面，设计了分级响应机制，对于低威胁区域采用路径微调策略，对于高威胁区域则触发完全重规划。当检测到突发威胁如导弹来袭时，启动紧急规避模式，采用简化的快速算法在极短时间内生成临时规避路径。

针对通信中断问题，设计了基于预测的自主决策机制。每架无人机存储其他成员的历史轨迹和行为模式，当通信中断时根据预测模型估计其他无人机的位置和意图，自主进行冲突避免决策。建立了多模式切换机制，根据任务阶段和环境条件在集中式规划、分布式协商、完全自主等多种模式间切换。在集中式模式下，由地面控制站或领队无人机统一规划所有路径；在分布式模式下，各无人机平等协商生成协同路径；在完全自主模式下，各无人机独立决策仅考虑避碰约束。

设计了故障处理和任务重分配机制。当某架无人机发生故障无法继续执行任务时，系统自动将其任务分配给其他健康无人机，并重新规划集群路径。建立了任务优先级队列，在资源不足时优先保证高优先级任务完成。在路径执行过程中，实时监测各无人机的路径跟踪误差，当误差超过阈值时触发局部路径修正，采用模型预测控制方法生成修正指令。针对编队变换需求，设计了平滑过渡算法，在保持安全间距的前提下逐步调整编队构型，避免突变导致的碰撞风险。建立了学习机制，将历史飞行数据和规划结果存储到经验库，利用案例推理方法加速后续类似场景的路径规划，通过强化学习不断优化决策策略。

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

class UAVSwarmPSO:
    def __init__(self, n_uavs, start_positions, goal_positions, obstacles, space_bounds):
        self.n_uavs = n_uavs
        self.start_positions = np.array(start_positions)
        self.goal_positions = np.array(goal_positions)
        self.obstacles = obstacles
        self.space_bounds = space_bounds
        self.n_particles = 40
        self.n_iterations = 150
        self.n_waypoints = 8
        self.dim = n_uavs * n_waypoints * 3
        self.w_max = 0.9
        self.w_min = 0.4
        self.c1_initial = 2.5
        self.c1_final = 0.5
        self.c2_initial = 0.5
        self.c2_final = 2.5
        self.max_velocity = 2.0
        self.min_distance = 5.0
        self.particles = None
        self.velocities = None
        self.pbest = None
        self.pbest_fitness = None
        self.gbest = None
        self.gbest_fitness = float('inf')
        
    def initialize_particles(self):
        self.particles = np.zeros((self.n_particles, self.dim))
        self.velocities = np.zeros((self.n_particles, self.dim))
        
        for i in range(self.n_particles):
            for uav in range(self.n_uavs):
                for wp in range(self.n_waypoints):
                    idx = (uav * self.n_waypoints + wp) * 3
                    t = (wp + 1) / (self.n_waypoints + 1)
                    base_pos = self.start_positions[uav] * (1 - t) + self.goal_positions[uav] * t
                    noise = np.random.uniform(-3, 3, 3)
                    self.particles[i, idx:idx+3] = np.clip(base_pos + noise, 
                                                           [self.space_bounds[0][0], self.space_bounds[1][0], self.space_bounds[2][0]],
                                                           [self.space_bounds[0][1], self.space_bounds[1][1], self.space_bounds[2][1]])
            
            self.velocities[i] = np.random.uniform(-self.max_velocity, self.max_velocity, self.dim)
        
        self.pbest = self.particles.copy()
        self.pbest_fitness = np.array([self.fitness(p) for p in self.particles])
        self.gbest = self.particles[np.argmin(self.pbest_fitness)].copy()
        self.gbest_fitness = np.min(self.pbest_fitness)
    
    def fitness(self, particle):
        paths = self.decode_particle(particle)
        total_cost = 0
        
        for uav in range(self.n_uavs):
            path = paths[uav]
            path_length = 0
            for i in range(len(path) - 1):
                path_length += np.linalg.norm(path[i+1] - path[i])
            total_cost += path_length * 0.4
            
            threat_cost = 0
            for pos in path:
                for obs in self.obstacles:
                    dist = np.linalg.norm(pos - obs[:3])
                    if dist < obs[3]:
                        threat_cost += (obs[3] - dist) ** 2 * 10
                    elif dist < obs[3] * 1.5:
                        threat_cost += (obs[3] * 1.5 - dist) * 2
            total_cost += threat_cost
            
            smoothness_cost = 0
            for i in range(1, len(path) - 1):
                vec1 = path[i] - path[i-1]
                vec2 = path[i+1] - path[i]
                vec1_norm = np.linalg.norm(vec1)
                vec2_norm = np.linalg.norm(vec2)
                if vec1_norm > 0 and vec2_norm > 0:
                    cos_angle = np.dot(vec1, vec2) / (vec1_norm * vec2_norm)
                    smoothness_cost += (1 - cos_angle) * 0.5
            total_cost += smoothness_cost
        
        collision_penalty = 0
        for uav1 in range(self.n_uavs):
            for uav2 in range(uav1 + 1, self.n_uavs):
                path1 = paths[uav1]
                path2 = paths[uav2]
                for i in range(min(len(path1), len(path2))):
                    dist = np.linalg.norm(path1[i] - path2[i])
                    if dist < self.min_distance:
                        collision_penalty += (self.min_distance - dist) ** 2 * 20
        total_cost += collision_penalty
        
        formation_cost = 0
        for i in range(self.n_waypoints):
            centroid = np.mean([paths[uav][i+1] for uav in range(self.n_uavs)], axis=0)
            for uav in range(self.n_uavs):
                deviation = np.linalg.norm(paths[uav][i+1] - centroid)
                formation_cost += deviation * 0.1
        total_cost += formation_cost
        
        return total_cost
    
    def decode_particle(self, particle):
        paths = []
        for uav in range(self.n_uavs):
            path = [self.start_positions[uav]]
            for wp in range(self.n_waypoints):
                idx = (uav * self.n_waypoints + wp) * 3
                waypoint = particle[idx:idx+3]
                path.append(waypoint)
            path.append(self.goal_positions[uav])
            paths.append(np.array(path))
        return paths
    
    def optimize(self):
        self.initialize_particles()
        
        for iteration in range(self.n_iterations):
            w = self.w_max - (self.w_max - self.w_min) * (iteration / self.n_iterations)
            c1 = self.c1_initial - (self.c1_initial - self.c1_final) * (iteration / self.n_iterations)
            c2 = self.c2_initial + (self.c2_final - self.c2_initial) * (iteration / self.n_iterations)
            
            for i in range(self.n_particles):
                r1 = np.random.random(self.dim)
                r2 = np.random.random(self.dim)
                
                self.velocities[i] = (w * self.velocities[i] + 
                                     c1 * r1 * (self.pbest[i] - self.particles[i]) +
                                     c2 * r2 * (self.gbest - self.particles[i]))
                
                self.velocities[i] = np.clip(self.velocities[i], -self.max_velocity, self.max_velocity)
                
                self.particles[i] += self.velocities[i]
                
                for uav in range(self.n_uavs):
                    for wp in range(self.n_waypoints):
                        idx = (uav * self.n_waypoints + wp) * 3
                        self.particles[i, idx] = np.clip(self.particles[i, idx], 
                                                        self.space_bounds[0][0], self.space_bounds[0][1])
                        self.particles[i, idx+1] = np.clip(self.particles[i, idx+1], 
                                                          self.space_bounds[1][0], self.space_bounds[1][1])
                        self.particles[i, idx+2] = np.clip(self.particles[i, idx+2], 
                                                          self.space_bounds[2][0], self.space_bounds[2][1])
                
                fitness = self.fitness(self.particles[i])
                
                if fitness < self.pbest_fitness[i]:
                    self.pbest[i] = self.particles[i].copy()
                    self.pbest_fitness[i] = fitness
                    
                    if fitness < self.gbest_fitness:
                        self.gbest = self.particles[i].copy()
                        self.gbest_fitness = fitness
            
            if iteration % 20 == 0 and iteration > 0:
                diversity = np.mean(np.std(self.particles, axis=0))
                if diversity < 0.5:
                    n_mutate = int(self.n_particles * 0.3)
                    for i in range(n_mutate):
                        idx = np.random.randint(self.n_particles)
                        self.particles[idx] += np.random.uniform(-2, 2, self.dim)
        
        return self.decode_particle(self.gbest), self.gbest_fitness

n_uavs = 5
start_positions = np.array([[0, 0, 10], [0, 5, 10], [0, 10, 10], [5, 0, 10], [5, 5, 10]])
goal_positions = np.array([[100, 100, 20], [100, 95, 20], [100, 90, 20], [95, 100, 20], [95, 95, 20]])
obstacles = np.array([[50, 50, 15, 15], [30, 70, 12, 12], [70, 30, 10, 10], [60, 60, 8, 8]])
space_bounds = [[0, 100], [0, 100], [5, 30]]

pso = UAVSwarmPSO(n_uavs, start_positions, goal_positions, obstacles, space_bounds)
best_paths, best_fitness = pso.optimize()

print(f"Best fitness: {best_fitness:.2f}")
for i, path in enumerate(best_paths):
    print(f"UAV {i} path length: {np.sum([np.linalg.norm(path[j+1]-path[j]) for j in range(len(path)-1)]):.2f}")

如有问题，可以直接沟通

👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇