精华内容
下载资源
问答
  • 2020-03-09 19:05:41

    概述

    PSO(粒子群算法)在处理连续问题上有着较强的能力,因此很适合用来做参数优化,而PID控制器由三个参数组成,它们分别是:
    K p 、 K i 、 K d K_p、K_i、K_d KpKiKd
    我们可以把PID控制器当做一个“黑箱”,输入为这三个参数,输出为响应曲线,我们要做的就是优化这个响应曲线。而一个控制效果好的PID控制器应针对不同类型输入都有较快的响应速度,较小的超调以及稳态误差。因此我们将经典的三种输入信号:阶跃、斜坡、抛物用来衡量PID控制效果。

    适应函数设计

    我们选用综合指标来衡量设计效果,由于是数字控制器,我们选用求和而不是积分的方式:
    W = Σ e 2 ( i ) W=\Sigma e^2(i) W=Σe2(i)
    又因为我们考虑了三种输入,因此:
    Σ W = Σ Σ e 2 ( i ) \Sigma W=\Sigma \Sigma e^2(i) ΣW=ΣΣe2(i)
    下面是编写的适应函数:

    function return_value = PID_find_betterparameters(Kp,Ki,Kd)
        t = 1:50;
        ideal = 5;
        x=[];e=[];
        x(1)=0;
        for i = t                   %阶跃输入
            e(i) = ideal - x(i);
            if(i>1)
                x(i+1) = x(i) + Kp*e(i) + Ki*sum(e) + Kd*(e(i)-e(i-1));
            end
            if i==1
                x(i+1) = x(i) + Kp*e(i) + Ki*sum(e);
            end
        end
        for j = t
            s(j) = (x(j)-ideal)^2;
        end
        return_value1 = sum(s);
    
        for i = t                      %斜坡输入
            e(i) = ideal*i - x(i);
            if(i>1)
                x(i+1) = x(i) + Kp*e(i) + Ki*sum(e) + Kd*(e(i)-e(i-1));
            end
            if i==1
                x(i+1) = x(i) + Kp*e(i) + Ki*sum(e);
            end
        end
        for j = t
            s(j) = (x(j)-ideal*j)^2;
        end
        return_value2 = sum(s);
        
        for i = t                          %抛物输入
            e(i) = ideal*i^2 - x(i);
            if(i>1)
                x(i+1) = x(i) + Kp*e(i) + Ki*sum(e) + Kd*(e(i)-e(i-1));
            end
            if i==1
                x(i+1) = x(i) + Kp*e(i) + Ki*sum(e);
            end
        end
        for j = t
            s(j) = (x(j)-ideal*j^2)^2;
        end
        return_value3 = sum(s);
        
        return_value = (return_value1 + return_value2 + return_value3)/100;
    end
    

    PSO优化

    之前也说到,我们将PID控制器当做一个“黑箱”来处理,它的返回值是 e e e ,输入维数为3,也就是一个三元函数。下面给出粒子群优化代码:

    %---------------粒子群优化寻PID参数----------------%
    close all;clear;clc;
    maxgen = 100;
    sizepop = 60;
    Vmax = 0.5;
    Vmin = -0.5;
    popmax = 2;
    popmin = -2;
    c1 = 0.3;
    c2 = 1.5;
    %------------------初始化种群-----------------------%
    for i = 1:sizepop
        pop(i,:) = -2+4*rand(1,3);
        V(i,:) = rand(1,3);
        fitness(i) = PID_find_betterparameters(pop(i,1),pop(i,2),pop(i,3));
    end
    
    [bestfitness,bestindex] = min(fitness);
    fitnesszbest = bestfitness;
    fitnessgbest = fitness;
    zbest = pop(bestindex,:);     %种群历史最优解
    gbest = pop;                  %个体历史最优解
    
    %---------------寻优--------------------------%
    for i = 1:maxgen
        for j = 1:sizepop
            %-----------速度更新-----------------%
            V(j,:) = V(j,:) + c1*rand*(gbest(j,:) - pop(j,:)) + c2*rand*(zbest - pop(j,:));
            V(j,find(V(j,:)>Vmax)) = Vmax;           %限制搜索速度
            V(j,find(V(j,:)<Vmin)) = Vmin;
            
            %----------种群更新------------------%
            pop(j,:) = pop(j,:) + V(j,:);
            pop(j,find(pop(j,:)>popmax)) = popmax;    %限制搜索范围
            pop(j,find(pop(j,:)<popmin)) = popmin;
            
            %----------更新适应值----------------%
            fitness(j) = PID_find_betterparameters(pop(j,1),pop(j,2),pop(j,3));
        end
        %----------------个体最优更新-------------%
        for j = 1:sizepop
            if (fitness(j)<fitnessgbest(j))
                gbest(j,:) = pop(j,:);
                fitnessgbest(j,:) = fitness(j);
            end
            if (fitness(j)<fitnesszbest)
                zbest = pop(j,:);
                fitnesszbest = fitness(j);
            end
        end
        yy(i) = fitnesszbest;  %每一代的最优适应值
        
        %---------------绘制搜索动态3D---------------%
        if (i>1) 
            delete(G); 
        end
        G = scatter3(pop(:,1),pop(:,2),pop(:,3),40,'r.');
        xlim([-2,2]);
        ylim([-2,2]);
        zlim([-2,2]);
        drawnow
        hold on
        pause(0.05);
    end
    

    输出最优参数和对应适值:

    zbest                          %最优参数
    fitnesszbest                   %最优参数对应的适值
    

    绘制响应动态图(以斜坡为例):

    %------------------绘制响应-----------------------------%
    t = 1:100;
    ideal = 5;
    x=[];e=[];
    x(1)=0;
    Kp = zbest(1); Ki = zbest(2); Kd = zbest(3);
    for i = t
        e(i) = ideal*i - x(i);
        if(i>1)
            x(i+1) = x(i) + Kp*e(i) + Ki*sum(e) + Kd*(e(i)-e(i-1));
        end
        if i==1
            x(i+1) = x(i) + Kp*e(i) + Ki*sum(e);
        end
    end
    figure(2);
    plot(1:101,x,'r');
    xlim([0,20]);
    hold on;
    plot(1:101,5*[1:101],'b');
    xlim([0,20]);
    

    在这里插入图片描述
    在这里插入图片描述

    总结

    我们利用PSO处理连续问题的优势对工程上常用的PID控制进行优化,虽然现在大部分的PID参数调节都是依靠经验,但是在不久的将来,智能算法的进步一定会促使控制算法参数调节更为便捷。

    更多相关内容
  • 粒子群算法优化PID参数实例

    千次阅读 2021-08-13 21:03:31
    粒子群算法是一种智能优化算法。关于智能,个人理解,不过是在枚举法的基础上加上了一定的寻优机制。试想一下枚举法,假设问题的解空间很小,比如一个函数 y = x^2 ,解空间在[-1,1],现在求这个函数的最小值,我们...

    粒子群优化算法(PSO)以及Matlab实现
    1、粒子群算法

    粒子群算法是一种智能优化算法。关于智能,个人理解,不过是在枚举法的基础上加上了一定的寻优机制。试想一下枚举法,假设问题的解空间很小,比如一个函数 y = x^2 ,解空间在[-1,1],现在求这个函数的最小值,我们完全可以使用枚举法,比如在这里,在解空间[-1,1]上,取1000等分,也就是步长为0.002,生成1000个x值,然后代入函数中,找到这1000个最小的y就可以了。然而实际情况不是这样的,比如为什么选1000等分,不是1w,10w等分,很显然等分的越大,计算量也就越大,带来的解当然也就越精确,那么实际问题中如何去平衡这两点呢?也就是既要计算量小(速度快),也要准确(精度高),这就是智能算法的来源了,一般的智能算法基本上都是这样的,在很大的搜索空间上,即保证了速度快,也能比较好的找到最优解。

    再来看看粒子群算法(也称PSO算法),也是一种进化算法,模拟生物群体的觅食行为,是一种群体智能算法,类似的算法想遗传算法,模拟退火算法等等。PSO是通过当前已知种群寻找到的所有解来决定新的解的寻找方向,也就是新解的生成方式依赖于这些种群历史上寻找的所有解。

    形象的理解比如下图: 

    å¾ç

     

    开始随机生成一堆种群,那么这些种群之间的每个个体可以相互交流,比如下一时刻,A告诉B说我的解比你好,那么B就往A那个地方飞,也就是B的解朝着A的解方向变化,当然所有粒子间都这样操作,想想一旦粒子群中间有一个粒子找到了一个最优解,是不是所有的粒子会一窝蜂朝着这个方向而去了,而在这个去的过程中,万一某个粒子找到了一个更好的解,那它还会走吗?不会了,它就告诉剩下的所有粒子说我的解更好呀,大家快来呀(很无私的),然后所有粒子又一窝蜂的照着这个粒子方向前进,当然在这个前进的过程中可能又会产生新的解,就这样一步步的迭代,最终慢慢的趋近于一个最优解,这个解是不是全局最优解,不知道,可能是,也可能不是,取决于原始问题的复杂程度,也取决于粒子前进的多少等等。

    粒子群算法相对于其他算法来说还是有很多优点的,典型的就是计算速度很快,在每次迭代时,所有粒子同时迭代,是一种并行计算方式,而且粒子的更新方式简单,朝着一个优秀解方向更新。这个优秀解包括两个部分: 
    1)一个是朝着自己在迭代的历史上找到的个体最优解gbest前进 
    2)一个是朝着群体在得带历史上找到的全体最优解zbest前进 
    现在还有一个问题就是每次迭代的时候更新多少呢?也就是自变量的增加步长了,我们用一个速度量V来表示,也就是每个粒子的更新速度了,公式化的表示就是这样的: 

    Vid(t+1)=Vidt+c1∗rand∗(Pid−xid(t))+c2∗rand∗(Pgd−xid(t))Vid(t+1)=Vidt+c1∗rand∗(Pid−xid(t))+c2∗rand∗(Pgd−xid(t))


    其中自变量的更新为: xi(t+1)=xi(t)+Vi(t)xi(t+1)=xi(t)+Vi(t) 
    从上面的速度V的更新而已看到,c1那项就是朝着自己的最优解前进,c2那一项就是朝着全局最优解那前进。用简单的图表示如下: 

    2、粒子群的算法步骤

    粒子群的核心部分就是上面说到的那两个公式,一个是速度的更新方式,另一个是位置的更新方式,重点还是速度的更新方式; 
    总结来说,粒子群的算法步骤如下:

    初始化粒子群个体;

    计算每个个体的适应度值(函数值)作为评判好坏的标准;

    找到每个个体自己在所有迭代过程中的最优解Pbest;

    找到所有个体在所有迭代过程中的最优解Zbest;

    根据速度公式更新速度;

    根据位置公式更新位置;

    重复步骤二直至迭代次数结束

    这里有几个参数需要说一下,

    关于速度V,限制速度的范围,比如需要设置一个最大速度,防止更新过快;

    关于c1与c2,这两个参数代表学习因子,决定跟随历史优秀解的能力;

    关于粒子数与迭代次数,粒子数一般50-100,迭代次数视问题而定了;

    3、粒子群算法优化PID参数实例

     关键是定义好对应的指标,m文件赋值给simulink,simulink运行得到适应度z

     

     

    展开全文
  • 在本文中,我们通过将PID的动态响应信息整合到优化器中,开发了一种基于知识的粒子群优化算法。 先验知识不仅使粒子群优化算法能够快速识别出有希望的区域,而且还有助于所提出的算法在有限的运行时间内提高求解...
  • 粒子群算法优化PID参数的研究 关键词(Tag):粒子群 优化 PID
  • 本代码主要利用MATLAB工具进行MATLAB——基于粒子群算法PID控制器优化设计的仿真
  • 基于粒子群算法PID参数寻优(MATLA程序).zip
  • 针对PID控制器参数整定问题,提出一种基于改进粒子群优化算法优化方法。该方法在实数编码及设定参数搜索空间的基础上,采用基于指数曲线的非线性惯性权值递减策略,以较大幅度地提高算法的收敛速度和精度;嵌入基于差...
  • 摘要:PID控制是过程控制中应用最广泛的控制方法,其关键在于PID参数优化。针对其参数整定和优化问题,提出了一种改进的粒子群优化算法。仿真结果证明了该算法的有效性,其性能优于遗传算法和基本微粒群算法,具有...
  • 通过粒子群算法优化PID参数, 通过粒子群算法优化PID参数
  • 基于粒子群算法PID参数寻优(MATLA程序),利用混合粒子去算法寻优参数。
  • 粒子群算法优化pid参数时,需要每个粒子(即一组pid参数)进控制器,得到反馈误差 ,进而计算适应度,那么问题来了,在每一代中的所有粒子,都需要经过控制器的运算,才能得到适应度,这样在工程中,远远不能满足...
  • -注释详细 -利用PSO算法对Kp、Ki和Kd三个系数的寻优 -选择ITAE指标作为适应度函数
  • 基于粒子群算法和遗传算法的PID参数优化程序,matlab源代码。内含matlab源代码源代码说参考论文。
  • 基于粒子群算法PID控制器优化 matlab
  • 粒子群算法优化PID控制参数研究.pdf
  • 基于粒子群算法PID参数优化.pdf
  • 基于改进粒子群算法PID参数优化.pdf
  • 基于粒子群算法PID参数优化与仿真.pdf
  • 基于自然选择粒子群算法PID参数优化.pdf
  • 基于改进粒子群算法PID参数优化研究.pdf
  • 用的是《MATLAB智能算法30个案例分析》中的程序1.文件名为PSO_PID.mfunction z = PSO_PID(x)assignin('base','Kp',x(1)); % 粒子群依次赋值给Kp 这部分运行结果> PSO_PIDassignin('base'...

    用的是《MATLAB智能算法30个案例分析》中的程序

    1.文件名为PSO_PID.m

    function z = PSO_PID(x)

    assignin('base','Kp',x(1));                   % 粒子群依次赋值给Kp                                            这部分运行结果> PSO_PID

    assignin('base','Ki',x(2));                     % 粒子群依次赋值给Ki                                                                     Error using PSO_PID (line 2)

    assignin('base','Kd',x(3));                   % 粒子群依次赋值给Kd                                                                      Not enough input arguments.

    [ y_out] = sim('PID_Model', [0, 20]); % 使用命令行运行控制系统模块

    z = y_out(end, 1);                            % 返回性能指标

    2.文件名为Optm1_PSO_PID.m

    %% 清空环境clearclc

    %% 参数设置w = 0.6;      % 惯性因子c1 = 2;       % 加速常数c2 = 2;       % 加速常数

    Dim = 3;            % 维数SwarmSize = 100;    % 粒子群规模ObjFun = @PSO_PID;  % 待优化函数句柄

    MaxIter = 100;      % 最大迭代次数  MinFit = 0.1;       % 最小适应值

    Vmax = 1;Vmin = -1;Ub = [300 300 300];Lb = [0 0 0];

    %% 粒子群初始化    Range = ones(SwarmSize,1)*(Ub-Lb);    Swarm = rand(SwarmSize,Dim).*Range + ones(SwarmSize,1)*Lb ;     % 初始化粒子群    VStep = rand(SwarmSize,Dim)*(Vmax-Vmin) + Vmin ;                % 初始化速度    fSwarm = zeros(SwarmSize,1);for i=1:SwarmSize    fSwarm(i,:) = feval(ObjFun,Swarm(i,:));                         % 粒子群的适应值end

    %% 个体极值和群体极值[bestf bestindex]=min(fSwarm);zbest=Swarm(bestindex,:);   % 全局最佳gbest=Swarm;                % 个体最佳fgbest=fSwarm;              % 个体最佳适应值fzbest=bestf;               % 全局最佳适应值

    %% 迭代寻优iter = 0;y_fitness = zeros(1,MaxIter);   % 预先产生4个空矩阵K_p = zeros(1,MaxIter);         K_i = zeros(1,MaxIter);K_d = zeros(1,MaxIter);while( (iter < MaxIter) && (fzbest > MinFit) )    for j=1:SwarmSize        % 速度更新        VStep(j,:) = w*VStep(j,:) + c1*rand*(gbest(j,:) - Swarm(j,:)) + c2*rand*(zbest - Swarm(j,:));        if VStep(j,:)>Vmax, VStep(j,:)=Vmax; end        if VStep(j,:)Ub(k), Swarm(j,k)=Ub(k); end            if Swarm(j,k)

    figure(2)      % 绘制PID控制器参数变化曲线plot(K_p)hold onplot(K_i,'k','LineWidth',3)plot(K_d,'--r')title('Kp、Ki、Kd 优化曲线','fontsize',18);xlabel('迭代次数','fontsize',18);ylabel('参数值','fontsize',18);set(gca,'Fontsize',18);legend('Kp','Ki','Kd',1);

    2014-4-12 22:10 上传

    b4d287d1aacbf0cf95a77c41289acfe6.gif

    c5006d1a5b4047f80d42a7082635a87b.gif

    仿真模型 文件名为PID_Model

    74cebf67aefae40a311644b1fe380f73.png

    展开全文
  • 基于粒子群算法PID参数自整定,栾丽君,谭立静,PID控制器的参数整定,从优化的角度来说就是在Kp, Ki ,Kd 3个参数空间中寻找最优值,使系统的控制性能达到最优。粒子群优化(PSO)算法是一
  • 基于改进粒子群算法PID参数优化方法研究.pdf
  • 基于改进粒子群算法PID参数优化与仿真.pdf
  • 改进粒子群算法PID参数优化中的应用.pdf
  • 基于粒子群算法PID控制器优化设计

    千次阅读 热门讨论 2022-01-06 16:03:40
    粒子群算法PID、寻优

    这篇文章主要讲解的是使用粒子群算法对PID参数进行寻优,大家可以进行参考。

    1. 理论基础

    PID控制器的一般形式为
    u ( t ) = K p e ( t ) + K i ∫ 0 t e ( τ ) d τ + K d d e ( t ) d t u(t) = {K_p}e(t) + {K_i}\int_0^t {e(\tau )} d\tau + {K_d}\frac{{de(t)}}{{dt}} u(t)=Kpe(t)+Ki0te(τ)dτ+Kddtde(t)
    其中, e ( t ) e(t) e(t)是系统误差; K p K_p Kp K i K_i Ki K d K_d Kd分别是对系统误差信号及其积分与微分量的加权,控制器通过这样的加权就可以计算出控制信号,驱动受控对象。
    因此,PID控制器的三个参数的选择相当重要,优化这三个参数相当重要。传统参数的选取都是靠人工经验进行选取,此文章将使用PSO对PID控制器中的这三个参数进行优化。

    2. 问题描述

    PID控制器的系统结构图如下
    在这里插入图片描述
    PID控制器的优化问题就是确定一组合适的参数 K p K_p Kp K i K_i Ki K d K_d Kd,使得指标达到最优。这里选用ITAE指标,其定义为
    J = ∫ 0 ∞ t ∣ e ( t ) ∣ d t J = \int_0^\infty {t\left| {e(t)} \right|dt} J=0te(t)dt
    选取的被控对象为为下面的不稳定系统:
    G ( s ) = s + 2 s 4 + 8 s 3 + 4 s 2 − s + 0.4 G(s) = \frac{{s + 2}}{{{s^4} + 8{s^3} + 4{s^2} - s + 0.4}} G(s)=s4+8s3+4s2s+0.4s+2
    在Simulink环境下搭建上述的模型如下图所示:
    在这里插入图片描述

    3. 思路及步骤

    3.1 优化设计过程

    李用粒子群算法对PID控制器的参数进行优化设计,过程图如下所示:
    在这里插入图片描述
    上图中,粒子群算法与Simulink模型之间连接的桥梁是粒子(即PID控制器参数)和该粒子对应的适应值(即控制系统的性能指标)。优化过程如下:PSO产生粒子群(可以是初始化的粒子群,也可以是更新后的粒子群),将该粒子群中的粒子依次赋值给PID控制器的参数 K p K_p Kp K i K_i Ki K d K_d Kd,然后运行控制器系统的Simulink模型,得到该参数对应的性能指标,该性能指标传递到PSO中作为该粒子的适应值,最后判断是否可以退出算法。

    3.2 粒子群算法实现

    粒子群算法中速度和位置是根据下面两个公式进行更新
    v t + 1 = ω v t + c 1 r 1 ( P t − x t ) + c 2 r 2 ( G t − x t ) {v_{t + 1}} = \omega {v_t} + {c_1}{r_1}({P_t} - {x_t}) + {c_2}{r_2}({G_t} - {x_t}) vt+1=ωvt+c1r1(Ptxt)+c2r2(Gtxt)
    x t + 1 = x t + v t + 1 x_{t+1}=x_t+v_{t+1} xt+1=xt+vt+1
    其中, x x x表示粒子的位置; v v v表示粒子的速度; ω \omega ω为惯性因子; c 1 c_1 c1 c 2 c_2 c2为加速度常数; r 1 r_1 r1 r 2 r_2 r2 [ 0 , 1 ] [0,1] [0,1]区间的随机数; P t P_t Pt是粒子迄今为止搜索到的最优为止; G t G_t Gt是整个粒子群迄今为止搜索到的最优为止。
    PSO的流程如下:

    1. 初始化粒子群,随机产生所有粒子的位置和速度,并确定粒子的 P t P_t Pt G t G_t Gt
    2. 对每个粒子,将其适应值与该粒子所经历过的最优位置 P t P_t Pt的适应值进行比较,若较好,则将其作为当前的 P t P_t Pt
    3. 对每个粒子,将其适应值与整个粒子群所经历过的最优位置 G t G_t Gt的适应值进行比较,若较好,则将其作为当前的 G t G_t Gt
    4. 按照上面的公式进行速度和位置的更新。
    5. 如果没有满足终止条件(通常为预设的最大迭代次数和适应值下限值),则返回步骤(2);否则,推出算法,得到最优解。

    4. MATLAB程序

    下面是Simulink图

    在这里插入图片描述
    其中函数部分的程序如下:

    function z=PSO_PID(x)
    assignin('base','Kp',x(1));    %粒子依次赋值给Kp
    assignin('base','Ki',x(2));    %粒子依次赋值给Ki
    assignin('base','Kd',x(3));    %粒子依次赋值给Kd
    [t_time,x_state,y_out]=sim('PID_Model',[0,20]);    %使用命令行运行控制系统模型
    z=y_out(end,1);    %返回性能指标
    

    主程序如下:

    %% 清空环境
    clear
    clc
    
    %% 参数设置
    w = 0.6;      % 惯性因子 
    c1 = 2;       % 加速常数
    c2 = 2;       % 加速常数
    
    Dim = 3;            % 维数
    SwarmSize = 100;    % 粒子群规模
    ObjFun = @PSO_PID;  % 待优化函数句柄
    
    MaxIter = 100;      % 最大迭代次数  
    MinFit = 0.1;       % 最小适应值 
    
    Vmax = 1;
    Vmin = -1;
    Ub = [300 300 300];
    Lb = [0 0 0];
    
    %% 粒子群初始化
        Range = ones(SwarmSize,1)*(Ub-Lb);
        Swarm = rand(SwarmSize,Dim).*Range + ones(SwarmSize,1)*Lb      % 初始化粒子群
        VStep = rand(SwarmSize,Dim)*(Vmax-Vmin) + Vmin                 % 初始化速度
        fSwarm = zeros(SwarmSize,1);
    for i=1:SwarmSize
        fSwarm(i,:) = feval(ObjFun,Swarm(i,:));                         % 粒子群的适应值
    end
    
    %% 个体极值和群体极值
    [bestf bestindex]=min(fSwarm);
    zbest=Swarm(bestindex,:);   % 全局最佳
    gbest=Swarm;                % 个体最佳
    fgbest=fSwarm;              % 个体最佳适应值
    fzbest=bestf;               % 全局最佳适应值
    
    %% 迭代寻优
    iter = 0;
    y_fitness = zeros(1,MaxIter);   % 预先产生4个空矩阵
    K_p = zeros(1,MaxIter);         
    K_i = zeros(1,MaxIter);
    K_d = zeros(1,MaxIter);
    while( (iter < MaxIter) && (fzbest > MinFit) )
        for j=1:SwarmSize
            % 速度更新
            VStep(j,:) = w*VStep(j,:) + c1*rand*(gbest(j,:) - Swarm(j,:)) + c2*rand*(zbest - Swarm(j,:));
            if VStep(j,:)>Vmax, VStep(j,:)=Vmax; end
            if VStep(j,:)<Vmin, VStep(j,:)=Vmin; end
            % 位置更新
            Swarm(j,:)=Swarm(j,:)+VStep(j,:);
            for k=1:Dim
                if Swarm(j,k)>Ub(k), Swarm(j,k)=Ub(k); end
                if Swarm(j,k)<Lb(k), Swarm(j,k)=Lb(k); end
            end
            % 适应值
            fSwarm(j,:) = feval(ObjFun,Swarm(j,:));
            % 个体最优更新     
            if fSwarm(j) < fgbest(j)
                gbest(j,:) = Swarm(j,:);
                fgbest(j) = fSwarm(j);
            end
            % 群体最优更新
            if fSwarm(j) < fzbest
                zbest = Swarm(j,:);
                fzbest = fSwarm(j);
            end
        end 
        iter = iter+1;                      % 迭代次数更新
        y_fitness(1,iter) = fzbest;         % 为绘图做准备
        K_p(1,iter) = zbest(1);
        K_i(1,iter) = zbest(2);
        K_d(1,iter) = zbest(3);
    end
    %% 绘图输出
    figure(1)      % 绘制性能指标ITAE的变化曲线
    plot(y_fitness,'LineWidth',2)
    title('最优个体适应值','fontsize',18);
    xlabel('迭代次数','fontsize',18);ylabel('适应值','fontsize',18);
    set(gca,'Fontsize',18);
    
    figure(2)      % 绘制PID控制器参数变化曲线
    plot(K_p)
    hold on
    plot(K_i,'k','LineWidth',3)
    plot(K_d,'--r')
    title('Kp、Ki、Kd 优化曲线','fontsize',18);
    xlabel('迭代次数','fontsize',18);ylabel('参数值','fontsize',18);
    set(gca,'Fontsize',18);
    legend('Kp','Ki','Kd',1);
    
    

    5.仿真结果

    经过优化后的PID控制器的最优参数以及性能指标为
    K p = 33.6326 , K i = 0.1662 K_p= 33.6326, K_i=0.1662 Kp=33.6326,Ki=0.1662
    K d = 38.7892 , I T A E = 1.0580 K_d= 38.7892 , ITAE= 1.0580 Kd=38.7892,ITAE=1.0580

    性能指标曲线图:
    在这里插入图片描述

    单位阶跃响应曲线:
    在这里插入图片描述
    K p K_p Kp K i K_i Ki K d K_d Kd优化曲线:

    在这里插入图片描述

    大家如果有使用PSO算法对LQR中的Q参数进行优化的程序可以进行交流一下,谢谢!

    展开全文
  • 针对开关磁阻调速电动机(SRD)非线性、数学模型难以精确建立的特点,采用粒子群算法对开关磁阻电动机PID控制器参数进行优化,基于MATLAB Simulink建立SRD仿真模型,仿真验证粒子群优化算法的有效性。 2 部分代码 ...
  • 新的粒子群算法PID参数优化中的应用.pdf

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 459
精华内容 183
关键字:

粒子群算法优化pid参数