ADRC自抗扰控制自学笔记（包含simulink仿真）（转载）

最新推荐文章于 2024-05-16 19:21:42 发布
最新推荐文章于 2024-05-16 19:21:42 发布
阅读量900 收藏 24
点赞数 10
分类专栏： 电机控制 文章标签： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42007446/article/details/135018203
版权

他这里让我很好理解了跟踪微分器

非线性PID(准确说是非线性PD，所以可以看到输入是两根线而不是三根线）  也就是说传统PID是线性的？但是不是那些系统是非线性的，比如无人机，平衡车，只是小幅度里近似为线性的。

下面这个来自于：自抗扰控制理论（一）ADRC的原理 - 知乎

他这里确实让我对ADRC的理解更进了一个层面。现在对ADRC有了比较清晰的认识，并不神秘并不高深，其实还好。还是很好理解的。

下面这个来自这篇自抗扰控制理论（一）ADRC的原理 - 知乎

扩张状态观测器（ESO）

（1）功能
估计系统内外扰动的实时作用值，并在反馈中给予补偿，用补偿的方法消除扰动的影响，从而具有抗干扰的作用。

所以它的输入是从被控对象的前后两个输入，这样也好理解。

摘自：https://blog.csdn.net/zouxu634866/article/details/106287879#comments_12978720

ADRC自抗扰控制自学笔记（包含simulink仿真）

总被蚊子叮的小旭 2020-05-22 17:59:36 1856 收藏 28

分类专栏： 控制

版权

ADRC控制中包含三个主要的部分：

跟踪微分器，非线性状态反馈（非线性组合），扩张观测器。

在这里插入图片描述
ADRC特点：

继承了经典PID控制器的精华，对被控对象的数学模型几乎没有任何要求，又在其基础上引入了基于现代控制理论的状态观测器技术，将抗干扰技术融入到了传统PID控制当中去，最终设计出了适合在工程实践中广泛应用的全新控制器。

本博客将从0开始，逐一介绍每一个部分，最后在合起来实现ADRC，每个部分都将介绍其公式原理和仿真实验。

一、跟踪微分器（TD）

这是一个单输入双输出的模块，作用有两个：

  • 避免输入量不要有跳变，便于实际系统实时跟踪。因为传统的pid有个问题，就是当跟踪像阶跃信号这种突变信号时超调和上升时间共存的现象，所以我们的思路就是对输入的信号进行平滑处理，也就是避免其出现突变。
  • 过滤高频噪声

所以输出1就是处理过的信号，第二个信号是输出1的微分，输出1和2都将用于下一环节，这里不介绍。

先摆出他的输出效果图，输入为阶跃信号：
在这里插入图片描述

说明：蓝色为处理后的阶跃信号，显然就好很多，没有那么突变。黄色为微分。

TD公式：
在这里插入图片描述

在这里插入图片描述

公式不难理解，接下来，我将对TD进行simulink仿真，其中fst函数我用的脚本写的：

在这里插入图片描述

在这里插入图片描述

友情提示：离散差分方程建模和连续系统微分方程建模一样，先找准输出y(k),再找准y（k-1）…,然后他们之间用单位延迟连接，最后在这基础上连其他东西。

hfst函数模块：

 

  1.  
    function out = hfst(u1,u2,r,h)
     
  2.  
    d=r*h;
     
  3.  
    d0=h*d;
     
  4.  
    y=u1+h*u2;
     
  5.  
    a0=sqrt(d*d+8*r*abs(y));
     
  6.  
    a=0;
     
  7.  
    out1=0;
     
  8.  
    if abs(y)>d0
     
  9.  
    a=u2+(a0-d)/2*sign(y);
     
  10.  
    end
     
  12.  
    if abs(y)<=d0
     
  13.  
    a=u2+y/h;
     
  14.  
    end
     
  16.  
    if abs(a)>d
     
  17.  
    out1=-r*sign(a);
     
  18.  
    end
     
  20.  
    if abs(a)<=d
     
  21.  
    out1=-r*a/d;
     
  22.  
    end
     
  23.  
    out=out1;
     
  24.  
    end
     
 

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
 

或者，不用像上面的simulink+m，整个td都可以直接用m脚本写也可以，已经过验证效果一样：
 

 

  1.  
    function [y1k,y2k] = fcn(u)
     
  2.  
    persistent y1k_1 y2k_1
     
  3.  
    h=0.01;
     
  4.  
    delta=10;
     
  5.  
    if isempty(y1k_1)
     
  6.  
    y1k_1=0;
     
  7.  
    end
     
  9.  
    if isempty(y2k_1)
     
  10.  
    y2k_1=0;
     
  11.  
    end
     
  13.  
    y1k=y1k_1+h*y2k_1;
     
  15.  
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%hfst计算内容
     
  16.  
    d=delta*h;
     
  17.  
    d0=h*d;
     
  18.  
    y=y1k_1-u+h*y2k_1;
     
  19.  
    a0=sqrt(d*d+8*delta*abs(y));
     
  20.  
    a=0;
     
  21.  
    out1=0;
     
  22.  
    if abs(y)>d0
     
  23.  
    a=y2k_1+(a0-d)/2*sign(y);
     
  24.  
    end
     
  26.  
    if abs(y)<=d0
     
  27.  
    a=y2k_1+y/h;
     
  28.  
    end
     
  30.  
    if abs(a)>d
     
  31.  
    out1=-delta*sign(a);
     
  32.  
    end
     
  34.  
    if abs(a)<=d
     
  35.  
    out1=-delta*a/d;
     
  36.  
    end
     
  37.  
    out=out1;
     
  38.  
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     
  40.  
    y2k=y2k_1+h*out;
     
  42.  
    y1k_1=y1k;
     
  43.  
    y2k_1=y2k;
     
  45.  
    y1k=y1k;
     
  46.  
    y2k=y2k;
     
  48.  
    end
     
 

 

 

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
 

说明：TD模型涉及两个调参：δ和h，h为采样周期，delta决定跟踪快慢（δ越大，过滤后的输出越接近输入），一般的仿真模型r可以尽量大一些，在100~500范围内基本相同，即使再大效果也基本不会有大的提升，我这里delta为50，h=0.001。
 

C语言实现：
 

//ADRC最速跟踪微分器TD，改进的算法fhan
void Fhan_ADRC(Fhan_Data *fhan_Input,float expect_ADRC)//安排ADRC过度过程
{
  float d=0,a0=0,y=0,a1=0,a2=0,a=0;
  float x1_delta=0;//ADRC状态跟踪误差项
  x1_delta=fhan_Input->x1-expect_ADRC;//用x1-v(k)替代x1得到离散更新公式
  fhan_Input->h0=fhan_Input->N0*fhan_Input->h;//用h0替代h，解决最速跟踪微分器速度超调问题
  d=fhan_Input->r*fhan_Input->h0*fhan_Input->h0;//d=rh^2;
  a0=fhan_Input->h0*fhan_Input->x2;//a0=h*x2
  y=x1_delta+a0;//y=x1+a0
  a1=sqrt(d*(d+8*ABS(y)));//a1=sqrt(d*(d+8*ABS(y))])
  a2=a0+Sign_ADRC(y)*(a1-d)/2;//a2=a0+sign(y)*(a1-d)/2;
  a=(a0+y)*Fsg_ADRC(y,d)+a2*(1-Fsg_ADRC(y,d));
  fhan_Input->fh=-fhan_Input->r*(a/d)*Fsg_ADRC(a,d)
    -fhan_Input->r*Sign_ADRC(a)*(1-Fsg_ADRC(a,d));//得到最速微分加速度跟踪量
  fhan_Input->x1+=fhan_Input->h*fhan_Input->x2;//跟新最速跟踪状态量x1
  fhan_Input->x2+=fhan_Input->h*fhan_Input->fh;//跟新最速跟踪状态量微分x2
}


 

 

 

二、非线性组合
 

这一部分对应第一张图中的非线性组合模块，这一模块为双输入单输出，输入的是两个误差，分别是指令信号差和指令信号微分的差，参考指令信号和参考指令信号的微分均由TD产生。
 

传统的pid或者pd控制就是比例、积分、微分的线性加权之和，但这种线性的组合不是最佳的，后来发现三者的非线性组合效果更好。最常用的就是pd形式的非线性组合：
在这里插入图片描述
这里面涉及的调参有三个：β1，β2，δ，δ为h的整数倍。
 

实验：演示非线性pd相比传统pd的优越性
 

咱们先看传统的pd控制：
 对象为：
 

 

  1.  
    sys = tf([133],[1,25,0])
     
  2.  
    dsys = c2d(sys,0.001,'z');
     
  3.  
    [num,den]=tfdata(dsys,'v');
     
 

  • 1
  • 2
  • 3
 

在这里插入图片描述
 

效果：
在这里插入图片描述
 

显然效果不好。
 

再来看看非线性pd控制：
 

在这里插入图片描述
 

函数模块代码：
 

 

  1.  
    function y =nonlinear_pd(e1,e2)
     
  2.  
    alfa1=0.75;
     
  3.  
    alfa2=1.5;
     
  4.  
    delta=0.002;
     
  5.  
    beta1=150;
     
  6.  
    beta2=1;
     
  7.  
    fal1=1;
     
  8.  
    fal2=1;
     
  10.  
    if abs(e1)<=delta
     
  11.  
    fal1=e1/(delta^(1-alfa1));
     
  12.  
    end
     
  14.  
    if abs(e1)>delta
     
  15.  
    fal1=(abs(e1))^(alfa1)*sign(e1);
     
  16.  
    end
     
  18.  
    if abs(e2)<=delta
     
  19.  
    fal2=e2/(delta^(1-alfa2));
     
  20.  
    end
     
  22.  
    if abs(e2)>delta
     
  23.  
    fal2=(abs(e2))^(alfa2)*sign(e2);
     
  24.  
    end
     
  26.  
    y=beta1*fal1+beta2*fal2;
     
  27.  
    end
     
 

 

 

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
 

效果：
 

在这里插入图片描述
 

可见效果好多了，因此非线性pid有效果！！！！！！
 

当然，我们这里用的是非线性pd控制，我们也可以用论文中的非线性pid控制，同理，这一部分公式为：
 

在这里插入图片描述
 

这里不再演示了。
 

 

三、ESO扩张观测器
 

ESO是一个双输入单输出模块，输入的值为对象的输出以及对象的控制输入，见第一张图，而输出有三个，分别是对象输出的估计值、对象输出的估计值的一阶导数、对象输出的估计值的二阶导数。而对象输出的估计值、对象输出的估计值的一阶导数将反馈给最开始的跟踪微分器（TD），而对象输出的估计值的二阶导数将反馈给非线性组合的输出上用于弥补扰动。
 

 
 
一般观测器仅观测系统的状态，只有输出和输出的导数（速度）。但是这里对输出的导数的导数（加速度）也进行了观测，这里也就是所谓的扰动（即第一张图中的w），对扰动进行了观测。观测器的状态量也由此扩张了一维，因此叫做扩张观测器。
 

 

ESO的公式见下图：
在这里插入图片描述
 simulink模型：
在这里插入图片描述
 

里面的代码如下：
 

 

  1.  
    function [z1_k,z2_k,z3_k] = ESO(yk,uk)
     
  2.  
    %%参数初始化
     
  3.  
    persistent z1_k_1 z2_k_1 z3_k_1
     
  4.  
    bata01=30;
     
  5.  
    beta02=300;
     
  6.  
    beta03=1000;
     
  7.  
    b=5;
     
  8.  
    h=0.001;
     
  9.  
    alfa1=0.75;
     
  10.  
    alfa2=1.5;
     
  11.  
    delta=0.002;
     
  12.  
    fal1=1;
     
  13.  
    fal2=1;
     
  14.  
    if isempty(z1_k_1)
     
  15.  
    z1_k_1=0;
     
  16.  
    end
     
  17.  
    if isempty(z2_k_1)
     
  18.  
    z2_k_1=0;
     
  19.  
    end
     
  20.  
    if isempty(z3_k_1)
     
  21.  
    z3_k_1=0;
     
  22.  
    end
     
  24.  
    e1=z1_k_1-yk;
     
  25.  
    z1_k=z1_k_1+h*(z2_k_1-bata01*e1);
     
  26.  
    z1_k_1=z1_k; %%迭代更新z1_k_1
     
  28.  
    %%计算fal函数
     
  29.  
    if abs(e1)<=delta
     
  30.  
    fal1=e1/(delta^(1-alfa1));
     
  31.  
    end
     
  32.  
    if abs(e1)>delta
     
  33.  
    fal1=(abs(e1))^(alfa1)*sign(e1);
     
  34.  
    end
     
  35.  
    if abs(e1)<=delta
     
  36.  
    fal2=e1/(delta^(1-alfa2));
     
  37.  
    end
     
  38.  
    if abs(e1)>delta
     
  39.  
    fal2=(abs(e1))^(alfa2)*sign(e1);
     
  40.  
    end
     
  42.  
    z2_k=z2_k_1+h*(z3_k_1-beta02*fal1+b*uk);
     
  43.  
    z2_k_1=z2_k;%%迭代更新z2_k_1
     
  45.  
    z3_k=z3_k_1-h*beta03*fal2;
     
  46.  
    z3_k_1=z3_k;%%迭代更新z3_k_1
     
  48.  
    end
     
 

 

 

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
 

但要注意：因为ESO的公式里面已经加入了b*u，所以在搭最后的模型时第一张图中的b0就不要了，即不用再乘上b0，直接将补偿后的u输入ESO。同理，如果你要在similink模型里要显示用上b0这个比例系数，那么ESO里的公式里就要改为：z2_k=z2_k_1+h*(z3_k_1-beta02*fal1+uk);即去掉最后的uk前的系数b。
 


//状态观测器参数beta01=1/h  beta02=1/(3*h^2)  beta03=2/(8^2*h^3) ...
void ESO_ADRC(Fhan_Data *fhan_Input)
{
  fhan_Input->e=fhan_Input->z1-fhan_Input->y;//状态误差
  
  fhan_Input->fe=Fal_ADRC(fhan_Input->e,0.5,fhan_Input->N1*fhan_Input->h);//非线性函数，提取跟踪状态与当前状态误差
  fhan_Input->fe1=Fal_ADRC(fhan_Input->e,0.25,fhan_Input->N1*fhan_Input->h);
  
  /*************扩展状态量更新**********/
  fhan_Input->z1+=fhan_Input->h*(fhan_Input->z2-fhan_Input->beta_01*fhan_Input->e);
  fhan_Input->z2+=fhan_Input->h*(fhan_Input->z3
                                 -fhan_Input->beta_02*fhan_Input->fe
                                   +fhan_Input->b0*fhan_Input->u);
  //ESO估计状态加速度信号，进行扰动补偿，传统MEMS陀螺仪漂移较大，估计会产生漂移
  fhan_Input->z3+=fhan_Input->h*(-fhan_Input->beta_03*fhan_Input->fe1);
}


 

 

四、完整的ADRC
 

这一节将把前面的组合起来构成一个完整的ADRC，也就是第一张图中的形式。搭好的结构如下：
 

在这里插入图片描述
注意点：
 1.因为这是一个离散的模型，所以确保所有模块的采样时间一致
 2.注意检查所有的求和模块的正负
 3.注意上面第三节的黑色注意部分
 

开始仿真，报错了：
在这里插入图片描述
 

翻译过来就是说存在代数环的原因，这个问题我搜了百度：
 

 
 
https://wenku.baidu.com/view/c3be45de763231126fdb1143.html
 

 

这个问题很同意理解，我们知道，我们在求解反馈环的时候，首先反馈的初始值是为o的，也就是反馈系统的顺序是：我们先根据主路输入计算得到主路的输出（即得到反馈路的输入），在根据反馈路的输入计算出反馈路的输出（即反馈值），然后进行下一次循环。而在simulink中，他不像我们之前写的m脚本（我们自己写脚本就是从主路开始），他不知道首先应该计算主路还是首先计算反馈路，所以我们需要告诉他，解决办法就是在反馈路的输出端加上单位延迟，也就是告诉反馈路你等等，别太急，等主路先走。
 

其实我们还可以这样去理解代数环，将其理解为初始状态时反馈量没有初始值，我们以前的控制模型比如pid啥的，我们反馈的反馈量都会有一个初始值，而这个模型的ESO的输出作为反馈量是没有初始值的，所以他报错的原因还可以理解为反馈量没有初始值，所以我们就去给反馈量设一个初始值，我们就可以用memory模块（这个模块的作用就是有输入时输出=输入，没输入时输出保持原先状态，且当输入改变时输出才改变，否则一直保持输出不变），在memory模块里设置一个初始值，这样反馈量就有初始值了。而上面我们用的单位延迟模块就是一个memory模块，二者本来就是一样的。所以上面用单位延迟模块也可以这样理解。
 

修改后的simulink为：
 

在这里插入图片描述
 

或者（两者等价）：
 

在这里插入图片描述
 

 

仿真后结果没报错，且结果令人满意：
在这里插入图片描述
 

其中黄色为初始阶跃信号，红色为经过td的信号，蓝色为控制输出。
 

 
 

/*----------------------------------------------------------------------------------------------------------------------/
*               本程序只供购买者学习使用，版权著作权属于无名科创团队，无名科创团队将飞控程序源码提供给购买者，
*               购买者要为无名科创团队提供保护，未经作者许可，不得将源代码提供给他人，不得将源代码放到网上供他人免费下载， 
*               更不能以此销售牟利，如发现上述行为，无名科创团队将诉之以法律解决！！！
-----------------------------------------------------------------------------------------------------------------------/
*               生命不息、奋斗不止；前人栽树，后人乘凉！！！
*               开源不易，且学且珍惜，祝早日逆袭、进阶成功！！！
*               学习优秀者，简历可推荐到DJI、ZEROTECH、XAG、AEE、GDU、AUTEL、EWATT、HIGH GREAT等公司就业
*               求职简历请发送：15671678205@163.com，需备注求职意向单位、岗位、待遇等
*               无名科创开源飞控QQ群：540707961
*               CSDN博客：http://blog.csdn.net/u011992534
*               优酷ID：NamelessCotrun无名小哥
*               B站教学视频：https://space.bilibili.com/67803559/#/video
*               客户使用心得、改进意见征集贴：http://www.openedv.com/forum.php?mod=viewthread&tid=234214&extra=page=1
*               淘宝店铺：https://shop348646912.taobao.com/?spm=2013.1.1000126.2.5ce78a88ht1sO2
*               百度贴吧:无名科创开源飞控
*               修改日期:2018/8/30
*               版本：慧飞者——V1.0.1
*               版权所有，盗版必究。
*               Copyright(C) 武汉科技大学无名科创团队 2017-2025
*               All rights reserved
----------------------------------------------------------------------------------------------------------------------*/
#include "Headfile.h"
#include "ADRC.h"
 
Fhan_Data ADRC_Pitch_Controller;
Fhan_Data ADRC_Roll_Controller;
const float ADRC_Unit[4][16]=
{
  /*TD跟踪微分器   改进最速TD,h0=N*h      扩张状态观测器ESO           扰动补偿     非线性组合*/
  /*  r     h      N                  beta_01   beta_02    beta_03     b0     beta_0  beta_1     beta_2     N1     C    alpha1  alpha2  zeta       b*/
  {1000000 ,0.005 , 5,               300,      10000,      100000,      0.5,    0.85,   1.5,      0.0003,       2,    5,    0.9,   1.2,    0.03,    0.1},
  {1000000 ,0.005 , 5,               300,      10000,      100000,      0.5,    0.85,   1.5,      0.0003,       2,    5,    0.9,   1.2,    0.03,    0.1},
  {300000  ,0.005 , 3,               300,      4000,      10000,     100,   0.2,    1.2,      0.0010,       5,      5,    0.8,   1.5,    0.03,    0.05},
};
 
 
float Constrain_Float(float amt, float low, float high){
  return ((amt)<(low)?(low):((amt)>(high)?(high):(amt)));
}
 
Butter_Parameter ADRC_Div_LPF_Parameter={
  //200---20hz
  1,    -1.14298050254,   0.4128015980962,
  0.06745527388907,   0.1349105477781,  0.06745527388907
};
float ADRC_LPF(float curr_inputer,Butter_BufferData *Buffer,Butter_Parameter *Parameter)
{
  /* 加速度计Butterworth滤波 */
  /* 获取最新x(n) */
  Buffer->Input_Butter[2]=curr_inputer;
  /* Butterworth滤波 */
  Buffer->Output_Butter[2]=
    Parameter->b[0] * Buffer->Input_Butter[2]
      +Parameter->b[1] * Buffer->Input_Butter[1]
	+Parameter->b[2] * Buffer->Input_Butter[0]
          -Parameter->a[1] * Buffer->Output_Butter[1]
            -Parameter->a[2] * Buffer->Output_Butter[0];
  /* x(n) 序列保存 */
  Buffer->Input_Butter[0]=Buffer->Input_Butter[1];
  Buffer->Input_Butter[1]=Buffer->Input_Butter[2];
  /* y(n) 序列保存 */
  Buffer->Output_Butter[0]=Buffer->Output_Butter[1];
  Buffer->Output_Butter[1]=Buffer->Output_Butter[2];
  return (Buffer->Output_Butter[2]);
}
 
 
 
 
 
int16_t Sign_ADRC(float Input)
{
  int16_t output=0;
  if(Input>1E-6) output=1;
  else if(Input<-1E-6) output=-1;
  else output=0;
  return output;
}
 
int16_t Fsg_ADRC(float x,float d)
{
  int16_t output=0;
  output=(Sign_ADRC(x+d)-Sign_ADRC(x-d))/2;
  return output;
}
 
 
void ADRC_Init(Fhan_Data *fhan_Input1,Fhan_Data *fhan_Input2)
{
  fhan_Input1->r=ADRC_Unit[0][0];
  fhan_Input1->h=ADRC_Unit[0][1];
  fhan_Input1->N0=(uint16)(ADRC_Unit[0][2]);
  fhan_Input1->beta_01=ADRC_Unit[0][3];
  fhan_Input1->beta_02=ADRC_Unit[0][4];
  fhan_Input1->beta_03=ADRC_Unit[0][5];
  fhan_Input1->b0=ADRC_Unit[0][6];
  fhan_Input1->beta_0=ADRC_Unit[0][7];
  fhan_Input1->beta_1=ADRC_Unit[0][8];
  fhan_Input1->beta_2=ADRC_Unit[0][9];
  fhan_Input1->N1=(uint16)(ADRC_Unit[0][10]);
  fhan_Input1->c=ADRC_Unit[0][11];
  
  fhan_Input1->alpha1=ADRC_Unit[0][12];
  fhan_Input1->alpha2=ADRC_Unit[0][13];
  fhan_Input1->zeta=ADRC_Unit[0][14];
  fhan_Input1->b=ADRC_Unit[0][15];
  
  fhan_Input2->r=ADRC_Unit[1][0];
  fhan_Input2->h=ADRC_Unit[1][1];
  fhan_Input2->N0=(uint16)(ADRC_Unit[1][2]);
  fhan_Input2->beta_01=ADRC_Unit[1][3];
  fhan_Input2->beta_02=ADRC_Unit[1][4];
  fhan_Input2->beta_03=ADRC_Unit[1][5];
  fhan_Input2->b0=ADRC_Unit[1][6];
  fhan_Input2->beta_0=ADRC_Unit[1][7];
  fhan_Input2->beta_1=ADRC_Unit[1][8];
  fhan_Input2->beta_2=ADRC_Unit[1][9];
  fhan_Input2->N1=(uint16)(ADRC_Unit[1][10]);
  fhan_Input2->c=ADRC_Unit[1][11];
  
  fhan_Input2->alpha1=ADRC_Unit[1][12];
  fhan_Input2->alpha2=ADRC_Unit[1][13];
  fhan_Input2->zeta=ADRC_Unit[1][14];
  fhan_Input2->b=ADRC_Unit[1][15];
}
 
 
 
//ADRC最速跟踪微分器TD，改进的算法fhan
void Fhan_ADRC(Fhan_Data *fhan_Input,float expect_ADRC)//安排ADRC过度过程
{
  float d=0,a0=0,y=0,a1=0,a2=0,a=0;
  float x1_delta=0;//ADRC状态跟踪误差项
  x1_delta=fhan_Input->x1-expect_ADRC;//用x1-v(k)替代x1得到离散更新公式
  fhan_Input->h0=fhan_Input->N0*fhan_Input->h;//用h0替代h，解决最速跟踪微分器速度超调问题
  d=fhan_Input->r*fhan_Input->h0*fhan_Input->h0;//d=rh^2;
  a0=fhan_Input->h0*fhan_Input->x2;//a0=h*x2
  y=x1_delta+a0;//y=x1+a0
  a1=sqrt(d*(d+8*ABS(y)));//a1=sqrt(d*(d+8*ABS(y))])
  a2=a0+Sign_ADRC(y)*(a1-d)/2;//a2=a0+sign(y)*(a1-d)/2;
  a=(a0+y)*Fsg_ADRC(y,d)+a2*(1-Fsg_ADRC(y,d));
  fhan_Input->fh=-fhan_Input->r*(a/d)*Fsg_ADRC(a,d)
    -fhan_Input->r*Sign_ADRC(a)*(1-Fsg_ADRC(a,d));//得到最速微分加速度跟踪量
  fhan_Input->x1+=fhan_Input->h*fhan_Input->x2;//跟新最速跟踪状态量x1
  fhan_Input->x2+=fhan_Input->h*fhan_Input->fh;//跟新最速跟踪状态量微分x2
}
 
 
//原点附近有连线性段的连续幂次函数
float Fal_ADRC(float e,float alpha,float zeta)
{
  int16 s=0;
  float fal_output=0;
  s=(Sign_ADRC(e+zeta)-Sign_ADRC(e-zeta))/2;
  fal_output=e*s/(powf(zeta,1-alpha))+powf(ABS(e),alpha)*Sign_ADRC(e)*(1-s);
  return fal_output;
}
 
 
 
 
/************扩张状态观测器********************/
//状态观测器参数beta01=1/h  beta02=1/(3*h^2)  beta03=2/(8^2*h^3) ...
void ESO_ADRC(Fhan_Data *fhan_Input)
{
  fhan_Input->e=fhan_Input->z1-fhan_Input->y;//状态误差
  
  fhan_Input->fe=Fal_ADRC(fhan_Input->e,0.5,fhan_Input->N1*fhan_Input->h);//非线性函数，提取跟踪状态与当前状态误差
  fhan_Input->fe1=Fal_ADRC(fhan_Input->e,0.25,fhan_Input->N1*fhan_Input->h);
  
  /*************扩展状态量更新**********/
  fhan_Input->z1+=fhan_Input->h*(fhan_Input->z2-fhan_Input->beta_01*fhan_Input->e);
  fhan_Input->z2+=fhan_Input->h*(fhan_Input->z3
                                 -fhan_Input->beta_02*fhan_Input->fe
                                   +fhan_Input->b0*fhan_Input->u);
  //ESO估计状态加速度信号，进行扰动补偿，传统MEMS陀螺仪漂移较大，估计会产生漂移
  fhan_Input->z3+=fhan_Input->h*(-fhan_Input->beta_03*fhan_Input->fe1);
}
 
 
/************非线性组合****************/
/*
void Nolinear_Conbination_ADRC(Fhan_Data *fhan_Input)
{
float d=0,a0=0,y=0,a1=0,a2=0,a=0;
float Sy=0,Sa=0;//ADRC状态跟踪误差项
 
fhan_Input->h1=fhan_Input->N1*fhan_Input->h;
 
d=fhan_Input->r*fhan_Input->h1*fhan_Input->h1;
a0=fhan_Input->h1*fhan_Input->c*fhan_Input->e2;
y=fhan_Input->e1+a0;
a1=sqrt(d*(d+8*ABS(y)));
a2=a0+Sign_ADRC(y)*(a1-d)/2;
 
Sy=Fsg_ADRC(y,d);
a=(a0+y-a2)*Sy+a2;
Sa=Fsg_ADRC(a,d);
fhan_Input->u0=-fhan_Input->r*((a/d)-Sign_ADRC(a))*Sa-fhan_Input->r*Sign_ADRC(a);
 
//a=(a0+y)*Fsg_ADRC(y,d)+a2*(1-Fsg_ADRC(y,d));
 
//fhan_Input->fh=-fhan_Input->r*(a/d)*Fsg_ADRC(a,d)
//                -fhan_Input->r*Sign_ADRC(a)*(1-Fsg_ADRC(a,d));//得到最速微分加速度跟踪量
}
*/
void Nolinear_Conbination_ADRC(Fhan_Data *fhan_Input)
{
  float temp_e2=0;
  //temp_e2=Constrain_Float(fhan_Input->e2,-3000,3000);
  temp_e2=Constrain_Float(fhan_Input->e2_lpf,-3000,3000);
  fhan_Input->u0=fhan_Input->beta_1*Fal_ADRC(fhan_Input->e1,fhan_Input->alpha1,fhan_Input->zeta)
    +fhan_Input->beta_2*Fal_ADRC(temp_e2,fhan_Input->alpha2,fhan_Input->zeta);
  
}
 
 
void ADRC_Control(Fhan_Data *fhan_Input,float expect_ADRC,float feedback_ADRC)
{
  fhan_Input->Last_TD_Input=fhan_Input->TD_Input;
  fhan_Input->TD_Input=expect_ADRC;
  fhan_Input->TD_Input_Div=(fhan_Input->TD_Input-fhan_Input->Last_TD_Input)/fhan_Input->h;
  
  fhan_Input->Last_ESO_Input=fhan_Input->ESO_Input;
  fhan_Input->ESO_Input=feedback_ADRC;
  fhan_Input->ESO_Input_Div=(fhan_Input->ESO_Input-fhan_Input->Last_ESO_Input)/fhan_Input->h;
  
  /*自抗扰控制器第1步*/
  /********
      **
      **
      **
      **
      **
  ********/
  /*****
  安排过度过程，输入为期望给定，
  由TD跟踪微分器得到：
  过度期望信号x1，过度期望微分信号x2
  ******/
  Fhan_ADRC(fhan_Input,expect_ADRC);
  
  /*自抗扰控制器第2步*/
  /********
          *
          *
  *  * *  *
  *
  *
  ********/
  /************系统输出值为反馈量，状态反馈，ESO扩张状态观测器的输入*********/
  fhan_Input->y=feedback_ADRC;
  /*****
  扩张状态观测器，得到反馈信号的扩张状态：
  1、状态信号z1；
  2、状态速度信号z2；
  3、状态加速度信号z3。
  其中z1、z2用于作为状态反馈与TD微分跟踪器得到的x1,x2做差后，
  经过非线性函数映射，乘以beta系数后，
  组合得到未加入状态加速度估计扰动补偿的原始控制量u
  *********/
  ESO_ADRC(fhan_Input);//低成本MEMS会产生漂移，扩展出来的z3此项会漂移，目前暂时未想到办法解决，未用到z3
  /*自抗扰控制器第3步*/
  /********
         **
      **
     **
      **
        **
  ********/
  /********状态误差反馈率***/
  fhan_Input->e0+=fhan_Input->e1*fhan_Input->h;//状态积分项
  fhan_Input->e1=fhan_Input->x1-fhan_Input->z1;//状态偏差项
  fhan_Input->e2=fhan_Input->x2-fhan_Input->z2;//状态微分项
  fhan_Input->e2_lpf=ADRC_LPF(fhan_Input->e2,
                              &fhan_Input->ADRC_LPF_Buffer,
                              &ADRC_Div_LPF_Parameter);//巴特沃斯低通后得到的微分项,20hz
  /********线性组合*******/
  /*
  fhan_Input->u0=//fhan_Input->beta_0*fhan_Input->e0
  +fhan_Input->beta_1*fhan_Input->e1
  +fhan_Input->beta_2*fhan_Input->e2;
  */
  Nolinear_Conbination_ADRC(fhan_Input);
  /**********扰动补偿*******/
  fhan_Input->u=fhan_Input->u0//-fhan_Input->z3/fhan_Input->b;
    -fhan_Input->z3/fhan_Input->b0;
  //fhan_Input->u+=Constrain_Float(fhan_Input->beta_0*fhan_Input->e0,-150,150);
  //由于MEMS传感器漂移比较严重，当beta_03取值比较大时，长时间z3漂移比较大，目前不加入扰动补偿控制量
  fhan_Input->u=Constrain_Float(fhan_Input->u0,-450,450);//不加入扰动补偿
  //fhan_Input->u=Constrain_Float(fhan_Input->u,-450,450);//加入扰动补偿
}
 
void ADRC_Integrate_Reset(Fhan_Data *fhan_Input)  {fhan_Input->e0=0.0f;}
 
 

#ifndef _ADRC_H_
#define _ADRC_H_
/*----------------------------------------------------------------------------------------------------------------------/
        *               本程序只供购买者学习使用，版权著作权属于无名科创团队，
        *               无名科创团队将飞控程序源码提供给购买者，
        *               购买者要为无名科创团队提供保护，
        *               未经作者许可，不得将源代码提供给他人
        *               不得将源代码放到网上供他人免费下载，
        *               更不能以此销售牟利，如发现上述行为，
        *               无名科创团队将诉之以法律解决！！！
-----------------------------------------------------------------------------------------------------------------------/
        *               生命不息、奋斗不止；前人栽树，后人乘凉！！！
        *               开源不易，且学且珍惜，祝早日逆袭、进阶成功！！！
-----------------------------------------------------------------------------------------------------------------------/
	*		无名科创开源飞控 V1.1	武汉科技大学  By.YuYi
	*		CSDN博客: http://blog.csdn.net/u011992534
	*               优酷ID：NamelessCotrun无名小哥
	*               无名科创开源飞控QQ群：540707961
        *               https://shop348646912.taobao.com/?spm=2013.1.1000126.2.5ce78a88ht1sO2
        *               百度贴吧:无名科创开源飞控
        *               修改日期:2017/10/30
        *               版本：V1.1
        *               版权所有，盗版必究。
        *               Copyright(C) 武汉科技大学无名科创团队 2017-2019
        *               All rights reserved
----------------------------------------------------------------------------------------------------------------------*/
typedef struct
{
/*****安排过度过程*******/
float x1;//跟踪微分期状态量
float x2;//跟踪微分期状态量微分项
float r;//时间尺度
float h;//ADRC系统积分时间
uint16 N0;//跟踪微分器解决速度超调h0=N*h
 
float h0;
float fh;//最速微分加速度跟踪量
/*****扩张状态观测器*******/
/******已系统输出y和输入u来跟踪估计系统状态和扰动*****/
float z1;
float z2;
float z3;//根据控制对象输入与输出，提取的扰动信息
float e;//系统状态误差
float y;//系统输出量
float fe;
float fe1;
float beta_01;
float beta_02;
float beta_03;
 
/**********系统状态误差反馈率*********/
float e0;//状态误差积分项
float e1;//状态偏差
float e2;//状态量微分项
float u0;//非线性组合系统输出
float u;//带扰动补偿后的输出
 
 
/*********第一种组合形式*********/
float beta_0;//线性
float beta_1;//非线性组合参数
float beta_2;//u0=beta_1*e1+beta_2*e2+(beta_0*e0);
/*********第二种组合形式*********/
float alpha1;//u0=beta_1*fal(e1,alpha1,zeta)+beta_2*fal(e2,alpha2,zeta)
float alpha2;//0<alpha1<1<alpha2
float zeta;//线性段的区间长度
/*********第三种组合形式*********/
float h1;//u0=-fhan(e1,e2,r,h1);
uint16 N1;//跟踪微分器解决速度超调h0=N*h
/*********第四种组合形式*********/
float c;//u0=-fhan(e1,c*e2*e2,r,h1);
float b0;//扰动补偿
}Fhan_Data;
 
 
 
void ADRC_Init(Fhan_Data *fhan_Input1,Fhan_Data *fhan_Input2);
void Fhan_ADRC(Fhan_Data *fhan_Input,float expect_ADRC);
void ADRC_Control(Fhan_Data *fhan_Input,float expect_ADRC,float feedback);
 
extern Fhan_Data ADRC_Pitch_Controller,ADRC_Roll_Controller;
#endif
 
 


                

        

        

    




    

      

        

            

              
                
                  缘梦 CC
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    10
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    24
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
ADRC自抗扰控制从Simulink仿真到PLC控制实现

				
			

			

				

					RXXW_Dor的博客
				

				

					11-19
					
					1514
					
				

			

		

		

			
				
PLC的自抗扰控制(ADRC)算法_RXXW_Dor的博客-CSDN博客_adrc算法1、自抗扰控制算法，网上很多文章有所讲解，大家也可以关注韩京清教授的论文和书籍，这里就不赘述了，下面给出梯形图+SCL代码。1、跟踪微分器2、线性控制率3、博图SCL控制代码4、ADRC控制算法的所有公式汇总......https://blog.csdn.net/m0_46143730/article/details/123763059。这篇我们学习在MATLAB里如何搭建ADRC自抗扰控制仿真框图。

			
		

	



                

              
                



	

		

			

				
					
基于ADRC自抗扰控制器的simulink仿真,包括ESO，TD等模块+含代码操作演示视频 

				
			

			

				

					05-19
				

			

		

		

			
				
基于ADRC自抗扰控制器的simulink仿真,包括ESO，TD等模块+含代码操作演示视频   运行注意事项：使用matlab2021a或者更高版本测试，运行里面的Runme.m文件，不要直接运行子函数文件。运行时注意matlab左侧的当前文件夹...

			
		

	



                


  
              

                


	

		

			

				
					
基于自抗扰控制ADRC的永磁同步电机仿真模型(Simulink仿真实现）

				
			

			

				

					weixin_66436111的博客
				

				

					03-04
					
					470
					
				

			

		

		

			
				
使用自抗扰控制(ADRC)技术来控制永磁同步电机是一种常见的方法。在进行仿真模型设计时，通常需要考虑永磁同步电机的动态方程、控制策略以及系统的稳定性等因素。1. 首先，编写永磁同步电机的动态方程。这可以是基于电机的物理特性和转子、定子之间的电磁耦合关系建立的微分方程组。2. 接下来，设计ADRC控制器，包括观测器和控制器。ADRC控制器通常包括状态观测器、扰动观测器和控制器三部分，用于实现对系统状态和扰动的估计和补偿。

			
		

	





	

		

			

				
					
基于ADRC自抗扰控制器的simulink仿真,ESO和TD等模块使用S函数开发

				
			

			

				

					fpga/matlab/simulink算法仿真工程
				

				

					02-27
					
					2963
					
				

			

		

		

			
				
跟踪微分器的作用是安排过渡过程，给出合理的控制信号，解决了响应速度与超调性之间的矛盾。设计扩展状态观测器的目的就是观测扩展出来的状态变量，用来估计未知扰动和控制对象未建模部分，实现动态系统的反馈线性化，将控制对象变为积分串联型。自抗扰控制是在PID控制算法基础上进行改进的新型控制方法，它具有不依赖于控制对象模型、不区分系统内外扰的结构特点。非线性状态误差反馈控制率是一种非线性的组合方式，输入是TD输出的状态变量与ESO状态估计值之间的误差，输出结合ESO的总扰动补偿值得到控制器的控制量。

			
		

	



		

			
		



	

		

			

				
					
自抗扰控制（ADRC）仿真系统（matlab/simulink）的搭建

					
热门推荐

				
			

			

				

					qq_43309646的博客
				

				

					09-09
					
					2万+
					
				

			

		

		

			
				
一、现在关于自抗扰控制技术方面的研究已经比较成熟了，基本上了解结构以后都可以找到历程实现，今天简单总结一采用自抗扰控制的仿真系统搭建，不必畏惧，熟悉皆可达。
1.首先自抗扰控制分为TD（跟踪微分器），非线性组合，ESO扩张状态观测器。而每部分的公式推导均可在《自抗扰控制技术-估计补偿不确定因素的控制技术》这本书中找到，很推荐，如果有些不了解的也可以搜索韩老师的论文看看。

2.按照一般论文流程，先介绍整体结构，框图如下：

其实结构也挺少，使用习惯以后，其实很好理解。
3.接下来按照每个部分简单做一个介绍。

			
		

	





	

		

			

				
					
永磁同步电机转速PI控制，SMC滑模控制，ADRC自抗扰控制Simulink对比仿真模型

				
			

			

				

					LQVYVHpom的博客
				

				

					11-12
					
					396
					
				

			

		

		

			
				
接着，我们来看一下SMC滑模控制。SMC是一种基于滑模模型的控制方法，它以系统非线性特性为前提，通过引入滑模曲线的概念，使系统在滑模面上运行，从而实现对系统的控制。在本文中，我们将针对转速环控制方法，进行三种不同的方法对比，包括PI控制、SMC滑模控制和ADRC自抗扰控制。仿真结果表明，相比于PI控制和SMC控制，ADRC控制对PMSM转速的控制效果更加优秀。2.转速电流双闭环控制，电流环采用PI控制，转速环分别采用PI控制、SMC滑模控制和ADRC自抗扰控制，对三种方法进行对比，分析ADRC控制优越性～

			
		

	





	

		

			

				
					
ADRC自抗扰控制simulink仿真程序

				
			

			

				

					11-02
				

			

		

		

			
				
ADRC自抗扰控制simulink仿真程序，包含simulink仿真框图及代码，可以运行。

			
		

	





	

		

			

				
					
永磁同步电机（PMSM）的自抗扰控制（ADRC）simulink仿真程序，附上各部分模块详细介绍及参考资料

				
			

			

				

					04-13
				

			

		

		

			
				
永磁同步电机（PMSM）的自抗扰控制（ADRC）simulink仿真程序，MATALB2015b以上都能正常运行，参数已调节。内涵资料，对simulink各模块怎么搭建及原理做详细介绍，同时附模型搭建的参考文献。应付大作业、本科毕设等...

			
		

	





	

		

			

				
					
自抗扰控制（ADRC）Matlab/Simulink仿真模型

				
			

			

				

					04-22
				

			

		

		

			
				
适用于初学者的ADRC仿真模型，可直接调试，仿真，便于新人入门学习

			
		

	





	

		

			

				
					
XTuner笔记

				
			

			

				

					qq_19859865的博客
				

				

					05-10
					
					396
					
				

			

		

		

			
				
方法：在模型的每一层之间添加可训练的小规模的网络，冻结原始网络权重，以此来减少fine-tune所需要的参数量。应用：适用于那些希望在保持预训练模型结构不变的同时，对模型进行特定任务调整的场景。缺点：引入推理延时在LoRA的基础上，添加了NF4的数据压缩（信息理论中最有的正太分布数据量化数据类型），进一步减少了显存和内存的消耗；然后添加一组可学习的LoRA权重，这些权重通过量化权重的反向传播梯度进行调整。块状 k-bit 量化：既压缩了数据，又解决了异常值（我理解为噪声）对数据压缩的影响。

			
		

	





	

		

			

				
					
Linux知识点笔记

					
最新发布

				
			

			

				

					exercise_smile的博客
				

				

					05-16
					
					555
					
				

			

		

		

			
				
Linux 主要的发行版(release):Ubuntu(乌班图)、 RedHat(红帽)、 CentOS、 Debain[蝶变]、 Fedora、 SuSE、 OpenSUSE [示意图]在 linux 中的每个用户必须属于一个组， 不能独立于组外。在 linux 中每个文件 有所有者、 所在组、 其它组的概念。ls -l 中显示的内容如下：0-9 位说明：第 0 位确定文件类型(d, - , l , c , b)l 是链接， 相当于 windows 的快捷方式。

			
		

	





	

		

			

				
					
Linux FT260驱动内核学习笔记

				
			

			

				

					pq的博客
				

				

					05-12
					
					782
					
				

			

		

		

			
				
系统采用Ubuntu 22，X86 64。

			
		

	





	

		

			

				
					
openGauss学习笔记-279 openGauss性能调优-实际调优案例08-改写SQL消除in-clause

				
			

			

				

					超哥的博客
				

				

					05-10
					
					72
					
				

			

		

		

			
				
openGauss学习笔记-279 openGauss性能调优-实际调优案例08-改写SQL消除in-clause279.1 现象描述279.2 优化说明 openGauss学习笔记-279 open

			
		

	





	

		

			

				
					
《大数据分析-数据仓库项目实战》学习笔记

				
			

			

				

					LANXIAMAO的博客
				

				

					05-09
					
					903
					
				

			

		

		

			
				
文章部分内容参考《大数据分析-数据仓库项目实战》一书，仅供学习，喜欢可购买正版书籍，如有不妥请联系删除。

			
		

	





	

		

			

				
					
【强训笔记】day20

				
			

			

				

					Lehjy的博客
				

				

					05-11
					
					329
					
				

			

		

		

			
				
【强训笔记】day20

			
		

	





	

		

			

				
					
Electron学习笔记（三）

				
			

			

				

					qq_45897239的博客
				

				

					05-10
					
					767
					
				

			

		

		

			
				
五、界面
1、获取 webContents 实例
（1）通过窗口对象的 webContent 属性获取 webContent 实例：
（2）获取当前激活窗口的 webContents 实例：
（3）在渲染进程中获取当前窗口的 webContents 实例：
（4）通过 id 获取 webContents 实例：
（5）遍历应用内的 webContents 对象：
2、页面加载事件及触发顺序
3、页面跳转事件
4、页面缩放
5、页面容器
6、脚本注入
(1) 通过 preload 参数注入脚本
(2) 通过 

			
		

	





	

		

			

				
					
计算机网络原原理学习资料分享笔记---第三章/第三节（为有梦想的自己加油！）

				
			

			

				

					Java000I的博客
				

				

					05-13
					
					971
					
				

			

		

		

			
				
2 、收到 1 个ACKn。1 、正确接收到序号在接收窗口范围内的分组PTKn，发送ACKn，窗口滑动。序号为基序号，则发送一个ACKn，接收窗口滑动到序号n+ 1 的位置。3 ）发送方如果收到ACK，则继续发送后续报文段，否则重发刚刚发送。3 ）发送方如果收到ACK，则继续发送后续报文段，否则重发刚刚发送。发送方接收到NAK，表示接收方没有正确接收数据，则将出错的数据重。2 ）接收方如果差错检测无误且序号正确，则接收报文段，并向发送方。2 ）接收方如果差错检测无误且序号正确，则接收报文段，并向发送方。

			
		

	





	

		

			

				
					
【3dmax笔记】022：文件合并、导入、导出

				
			

			

				

					「 刘一哥与GIS的故事」
				

				

					05-15
					
					42
					
				

			

		

		

			
				
3dmax高版本转低版本只能向下转换3个版本，可以选择导出为fbx，解除版本限制。只能合并 max 文件（高版本能够合并低版本模型，低版本不能合并高版本的模型）。导入格式有- - - fbx dwg skp 等等。

			
		

	





	

		

			

				
					
matlabl adrc

				
			

			

				

					11-24
				

			

		

		

			
				
MATLAB ADRC（Active Disturbance Rejection Control）是一种优秀的自适应控制算法，用于实时控制系统中的运动控制、电力系统、通信系统、机器人控制等领域。

MATLAB ADRC的核心思想是通过对系统的扰动进行实时估计和补偿，达到抑制扰动并实现精确控制的目的。其基本原理是在系统输出和期望输出之间引入一个扰动观测器，以实时估计系统的外来扰动，进而进行有效的补偿。

MATLAB ADRC 的主要优点包括：

1. 具有良好的鲁棒性：ADRC能够在存在参数变化、扰动干扰时保持系统的稳定性和精确控制性能。

2. 实时性较高：ADRC的设计简单，可用于实时控制系统，响应速度较快。

3. 抗干扰能力强：ADRC通过实时对扰动的估计和补偿，有效抑制外来扰动对系统的影响。

4. 适用范围广泛：ADRC适用于各种类型的控制系统，如运动控制、电力系统、机器人控制等。

MATLAB ADRC的实现步骤包括：系统建模、ADRC参数设计、扰动观测器设计、控制器设计等。通过MATLAB工具箱中丰富的函数和工具，可以方便地实现ADRC算法。

总之，MATLAB ADRC是一种有效的自适应控制算法，在实时控制系统中具有广泛的应用价值。通过对系统扰动的实时估计和补偿，能够实现对系统的精确控制，提高系统的稳定性和鲁棒性。

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值