PID控制算法一勺烩 从模型到实现再到口诀已经把帖子编辑好了，这回可以看了。

一、PID的数学模型

在工业应用中PID及其衍生算法是应用最广泛的算法之一，是当之无愧的万能算法，如果能够熟练掌握PID算法的设计与实现过程，对于一般的研发人员来讲，应该是足够应对一般研发问题了，而难能可贵的是，在很多控制算法当中，PID控制算法又是最简单，最能体现反馈思想的控制算法，可谓经典中的经典。经典的未必是复杂的，经典的东西常常是简单的，而且是最简单的。PID算法的一般形式：

; b0 @' c  o; |5 I* @# E

PID算法通过误差信号控制被控量，而控制器本身就是比例、积分、微分三个环节的加和。这里我们规定（在t时刻）：

二、PID算法的数字离散化

假设采样间隔为T，则在第K个T时刻：

偏差=

! D8 ?" o, W$ U

积分环节用加和的形式表示，即

+ E( I9 m. S( s2 l) H6 M

微分环节用斜率的形式表示，即

PID算法离散化后的式子：

则可表示成为：

9 Q% E+ u) s1 M3 _& h' o! e( C

其中式中：

$ t' Q$ |' u$ ~  q# |

比例参数控制器的输出与输入偏差值成比例关系。系统一旦出现偏差，比例调节立即产生调节作用以减少偏差。特点：过程简单快速、比例作用大，可以加快调节，减小误差；但是使系统稳定性下降，造成不稳定，有余差。

积分参数：积分环节主要是用来消除静差，所谓静差，就是系统稳定后输出值和设定值之间的差值，积分环节实际上就是偏差累计的过程，把累计的误差加到原有系统上以抵消系统造成的静差。

微分参数：微分信号则反应了偏差信号的变化规律，或者说是变化趋势，根据偏差信号的变化趋势来进行超前调节，从而增加了系统的快速性。

: V1 e9 n$ v" s- x; p

PID的基本离散表示形式如上。目前的这种表述形式属于位置型PID，另外一种表述方式为增量式PID，由上述表达式可以轻易得到：

) v3 q+ f( G! h. b* ~

那么：

% [  D4 @  U- q2 ^) G

上式就是离散化PID的增量式表示方式，由公式可以看出，增量式的表达结果和最近三次的偏差有关，这样就大大提高了系统的稳定性。需要注意的是最终的输出结果应该为：

输出量 = + 增量调节值

三、PID的C语言实现

1.位置式PID的C语言实现

上边已经抽象出了位置性PID和增量型PID的数学表达式，这里重点讲解C语言代码的实现过程。

第一步：定义PID变量结构体，代码如下：

1. struct t_pid{
   
2.     float SetSpeed;         //定义设定值
   
3.     float ActualSpeed;       //定义实际值
   
4.     float err;            //定义偏差值
   
5.     float err_last;         //定义上一个偏差值
   
6.     float Kp,Ki,Kd;         //定义比例、积分、微分系数
   
7.     float voltage;         //定义电压值（控制执行器的变量）
   9 m& _4 R! T. f
8.     float integral;         //定义积分值
   1 T& [& _1 f% ]. I0 B  Q) e
9. }pid;

复制代码

( T% K, S: b' }( z- m

第二部：初始化变量，代码如下：

1. void PID_init(){
   
2.     pid.SetSpeed=0.0;
   ; v+ _/ o: W; \; o7 U+ k
3.     pid.ActualSpeed=0.0;
   
4.     pid.err=0.0;
   
5.     pid.err_last=0.0;
   
6.     pid.voltage=0.0;
   6 Y' }! H, h: ]
7.     pid.integral=0.0;
   . ]% S4 U; b9 I* U. t% h( n
8.     pid.Kp=0.2;
   
9.     pid.Ki=0.015;
   6 F2 j* H- S) r& ^
10.     pid.Kd=0.2;
    9 F6 n, n2 b# {% h* x  a3 o. i
11. }

复制代码

* ^* i  x9 x/ m' S' v( B8 l

统一初始化变量，尤其是Kp,Ki,Kd三个参数，调试过程当中，对于要求的控制效果，可以通过调节这三个量直接进行调节。

第三步：编写控制算法，代码如下：

1. float PID_realize(float speed){
   5 F) c2 E$ z% Y7 I- k1 H
2.     pid.SetSpeed=speed;
   
3.     pid.err=pid.SetSpeed-pid.ActualSpeed;
   0 M$ v6 _, n5 v7 B1 |  C/ K5 v! C
4.     pid.integral+=pid.err;
   * V8 O6 t7 l( G# X- S: k) d9 H
5.     pid.voltage=pid.Kp*pid.err+pid.Ki*pid.integral+pid.Kd*(pid.err-pid.err_last);
   
6.     pid.err_last=pid.err;
   . y$ g5 l# T( B( K
7.     pid.ActualSpeed=pid.voltage*1.0;
   
8.     return pid.ActualSpeed;
   % s; B6 W" ?" @$ T5 f
9. }

复制代码

注意：这里用了最基本的算法实现形式，没有考虑死区问题，没有设定上下限，只是对公式的一种直接的实现，后面的介绍当中还会逐渐的对此改进。

到此为止，PID的基本实现部分就初步完成了。下面是测试代码：

1. int main(){
   % }7 a& k2 _# m/ H6 \, \% O
2.     PID_init();
   ) {6 f0 l& ^' @& f7 A- a, G! n: e
3.     int count=0;
   . o. g+ V4 e3 n- F% y6 x
4.     while(count<1000)
   ) T/ P- C* q0 D- R; t' B  m! {
5.     {
   
6.         float speed=PID_realize(200.0);
   
7.         printf("%f\n",speed);
   
8.         count++;
   : L8 c6 |. [( b! G& r- i
9.     }
   
10. return 0;
    
11. }

复制代码

0 i$ B2 K4 J2 M6 J  @8 m

2.增量型PID的C语言实现

6 i7 ]5 b& `2 @3 U

上一节中介绍了最简单的位置型PID的实现手段，这一节讲解增量式PID的实现方法。
! e1 z  r- m: [2 q- h. P

" {5 v* \. x: q/ j& |/ U* p% ?: B

1. #include<stdio.h>
   
2. #include<stdlib.h>
   # S( W& {4 x) }/ _3 m, X2 r
3. 
   
4. struct t_pid{
   ( `# k2 c0 {4 I3 h" }' w
5.     float SetSpeed;          //定义设定值
   
6.     float ActualSpeed;        //定义实际值
   & A! g) o) q- x, ~
7.     float err;             //定义偏差值
   ; }$ T$ @+ r0 Z5 Z7 u" A" \
8.     float err_next;          //定义上一个偏差值
   . q0 B5 _, \$ Q& S/ ]$ A
9.     float err_last;          //定义最上前的偏差值
   
10.     float Kp,Ki,Kd;          //定义比例、积分、微分系数
    
11. }pid;
    
12. 
    5 ?: _; e  E( n3 p
13. void PID_init(){
    * r. A9 z, [4 Y0 |- I2 q, H6 b
14.     pid.SetSpeed=0.0;
    
15.     pid.ActualSpeed=0.0;
    
16.     pid.err=0.0;
    
17.     pid.err_last=0.0;
    3 d2 S7 u6 z+ j2 E2 Z9 _; E
18.     pid.err_next=0.0;
    
19.     pid.Kp=0.2;
    : `+ A: Y6 @+ x; i% t
20.     pid.Ki=0.015;
    
21.     pid.Kd=0.2;
    , \. P' C2 V$ Y' r
22. }
    4 s9 `# |: L" z5 x
23. 
    - L% _! o, k4 ~& G
24. float PID_realize(float speed){
    
25.     pid.SetSpeed=speed;
    
26.     pid.err=pid.SetSpeed-pid.ActualSpeed;
    & T' B$ q  x6 X# d% u
27.     float incrementSpeed=pid.Kp*(pid.err-pid.err_next)+pid.Ki*pid.err+pid.Kd*(pid.err-2*pid.err_next+pid.err_last);
    
28.     pid.ActualSpeed+=incrementSpeed;
    1 A# c5 u/ [$ N8 j* M
29.     pid.err_last=pid.err_next;
    # u3 R4 t: X. B7 v1 L0 m, H
30.     pid.err_next=pid.err;
      f0 j$ J1 _9 c% o2 y6 o
31.     return pid.ActualSpeed;
    
32. }
    
33. 
    % _- i- P6 \! D0 A6 H5 h9 ]
34. int main(){
    % l' H6 M  u: N* L
35.     PID_init();
    
36.     int count=0;
    
37.     while(count<1000)
    
38.     {
    
39.         float speed=PID_realize(200.0);
    ! ^" K' M; z$ o
40.         printf("%f\n",speed);
    
41.         count++;
    
42.     }
    : y( f" ?- u/ y
43.     return 0;
    . W2 `) [4 @  j( u5 v8 {. j% e
44. }
    

复制代码

) b- v+ R+ w. j- j( l$ a

3.积分分离的PID控制算法   

在普通PID控制中，引入积分环节的目的，主要是为了消除静差，提高控制精度。但是在启动、结束或大幅度增减设定时，短时间内系统输出有很大的偏差，会造成PID运算的积分积累，导致控制量超过执行机构可能允许的最大动作范围对应极限控制量，从而引起较大的超调，甚至是震荡，这是绝对不允许的。

为了克服这一问题，引入了积分分离的概念，其基本思路是 当被控量与设定值偏差较大时，取消积分作用; 当被控量接近给定值时，引入积分控制，以消除静差，提高精度。其具体实现代码如下：

pid.Kp=0.2;
6 j" x9 Z) \. v: E& k' V6 R    pid.Ki=0.04;
    pid.Kd=0.2;  //初始化过程

if(abs(pid.err)>200)
    {
    index=0;
: L% S5 H1 E" I2 j$ u* R9 {4 H    }else{
2 g1 L/ M4 e' Y& W2 u    index=1;
  S+ N3 V3 f0 Y0 q' G+ c    pid.integral+=pid.err;
& V8 k# p& G! w3 P    }
    pid.voltage=pid.Kp*pid.err+index*pid.Ki*pid.integral+pid.Kd*(pid.err-pid.err_last);    //算法具体实现过程

4.抗积分饱和的PID控制算法C语言实现

所谓的积分饱和现象是指如果系统存在一个方向的偏差，PID控制器的输出由于积分作用的不断累加而加大，从而导致执行机构达到极限位置，若控制器输出U(k)继续增大，执行器开度不可能再增大，此时计算机输出控制量超出了正常运行范围而进入饱和区。一旦系统出现反向偏差，u(k)逐渐从饱和区退出。进入饱和区越深则退出饱和区时间越长。在这段时间里，执行机构仍然停留在极限位置而不随偏差反向而立即做出相应的改变，这时系统就像失控一样，造成控制性能恶化，这种现象称为积分饱和现象或积分失控现象。

/ d8 q" a% Q$ `( r! x  W$ n6 r2 I

防止积分饱和的方法之一就是抗积分饱和法，该方法的思路是在计算u(k)时，首先判断上一时刻的控制量u(k-1)是否已经超出了极限范围： 如果u(k-1)>umax，则只累加负偏差; 如果u(k-1)<umin，则只累加正偏差。从而避免控制量长时间停留在饱和区。

1. struct t_pid{
   
2.     float SetSpeed;            //定义设定值
   0 J. o2 L/ n: n
3.     float ActualSpeed;        //定义实际值
   . `  j3 O* @+ T" u- d& U8 |
4.     float err;                //定义偏差值
     r1 M0 h( x+ E
5.     float err_last;            //定义上一个偏差值
   ) T7 Z/ h3 o( J5 q
6.     float Kp,Ki,Kd;            //定义比例、积分、微分系数
     E: J; Q; J+ p. ]/ r$ t0 W: i5 r8 M. S
7.     float voltage;            //定义电压值（控制执行器的变量）
   
8.     float integral;            //定义积分值
   
9.     float umax;
   1 x+ s0 B( N% q
10.     float umin;
    
11. }pid;
    ) r# q* q/ W6 l' C2 Z6 O
12. 
      z8 z; _. i: E7 F' N
13. void PID_init(){
    
14.     pid.SetSpeed=0.0;
    & W  Y  Z' S  ]
15.     pid.ActualSpeed=0.0;
    
16.     pid.err=0.0;
    
17.     pid.err_last=0.0;
    5 x, I+ l/ I0 r- U& b" u; j
18.     pid.voltage=0.0;
    
19.     pid.integral=0.0;
    2 {6 j8 }$ f+ t  B
20.     pid.Kp=0.2;
    
21.     pid.Ki=0.1;       //注意，和上几次相比，这里加大了积分环节的值
    
22.     pid.Kd=0.2;
    : n, n  @: H4 X/ ?  D
23.     pid.umax=400;
    ! P, W4 T9 B. a! ?! }' \
24.     pid.umin=-200;
    
25. }
    . t9 d' O7 e: c3 P0 N5 w$ s
26. float PID_realize(float speed){
    
27.     int index;
    2 a0 G" C$ s2 }1 n3 A
28.     pid.SetSpeed=speed;
    9 \# u5 B- a4 U: p$ e  E% l7 U
29.     pid.err=pid.SetSpeed-pid.ActualSpeed;
    
30.    if(pid.ActualSpeed>pid.umax)  //灰色底色表示抗积分饱和的实现
    
31.     {
    
32.        if(abs(pid.err)>200)      //蓝色标注为积分分离过程
    
33.         {
    6 O: r* D7 A. b
34.             index=0;
    " `: [" i0 |# O. Z
35.         }else{
    2 ?+ D6 f3 Y# V$ k: W! R5 ]
36.             index=1;
    5 G9 N7 W$ y; t5 I6 ?$ s$ H: M# U
37.             if(pid.err<0)
    ! E5 t1 Y9 U2 Y; a7 D
38.             {
    
39.             pid.integral+=pid.err;
    
40.             }
    
41.         }
    
42.     }else if(pid.ActualSpeed<pid.umin){
    
43.         if(abs(pid.err)>200)      //积分分离过程
    : x, {% Z  m. j8 F- F1 N
44.         {
    
45.             index=0;
    * r! P$ [2 H7 k) b- d6 ?
46.         }else{
    1 m- D* w# D" R- c- C% t
47.             index=1;
    
48.             if(pid.err>0)
    
49.             {
    ' T& P( U2 Y3 @: E
50.             pid.integral+=pid.err;
    9 l" d4 |& f) N7 H
51.             }
    
52.         }
    1 U! n  {# v4 a- \
53.     }else{
    
54.         if(abs(pid.err)>200)                 //积分分离过程
    % e+ g2 `; {2 B2 _/ C1 n& u, }; q
55.         {
    
56.             index=0;
    
57.         }else{
    ; s) Y' U/ ?9 e
58.             index=1;
    3 |3 V5 J% T: H3 H# o; ^: \: n
59.             pid.integral+=pid.err;
    
60.         }
    
61.     }
    
62.     pid.voltage=pid.Kp*pid.err+index*pid.Ki*pid.integral+pid.Kd*(pid.err-pid.err_last);
    
63.     pid.err_last=pid.err;
    
64.     pid.ActualSpeed=pid.voltage*1.0;
    
65.     return pid.ActualSpeed;
    7 I" N) [# T* t4 x. l' ]7 t2 @
66. }
    

复制代码

- ]6 i& S, M1 g/ A: `5 ]0 M( `* G

5.梯形积分的PID控制算法

先看一下梯形算法的积分环节公式

作为PID控制律的积分项，其作用是消除余差，为了尽量减小余差，应提高积分项运算精度，为此可以将矩形积分改为梯形积分，具体实现的语句为：

+ V% f( \; }& U! M  x1 W5 m# z

1. pid.voltage=pid.Kp*pid.err+index*pid.Ki*pid.integral/2+pid.Kd*(pid.err-pid.err_last);  //梯形积分

复制代码

' D, K( a# C! g; x5 R) L

6.变积分的PID控制算法

变积分PID可以看成是积分分离的PID算法的更一般的形式。在普通的PID控制算法中，由于积分系数是常数，所以在整个控制过程中，积分增量是不变的。但是，系统对于积分项的要求是，系统偏差大时，积分作用应该减弱甚至是全无，而在偏差小时，则应该加强。积分系数取大了会产生超调，甚至积分饱和，取小了又不能短时间内消除静差。因此，根据系统的偏差大小改变积分速度是有必要的。

: n$ e3 R8 f( j& T

变积分PID的基本思想是设法改变积分项的累加速度，使其与偏差大小相对应：偏差越大，积分越慢; 偏差越小，积分越快。

这里给积分系数前加上一个比例值index：

$ G; s7 J  S0 V1 j1 G' K# f

1. 当abs(err)<180时，index=1;
   
2.    当180<abs(err)<200时，index=（200-abs(err)）/20;
   
3.    当abs(err)>200时，index=0;
   
4.    最终的比例环节的比例系数值为ki*index;
   
5.    具体PID实现代码如下：
   : E, {5 U& V) ~
6.     pid.Kp=0.4;
   
7.     pid.Ki=0.2;    //增加了积分系数
   + C2 b- a' @. a2 v8 _* t# ~6 A
8.     pid.Kd=0.2;
   
9.    float PID_realize(float speed){
   
10.     float index;
    ; T! L' P8 D7 d( c+ B- ?2 S( _6 y
11.     pid.SetSpeed=speed;
    4 x7 k8 \8 y$ L: P- J2 ]
12.     pid.err=pid.SetSpeed-pid.ActualSpeed;
    
13.     if(abs(pid.err)>200)           //变积分过程
    . u- ^' X0 q: g- F& s
14.     {
    # S. Q+ E& |( L
15.     index=0.0;
    ! s( h# i8 O& k3 A/ T- L& Q- _
16.     }else if(abs(pid.err)<180){
    
17.     index=1.0;
    : r) @" \0 ~5 l# G9 |/ |
18.     pid.integral+=pid.err;
    
19.     }else{
    , E6 w" Y( S: T# b* N* G( _  H
20.     index=(200-abs(pid.err))/20;
    ! T9 o6 Z7 Q1 r$ v, d: e% R! _
21.     pid.integral+=pid.err;
    / x6 M% x* w* o' x* D4 H4 g
22.     }
    
23.     pid.voltage=pid.Kp*pid.err+index*pid.Ki*pid.integral+pid.Kd*(pid.err-pid.err_last);
    6 Y; G) t. _% e8 Z9 a
24.     pid.err_last=pid.err;
    
25.     pid.ActualSpeed=pid.voltage*1.0;
    % S: S% `6 w) U( D9 M
26.     return pid.ActualSpeed;
    ( J, v- r0 U% v% M& `
27. }

复制代码

( {8 E, a3 k0 Y

! w$ b1 @; j" A8 a* W+ c

7.专家PID和模糊PID   

从前面的讲解中不难看出，PID的控制思想非常简单，其主要问题点和难点在于比例、积分、微分环节上的参数整定过程，对于执行器控制模型确定或者控制模型简单的系统而言，参数的整定可以通过计算获得，对于一般精度要求不是很高的执行器系统，可以采用拼凑的方法进行实验型的整定。

1 ]) c3 W- d1 }$ d# K

然而，在实际的控制系统中，线性系统毕竟是少数，大部分的系统属于非线性系统，或者说是系统模型不确定的系统，如果控制精度要求较高的话，那么对于参数的整定过程是有难度的。专家PID和模糊PID就是为满足这方面的需求而设计的。专家算法和模糊算法都归属于智能算法的范畴，智能算法最大的优点就是在控制模型未知的情况下，可以对模型进行控制。这里需要注意的是，专家PID也好，模糊PID也罢，绝对不是专家系统或模糊算法与PID控制算法的简单加和，他是专家系统或者模糊算法在PID控制器参数整定上的应用。也就是说，智能算法是辅助PID进行参数整定的手段。

  b: O: ~- J: b0 [  Y$ f

专家系统、模糊算法，需要参数整定就一定要有整定的依据，也就是说什么情况下整定什么值是要有依据的，这个依据是一些逻辑的组合，只要找出其中的逻辑组合关系来，这些依据就再明显不过了。下面先说一下专家PID的C语言实现。正如前面所说，需要找到一些依据，还得从PID系数本身说起。

0 u/ N2 U- J+ t2 k: ]& r' k9 [8 \

(1).比例系数的作用是加快系统的响应速度，提高系统的调节精度。越大，系统的响应速度越快，系统的调节精度越高，但是容易产生超调，甚至会使系统不稳定。取值过小，则会降低调节精度，使响应速度缓慢，从而延长调节时间，是系统静态、动态特性变差；

, r& |3 ~/ L0 i/ Z$ d- w# j6 u

(2).积分作用系数的作用是消除系统的稳态误差。越大，系统的静态误差消除的越快，但是过大，在响应过程的初期会产生积分饱和的现象，从而引起响应过程的较大超调。若过小，将使系统静态误差难以消除，影响系统的调节精度；

& @5 M  i5 J' j0 D  k

(3).微分系数的作用是改善系统的动态特性，其作用主要是在响应过程中抑制偏差向任何方向的变化，对偏差变化进行提前预报。但是过大，会使响应过程提前制动，从而延长调节时间，而且会降低系统的抗干扰性。

反应系统性能的两个参数是系统误差e和误差变化律，这点还是好理解的：

+ I- P' k0 b. I

首先我们规定一个误差的极限值，假设为Mmax；规定一个误差的比较大的值，假设为Mmid；规定一个误差的较小值，假设为Mmin；

当abs（e）>Mmax时，说明误差的绝对值已经很大了，不论误差变化趋势如何，都应该考虑控制器的输入应按最大（或最小）输出，以达到迅速调整误差的效果，使误差绝对值以最大的速度减小。此时，相当于实施开环控制。

当e*ec>0时，说明误差在朝向误差绝对值增大的方向变化，此时，如果abs(e)>Mmid，说明误差也较大，可考虑由控制器实施较强的控制作用，以达到扭转误差绝对值向减小的方向变化，并迅速减小误差的绝对值。此时如果abs(e)<Mmid，说明尽管误差是向绝对值增大的方向变化，但是误差绝对值本身并不是很大，可以考虑控制器实施一般的控制作用，只需要扭转误差的变化趋势，使其向误差绝对值减小的方向变化即可。

当e*err<0且e*err(k-1)>0或者e=0时，说明误差的绝对值向减小的方向变化，或者已经达到平衡状态，此时保持控制器输出不变即可。

当e*err<0且e*err(k-1)<0时，说明误差处于极限状态。如果此时误差的绝对值较大，大于Mmin，可以考虑实施较强控制作用。如果此时误差绝对值较小，可以考虑实施较弱控制作用。

2 D% x7 H; d( ^1 x1 h; U8 e0 K

当abs(e)<Mmin时，说明误差绝对值很小，此时加入积分，减小静态误差。

上面的逻辑判断过程，实际上就是对于控制系统的一个专家判断过程。

实际上模糊算法属于智能算法，智能算法也可以叫非模型算法，智能算法包含了专家系统、模糊算法、遗传算法、神经网络算法等。其实这其中的任何一种算法都可以跟PID去做结合，而选择的关键在于，处理的实时性能不能得到满足。当我们处理器的速度足够快速时，我们可以选择更为复杂的、精度更加高的算法。但是，控制器的处理速度限制了我们算法的选择。当然，成本是限制处理器速度最根本的原因。模糊PID适应一般的控制系统是没有问题。

& o; q% i6 g) H, k+ x

模糊算法其实并不模糊。模糊算法其实也是逐次求精的过程。这里举个例子说明。我们设计一个倒立摆系统，假如摆针偏差＜5°，我们说它的偏差比较“小”；摆针偏差在5°和10°之间，我们说它的偏差处于“中”的状态；当摆针偏差＞10°的时候，我们说它的偏差有点儿“大”了。对于“小”、“中”、“大”这样的词汇来讲，他们是精确的表述，可问题是如果摆针偏差是3°呢，那么这是一种什么样的状态呢。我们可以用“很小”来表述它。如果是7°呢，可以说它是“中”偏“小”。那么如果到了80°呢，它的偏差可以说“非常大”。而我们调节的过程实际上就是让系统的偏差由非常“大”逐渐向非常“小”过度的过程。当然，我们系统这个调节过程是快速稳定的。通过上面的说明，可以认识到，其实对于每一种状态都可以划分到大、中、小三个状态当中去，只不过他们隶属的程度不太一样，比如6°隶属于小的程度可能是0.3，隶属于中的程度是0.7，隶属于大的程度是0。这里实际上是有一个问题的，就是这个隶属的程度怎么确定？这就要求我们去设计一个隶属函数。详细内容可以查阅相关的资料，这里没有办法那么详细的说明了。那么，知道了隶属度的问题，就可以根据目前隶属的程度来控制电机以多大的速度和方向转动了，当然，最终的控制量肯定要落实在控制电压上。这点可以很容易的想想，我们控制的目的就是让倒立摆从隶属“大”的程度为1的状态，调节到隶属“小”的程度为1的状态。当隶属大多一些的时候，我们就加快调节的速度，当隶属小多一些的时候，我们就减慢调节的速度，进行微调。可问题是，大、中、小的状态是汉字，怎么用数字表示，进而用程序代码表示呢？其实我们可以给大、中、小三个状态设定三个数字来表示，比如大表示用3表示，中用2表示，小用1表示。那么我们完全可以用1*0.3+2*0.7+3*0.0=1.7来表示它，当然这个公式也不一定是这样的，这个公式的设计是系统模糊化和精确化的一个过程，读者也可参见相关文献理解。但就1.7这个数字而言，可以说明，目前6°的角度偏差处于小和中之间，但是更偏向于中。我们就可以根据这个数字来调节电机的转动速度和时间了。当然，这个数字与电机转速的对应关系，也需要根据实际情况进行设计和调节。

前面一个例子已经基本上说明了模糊算法的基本原理了。可是实际上，一个系统的限制因素常常不是一个。上面的例子中，只有偏差角度成为了系统调节的参考因素。而实际系统中，比如PID系统，我们需要调节的是比例、积分、微分三个环节，那么这三个环节的作用就需要我们认清，也就是说，我们需要根据超调量、调节时间、震荡情况等信息来考虑对这三个环节调节的比重，输入量和输出量都不是单一的，可是其中必然有某种内在的逻辑联系。所以这种逻辑联系就成为我们设计工作的重点了。

四、PID算法参数整定方法

1.临界比例度法

（1）将调节器的积分时间置于最大，微分时间置零，比例度δ适当，平衡操作一段时间，把系统投入自动运行。

（2）将比例度δ逐渐减小，得到等幅振荡过程，记下临界比例度和临界振荡周期值。

（3）根据和值，采用经验公式，计算出调节器各个参数，即δ、、的值。

（4）按“先P后I最后D”的操作程序将调节器整定参数调到计算值上。若还不够满意，可再作进一步调整。

8 L6 b  `7 F, A7 a) |1 k

临界振荡整定计算公式

2.衰减曲线法

在纯比例作用下，由大到小调整比例度以得到具有衰减比（4：1）的过渡过程，记下此时的比例度及振荡周期，根据经验公式，求出相应的积分时间和微分时间。

衰减曲线法控制器参数计算表

9 m4 f/ |% ~  F9 R0 S7 P6 Z! o

Note1).反应较快的控制系统，要认定4：1衰减曲线和读出Ts比较困难，此时，可用记录来回摆动两次就达到稳定作为4：1衰减过程。 (2).在生产过程中，负荷变化会影响过程特性。当负荷变化较大时，必须重新整定调节器参数值。 (3).若认为4：1衰减太慢，宜应用10：1衰减过程。对于10：1衰减曲线法整定调节器参数的步骤与上述完全相同，仅仅采用计算公式有些不同。

' _! `) \1 J# _% D! \

3.经验法

根据经验先将控制器参数放在某些数值上，直接在闭合的控制系统中通过改变给定值以施加干扰，看输出曲线的形状，以δ、、，对控制过程的规律为指导，调整相应的参数进行凑试，直到合适为止。

   

长期的生产实践中总结出来的参数表

1 `5 B: a2 y' ^- h" G* R

4.经验口诀

参数整定找最佳，从小到大顺序查。

先是比例后积分，最后再把微分加。

曲线振荡很频繁，比例度盘要放大。

曲线漂浮绕大湾，比例度盘往小扳。

曲线偏离回复慢，积分时间往下降。

曲线波动周期长，积分时间再加长。

曲线振荡频率快，先把微分降下来。

动差大来波动慢。微分时间应加长。

理想曲线两个波，前高后低4比1。

一看二调多分析，调节质量不会低。

' B2 \% x* J9 X! P$ o; S

谢谢分享                              

zero99 发表于 2017-2-24 15:32
- i! {1 m. L5 h谢谢分享，微信的图片看不到，是不是不能引用的？

应该是，我转成其他形式也是缺少东西，这个写的挺好的，所以转一下

黑夜之狼 发表于 2017-2-24 22:31
不错的东西，准备用PID来控温，先收藏了，谢谢！

# u- l+ r$ X9 n$ z看能不能整成文档上传一下

虽然是转载，但是也要支持一个！！！

谢谢分享，微信的图片看不到，是不是不能引用的？

你打印成pdf试一试，看能不能编程文档。

我打印成XPS、转成PDF都少一部分

不错的东西，准备用PID来控温，先收藏了，谢谢！

谢谢分享了

帖子这回编辑好了，方便查看了

你打印成pdf试一试，看能不能编程文档

努力的人 发表于 2017-2-25 10:58
+ v2 I0 g+ C, a' P$ D9 q看能不能整成文档上传一下

9 d; v6 V: Y  O! m# P* T7 B嗯，还在消化当中

感谢楼主分享，就是有些图片看不到

anobodykey 发表于 2017-2-26 20:55
/ E! C& b$ X2 K$ m  R; O感谢楼主分享，就是有些图片看不到

都可以看了了