fuzzy.c

用C51编的温度控制的PID算法适用性强方便移植

/*
	Application name:	FUzzy Development and Generation Environment (FUDGE) Version V1.02
	File name:			Fuzzy.c
	Written by:			Alex DeCastro & Jason Spielman

	Copyright Motorola 1994
	SCALE	1
*/

#include <stdio.h>
#include "Fuzzy.h"

int	num_inputs = 2;
int	num_outputs = 1;
int	num_rules = 15;

int	num_input_mfs[2] = { 7, 7 };

struct	In	Inputs[] =
{
	{ -90.000000, 90.000000 },
	{ -90.000000, 90.000000 }
};

float	inmem_points[2][7][4] =
{
	{
		{ -90.000000, -90.000000, -54.000000, -36.000000 },
		{ -54.000000, -36.000000, -36.000000, -16.000000 },
		{ -36.000000, -19.000000, -18.000000, 0.000000 },
		{ -18.000000, 0.000000, 0.000000, 20.000000 },
		{ 0.000000, 17.000000, 18.000000, 36.000000 },
		{ 18.000000, 36.000000, 36.000000, 56.000000 },
		{ 36.000000, 56.000000, 90.000000, 90.000000 }
	},
	{
		{ -90.000000, -90.000000, -72.000000, -49.000000 },
		{ -72.000000, -49.000000, -48.000000, -25.000000 },
		{ -48.000000, -25.000000, -24.000000, -1.000000 },
		{ -24.000000, -1.000000, 0.000000, 23.000000 },
		{ 0.000000, 23.000000, 24.000000, 47.000000 },
		{ 24.000000, 47.000000, 48.000000, 71.000000 },
		{ 48.000000, 71.000000, 90.000000, 90.000000 }
	}
};
int	num_output_mfs[1] = { 7 };

struct	Out	Outputs[] =
{
	{ -18.000000, 18.000000 }
};

float	outmem_points[1][7][4] =
{
	{
		{ -18.000000 },
		{ -12.000000 },
		{ -6.000000 },
		{ 0.000000 },
		{ 6.000000 },
		{ 12.000000 },
		{ 18.000000 }
	}
};
float	crisp_outputs[1] = { 0};

int	num_rule_ants[15] = { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2};
int	num_rule_cons[15] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};

struct	Rule	Rules[15] =
{
	{ { 0x00, 0x19 }, { 0xb0 } },
	{ { 0x08, 0x19 }, { 0xa8 } },
	{ { 0x10, 0x19 }, { 0xa0 } },
	{ { 0x10, 0x21 }, { 0xa0 } },
	{ { 0x18, 0x01 }, { 0xb0 } },
	{ { 0x18, 0x09 }, { 0xa8 } },
	{ { 0x18, 0x19 }, { 0x98 } },
	{ { 0x18, 0x21 }, { 0x90 } },
	{ { 0x18, 0x29 }, { 0x88 } },
	{ { 0x18, 0x31 }, { 0x80 } },
	{ { 0x20, 0x11 }, { 0x90 } },
	{ { 0x20, 0x19 }, { 0x90 } },
	{ { 0x28, 0x19 }, { 0x88 } },
	{ { 0x30, 0x19 }, { 0x80 } },
	{ { 0x18, 0x11 }, { 0xa0 } }
};

void fuzzy_step(float *crisp_inputs, float *crisp_outputs)
{
	int             in_index,rule_index,out_index;
	float   in_val;
	for (in_index = 0;in_index < num_inputs;in_index++)
	{
		fuzzify_input(in_index,crisp_inputs[in_index]);
	}
	for (rule_index = 0;rule_index < num_rules;rule_index++)
	{
		eval_rule(rule_index);
	}
	for (out_index = 0;out_index < num_outputs;out_index++)
	{
		crisp_outputs[out_index] = defuzzify_output(out_index, crisp_inputs);
		if (TRACE) printf("crisp_output[%d] = %f\n", out_index, crisp_outputs[out_index]);
	}
}
void fuzzify_input(int in_index,float in_val)
{
	int i;
	if (TRACE) printf("Fuzzify: input #%d crisp value %f\n", in_index, in_val);
	for (i = 0;i < num_input_mfs[in_index];i++)
	{
		fuzzy_inputs[in_index][i] = get_membership_value(in_index,i,in_val);
		if (TRACE) printf("Membership function #%d grade %f\n", i, fuzzy_inputs[in_index][i]);
	}
}
float get_membership_value(int in_index,int mf_index,float in_val)
{
	if (in_val < inmem_points[in_index][mf_index][0]) return 0;
	if (in_val > inmem_points[in_index][mf_index][3]) return 0;
	if (in_val <= inmem_points[in_index][mf_index][1])
	{
		if (inmem_points[in_index][mf_index][0] == inmem_points[in_index][mf_index][1])
			return 1;
		else
			return ((in_val - inmem_points[in_index][mf_index][0]) /
					(inmem_points[in_index][mf_index][1] - inmem_points[in_index][mf_index][0]));
	}
	if (in_val >= inmem_points[in_index][mf_index][2])
	{
		if (inmem_points[in_index][mf_index][2] == inmem_points[in_index][mf_index][3])
			return 1;
		else
			return ((inmem_points[in_index][mf_index][3] - in_val) /
					(inmem_points[in_index][mf_index][3] - inmem_points[in_index][mf_index][2]));
	}
	return 1;
}
void eval_rule(int rule_index)
{
	int             in_index,out_index,mf_index,ant_index,con_index;
	int     val;
	float   rule_strength = 1;
	for     (ant_index = 0;ant_index < num_rule_ants[rule_index];ant_index++)
	{
		val = Rules[rule_index].antecedent[ant_index];
		in_index = (val & 0x07);
		mf_index = ((val & 0x38) >> 3);
		rule_strength = MIN(rule_strength,fuzzy_inputs[in_index][mf_index]);
	}
	rule_strengths[rule_index] = rule_strength;
	if (TRACE) printf("Rule  #%d strength %f\n", rule_index, rule_strength);
	for (con_index = 0;con_index < num_rule_cons[rule_index];con_index++)
	{
		val = Rules[rule_index].consequent[con_index];
		out_index = (val & 0x03);
		mf_index = ((val & 0x38) >> 3);
		fuzzy_outputs[out_index][mf_index] = MAX(fuzzy_outputs[out_index][mf_index],
			rule_strengths[rule_index]);
	}
}
float defuzzify_output(int out_index,float *inputs)
{
	float           summ = 0;
	float           product = 0;
	float           temp1,temp2;
	int             mf_index,in_index;
	if (TRACE) printf("Defuzzify: output #%d\n", out_index);
	for (mf_index = 0;mf_index < num_output_mfs[out_index];mf_index++)
	{
		temp1 = fuzzy_outputs[out_index][mf_index];
		temp2 = outmem_points[out_index][mf_index][0];
		summ = summ + temp1;
		product = product + (temp1 * temp2);
		if (TRACE) printf("Membership function #%d grade %f\n", mf_index, fuzzy_outputs[out_index][mf_index]);
		fuzzy_outputs[out_index][mf_index] = 0;
	}
	if (summ > 0)
	{
		crisp_outputs[out_index] = product / summ;
		return crisp_outputs[out_index];
	}
	else
	{
		if (NO_RULES){
		printf("No rules fire for:\n");
			for (in_index = 0;in_index < num_inputs;in_index++)
			    printf("Input #%d=%f ", in_index,inputs[in_index]);
			    printf("\n");}
		return crisp_outputs[out_index];
	}
}