模糊算法的研究和C语言实现--包宇骅

模糊算法是通过对现实对象的分析，处理数据并构建模糊型数学模型。用隶属关系将数据元素集合灵活成模糊集合，确定隶属函数，进行模糊统计多依据经验和人的心理过程，它往往是通过心理测量来进行的，它研究的是事物本身的模糊性。

近年来，智能控制理论和方法的研究受到国内外众多专家和学者的高度重视，并取得了许多成功的实例。目前，对于工业过程控制，实用的智能控制方法主要有两种：专家式控制和模糊控制，它们的特点是基于“专家”经验设计控制器，而无需考虑工业对象具体物理模型，尤其是后一种方法，由于它利用了模糊推理，已形成了一套较为规范的设计程序，且成功实例较多，故目前模糊控制算法的研究较为活跃。

模糊控制的特点

①适用于不易获得精确数学模型的被控对象； ②是一种语言变量控制器；

③从属于智能控制的范畴。该系统尤其适于非线性，时变，滞后系统的控制； ④抗干扰能力强，响应速度快，并对系统参数的变化有较强的鲁棒性。

模糊控制的原理

把由各种传感器测出的精确量转换成为适于模糊运算的模糊量,然后将这些量在模糊控制器中加以运算, 最后再将运算结果中的模糊量转换为精确量, 以便对各执行器进行具体的操作控制，在模糊控制中, 存在着一个模糊量和精确量之间相互转化的问题。

s:系统的设定值；

x1, x2:模糊控制的输入(精确量)； X1 , X2:模糊量化处理后的模糊量；

U:经过模糊控制规则和近似推理后得出的模糊控制量； u:经模糊判决后得到的控制量(精确量)； y:对象的输出。 也可以表示成：

工作步骤：输入量模糊化、建立模糊规则、进行模糊推理、输出量反模糊。

模糊控制的优点：

传统的自动控制控制器的综合设计都要建立在被控对象准确的数学模型(即传递函数模型或状态空间模型)的基础上，但是在实际中，很多系统的影响因素很多，油气混合过程、缸内燃烧过程等) ，很难找出精确的数学模型。这种情况下，模糊控制的诞生就显得意义重大。因为模糊控制不用建立数学模型不需要预先知道过程精确的数学模型。

模糊算法的应用

基于遗传算法的模糊滑模控制器设计及其在直流伺服系统中的应用 滑模控制因其设计简单，对控制对象参数变化及外扰动的不变性等优点而被广泛用于工业生产过程，尤其在伺服系统的控制中取得了成功的应用［1～3］，但是传统滑模控制存在一个突出的缺点，即抖振。为解决这一问题出现了模糊滑模控制［4，5］，通过在边界层内根据滑动模变量s的模糊量，决定控制量u，进而实现对u的“柔化”，以消弱抖动。但是上述模糊滑模控制方案难以保证边界层内滑动模态的可达性，因而也就失去了滑模控制不变性的优点［6］。本文提出一种新的模糊滑模控制器设计方法，可充 分保证滑动模态的可达性。由于模糊控制量与滑模变量之间无直接对应关系，按照专家经验采用启发式设计方案难度较大，而且难以保证设计参数的最优性，为此，本文通过采用遗传算法对控制器模糊项参数进行寻优设计。

考虑如下动态系统

x(n)=f(x,，…,x(n-1)）+bu b>0 (1)

其中状态向量(x,，…,x(n-1)）=XT，假设

f(.)=

其中

(.)+Δf(.) (2)

是f的估计值，Δf为模型的不确定性，F是Δf的上界函数，即

｜Δf(.)｜≤F(.) (3)

为讨论方便，先假设b=1,u为系统输入，控制目标是在系统存在不确定性的情况下，使系统状态向量跟踪预先选定的轨迹Xr,XTr=(xr,r，…,x(n-1)r）。定义误差向量

(4)

于是系统(1)可以表示成如下状态方程

在传统SMC设计中，首先定义一个滑动平面

(5)

(6)

这里CT=(c1,c2,…,cn)是滑动平面系数，满足霍尔维兹多项式，不失一般性，取cn=1。滑模控制的一个基本思想是要求通过等价控制量ueq保持状态在滑动平面上，由

这里

Te-f(xTr-eT)-u+x(n)r=0 (7)

=(0,c1,c2,…,cn-1)，得到等价控制量ueq

(8)

可以保证系统状态到达滑动平面后，保持在滑动平面上，为实现滑动模态的存在及可达，还要求存在一不连续控制分量

(9)

以实现s.<0，即满足可达性条件，因此整个控制量为

u=ueq+ud (10)

然而，由于系统具有不确定性，ueq难以精确获得，因此考虑不确定性后有

ueq=

把式(9)，式(11)代入式(6)得

Te-(xTr-eT)+x(n)r (11)

(12)

由s.<0，得

ud=(F(.)+η)sgn(s) η>0 (13)

考虑一般性，b≠1，且b具有不确定性，假设

β-1≤/b≤β (14)

其中为b的估计值，β大于或等于1，那么取式(10)控制律为

u=-1(ueq+ud)=eq+d (15)

进而得到

ud=［β(F(.)+η)+(β-1)｜eq｜］sgn(s) (16)

令Q=β(F(.)+η)+(β-1)｜eq｜，由前面有关参数的定义可知Q>0，若不考虑参数的不确定性，即β=1，F(.)=0，则Q=η。由分析可知，Q过小将影响非滑动模态到滑动模态的过渡时间或难以满足可达性条件；Q过大，将导致大的抖振。考虑参数不确定性，在仅知道参数上下界的情况下，会使Q取值过大，不可避免产生大的抖振。为尽量消除抖振现象，文献［4］，［5］提出在边界层内根据s的模糊值对Q值进行模糊调节，这一方法虽可以在边界层内起到柔化控制量u的作用，但由于参数的不确定性，对Q值的调节难以保证s.<0在边界层内成立，因为此时没有考虑的变化情况。本文提出一种模糊滑模控制器，该控制器根据滑模函数s及其导数的模糊值决定Q的变化量ΔQ。当s与符号相反时ΔQ取值小于或等于零，当s与同号时，ΔQ适当取正以使s.<0成立。ΔQ的模糊取值根据如下规则。 Ri If s is Ai and

is Bi then ΔQi is yi

规则中Ai,Bi表示模糊集，则规则集输出ΔQ与模糊规则之间可通过模糊推理机建立如下关系。

(17)

Ri表示第i条模糊规则，m表示模糊规则数，且有

μi=ΠμAi(s)μBi() (18)

(19)

μAi、μBi是s、的隶属度函数，定义如下

(20)

对αi、βi、γi有如下定义

(21)

式中αi0，βi0，γi0表示αi、βi、γi的初值，可结合一定的经验知识给出。

从以上对模糊控制器的结构分析可以发现，s和的隶属度函数参数αi、βi、γi与规则输出参数yi影响着模糊量ΔQ的值。而由式(21)可知，在αi0，βi0，γi0等初值给定情况下，αi，βi，γi是由δi，φ i决定的。所以对δi，φ i，yi寻优即可以实现模糊控制器参数优化设计。但是仅进行参数优化设计还难以实现真正的控制器优化，因为参数优化是在模糊集划分一定的情况下进行的，过多的模糊集划分将造成规则冗余，冗余的模糊规则必然会占用过多的存储空间，增大控制器决策时间。因此，对模糊集的划分同样需要寻优，以实现模糊控制器从结构到参数的最优设计。

2.柴油机转速模糊控制的一种算法及其实现 转速模糊控制算法及实现

仅考虑转速闭环时,柴油机转速模糊控制系统框图如图1 所示.

图1 中, R 为转速给定值; Y 为系统输出(实际转速值) ; E = Y - R 为转速偏差; EC 为转速偏差的变化率; A 为E 经模糊化处理后,论域为X 的模糊集; B 为EC 经模糊化处理后,论域为Y 的模糊集; C为论域为Z 的控制量模糊集;Δu 为C 经模糊判决后的控制增量;Δu*为清晰化计算出的实际控制增量.

2. 1 输入变量的模糊化

考虑到本文研究的转速控制系统被控对象是一台6135 型柴油机,最高转速为1 500 r/ min ,最低稳定转速为750 r/ min ,因此X 的论域可取为{ - 1 500 ,1 500} , y = { - 1 500 ,1 500} . 取转速偏差E 的论域为[ - 750 ,750 ] ,隶属函数取梯形2三角形式(见图2) .

转速偏差的语言变量E 在X 中取11 个语言值. 由图2 可见,每个模糊子集均可用以下两式表示:

μ( x) = ax + b (1) μ( x ) = - cx + d (2)

显然,对任意转速偏差输入,在进行模糊化过程中,只属于两个模糊子集,对其它模糊子集的隶属度为零,如此处理可简化计算,减少内存和时间开销. 其中,转速偏差分为5 个区域,即[0 , 10 ] , [10 , 110 ] ,[110 ,210 ] , [210 ,310 ] , [310 ,750 ] ,每个区域的隶属度按(1) 式和(2) 式计算,区别仅在于系数a , b , c , d各不相同,由于μ( x) 轴的左半部曲线与右半部取为完全轴对称,因此当转速偏差为负值时,其计算程序上与上述程序相同.

2. 2 模糊规则及模糊推理

考虑最简单的情况,模糊控制器采用一维结构时,其控制规则如下:

If E is ZE then Δu is ZE If E is PS then Δu is PS If E is PM then Δu is PM If E is PB then Δu is PB If E is PVB then Δu is PVB

其中: Δu 为模糊控制量的增量值, 当转速偏差E 为负值时, 规则同上, 只是Δu 的符号相应改变(Δu的符号与E 的符号一致) ; ZE ,S ,M ,B ,VB 分别表示输出增量Δu 为“零, 小, 中等, 大, 很大”, P 表示“Positive”,N 表示“Negative”.

由以上分析可见,虽然模糊控制规则共有9 条,但由于转速偏差E 符号不同时,其控制规则是对称的,因此在实施模糊推理时,只用到了5 条规则. 此外,由于任意转速偏差E 只可能属于两个模糊子集,因此在实际运算时,对应每个采样周期的转速偏差输入只可能激活两条规则,这样处理的结果是大大简化了计算,保证了实时控制对微处理器运算速度的需要.

模糊推理采用近似推理法则. 对于一条被激活的规则, 控制增量Δu 的隶属度按Mamdani 合成推理方法计算,即

由于此处只考虑转速误差E 作为模糊输入变量,因此输出增量Δu 的隶属度与输入变量的隶属度相同.

2. 3 清晰化计算

对应于每个采集周期的转速偏差值E ,由上述模糊决策过程激活2 条控制规则(当E 小于10 r/min 时仅激活一条规则) , 并可求出每条规则中模糊输出增量Δu 的隶属度值. Δu*的隶属函数取单值线函数, 即一系列的离散值(见图3) .

输出控制量是执行器闭环控制的给定值, 其论域为{0 , 100 %} , 则输出增量Δu* 的论域取值为{ - 100 % ,100 %} .

对于求出的模糊输出增量,采用重心法计算其精确输出增量值,即:

当采用一维模糊控制器时,对于上述的输入变量模糊隶属度函数的模糊推理方法,不难证明

因此上式的计算量很小,易于在单片机中实现.

结 论

在以80C196 KC 嵌入式16 位单片机为核心的柴油机数字调速系统中,根据上述算法设计了控制软件,并在6135 型柴油机上进行了实机试验. 图4 和图5 表示了柴油机低速空车接排时转速和齿杆位移变化的动态过程. 由图可见,在接排的瞬间,柴油机的转速急剧下降,与此同时,齿杆位移量几乎是呈直线增加到100 % ,说明控制器控制动作的快速性已达到极限. 事实上,通过一系列性能测试,以本文提出的模糊控制算法为基本控制策略的柴油机转速控制系统具有良好的动态性能,但若仅采用模糊控制,系统的稳态性能达不到一级调速精度. 可采用多种控制策略来改善系统的稳态性能,其中Fuzzy- PID 复合控制是提高系统控制精度的有效途径。

模糊控制算法的C语言实现

#include #include\"math.h\"

#define PMAX 100 #define PMIN -100 #define DMAX 100

#define DMIN -100

#define FMAX 100 /*语言值的满幅值*/ int PFF[4]={0,12,24,48}; /*输入量D语言值特征点*/ int DFF[4]={0,16,32,}; /*输出量U语言值特征点*/

int UFF[7]={0,15,30,45,60,75,90};

/*采用了调整因子的规则表,大误差时偏重误差,小误差时偏重误差变化*/ /*a0=0.3,a1=0.55,a2=0.74,a3=0. */ int rule[7][7]={

//误差变化率 -3,-2,-1, 0, 1, 2, 3 // 误差 {-6,-6,-6,-5,-5,-5,-4,}, // -3 {-5,-4,-4,-3,-2,-2,-1,}, // -2 {-4,-3,-2,-1, 0, 1, 2,}, // -1 {-4,-3,-1, 0, 1, 3, 4,}, // 0 {-2,-1, 0, 1, 2, 3, 4,}, // 1 { 1, 2, 2, 3, 4, 4, 5,}, // 2 { 4, 5, 5, 5, 6, 6, 6}}; // 3

/**********************************************************/

int Fuzzy(int P,int D) /*模糊运算引擎*/ {

int U; /*偏差,偏差微分以及输出值的精确量*/ unsigned int PF[2],DF[2],UF[4]; /*偏差,偏差微分以及输出值的隶属度*/

int Pn,Dn,Un[4];

long temp1,temp2;

/*隶属度的确定*/

/*根据PD的指定语言值获得有效隶属度*/ if(P>-PFF[3] && Pif(P<=-PFF[2]) {

Pn=-2;

PF[0]=FMAX*((float)(-PFF[2]-P)/(PFF[3]-PFF[2])); }

else if(P<=-PFF[1]) {

Pn=-1;

PF[0]=FMAX*((float)(-PFF[1]-P)/(PFF[2]-PFF[1])); }

else if(P<=PFF[0]) {

Pn=0;

PF[0]=FMAX*((float)(-PFF[0]-P)/(PFF[1]-PFF[0])); }

else if(P<=PFF[1]) {

Pn=1; PF[0]=FMAX*((float)(PFF[1]-P)/(PFF[1]-PFF[0])); }

else if(P<=PFF[2]) {

Pn=2; PF[0]=FMAX*((float)(PFF[2]-P)/(PFF[2]-PFF[1])); }

else if(P<=PFF[3]) {

Pn=3; PF[0]=FMAX*((float)(PFF[3]-P)/(PFF[3]-PFF[2])); } }

else if(P<=-PFF[3]) {

Pn=-2; PF[0]=FMAX; }

else if(P>=PFF[3]) {

Pn=3; PF[0]=0; }

PF[1]=FMAX-PF[0];

if(D>-DFF[3] && Dif(D<=-DFF[2]) {

Dn=-2;DF[0]=FMAX*((float)(-DFF[2]-D)/(DFF[3]-DFF[2])); }

else if(D<=-DFF[1]) {

Dn=-1;

DF[0]=FMAX*((float)(-DFF[1]-D)/(DFF[2]-DFF[1])); }

else if(D<=DFF[0]) {

Dn=0;

DF[0]=FMAX*((float)(-DFF[0]-D)/(DFF[1]-DFF[0])); }

else if(D<=DFF[1]) {

Dn=1;

DF[0]=FMAX*((float)(DFF[1]-D)/(DFF[1]-DFF[0])); }

else if(D<=DFF[2]) {

Dn=2; DF[0]=FMAX*((float)(DFF[2]-D)/(DFF[2]-DFF[1])); }

else if(D<=DFF[3]) {

Dn=3; DF[0]=FMAX*((float)(DFF[3]-D)/(DFF[3]-DFF[2])); } }

else if(D<=-DFF[3]) {

Dn=-2;

DF[0]=FMAX; }

else if(D>=DFF[3]) {

Dn=3;

DF[0]=0; }

DF[1]=FMAX-DF[0];

/*使用误差范围优化后的规则表rule[7][7]*/

/*输出值使用13个隶属函数,中心值由UFF[7]指定*/ /*一般都是四个规则有效*/ Un[0]=rule[Pn-1+3][Dn-1+3]; Un[1]=rule[Pn+3][Dn-1+3]; Un[2]=rule[Pn-1+3][Dn+3]; Un[3]=rule[Pn+3][Dn+3]; if(PF[0]<=DF[0]) UF[0]=PF[0]; else

UF[0]=DF[0]; if(PF[1]<=DF[0]) UF[1]=PF[1]; else

UF[1]=DF[0]; if(PF[0]<=DF[1]) UF[2]=PF[0]; else

UF[2]=DF[1]; if(PF[1]<=DF[1]) UF[3]=PF[1]; else

UF[3]=DF[1];

/*同隶属函数输出语言值求大*/

if(Un[0]==Un[1]) {

if(UF[0]>UF[1]) UF[1]=0; else

UF[0]=0; }

if(Un[0]==Un[2]) {

if(UF[0]>UF[2]) UF[2]=0; else

UF[0]=0; }

if(Un[0]==Un[3]) {

if(UF[0]>UF[3]) UF[3]=0; else

UF[0]=0; }

if(Un[1]==Un[2]) {

if(UF[1]>UF[2]) UF[2]=0; else

UF[1]=0; }

if(Un[1]==Un[3]) {

if(UF[1]>UF[3]) UF[3]=0; else

UF[1]=0; }

if(Un[2]==Un[3]) {

if(UF[2]>UF[3]) UF[3]=0; else

UF[2]=0; }

/*重心法反模糊*/

/*Un[]原值为输出隶属函数标号，转换为隶属函数值*/ if(Un[0]>=0)

Un[0]=UFF[Un[0]]; else

Un[0]=-UFF[-Un[0]]; if(Un[1]>=0)

Un[1]=UFF[Un[1]]; else

Un[1]=-UFF[-Un[1]]; if(Un[2]>=0)

Un[2]=UFF[Un[2]]; else

Un[2]=-UFF[-Un[2]]; if(Un[3]>=0)

Un[3]=UFF[Un[3]]; else

Un[3]=-UFF[-Un[3]];

temp1=UF[0]*Un[0]+UF[1]*Un[1]+UF[2]*Un[2]+UF[3]*Un[3]; //因为选定隶属函数为三角形，且对称，故可以证明中心在中间的特征点上（横坐标）。 temp2=UF[0]+UF[1]+UF[2]+UF[3]; U=temp1/temp2;

return U; //最后的输出 }

void main() {

int a=0,e,ec;

/*int nowpoint,p1,p2=1; FILE *in,*out;

in=fopen(\"in.txt\

out=fopen(\"out.txt\//while(!feof(in)) while(1) {

//fscanf(in,\"%d\ //p1=nowpoint; //e=0-nowpoint; //ec= p1-p2;

printf(\"请输入e:\"); scanf(\"%d\

printf(\"请输入ec:\"); scanf(\"%d\ a=Fuzzy(e,ec);

//fprintf(out,\"%d \ //printf(\"%d: \

printf(\"e: %d ec: %d \ printf(\"a: %d \\n\ //p2=p1; }

//fclose(in); //fclose(out); }