fuzzycontroller.cpp

三容水箱编写FuzzyController程序VC++源代码

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

#include "stdafx.h"
#include "FuzzyController.h"
#include "setting.h"
#include "ExternData.h"

#define DllImport __declspec(dllimport)
extern DllImport ExternData Dll_ExternData;
//--------------Testing-----------------------//
double input2[MAXSETS][3] = {		//err -- input2
				{NegNaN, -95, -80},
				{-99, -80, -23},
				{-75, -23, 0},
				{-17, 0, 17},
				{0, 23, 75},
				{23, 80, 99},
				{80, 95,NaN},
};
double input1[MAXSETS][3] = {	//delta_err -- input1
				{NegNaN, -95, -60},
				{-98, -80, -30},
				{-60, -30, 0},
				{-10, 0, 10},
				{0, 30, 60},
				{30, 80, 98},
				{60, 95, NaN},
};

double output[MAXSETS][3] = {	//delta_u
	{NegNaN, -95, -80},	//{NegNaN, -9.5, -4.0},//
	{-98, -80, -18},	//{-8.0, -4.0, -1.0},//
	{-77, -18, 0},		//{-4.0, -1.0, 0},//
	{-10, 0, 10},		//{-0.5, 0, 0.5},//
	{0, 18, 77},		//{0, 1.0, 4.0},//
	{18, 80, 98},		//{1.0, 4.0, 8.0},//
	{80, 95, NaN},		//{4.0, 9.5, NaN},//
};

int rules[MAXSETS][MAXSETS] = {	
//col: input2	 
			//NL  NM  NS  ZE  PS  PM  PL    //row: input1
			{NL, NL, NM, NM, NS, NS, ZE},	//NL
			{NL, NM, NM, NS, NS, ZE, PS},	//NM
			{NM, NM, NS, NS, ZE, PS, PS},	//NS
			{NM, NS, NS, ZE, PS, PS, PM},	//ZE
			{NS, NS, ZE, PS, PS, PM, PM},	//PS
			{NS, ZE, PS, PS, PM, PM, PL},	//PM
			{ZE, PS, PS, PM, PM, PL, PL},	//PL
};

CString labels[MAXSETS + 1] = {"NL", "NM", "NS", "ZE", "PS", "PM", "PL", "UD"};

void FuzzyController::Test()
{
	double devideinput1 = 10;	//delta_e
	double devideinput2 = 0.1;	//err
	double devideoutput = 100;
	for(int i = 0; i < MAXSETS; i++)
	{
		int j;
		for(j = 0; j < 3; j ++)
			input1[i][j] /= devideinput1;
		input1[0][0] = NegNaN;
		input1[MAXSETS-1][3-1] = NaN;
		m_input1.m_fuzzysets[i].SetParam(labels[i], input1[i]);	//delta_err, input1
		for(j = 0; j < 3; j++)
			input2[i][j] /= devideinput2;
		input2[0][0] = NegNaN;
		input2[MAXSETS - 1][3-1] = NaN;
		m_input2.m_fuzzysets[i].SetParam(labels[i], input2[i]);	//err, input2
		for(j = 0; j < 3; j++)
			output[i][j] /= devideoutput;
		output[0][0] = NegNaN;
		output[MAXSETS - 1][3-1] = NaN;
		m_output.m_fuzzysets[i].SetParam(labels[i], output[i]);
	}
	m_input1.m_nSet = MAXSETS;
	m_input2.m_nSet = MAXSETS;
	m_output.m_nSet = MAXSETS;
	m_input1.m_dmax = 100.0/devideinput1;
	m_input1.m_dmin = -100.0/devideinput1;
	m_input2.m_dmax = 100.0 / devideinput2;
	m_input2.m_dmin = -100.0 / devideinput2;
	m_output.m_dmax = 100.0 / devideoutput;
	m_output.m_dmin = -100.0 / devideoutput;
	//涉及到将整个rule table中的rule进行编号的关系
	//affected: rule grid display(由编号决定), 
	//			fuzzy inference(由SetRule决定)
	//input1:	err			-- SetRule--index1
	//input2:	delta_err	-- SetRule--index2
	int col, row;
	for(row = 0; row < m_input1.m_nSet; row ++)	//row -- delta_err -- input1
		for(col = 0; col < m_input2.m_nSet; col++)	//column -- err -- input2
		{
			m_rules[row][col].SetRule(row, col, rules[row][col]);
		}
}
//--------------End Testing--------------------//

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

FuzzyController::FuzzyController()
{
	m_nType = CONTROLLER_FUZZY;
	m_cstrName = "----模糊控制";
	//private variables
	cur_err = 0.0;		//init data
	prev_err = 0.0;
	prev_u = 0.0;
	Test();
}

FuzzyController::~FuzzyController()
{

}

void FuzzyController::CalcU(const double *input, double *output, const double *reference)
{
	int indim = 0;	//the 1st AD variable
	int outdim = 0;	//the 1st DA variable
	cur_err = reference[indim] - input[indim];
	//--------fuzzy controller calculation---------
	double out = 0.0;
	//fuzzification
	m_input1.Fuzzify(cur_err - prev_err);	//delta_e
	m_input2.Fuzzify(cur_err);				//err
	//fuzzy reasoning
		//clear previous result
	m_output.Reset();
	int r = 0, c = 0;
	int index1, index2, outindex;
	double mem;
	for(r = 0; r < m_input1.m_nSet; r ++)
		for(c = 0; c < m_input2.m_nSet; c ++)
	{
		index1 = m_rules[r][c].m_index1;	//index into input1, delta_e
		index2 = m_rules[r][c].m_index2;	//index into input2, err
		outindex = m_rules[r][c].m_outindex;
		if(outindex < 0)
			continue;
		//模糊与操作 -- 求Min
		mem = m_input1.m_memship[index1] < m_input2.m_memship[index2] ? 
			m_input1.m_memship[index1] : m_input2.m_memship[index2];
		m_output.SetMemship(outindex,mem);	//可能有问题,如果多个规则得到相同的结论
											//已经处理了，中间有求Max的操作!!2003_July_03
	}
	//defuzzification
	out = m_output.Defuzzify();
	//send calculated action
	output[outdim] = out + prev_u;

/*	if(output[0] > Dll_ExternData.m_MAXU)
		output[0] = Dll_ExternData.m_MAXU;
	if(output[0] < Dll_ExternData.m_MINU)
		output[0] = Dll_ExternData.m_MINU;
*/
	//shift data
	prev_err = cur_err;
	prev_u = output[outdim];

	//limit the minimum value
	if(output[outdim] > -1.0 
		&& output[outdim] < Dll_ExternData.m_DASetting[outdim].m_MINVALIDU)		//special limit controller output
		output[outdim] = Dll_ExternData.m_DASetting[outdim].m_MINVALIDU;
}

void FuzzyController::Reset()
{
	prev_err = 0.0;
	prev_u = 0.0;
}