PID 控制算法 | 模糊控制 | 控制规则

标签：输出 控制器 模糊 模糊控制 控制 PID 控制算法 0.5

注：本文为几位功夫博主关于 PID 控制算法的几篇合辑。
知识点交集未去重，如有内容异常请看原文。

---

控制算法（一）—— PID 控制算法

fxfreefly 于 2020-03-17 17:25:43 发布

比例积分微分控制，简称 PID 控制，其中 P 表示比例、I 表示积分、D 表示微分。PID 控制算法是最早发展起来的控制策略之一，由于其算法简单、鲁棒性好和可靠性高，被广泛应用于工业过程控制。而且也衍生出多种相关的控制算法：P 控制、PI 控制、PD 控制、增量式 PID 控制、模糊 PID 控制等。虽然这些算法各不相同，但都是基于最基本的 PID 控制算法为原型的。

下图为 PID 控制的示意图

其中 r (t) 为被控对象状态的期望值，y (t) 为被控对象状态的实际值，e (t) 为被控对象期望值与实际值之间的偏差，偏差输入给 P、I、D 三个控制器。、、 分别为比例、积分和微分参数，它们是 PID 控制的基本参数。经过 P、I、D 三个控制器输出的值加和生成 u (t)，u (t) 为对被控对象的控制量。u (t) 作用在被控对象上导致被控对象的状态 y (t) 改变。

下面我们来分析一下 P、I、D 三个控制的具体作用。

1、P 控制

P 控制按偏差 e (t) 的比例关系对被控对象进行控制，偏差一旦产生，控制器立即产生控制作用，以减小偏差。当仅有比例控制时系统输出存在稳态误差。

P 参数越大，比例作用越强，动态响应越快，消除误差的能力越强。但实际系统是有惯性的，控制输出变化后，实际 y (t) 值变化还需等待一段时间才会缓慢变化。由于实际系统是有惯性的，比例作用不宜太强，比例作用太强会引起系统振荡不稳定。P 参数的大小应在以上定量计算的基础上根据系统响应情况，进行调试决定，通常将 P 参数由大向小调，以能达到最快响应又无超调为最佳参数。

P 控制比较容易理解，举一个简单的控制，比如一个电控水温加热系统，期望水温为 80 度。如果当前实际水温小于 80 度，比如是 60 度，则偏差 e (t)=20，则 P 控制用 20 乘以 K p K_{p} Kp​，得到一个正的控制量，这个控制实际上是电控加热的功率附加量。比如我们将水温维持在 80 度需要的加热功率为 X X X，则在这种情况下，加热的控制量为

X + 20 ∗ K p X+20\ast K_{p} X+20∗Kp​

如果偏差越大，则加热功率的调节轮越大。如果当前实际水温为 90 度，则偏差 e (t)=-10，则加热的功率控制量为

X − 10 ∗ K p X-10\ast K_{p} X−10∗Kp​

偏差越大，则对 X X X 减小的越多。

2、I 控制

I 控制器的输出与输入误差信号的积分成正比关系。I 控制主要用于消除静态误差。

比例作用的输出与误差的大小成正比，用数学表达式表示为： u p = K p e u_p = K_p e up​=Kp​e （其中 u p u_p up​ 为比例作用输出， K p K_p Kp​ 为比例系数， e e e 为误差），误差越大，输出越大，误差越小，输出越小，误差为零，输出为零。由于没有误差时输出为零，因此比例调节不可能完全消除误差。必定会存在一个稳定的误差，以维持一个稳定的输出。这个控制误差称为静态误差，加强比例作用只能减少静态误差，但不能消除静态误差。

为了消除静态误差，引入积分控制，积分作用可以消除静差，以使被控对象的状态 y ( t ) y(t) y(t) 值最后与给定值一致。

积分作用消除静态误差的原理是，只要有误差存在，就对误差进行积分，使输出继续增大或减小，一直到误差为零，积分停止，输出不再变化， y ( t ) y(t) y(t) 值等于 u ( t ) u(t) u(t) 值，达到无差调节的效果。用数学表达式表示积分作用为： u i = ∫ e ( t ) d t u_i=\int e(t)dt ui​=∫e(t)dt （其中 u i u_i ui​ 为积分作用输出， e ( t ) e(t) e(t) 为误差关于时间 t t t 的函数）。

但由于实际系统是有惯性的，控制量变化后， y ( t ) y(t) y(t) 值不会马上变化，须等待一段时间才缓慢变化，因此积分的快慢必须与实际系统的惯性相匹配，惯性大、积分作用就应该弱，积分时间就应该大些。如果积分作用太强，积分输出变化过快，就会引起积分过度的现象，产生积分超调和振荡。

依然用上面的例子进行说明 I 控制的作用。如果在调节过程中，水温维持在 79 79 79 度，一直无法达到 80 80 80 度，此时，如果只有 P P P 控制，则控制量为 X + 1 × K p X + 1\times K_{p} X+1×Kp​ 。可以看到控制量一直不变，温度也一直上不去，这 1 1 1 度的误差就是静态误差。很显然不加大功率水温是不可能上去的。在这种情况下，我们加入 I I I 控制，则控制量变为 X + 1 × K p + ∫ e ( t ) d t X + 1\times K_{p}+\int e(t)dt X+1×Kp​+∫e(t)dt 。加入积分量之后，在原有的控制量基础上加入了积分控制量，而且，稳态误差存在时间越长，积分量越大，控制量也会越大，直到消除稳态误差。

3、D 控制

上面已经分析过，不论比例调节作用，还是积分调节作用都是建立在产生误差后才进行调节以消除误差，都是事后调节，因此这种调节对稳态来说是无差的，对动态来说肯定是有差的，因为对于负载变化或给定值变化所产生的扰动，必须等待产生误差以后，然后再来慢慢调节予以消除。

但一般的控制系统，不仅对稳定控制有要求，而且对动态指标也有要求，通常都要求负载变化或给定调整等引起扰动后，恢复到稳态的速度要快，因此光有比例和积分调节作用还不能完全满足要求，必须引入微分作用。比例作用和积分作用是事后调节，而微分作用则是事前预防控制，即一发现 y (t) 有变大或变小的趋势，马上就输出一个阻止其变化的控制信号，以防止出现过冲或超调等。

D 越大，微分作用越强，D 越小，微分作用越弱。系统调试时通常把 D 从小往大调，具体参数由试验决定。

依然以上面水温的控制为例，如果在加大功率给水加热，水温逐渐上升，每个控制周期增加 1 度，如果没有 D 控制，则温度达到 80 度后，必然会出现超调，然后误差为负后，减小加热功率。如果加入了 D 控制，则会在上面控制量的基础上加入 D 环节 d e ( t ) d t K d \frac {\mathrm {d} e\left ( t \right )}{\mathrm {d} t}K_{d} dtde(t)​Kd​，在水温逐渐上升时 d e ( t ) d t \frac {\mathrm {d} e\left ( t \right )}{\mathrm {d} t} dtde(t)​ 为负值，则相当于在原有控制量的基础上加了一个负的控制量，从而使总的控制量提前减小，以避免水温的超调。

由于 PID 控制应用已经很广泛，前人的经验也有很多可以作为参考，当然也有人总结了很多实用的调试方法。下面奉上几段顺口溜来形象说明 PID 控制，当然这些顺口溜是在网上抄袭的。

比例作用顺口溜

比例州节器，像个放大器；

一个偏差来，放大送出去；

放大是多少，旋钮看仔细；

比例度旋大，放大倍数低。

积分作用顺口溜

重定调节器，累积有本领；

只要偏差在，累积不停止；

累积快与慢，旋钮看仔细；

积分时间长，累积速度低。

微分作用顺口溜

说起微分器，一点不神秘；

阶跃输入来，输出跳上去；

下降快与慢，旋钮看仔细；

微分时间长，下降就慢些。

下面再奉上一段 PID 参数调节经验的顺口溜。

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

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

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

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

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

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

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

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

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

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

控制算法（二）—— 模糊控制算法

fxfreefly 于 2020-03-19 17:24:29 发布

模糊控制是以模糊集理论、模糊语言变量和模糊逻辑推理为基础的一种智能控制方法，它是从行为上模仿人的模糊推理和决策过程的一种智能控制算法。模糊控制首先将操作人员或专家经验编成模糊规则，然后将来自传感器的实时信号模糊化，将模糊化后的信号作为模糊规则的输入，完成模糊推理，将推理后得到的输出量加到执行器上。

模糊控制的过程如下图所示。

上图中，包括了模糊控制的主要过程。关于模糊控制的基本原理，在很多文章中都有介绍，但一般介绍都比较抽象，读者不容易理解。在本文中，我们通过一个简单的例子来进行介绍。

1、模糊化

以水温的电加热为例，我们对模糊控制进行介绍。在一个容器中装满了水，我们要将水维持在一个恒定的温度，比如：60 度。我们控制水温的工具是电加热器。在这个控制系统中，控制算法的输入为温度的偏差，即期望温度与实际温度的插，我们假设这个偏差的范围为 [-20, 20]，我们称它为基本论域。算法的输出为电加热的功率，我们假设它的基本论域为 [0, 2000]，单位是瓦。

我们取输入和输出的模糊集合分别为 { N B , N S , O , P S , P B } ， { N B , N S , O , P S , P B } \{NB, NS, O, PS, PB\}，\{NB, NS, O, PS, PB\} {NB,NS,O,PS,PB}，{NB,NS,O,PS,PB}。其中：

• N B NB NB 表示负大
• N S NS NS 表示负小
• O O O 表示零
• P S PS PS 表示正小
• P B PB PB 表示正大

另外，我们取输入和输出的模糊子集论域为 { − 4 , − 3 , − 2 , − 1 , 0 , 1 , 2 , 3 , 4 } ， { − 3 , − 2 , − 1 , 0 , 1 , 2 , 3 } \{-4, -3, -2, -1, 0, 1, 2, 3, 4\}，\{-3, -2, -1, 0, 1, 2, 3\} {−4,−3,−2,−1,0,1,2,3,4}，{−3,−2,−1,0,1,2,3}。

我们可以得出一般的公式，由基本论域到 [ a , b ] [a, b] [a,b] 模糊子集论域 [ − n , n ] [-n, n] [−n,n] 的转换关系：

y = ( x − ( a + b ) / 2 ) ⋅ 2 n / ( b − a ) y=\left ( x-(a+b)/2 \right )\cdot 2n/(b-a) y=(x−(a+b)/2)⋅2n/(b−a)

通过上面的公式我们可以将基本论域上的精确至映射到模糊子集论域内，接下来我们要通过隶属度关系计算出我们的输入或输出变量对模糊集合的隶属度，这个过程称为模糊化。隶属度关系我们一般通过隶属度图或隶属度表格来表示。如下图所示，为输入的隶属度图。

用表格表示，如下所示。

	-4	-3	-2	-1	0	1	2	3	4
PB	0	0	0	0	0	0	0	0.5	1
PS	0	0	0	0	0	0.5	1	0.5	0
O	0	0	0	0.5	1	0.5	0	0	0
NS	0	0.5	1	0.5	0	0	0	0	0
NB	1	0.5	0	0	0	0	0	0	0

同样，输出的隶属度关系，用表格表示为

	-3	-2	-1	0	1	2	3
PB	0	0	0	0	0	0.5	1
PS	0	0	0	0	0.5	0.5	0
O	0	0	0.5	1	0.5	0	0
NS	0	0.5	0.5	0	0	0	0
NB	1	0.5	0	0	0	0	0

有了上边的关系，我们就可以将控制算法的输入进行模糊化。比如我们期望的温度是 60 度，实际的温度为 45 度，则温度偏差为 15 度，则对应的模糊子集论域上的取值为：

y = ( 15 − ( − 20 + 20 ) / 2 ) ⋅ 2 ⋅ 4 / ( 20 + 20 ) = 3 y=(15-(-20+20)/2)\cdot 2\cdot 4/(20+20)=3 y=(15−(−20+20)/2)⋅2⋅4/(20+20)=3

我们从表中可以看到，3 对应 PB 的隶属度为 0.5，PS 的隶属度为 0.5。这样我们完成了偏差 15 的模糊化。

2、建立模糊控制规则

模糊规则是模糊控制算法的核心，它决定了算法的控制规则。在我们这个例子中，如果偏差很大，我们模糊化后为 PB，则实际温度比期望温度低很多，这是我们需要用很大的功率来加热，所以控制量为 PB；如果实际温度已经达到了期望温度，则输入的温度偏差模糊化后为 O，这时，我们为了维持温度，需要用中等的功率来维持温度，所以控制量为 O。如果输入量为 NB，相应的控制量为 NB。所以根据这个原则，我们可以得到模糊控制规则，如下表。

if（若）	NBe	NSe	Oe	PSe	PBe
then（则）	NBu	NSu	Ou	PSu	PBu

3、求模糊关系

模糊控制规则是一个多条语句，它可以表示为 EXU 上的模糊子集，即模糊关系 R，它通过下面的式子计算。

R = ( N B e ∩ N B u ) ∪ ( N S e ∩ N S u ) ∪ ( O e ∩ O u ) ∪ ( P S e ∩ P S u ) ∪ ( P B e ∩ P B u ) R=\left ( NBe\cap NBu \right )\cup \left ( NSe\cap NSu \right )\cup \left ( Oe\cap Ou \right )\cup \left ( PSe\cap PSu \right )\cup \left ( PBe\cap PBu \right ) R=(NBe∩NBu)∪(NSe∩NSu)∪(Oe∩Ou)∪(PSe∩PSu)∪(PBe∩PBu)

其中， ∩ \cap ∩ 表示求交集，对于两个数值来说，就是取数值小的数值。 ∪ \cup ∪ 表示求并集，对于两个数值来说就是取数值大的数值。NBe、NBu 等为最上面的表格中的隶属度的向量，我们进行计算得到下面的结果。
-==

N B e ∩ N B u = [ 1 0.5 0 0 0 0 0 0 0 ] ∩ [ 1 0.5 0 0 0 0 0 ] = [ 1 0.5 0 0 0 0 0 0.5 0.5 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ] NBe \cap NBu = \begin{bmatrix} 1\\ 0.5\\ 0\\ 0\\ 0\\ 0\\ 0\\ 0\\ 0\end{bmatrix} \cap \begin{bmatrix} 1 \\ 0.5 \\ 0 \\ 0 \\ 0 \\ 0 \\ 0 \end{bmatrix} = \begin{bmatrix} 1 & 0.5 & 0 & 0 & 0 & 0 & 0\\ 0.5 & 0.5 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0 \end{bmatrix} NBe∩NBu= ​10.50000000​ ​∩ ​10.500000​ ​= ​10.50000000​0.50.50000000​000000000​000000000​000000000​000000000​000000000​ ​

N S e ∩ N S u = [ 0 0.5 1 0.5 0 0 0 0 ] ∩ [ 0 0.5 0.5 0 0 0 0 ] = [ 0 0 0 0 0 0 0 0 0.5 0.5 0 0 0 0 0 0.5 0.5 0 0 0 0 0 0.5 0.5 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ] NSe \cap NSu = \begin{bmatrix} 0\\ 0.5\\ 1\\ 0.5\\ 0\\ 0\\ 0\\ 0\end{bmatrix} \cap \begin{bmatrix} 0 \\ 0.5 \\ 0.5 \\ 0 \\ 0 \\ 0 \\ 0 \end{bmatrix} = \begin{bmatrix} 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0.5 & 0.5 & 0 & 0 & 0 & 0\\ 0 & 0.5 & 0.5 & 0 & 0 & 0 & 0\\ 0 & 0.5 & 0.5 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0 \end{bmatrix} NSe∩NSu= ​00.510.50000​ ​∩ ​00.50.50000​ ​= ​000000000​00.50.50.500000​00.50.50.500000​000000000​000000000​000000000​000000000​ ​

O e ∩ O u = [ 0 0 0 0.5 1 0.5 0 0 ] ∩ [ 0 0 0.5 1 0.5 0 0 ] = [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.5 0.5 0.5 0 0 0 0 0.5 1 0.5 0 0 0 0 0.5 0.5 0.5 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ] Oe \cap Ou = \begin{bmatrix} 0\\ 0\\ 0\\ 0.5\\ 1\\ 0.5\\ 0\\ 0\end{bmatrix} \cap \begin{bmatrix} 0 \\ 0 \\ 0.5 \\ 1 \\ 0.5 \\ 0 \\ 0 \end{bmatrix} = \begin{bmatrix} 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0.5 & 0.5 & 0.5 & 0 & 0\\ 0 & 0 & 0.5 & 1 & 0.5 & 0 & 0\\ 0 & 0 & 0.5 & 0.5 & 0.5 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0 \end{bmatrix} Oe∩Ou= ​0000.510.500​ ​∩ ​000.510.500​ ​= ​000000000​000000000​0000.50.50.5000​0000.510.5000​0000.50.50.5000​000000000​000000000​ ​

P S e ∩ P S u = [ 0 0 0 0 0 0.5 1 0.5 0 ] ∩ [ 0 0 0 0 0.5 0.5 0 ] = [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.5 0.5 0 0 0 0 0.5 0.5 0 0 0 0 0 0.5 0.5 0 0 0 0 0 0.5 0.5 0 0 0 0 0 0 0 0 ] PSe \cap PSu = \begin{bmatrix} 0\\ 0\\ 0\\ 0\\ 0\\ 0.5\\ 1\\ 0.5\\ 0\end{bmatrix} \cap \begin{bmatrix} 0 \\ 0 \\ 0 \\ 0 \\ 0.5 \\ 0.5 \\ 0 \end{bmatrix} = \begin{bmatrix} 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0.5 & 0.5\\ 0 & 0 & 0 & 0 & 0.5 & 0.5 & 0\\ 0 & 0 & 0 & 0 & 0.5 & 0.5 & 0\\ 0 & 0 & 0 & 0 & 0.5 & 0.5 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0 \end{bmatrix} PSe∩PSu= ​000000.510.50​ ​∩ ​00000.50.50​ ​= ​000000000​000000000​000000000​000000000​000000.50.50.50​00000.50.50.50.50​00000.50000​ ​

P B e ∩ P B u = [ 0 0 0 0 0 0 0 0.5 1 ] ∩ [ 0 0 0 0 0 0.5 1 ] = [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.5 0.5 0 0 0 0 0 0.5 1 ] PBe \cap PBu = \begin{bmatrix} 0\\ 0\\ 0\\ 0\\ 0\\ 0\\ 0\\ 0.5\\ 1\end{bmatrix} \cap \begin{bmatrix} 0 \\ 0 \\ 0 \\ 0 \\ 0 \\ 0.5 \\ 1 \end{bmatrix} = \begin{bmatrix} 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0.5 & 0.5\\ 0 & 0 & 0 & 0 & 0 & 0.5 & 1 \end{bmatrix} PBe∩PBu= ​00000000.51​ ​∩ ​000000.51​ ​= ​000000000​000000000​000000000​000000000​000000000​00000000.50.5​00000000.51​ ​

将上面的 5 个矩阵求并集计算得到模糊关系如下

R = [ 1 0.5 0 0 0 0 0 0.5 0.5 0.5 0 0 0 0 0 0.5 0.5 0 0 0 0 0 0.5 0.5 0.5 0.5 0 0 0 0 0.5 1 0.5 0 0 0 0 0.5 0.5 0.5 0.5 0 0 0 0 0 0.5 0.5 0 0 0 0 0 0.5 0.5 0.5 0 0 0 0 0 0.5 1 ] R = \begin{bmatrix} 1 & 0.5 & 0 & 0 & 0 & 0 & 0\\ 0.5 & 0.5 & 0.5 & 0 & 0 & 0 & 0\\ 0 & 0.5 & 0.5 & 0 & 0 & 0 & 0\\ 0 & 0.5 & 0.5 & 0.5 & 0.5 & 0 & 0\\ 0 & 0 & 0.5 & 1 & 0.5 & 0 & 0\\ 0 & 0 & 0.5 & 0.5 & 0.5 & 0.5 & 0\\ 0 & 0 & 0 & 0 & 0.5 & 0.5 & 0\\ 0 & 0 & 0 & 0 & 0.5 & 0.5 & 0.5\\ 0 & 0 & 0 & 0 & 0 & 0.5 & 1 \end{bmatrix} R= ​10.50000000​0.50.50.50.500000​00.50.50.50.50.5000​0000.510.5000​0000.50.50.50.50.50​000000.50.50.50.5​00000000.51​ ​

4、模糊决策

模糊控制器的输出为误差向量和模糊关系的合成：

u = e ∘ R u = e\circ R u=e∘R

例如，如果误差为(PS)，则对应的向量

e = [ 0 0 0 0 0 0.5 1 0.5 0 ] e=\begin {bmatrix} 0 & 0 & 0 & 0 & 0 & 0.5 & 1 & 0.5 & 0\end {bmatrix} e=[0​0​0​0​0​0.5​1​0.5​0​]

则

u = e ∘ R = [ 0 0 0 0 0 0.5 1 0.5 0 ] ∘ [ 1 0.5 0 0 0 0 0 0 0 0.5 0.5 0.5 0 0 0 0 0 0 0 0.5 0.5 0.5 0.5 0 0 0 0 0 0 0.5 1 0.5 0 0 0 0 0 0 0.5 0.5 0.5 0.5 0 0 0 0 0 0 0.5 0.5 0.5 0 0 0 0 0 0 0 0.5 1 0.5 0 0 0 0 0 0 0 0.5 0.5 0.5 0 0 0 0 0 0 0 0 0.5 1 ] = [ 0 0 0.5 0.5 0.5 0.5 0.5 ] u=e\circ R=\begin{bmatrix}0\\0\\0\\0\\0\\0.5\\1\\0.5\\0\end{bmatrix}\circ\begin{bmatrix}1&0.5&0&0&0&0&0&0&0\\0.5&0.5&0.5&0&0&0&0&0&0\\0&0.5&0.5&0.5&0.5&0&0&0&0\\0&0&0.5&1&0.5&0&0&0&0\\0&0&0.5&0.5&0.5&0.5&0&0&0\\0&0&0&0.5&0.5&0.5&0&0&0\\0&0&0&0&0.5&1&0.5&0&0\\0&0&0&0&0&0.5&0.5&0.5&0\\0&0&0&0&0&0&0&0.5&1\end{bmatrix}=\begin{bmatrix}0\\0\\0.5\\0.5\\0.5\\0.5\\0.5\end{bmatrix} u=e∘R= ​000000.510.50​ ​∘ ​10.50000000​0.50.50.5000000​00.50.50.50.50000​000.510.50.5000​000.50.50.50.50.500​00000.50.510.50​0000000.50.50​00000000.50.5​000000001​ ​= ​000.50.50.50.50.5​ ​

5、控制量的反模糊化

由上面的计算得到 u = [ 0 0 0.5 0.5 0.5 0.5 0.5 ] u=\begin {bmatrix} 0 & 0 & 0.5 & 0.5 & 0.5 & 0.5 & 0.5 \end {bmatrix} u=[0​0​0.5​0.5​0.5​0.5​0.5​]

这几个系数，对应于模糊子集论域，一般表示为

u = 0 − 3 + 0 − 2 + 0.5 − 1 + 0.5 0 + 0.5 1 + 0.5 2 + 0.5 3 \displaystyle u=\frac {0}{-3}+\frac {0}{-2}+\frac {0.5}{-1}+\frac {0.5}{0}+\frac {0.5}{1}+\frac {0.5}{2}+\frac {0.5}{3} u=−30​+−20​+−10.5​+00.5​+10.5​+20.5​+30.5​

注意这个式子只是一个表示方式，不是除的计算。

一般，我们采用重心发来计算控制量的模糊值，如下进行计算

U = ∑ x i μ N ( x i ) ∑ μ N ( x i ) = − 0.5 × 1 + 0.5 × 0 + 0.5 × 1 + 0.5 × 2 + 0.5 × 3 0.5 + 0.5 + 0.5 + 0.5 + 0.5 = 1 \displaystyle U=\frac {\sum x_{i}\mu _{N}\left ( x_{i} \right )}{\sum \mu _{N}\left ( x_{i} \right )}=\frac {-0.5\times1 + 0.5\times0 + 0.5\times1 + 0.5\times2 + 0.5\times3}{0.5 + 0.5 + 0.5 + 0.5 + 0.5}=1 U=∑μN​(xi​)∑xi​μN​(xi​)​=0.5+0.5+0.5+0.5+0.5−0.5×1+0.5×0+0.5×1+0.5×2+0.5×3​=1

注意这个 u u u 的值是模糊子集论域中的值，它的取值范围是 [ − n , n ] [-n, n] [−n,n]，用项目的公式，可以将它转换为 [ a , b ] [a, b] [a,b] 空间上。

u = a + b 2 + b − a 2 n U \displaystyle u=\frac {a + b}{2}+\frac {b - a}{2n}U u=2a+b​+2nb−a​U

在这个示例中， a = 0 a = 0 a=0， b = 2000 b = 2000 b=2000， n = 3 n = 3 n=3， U = 1 U = 1 U=1。代入公式计算得到 u = 1333 u = 1333 u=1333，即需要用 1333 1333 1333 瓦的功率来进行加热。

---

模糊 PID 控制的规则表一点理解

hasee_z6 已于 2022 - 10 - 27 20:17:12修改

前言

最近在学习模糊 PID 控制，对于模糊 PID 控制的规则表有一点疑惑，然后上网查了一下资料，记录一下。

参考

• 怎么理解模糊 PID 控制表？@人间苦旅 - 知乎

  https://www.zhihu.com/question/52908880/answer/1519061148

过程

模糊 PID 控制器的输入值是偏差 e e e 和偏差变化率 e c ec ec ，经过模糊化处理后，由模糊推理系统进行近似推理，得出在一定偏差和偏差变化率的情况下， K p K_p Kp​ 、 K i K_i Ki​ 、 K d K_d Kd​ 的校正量 Δ K p \Delta K_p ΔKp​ 、 Δ K i \Delta K_i ΔKi​ 、 Δ K d \Delta K_d ΔKd​ ，经过清晰化后与初始 PID 参数相叠加，在系统偏差和偏差变化率的不断变化中实时调节 PID 参数，从而实现 PID 参数的自整定。用数学式表示为:
K p = K p ′ + Δ K p (1) K_p = K_p'+\Delta K_p\tag {1} Kp​=Kp′​+ΔKp​(1)
如下图所示

图中：

• 模糊控制器输出 K p K_p Kp​ 就等于公式 ( 1 ) (1) (1) 中的 Δ K p \Delta K_p ΔKp​ ，也就是校正量。 K p ′ K_p' Kp′​ 就是 PID 控制器 K p K_p Kp​ 的固定参数。

我们来看这张 K p K_p Kp​ 的表

规则应该是误差 E = 测量值（实际值） − 设定值 E = 测量值（实际值） - 设定值 E=测量值（实际值）−设定值 ，而 E C EC EC 就是误差的变化率，表示误差的变化方向。

i f   E = P B ,    E C = P B ,    t h e n   k p = N B if\ E = PB, \,\,EC = PB, \,\,then\ kp = NB if E=PB,EC=PB,then kp=NB

从图中可以看出，误差已经超过设定值（正大），并且误差变化率 E C EC EC 是正的（正大），那么下一时刻的误差还会一直增加（变大）。我们知道 K p K_p Kp​ 过大会引起超调，所以我们要减小 K p K_p Kp​ ，也就是减小 Δ K p \Delta K_p ΔKp​ ，所以 k p = N B kp = NB kp=NB （负大），其余都依次类推。

对于 i f   E = N M ,    E C = P B ,    t h e n   k p = N S ( k p = Z O ) if\ E = NM, \,\, EC = PB, \,\, then\ kp = NS (kp = ZO) if E=NM,EC=PB,then kp=NS(kp=ZO)

我的个人理解是两种都可以，看具体情况。假如说 E C EC EC 变化率往正的方向变得太快，可能会产生超调，所以 k p = N S kp = NS kp=NS ，或者说你觉得这个变化率可以，不会影响，那你就 k p = Z O kp = ZO kp=ZO 。

---

PID 控制算法介绍与 C 程序实现

爱上电路设计 已于 2024-06-04 17:33:19 修改

一、PID（比例积分微分）介绍

PID（比例积分微分）英文全称为 Proportion Integration Differentiation，它是一个数学物理术语。

目前工业自动化水平已成为衡量各行各业现代化水平的一个重要标志。同时，控制理论的发展也经历了古典控制理论、现代控制理论和智能控制理论三个阶段。智能控制的典型实例是模糊全自动洗衣机等。自动控制系统可分为开环控制系统和闭环控制系统。一个控制系统包括控制器、传感器、变送器、执行机构、输入输出接口。控制器的输出经过输出接口、执行机构，加到被控系统上；控制系统的被控量，经过传感器，变送器，通过输入接口送到控制器。不同的控制系统，其传感器、变送器、执行机构是不一样的。比如压力控制系统要采用压力传感器。

电加热控制系统的传感器是温度传感器。

目前，PID 控制及其控制器或智能 PID 控制器（仪表）已经很多，产品已在工程实际中得到了广泛的应用，有各种各样的 PID 控制器产品，各大公司均开发了具有 PID 参数自整定功能的智能调节器 (intelligent regulator)，其中 PID 控制器参数的自动调整是通过智能化调整或自校正、自适应算法来实现。有利用 PID 控制实现的压力、温度、流量、液位控制器，能实现 PID 控制功能的可编程控制器 (PLC)，还有可实现 PID 控制的 PC 系统等等。

可编程控制器 (PLC) 是利用其闭环控制模块来实现 PID 控制，而可编程控制器 (PLC) 可以直接与 ControlNet 相连，如 Rockwell 的 PLC-5 等。还有可以实现 PID 控制功能的控制器，如 Rockwell 的 Logix 产品系列，它可以直接与 ControlNet 相连，利用网络来实现其远程控制功能。

1、开环控制系统

开环控制系统 (open-loop control system) 是指被控对象的输出 (被控制量) 对控制器 (controller) 的输出没有影响。在这种控制系统中，不依赖将被控量反送回来以形成任何闭环回路。

2、闭环控制系统

闭环控制系统 (closed-loop control system) 的特点是系统被控对象的输出 (被控制量) 会反送回来影响控制器的输出，形成一个或多个闭环。闭环控制系统有正反馈和负反馈，若反馈信号与系统给定值信号相反，则称为负反馈 ( Negative Feedback)，若极性相同，则称为正反馈，一般闭环控制系统均采用负反馈，又称负反馈控制系统。

闭环控制系统的例子很多。比如人就是一个具有负反馈的闭环控制系统，眼睛便是传感器，充当反馈，人体系统能通过不断的修正最后作出各种正确的动作。如果没有眼睛，就没有了反馈回路，也就成了一个开环控制系统。另例，当一台真正的全自动洗衣机具有能连续检查衣物是否洗净，并在洗净之后能自动切断电源，它就是一个闭环控制系统。

3、阶跃响应

阶跃响应是指将一个阶跃输入（step function）加到系统上时，系统的输出。稳态误差是指系统的响应进入稳态后，系统的期望输出与实际输出之差。

控制系统的性能可以用稳、准、快三个字来描述。稳是指系统的稳定性 (stability)，一个系统要能正常工作，首先必须是稳定的，从阶跃响应上看应该是收敛的；准是指控制系统的准确性、控制精度，通常用稳态误差来 (Steady-state error) 描述，它表示系统输出稳态值与期望值之差；快是指控制系统响应的快速性，通常用上升时间来定量描述。

4、PID 控制的原理和特点

在工程实际中，应用最为广泛的调节器控制规律为比例、积分、微分控制，简称 PID 控制，又称 PID 调节。PID 控制器问世至今已有近 70 年历史，它以其结构简单、稳定性好、工作可靠、调整方便而成为工业控制的主要技术之一。当被控对象的结构和参数不能完全掌握，或得不到精确的数学模型时，控制理论的其它技术难以采用时，系统控制器的结构和参数必须依靠经验和现场调试来确定，这时应用 PID 控制技术最为方便。即当我们不完全了解一个系统和被控对象，或不能通过有效的测量手段来获得系统参数时，最适合用 PID 控制技术。PID 控制，实际中也有 PI 和 PD 控制。PID 控制器就是根据系统的误差，利用比例、积分、微分计算出控制量进行控制的。

比例（P）控制

比例控制是一种最简单的控制方式。其控制器的输出与输入误差信号成比例关系。当仅有比例控制时系统输出存在稳态误差（Steady-state error）。

积分（I）控制

在积分控制中，控制器的输出与输入误差信号的积分成正比关系。对一个自动控制系统，如果在进入稳态后存在稳态误差，则称这个控制系统是有稳态误差的或简称有差系统（System with Steady-state Error）。为了消除稳态误差，在控制器中必须引入 “积分项”。

积分项对误差取决于时间的积分，随着时间的增加，积分项会增大。这样，即便误差很小，积分项也会随着时间的增加而加大，它推动控制器的输出增大使稳态误差进一步减小，直到等于零。因此，比例 + 积分 (PI) 控制器，可以使系统在进入稳态后无稳态误差。

微分（D）控制

在微分控制中，控制器的输出与输入误差信号的微分（即误差的变化率）成正比关系。自动控制系统在克服误差的调节过程中可能会出现振荡甚至失稳。其原因是由于存在有较大惯性组件（环节）或有滞后 (delay) 组件，具有抑制误差的作用，其变化总是落后于误差的变化。解决的办法是使抑制误差的作用的变化 “超前”，即在误差接近零时，抑制误差的作用就应该是零。

这就是说，在控制器中仅引入 “比例” 项往往是不够的，比例项的作用仅是放大误差的幅值，而目前需要增加的是 “微分项”，它能预测误差变化的趋势，这样，具有比例 + 微分的控制器，就能够提前使抑制误差的控制作用等于零，甚至为负值，从而避免了被控量的严重超调。所以对有较大惯性或滞后的被控对象，比例 + 微分 (PD) 控制器能改善系统在调节过程中的动态特性。

5、PID 控制器的参数整定

PID 控制器的参数整定是控制系统设计的核心内容。它是根据被控过程的特性确定 PID 控制器的比例系数、积分时间和微分时间的大小。PID 控制器参数整定的方法很多，概括起来有两大类：

一是理论计算整定法。它主要是依据系统的数学模型，经过理论计算确定控制器参数。这种方法所得到的计算数据未必可以直接用，还必须通过工程实际进行调整和修改。

二是工程整定方法，它主要依赖工程经验，直接在控制系统的试验中进行，且方法简单、易于掌握，在工程实际中被广泛采用。PID 控制器参数的工程整定方法，主要有临界比例法、反应曲线法和衰减法。

三种方法各有其特点，其共同点都是通过试验，然后按照工程经验公式对控制器参数进行整定。但无论采用哪一种方法所得到的控制器参数，都需要在实际运行中进行最后调整与完善。现在一般采用的是临界比例法。利用该方法进行 PID 控制器参数的整定步骤如下：

(1) 首先预选择一个足够短的采样周期让系统工作；

(2) 仅加入比例控制环节，直到系统对输入的阶跃响应出现临界振荡，记下这时的比例放大系数和临界振荡周期；

(3) 在一定的控制度下通过公式计算得到 PID 控制器的参数。

在实际调试中，只能先大致设定一个经验值，然后根据调节效果修改。

对于温度系统：P（%）20–60，I（分）3–10，D（分）0.5–3

对于流量系统：P（%）40–100，I（分）0.1–1

对于压力系统：P（%）30–70，I（分）0.4–3

对于液位系统：P（%）20–80，I（分）1–5

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

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

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

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

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

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

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

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

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

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

PID 与自适应 PID 的区别：

首先弄清楚什么是自适应控制

在生产过程中为了提高产品质量，增加产量，节约原材料，要求生产管理及生产过程始终处于最优工作状态。因此产生了一种最优控制的方法，这就叫自适应控制。在这种控制中要求系统能够根据被测参数，环境及原材料的成本的变化而自动对系统进行调节，使系统随时处于最佳状态。自适应控制包括性能估计（辨别）、决策和修改三个环节。它是微机控制系统的发展方向。但由于控制规律难以掌握，所以推广起来尚有一些难以解决的问题。

加入自适应的 pid 控制就带有了一些智能特点，像生物一样能适应外界条件的变化。还有自学习系统，就更加智能化了。

二、PID 调试步骤

没有一种控制算法比 PID 调节规律更有效、更方便的了。现在一些时髦点的调节器基本源自 PID。甚至可以这样说：PID 调节器是其它控制调节算法的基础。

为什么 PID 应用如此广泛、又长久不衰？

因为 PID 解决了自动控制理论所要解决的最基本问题，既系统的稳定性、快速性和准确性。调节 PID 的参数，可实现在系统稳定的前提下，兼顾系统的带载能力和抗扰能力，同时，在 PID 调节器中引入积分项，系统增加了一个零积点，使之成为一阶或一阶以上的系统，这样系统阶跃响应的稳态误差就为零。

由于自动控制系统被控对象的千差万别，PID 的参数也必须随之变化，以满足系统的性能要求。这就给使用者带来相当的麻烦，特别是对初学者。下面简单介绍一下调试 PID 参数的一般步骤：

1、负反馈

自动控制理论也被称为负反馈控制理论。首先检查系统接线，确定系统的反馈为负反馈。例如电机调速系统，输入信号为正，要求电机正转时，反馈信号也为正（PID 算法时，误差 = 输入 - 反馈），同时电机转速越高，反馈信号越大。其余系统同此方法。

2、PID 调试一般原则

a. 在输出不振荡时，增大比例增益 P。

b. 在输出不振荡时，减小积分时间常数 Ti。

c. 在输出不振荡时，增大微分时间常数 Td。

3、一般步骤

a. 确定比例增益 P

确定比例增益 P 时，首先去掉 PID 的积分项和微分项，一般是令 Ti=0、Td=0（具体见 PID 的参数设定说明），使 PID 为纯比例调节。输入设定为系统允许的最大值的 60%~70%，由 0 逐渐加大比例增益 P，直至系统出现振荡；再反过来，从此时的比例增益 P 逐渐减小，直至系统振荡消失，记录此时的比例增益 P，设定 PID 的比例增益 P 为当前值的 60%~70%。比例增益 P 调试完成。

b. 确定积分时间常数 Ti

比例增益 P 确定后，设定一个较大的积分时间常数 Ti 的初值，然后逐渐减小 Ti，直至系统出现振荡，之后在反过来，逐渐加大 Ti，直至系统振荡消失。记录此时的 Ti，设定 PID 的积分时间常数 Ti 为当前值的 150%~180%。积分时间常数 Ti 调试完成。

c. 确定微分时间常数 Td

微分时间常数 Td 一般不用设定，为 0 即可。若要设定，与确定 P 和 Ti 的方法相同，取不振荡时的 30%。

d. 系统空载、带载联调，再对 PID 参数进行微调，直至满足要求。

三、PID 控制简介

目前工业自动化水平已成为衡量各行各业现代化水平的一个重要标志。同时，控制理论的发展也经历了古典控制理论、现代控制理论和智能控制理论三个阶段。智能控制的典型实例是模糊全自动洗衣机等。自动控制系统可分为开环控制系统和闭环控制系统。

一个控制系统包括控制器、传感器、变送器、执行机构、输入输出接口。控制器的输出经过输出接口、执行机构，加到被控系统上﹔控制系统的被控量、经过传感器、变送器，通过输入接口送到控制器。不同的控制系统，其传感器、变送器、执行机构是不一样的。比如压力控制系统要采用压力传感器。

电加热控制系统的传感器是温度传感器。目前，PID 控制及其控制器或智能 PID 控制器（仪表）已经很多，产品已在工程实际中得到了广泛的应用，有各种各样的 PID 控制器产品，各大公司均开发了具有 PID 参数自整定功能的智能调节器 (intelligent regulator)，其中 PID 控制器参数的自动调整是通过智能化调整或自校正、自适应算法来实现。有利用 PID 控制实现的压力、温度、流量、液位控制器，能实现 PID 控制功能的可编程控制器 (PLC)，还有可实现 PID 控制的 PC 系统等等。

可编程控制器 (PLC) 是利用其闭环控制模块来实现 PID 控制，而可编程控制器 (PLC) 可以直接与 ControlNet 相连，如 Rockwell 的 PLC-5 等。还有可以实现 PID 控制功能的控制器，如 Rockwell 的 Logix 产品系列，它可以直接与 ControlNet 相连，利用网络来实现其远程控制功能。

1、开环控制系统

开环控制系统 (open-loop control system) 是指被控对象的输出 (被控制量) 对控制器 (controller) 的输出没有影响。在这种控制系统中，不依赖将被控量反送回来以形成任何闭环回路。

2、闭环控制系统

闭环控制系统 (closed-loop control system) 的特点是系统被控对象的输出 (被控制量) 会反送回来影响控制器的输出，形成一个或多个闭环。闭环控制系统有正反馈和负反馈，若反馈信号与系统给定值信号相反，则称为负反馈 ( Negative Feedback)，若极性相同，则称为正反馈，一般闭环控制系统均采用负反馈，又称负反馈控制系统。

闭环控制系统的例子很多。比如人就是一个具有负反馈的闭环控制系统，眼睛便是传感器，充当反馈，人体系统能通过不断的修正最后作出各种正确的动作。如果没有眼睛，就没有了反馈回路，也就成了一个开环控制系统。另例，当一台真正的全自动洗衣机具有能连续检查衣物是否洗净，并在洗净之后能自动切断电源，它就是一个闭环控制系统。

3、阶跃响应

阶跃响应是指将一个阶跃输入（step function）加到系统上时，系统的输出。稳态误差是指系统的响应进入稳态后﹐系统的期望输出与实际输出之差。控制系统的性能可以用稳、准、快三个字来描述。稳是指系统的稳定性 (stability)，一个系统要能正常工作，首先必须是稳定的，从阶跃响应上看应该是收敛的﹔准是指控制系统的准确性、控制精度，通常用稳态误差来 (Steady-state error) 描述，它表示系统输出稳态值与期望值之差﹔快是指控制系统响应的快速性，通常用上升时间来定量描述。

4、PID 控制的原理和特点

在工程实际中，应用最为广泛的调节器控制规律为比例、积分、微分控制，简称 PID 控制，又称 PID 调节。PID 控制器问世至今已有近 70 年历史，它以其结构简单、稳定性好、工作可靠、调整方便而成为工业控制的主要技术之一。当被控对象的结构和参数不能完全掌握，或得不到精确的数学模型时，控制理论的其它技术难以采用时，系统控制器的结构和参数必须依靠经验和现场调试来确定，这时应用 PID 控制技术最为方便。即当我们不完全了解一个系统和被控对象﹐或不能通过有效的测量手段来获得系统参数时，最适合用 PID 控制技术。PID 控制，实际中也有 PI 和 PD 控制。PID 控制器就是根据系统的误差，利用比例、积分、微分计算出控制量进行控制的。

比例（P）控制

比例控制是一种最简单的控制方式。其控制器的输出与输入误差信号成比例关系。当仅有比例控制时系统输出存在稳态误差（Steady-state error）。比例调节作用：是按比例反应系统的偏差，系统一旦出现了偏差，比例调节立即产生调节作用用以减少偏差。比例作用大，可以加快调节，减少误差，但是过大的比例，使系统的稳定性下降，甚至造成系统的不稳定。

积分（I）控制

在积分控制中，控制器的输出与输入误差信号的积分成正比关系。对一个自动控制系统，如果在进入稳态后存在稳态误差，则称这个控制系统是有稳态误差的或简称有差系统（System with Steady-state Error）。为了消除稳态误差，在控制器中必须引入 “积分项”。积分项对误差取决于时间的积分，随着时间的增加，积分项会增大。这样，即便误差很小，积分项也会随着时间的增加而加大，它推动控制器的输出增大使稳态误差进一步减小，直到等于零。

因此，比例 + 积分 (PI) 控制器，可以使系统在进入稳态后无稳态误差。积分调节作用：是使系统消除稳态误差，提高无差度。因为有误差，积分调节就进行，直至无差，积分调节停止，积分调节输出一常值。积分作用的强弱取决与积分时间常数 Ti,Ti 越小，积分作用就越强。反之 Ti 大则积分作用弱，加入积分调节可使系统稳定性下降，动态响应变慢。积分作用常与另两种调节规律结合，组成 PI 调节器或 PID 调节器。

微分（D）控制

在微分控制中，控制器的输出与输入误差信号的微分（即误差的变化率）成正比关系。自动控制系统在克服误差的调节过程中可能会出现振荡甚至失稳。其原因是由于存在有较大惯性组件（环节）或有滞后 (delay) 组件，具有抑制误差的作用，其变化总是落后于误差的变化。解决的办法是使抑制误差的作用的变化 “超前”，即在误差接近零时，抑制误差的作用就应该是零。这就是说，在控制器中仅引入 “比例” 项往往是不够的，比例项的作用仅是放大误差的幅值，而目前需要增加的是 “微分项”，它能预测误差变化的趋势，这样，具有比例 + 微分的控制器，就能够提前使抑制误差的控制作用等于零，甚至为负值，从而避免了被控量的严重超调。所以对有较大惯性或滞后的被控对象，比例 + 微分 (PD) 控制器能改善系统在调节过程中的动态特性。

微分调节作用：微分作用反映系统偏差信号的变化率，具有预见性，能预见偏差变化的趋势，因此能产生超前的控制作用，在偏差还没有形成之前，已被微分调节作用消除。因此，可以改善系统的动态性能。在微分时间选择合适情况下，可以减少超调，减少调节时间。微分作用对噪声干扰有放大作用，因此过强的加微分调节，对系统抗干扰不利。

此外，微分反应的是变化率，而当输入没有变化时，微分作用输出为零。微分作用不能单独使用，需要与另外两种调节规律相结合，组成 PD 或 PID 控制器。

5、PID 控制器的参数整定

PID 控制器的参数整定是控制系统设计的核心内容。它是根据被控过程的特性确定 PID 控制器的比例系数、积分时间和微分时间的大小。PID 控制器参数整定的方法很多，概括起来有两大类：

一是理论计算整定法。它主要是依据系统的数学模型，经过理论计算确定控制器参数。

这种方法所得到的计算数据未必可以直接用，还必须通过工程实际进行调整和修改。

二是工程整定方法。它主要依赖工程经验，直接在控制系统的试验中进行，且方法简单、易于掌握，在工程实际中被广泛采用。PID 控制器参数的工程整定方法，主要有临界比例法、反应曲线法和衰减法。

三种方法各有其特点，其共同点都是通过试验，然后按照工程经验公式对控制器参数进行整定。但无论采用哪一种方法所得到的控制器参数，都需要在实际运行中进行最后调整与完善。

现在一般采用的是临界比例法。利用该方法进行 PID 控制器参数的整定步骤如下：

(1) 首先预选择一个足够短的采样周期让系统工作﹔

(2) 仅加入比例控制环节，直到系统对输入的阶跃响应出现临界振荡，记下这时的比例放大系数和临界振荡周期﹔

(3) 在一定的控制度下通过公式计算得到 PID 控制器的参数。

PID 控制器参数的工程整定，各种调节系统中 PID 参数经验数据以下可参照：

• 温度 T:
  P: 20~60%
  T: 180~600s
  D: 3-180s

• 压力 P:
  P: 30~70%
  T: 24~180s

• 液位 L:
  P: 20~80%
  T: 60~300s

• 流量 L:
  P: 40~100%
  T: 6~60s

PID 常用口诀：

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

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

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

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

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

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

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

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

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

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

6、PID 控制对象说明

PI 适用于压力、流量、液位、速度等相对滞后量的控制；

PD 适用于电源电压控制，不要过冲；

PID 适用于温度、位置控制。

四、PID 代码

//定义变量
float Kp;                      //PI调节的比例常数
float Ti;                       //PI调节的积分常数
float T;                        //采样周期
float Ki;
float ek;                       //偏差e[k]
float ek1;                     //偏差e[k-1]
float ek2;                     //偏差e[k-2]
float uk;                       //u[k]
signed int uk1;            //对u[k]四舍五入取整
signed int adjust;        //调节器输出调整量
 
//变量初始化
    Kp=4;
    Ti=0.005;
    T=0.001;
// Ki=KpT/Ti=0.8，微分系数Kd=KpTd/T=0.8,Td=0.0002,根据实验调得的结果确定这些参数
    ek=0;
    ek1=0;
    ek2=0;
    uk=0;
    uk1=0;
    adjust=0;
 
int piadjust(float ek)  //PI调节算法
{
    if( gabs(ek)<0.1 )
    {
       adjust=0;
    }
    else
    {     
       uk=Kp*(ek-ek1)+Ki*ek;  //计算控制增量
       ek1=ek;
      
       uk1=(signed int)uk;
       if(uk>0)
       {
          if(uk-uk1>=0.5)
          {
             uk1=uk1+1;
          }
       }
       if(uk<0)
       {
          if(uk1-uk>=0.5)
          {
             uk1=uk1-1;
          }
       }
       adjust=uk1;   
    }
    return adjust;
}
下面是在AD中断程序中调用的代码。
       。。。。。。。。。。。
       else //退出软启动后，PID调节,20ms调节一次
           {
              EvaRegs.CMPR3=EvaRegs.CMPR3+piadjust(ek);//误差较小PID调节稳住
              if(EvaRegs.CMPR3>=890)
              {
                 EvaRegs.CMPR3=890; //限制PWM占空比
              }        
           }
        。。。。。。。。。。。。。。。。

五、PID 调节经验总结

PID 控制器参数选择的方法很多，例如试凑法、临界比例度法、扩充临界比例度法等。但是，对于 PID 控制而言，参数的选择始终是一件非常烦杂的工作，需要经过不断的调整才能得到较为满意的控制效果。依据经验，一般 PID 参数确定的步骤如下 [42]：

(1) 确定比例系数 Kp

确定比例系数 Kp 时，首先去掉 PID 的积分项和微分项，可以令 Ti=0、Td=0，使之成为

纯比例调节。输入设定为系统允许输出最大值的 60％～70％，比例系数 Kp 由 0 开始逐渐增大，直至系统出现振荡；再反过来，从此时的比例系数 Kp 逐渐减小，直至系统振荡消失。记录此时的比例系数 Kp，设定 PID 的比例系数 Kp 为当前值的 60％～70％。

(2) 确定积分时间常数 Ti

比例系数 Kp 确定之后，设定一个较大的积分时间常数 Ti，然后逐渐减小 Ti，直至系统出现振荡，然后再反过来，逐渐增大 Ti，直至系统振荡消失。记录此时的 Ti，设定 PID 的积分时间常数 Ti 为当前值的 150％～180％。

(3) 确定微分时间常数 Td

微分时间常数 Td 一般不用设定，为 0 即可，此时 PID 调节转换为 PI 调节。如果需要设定，则与确定 Kp 的方法相同，取不振荡时其值的 30％。

(4) 系统空载、带载联调

对 PID 参数进行微调，直到满足性能要求。

上面的实际是 PI 调节的代码，现附上 PID 的。

//声明变量
 
//定义变量
float Kp;                      //PID调节的比例常数
float Ti;                       //PID调节的积分常数
float T;                        //采样周期
float Td;                      //PID调节的微分时间常数
float a0;
float a1;
 
float a2;
float ek;                      //偏差e[k]
float ek1;                    //偏差e[k-1]
float ek2;                    //偏差e[k-2]
float uk;                     //u[k]
int uk1;                      //对uk四舍五入求整
int adjust;                  //最终输出的调整量
 
//变量初始化，根据实际情况初始化
Kp=;
Ti=;
T=;
Td=; 
a0=Kp*(1+T/Ti+Td/T);
a1=-Kp*(1+2*Td/T);
a2=Kp*Td/T;
 
// Ki=KpT/Ti=0.8，微分系数Kd=KpTd/T=0.8,Td=0.0002,根据实验调得的结果确定这些参数
ek=0;
ek1=0;
ek2=0;
uk=0;
uk1=0;
adjust=0;
 
int pid(float ek)
{
  if(gabs(ek)
  {
    adjust=0;
  }
  else
  {
    uk=a0*ek+a1*ek1+a2*ek2;
    ek2=ek1;
    ek1=ek;
    uk1=(int)uk;
 
    if(uk>0)
    {
      if(uk-uk1>=0.5)
      {
        uk1=uk1+1;
      }
    }
 
    if(uk<0)
    {
      if(uk1-uk>=0.5)
      {
        uk1=uk1-1;
      }
    }
    adjust=uk1;
   }
   return adjust;
}
 
float gabs(float ek)
{
  if(ek<0)
  {
    ek=0-ek;
  }
  return ek;
}

---

PID 算法详解

计算机小混子 已于 2023-03-03 14:14:58 修改

控制算法

所谓控制就是把当前所控制的对象的状态控制为我们设定的目标值，或者尽可能的接近，例如：一个温度控制系统中，我想控制水温在 100 摄氏度，100 摄氏度就是目标值，我们需要把当前温度不断地接近目标值 100 摄氏度。

传统的控制算法

SV 是我们设定的值，PV 是对象当前的值，将 SV 和 PV 同时送入特定电路或者算法中，利用控制算法对 SV 和 PV 进行分析、判断、处理，从而得出一个输出信号 OUT，将 OUT 加到执行机构中，去产生预期的控制效果。

位式控制算法

这种控制算法输出的控制量只有高低电平两种状态，即通电和断电，当当前值 PV 低于目标值 SV 时，控制对象就全额工作，反之就停止工作，例如说控制对象是一个 500W 的加热棒，温度不到目标值就满功率 500W 工作，如果到达目标值就直接断电。

这种算法存在很大缺陷，如果当前值 PV 在目标值 SV 附近，输出信号 OUT 就会不断地通断，导致执行部件的开关的寿命大大减少，并且由于惯性因素，控制效果往往会在目标值 SV 上下产生很大的波动。

PID 算法

位置式 PID 算法

PID 算法是一种具有预测未来状态的算法，其核心思想是

1. PID 算法不但考虑控制对象的当前状态值，而且还考虑控制对象过去，和最近一段状态的状态值变化，并由这 3 面共同决定当前的输出控制状态

2. PID 控制算法的运算结果是一个数，利用这个数可以控制被控对象的工作状态，一般输出形式是 PWM

算法分析

某控制系统中，用户的设定值是 SV

1. 从系统开始运行后，控制算法每隔一段时间对被控对象的状态值进行采样。得到从开机以来被控对象每个采样点被控制对象的状态值所形成的数据序列：

X 1 , X 2 , X 3 , X 4 , . . . . X k − 2 , X k − 1 , X k X_1,X_2, X_3, X_4, .... X_{k-2},X_{k-1},X_k X1​,X2​,X3​,X4​,....Xk−2​,Xk−1​,Xk​

X 1 ：开机以来的第一次采样值 X_1：开机以来的第一次采样值 X1​：开机以来的第一次采样值

X k : 目前的采样值（最近一次的采样值） X_k: 目前的采样值（最近一次的采样值） Xk​:目前的采样值（最近一次的采样值）

1. 我们从这些序列中提取出来三个信息

1）当前采样值 Xk 与用户设定值 SV 之间的差值：{E_k}

E k = S v − X k Ek =Sv - Xk Ek=Sv−Xk

{E_k >0}: 说明当前状态值未达标

{E_k =0}：说明当前控制状态值正好满足要求

{E_k <0}：说明当前状态值已经超标

明显可以看出 {E_k} 就是控制对象当前值和设定值的偏差程度，我们可以根据 {E_k} 的大小对输出信号 OUT 进行调整，即偏差程度大 OUT 增大，偏差程度小 OUT 减小。即输出信号的强弱和当前的偏差程度有着某种关系，单纯根据 {E_k} 的大小来给出控制信号 OUT 的值的算法被称为比例控制，即

P O U T = ( K p ⋅ E k ) + O u t 0 POUT = (K_p \cdot E_k) + Out_0 POUT=(Kp​⋅Ek​)+Out0​

• K p K_p Kp​：称为比例系数，可以理解成一个放大器，选取不同的 K p K_p Kp​ 可以将 OUT 的增益放大或者缩小，并提高控制算法的响应速度。

• O u t 0 Out_0 Out0​：是一个常数，为了在 E k E_k Ek​ 为 0 时，确保输出信号不为 0，防止 PV = SV 时 O U T = 0 OUT = 0 OUT=0，系统就处于失控状态。

2）如果把开机运行以来的各个采样值都与设定值相减，就能得到开机以来每个采样时刻的偏差序列数据：

E 1 , E 2 , E 3 , … , E k − 2 , E k − 1 , E k E_1, E_2, E_3, \ldots, E_{k-2}, E_{k-1}, E_k E1​,E2​,E3​,…,Ek−2​,Ek−1​,Ek​

• E 1 E_1 E1​：开机后第一个采样时刻的偏差值

  E 1 = S V − X 1 ; E 2 = S V − X 2 ; … ; E k − 2 = S V − X k − 2 ; E k − 1 = S V − X k − 1 ; E_1 = SV - X_1; \quad E_2 = SV - X_2; \quad \ldots; \quad E_{k-2} = SV - X_{k-2}; \quad E_{k-1} = SV - X_{k-1}; E1​=SV−X1​;E2​=SV−X2​;…;Ek−2​=SV−Xk−2​;Ek−1​=SV−Xk−1​;

• E k E_k Ek​：当前的采样值与设定值的偏差。

分析这个序列可以得出：

每个偏差值可以是：>0，<0，=0 这三种数值，这是因为开机后控制算法不断作用，导致过去的这段时间有的时候超标（Ex<0）, 有些时候未达标（Ex>0）, 有时候正好满足要求（Ex=0），将这些偏差值进行累加得到 Sk，即：

S k = E 1 + E 2 + E + . . . . . . . . . + E k − 2 + E k − 1 + E k Sk=E_1+E_2+E_+.........+E_{k-2}+E_{k-1}+E_k Sk=E1​+E2​+E+​.........+Ek−2​+Ek−1​+Ek​

S k > 0 S_k >0 Sk​>0: 过去大多数时候未达标

S k = 0 S_k =0 Sk​=0：过去控制效果较理想

S k < 0 S_k <0 Sk​<0: 过去大多数时候已经超标

通过分析 S k S_k Sk​，可以对控制算法过去的控制效果进行评估，控制算法按照曾经的方式输出的控制信号导致了现在的结果，可以利用这个值对当前要输出的控制信号 OUT 进行修正，来保证控制对象会尽快的达到用户的设定值

S k S_k Sk​ 实际上就是对过去每个时间点的误差相加，相等于高等数学中的定积分，所以根据 S k S_k Sk​ 对输出信号进行调节的算法称为积分算法，即

S p S_p Sp​ 是一常数，其目的类似硬件上的放大器，用于放大或者缩小

Out0 是一常数，为了在历史积分偏差值为 0 时确保系统有一个输出值，避免失控

Ti 叫做积分时间常数，取值越大会导致输出 OUT 越小，可以理解为历史上已经很久的误差值都影响了现在的输出信号，取值越小，输出 OUT 会更大，相当于积分只考虑了最近一段时间的误差。

但是在实际上，如果系统已经运行很长时间，早期的偏差值的影响是可以忽略的，所以如果选取合适的 TI 值会有意想不到的控制效果

3）Dk 是最近两次的偏差

D k = E k − E k − 1 D_k=E_k-E_{k-1} Dk​=Ek​−Ek−1​

Ek： 当前的偏差

E k − 1 E_{k-1} Ek−1​: 基于当前的前一个采样时刻的偏差值（即上一次的偏差值）；

D k > 0 D_k > 0 Dk​>0: 说明从上一采样时刻到当前误差有增大趋势

D k = 0 D_k = 0 Dk​=0：说明从上一采样时刻到当前误差平稳

D k < 0 D_k < 0 Dk​<0: 说明从上一采样时刻到当前误差有减小趋

Dk 可以反映出上次采样到当前采样的这段时间被控对象的状态变化趋势，这种趋势可能会延续到下一个采样时间点，可以根据这个变化趋势 Dk 对输出信号 OUT 进行调整，通过预测 “未来”，达到提前控制的目的

Dk 很像高等数学中的微分运算，即变化率，反映控制对象在一段时间内的变化趋势和变化量，所以利用 Dk 对控制器输出信号进行调节的算法称为微分算法，即：

D O U T = K p ∗ ( T d ( d e / d t ) ) + O u t 0 DOUT=Kp*(Td (de/dt))+Out0 DOUT=Kp∗(Td(de/dt))+Out0

Kp：为一常数，可理解为硬件上的放大器或衰减器，用于对输出信号 OUT 的增益进行调整 Out0: 为一常数，为了在

Dk：为 0 时确保 OUT 都有一个稳定的控制值，避免失控

Td：叫微分时间常数，Td 越大会导致输出 OUT 增大，对输出信号产生很大影响

PID 算法的组成部分

[外链图片转存失败，源站可能有防盗链机制，建议将图片保存下来直接上传 (img-4xHOu7bV-1677824095719)(null)]

他们的优缺点分析

• 比例算法：只考虑当前的误差，当前有误差才输出控制信号，当前没有误差就不输出控制信号，也就是说只有误差产生后比例算法才采取措施进行调整，单独的比例算法不可能将控制对象的状态值控制在设定值上，始终在设定值上下波动，但是比例控制反应非常灵敏，有误差就立刻反映到输出。

• 积分算法：只考虑的是控制对象的历史误差情况，过去的误差状况参与了当前的输出控制，但是在系统没有到达目标期间，这些历史误差会对当前的输出产生干扰，如果使用不到，可能扰乱当前的输出。但是在系统进入稳定状态后，特别是当前值和设定值没有误差时，积分算法就会根据过去的误差值输出一个相对稳定的控制信号，防止偏离目标值

• 微分算法：只考虑了最近一段时间的变化率，当系统懂得偏差趋近于某一个固定值时（变化率为 0），微分算法不输出控制信号对其偏差进行调整，所以微分算法也不能单独使用，它只关心偏差的变化速度，而不考虑是否存在偏差。但是微分算法可以知道控制对象最近的变化趋势，可以尽早的抑制控制对象的变化，在将要发生剧烈变化时，就大幅度调整输出信号进行抑制，避免控制对象的大幅度变化。

这三种算法综合起来，相互的优缺点互补，就形成了 PID 算法

O U T = P O U T + I O U T + D O U T OUT= POUT+ IOUT+ DOUT OUT=POUT+IOUT+DOUT

或者

将所有的 Out0 归并到 OUT0

说了这么多接下来说说在单片机中的 PID 算法

T 是采样周期，即多久采样一次当前值 PV，进行一次 PID 计算

Ti：是积分算法在 Ti 时间内和比例算法的控制信号是相同的

Td：是微分算法在 Td 时间内和比例算法产生的控制信号是相同的

再经过一次变换

就得到了

利用 C 语言可以方便实现这个计算公式。OUT 即为本次运算的结果，利用 OUT 可以去驱动执行机构输出对应的控制信号，例如温度控制就可以控制 PWM 的宽度

这种 PID 算法计算出的结果（OUT 值）表示当前控制器应该输出的控制量，所以称为位置式（直接输出了执行机构应该达到的状态值）。

增量式 PID 算法

位置式 PID 算法计算量较大，比较消耗处理器的资源。在有些控制系统中，执行机构本身没有记忆功能，比如 MOS 管是否导通完全取决于控制极电压，可控硅是否导通取决于触发信号，继电器是否接通取决于线圈电流等，只要控制信号丢失，执行机构就停止，在这些应用中应该采用位置式 PID。

也有一些执行机构本身具有记忆功能，比如步进电机，即使控制信号丢失，由于其自身的机械结构会保持在原来的位置等，在这些控制系统中，PID 算法没有必要输出本次应该到达的真实位置，只需要说明应该在上次的基础上对输出信号做多大的修正（可正可负）即可，这就是增量式 PID 算法。

增量式 PID 计算出的是应该在当前控制信号上的调整值，如果计算出为正，则增强输出信号；如果计算出为负则减弱输出信号。

如果用 OUTK-1 表示上次的输出控制信号值，那么当前的输出值应该为 OUTk, 这两者之间的关系为：

O U T K = O U T k − 1 + O U T OUTK=OUTk-1 + OUT OUTK=OUTk−1+OUT

变化后得到

O U T = O U T K − O U T k − 1 OUT= OUTK- OUTk-1 OUT=OUTK−OUTk−1

本次的位置式算法输出：

O U T k = ( K p ∗ E k ) + ( K i ∑ E k ) + ( K D ( E K − E k − 1 ) ) + O U T 0 OUTk=(Kp*Ek) + (Ki∑Ek) + (KD (EK-Ek-1)) +OUT0 OUTk=(Kp∗Ek)+(Ki∑Ek)+(KD(EK−Ek−1))+OUT0

上次的位置式算法输出：

O U T k − 1 = ( K p ∗ E k − 1 ) + ( K i ∑ E k ) + ( K D ( E K − 1 − E k − 2 ) ) + O U T 0 OUTk-1=(Kp*Ek-1) +(Ki∑Ek) + (KD (EK-1-Ek-2)) +OUT0 OUTk−1=(Kp∗Ek−1)+(Ki∑Ek)+(KD(EK−1−Ek−2))+OUT0

两个式子相减

k p ( E K − E K − 1 ) + ( ( K p ∗ T ) / T i ) E k + ( ( ( K p ∗ T D ) / T ) ∗ ( E k − 2 E k − 1 + E k − 2 ) ) kp (EK-EK-1)+((Kp*T)/Ti) Ek+(((Kp*TD)/T)*(Ek-2Ek-1+Ek-2)) kp(EK−EK−1)+((Kp∗T)/Ti)Ek+(((Kp∗TD)/T)∗(Ek−2Ek−1+Ek−2))

K i = K p ∗ ( T / T i ) ; K D = ( K p ∗ ( T D / T ) Ki= Kp*(T/Ti); KD=(Kp*(TD/T) Ki=Kp∗(T/Ti);KD=(Kp∗(TD/T)

得到

k p ( E K − E K − 1 ) + ( ( K p ∗ T ) / T i ) E k + ( ( ( K p ∗ T D ) / T ) ∗ ( E k − 2 E k − 1 + E k − 2 ) ) kp (EK-EK-1)+((Kp*T)/Ti) Ek+(((Kp*TD)/T)*(Ek-2Ek-1+Ek-2)) kp(EK−EK−1)+((Kp∗T)/Ti)Ek+(((Kp∗TD)/T)∗(Ek−2Ek−1+Ek−2))

EK： 本次的偏差；

Ek-1：上次的偏差

Ek-2：上上次的偏差

Kp： 算法增益调节

Ti ： 积分时间

TD: 微分时间常数

增量式 PID 的计算只需要最近 3 次的偏差（本次偏差，上次偏差，上上次偏差），不需要处理器存储大量的历史偏差值，计算量也相对较少，容易实现。

关于 Ti 和 TD 的理解：

在 PID 控制算法中，当前的输出信号由比例项，积分项，微分项共同作用形成，当比例项输出不为 0 时，如果积分项对运算输出的贡献作用与比例项对运算对输出的贡献一样时（即同为正或同为负时），积分项相当于重复了一次比例项产生作用的时间，这个时间就可以理解为积分时间。

当比例项不为 0 时，如果微分项在一段时间里计算的结果与比例项对输出的贡献相同（即同为正或同为负）时，微分项相当于在一段时间里重复了比例项的作用，这段时间可理解为就是微分时间。

实际应用中应该合理选择 Kp,Ti,Td 以确保三者对输出的贡献平衡，从而使控制对象在设定值的附近。

程序示例

这是一个温控项目，位置式 PID

pid.h

#ifndef _pid_
#define _pid_
#include "stm32f10x_conf.h"

typedef struct
{
 float Sv;//用户设定值
 float Pv;//当前值

 float Kp;//比例系数
 float T;  //PID计算周期--采样周期
 float Ti;//积分常数
 float Td; //微分常数



 float Ek;  //本次偏差
 float Ek_1;//上次偏差
 float SEk; //历史偏差之和

  float Pout;//比例项输出
	float Iout;//积分项输出
	float Dout;//微分项输出

 float OUT0;//基础输出

 float OUT;//最终输出


 u16 C10ms;//10ms

 u16 pwmcycle;//pwm周期

}PID;

extern PID pid; //存放PID算法所需要的数据
void PID_Calc(void); //pid计算

#endif

pid.c

#include "pid.h"

PID pid; //存放PID算法所需要的数据


void PID_Calc()  //pid计算
{
 float DelEk;
	float ti,ki;
	float td;
	float kd;
	float out;
 if(pid.C10ms<(pid.T))  //计算周期未到
 {
    return ;
 }

 pid.Ek=pid.Sv-pid.Pv;   //得到当前的偏差值
 pid.Pout=pid.Kp*pid.Ek;      //比例输出

 pid.SEk+=pid.Ek;        //历史偏差总和

 DelEk=pid.Ek-pid.Ek_1;  //最近两次偏差之差

 ti=pid.T/pid.Ti;//积分时间常数
 ki=ti*pid.Kp;//积分项系数

  pid.Iout=ki*pid.SEk*pid.Kp;  //积分输出

 td=pid.Td/pid.T;//微分时间常数

 kd=pid.Kp*td;//微分项系数

  pid.Dout=kd*DelEk;    //微分输出

 out= pid.Pout+ pid.Iout+ pid.Dout;//最终输出


 if(out>pid.pwmcycle)//大于最大pwm周期
 {
  pid.OUT=pid.pwmcycle;//满占空比
 }
 else if(out<0)//小于最小
 {
  pid.OUT=pid.OUT0; //占空比为0
 }
 else
 {
  pid.OUT=out;//其他情况
 }
 pid.Ek_1=pid.Ek;  //更新偏差

 pid.C10ms=0;//一个PID计算时间归0
}

pidout.c

#include "pidout.h"
#include "pid.h"
void PIDOUT_init()//pid输出脚初始化
{
	GPIO_InitTypeDef GPIO_InitStructure;
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);  //开B口时钟
  GPIO_InitStructure.GPIO_Pin =GPIO_Pin_8;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOB, &GPIO_InitStructure);
}


void PID_out()  //输出PID运算结果到负载---每1ms被调用1次
{
   static u16 pw;
	 pw++;
	 if(pw>=pid.pwmcycle)  //
	 {
	   pw=0;
	 }
	  //0  ~  pid.pwmcycle-1

	 if(pw<pid.OUT)
	 {
	   pwmout_0;//加热
	 }
	 else
	 {
	   pwmout_1;//停止加热
	 }

}

time_init.c

 #include "time_init.h"

#include"stm32f10x_conf.h"


void Timer4_init()	//T4 10ms时钟
{	 //72000000/7200=100us
//
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;

RCC_APB1PeriphClockCmd (RCC_APB1Periph_TIM4,ENABLE);



TIM_TimeBaseStructure.TIM_Period = 10000-1; //计数个数     //100us*10=1000us=10ms
TIM_TimeBaseStructure.TIM_Prescaler =72-1;//分频值
TIM_TimeBaseStructure.TIM_ClockDivision = 0x0; 	//分割时钟
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; //向上计数
 TIM_DeInit(TIM4);
TIM_TimeBaseInit(TIM4, & TIM_TimeBaseStructure);
TIM_Cmd(TIM4, ENABLE); 	 //使能定时器2

 /*以下定时器4中断初始化*/
TIM_ITConfig(TIM4,TIM_IT_Update,ENABLE); //向上计数溢出产生中断


}

void Timer3_init()	//T3 1ms时钟
{	 //72000000/7200=100us
//
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;

RCC_APB1PeriphClockCmd (RCC_APB1Periph_TIM3,ENABLE);



TIM_TimeBaseStructure.TIM_Period = 1000-1; //计数个数     //10ms
TIM_TimeBaseStructure.TIM_Prescaler =72-1;//分频值
TIM_TimeBaseStructure.TIM_ClockDivision = 0x0; 	//分割时钟
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; //向上计数
 TIM_DeInit(TIM3);
TIM_TimeBaseInit(TIM3, & TIM_TimeBaseStructure);
TIM_Cmd(TIM3, ENABLE); 	 //使能定时器2

 /*以下定时器4中断初始化*/
TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE); //向上计数溢出产生中断


}

max6675.c

#include "max6675.h"
#include "pid.h"

float temper;
extern u16 Kms10;


#define cs_1   GPIO_SetBits(GPIOC, GPIO_Pin_11)
#define cs_0   GPIO_ResetBits(GPIOC, GPIO_Pin_11)

#define sck_1  GPIO_SetBits(GPIOC, GPIO_Pin_12)
#define sck_0   GPIO_ResetBits(GPIOC, GPIO_Pin_12)

#define so GPIO_ReadInputDataBit(GPIOD,GPIO_Pin_2)

u16 read_max6675()  //????
{
  u16 d,i;
  //so_1;
  cs_0;
  delay_us(2);
  for(i=0;i<16;i++)
  {
    sck_1;
    delay_us(2);
    sck_0;
    delay_us(2);
    d<<=1;
    if(so)
     d++;
  }
  cs_1;
  return d;
}

void read_temper()//??????
{
  u16 d;
	if(Kms10<20)  return ;

  d=read_max6675();//读取MAX6675当前的温度值
  pid.Pv=((d>>4)&0x0fff)*0.25;//????
  Kms10=0;
}


void Max6675_Init()
{GPIO_InitTypeDef GPIO_InitStructure;
	 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);  //开C口时钟
 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD,ENABLE);  //开D口时钟


  GPIO_InitStructure.GPIO_Pin =GPIO_Pin_11;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOC, &GPIO_InitStructure);

	   GPIO_InitStructure.GPIO_Pin =GPIO_Pin_2;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOD, &GPIO_InitStructure);


	   GPIO_InitStructure.GPIO_Pin =GPIO_Pin_12;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOC, &GPIO_InitStructure);
}

main.c

#include "led.h"
#include "12864.h"
#include "time_init.h"
#include "max6675.h"
#include "pid.h"
#include "pidout.h"

u16 Kms10;
void delay(u32 x)
{
  while(x--);
}

void delay_us(u16 us)
{
	 u8 i;
  while(us--)
	{
	  for(i=0;i<6;i++)
		{

		}
	}
}

void Isr_Init()
{
	NVIC_InitTypeDef NVIC_InitStructure;

  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
NVIC_InitStructure.NVIC_IRQChannel =TIM4_IRQn;// TIM4_IRQChannel;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init (&NVIC_InitStructure);


NVIC_InitStructure.NVIC_IRQChannel =TIM3_IRQn;// TIM3_IRQChannel;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init (&NVIC_InitStructure);

}

 void TIM4_IRQHandler() //10ms 1次
{

	static u8 tsec; u8 st;
	st=TIM_GetFlagStatus(TIM4, TIM_IT_Update);
	if(st!=0)
	{  TIM_ClearFlag(TIM4, TIM_IT_Update);
		Kms10++;
//    pid.C10ms++;
		if(tsec++>=100)
		{
		  tsec=0;

		}
	}
}

 void TIM3_IRQHandler() //1ms 1次
{
   u8 st;
	st=TIM_GetFlagStatus(TIM3, TIM_IT_Update);
	if(st!=0)
	{  pid.C10ms++;
		 TIM_ClearFlag(TIM3, TIM_IT_Update);
     PID_out(); //输出PID运算结果到负载
	}
}

void PID_Init()
{
  pid.Sv=120;//用户设定温度
	pid.Kp=30;
	pid.T=500;//PID计算周期
  pid.Ti=5000000;//积分时间
	pid.Td=1000;//微分时间
	pid.pwmcycle=200;//pwm周期1000
	pid.OUT0=1;
}


void Display()
{
	Show_string1(0x90,"设定值:");
	Show_number(0X94,pid.Sv);

	Show_string1(0x88,"当前值:");
	Show_number(0X8c,pid.Pv);

	Show_string1(0x98,"PIDOUT:");
	Show_number(0X9c,pid.OUT);
}


int main()
{
   LCD_Init();
	 Show_string1(0x80,"位置式PID");
	 Timer4_init();	//T4 10ms时钟
	 Isr_Init();
	 Max6675_Init();
	 PID_Init();
	 PIDOUT_init();
	 Timer3_init();	//T3 1ms时钟
   while(1)
   {
    read_temper();//读取当前温度
		PID_Calc(); //pid计算
		Display();
   }
}

---

一文读懂 PID 控制算法（抛弃公式，从原理上真正理解PID控制）

确定有穷自动机 于 2018 - 07 - 12 10:54:54发布

PID 控制应该算是应用非常广泛的控制算法了。小到控制一个元件的温度，大到控制无人机的飞行姿态和飞行速度等等，都可以使用 PID 控制。这里我们从原理上来理解 PID 控制。

PID ( p r o p o r t i o n proportion proportion;   i n t e g r a t i o n integration integration;  d i f f e r e n t i a t i o n differentiation differentiation )其实就是指比例，积分，微分控制。

先把图片和公式摆出来，看不懂没关系。

（一开始看这个算法，公式能看懂，具体怎么用怎么写代码也知道，但是就是不知道原理，不知道为什么要用比例，微分，积分这3个项才能实现最好的控制，用其中两个为什么不行，用了3个项能好在哪里，每一个项各有什么作用）

总的来说，当得到系统的输出后，将输出经过比例，积分，微分 3 种运算方式，叠加到输入中，从而控制系统的行为，下面用一个简单的实例来说明。

比例控制算法

我们先说 PID 中最简单的比例控制，抛开其他两个不谈。还是用一个经典的例子吧。假设我有一个水缸，最终的控制目的是要保证水缸里的水位永远的维持在 1 米的高度。假设初始时刻，水缸里的水位是 0.2 米，那么当前时刻的水位和目标水位之间是存在一个误差 error，且 error 为 0.8。这个时候，假设旁边站着一个人，这个人通过往缸里加水的方式来控制水位。如果单纯的用比例控制算法，就是指加入的水量 u 和误差 error 是成正比的。即

u = k p × e r r o r u = kp \times error u=kp×error

假设 kp 取 0.5，

那么 t=1 时（表示第 1 次加水，也就是第一次对系统施加控制），那么 u = 0.5 × 0.8 = 0.4 u=0.5 \times 0.8=0.4 u=0.5×0.8=0.4，所以这一次加入的水量会使水位在 0.2 的基础上上升 0.4，达到 0.6。

接着，t=2 时刻（第 2 次施加控制），当前水位是 0.6，所以 error 是 0.4。 u = 0.5 × 0.4 = 0.2 u=0.5 \times 0.4=0.2 u=0.5×0.4=0.2，会使水位再次上升 0.2，达到 0.8。

如此这么循环下去，就是比例控制算法的运行方法。

可以看到，最终水位会达到我们需要的 1 米。

但是，单单的比例控制存在着一些不足，其中一点就是 –稳态误差！（我也是看了很多，并且想了好久才想通什么是稳态误差以及为什么有稳态误差）。

像上述的例子，根据 kp 取值不同，系统最后都会达到 1 米，不会有稳态误差。但是，考虑另外一种情况，假设这个水缸在加水的过程中，存在漏水的情况，假设每次加水的过程，都会漏掉 0.1 米高度的水。仍然假设 kp 取 0.5，那么会存在着某种情况，假设经过几次加水，水缸中的水位到 0.8 时，水位将不会再变换！！！因为，水位为 0.8，则误差 error=0.2。所以每次往水缸中加水的量为 u = 0.5 × 0.2 = 0.1 u=0.5 \times 0.2=0.1 u=0.5×0.2=0.1。同时，每次加水缸里又会流出去 0.1 米的水！！！加入的水和流出的水相抵消，水位将不再变化！！！

也就是说，我的目标是 1 米，但是最后系统达到 0.8 米的水位就不在变化了，且系统已经达到稳定。由此产生的误差就是稳态误差了。（在实际情况中，这种类似水缸漏水的情况往往更加常见，比如控制汽车运动，摩擦阻力就相当于是“漏水”，控制机械臂、无人机的飞行，各类阻力和消耗都可以理解为本例中的“漏水”）

所以，单独的比例控制，在很多时候并不能满足要求。

积分控制算法

还是用上面的例子，如果仅仅用比例，可以发现存在暂态误差，最后的水位就卡在 0.8 了。于是，在控制中，我们再引入一个分量，该分量和误差的积分是正比关系。所以，比例 + 积分控制算法为：

u = k p × e r r o r + k i × ∫ e r r o r   d t u = kp \times error + ki \times \int error \, dt u=kp×error+ki×∫errordt

还是用上面的例子来说明，第一次的误差 error 是 0.8，第二次的误差是 0.4，至此，误差的积分（离散情况下积分其实就是做累加）， e r r o r = 0.8 + 0.4 = 1.2 error=0.8+0.4=1.2 error=0.8+0.4=1.2
这个时刻的控制量，除了比例的那一部分，还有一部分就是一个系数 ki 乘以这个积分项。由于这个积分项会将前面若干次的误差进行累计，所以可以很好的消除稳态误差（假设在仅有比例项的情况下，系统卡在稳态误差了，即上例中的 0.8，由于加入了积分项的存在，会让输入增大，从而使得水缸的水位可以大于 0.8，渐渐到达目标的 1.0）。这就是积分项的作用。

微分控制算法

换一个另外的例子，考虑刹车情况。平稳的驾驶车辆，当发现前面有红灯时，为了使得行车平稳，基本上提前几十米就放松油门并踩刹车了。当车辆离停车线非常近的时候，则使劲踩刹车，使车辆停下来。整个过程可以看做一个加入微分的控制策略。

微分，说白了在离散情况下，就是 error 的差值，就是 t 时刻和 t-1 时刻 error 的差，即

u = k d × ( e r r o r ( t ) − e r r o r ( t − 1 ) ) u = kd \times (error(t) - error(t-1)) u=kd×(error(t)−error(t−1))

其中的 kd 是一个系数项。可以看到，在刹车过程中，因为 error 是越来越小的，所以这个微分控制项一定是负数，在控制中加入一个负数项，他存在的作用就是为了防止汽车由于刹车不及时而闯过了线。从常识上可以理解，越是靠近停车线，越是应该注意踩刹车，不能让车过线，所以这个微分项的作用，就可以理解为刹车，当车离停车线很近并且车速还很快时，这个微分项的绝对值（实际上是一个负数）就会很大，从而表示应该用力踩刹车才能让车停下来。

切换到上面给水缸加水的例子，就是当发现水缸里的水快要接近 1 的时候，加入微分项，可以防止给水缸里的水加到超过 1 米的高度，说白了就是减少控制过程中的震荡。

现在在回头看这个公式，就很清楚了

括号内第一项是比例项，第二项是积分项，第三项是微分项，前面仅仅是一个系数。很多情况下，仅仅需要在离散的时候使用，则控制可以化为

每一项前面都有系数，这些系数都是需要实验中去尝试然后确定的，为了方便起见，将这些系数进行统一一下：

这样看就清晰很多了，且比例，微分，积分每个项前面都有一个系数，且离散化的公式，很适合编程实现。

讲到这里， PID 的原理和方法就说完了，剩下的就是实践了。在真正的工程实践中，最难的是如果确定三个项的系数，这就需要大量的实验以及经验来决定了。通过不断的尝试和正确的思考，就能选取合适的系数，实现优良的控制器。

---

模糊控制数学基础（模糊推理）

ksjz123 于 2017-10-12 12:59:20 发布

模糊推理

1. 概括

其主要内容为

2 模糊推理基础

2.1 模糊关系

2.1.1 模糊关系及模糊关系矩阵

（1）

将论域 U 与 V 的直积 UXV 中每一个元素赋予一个隶属度，就可得到 U 与 V 间的一个模糊关系，记为 R. 隶属度记为 μ R \mathop{\mu }_{R} μR​。

（2）模糊关系的表示

2.1.2 模糊关系矩阵运算及合成

2.2 语言变量

2.2.1 概念

2.2.2 语气算子

2.2.3 模糊数

3 模糊推理规则

…

4 模糊推理合成

---

模糊 PID（自适应模糊 PID、fuzzy PID）的基本原理及应用举例 by 研三笔记

干了这碗汤 已于 2024-07-23 17:36:54 修改

1 控制框图

2 概述

• 模糊控制 PID 又叫模糊自适应 PID，因为三个 PID 参数能够实时调整。

• 模糊 PID 控制，即利用模糊逻辑并根据一定的模糊规则对 PID 的参数进行实时的优化，以克服传统 PID 参数无法实时调整 PID 参数的缺点。

• 模糊 PID 控制包括：

  • 模糊化

  • 确定模糊规则（模糊推力）

  • 解模糊（清晰化）

• 例如，小车通过传感器采集赛道信息，确定当前距赛道中线的偏差 E 以及当前偏差和上次偏差的变化 ec，根据给定的模糊规则进行模糊推理，最后对模糊参数进行解模糊，输出 PID 控制参数。

3 基本原理

模糊控制器主要由三个模块组成：模糊化，模糊推理，清晰化。

3. 基本原理

3.1 一些基本的概念、定义

• 模糊量：如 E E E 、 E C EC EC 。

• 论域（上下限）： − 240 ∼ 240 -240\sim240 −240∼240 。

• 划分区间： − 240 ∼ − 180 -240\sim -180 −240∼−180 ； − 180 ∼ − 120 -180\sim -120 −180∼−120 ； − 120 ∼ − 60 -120\sim -60 −120∼−60 ； − 60 ∼ 0 -60\sim 0 −60∼0 ； 0 ∼ 60 0\sim 60 0∼60 ； 60 ∼ 120 60\sim 120 60∼120 ； 120 ∼ 180 120\sim 180 120∼180 ； 180 ∼ 240 180\sim 240 180∼240 。

• 隶属度：隶属于某个模糊子集的隶属度，程度。

• 模糊子集：

  • 负大 N B NB NB （Negative Big）

  • 负中 N M NM NM （Negative Medium）

  • 负小 N S NS NS （Negative Small）

  • 零 Z E ZE ZE 或 Z O ZO ZO （Zero）

  • 正小 P S PS PS （Positive Small）

  • 正中 P M PM PM （Positive Medium）

  • 正大 P B PB PB （Positive Big）

• 隶属度函数：用于求解隶属度，有线性的、非线性的。

3.2 模糊化

实质：根据隶属度函数求取隶属度。可以拆分成以下3个部分来理解：

把 − 180 -180 −180 ， − 120 -120 −120 ， − 60 -60 −60 ， 0 0 0 ， 60 60 60 ， 120 120 120 ， 180 180 180 分别用 N B NB NB ， N M NM NM ， N S NS NS ， Z O ZO ZO ， P S PS PS ， P M PM PM ， P B PB PB 表示。

例如，当 E = 170 E = 170 E=170 时，此时的 E E E 属于 P M PM PM 和 P B PB PB 之间，而此时的 E E E 也会对应 2 2 2 个隶属度。 E E E 隶属于 P M ( 120 ) PM(120) PM(120) 的隶属度为 180 − 170 180 − 120 = 1 6 \frac{180 - 170}{180 - 120}=\frac{1}{6} 180−120180−170​=61​ ，而同理隶属于 P B ( 180 ) PB(180) PB(180) 的隶属度为 170 − 120 180 − 120 = 5 6 \frac{170 - 120}{180 - 120}=\frac{5}{6} 180−120170−120​=65​ 。意思就是 120 120 120 到 180 180 180 进行线性分割了， E E E 离 P M PM PM 和 P B PB PB 哪个更近，则隶属于哪个的程度就更大（当输出值 E E E 大于 180 ( P B ) 180(PB) 180(PB) 时，则隶属度为 1 1 1 ，隶属度值为 P B PB PB ，即 E E E 完全隶属于 P B PB PB ，同理当 E E E 小于 − 180 ( N B ) -180(NB) −180(NB) 时也一样）。同理也可以对 E C EC EC 进行模糊化。

那么 E E E 分别隶属于模糊子集 N B NB NB ， N M NM NM ， N S NS NS ， Z O ZO ZO ， P S PS PS ， P M PM PM ， P B PB PB 的各个隶属度都可以求出。

3.3 模糊推理

实质：根据模糊规则表求取输出值 U U U 的隶属度。即根据模糊控制规则进行模糊推理，并决策出模糊输出量。

首先要确定模糊规则，即专家经验。对于我们这个二维控制结构以及相应的输入模糊集，我们可以制定 49 49 49 条模糊控制规则（一般来说，这些规则都是现成的，很多教科书上都有）。

我们假设 E E E 的两个隶属度值为 P M PM PM 、 P B PB PB ；

假设 E E E 属于 P M PM PM 的隶属度为 a a a ，则属于 P B PB PB 的隶属度为 ( 1 − a ) (1 - a) (1−a) ；

再假设 E C EC EC 的两个隶属度值为 N B NB NB 、 N M NM NM ；

假设 E C EC EC 属于 N M NM NM 的隶属度为 b b b ，则属于 N B NB NB 的隶属度为 ( 1 − b ) (1 - b) (1−b) ；

根据模糊规则表，当 E E E 隶属于 P M PM PM 且 E C EC EC 隶属于 N B NB NB 时，可知输出值 U U U 隶属于 Z O ZO ZO 。

此时输出值 U U U 隶属于 Z O ZO ZO 的隶属度为 a × ( 1 − b ) a\times(1 - b) a×(1−b) ，其他同理。

根据上表的求解规则，可以求得输出值 U U U 隶属于各个模糊子集的隶属度为：

隶属于 Z O ZO ZO 的隶属度为： a × b + a × ( 1 − b ) + ( 1 − a ) × ( 1 − b ) a\times b + a\times(1 - b)+(1 - a)\times(1 - b) a×b+a×(1−b)+(1−a)×(1−b) ；

隶属于 N S NS NS 的隶属度为： ( 1 − a ) × b (1 - a)\times b (1−a)×b 。

3.4 清晰化（解模糊、反模糊化）

对于输出值，我们同样采用给予隶属度的办法。例如，我们把输出值假设为 [ 1000 , 1400 ] [1000,1400] [1000,1400] （即舵机的摆角值范围）的区间同样划分为八个部分，即 7 7 7 个模糊子集 N B U NB_U NBU​ ， N M U NM_U NMU​ ， N S U NS_U NSU​ ， Z O U ZO_U ZOU​ ， P S U PS_U PSU​ ， P M U PM_U PMU​ ， P B U PB_U PBU​ 。根据上一步所得出的结论，我们就可以用隶属度乘以相应的隶属值算出输出值的解，即 ( a × b + a × ( 1 − b ) + ( 1 − a ) × ( 1 − b ) ) × Z O U + ( 1 − a ) × b × N S U (a\times b + a\times(1 - b)+(1 - a)\times(1 - b))\times ZO_U+(1 - a)\times b\times NS_U (a×b+a×(1−b)+(1−a)×(1−b))×ZOU​+(1−a)×b×NSU​ 。到此为止，整个模糊过程就结束了。

对输出模糊量的解模糊：模糊控制器的输出量是一个模糊集合，通过反模糊化方法判决出一个确切的精确量，反模糊化方法很多，我们这里选取重心法。

3.5 模糊PID

我们已经知道了整个模糊的过程，但上述的输出值只有一个输出，并没有实现PID。因此我们可以先对 E E E 和 E C EC EC 进行模糊化，然后分别根据不同的逻辑模糊子集、隶属度函数、模糊规则表求得输出值 k p k_p kp​ 、 k i k_i ki​ 和 k d k_d kd​ 的隶属度，然后反模糊化求得 k p k_p kp​ 、 k i k_i ki​ 和 k d k_d kd​ 。再将 k p k_p kp​ 、 k i k_i ki​ 和 k d k_d kd​ 套入PID公式。

即将 u u u 分别为 k i k_i ki​ 、 k d k_d kd​ 、 k p k_p kp​ 求取各自的隶属度，然后清晰化。

3.6 使用.fis文件

simulink中使用 f i s fis fis 文件，首先加入 f u z z y fuzzy fuzzy 模块，然后写入模糊文件，注意应用格式加单引号：‘ f u z z p i d . f i s fuzzpid.fis fuzzpid.fis ’

或者，现在命令空间中运行：

f i s = r e a d f i s ( ‘ f u z z p i d . f i s ’ ) fis = readfis(‘fuzzpid.fis’) fis=readfis(‘fuzzpid.fis’)

然后 b l o c k block block 中用 f i s fis fis 。

4 利用 matlab 模糊控制工具箱设计模糊控制器

matlab 版本：matlab2010b。

步骤：

1. 在 matlab 命令窗口中输入 fuzzy ，打开模糊控制工具箱。

2. 确定输入、输出量。

   Edit -> Add Variable -> Input

   

   查看规则编辑器和曲面观测器（view/rules view/surface)：

   

   
   …

---

飞思卡尔智能车 ---- 模糊 PID 算法通俗讲

我爱广工大于 2018-02-02 11:14:15 发布

在讲解模糊 PID 前，我们先要了解 PID 控制器的原理（本文主要介绍模糊 PID 的运用，对 PID 控制器的原理不做详细介绍）。PID 控制器（比例 - 积分 - 微分控制器）是一个在工业控制应用中常见的反馈回路部件，由比例单元 P、积分单元 I 和微分单元 D 组成。PID 控制的基础是比例控制；积分控制可消除稳态误差，但可能增加超调；微分控制可加快大惯性系统响应速度以及减弱超调趋势。

1.1 传统 PID 控制

传统 PID 控制器自出现以来，凭借其结构简单、稳定性好、工作可靠、调整方便等优点成为工业控制主要技术。当被控对象的结构和参数具有一定的不确定性，无法对其建立精确的模型时，采用 PID 控制技术尤为方便。PID 控制原理简单、易于实现，但是其参数整定异常麻烦。对于小车的速度控制系统而言，由于其为时变非线性系统不同时刻需要选用不同的 PID 参数，采用传统的 PID 控制器，很难使整个运行过程具有较好的运行效果。

1.2 模糊 PID 控制

模糊 PID 控制，即利用模糊逻辑并根据一定的模糊规则对 PID 的参数进行实时的优化，以克服传统 PID 参数无法实时调整 PID 参数的缺点。模糊 PID 控制包括模糊化，确定模糊规则，解模糊等组成部分。小车通过传感器采集赛道信息，确定当前距赛道中线的偏差 E 以及当前偏差和上次偏差的变化 ec，根据给定的模糊规则进行模糊推理，最后对模糊参数进行解模糊，输出 PID 控制参数。

2.1 模糊化

模糊控制器主要由三个模块组成：模糊化，模糊推理，清晰化。具体如下图所示。而我们将一步步讲解如何将模糊 PID 算法运用到智能车上。（最好用笔一步步自己写一遍！！！）

首先我们的智能车会采集到赛道的相关数据，例如摄像头车，其采集到的数据经过算法处理之后会得到与中线的偏差 E，以及当前偏差和上次偏差的变化（差值）EC 两个值（即此算法为 2 维输入，同理也可以是 1 维和 3 维，但 2 维更适合智能车）。例如此时车偏离中线的距离为 150，而上一时刻偏离中线的距离为 120，则 E 为 150，EC 为 150 - 120 = 30。

其次我们要对这两个值进行模糊化。这里我们对 E 进行举例。摄像头车采集回来的 E 是有范围的，即与中线的偏差是在一个区间内可行的。在这里我们假设该区间为 - 240 到 240，即小车偏离中线的最大距离为 240，正负即为左右。再假设中线偏差变化率的可行区间为 - 40 到 + 40。

接着我们要对这两个值进行模糊化。我现在将 E 的区间（-240 到 240）分成 8 个部分，那么他们分别为 - 240 ~ -180，-180 ~ -120 ，-120 ~ -60，-60 ~ 0，0 ~ 60，60 ~ 120，120 ~ 180，180 ~ 240。然后我们把 - 180，-120，-60，0，60，120，180 分别用 NB，NM，NS，ZO，PS，PM，PB 表示（个人理解 N 为 negative，P 为 positive，B 为 big，M 为 middle，S 为 small，ZO 为 zero）。例如，当 E = 170 时，此时的 E 属于 PM 和 PB 之间，而此时的 E 也会对应 2（或 1）个隶属度。E 隶属于 PM（120）的百分比为（180 - 170） / （180 - 120） = 1 / 6 ，而同理隶属于 PB（180）的百分比为（170 - 120） / （180 - 120） = 5 / 6 。意思就是 120 到 180 进行线性分割了，E 离 PM 和 PB 哪个更近，则隶属于哪个就更大（当输出值 E 大于 180（PB）时，则隶属度为 1，隶属度值为 PB，即 E 完全隶属于 PB，同理当 E 小于 - 180 （NB）时也一样）。同理也可以对 EC 进行模糊化。

2.2 模糊推理

对于采集回来的 E 和 EC，我们可以推出它们各所占的隶属度，此时我们可以根据模糊规则表去找出输出值所对应的隶属度。

我们假设为 E 的两个隶属度值为 PM、PB,E 属于 PM 的隶属度为 a（a < 1），则属于 PB 的隶属度为（1 - a）。再假设 EC 的两个隶属度值为 NB、NM，EC 属于 NM 的隶属度为 b，则属于 NB 的隶属度为（1 - b）。而在假设中，E 属于 PM 的隶属度为 a，EC 属于 NB 的隶属度为 ( 1 - b )，则输出值属于 ZO 的隶属度为 a *( 1 - b )（看图）。

同理我们可以得出，当输出值属于 ZO 的另外两个隶属度为 a * b， （ 1 - a ） * （ 1 - b） ，而输出值属于 NS 的隶属度为 ( 1 - a ) * b。

在这里我们先证明一个条件，将这四个隶属度加起来，刚好等于 1。这是因为

（a + （1 - a）） * （b + （1 - b）） = a * b + ( 1 - a ) * b + a * ( 1 - b ) + ( 1 - a ) * ( 1 - b ) （下图）

即一个十字相乘的概念。这个等式说明输出值的隶属度之和等于 1（第三步求解的时候需要用到隶属度之和）。

因此，我们知道了输出值为 ZO 的隶属度和为 a * b + a * ( 1 - b ) + ( 1 - a ) * ( 1 - b ) ，输出值为 NS 的隶属度为 ( 1 - a ) * b 。

2.3 清晰化

对于输出值，我们同样采用给予隶属度的办法。例如，我们把输出值假设为 [1000，1400]（即舵机的摆角值范围）的区间同样划分为八个部分，即 7 个隶属值 NB,NM,NS,ZO,PS,PM,PB。根据上一步所得出的结论，我们就可以用隶属度乘以相应的隶属值算出输出值的解，即 （a * b + a * ( 1 - b ) + ( 1 - a ) * ( 1 - b ) ） * ZO + ( 1 - a ) * b * NS。到此为止，整个模糊过程就结束了。

3 模糊 PID

我们已经知道了整个模糊的过程，但上述的过程还不够完美。因为我们的输出值只有一个输出，并没有实现 PID。因此我们可以先对 E 和 EC 进行模糊化，然后分别对 kp 和 ki 和 kd（PID 的三个参数）进行求解，再套入公式。

一般的我们也可以只用 kp，kd，不用 ki。而模糊规则表一般的论文已经基本给出。因此带入算法之后我们的难度也只是在于调节 kp，kd，和适当调节规则表。当然调节的难度会大于普通的 PID，因为还要定 kp，kd 的输出范围，调得不好可能效果并没有普通的 PID 好。

4. 部分解释

4.1 对于部分论文所说的重心法解模糊，其实就是上述方法。公式如下。

式中 μ（Zi） * Zi 相当于文章上面的（a * b + a * ( 1 - b ) + ( 1 - a ) * ( 1 - b ) ） * ZO + ( 1 - a ) * b * NS，即隶属度乘以隶属度值之和，而 μ（Zi）之和就是输出值的隶属度之和，我们已经证明它是等于 1 的。

---

MATLAB 模糊 PID 实现（全流程详细报告 + 附实现代码）

孟秋廿二 于 2020-10-11 13:53:54 发布

写在前面

本文是一篇完整的报告，在写的过程中博主也查阅了一些资料，感谢各位大神的博客，详细理论可以参考教材，博主用的是刘金锟老师的智能控制教材，第 6 章给出了一些参考资料，个人认为非常有用。

第 1 章 问题的提出

当今的自动控制技术都是基于反馈的概念。反馈理论的要素包括三个部分：测量、比较和执行。测量关心的变量，与期望值相比较，用这个误差纠正调节控制系统的响应。

它由于用途广泛、使用灵活，已有系列化产品，使用中只需设定三个参数（Kp， Ti 和 Td）即可。在很多情况下，并不一定需要全部三个单元，可以取其中的一到两个单元，但比例控制单元是必不可少的。

首先，PID 应用范围广。虽然很多工业过程 是非线性或时变的，但通过对其简化可以变成基本线性和动态特性不随时间变化的系统，这样 PID 就可控制了。

其次，PID 参数较易整定。也就是，PID 参数 Kp，Ti 和 Td 可以根据过程的动态特性及时整定。如果过程的动态特性变化，例如可能由负载的变化引起系统动态特性变化，PID 参数就可以重新整定。

第三，PID 控制器在实践中也不断的得到改进，下面两个改进的例子。

在工厂，总是能看到许多回路都处于手动状态，原因是很难让过程在 “自动” 模式下平稳工作。由于这些不足，采用 PID 的工业控制系统总是受产品质量、安全、产量和能源浪费等问题的困扰。PID 参数自整定就是为了处理 PID 参数整定这个问题而产生的。现在，自动整定或自身整定的 PID 控制器已是商业单回路控制器和分散控制系统的一个标准。

在一些情况下针对特定的系统设计的 PID 控制器控制得很好，但它们仍存在一些问题需要解决：

如果自整定要以模型为基础，为了 PID 参数的重新整定在线寻找和保持好过程模型是较难的。闭环工作时，要求在过程中插入一个测试信号。这个方法会引起扰动，所以基于模型的 PID 参数自整定在工业应用不是太好。

如果自整定是基于控制律的，经常难以把由负载干扰引起的影响和过程动态特性变化引起的影响区分开来，因此受到干扰的影响控制器会产生超调，产生一个不必要的自适应转换。另外，由于基于控制律的系统没有成熟的稳定性分析方法，参数整定可靠与否存在很多问题。

因此，许多自身整定参数的 PID 控制器经常工作在自动整定模式而不是连续的自身整定模式。自动整定通常是指根据开环状态确定的简单过程模型自动计算 PID 参数。

PID 在控制非线性、时变、耦合及参数和结构不确定的复杂过程时，工作地不是太好。最重要的是，如果 PID 控制器不能控制复杂过程，无论怎么调参数都没用。

虽然有这些缺点，PID 控制器是最简单的有时却是最好的控制器

模糊控制是利用模糊数学的基本思想和理论的控制方法。在传统的控制领域里，控制系统动态模式的精确与否是影响控制优劣的最主要关键，系统动态的信息越详细，则越能达到精确控制的目的。然而，对于复杂的系统，由于变量太多，往往难以正确的描述系统的动态，于是工程师便利用各种方法来简化系统动态，以达成控制的目的，但却不尽理想。换言之，传统的控制理论对于明确系统有强而有力的控制能力，但对于过于复杂或难以精确描述的系统，则显得无能为力了。因此便尝试着以模糊数学来处理这些控制问题。模糊控制在智能控制领域由于理论研究比较成熟、实现相对比较简单、适应面宽而得到了广泛的应用。不论是对复杂的水泥回砖窑的控制，还是在智能化家用电器中的应用，模糊控制都充当着重要的角色。

本文针对固定系统，分别利用传统 PID 控制方法和模糊控制方法对其进行仿真控制，并对两种控制的控制结果进行了比较，通过比较表明了模糊控制相比传统的 PID 控制改善控制系统的动态性能。

第 2 章 PID 控制器的设计

2.1 PID 控制原理图

PID 控制其结构框图如下图所示：

2.2 PID 控制器传递函数的一般表达式

PID 控制器传递函数的一般表达形式为：

G c ( s ) = k p + k i s + k d × s \Large Gc(s)=\mathop{k}_{p}+\frac{\mathop{k}_{i}}{s}+\mathop{k}_{d}\times s Gc(s)=kp​+ski​​+kd​×s

其中 k p {k_p} kp​ 为比例增益； k i {k_i} ki​ 为积分增益； k d {k_d} kd​ 为微分增益。

调整 PID 参数，以满足系统要求，从而使被控对象有更优良的动态响应和静态响应。

比例环节：根据偏差量成比例的调节系统控制量，以此产生控制作用，减少偏差。比例系数的作用是增加系统响应的速度，比例系数越大，系统响应越快，但系统容易产生超调，比例系数过小，会影响系统调节的精度，系统响应时间变长，系统的动态响应变差。

积分环节：用于消除静差，提高系统的无差度，积分时间常数决定着积分环节作用的强度，但是积分作用过强的话会影响系统的稳定性。

微分环节：根据偏差量的变化趋势来调节系统控制量，在偏差信号发生较大变化之前，提早引入一个校正信号，起到加快系统动作速度，减少调节时间的作用，调节微分参数需要注意微分作用太强可能会引起系统振荡。

第 3 章 模糊控制器的设计

3.1 模糊控制原理图

模糊控制器结构框图如下图所示：

模糊控制器结构如下图：

3.2 模糊控制器传递函数一般表达形式

一个典型工业过程通常可以等效为二阶系统加上一个非线性环节（如纯滞后），给出如下经典控制对象传递函数的一般形式：

其中模糊控制规则是模糊控制器的核心，是设计控制系统的主要内容。

一个基本模糊控制器主要有三个功能：

（1）模糊化：把精确量（如偏差 e 和偏差变化 ec）转化为相应的模糊量（E、EC）；

（2）模糊推理：按总结的语言规则（模糊控制规划表）进行模糊推理；

（3）模糊判决：把推理结果（U）从模糊量转化为可以用于实际控制的精确量（u）。

模糊规则是由一系列的模糊条件语句组成的，即由许多模糊蕴含关系构成。这些条件语句是推理的出发点和得到的正确结论的根据和基础。每条模糊条件语句都给出模糊蕴含关系，即一条控制规则。若有 n 条规则，就把它们表达的 n 个模糊蕴含关系 (i=l，2，⋯，n) 做并运算，构成系统总的模糊蕴含关系：

第 4 章 系统仿真

4.1 经典 PID

本文采用的传递函数为：

选用的输入是单位阶跃信号。

首先使用以下语句在 MATLAB 中输入传递函数：

sys=tf (4.23,[1,1.64,8.46],‘ioDelay’,3); % 建立被控对象传递函数

运行结果如图：

采样时间 ts=0.1，使用以下语句对传递函数作 Z 变换：

dsys=c2d (sys,ts,‘z’) % 离散化

运行结果如图：

将 Z 变换转化为差分方程，输出序列 y (k), 设置 kp=0.36;ki=0.035; kd=0.3 结果如下图：

4.2 模糊 PID

设计模糊控制器的主要步骤为：

选择偏差 e、偏差变化 ec 的模糊语言变量为 e、ec。根据 e、ec 实际的基本论域，设定 e、ec 论域都为 [-3,3]。

选取 E、EC 和 U 的各语言变量值：正大为 PB，正中为 PM，正小为 PS，为零为 Z，负小为 NS，负中为 NM，负大为 NB，它们各自在论域上的模糊子集隶属度函数均为三角形。

选择一种模糊判决方法，将控制量由模糊量变为精确量，这个过程叫做 “去模糊化”，这里采用的是 “重心法”。

对上述传递函数同样进行 z 变换，转换为差分方程，其中 PID 参数初值为 kp0=0.35; ki0=0.35; kd0=1; 语言值的隶属函数选择三角形的隶属度函数如下图所示：

（1）e 的隶属度函数：

（2）ec 的隶属度函数：

（3）kp 的隶属度函数

（4）ki 的隶属度函数

（5）kd 的隶属度函数

Δkp 的控制规则如表 1 所示：

表 1：Δkp 模糊规则表：

Δki 的控制规则如表 2 所示：

Δkd 的控制规则如表 3 所示：

将规则输入到编辑器中（如图 8 所示）一共有 7×7=49 条规则，输入后可以在变量器中查看对具体输入的模糊推理及输出情况，输入各种不同的数据，查看模糊推理情况及输出数据。也可以用于检查，看自己输入的规则和有没有错误。

编辑器中 Rule Viewer

实验得到的结果图形如下所示：

kp 变化曲线

ki 变化曲线

kd 变化曲线

第 5 章 MATLAB 代码实现

经典 PID 代码

% 经典 pid,Matlab 实现
clear all;
close all;
ts=0.1;  % 采样时间 = 0.1s
sys=tf (4.23,[1,1.64,8.46],'ioDelay',3) % 建立被控对象传递函数
dsys=c2d (sys,ts,'z') % 离散化
[num,den]=tfdata (dsys,'v');   %
e_1=0;  % 前一时刻的偏差
Ee=0;   % 累积偏差
% X={0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0}
%[u_1,u_2,u_3,u_4,u_5,u_6,u_7,u_8,u_9,u_10,u_11,u_12,u_13,u_14,u_15,u_16,u_17,u_18,u_19,u_20,u_21,u_22,u_23,u_24,u_25,u_26,u_27,u_28,u_29,u_30,u_31,u_32,u_33]=deal (X {:});
% 前一时刻的控制量
% y_1=0; y_2=0;  % 前一时刻的输出
% PID 参数
% kp=0.35;
% ki=0.02;
% kd=0.9;
 kp=0.36; ki=0.035; kd=0.3
u=zeros (1,1000);
for j=1:32;% 差分方程，0 时刻前的 32 个点
u (j)=0.0;
end
% y=zeros (1,2);% 预先分配内存
time=zeros (1,1000);% 时刻点（设定 1000 个）
for k=1:1:1000
time (k)=(k)*ts;   % 时间参数
r (k)=1;  % 期望值
y (1)=0;y (2)=0;
y (k+2)=-1*den (3)*y (k-2+2)-1*den (2)*y (k-1+2)+num (2)*u (k-31+32)+num (3)*u (k-32+32);% 系统响应输出序列
e (k)=r (k)-y (k+2);   % 误差信号
m=e (k)-e_1;
u (k+32)=kp*e (k)+ki*Ee+kd*m; % 系统 PID 控制器输出序列
Ee=Ee+e (k);% 误差的累加和
% 前一个的控制器输出值
% y_1=y (k);y_2=y (k-1);
% 前一个的系统响应输出值
e_1=e (k);		% 前一个误差信号的值
end
%（仅绘制过渡过程的曲线，x 坐标限制为 [0,1]）
% p1=plot (time,r,'*');xlim ([0,100]);hold on;% 指令信号的曲线（即期望输入）
p2=plot (time,y (3:1002),'--');xlim ([0,100]);ylim ([0,1.2]);grid on;% 不含积分分离的 PID 曲线
hold on;

模糊 PID 代码

第一个文件，用于制定定模糊规则，文件名 “Fuzzyrule”

% 第一个文件，用于制定定模糊规则，文件名 "Fuzzyrule"
% Fuzzy Tunning PID Control
clear all;
close all;
a=newfis ('fuzzpid');
a=addvar (a,'input','e',[-3,3]);% Parameter e
a=addmf (a,'input',1,'NB','zmf',[-3,-1]);
a=addmf (a,'input',1,'NM','trimf',[-3,-2,0]);
a=addmf (a,'input',1,'NS','trimf',[-3,-1,1]);
a=addmf (a,'input',1,'Z','trimf',[-2,0,2]);
a=addmf (a,'input',1,'PS','trimf',[-1,1,3]);
a=addmf (a,'input',1,'PM','trimf',[0,2,3]);
a=addmf (a,'input',1,'PB','smf',[1,3]);
a=addvar (a,'input','ec',[-3,3]);   % Parameter ec
a=addmf (a,'input',2,'NB','zmf',[-3,-1]);
a=addmf (a,'input',2,'NM','trimf',[-3,-2,0]);
a=addmf (a,'input',2,'NS','trimf',[-3,-1,1]);
a=addmf (a,'input',2,'Z','trimf',[-2,0,2]);
a=addmf (a,'input',2,'PS','trimf',[-1,1,3]);
a=addmf (a,'input',2,'PM','trimf',[0,2,3]);
a=addmf (a,'input',2,'PB','smf',[1,3]);
a=addvar (a,'output','kp',[-0.3,0.3]);   % Parameter kp
a=addmf (a,'output',1,'NB','zmf',[-0.3,-0.1]);
a=addmf (a,'output',1,'NM','trimf',[-0.3,-0.2,0]);
a=addmf (a,'output',1,'NS','trimf',[-0.3,-0.1,0.1]);
a=addmf (a,'output',1,'Z','trimf',[-0.2,0,0.2]);
a=addmf (a,'output',1,'PS','trimf',[-0.1,0.1,0.3]);
a=addmf (a,'output',1,'PM','trimf',[0,0.2,0.3]);
a=addmf (a,'output',1,'PB','smf',[0.1,0.3]);
a=addvar (a,'output','ki',[-0.06,0.06]); % Parameter ki
a=addmf (a,'output',2,'NB','zmf',[-0.06,-0.02]);
a=addmf (a,'output',2,'NM','trimf',[-0.06,-0.04,0]);
a=addmf (a,'output',2,'NS','trimf',[-0.06,-0.02,0.02]);
a=addmf (a,'output',2,'Z','trimf',[-0.04,0,0.04]);
a=addmf (a,'output',2,'PS','trimf',[-0.02,0.02,0.06]);
a=addmf (a,'output',2,'PM','trimf',[0,0.04,0.06]);
a=addmf (a,'output',2,'PB','smf',[0.02,0.06]);
a=addvar (a,'output','kd',[-3,3]);   % Parameter kp
a=addmf (a,'output',3,'NB','zmf',[-3,-1]);
a=addmf (a,'output',3,'NM','trimf',[-3,-2,0]);
a=addmf (a,'output',3,'NS','trimf',[-3,-1,1]);
a=addmf (a,'output',3,'Z','trimf',[-2,0,2]);
a=addmf (a,'output',3,'PS','trimf',[-1,1,3]);
a=addmf (a,'output',3,'PM','trimf',[0,2,3]);
a=addmf (a,'output',3,'PB','smf',[1,3]);
rulelist=[1 1 7 1 5 1 1;% 前 m 个数字表示各输入语言变量的语言之（隶属度函数的编号），此处 m=2
		  1 2 7 1 3 1 1;% 随后的 n 个数字表示输出语言变量的语言值，此处 n=3
  1 3 6 2 1 1 1;% 第 n+m+1 个数字是该规则的权重，权重的值在 0 到 1 之间，一般为 1
  1 4 6 2 1 1 1;% 第 n+m+2 个数字为 0 或 1 两者之一，各输入语言变量之间的关系，1 为与，0 为或
  1 5 5 3 1 1 1;
  1 6 4 4 2 1 1;
  1 7 4 4 5 1 1;
  2 1 7 1 5 1 1;
  2 2 7 1 3 1 1;
  2 3 6 2 1 1 1;
  2 4 5 3 2 1 1;
  2 5 5 3 2 1 1;
  2 6 4 4 3 1 1;
  2 7 3 4 4 1 1;
  3 1 6 1 4 1 1;
  3 2 6 2 3 1 1;
  3 3 6 3 2 1 1;
  3 4 5 3 2 1 1;
  3 5 4 4 3 1 1;
  3 6 3 5 3 1 1;
  3 7 3 5 4 1 1;
  4 1 6 2 4 1 1;
  4 2 6 2 3 1 1;
  4 3 5 3 3 1 1;
  4 4 4 4 3 1 1;
  4 5 3 5 3 1 1;
  4 6 2 6 3 1 1;
  4 7 2 6 4 1 1;
  5 1 5 2 4 1 1;
  5 2 5 3 4 1 1;
  5 3 4 4 4 1 1;
  5 4 3 5 4 1 1;
  5 5 3 5 4 1 1;
  5 6 2 6 4 1 1;
  5 7 2 7 4 1 1;
  6 1 5 4 7 1 1;
  6 2 4 4 5 1 1;
  6 3 3 5 5 1 1;
  6 4 2 5 5 1 1;
  6 5 2 6 5 1 1;
  6 6 2 7 5 1 1;
  6 7 1 7 7 1 1;
  7 1 4 4 7 1 1;
  7 2 4 4 6 1 1;
  7 3 2 5 6 1 1;
  7 4 2 6 6 1 1;
  7 5 2 6 5 1 1;
  7 6 1 7 5 1 1;
  7 7 1 7 7 1 1];
a=addrule (a,rulelist);
a=setfis (a,'DefuzzMethod','centroid');
writefis (a,'fuzzpid');
a=readfis ('fuzzpid');
figure (1);
plotmf (a,'input',1);
figure (2);
plotmf (a,'input',2);
figure (3);
plotmf (a,'output',1);
figure (4);
plotmf (a,'output',2);
figure (5);
plotmf (a,'output',3);
figure (6);
plotfis (a);
fuzzy fuzzpid;
showrule (a);
ruleview fuzzpid;

第二个文件

% 模糊 PID
% Fuzzy PID Control
close all;
clear all;
a=readfis ('fuzzpid');   % Load fuzzpid.fis
% ts=0.001;
% sys=tf (5.235e005,[1,87.35,1.047e004,0]);
% dsys=c2d (sys,ts,'tustin');
% [num,den]=tfdata (dsys,'v');
ts=0.1;  % 采样时间 = 0.1s
sys=tf (4.23,[1,1.64,8.46],'ioDelay',3); % 建立被控对象传递函数
dsys=c2d (sys,ts,'z') % 离散化
[num,den]=tfdata (dsys,'v');   %
x=[0,0,0]';
e_1=0;
ec_1=0;
kp0=0.35;
ki0=0.35;
kd0=1;
for j=1:32;
u (j)=0.0;
end
for k=1:1:3000
time (k)=k*ts;
r (k)=1;
% Using fuzzy inference to tunning PID
k_pid=evalfis ([e_1,ec_1],a);
kp (k)=kp0+k_pid (1);
ki (k)=ki0+k_pid (2);
kd (k)=kd0+k_pid (3);
y (1)=0;y (2)=0;
y (k+2)=-1*den (3)*y (k-2+2)-1*den (2)*y (k-1+2)+num (2)*u (k-31+32)+num (3)*u (k-32+32);% 系统响应输出序列
e (k)=r (k)-y (k+2);
u (k+32)=kp (k)*x (1)+kd (k)*x (2)+ki (k)*x (3);
   x (1)=e (k);% Calculating P
   x (2)=e (k)-e_1;% Calculating D
   x (3)=x (3)+e (k)*ts;% Calculating I
   ec_1=x (2);
   e_2=e_1;
   e_1=e (k);
end
figure (1);
plot (time,r,'b',time,y (3:3002),'r');
xlim ([0,300]);ylim ([0,1.2]);grid on;
xlabel ('time (s)');ylabel ('rin,yout');
figure (2);
plot (time,e,'r');
xlabel ('time (s)');ylabel ('error');
figure (3);
plot (time,u (33:3032),'r');
xlabel ('time (s)');ylabel ('u');
figure (4);
plot (time,kp,'r');
xlabel ('time (s)');ylabel ('kp');
figure (5);
plot (time,ki,'r');
xlabel ('time (s)');ylabel ('ki');
figure (6);
plot (time,kd,'r');
xlabel ('time (s)');ylabel ('kd');

第 6 章 参考资料

1. 模糊控制的 MATLAB 实现具体过程 (强势吐血推荐)… - 百度文库

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

2. 刘金锟智能控制教材源代码及各章 ppt (CSDN 有下载)

---

Matlab 仿真 PID 控制（带 M 文件、simulink 截图和参数分析）

非线性光学元件 于 2019-01-06 10:16:09 发布

0. 符号说明

1. y (k)—— 系统响应输出的离散值

2. u (k)—— 数字 PID 控制输出的离散值

3. r (k)—— 期望输出的离散值（事先已知），在本例中为常数（即阶跃输入）

4. e (k)——e (k)=r (k)-y (k)，为期望值 - 实际值，是单位负反馈的误差比较信号

   

   注：图片来源于百度百科

1. 如何根据连续系统建立差分方程

1.1. 获取连续系统的传递函数

线性定常系统的控制中，PID 是个非常常见的控制方式，如果可以通过 Matlab 仿真出 PID 的控制效果图，那么对系统设计时的实时调试将会容易得多。在这里我们将会以一个利用系统辨识参数的 PID 设计为为例展示 Matlab 仿真 PID 的过程。

首先需要对一个未知的系统的参数进行辨识，以延迟环节可以忽略不计的电机调速系统为例。将时间戳导入 xdata 向量，对应的时刻转速导入 ydata 向量，进行系统辨识

• Matlab 对指定参数的曲线进行非线性拟合_matlab 非球面方程拟合 - CSDN 博客

  https://blog.csdn.net/weixin_44044411/article/details/85636950

我们就以上文链接中辨识的系统传递函数为例：

$ G (s)=\frac {0.998}{0.021s+1} $ 因此通过 tf 函数建立系统结构体如下：

sys=tf (0.998,[0.021,1]);   % 建立被控对象传递函数，即式 4.1

1.2. 获取离散系统的传递函数

由于是数字 PID 仿真，我们需要选取一个采样时间，本案例选用的是 0.005s（注意，采样周期应该小于系统纯滞后时间的 0.1 倍）。在对其进行数字 PID 控制前，我们需要将这个系统离散化：

ts=0.005;  % 采样时间 = 0.005s
dsys=c2d (sys,ts,'z');  % 离散化

dsys 即我们根据采样周期离散化的 Z 变换系统。首先我们需要提取这个 Z 变化 d 那系统的参数方便后面的计算：

[num,den]=tfdata (dsys,'v');%'v' 代表强制以向量的格式（默认为元胞数组）输出 num 和 den

1.3. 转换为差分方程

求解出的 Z 变换表达式为 d s y s = n u m ( 1 ) ⋅ z + n u m ( 2 ) d e n ( 1 ) ⋅ z + d e n ( 2 ) = 0.2114 z − 0.7881 dsys=\frac {num (1)\cdot z +num (2)}{den (1)\cdot z+den (2)}=\frac {0.2114}{z-0.7881} dsys=den(1)⋅z+den(2)num(1)⋅z+num(2)​=z−0.78810.2114​

在 PID 仿真的过程中我们需要求解出时域表达式，因此需要借助差分方程解决，对于以下的 Z 变换：

Y ( z ) = d s y s ⋅ U ( z ) = n u m ( 2 ) d e n ( 1 ) ⋅ z + d e n ( 2 ) ⋅ U ( z ) Y(z) = d_{sys} \cdot U(z) = \frac{num(2)}{den(1) \cdot z + den(2)} \cdot U(z) Y(z)=dsys​⋅U(z)=den(1)⋅z+den(2)num(2)​⋅U(z)

z Y ( z ) + d e n ( 2 ) Y ( z ) = n u m ( 1 ) z U ( z ) + n u m ( 2 ) U ( z ) zY(z) + den(2) Y(z) = num(1) zU(z) + num(2) U(z) zY(z)+den(2)Y(z)=num(1)zU(z)+num(2)U(z)

对上式进行反 Z 变换，可以得到以下的差分方程：

y ( k + 1 ) + d e n ( 2 ) y ( k ) = n u m ( 1 ) u ( k + 1 ) + n u m ( 2 ) u ( k ) y(k+1) + den(2) y(k) = num(1) u(k+1) + num(2) u(k) y(k+1)+den(2)y(k)=num(1)u(k+1)+num(2)u(k)

整理后可得：

y ( k + 1 ) = − d e n ( 2 ) y ( k ) + n u m ( 1 ) u ( k + 1 ) + n u m ( 2 ) u ( k ) y(k+1) = -den(2) y(k) + num(1) u(k+1) + num(2) u(k) y(k+1)=−den(2)y(k)+num(1)u(k+1)+num(2)u(k)

位置型 PID 仿真时实际上可以不需要保存前一个数据 u ( k ) u(k) u(k) 和 y ( k ) y(k) y(k)，增量型 PID 必须要保存前一个数据。这里我们使用了位置型 PID，但仍然利用 u 1 u_1 u1​ 和 y 1 y_1 y1​ 保存了上一个数据，仅仅是为了演示这一过程。

将公式进一步转换为下面的式子：

y ( k ) = − d e n ( 2 ) y 1 + n u m ( 1 ) u ( k ) + n u m ( 2 ) u 1 y(k) = -den(2) y_1 + num(1) u(k) + num(2) u_1 y(k)=−den(2)y1​+num(1)u(k)+num(2)u1​

我们的差分方程就这样建立完毕。注意，此差分方程仅仅是描述系统模型的运算规律的，和我们的控制无关。因此是 y ( k ) y(k) y(k) 和 u ( k ) u(k) u(k) 的映射关系。我们下面的控制则是利用负反馈信号 e ( k ) e(k) e(k) 导出 u ( k ) u(k) u(k) 的输出，求解的是控制器 u ( k ) u(k) u(k) 的序列值。

2. 基本 PID 控制原理

以位置型 PID 控制为例。将连续的 PID 控制转换为数字式时，微分环节被用差分代替，积分环节被累加和代替，比例环节则保持不变。差分的实现非常简单，只需要用 $ e (k+1)-e (k) $ 即 $ e (k)-e_1 $ 等效即可。积分的实现在每一次运算的后面都累加原来的误差，即 Ee=Ee+e_1; 即可。PID 的控制器输出 $ u (k)=Kp\cdot e (k)+Kd\cdot (e (k)-e_1)+Ki\cdot Ee$

PID 控制器构造完毕，我们需要通过 r (k) 和 y (k) 得到 e (k)，再通过 e (k) 得出 u (k)，进而再求解出 y (k)，再结合 r (k) 求解出 e (k),… 以此循环，求解出离散的响应点。

详细的代码如下：

ts=0.005;  %采样时间=0.005s
sys=tf(0.998,[0.021,1]);   %建立被控对象传递函数，即式4.1
dsys=c2d(sys,ts,'z');      %离散化
[num,den]=tfdata(dsys,'v');   %
e_1=0;      %前一时刻的偏差      
Ee=0;       %累积偏差
u_1=0.0;    %前一时刻的控制量
y_1=0;       %前一时刻的输出
%PID参数
kp=0.22;    
ki=0.13;
kd=0;
u=zeros(1,1000);%预先分配内存
time=zeros(1,1000);%时刻点（设定1000个）
for k=1:1:1000
    time(k)=k*ts;   %时间参数
    r(k)=1500;      %期望值
    y(k)=-1*den(2)*y_1+num(2)*u_1+num(1)*u(k);%系统响应输出序列
    e(k)=r(k)-y(k);   %误差信号
    u(k)=kp*e(k)+ki*Ee+kd*(e(k)-e_1); %系统PID控制器输出序列
    Ee=Ee+e(k);    %误差的累加和
    u_1=u(k);    	%前一个的控制器输出值
    y_1=y(k);    	%前一个的系统响应输出值
    e_1=e(k);		%前一个误差信号的值
end
%（仅绘制过渡过程的曲线，x坐标限制为[0,1]）
p1=plot(time,r,'-.');xlim([0,1]);hold on;%指令信号的曲线（即期望输入）
p2=plot(time,y,'--');xlim([0,1]);%不含积分分离的PID曲线
hold on;

输出的 PID 控制曲线如下：

3. 比较 PID 输出，分析参数产生的影响

一个基本的 PID 就完成了。下面如果我们想要知道修改 PID 的三个参数 kp,ki,kd 会带来什么效果，只需要在程序中修改即可。为了方便起见，我们建立一个 PID 的数组，kp,ki,kd 每次都取数组的一个值，然后设定一个大循环开始循环仿真。再利用 subplot 输出子图的方式将所有的 PID 效果都输出到一个图进行对比。该代码根据上述代码修改已经很容易，PID 比较图的代码如下：

close all
PID=[0.22,0.13,0;
    0.4,0.13,0;
    0.4,0.25,0;
    0.8,0.23,0.4;
    0.8,0.2,1;
    0.7,0.2,0.9];%初始化PID参数
for pid=1:1:6
ts=0.005;  %采样时间=0.005s
sys=tf(0.998,[0.021,1]);   %建立被控对象传递函数，即式4.1
dsys=c2d(sys,ts,'z');      %离散化
[num,den]=tfdata(dsys,'v');   %
e_1=0;      %前一时刻的偏差      
Ee=0;       %累积偏差
u_1=0.0;    %前一时刻的控制量
y_1=0;       %前一时刻的输出
%PID参数
kp=PID(pid,1);    
ki=PID(pid,2);
kd=PID(pid,3);
u=zeros(1,1000);
time=zeros(1,1000);
for k=1:1:1000
    time(k)=k*ts;   %时间参数
    r(k)=1500;      %给定量
    y(k)=-1*den(2)*y_1+num(2)*u_1+num(1)*u(k);
    e(k)=r(k)-y(k);   %偏差
    u(k)=kp*e(k)+ki*Ee+kd*(e(k)-e_1);   
    Ee=Ee+e(k);    
    u_1=u(k);    
    y_1=y(k);    
    e_1=e(k);
end
subplot(2,3,pid);
p1=plot(time,r,'-.');xlim([0,1]);hold on;
p2=plot(time,y,'--');xlim([0,1]);
title(['Kp=',num2str(kp),' Ki=',num2str(ki),' Kd= ',num2str(kd)]);
hold on;
end

输出的子图矩阵如下：

可以发现，修改 Kp 会造成上升时间的缩短，但是有可能也会带来较大的超调。积分的增加是一个严重的滞后环节，会减小相位裕度，也会带来超调（超调量并不是绝对的，相对于较小的 Kp 可能会产生较大的超调，而 Kp 较大时超调会减小（例如第一行的 1 图和 2 图的对比））。然而积分的引入也是必要的，否则将会很长时间无法削弱误差 e (k)（例如第二行第二个图）。微分的引入相当于一个超前校正，会减少超调，但是过渡的微分很可能会造成尾部振荡，系统逐渐变得不稳定。因此微分和积分之间需要一个平衡，当满足这个平衡的时候，系统几乎没有振荡，同时响应速度也较快。（第一行的图 3 是积分过多，产生超调，第二行的图 1 和图 3 就比较理想）

综合上述，PID 的调节经验可以归结为以下几点：

• Kp 较小时，系统对微分和积分环节的引入较为敏感，积分会引起超调，微分可能会引起振荡，而振荡剧烈的时候超铁也会增加。

• Kp 增大时，积分环节由于滞后产生的超调逐渐减小，此时如果想要继续减少超调可以适当引入微分环节。继续增大 Kp 系统可能会不太稳定，因此在增加 Kp 的同时引入 Kd 减小超调，可以保证在 Kp 不是很大的情况下也能取得较好的稳态特性和动态性能。

• Kp 较小时，积分环节不宜过大，Kp 较大时积分环节也不宜过小（否则调节时间会非常地长），在下面这个例子中我们还会介绍到，当使用分段 PID，在恰当的条件下分离积分，可以取得更好的控制效果。原因在于在稳态误差即将满足要求时，消除了系统的滞后。因此系统超调会明显减少。本例中采样的抗积分饱和的方法是遇限削弱积分法。

4. 改进 PID 算法（遇限削弱积分法）

遇限削弱积分法的原理是

当 u ( k ) > u m a x u (k)>u_{max} u(k)>umax​ 时，若 e (k)>0 即输出值还未到达指定值，则认为积分会带来滞后，不再积分。

当 u ( k ) < 0 u (k)<0 u(k)<0 时，若 e (k)<0 即输出值超过了指定值，则认为积分会带来滞后，不再积分。

在本案例中认为 u m a x = r ( k ) u_{max}=r (k) umax​=r(k)

改进 PID 算法如下（需要些两个循环，当然也可以用一个循环，将其中的 PID 设为一个子过程调用）：

close all
ts=0.005;  %采样时间=0.005s
sys=tf(0.998,[0.021,1]);   %建立被控对象传递函数，即式4.1
dsys=c2d(sys,ts,'z');      %离散化
[num,den]=tfdata(dsys,'v');   %
e_1=0;      %前一时刻的偏差      
Ee=0;       %累积偏差
u_1=0.0;    %前一时刻的控制量
y_1=0;       %前一时刻的输出
%PID参数
kp=0.22;    
ki=0.13;
kd=0;
u=zeros(1,1000);
time=zeros(1,1000);
for k=1:1:1000
    time(k)=k*ts;   %时间参数
    r(k)=1500;      %给定量
    y(k)=-1*den(2)*y_1+num(2)*u_1+num(1)*u(k);
    e(k)=r(k)-y(k);   %偏差
    u(k)=kp*e(k)+ki*Ee+kd*(e(k)-e_1);   
    Ee=Ee+e(k);    
    u_1=u(k);    
    y_1=y(k);    
    e_1=e(k);
end
p1=plot(time,r,'-.');xlim([0,1]);hold on;
p2=plot(time,y,'--');xlim([0,1]);
hold on;
a=1;%控制积分分离的二值数
e_1=0;Ee=0;u_1=0.0;y_1=0;%重新初始化       
for k=1:1:1000
    time(k)=k*ts;   %时间参数
    r(k)=1500;      %给定量
    y(k)=-1*den(2)*y_1+num(2)*u_1;
    e(k)=r(k)-y(k);   %偏差
    u(k)=kp*e(k)+ki*Ee+kd*(e(k)-e_1);   
     if ((u(k)>r(k)) && (e(k)>0))||((u(k)<0) && (e(k)<0))
         a=0;
     else 
         a=1;
     end     
    Ee=Ee+a*e(k);    
    u_1=u(k);    
    y_1=y(k);    
    e_1=e(k);
end
p3=plot(time,y,'-');xlim([0,1]);
title('含积分分离与不含积分分离的对比');
legend([p1,p2,p3],'指令信号','不含积分分离','含积分分离');

输出的曲线对比图如下：

可以发现，系统的超调量明显减少了，调节时间也减少了一点。原因在于我们采用了分段 PID 的手段，既消除了稳态误差还削弱了积分环节带来的滞后影响。

5.simulink 仿真

需要的模块名称（不区分大小写）如下：

• gain（参数分别为 0.22 和 0.13/0.005）

• sum（参数分别为 “|±” 和 “|++”）

• integrator

• scope

  注意：本文使用的是离散 PID 仿真，而 simulink 使用的是连续系统仿真，转换 PID 参数时 P 参数不变，I 参数应该除以仿真间隔 Ts=0.005，D 参数应该乘 Ts。

以表中第一组 PI 参数为例：

得到的示波器曲线如下：

……

---

模糊控制算法实例解析（含代码）

老 A 的 AI 实验室 于 2017-02-22 19:45:51 发布

首先来看一个实例，控制进水阀 S1 和出水阀 S2，使水箱水位保持在目标水位 O 处。

按照日常操作经验，有以下规则：

1、 若当前水位高于目标水位，则向外排水，差值越大，排水越快；

2、 若当前水位低于目标水位，则向内注水，差值越大，注水越快；

3、 若当前水位和目标水位相差很小，则保持排水速度和注水速度相等。

下面来设计一个模糊控制器

1、选择观测量和控制量

一般选择偏差 e，即目标水位和当前水位的差值作为观察量，选取阀门开度 u 为控制量。

2、输入量和输出量的模糊化

将偏差 e 划分为 5 个模糊集，负大 (NB)、负小 (NS)、零 (ZO)、正小 (PS)、正大 (PB)，e 为负表示当前水位低于目标水位，e 为正表示当前水位高于目标水位。设定 e 的取值范围为 [-3，3]，隶属度函数如下。

偏差 e 对应的模糊表如下：

同样将控制量 u 划分为 5 个模糊集，负大 (NB)、负小 (NS)、零 (ZO)、正小 (PS)、正大 (PB)，u 为负表示增大进水阀门 S1 的开度 (同时减小出水阀门 S2 的开度)，u 为正表示减小进水阀门 S1 的开度 (同时增大出水阀门 S2 的开度)。设定 u 的取值范围为 [-4，4]，隶属度函数如下。

控制量 u 对应的模糊表如下：

3、制定模糊规则

模糊规则的制定是模糊控制的核心内容，控制性能的好坏很大程度上由模糊规则决定，目前主要是根据经验来制定相应的规则。【后面可以结合神经网络来学习模糊规则】

（1）若 e 负大，则 u 负大；

（2）若 e 负小，则 u 负小；

（3）若 e 为零，则 u 为零；

（4）若 e 正小，则 u 正小；

（5）若 e 正大，则 u 正大；

将上述用语言描述的规则转化为’’IF A THEN B’’的语句如下：

4、求解模糊关系

根据制定的模糊规则，通过相应的模糊集合运算，可得到模糊关系集合 R。

5、进行模糊决策

我们最终需要获得的控制量 u 即为模糊控制的输出，u 可由偏差矩阵 e 和模糊关系矩阵 R 合成得到。

u = e ∘ R u=e\circ R u=e∘R

6、控制量的反模糊化

我们模糊决策得到的控制量 u 是一个矩阵，并不能直接应用在工程上，因此需要将 u 解释为实际中的特定行为，即反模糊化操作。目前常用的反模糊化方法有以下几种：

（1）最大隶属度法 ---- 计算简单控制要求不高场合

（2）重心法 ---- 输出更平滑

（3）加权平均法 ---- 工业上应用最广泛

具体方法的介绍请参照刘金琨《智能控制》一书 P45-P46，博文最后会附上书籍相关链接。

7、matlab 实现

所幸的是，在 matlab 模糊控制工具箱中已经帮我们实现了 4-6 步求解矩阵运算的操作，只需要直接调用 evalfis 函数就可以得到相应的决策控制量。

通过 matlab 集成的模糊控制模块，我们能够更加方便地对应偏差 e 和控制量 u 的关系，并可以调节 e 在不同值下 u 的对应输出。

Matlab 程序

%水位模糊控制算法
clear all;
close all;
 
a = newfis('fuzzy tank');
 
a = addvar(a,'input','e',[-3,3]);
a = addmf(a,'input',1,'NB','zmf',[-3,-1]);
a =addmf(a,'input',1,'NS','trimf',[-3,-1,1]);
a =addmf(a,'input',1,'ZO','trimf',[-2,0,2]);
a =addmf(a,'input',1,'PS','trimf',[-1,1,3]);
a = addmf(a,'input',1,'PB','smf',[1,3]);
 
a = addvar(a,'output','u',[-4,4]);
a = addmf(a,'output',1,'NB','zmf',[-4,-2]);
a =addmf(a,'output',1,'NS','trimf',[-4,-2,0]);
a =addmf(a,'output',1,'ZO','trimf',[-2,0,2]);
a =addmf(a,'output',1,'PS','trimf',[0,2,4]);
a = addmf(a,'output',1,'PB','smf',[2,4]);
 
%建立模糊规则
rulelist=[1 1 1 1;
         2 2 1 1;
         3 3 1 1;
         4 4 1 1;
         5 5 1 1];
a = addrule(a,rulelist);
 
%设置反模糊化算法
a1 = setfis(a,'DefuzzMethod','mom');
writefis(a1,'tank');
a2 = readfis('tank');
 
figure(1);
plotfis(a2);
figure(2);
plotmf(a,'input',1);
figure(3);
plotmf(a,'output',1);
 
 
showrule(a);
ruleview('tank');
 
for i=1:1:7
   e(i)=i-4;
   Ulist(i)=evalfis([e(i)],a2);
end
Ulist = round(Ulist);  %对决策结果四舍五入取整
 
disp('------------------------------------------------------');
disp('----------模糊控制表：e =[-3,3], u = [-4,4]-----------');
disp('------------------------------------------------------');
fprintf('| a  |');
fprintf(' %d  |',e);
fprintf('\n');
fprintf('| u  |');
fprintf(' %d  |',Ulist);
fprintf('\n');

备注：

1、模糊规则矩阵 rulelist 的含义：模糊矩阵是由模糊规则转化而来，这里矩阵规模为 5*4，矩阵第一列表示输入 e (5 个模糊集合 PB/PS/ZO/NS/NB 依次对应 1-5)，矩阵第二列表示输出 u (含义同理)，第三列为规则的权重 weight，第四列为 AND 模糊运算 (1 对应 AND，2 对应 OR)，如果是多输入多数出模糊控制器，规则列表的含义请参考：

The first mcolumns refer to the inputs of the system. Each column contains a number thatrefers to the index of the membership function for that variable.

The next n columns refer to the outputs of thesystem. Each column contains a number that refers to the index of themembership function for that variable.

The m + n + 1 column contains the weight that isto be applied to the rule. The weight must be a number between zero and one andis generally left as one.

The m + n + 2 column contains a 1 if the fuzzyoperator for the rule’s antecedent is AND. It contains a 2 if the fuzzyoperator is OR.

2、设置反模糊化方法 setfis (a,‘DefuzzMethod’,‘mom’); 反模糊化方法不同最终输出控制量也不同。

mom 最大隶属度平均法

centroid 面积重心法

bisector 面积等分法

som 最大隶属度取小法

lom 最大隶属度去大法

3、如果要对决策结果取整有三种方法：round（四舍五入）、ceil（向上取整）、floor（向下取整）。

最后总结一下模糊控制器的设计步骤：

参考书籍：

刘金琨《智能控制》

---

Matlab 中模糊控制器的使用

老 A 的 AI 实验室 于 2017-02-23 11:42:18 发布

在上一篇博客《模糊控制算法实例解析（含代码）》中我们通过控制水位的实例来掌握一般问题的模糊控制器的设计流程，并给出了 matlab 代码的实现，就简单的水位控制而言，我们可以直接通过 matlab 集成的模糊控制模块进行可视化操作设计模糊控制器，脱离了代码的编写也可以实现完全相同的功能。本篇博客同样是基于水位控制问题对 matlab 集成的 FIS 模块的设计进行详细说明。

1 通过控制台打开 FIS 编辑器

直接输入 fuzzy 命令即可进入 FIS 编辑器

2 新建模糊控制系统

直接 Ctrl+S 就可以了：

编辑器菜单各功能介绍

3 编辑输入输出变量

对控制系统的输入输出变量进行编辑，双击设置相应的隶属度函数。

输入模块菜单介绍：

设置完后的界面，输出变量按照同样的步骤进行设置即可。

4 编写模糊规则

双击 PIS Editor 中间白色部分或者通过菜单栏进入模糊规则的编写。

通过经验得到模糊规则并将输入模糊子集和输出模糊子集之间进行规则对应。

规则菜单栏说明：

编辑模糊规则后的界面

这个其实与 matlab 中程序对应

5 规则观察器和模糊推理框图

至此，水位控制的模糊控制器已经设计完成，可以通过 View-rules 来查看规则视图，可在线改变输入 e 得到输出 u。

最后回过头来打开模糊控制系统文件 water_demo.fis，可以清楚地看到整个系统的设计细节。

是不是很简单？通过以上的讲解说明，相信你一定能够很好地掌握模糊控制器的设计:）

---

via:

• 控制算法（一）—— PID 控制算法 - CSDN 博客 fxfreefly 于 2020-03-17 17:25:43 发布
  https://blog.csdn.net/bhniunan/article/details/104925982

• 控制算法（二）—— 模糊控制算法 - CSDN 博客 fxfreefly 于 2020-03-19 17:24:29 发布
  https://blog.csdn.net/bhniunan/article/details/104970923

• 模糊 PID 控制的规则表一点理解_模糊 pid 规则表是如何得到的 - CSDN 博客 *hasee_z6 已于 2022-10-27 20:17:12 修改 *
  https://blog.csdn.net/qq_36262908/article/details/127006503

• PID 控制算法介绍与 C 程序实现_pid 控制程序 - CSDN 博客 爱上电路设计 已于 2024-06-04 17:33:19 修改
  https://liht1634.blog.csdn.net/article/details/124217581

• PID 算法详解_继电器控制加热器 pid 算法程序 - CSDN 博客 计算机小混子
  已于 2023-03-03 14:14:58 修改
  https://blog.csdn.net/Johnor/article/details/129319285

• 一文读懂 PID 控制算法（抛弃公式，从原理上真正理解 PID 控制）-CSDN 博客 确定有穷自动机 于 2018-07-12 10:54:54 发布
  https://blog.csdn.net/qq_25352981/article/details/81007075

• 模糊控制数学基础（模糊推理）-CSDN 博客 ksjz123 于 2017-10-12 12:59:20 发布
  https://blog.csdn.net/ksjz123/article/details/78213662

• 模糊 PID（自适应模糊 PID、fuzzy PID）的基本原理及应用举例 by 研三笔记-CSDN博客 干了这碗汤 已于 2024-07-23 17:36:54 修改
  https://blog.csdn.net/weixin_43321489/article/details/113819404

• 飞思卡尔智能车 ---- 模糊 PID 算法通俗讲_汽车运动控制模糊 pid-CSDN 博客 我爱广工大于 2018-02-02 11:14:15 发布
  https://blog.csdn.net/weixin_36340979/article/details/79168052

• MATLAB 模糊 PID 实现（全流程详细报告 + 附实现代码）-CSDN 博客 孟秋廿二 于 2020-10-11 13:53:54 发布
  https://blog.csdn.net/qq_40841018/article/details/109011061

• Matlab 仿真 PID 控制（带 M 文件、simulink 截图和参数分析）非线性光学元件 于 2019-01-06 10:16:09 发布
  https://blog.csdn.net/weixin_44044411/article/details/85891109

• 模糊控制算法实例解析（含代码）_模糊控制实例 - CSDN 博客 老 A 的 AI 实验室 于 2017-02-22 19:45:51 发布
  https://blog.csdn.net/acelit/article/details/56495284

• Matlab 中模糊控制器的使用_怎么打开之前保存的模糊控制器文件 - CSDN 博客 老 A 的 AI 实验室 于 2017-02-23 11:42:18 发布
  https://blog.csdn.net/acelit/article/details/56667907

标签：输出,控制器,模糊,模糊控制,控制,PID,控制算法,0.5
From： https://blog.csdn.net/u013669912/article/details/143583368