模糊控制，模糊pid源码

/****************************************************************************
*
*文件名：FUZZY_PID.c
*
*功  能：此文件是模糊自适应整定PID控制程序
*
*作  者: Sahara
*
****************************************************************************/

#include “fuzzy_pid.h“

/****************************************************************************
*
*文件名：FUZZY_Calc_Kp（float efloat ecuint16_t e_maxuint16_t ec_maxuint8_t fuzzy_max）
*
*功  能：模糊处理 （具体处理依靠参数设定）
*
*作  者: Sahara   Ekko
* 
*入口参数：float efloat ec，e_max（误差变化范围为+-e_max）ec_max同理，
*
*出口参数：fuzzy
*
****************************************************************************/

float FUZZY_Calc（float efloat ecuint16_t e_maxuint16_t ec_maxuint8_t fuzzy_max）
{
	float eRule[7]  = {-e_max -e_max * 0.667f -e_max * 0.333f 0 e_max * 0.333f e_max * 0.667f e_max};
	float ecRule[7] = {-ec_max -ec_max * 0.667f -ec_max * 0.333f 0 ec_max * 0.333f ec_max * 0.667f ec_max};
	float uRule[7]  = {fuzzy_max fuzzy_max * 0.667f fuzzy_max * 0.333f 0 fuzzy_max * 0.333f fuzzy_max * 0.667f fuzzy_max};
	
	float eFuzzy[7];
	float eFuzzy_Out[6];
	float ecFuzzy[7];	
	float ecFuzzy_Out[6];
	float uFuzzy[7];
	int   PePec;
	float Rule[7][7];
	float a1 a2;//生成模糊规则表的可调因子
  float fuzzy; //输出值
	/*int Rule[6][6]={{3 2 2 1 0 0}
					{3 2 1 1 0 -1}
					{2 2 1 0 -1 -1}
					{2 1 0 -1 -2 -2}
					{1 0 -1 -1 -2 -2}
					{0 -1 -2 -2 -2 -3}
					};
	*/
	/*int Rule[7][7]={{3 3 2 2 1 0 0}
					{3 3 2 1 1 0 -1}
					{2 2 2 1 0 -1 -1}
					{2 2 1 0 -1 -2 -2}
					{1 1 0 -1 -1 -2 -2}
					{1 0 -1 -2 -2 -2 -3}
					{0 0 -2 -2 -2 -3 -3}
					};
	*/
	int ij;
	for（i=0;i<7;i++）
	{
		eFuzzy[i]=0;
	}
	for（i=0;i<7;i++）
	{
		ecFuzzy[i]=0;
	}
	for（i=0;i<7;i++）
	{
		uFuzzy[i]=0;
	}
	for（i=0;i<2;i++）
	{
		eFuzzy_Out[i]=0;	
	}
	for（i=0;i<2;i++）
	{
		ecFuzzy_Out[i]=0;	
	}
/****************************************************************************
*
* 误差隶属函数描述
* 误差隶属函数的描述采用三角形隶属函数描述
*
****************************************************************************/		
	if（e < eRule[0]）
	{
		eFuzzy_Out[0] = 1.0;
		Pe = 0;
	}
	else if（e > eRule[0] && e < eRule[1]）
	{
		eFuzzy[0] = （e - eRule[1]）/（eRule[0] - eRule[1]）;
		eFuzzy[1] = （e - eRule[0]）/（eRule[1] - eRule[0]）;
		eFuzzy_Out[0] = eFuzzy[0] > eFuzzy[1] ? eFuzzy[0] : eFuzzy[1];
		Pe = 0;
	}
	else if（e > eRule[1] && e < eRule[2]）
	{
		eFuzzy[1] = （e - eRule[2]）/（eRule[1] - eRule[2]）;
		eFuzzy[2] = （e - eRule[1]）/（eRule[2] - eRule[1]）;
		eFuzzy_Out[1] = eFuzzy[1] > eFuzzy[2] ? eFuzzy[1] : eFuzzy[2];
		Pe = 1;
	}
	else if（e > eRule[2] && e < eRule[3]）
	{
		eFuzzy[2] = （e - eRule[3]）/（eRule[2] - eRule[3]）;
		eFuzzy[3] = （e - eRule[2]）/（eRule[3] - eRule[2]）;
		eFuzzy_Out[2] = eFuzzy[2] > eFuzzy[3] ? eFuzzy[2] : eFuzzy[3];
		Pe = 2;
	}
	else if（e > eRule[3] && e < eRule[4]）
	{
		eFuzzy[3] = （e - eRule[4]）/（eRule[3] - e