自适应模糊PID代码 C++实现

基于C++ 的模糊PID控制代码，参考许多论文制定的PID参数调整模糊规则，代码对于想了解这方面的人有一定的借鉴意义。但是不保证什么控制对象都能用，具体对象具体设计。

#include“fuzzy_PID.h“


FuzzyPID::FuzzyPID（float e_maxfloat de_maxfloat kp_maxfloat ki_maxfloat kd_maxfloat Kp0float Ki0float 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 *fuzzyLimitfloat *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 xfloat afloat bfloat 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 xfloat avefloat sigma） 
{
	float u;
	if（sigma<0）
	{
	   cout<<“In gaussmf sigma must larger than 0“<	}
	u=exp（-pow（（（x-ave）/sigma）2））;
	return u;
}
//梯形隶属度函数
float FuzzyPID::trapmf（float xfloat afloat bfloat cfloat d）
{
    float u;
	if（x>=a&&x		u=（x-a）/（b-a）;
	else if（x>=b&&x        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	   for（int j=0;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 & typefloat *parasint n）
{
	int N_mf_eN_mf_deN_mf_KpN_mf_KiN_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\““<      if（mf_t_e==“trimf“）
        N_mf_e=3;
	  else if（mf_t_e==“gaussmf“）
		N_mf_e=2;
	  els

 属性            大小     日期    时间   名称
----------- ---------  ---------- -----  ----

     文件      10863  2017-06-27 21:26  Fuzzy_PID\fuzzy_PID.cpp

     文件       2651  2017-06-27 16:29  Fuzzy_PID\fuzzy_PID.h

     文件       2120  2017-06-30 10:49  Fuzzy_PID\main.cpp

     目录          0  2018-05-24 09:22  Fuzzy_PID

----------- ---------  ---------- -----  ----

                15634                    4