tempctrl.cpp

基于人工智能中模糊集理论的模拟温控程序

// TempCtrl.cpp: implementation of the TempCtrl class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Temperature.h"
#include "TempCtrl.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

float Min(float x,float y)
{
	if(x>y)
	{
		return y;
	}
	else
	{
		return x;
	}
}

float Max(float x,float y)
{
	if(x>y)
	{
		return x;
	}
	else
	{
		return y;
	}
}

TempCtrl::TempCtrl()
{
	dx=0;
	dtime=0;
	T0=210.0f;
	T=82.5f;
	E=(210-T)*4/170;
	DE=0.0f;
	K=0.1f;
	W=0.0f;
	for(int i=0;i<5;i++)
	{
		mFE[i]=0;
		mFDE[i]=0;
	}
	for(i=0;i<4;i++)
	{
		malphaW[i].FunctionNumber=5;
		malphaW[i].alpha=0;
	}
	mTW=0;
}

float TempCtrl::NB(float x)
{
	if((x>=-4)&&(x<=-2))
	{
		return (-0.5f*x-1);
	}
	else
	{
		return 0;
	}
}

float TempCtrl::NS(float x)
{
	if((x>=-4)&&(x<=-2))
	{
		return (0.5f*x+2);
	}
	else
		if((x>=-2)&&(x<=0))
		{
			return (-0.5f*x);
		}
		else
		{
			return 0;
		}
}

float TempCtrl::ZO(float x)
{
	if((x>=-2)&&(x<=0))
	{
		return (0.5f*x+1);
	}
	else
		if((x>=0)&&(x<=2))
		{
			return (-0.5f*x+1);
		}
		else
		{
			return 0;
		}
}

float TempCtrl::PS(float x)
{
	if((x>=0)&&(x<=2))
	{
		return (0.5f*x);
	}
	else
		if((x>=2)&&(x<=4))
		{
			return (-0.5f*x+2);
		}
		else
		{
			return 0;
		}
}

float TempCtrl::PB(float x)
{
	if((x>=2)&&(x<=4))
	{
		return (0.5f*x-1);
	}
	else
	{
		return 0;
	}
}

int TempCtrl::JudgeW(int e,int de)
{
	if(e==2)
	{
		switch(de)
		{
		case 0:
			return 4;
			break;
		case 1:
			return 3;
			break;
		case 2:
			return 2;
			break;
		case 3:
			return 1;
			break;
		case 4:
			return 0;
			break;
		}
	}
	if(de==2)
	{
		switch(e)
		{
		case 0:
			return 4;
			break;
		case 1:
			return 3;
			break;
		case 2:
			return 2;
			break;
		case 3:
			return 1;
			break;
		case 4:
			return 0;
			break;
		}
	}
	if((e!=2)&&(de!=2))
	{
		return 5;
	}
	return 5;
}

void TempCtrl::W_Member_Function()
{
	int count=0;
	mFE[0]=NB(E);
	mFE[1]=NS(E);
	mFE[2]=ZO(E);
	mFE[3]=PS(E);
	mFE[4]=PB(E);
	mFDE[0]=NB(DE);
	mFDE[1]=NS(DE);
	mFDE[2]=ZO(DE);
	mFDE[3]=PS(DE);
	mFDE[4]=PB(DE);
	for(int i=0;i<5;i++)
	{
		if(mFE[i]!=0)
		{
			for(int j=0;j<5;j++)
			{
				if(mFDE[j]!=0)
				{
					malphaW[count].FunctionNumber=TempCtrl::JudgeW(i,j);
					malphaW[count].alpha=Min(mFE[i],mFDE[j]);
					count++;
				}
			}
		}
	}
	count=0;
}

float TempCtrl::MW(float x,int y)
{
	switch(y)
	{
	case 0:
		{
			return NB(x);
			break;
		}
	case 1:
		{
			return NS(x);
			break;
		}
	case 2:
		{
			return ZO(x);
			break;
		}
	case 3:
		{
			return PS(x);
			break;
		}
	case 4:
		{
			return PB(x);
			break;
		}
	case 5:
		{
			return 0;
			break;
		}
	}
	return 0;
}

float TempCtrl::ComputW()
{
	float numerator=0.0f;
	float denominator=0.0f;
	float tempW;
	for(int k=0;k<8000;k++)
	{
		tempW=(-4.0f+k*0.001f);
		denominator=denominator+0.001f*Max(Max(Min(malphaW[0].alpha,MW(tempW,malphaW[0].FunctionNumber)),Min(malphaW[1].alpha,MW(tempW,malphaW[1].FunctionNumber))),Max(Min(malphaW[2].alpha,MW(tempW,malphaW[2].FunctionNumber)),Min(malphaW[3].alpha,MW(tempW,malphaW[3].FunctionNumber))));
		numerator=numerator+0.001f*tempW*Max(Max(Min(malphaW[0].alpha,MW(tempW,malphaW[0].FunctionNumber)),Min(malphaW[1].alpha,MW(tempW,malphaW[1].FunctionNumber))),Max(Min(malphaW[2].alpha,MW(tempW,malphaW[2].FunctionNumber)),Min(malphaW[3].alpha,MW(tempW,malphaW[3].FunctionNumber))));
	}
	if(denominator==0||numerator==0)
	{
		W=W;
	}
	else
	{
		W=numerator/denominator;
	}
	return W;
}

void TempCtrl::ComputNext()
{
	DE=DE+K*W;
	E=E+DE;
	T=210-E*170/4;
	T_Curr=(380-T)*T0/170;
}

TempCtrl::~TempCtrl()
{

}