基于模糊控制的速度跟踪控制问题(C语言以及MATLAB仿真实现)

基于模糊控制的速度控制

——地面智能移动车辆速度控制系统问题描述

利用模糊控制的方法解决速度跟踪问题，即已知期望速度(desire speed)，控制油门(throttle output)和刹车(brake output)来跟踪该速度。已知输入：车速和发动机转速（值可观测）。欲控制刹车和油门电压（同一时刻只有一个量起作用）。

算法思想

模糊控制器是一语言控制器，使得操作人员易于使用自然语言进行人机对话。模糊控制器是一种容易控制、掌握的较理想的非线性控制器，具有较佳的适应性及强健性(Robustness)、较佳的容错性(Fault Tolerance)。利用控制法则来描述系统变量间的关系。不用数值而用语言式的模糊变量来描述系统，模糊控制器不必对被控制对象建立完整的数学模式。

Figure 1模糊控制器的结构图

模糊控制的优点：

(1)模糊控制是一种基于规则的控制，它直接采用语言型控制规则，出发点是现场操作人员的控制经验或相关专家的知识，在设计中不需要建立被控对象的精确的数学模型，因而使得控制机理和策略易于接受与理解，设计简单，便于应用。

(2)由工业过程的定性认识出发，比较容易建立语言控制规则，因而模糊控制对那些数学模型难以获取，动态特性不易掌握或变化非常显著的对象非常适用。

(3)基于模型的控制算法及系统设计方法，由于出发点和性能指标的不同，容易导致较大差异；但一个系统语言控制规则却具有相对的独立性，利用这些控制规律间的模糊连接，容易找到折中的选择，使控制效果优于常规控制器。

(4)模糊控制是基于启发性的知识及语言决策规则设计的，这有利于模拟人工控制的过程和方法，增强控制系统的适应能力，使之具有一定的智能水平。

简化系统设计的复杂性，特别适用于非线性、时变、模型不完全的系统上。

模糊控制的缺点

1.模糊控制的设计尚缺乏系统性，这对复杂系统的控制是难以奏效的。所以如何建立一套系统的模糊控制理论，以解决模糊控制的机理、稳定性分析、系统化设计方法等一系列问题；

2.如何获得模糊规则及隶属函数即系统的设计办法，这在目前完全凭经验进行；

3.信息简单的模糊处理将导致系统的控制精度降低和动态品质变差。若要提高精度则必然增加量化级数，从而导致规则搜索范围扩大，降低决策速度，甚至不能实时控制；

4.如何保证模糊控制系统的稳定性即如何解决模糊控制中关于稳定性和鲁棒性问题。实现步骤以及算法

利用一般控制系统的架构，其中包含五个主要部分：定义变量、模糊化、知识库、逻辑判断及去模糊化，下面将就每一部分做简单的说明：

(1) 定义变量

也就是决定程序被观察的状况及考虑控制的动作，控制变量的选择要能够具有系统特性，而控制变量选择是否正确，对系统的性能将有很大的影响。在此控制问题上，输入变量有速度误差和实际速度，而控制变量则为下一个状态之输出油门和刹车。作为模糊控制器的语言变量，而如何选择则有赖工程师对于系统的了解和专业知识而定。因此，经验和工程知识在选择控制变量时占有相当重要的角色。

(2) 模糊化（fuzzify）

将输入值以适当的比例转换到论域的数值，利用口语化变量来描述测量物理量的过程，依适合的语言值（linguistic value）求该值相对之隶属度，此口语化变量我们称之为模糊子集合（fuzzy subsets）。当控制变量确定之后，接下来就是根据经验写出控制规则，但是在做成模糊控制规则之前，首先必需对模糊控制器的输入和输出变量空间做模糊分割。

本案例中输入空间有两个变量，可以用三个或五个模糊集合对空间做模糊分割，划分成三个或五个区域。由于程序实现的复杂性，暂时设置为三个。

模糊分割时各领域间重叠的程度大大地影响控制的性能；一般而言，模集合重叠的程度并没有明确的决定方法，目前大都依靠模拟和实验的调整决定分割方式，不过有文献提出大约1/3~1/2最为理想。重叠的部份意味着模糊控制规则间模糊的程度，因此模糊分割是模糊控制的重要特征。

由于隶属度函数是连续型的，这里采用高斯型的隶属函数。

Figure 2 速度误差的隶属度函数

即v ?的隶属度函数分别为： 110()

26120

()26

1

30

()261 0<10:() 10:() 30

:() 1 30v v v v P S v e v P M v e

e v P B v v μμμ?--?--

?--?

?=???≥??=???

??≥? 110

()26120

()26

1

30

()261 10<0

:() 10:() 30<0

:() 1 30

v v v v N S v e

v N M v e

e v N B v v μμμ?+-?+-

?+--?

?=???≤-??=??-?

??≤-?

其中左边为误差为正的情况，此时只有油门的输出，右边为误差为负的情况，此时只有

刹车的输出。

实际速度的隶属函数同样采用高斯型的，其图像同样如图Figure 1： 110()

26

120

()26

130()261 10<0:() 10:() 30<0:() 1 30

v v v v S v e v M v e

e v B v v μμμ----

---

=??≤-?=??-<=??≤-?

油门输出的隶属函数： 刹车输出的隶属函数：

1150()

2541300

()254

1

450

()2541 0

:() 1 t 450

t t t S v e M v e

e B v μμμ----

--

?=??≥?=??<=?

?≥? 18

()26

116()26

124

()26

:()

:():()v v v S b e

M b e

B b e

μμμ--

--

--

===

上式中，NB，NM，NS，ZO，PS，PM，PB等是论域中模糊集合的标记，其意义如下所示：

NB=负方向大的偏差(Negative Big)；

NM=负方向中的偏差(Negative Medium)；

NS=负方向小的偏差(Negative Small)；

ZO=近于零的偏差(Zero)；

PS=正方向小的偏差(Positive Small)；

PM=正方向中的偏差(Positive Medium)；

PB=正方向大的偏差(Positive Big)。

图中将模糊集合之全集合加以正规化为区间(0,1)，在模糊控制上，使用标准化的模糊变量，其全集也常正规化，这时之正规化常数（亦称为增益常数），也是在设计模糊控制器时必须决定的重要参数。

(3) 规则库

包括数据库（data base）与规则库（rule base）两部分，其中数据库是提供处理模糊数据之相关定义；而规则库则由一群语言控制规则描述控制目标和策略。控制规则是模糊控制器的核心，规则的正确与否直接影响控制器的性能，而规则数目的多寡也是一个重要因素，因此下面将对控制规则做进一步的探讨。

模糊控制规则的取得方式：

a．专家的经验和知识

前面曾经提到模糊控制也称为控制上的专家系统，专家的经验和知识是设计上有余力的线索。人类日常生活常中判断事情时，使用语言定性分析多于数值定量分析；而模糊控制规则提供了一个自然的架构来描述人类的行为及决策分析，并且专家的知识通常可用if….then 的型式来表示。

藉由询问经验丰富的专家，在获得系统的知识后，将知识改为if….then的型式，则如此便可构成模糊控制规则。为了获得最佳的系统性能，常需多次使用试误法，以修正模糊控制规则。

b．操作员的操作模式

现在流行的专家系统，其想法只考虑知识的获得，专家巧妙地操作复杂的控制对象，但要将专家的诀窍加以逻辑化并不容易；因此，在控制上也要考虑技巧的获得。在许多工业系统无法以一般的控制理论做正确的控制，但是熟练的操员在没有数学模式下，也能够成功地控制这些系统；因此，记录操作员的操作模式，并将其整理为if….then的型式，可构成一组控制规则。

c．学习

为了改善模糊控制器的性能，必须让它有自我学习或自我组织的能力，得模糊控制器能依设定的目标，增加或修改模糊控制规则。

模糊控制规则的型式：

状态评估模糊控制规则

状态评估（state evaluation）模糊控制规则为类似人类的直觉思考，所以大多数的模糊控制器都使用这种模糊控制规则，其型式如下：

Ri：if x1 is Ai1 and x2 is Ai2….and xn i s Ain then y is Ci ；

其中x1，x2，…，xn及y为语言变量或称为模糊变量，代表系统的态变量和控制变量；Ai1，Ai2，…，Ain及Ci为语言值，代表论域中的模糊集合。其次还有另一种表示法，是将后件部改为系统状态变量的函数，其形式如下：

Ri：if x1 is Ai1 and x2 is Ai2….and xn is Ain then y＝f1(x1，x2，…，xn)

设计模糊控制规则时，是在所设想对控制对象各阶段之反应，记述采取那一种控制比较好；首先选择各阶段的特征点，记录在模糊控制规则的前件部，然后思考在该点采取的动作，记录在模糊控制规则的后件部可分别得到如下的控制规则库：

a1：If v

?is PS and v is B then T is B；

b1：If v

?is PM and v is CE then T is CE；

c1：If v

?is PB and v is S then T is S ；

……

表为依上述程序所构成的9条控制规则，其中纵列为v值，横列为v

?值，表中所列之值为控制油门输出T值。由Table1可知规则数最多可为18条，但是v

?的值为负时，只有刹车B的输出。表中只使用了其中15条控制规则，也可依实际结果以及实验需求自行加减规则之数量；为了改善控制的结果，也可适当的改变规则数量以及规则。

(4) 模糊推理

推理模仿人类下判断时的模糊概念，运用模糊逻辑和模糊推论法进行推论，而得到模糊控制信号。不精确的前提集合中得出可能的不精确结论的推理过程，又称近似推理。在人的思维中，推理过程常常是近似的。此部分是模糊控制器的精髓所在。把模糊规则库中的模糊IF-Then规则结合起来，利用最大最小规则，程序实现的主要部分为该部分的内容。(5) 去模糊化（defuzzify）

将推论所得到的模糊值转换为明确的控制信号，做为系统的输出值。在实行模糊控制时，将许多控制规则进行上述推论演算，然后结合各个由演算得到的推论结果获得控制输出。为了求得受控系统的输出，必须将模糊集合去模糊化，本例中使用的是最大平均值法(Mean of Maximal，MOM)：取隶属度最大的所有元素代表取模糊推论结论中，具有最大隶属度值作为去模糊化的输出值。若同时具有多点最大，则取平均值，该方法简单易操作。

结果分析

由于该方法所设的隶属函数数量较少分别为3个，所以实验结果会存在数值较少，输出只会固定在几个值之间，而在两个隶属函数交叉相对较多的区间下，结果的可信度将提高，同时由于实验中未能进行智能车实跑，所以不能进行数据的进一步分析和实验方法的改进，若要加强该控制精度，一方面应该增加规则数量，另一方面通过具体实验结果更改规则库中规则。

实验中遇到的问题与总结

问题归结为模糊控制的经典问题：

1.模糊规则及隶属函数如何获得；

2.如何保证该系统你给的稳定性；

3.实际操作中，编程实现时对于问题的数学化建立模型遇到了不小的困难，同时编程也是以极大的考验，尤其是在C语言编程实现时。

尽管模糊控制理论已在各大领域取得了极大的成就，但就此问题依然有若干问题急需解决，这就进一步要求我们给出模糊控制器的系统化设计方法；同时把握模糊控制的发展方向：由于模糊规则是人们对过程或对象模糊信息的归纳，对高阶、非线性、大时滞、时变因素以及随机干扰等难以获得完整的先验经验，使得单纯的模糊控制在此问题上显得有些粗糙，并且难以获得适应不同的运行状态，影响控制效果。利用和其他经典的控制理论的结合来控制。例如利用神经网络(BP)实现模糊控制规则或模糊推理，同样的算法还有PID、遗传算法等。

附录

matlab程序

%%两个输入分别为deltav和desire speed;%

%%两个输入分别为throttle output和brake output%

% data=load('speedcontrol.dat');

% Dspeed=data(:,2);%desire speed;

% clear all

% clc

%

%x=9;%input1

function [output1,output2]=new(input1,input2)

x=input1;

uxy1=[2,1,1;3,2,1;3,3,2];%rule base 1

uxy2=[2,1,1;1,2,2;3,3,3];%rule base 2

ux01=0;%degree of membership of error;

ux02=0;

if (x>=0)&&(x<10)

ux1=1;

else

if (x>=10)

ux1=exp((-0.5)*((x-10)/6).^2);

end

end

ux2=exp((-0.5)*((x-20)/6).^2);

if (x<30)

ux3=exp((-0.5)*((x-30)/6).^2);

else

if(x>=30)

ux3=1;

end

end

if (x<=0)&&(x>-10)

ux1=1;

else

if (x<=-10)

ux1=exp((-0.5)*((x+10)/6).^2);

end

end

ux2=exp((-0.5)*((x+20)/6).^2);

if (x>-30)&&(x<0)

ux3=exp((-0.5)*((x+30)/6).^2);

else

if(x<=-30)

ux3=1;

end

end

uxgroup=[ux1,ux2,ux3];

a=sort(uxgroup);

[i1,j1] = find(uxgroup==a(3));

[i2,j2] = find(uxgroup==a(2));

ux01=uxgroup(j1);

ux02=uxgroup(j2);

y=input2;%input2

uy01=0;%degree of membership of actual speed; uy02=0;

if (y>=0)&&(y<10)

uy1=1;

else

if (y>=10)

uy1=exp((-0.5)*((y-10)/6).^2);

end

end

uy2=exp((-0.5)*((y-20)/6).^2);

if (y<30)

uy3=exp((-0.5)*((y-30)/6).^2); else

if(y>=30)

uy3=1;

end

end

uygroup=[uy1,uy2,uy3];

b=sort(uygroup);

b1=b(3);

b2=b(2);

[k1,l1] = find(uygroup==b(3));

[k2,l2] = find(uygroup==b(2));

uy01=uygroup(l1);

uy02=uygroup(l2);

z=1:1:460;%output1

uz=0;%degree of membership of throttle; uz1=exp((-0.5)*((z-150)/54).^2);

uz2=exp((-0.5)*((z-300)/54).^2);

uz3=exp((-0.5)*((z-450)/54).^2); uzgroup=[uz1;uz2;uz3];

%%max-min

%%min

position1=uxy1(j1,l1);

min1=min(ux01,uy01);

min1=min1(1);

min11=min(min1,uzgroup(position1,:)); position2=uxy1(j1,l2);

min2=min(ux01,uy02);

min2=min2(1);

min12=min(min2,uzgroup(position2,:)); position3=uxy1(j2,l1);

min3=min(ux02,uy01);

min3=min3(1);

min13=min(min3,uzgroup(position3,:)); position4=uxy1(j2,l2);

min4=min(ux02,uy02);

min4=min4(1);

min14=min(min4,uzgroup(position4,:)); %%max

minall=[min11;min12;min13;min14]; maxminvalue=max(minall);

uoutput=max(maxminvalue);

[ss,ss1] = find(maxminvalue==uoutput);

output1=mean(ss1);%%throttle output和brake output% b=1:1:30;%output2

ub=0;%degree of membership of brake;

ub1=exp((-0.5)*((b-8)/6).^2);

ub2=exp((-0.5)*((b-16)/6).^2);

ub3=exp((-0.5)*((b-24)/6).^2);

ubgroup=[ub1;ub2;ub3];

%%max-min

%%min

position5=uxy2(j1,l1);

min5=min(ux01,uy01);

min5=min5(1);

min15=min(min5,ubgroup(position5,:));

position6=uxy2(j1,l2);

min6=min(ux01,uy02);

min6=min6(1);

min16=min(min6,ubgroup(position6,:));

position7=uxy2(j2,l1);

min7=min(ux02,uy01);

min7=min2(1);

min17=min(min7,ubgroup(position7,:));

position8=uxy2(j2,l2);

min8=min(ux02,uy02);

min8=min8(1);

min18=min(min8,ubgroup(position8,:));

%%max

minall02=[min15;min16;min17;min18];

maxminvalue02=max(minall02);

uoutput2=max(maxminvalue02);

[ss01,ss102] = find(maxminvalue02==uoutput2); output2=mean(ss102); %%brake output%

if (x>0)

output2=0;

else

output1=0;

end

C程序

#include

#include

double max(double i,double j)

{ return i>j?i:j;}

double min(double i,double j)

{ return i

void main()

{

//初始化

double x=0,ux1=0,ux2=0,ux3=0,ux01=0,ux02=0;

double y=0,uy1=0,uy2=0,uy3=0,uy01=0,uy02=0;

//输入速度误差和期望速度，其中第一个参数为速度误差，第二个参数为期望速度cout<<"输入速度和速度的值"<

cin>>x>>y;

if(x>0&&x<10)

ux1=1;

else

ux1=exp((-0.5)*pow((x-10.0)/6.0,2));

ux2=exp((-0.5)*pow((x-20.0)/6.0,2));

if(x>0&&x<30)

ux3=exp((-0.5)*pow((x-30.0)/6.0,2));

else

ux3=1;

int px1=0,px2=0;

if(ux1>ux2)

if(ux1>ux3)

if(ux2>ux3)

{

ux01=ux1;

px1=1-1;

ux02=ux2;

px2=2-1;

}

else

{

ux01=ux1;

px1=1-1;

ux02=ux3;

px2=3-1;

}

else

{

ux01=ux3;

px1=3-1;

ux02=ux1;

px2=1-1;

}

else

if(ux2>ux3)

if(ux1>ux3)

{

ux01=ux2;

px1=2-1;

ux02=ux1;

px2=1-1;

}

else

{

ux01=ux2;

px1=2-1;

ux02=ux3;

px2=3-1;

}

else

{

ux01=ux3;

px1=3-1;

ux02=ux2;

px2=2-1;

}

cout<<"ux1="<

cout<<"ux01="<

if(y>0&&y<10)

uy1=1;

else

uy1=exp((-0.5)*pow((y-10.0)/6.0,2));

uy2=exp((-0.5)*pow((y-20.0)/6.0,2));

if(x>0&&x<30)

uy3=exp((-0.5)*pow((y-30.0)/6.0,2));

else

uy3=1;

int py1=0,py2=0;

if(uy1>uy2)

if(uy1>uy3)

if(uy2>uy3)

{

uy01=uy1;

py1=1-1;

uy02=uy2;

py2=2-1;

}

else

{

uy01=uy1;

py1=1-1;

uy02=uy3;

py2=3-1;

}

else

{

uy01=uy3;

py1=3-1;

uy02=uy1;

py2=1-1;

}

else

if(uy2>uy3)

if(uy1>uy3)

{

uy01=uy2;

py1=2-1;

uy02=uy1;

py2=1-1;

}

else

{

uy01=uy2;

py1=2-1;

uy02=uy3;

py2=3-1;

}

else

{

uy01=uy3;

py1=3-1;

uy02=uy2;

py2=2-1;

}

cout<<"uy1="<

cout<<"uy01="<

// cout<<"x="<

int z; //output1

double uz1[460],uz2[460],uz3[460];

double uz=0; //degree of membership of throttle;

for(z=0;z<=459;z++)

{

if (z<150)

uz1[z]=1;

else

uz1[z]=exp((-0.5)*pow((z-150.0)/54.0,2));

uz2[z]=exp((-0.5)*pow((z-300.0)/54.0,2));

if (z<450)

uz3[z]=exp((-0.5)*pow((z-450.0)/54,2));

else

uz3[z]=1;

}

cout<<"uz1[162]="<

int uxy01[3][3]={2,1,1,3,2,1,3,3,2};

int uxy02[3][3]={2,1,1,1,2,2,3,3,3};

double min1,min2,min3,min4;

double min11[460],min12[460],min13[460],min14[460];

min1=min(ux01,uy01);

switch (uxy01[px1][py1])

{

case 1:

for(z=0;z<=459;z++)

{

min11[z]=min(min1,uz1[z]);

}

case 2:

for(z=0;z<=459;z++)

{

min11[z]=min(min1,uz2[z]);

};

case 3:

for(z=0;z<=459;z++)

{

min11[z]=min(min1,uz3[z]);

}

}

min2=min(ux01,uy02);

switch (uxy01[px1][py2])

{

case 1:

for(z=0;z<=459;z++)

{

min12[z]=min(min2,uz1[z]);

}

case 2:

for(z=0;z<=459;z++)

{

min12[z]=min(min2,uz2[z]);

};

case 3:

for(z=0;z<=459;z++)

{

min12[z]=min(min2,uz3[z]);

}

}

min3=min(ux02,uy01);

switch (uxy01[px2][py1])

{

case 1:

for(z=0;z<=459;z++)

{

min13[z]=min(min3,uz3[z]);

}

case 2:

for(z=0;z<=459;z++)

{

min13[z]=min(min3,uz2[z]);

};

case 3:

for(z=0;z<=459;z++)

{

min13[z]=min(min3,uz3[z]);

}

}

min4=min(ux02,uy02);

switch (uxy01[px2][py2])

{

case 1:

for(z=0;z<=459;z++)

{

min14[z]=min(min4,uz1[z]);

}

case 2:

for(z=0;z<=459;z++)

{

min14[z]=min(min4,uz2[z]);

};

case 3:

for(z=0;z<=459;z++)

{

min14[z]=min(min4,uz3[z]);

}

}

//max of max-min method

double maxvalue[460];

for(z=0;z<=459;z++)

{

maxvalue[z]=max(max(max(min11[z],min12[z]),min13[z]),min14[z]);

}

cout<<"min1="<

cout<<"maxvalue"<

int j,k,sumj;

j=0;

double output1;

double uoutput=maxvalue[0];

for(z=0;z<=459;z++)

if(maxvalue[z]>=uoutput)

{

uoutput=maxvalue[z];

j=z;

}

cout<<"uoutput="<

k=0;

sumj=0;

for(z=0;z<=459;z++)

if(maxvalue[z]==uoutput)

{

sumj+=z;

k=k+1;

}

output1=sumj/k;

cout<<"output1="<

}