Está en la página 1de 6

#include <Fuzzy.

h>
#include <FuzzyInput.h>
#include <FuzzyOutput.h>
#include <FuzzySet.h>
#include <FuzzyRule.h>
#include <FuzzyRuleAntecedent.h>
#include <FuzzyRuleConsequent.h>
#include <FuzzyComposition.h>
#include <FuzzyIO.h>

#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
//Pin anlogo para la lectura de los valores del sensor.
int sensorPin = A0;
//PWM pin para el puente H.
int ventilator = 9;
//Almacena el pulso en microsegundos.
float pulseTime = 0;
//Declara un nuevo objeto fuzzy.
Fuzzy* fuzzy = new Fuzzy();
void setup(){
lcd.begin(16,2);
lcd.print("TEMP.: ");
lcd.setCursor(0,1);
lcd.print("VELOC.: ");
//Inicia el mdulo serial.
Serial.begin(9600);

//Asigna el pin del sensor como ENTRADA.


pinMode(sensorPin, INPUT);
pinMode(ventilator,OUTPUT);
//Declara la entrada difusa, la temperatura.
FuzzyInput* temperatura = new FuzzyInput(1);
//Establece las bases de las reglas que compone la entrada difusa.
FuzzySet* vf = new FuzzySet(15, 20, 20, 25); //Temperatura tibia-fria.
temperatura->addFuzzySet(vf);//Adiciona la variable temperatura tibia-fria.
FuzzySet* sf = new FuzzySet(20, 25, 25, 30); //Temperatura tibia.
temperatura->addFuzzySet(sf);//Adiciona la variable temperatura tibia.
FuzzySet* normal = new FuzzySet(30, 35, 35, 40); //Temperatura tibia-caliente.
temperatura->addFuzzySet(normal);//Adiciona la variable temperatura tibia-caliente.
FuzzySet* sc = new FuzzySet(40, 45, 45, 50); //Temperatura caliente.
temperatura->addFuzzySet(sc);//Adiciona la variable temperatura caliente.
FuzzySet* vc = new FuzzySet(35, 40, 50, 50); //Temperatura muy caliente.
temperatura->addFuzzySet(vc);//Adiciona la variable temperatura muy caliente.
fuzzy->addFuzzyInput(temperatura);//Adiciona la entrada de temperatura a la variable difusa.
//Declara la salida difusa, la velocidad del motor del ventilador.
FuzzyOutput* velocity = new FuzzyOutput(1);
// Crea los conjuntos difusos que componen la salida difusa de velocidad
FuzzySet* qbwd = new FuzzySet(0, 50, 50, 100); //Velocidad lenta
velocity->addFuzzySet(qbwd);//Adiciona el FuzzySet (conjunto difuso) lenta en velocidad
FuzzySet* sbwd = new FuzzySet(50, 100, 100, 150); //Velocidad media-lenta
velocity->addFuzzySet(sbwd);//Adiciona el FuzzySet (conjunto difuso) medio en velocidad
FuzzySet* mid = new FuzzySet(100, 150, 150, 200); //Velocidad media
velocity->addFuzzySet(mid);//Adiciona el FuzzySet (conjunto difuso) media en Velocidad
FuzzySet* sfwd = new FuzzySet(150, 200, 200, 250); //Velocidad rpida

velocity->addFuzzySet(sfwd);//Adiciona el FuzzySet (conjunto difuso) rpida en Velocidad


FuzzySet* ffwd = new FuzzySet(200, 250, 250, 250); //Velocidad muy rpida
velocity->addFuzzySet(ffwd);//Adiciona el FuzzySet (conjunto difuso) muy rpida en velocidad
fuzzy->addFuzzyOutput(velocity); //Adiciona una salida en un objeto Difuso
//Reglas difusas.
//SI la temperatura es tibia-fria ENTONCES velocidad ser lenta
FuzzyRuleAntecedent* iftemperaturaSmall = new FuzzyRuleAntecedent();
iftemperaturaSmall->joinSingle(vf);
FuzzyRuleConsequent* thenVelocitySlow = new FuzzyRuleConsequent();
//Inicia un Consecuente para una expresin
thenVelocitySlow->addOutput(qbwd);// Adiciona el FuzzySet correspondiente al objeto
Consecuente
// Inicia un objeto FuzzyRule
FuzzyRule* fuzzyRule01 = new FuzzyRule(1, iftemperaturaSmall, thenVelocitySlow); //Pasa el
Antecedente del Consecuente de una expresin
fuzzy->addFuzzyRule(fuzzyRule01); // Adiciona el FuzzyRule a un objeto Difuso.
//SI temperatura es tibia cerca ENTONCES velocidad ser media-lenta
FuzzyRuleAntecedent* iftemperaturaSafe = new FuzzyRuleAntecedent();
//Inicia un Antecedente para una expresin
iftemperaturaSafe->joinSingle(sf); // Adiciona el FuzzySet correspondiente al objeto
Antecediente
FuzzyRuleConsequent* thenVelocityAverage = new FuzzyRuleConsequent();
//Inicia un Consecuente para la expresin
thenVelocityAverage->addOutput(sbwd);//Adiciona el FuzzySet correspondiente al objeto
Consecuente
//Inicia un objeto FuzzyRule
FuzzyRule* fuzzyRule02 = new FuzzyRule(2, iftemperaturaSafe,
thenVelocityAverage); //Pasa el Antecedente en el Consecuente de la expresin
fuzzy->addFuzzyRule(fuzzyRule02); // Adiciona la FuzzyRule al objeto Fuzzy

//SI la temperatura es tibia-caliente ENTONCES speed ser mediz.


FuzzyRuleAntecedent* iftemperaturaBig = new FuzzyRuleAntecedent(); //Inicia un
Antecedente para una expresin
iftemperaturaBig->joinSingle(normal); // Adiciona el FuzzySet correspondiente al objeto
Antecedente
FuzzyRuleConsequent* thenVelocityFast = new FuzzyRuleConsequent(); //Inicia un
Consecuente para una expresin
thenVelocityFast->addOutput(mid);// Adiciona el FuzzySet correspondiente al objeto
Consecuente
//Inicia un objeto FuzzyRule
FuzzyRule* fuzzyRule03 = new FuzzyRule(3, iftemperaturaBig,
thenVelocityFast); //Pasa el Antecedente en el Consecuente de la expresin
fuzzy->addFuzzyRule(fuzzyRule03); //Adiciona el FuzzyRule al objeto Fuzzy
//SI temperatura es caliente ENTONCES velocidad ser rpida
FuzzyRuleAntecedent* iftemperaturaSF = new FuzzyRuleAntecedent();
//Inicia un Antecedente para una expresin
iftemperaturaSF->joinSingle(sc); //Adiciona el FuzzySet correspondiente al objeto Antecedente
FuzzyRuleConsequent* thenVelocitySF = new FuzzyRuleConsequent(); //IniciaIniciaInicia un
Consecuente para una expresin
thenVelocitySF->addOutput(sfwd);//Adiciona el FuzzySet correspondiente al objeto
Consecuente
// Instanciando um objeto FuzzyRule
FuzzyRule* fuzzyRule04 = new FuzzyRule(4, iftemperaturaSF,
thenVelocitySF); // Pasa el Antecedente en el Consecuente de la expresin
fuzzy->addFuzzyRule(fuzzyRule04); // Adiciona el FuzzyRule al objeto Fuzzy
//SI temperatura es muy caliente ENTONCES velocidad ser muy rpida
FuzzyRuleAntecedent* iftemperaturaVF = new FuzzyRuleAntecedent(); //Inicia un Antecedente
para a expresin
iftemperaturaVF->joinSingle(vc); // Adiciona el FuzzySet correspondiente al objeto
Antecedente

FuzzyRuleConsequent* thenVelocityFF = new FuzzyRuleConsequent(); //Inicia un Consecuente


para una expresin
thenVelocityFF->addOutput(ffwd);//Adiciona el FuzzySet correspondiente al objeto
Consecuente
//Inicia un objeto FuzzyRule
FuzzyRule* fuzzyRule05 = new FuzzyRule(5, iftemperaturaVF,
thenVelocityFF); // Pasa el Antecedente en el Consecuente de la expresin
fuzzy->addFuzzyRule(fuzzyRule05); // Adiciona el FuzzyRule al objeto Fuzzy
}
void loop(){
//Convertimos el valor anlogo ledo de 5 voltios a grados celsius
pulseTime = (1000.0*analogRead(sensorPin))/1023.0;
Serial.print("Temperatura medida: ");
Serial.println(pulseTime);
fuzzy->setInput(1,pulseTime);
fuzzy->fuzzify();
float output = fuzzy->defuzzify(1);
Serial.print("Velocidad: ");
Serial.println(output);
lcd.setCursor(4,0);
lcd.print(pulseTime);
lcd.setCursor(4,1);
lcd.print(output);
//Envia la seal al Arduino para la activacin necesaria de la salida del PWM
if(output>0)
{
Serial.println("Activando el ventilador...");
analogWrite(ventilator,200+output);

}
else if(output == 0)
{
Serial.println("Todo esta bien...");
analogWrite(ventilator,0);
analogWrite(ventilator,0);
}
else
{
Serial.println("Entrada irreconocible");
}
//Espera 5 segundos antes de repetirse nuevamente//
delay(1000);
}