智能控制相关书籍的书，包含模糊算法+pid，神经网络pid

智能控制相关书籍的书，包含模糊算法+pid，神经网络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

 属性            大小     日期    时间   名称
----------- ---------  ---------- -----  ----
     目录           0  2018-10-20 11:48  智能控制相关书籍的书，包含模糊算法+pid，神经网络pid\
     目录           0  2018-10-20 11:45  智能控制相关书籍的书，包含模糊算法+pid，神经网络pid\fuzzy-PID源码\
     文件       10863  2017-06-28 15:28  智能控制相关书籍的书，包含模糊算法+pid，神经网络pid\fuzzy-PID源码\fuzzy_PID.cpp
     文件        2651  2017-06-28 15:28  智能控制相关书籍的书，包含模糊算法+pid，神经网络pid\fuzzy-PID源码\fuzzy_PID.h
     文件        2122  2017-06-28 15:28  智能控制相关书籍的书，包含模糊算法+pid，神经网络pid\fuzzy-PID源码\main.cpp
     文件         135  2017-06-28 15:28  智能控制相关书籍的书，包含模糊算法+pid，神经网络pid\fuzzy-PID源码\README.md
     文件     6464830  2018-07-16 20:37  智能控制相关书籍的书，包含模糊算法+pid，神经网络pid\《智能控制原理及应用》PDF+书签.pdf
     文件     9409273  2018-07-16 20:40  智能控制相关书籍的书，包含模糊算法+pid，神经网络pid\智能控制系统.pdf
     文件     3963316  2018-07-16 21:22  智能控制相关书籍的书，包含模糊算法+pid，神经网络pid\智能控制－刘金琨编著-程序源码以及电子版书.zip
     文件     9409273  2018-07-16 20:38  智能控制相关书籍的书，包含模糊算法+pid，神经网络pid\经典教材——模煳逻辑、专家系统、神经网络控制——智能控制系统.pdf
     文件      712192  2018-10-19 22:07  智能控制相关书籍的书，包含模糊算法+pid，神经网络pid\基于BP神经网络PID整定原理和算法步骤.doc