模糊PID控制算法的C++实现

置顶 已于 2022-03-10 23:15:07 修改
阅读量4w 收藏 624
点赞数 59
分类专栏： 模糊控制算法 控制算法 文章标签： 模糊控制 模糊pid算法
于 2017-10-14 20:17:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shuoyueqishilove/article/details/78236541
版权

很久没有更新博客了，今天就来讲讲模糊PID的C++实现方法。先来看一下整体的框架：
模糊PID的整体框架

解释下上面框图的意思，模糊PID其实是在普通PID的基础之上，通过输入的两个变量：误差和误差的变化率的情况来动态的调整PID控制器的三个重要的参数Kp，Ki，Kd。从而使得控制器的性能达到最优。这里的PID参数的整定，使用的是增量的方式，这样可以避免过大的误差，提高整定的精度。
所使用的模糊控制器的设计方法与普通的模糊控制器设计是一样的，具体为：首先，确定模糊控制器的输入为二维输入，即把误差和误差的变化率作为模糊控制器的输入，实际设计时也可以设计成三维或者是其他的输入形式；模糊控制器的输出为PID参数的增量值，分别为kp’, ki’, kd’;
则PID的参数为：
Kp(n)=Kp(n-1)+kp’;
Ki(n)=Ki(n-1)+Ki’;
Kd(n)=Kd(n-1)+kd’;
然后对模糊控制器的输入变量和输出变量划分模糊区间，这里为了模糊控制器设计的简单起见将它们都映射到[-3,3]区间上，统一划分的区间为{-3，-2，-1,0,1,2,3}即为{NB，NM，NS，ZO，PS，PM，PB}；确定隶属度函数的形式，常用的隶属度函数类型有三角形隶属度函数，梯形隶属度函数，钟形隶属度函数，正态分布隶属度函数，根据控制对象的需要选择适当的隶属度函数；这里选择的是三角型隶属度函数，因为它形式简单，计算量小，便于在微控制器上实现。隶属度函数下图所示：
隶属度函数
接下来是设计模糊控制器的关键，确定模糊规则，根据前人的大量研究，模糊PID的模糊控制规则一般采用如下的形式，这也是我看过的论文中普遍选择的方式。可能有的控制对象比较特殊需要做一些调整。模糊规则如下：
这里写图片描述
这里写图片描述
这里写图片描述
有了这些规则就完成了模糊控制器的核心设计，然后就需要确定去模糊的方法，还是使用老的办法，加权平均法计算输出值，公式如下：
这里写图片描述
该公式的解释任意一篇关于模糊控制的论文都可以找到，不在赘述。
由以上的描述可以，模糊PID只是使用模糊控制方法来调整PID的参数，从而实现简单的自适应控制，与普通的模糊控制原理并无不同。
需要注意的是：模糊PID一般需要一个比较接近理想控制效果的PID参数初始值，否则，效果并不理想。
了解了模糊PID的控制原理，然后开始编写C++代码，并不是什么难事。这里采用的是C++面向对象的编程思想，设计一个fuzzy_pid类，需要使用时，只需要实例化这个类即可得到一个fuzzy_pid对象，然后调用它的方法就可以实现模糊PID控制，是不是感觉很酷炫；不多说了，直接看代码：
首先是设计fuzzy_pid类的接口；

class FuzzyPID
{
public:
	const static int N=7;
private:
	float target;  //系统的控制目标
	float actual;  //采样获得的实际值
	float e;       //误差
	float e_pre_1; //上一次的误差
	float e_pre_2; //上上次的误差
	float de;      //误差的变化率
	float emax;    //误差基本论域上限
	float demax;   //误差辩化率基本论域的上限
	float delta_Kp_max;   //delta_kp输出的上限
	float delta_Ki_max;   //delta_ki输出上限
	float delta_Kd_max;   //delta_kd输出上限
	float Ke;      //Ke=n/emax,量化论域为[-3,-2,-1,0,1,2,3]
	float Kde;     //Kde=n/demax,量化论域为[-3,-2,-1,0,1,2,3]
	float Ku_p;    //Ku_p=Kpmax/n,量化论域为[-3,-2,-1,0,1,2,3]
	float Ku_i;    //Ku_i=Kimax/n,量化论域为[-3,-2,-1,0,1,2,3]
	float Ku_d;    //Ku_d=Kdmax/n,量化论域为[-3,-2,-1,0,1,2,3]
	int Kp_rule_matrix[N][N];//Kp模糊规则矩阵
	int Ki_rule_matrix[N][N];//Ki模糊规则矩阵
	int Kd_rule_matrix[N][N];//Kd模糊规则矩阵
	string mf_t_e;       //e的隶属度函数类型
	string mf_t_de;      //de的隶属度函数类型
	string mf_t_Kp;      //kp的隶属度函数类型
	string mf_t_Ki;      //ki的隶属度函数类型
	string mf_t_Kd;      //kd的隶属度函数类型
	float *e_mf_paras; //误差的隶属度函数的参数
	float *de_mf_paras;//误差的偏差隶属度函数的参数
	float *Kp_mf_paras; //kp的隶属度函数的参数
	float *Ki_mf_paras; //ki的隶属度函数的参数
	float *Kd_mf_paras; //kd的隶属度函数的参数
	float Kp;
	float Ki;
	float Kd;
	float A;
	float B;
	float C;
void showMf(const string & type,float *mf_paras);      //显示隶属度函数的信息
void setMf_sub(const string & type,float *paras,int n);//设置模糊隶属度函数的子函数
public:
FuzzyPID(float e_max,float de_max,float kp_max,float ki_max,float kd_max,float Kp0,float Ki0,float Kd0);
FuzzyPID(float *fuzzyLimit,float *pidInitVal);
~FuzzyPID();
float trimf(float x,float a,float b,float c);          //三角隶属度函数
float gaussmf(float x,float ave,float sigma);          //正态隶属度函数
float trapmf(float x,float a,float b,float c,float d); //梯形隶属度函数
void setMf(const string & mf_type_e,float *e_mf,
			   const string & mf_type_de,float *de_mf,
			   const string & mf_type_Kp,float *Kp_mf,
		       const string & mf_type_Ki,float *Ki_mf,
			   const string & mf_type_Kd,float *Kd_mf);	//设置模糊隶属度函数的参数
void setRuleMatrix(int kp_m[N][N],int ki_m[N][N],int kd_m[N][N]);  //设置模糊规则
float realize(float t,float a);  //实现模糊控制
void showInfo();   //显示该模糊控制器的信息
};

然后是fuzzy_pid类的实现方法：


#include"fuzzy_PID.h"


FuzzyPID::FuzzyPID(float e_max,float de_max,float kp_max,float ki_max,float kd_max,float Kp0,float Ki0,float Kd0):
target(0),actual(0),emax(e_max),demax(de_max),delta_Kp_max(kp_max),delta_Ki_max(ki_max),delta_Kd_max(kd_max),e_mf_paras(NULL),de_mf_paras(NULL),
Kp_mf_paras(NULL),Ki_mf_paras(NULL),Kd_mf_paras(NULL)
{
   e=target-actual;
   e_pre_1=0;
   e_pre_2=0;
   de=e-e_pre_1;
   Ke=(N/2)/emax;
   Kde=(N/2)/demax;
   Ku_p=delta_Kp_max/(N/2);
   Ku_i=delta_Ki_max/(N/2);
   Ku_d=delta_Kd_max/(N/2);
   mf_t_e="No type";
   mf_t_de="No type";
   mf_t_Kp="No type";
   mf_t_Ki="No type";
   mf_t_Kd="No type";
   Kp=Kp0;
   Ki=Ki0;
   Kd=Kd0;
   A=Kp+Ki+Kd;
   B=-2*Kd-Kp;
   C=Kd;
}

FuzzyPID::FuzzyPID(float *fuzzyLimit,float *pidInitVal)
{
	target=0;
	actual=0;
	e=0;
	e_pre_1=0;
    e_pre_2=0;
    de=e-e_pre_1;
	emax=fuzzyLimit[0];
	demax=fuzzyLimit[1];
	delta_Kp_max=fuzzyLimit[2];
	delta_Ki_max=fuzzyLimit[3];
	delta_Kd_max=fuzzyLimit[4];
	Ke=(N/2)/emax;
    Kde=(N/2)/demax;
    Ku_p=delta_Kp_max/(N/2);
    Ku_i=delta_Ki_max/(N/2);
    Ku_d=delta_Kd_max/(N/2);
    mf_t_e="No type";
    mf_t_de="No type";
    mf_t_Kp="No type";
    mf_t_Ki="No type";
    mf_t_Kd="No type";
	e_mf_paras=NULL;
	de_mf_paras=NULL;
	Kp_mf_paras=NULL;
	Ki_mf_paras=NULL;
	Kd_mf_paras=NULL;

    Kp=pidInitVal[0];
    Ki=pidInitVal[1];
    Kd=pidInitVal[2];
    A=Kp+Ki+Kd;
    B=-2*Kd-Kp;
    C=Kd;
}

FuzzyPID::~FuzzyPID()
{
  delete [] e_mf_paras;
  delete [] de_mf_paras;
  delete [] Kp_mf_paras;
  delete [] Ki_mf_paras;
  delete [] Kd_mf_paras;
}
//三角隶属度函数
float FuzzyPID::trimf(float x,float a,float b,float c)
{
   float u;
   if(x>=a&&x<=b)
	   u=(x-a)/(b-a);
   else if(x>b&&x<=c)
	   u=(c-x)/(c-b);
   else
	   u=0.0;
   return u;

}
//正态隶属度函数
float FuzzyPID::gaussmf(float x,float ave,float sigma) 
{
	float u;
	if(sigma<0)
	{
	   cout<<"In gaussmf, sigma must larger than 0"<<endl;
	}
	u=exp(-pow(((x-ave)/sigma),2));
	return u;
}
//梯形隶属度函数
float FuzzyPID::trapmf(float x,float a,float b,float c,float d)
{
    float u;
	if(x>=a&&x<b)
		u=(x-a)/(b-a);
	else if(x>=b&&x<c)
        u=1;
	else if(x>=c&&x<=d)
		u=(d-x)/(d-c);
	else
		u=0;
	return u;
}
//设置模糊规则Matrix
void FuzzyPID::setRuleMatrix(int kp_m[N][N],int ki_m[N][N],int kd_m[N][N])
{
	for(int i=0;i<N;i++)
	   for(int j=0;j<N;j++)
	   {
		   Kp_rule_matrix[i][j]=kp_m[i][j];
		   Ki_rule_matrix[i][j]=ki_m[i][j];
		   Kd_rule_matrix[i][j]=kd_m[i][j];
	   }
}
//设置模糊隶属度函数的子函数
void FuzzyPID::setMf_sub(const string & type,float *paras,int n)
{
	int N_mf_e,N_mf_de,N_mf_Kp,N_mf_Ki,N_mf_Kd;
  switch(n)
  {
  case 0:
	  if(type=="trimf"||type=="gaussmf"||type=="trapmf")
	    mf_t_e=type;
	  else
		cout<<"Type of membership function must be \"trimf\" or \"gaussmf\" or \"trapmf\""<<endl;
      if(mf_t_e=="trimf")
        N_mf_e=3;
	  else if(mf_t_e=="gaussmf")
		N_mf_e=2;
	  else if(mf_t_e=="trapmf")
		N_mf_e=4;
       
	  e_mf_paras=new float [N*N_mf_e];
	  for(int i=0;i<N*N_mf_e;i++)
		e_mf_paras[i]=paras[i];
	  break;

  case 1:
	  if(type=="trimf"||type=="gaussmf"||type=="trapmf")
	    mf_t_de=type;
	  else
		cout<<"Type of membership function must be \"trimf\" or \"gaussmf\" or \"trapmf\""<<endl;
      if(mf_t_de=="trimf")
        N_mf_de=3;
	  else if(mf_t_de=="gaussmf")
		N_mf_de=2;
	  else if(mf_t_de=="trapmf")
		N_mf_de=4;
        de_mf_paras=new float [N*N_mf_de];
	  for(int i=0;i<N*N_mf_de;i++)
		de_mf_paras[i]=paras[i];
	  break;

   case 2:
	  if(type=="trimf"||type=="gaussmf"||type=="trapmf")
	    mf_t_Kp=type;
	  else
		cout<<"Type of membership function must be \"trimf\" or \"gaussmf\" or \"trapmf\""<<endl;
      if(mf_t_Kp=="trimf")
        N_mf_Kp=3;
	  else if(mf_t_Kp=="gaussmf")
		N_mf_Kp=2;
	  else if(mf_t_Kp=="trapmf")
		N_mf_Kp=4;
        Kp_mf_paras=new float [N*N_mf_Kp];
	  for(int i=0;i<N*N_mf_Kp;i++)
		Kp_mf_paras[i]=paras[i];
	  break;

   case 3:
	  if(type=="trimf"||type=="gaussmf"||type=="trapmf")
	    mf_t_Ki=type;
	  else
		cout<<"Type of membership function must be \"trimf\" or \"gaussmf\" or \"trapmf\""<<endl;
      if(mf_t_Ki=="trimf")
        N_mf_Ki=3;
	  else if(mf_t_Ki=="gaussmf")
		N_mf_Ki=2;
	  else if(mf_t_Ki=="trapmf")
		N_mf_Ki=4;
        Ki_mf_paras=new float [N*N_mf_Ki];
	  for(int i=0;i<N*N_mf_Ki;i++)
		Ki_mf_paras[i]=paras[i];
	  break;

   case 4:
	  if(type=="trimf"||type=="gaussmf"||type=="trapmf")
	    mf_t_Kd=type;
	  else
		cout<<"Type of membership function must be \"trimf\" or \"gaussmf\" or \"trapmf\""<<endl;
      if(mf_t_Kd=="trimf")
        N_mf_Kd=3;
	  else if(mf_t_Kd=="gaussmf")
		N_mf_Kd=2;
	  else if(mf_t_Kd=="trapmf")
		N_mf_Kd=4;
        Kd_mf_paras=new float [N*N_mf_Kd];
	  for(int i=0;i<N*N_mf_Kd;i++)
		Kd_mf_paras[i]=paras[i];
	  break;

   default: break;
  }
}
//设置模糊隶属度函数的类型和参数
void FuzzyPID::setMf(const string & mf_type_e,float *e_mf,
			const string & mf_type_de,float *de_mf,
			const string & mf_type_Kp,float *Kp_mf,
		    const string & mf_type_Ki,float *Ki_mf,
			const string & mf_type_Kd,float *Kd_mf)
{
	setMf_sub(mf_type_e,e_mf,0);
	setMf_sub(mf_type_de,de_mf,1);
	setMf_sub(mf_type_Kp,Kp_mf,2);
	setMf_sub(mf_type_Ki,Ki_mf,3);
	setMf_sub(mf_type_Kd,Kd_mf,4);
}
//实现模糊控制
float FuzzyPID::realize(float t,float a)   
{
	float u_e[N],u_de[N],u_u[N];
	int u_e_index[3],u_de_index[3];//假设一个输入最多激活3个模糊子集
	float delta_Kp,delta_Ki,delta_Kd;
	float delta_u;
	target=t;
	actual=a;
    e=target-actual;
	de=e-e_pre_1;
	e=Ke*e;
	de=Kde*de;
  /* 将误差e模糊化*/
	int j=0;
	for(int i=0;i<N;i++)
	{
		if(mf_t_e=="trimf")
		  u_e[i]=trimf(e,e_mf_paras[i*3],e_mf_paras[i*3+1],e_mf_paras[i*3+2]);//e模糊化，计算它的隶属度
		else if(mf_t_e=="gaussmf")
		  u_e[i]=gaussmf(e,e_mf_paras[i*2],e_mf_paras[i*2+1]);//e模糊化，计算它的隶属度
		else if(mf_t_e=="trapmf")
		  u_e[i]=trapmf(e,e_mf_paras[i*4],e_mf_paras[i*4+1],e_mf_paras[i*4+2],e_mf_paras[i*4+3]);//e模糊化，计算它的隶属度

		if(u_e[i]!=0)
            u_e_index[j++]=i;                //存储被激活的模糊子集的下标，可以减小计算量
  	}
	for(;j<3;j++)u_e_index[j]=0;             //富余的空间填0

	/*将误差变化率de模糊化*/
	j=0;
	for(int i=0;i<N;i++)
	{
		if(mf_t_de=="trimf")
		   u_de[i]=trimf(de,de_mf_paras[i*3],de_mf_paras[i*3+1],de_mf_paras[i*3+2]);//de模糊化，计算它的隶属度
		else if(mf_t_de=="gaussmf")
		   u_de[i]=gaussmf(de,de_mf_paras[i*2],de_mf_paras[i*2+1]);//de模糊化，计算它的隶属度
		else if(mf_t_de=="trapmf")
		   u_de[i]=trapmf(de,de_mf_paras[i*4],de_mf_paras[i*4+1],de_mf_paras[i*4+2],de_mf_paras[i*4+3]);//de模糊化，计算它的隶属度

		if(u_de[i]!=0)
			u_de_index[j++]=i;            //存储被激活的模糊子集的下标，可以减小计算量
	}
	for(;j<3;j++)u_de_index[j]=0;          //富余的空间填0

	float den=0,num=0;
	/*计算delta_Kp和Kp*/
	for(int m=0;m<3;m++)
		for(int n=0;n<3;n++)
		{
		   num+=u_e[u_e_index[m]]*u_de[u_de_index[n]]*Kp_rule_matrix[u_e_index[m]][u_de_index[n]];
		   den+=u_e[u_e_index[m]]*u_de[u_de_index[n]];
		}
	delta_Kp=num/den;
	delta_Kp=Ku_p*delta_Kp;
	if(delta_Kp>=delta_Kp_max)   delta_Kp=delta_Kp_max;
	else if(delta_Kp<=-delta_Kp_max) delta_Kp=-delta_Kp_max;
	Kp+=delta_Kp;
	if(Kp<0)Kp=0;
	/*计算delta_Ki和Ki*/
	den=0;num=0;
	for(int m=0;m<3;m++)
		for(int n=0;n<3;n++)
		{
		   num+=u_e[u_e_index[m]]*u_de[u_de_index[n]]*Ki_rule_matrix[u_e_index[m]][u_de_index[n]];
		   den+=u_e[u_e_index[m]]*u_de[u_de_index[n]];
		}

	delta_Ki=num/den;
	delta_Ki=Ku_i*delta_Ki;
	if(delta_Ki>=delta_Ki_max)   delta_Ki=delta_Ki_max;
	else if(delta_Ki<=-delta_Ki_max)  delta_Ki=-delta_Ki_max;
	Ki+=delta_Ki;
	if(Ki<0)Ki=0;
	/*计算delta_Kd和Kd*/
	den=0;num=0;
	for(int m=0;m<3;m++)
		for(int n=0;n<3;n++)
		{
		   num+=u_e[u_e_index[m]]*u_de[u_de_index[n]]*Kd_rule_matrix[u_e_index[m]][u_de_index[n]];
		   den+=u_e[u_e_index[m]]*u_de[u_de_index[n]];
		}
	delta_Kd=num/den;
	delta_Kd=Ku_d*delta_Kd;
	if(delta_Kd>=delta_Kd_max)   delta_Kd=delta_Kd_max;
	else if(delta_Kd<=-delta_Kd_max) delta_Kd=-delta_Kd_max;
	Kd+=delta_Kd;
	if(Kd<0)Kd=0;

	A=Kp+Ki+Kd;
    B=-2*Kd-Kp;
    C=Kd;
	delta_u=A*e+B*e_pre_1+C*e_pre_2;

	delta_u=delta_u/Ke;
  
	if(delta_u>=0.95*target)delta_u=0.95*target;
	else if(delta_u<=-0.95*target)delta_u=-0.95*target;

	e_pre_2=e_pre_1;
    e_pre_1=e;

	return delta_u;
}
void FuzzyPID::showMf(const string & type,float *mf_paras)
{
    int tab;
	if(type=="trimf")
		tab=2;
	else if(type=="gaussmf")
		tab==1;
	else if(type=="trapmf")
		tab=3;
	cout<<"函数类型："<<mf_t_e<<endl;
	cout<<"函数参数列表："<<endl;
	float *p=mf_paras;
	for(int i=0;i<N*(tab+1);i++)
	  {
		  cout.width(3);
	      cout<<p[i]<<"  ";
		  if(i%(tab+1)==tab)
			  cout<<endl;
	  }
}
void FuzzyPID::showInfo()
{
   cout<<"Info of this fuzzy controller is as following:"<<endl;
   cout<<"基本论域e：["<<-emax<<","<<emax<<"]"<<endl;
   cout<<"基本论域de：["<<-demax<<","<<demax<<"]"<<endl;
   cout<<"基本论域delta_Kp：["<<-delta_Kp_max<<","<<delta_Kp_max<<"]"<<endl;
   cout<<"基本论域delta_Ki：["<<-delta_Ki_max<<","<<delta_Ki_max<<"]"<<endl;
   cout<<"基本论域delta_Kd：["<<-delta_Kd_max<<","<<delta_Kd_max<<"]"<<endl;
   cout<<"误差e的模糊隶属度函数参数："<<endl;
   showMf(mf_t_e,e_mf_paras);
   cout<<"误差变化率de的模糊隶属度函数参数："<<endl;
   showMf(mf_t_de,de_mf_paras);
   cout<<"delta_Kp的模糊隶属度函数参数："<<endl;
   showMf(mf_t_Kp,Kp_mf_paras);
   cout<<"delta_Ki的模糊隶属度函数参数："<<endl;
   showMf(mf_t_Ki,Ki_mf_paras);
   cout<<"delta_Kd的模糊隶属度函数参数："<<endl;
   showMf(mf_t_Kd,Kd_mf_paras);
   cout<<"模糊规则表："<<endl;
   cout<<"delta_Kp的模糊规则矩阵"<<endl;
   for(int i=0;i<N;i++)
   {
	 for(int j=0;j<N;j++)
	   {
		 cout.width(3);
		 cout<<Kp_rule_matrix[i][j]<<"  ";
	    }
	   cout<<endl;
   }
   cout<<"delta_Ki的模糊规则矩阵"<<endl;
   for(int i=0;i<N;i++)
   {
	 for(int j=0;j<N;j++)
	   {
		 cout.width(3);
		 cout<<Ki_rule_matrix[i][j]<<"  ";
	    }
	   cout<<endl;
   }
   cout<<"delta_Kd的模糊规则矩阵"<<endl;
   for(int i=0;i<N;i++)
   {
	 for(int j=0;j<N;j++)
	   {
		 cout.width(3);
		 cout<<Kd_rule_matrix[i][j]<<"  ";
	    }
	   cout<<endl;
   }
   cout<<endl;
   cout<<"误差的量化比例因子Ke="<<Ke<<endl;
   cout<<"误差变化率的量化比例因子Kde="<<Kde<<endl;
   cout<<"输出的量化比例因子Ku_p="<<Ku_p<<endl;
   cout<<"输出的量化比例因子Ku_i="<<Ku_i<<endl;
   cout<<"输出的量化比例因子Ku_d="<<Ku_d<<endl;
   cout<<"设定目标target="<<target<<endl;
   cout<<"误差e="<<e<<endl;
   cout<<"Kp="<<Kp<<endl;
   cout<<"Ki="<<Ki<<endl;
   cout<<"Kd="<<Kd<<endl;
   cout<<endl;
}

之后是简单的测试：

#include<iostream>
#include"fuzzy_PID.h"

#define NB -3
#define NM -2
#define NS -1
#define ZO 0
#define PS 1
#define PM 2
#define PB 3

int main()
{
	float target=600;
	float actual=0;
	float u=0;
	int deltaKpMatrix[7][7]={{PB,PB,PM,PM,PS,ZO,ZO},
	                         {PB,PB,PM,PS,PS,ZO,NS},
						     {PM,PM,PM,PS,ZO,NS,NS},
	                         {PM,PM,PS,ZO,NS,NM,NM},
	                         {PS,PS,ZO,NS,NS,NM,NM},
	                         {PS,ZO,NS,NM,NM,NM,NB},
	                         {ZO,ZO,NM,NM,NM,NB,NB}};
	int deltaKiMatrix[7][7]={{NB,NB,NM,NM,NS,ZO,ZO},
	                         {NB,NB,NM,NS,NS,ZO,ZO},
						     {NB,NM,NS,NS,ZO,PS,PS},
	                         {NM,NM,NS,ZO,PS,PM,PM},
	                         {NM,NS,ZO,PS,PS,PM,PB},
	                         {ZO,ZO,PS,PS,PM,PB,PB},
	                         {ZO,ZO,PS,PM,PM,PB,PB}};
	int deltaKdMatrix[7][7]={{PS,NS,NB,NB,NB,NM,PS},
	                         {PS,NS,NB,NM,NM,NS,ZO},
						     {ZO,NS,NM,NM,NS,NS,ZO},
	                         {ZO,NS,NS,NS,NS,NS,ZO},
	                         {ZO,ZO,ZO,ZO,ZO,ZO,ZO},
	                         {PB,NS,PS,PS,PS,PS,PB},
	                         {PB,PM,PM,PM,PS,PS,PB}};
	float e_mf_paras[]={-3,-3,-2,-3,-2,-1,-2,-1,0,-1,0,1,0,1,2,1,2,3,2,3,3};
	float de_mf_paras[]={-3,-3,-2,-3,-2,-1,-2,-1,0,-1,0,1,0,1,2,1,2,3,2,3,3};
	float Kp_mf_paras[]={-3,-3,-2,-3,-2,-1,-2,-1,0,-1,0,1,0,1,2,1,2,3,2,3,3};
	float Ki_mf_paras[]={-3,-3,-2,-3,-2,-1,-2,-1,0,-1,0,1,0,1,2,1,2,3,2,3,3};
	float Kd_mf_paras[]={-3,-3,-2,-3,-2,-1,-2,-1,0,-1,0,1,0,1,2,1,2,3,2,3,3};
    FuzzyPID fuzzypid(1500,650,0.3,0.9,0.6,0.01,0.04,0.01);
	fuzzypid.setMf("trimf",e_mf_paras,"trimf",de_mf_paras,"trimf",Kp_mf_paras,"trimf",Ki_mf_paras,"trimf",Kd_mf_paras);
	fuzzypid.setRuleMatrix(deltaKpMatrix,deltaKiMatrix,deltaKdMatrix);
	cout<<"num target    actual"<<endl;
	/*fuzzy.showInfo();*/
	for(int i=0;i<50;i++)
	{
		u=fuzzypid.realize(target,actual);
		actual+=u;
		cout<<i<<"   "<<target<<"    "<<actual<<endl;
	}
	fuzzypid.showInfo();
	system("pause");
	return 0;
}

OK，完工，有不明白的欢迎交流！
代码已经上传至CSDN，需要参考的朋友可以下载看看：
https://download.csdn.net/download/shuoyueqishilove/10433941

Alexon Xu
关注
  • 59
    点赞
  • 踩
  • 624
    收藏
    觉得还不错? 一键收藏
  • 78
    评论
专栏目录
C/C++ PID控制算法详解及实现源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
04-30 1514
PID代表比例（Proportional）、积分（Integral）和微分（Derivative），它根据当前误差、累积误差和误差变化率来计算控制量，实现对控制对象的控制。总之，使用PID控制算法时需要根据实际情况进行参数选择和调节，并进行稳定性检查和模型匹配，以实现准确和稳定的控制。参数调节：PID算法的参数调节通常需要进行试验，根据系统的实际反馈来调整参数，以实现满意的控制效果。模型匹配：确保PID算法的模型与实际系统的特性相符合，以获得更好的控制效果。
模糊+PID C语言实现
06-20
模糊PID算法，采用C语言实现，对于控制类，特别像温度控制类变化需要预测的类型，可以采用此算法
自适应模糊PID代码 C++实现.zip
07-11
基于C++ 的模糊PID控制代码，参考许多论文制定的PID参数调整模糊规则，代码对于想了解这方面的人有一定的借鉴意义。但是不保证什么控制对象都能用，具体对象具体设计
模糊pid算法c语言
10-13
可以用的模糊pid.原代码，稍加修改变成自己的，c语言，注释详细
自适应模糊PID代码 C++实现
05-24
基于C++ 的模糊PID控制代码，参考许多论文制定的PID参数调整模糊规则，代码对于想了解这方面的人有一定的借鉴意义。但是不保证什么控制对象都能用，具体对象具体设计。
模糊pid控制C程序
01-25
本人对模糊PID控制的两种理解的写法，模糊pid控制C程序，内有一定注释，欢迎交流本人对模糊PID控制的两种理解的写法，模糊pid控制C程序，内有一定注释，欢迎交流
C#实现模糊PID算法的代码
o_no_on_o的博客
04-12 2127
刚开始在网上搜了下相关代码，发现全都是这个版本的(3条消息) c# 实现模糊PID控制算法_chinaherolts2008的博客-CSDN博客_c# pid算法 原作者简述中提到“这段算法在实际值低于目标值c#教程是工作正常，超过后会有问题，不知道如何调教”，我以为稳了，1天时间摸着鱼也就完成了，没想到远远没这么简单，以下是详情。 在熟悉代码的过程中发现了有下列3个问题： 1. 将“de = e - e_pre_1;”更正为“de = e - e_pre_1/Ke; //此处的e为外部反馈的...
C++ 根据进程名获取pid（PID最全方案）
zcy5157912的博客
01-05 4479
网络上流行的创建快照的方案对于部分进程无效，如360进程。解决方案亲测可用
梯形概率分布
yi_tech_blog的博客
01-05 4138
梯形概率分布，是指随机变量的概率呈梯形分布。如下图所示 其中，B点所代表的随机变量为最小值，C点所代表的随机变量为最大值，A到D区段所代表的随机变量为最可能的值 利用MATLAB生成梯形分布的随机数样本，并绘制其概率分布图，matlab代码如下 %梯形分布 a=-1; %分布左端,小于0的值：最小值 c=0;%最可能的值 d=1;%最可能的值 b=3; %分布右端,大于0的值：最大
飞思卡尔智能车----模糊PID算法通俗讲
coder_leaf的博客
08-16 1万+
 在讲解模糊PID前，我们先要了解PID控制器的原理（本文主要介绍模糊PID的运用,对PID控制器的原理不做详细介绍）。PID控制器（比例-积分-微分控制器）是一个在工业控制应用中常见的反馈回路部件，由比例单元P、积分单元I和微分单元D组成。PID控制的基础是比例控制；积分控制可消除稳态误差，但可能增加超调；微分控制可加快大惯性系统响应速度以及减弱超调趋势。   1.1传统PID控制   ...
模糊控制C++测试代码
10-19
在VS2010环境下，建立控制台应用程序，调用经修改过的MATLAB模糊逻辑工具箱中关于模糊控制部分的C代码函数，从而在C++中方便直接地实现模糊控制算法； fisMatrixFile.txt中存放自己配置的模糊逻辑工具箱生成的fis文件， dataMatrixFile.txt中存放模糊控制算法的输入量。
这是用C语言实现模糊控制的算法程序
09-04
这是用C语言实现模糊控制的算法程序 用C去实现模糊控制 C和模糊控制的借口转换
基于C++语言的多种PID控制算法实现（附详细说明文件及源程序）
08-07
目 录 一、PID算法原理 二、PID算法的离散化 三、 位置型PID的C++实现 ...详细介绍PID原理，及各种传统的PID控制算法C++实现，最后详细介绍了模糊算法，及其在PID控制中的应用，附详细说明文件及源程序。
PID算法详解和实例使用说明和模糊控制算法
04-23
PID算法详解和实例使用说明，内含增量式，位置式还有模糊控制PID算法详解和程序，及对电机的调试实例，还有飞思卡尔的使用PID程序
模糊PID算法C语言程序-查表法,模糊pid控制规则表,C,C++
09-10
模糊控制pid查表法源码，有需要的可以下载看看，可以用于大家参考学习，一起进步
C++实现PID控制算法
weixin_42156097的博客
08-24 7431
描述 PID控制算法，是自动化专业学生必须掌握的基本控制算法 比例积分微分算法 比例项P：与当前误差相关 积分项I：与一段时间积累的误差相关 微分项D：与误差的变化相关 大家的解释都很多了，这里不进行描述了。说一下调参的顺序和心得吧：先调P，再调D，最后调I 调P，让曲线震荡起来 调D，阻止曲线的震荡，让曲线平滑 调I，把曲线整体调整到目标值 代码 我随便写的代码，pid三个参数没有调整，但PID的意思我是基本写清楚了。 #include <iostream> #include <ma
模糊控制算法的C++实现
热门推荐
Alexon Xu的博客
07-01 2万+
之前写过一篇关于使用样本数据获取模糊规则的博文，原文 的地址是：http://blog.csdn.net/shuoyueqishilove/article/details/71908410，大家可以参考，本篇文章适合对模糊控制算法有一定了解的人阅读，给大家提供一种如何用C++实现模糊控制的方法，仅供参考。
博途PLC模糊PID控制（附SCL完整源代码）
RXXW_Dor的博客
05-10 6918
操作人员根据对象的当前状态和以往的控制经验，用手动控制的方法给出适当的控制量，对被控对象进行控制。用电脑模拟操作人员手动控制的经验，对被控对象进行控制。用模糊数学的知识模仿人脑的思维方式，对模糊现象进行识别和判决，给出精确的控制量，对被控对象进行控制。与经典控制理论和现代控制理论相比，模糊控制的特点是不需要建立对象的精确模型。根据操作人员手动控制的经验，总结的完整控制规则，在根据系统当前的运行状态，经过模糊推理，模糊判决等运算，求出控制量，实现对被控对象的控制。......
《动物园管理系统》关键算法C++
最新发布
08-24
动物园管理系统包含多个关键算法，以下是其中几个常见的算法： 1. 动物分类算法：通过对动物的特征进行分析和比较，将动物进行合理分类和归类。可以使用聚类算法（如K-means）或决策树算法来实现。 2. 动物饲养计划算法：根据动物的饮食习惯、生长需求和繁殖周期等因素，制定合理的饲养计划。可以使用遗传算法或规划算法来优化饲养计划。 3. 温度控制算法：根据不同动物对温度的要求和环境温度，自动调节动物园内的温度。可以使用模糊逻辑控制或PID控制等算法来实现。 4. 动物医疗诊断算法：根据动物的症状和体检数据，进行医疗诊断和治疗方案推荐。可以使用机器学习算法（如支持向量机）或专家系统来实现。 这些算法只是动物园管理系统中的一部分，具体系统还涉及到数据管理、用户交互和安全等方面的功能。

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 78
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值