打印
[应用方案]

模糊PID控制算法

[复制链接]
3617|62
手机看帖
扫描二维码
随时随地手机跟帖
跳转到指定楼层
楼主
mnynt121|  楼主 | 2023-10-25 19:25 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
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;
}


使用特权

评论回复
沙发
lzmm| | 2023-11-5 11:22 | 只看该作者
需要确定合适的模糊函数。这些函数需要能够反映系统的状态和性能指标,并且需要具有足够的精度和可表达性。同时,模糊函数需要考虑到系统的非线性和动态特性。

使用特权

评论回复
板凳
claretttt| | 2023-11-5 11:48 | 只看该作者
在实现模糊PID控制算法时,需要设计合适的模糊控制器。模糊控制器需要能够有效地将系统的实时状态转化为模糊指令,并控制执行机构的动作。同时,模糊控制器需要具有足够的稳定性和精度。

使用特权

评论回复
地板
iyoum| | 2023-11-5 14:50 | 只看该作者
比例环节能快速响应误差变化,积分环节能消除稳态误差,微分环节则可加快系统对于大惯性变化的响应速度并减弱超调趋势。根据系统的实际情况,适当调整这三个环节的比例,可以优化控制效果。例如,当误差向负方向增大时,可以适当增大比例环节以加快调节速度,同时减小积分环节以防止负方向上出现饱和积分的现象。

使用特权

评论回复
5
bestwell| | 2023-11-5 15:23 | 只看该作者
模糊PID控制算法的实现较为复杂,需要具备一定的编程能力和算法基础。如果开发人员缺乏相关经验和技能,则需要花费大量的时间和精力来学习和实践。

使用特权

评论回复
6
plsbackup| | 2023-11-5 16:18 | 只看该作者
需要注意选择合适的模糊化和解模糊的方法

使用特权

评论回复
7
uytyu| | 2023-11-5 17:34 | 只看该作者
在实现模糊PID控制算法时,需要考虑到这些不确定性问题,并采取相应的措施来解决。

使用特权

评论回复
8
mattlincoln| | 2023-11-5 18:07 | 只看该作者
可以减少模糊规则的个数,或者使用简化的模糊推理方法等。

使用特权

评论回复
9
ulystronglll| | 2023-11-5 21:09 | 只看该作者
使用模糊PID控制算法时,需要注意系统的稳定性。

使用特权

评论回复
10
mmbs| | 2023-11-5 21:39 | 只看该作者
模糊PID控制算法的运行环境也非常重要

使用特权

评论回复
11
jimmhu| | 2023-11-5 21:58 | 只看该作者
模糊PID控制算法需要经过严格的测试和验证才能投入使用,以确保其安全性和有效性。因此,开发人员需要制定一套完善的测试计划,并在实施过程中不断监控和评估控制系统的性能。

使用特权

评论回复
12
deliahouse887| | 2023-11-5 22:31 | 只看该作者
虽然模糊PID控制算法在一定程度上提高了系统的鲁棒性,但是在某些情况下,可能会影响系统的稳定性。

使用特权

评论回复
13
ulystronglll| | 2023-11-6 20:05 | 只看该作者
模糊PID控制中,模糊逻辑用于描述输入(误差和误差变化率)和输出(PID参数)之间的模糊关系。选择合适的模糊逻辑(如Mamdani或Takagi-Sugeno)对于实现良好的控制性能至关重要。

使用特权

评论回复
14
wilhelmina2| | 2023-11-7 19:29 | 只看该作者
模糊PID控制算法的核心是模糊规则库,它需要根据被控对象的特性进行设计。模糊规则库的设计需要考虑到输入和输出变量的选择、变量的模糊化方法、模糊规则的选择以及去模糊化方法等因素。

使用特权

评论回复
15
i1mcu| | 2023-11-8 12:17 | 只看该作者
在实际应用前,需要对系统进行建模和仿真,以验证模糊PID算法的有效性。根据仿真结果,可以进一步优化控制算法,提高控制性能。

使用特权

评论回复
16
mollylawrence| | 2023-11-8 13:38 | 只看该作者
在使用模糊PID控制算法时,需要注意系统的稳定性,必要时可以进行稳定性分析。

使用特权

评论回复
17
wilhelmina2| | 2023-11-8 14:58 | 只看该作者
需要根据实际过程的特性和需求,通过实验和调整来找到最佳的模糊控制规则。

使用特权

评论回复
18
ingramward| | 2023-11-8 15:05 | 只看该作者
在模糊PID控制算法中,需要注意避免过度调整PID参数导致系统不稳定的情况。

使用特权

评论回复
19
minzisc| | 2023-11-8 16:09 | 只看该作者
需要根据控制对象的特性和控制需求,合理地设定模糊规则,以达到调整PID参数的目的。

使用特权

评论回复
20
uptown| | 2023-11-8 19:09 | 只看该作者
模糊PID控制算法的计算量较大,因此在资源有限的条件下,可能需要对算法进行优化

使用特权

评论回复
发新帖 我要提问
您需要登录后才可以回帖 登录 | 注册

本版积分规则

19

主题

3016

帖子

2

粉丝