1
Control digital de sistema de motores DC
Con sensor de proximidad (lgica difusa)
Michael Carpintero 25757, Jhon Alexander Alarcn, 22014, Camilo Alejandro Garzn, 35496
Abstractpartiendo de un sistema de avance lineal
Propulsado por dos motores DC, se propone disear un control
sobre la distancia entre la planta y un obstculo que se le
interponga en la trayectoria considerando un valor de referencia
tal que impida que el sistema choque, usando conjunto difusos se
espera poder controlarlo de manera automtica.
Index Termsopen acces Dr. Jose Guillermo Guarnizo,
motor dc, sensor de ultrasonido
I. INTRODUCCION
II. DESCRIPCIN GENERAL DE LA PLANTA
T ENEMOS la tarea de evitar que un vehculo autmata
choque con los obstculos que pueda encontrar, hay
varias formas de abordar este problema, pero en esta ocasin
Componentes elegidos para el diseo.
Tanto los recursos de control como los de comunicaciones
tomaremos las herramientas ofrecidas por el control difuso. sern administrados por una placa Arduino-uno basada en un
La planta consistir en dos motores dc con sentido de marcha controlador Atmega 328p trabajando a 16MHz con una
controlable que harn marchar el vehculo; un lazo de frecuencia de muestreo de 4MHz en las entradas de conversin
realimentacin se har por medio de la un sensor infrarrojo anloga a digital.
encargado de entregar un voltaje consistente con la distancia El sensor ubicado a la salida es un par de bocinas ultrasnicas
Entre la plata y algn objeto en frente del mismo. (HC SR04) recibe un pulso de entrada y devuelve
un pulso de eco a la salida.
Se busca controlar esta distancia haciendo que no exceda Una seal de encendido entrar a travs del mdulo serial via
un punto de referencia determinado dentro de un cdigo bluetooth.
ejecutado en un micro controlador de 8 bits, una vez hecho Dos motoreductores se controlarn a travs del L293d como
de la forma correcta se garantiza que el autmata nunca lo muestra la figura:
chocar.
Modelamiento matemtico.
Luego se crean los conjuntos de lgica difusa para ayudar al
Sistema a mejorar la toma de decisin de una forma ms En lugar de modelar cada motor por separado asumimos
precisa. que la entrada de ganancia unitaria en lazo abierto se ajusta al
El control Fuzzy esta basado en la toma de decisiones, esto lo nivel requerido por la planta debido al driver l293d, en lugar
hace una tecnologa accesible, ya que las reglas estn mas de caracterizar los motores, se asume un comportamiento
cerca del sentido comn que de algn modelo matemtico o como sistema de primer orden y se estima la constante de
ecuaciones. tiempo en 100ms al cronometrar la demora que experimenta
Varios artefactos que usamos hoy en da, estn basados en la el sistema entre el momento de
lgica difusa, por ejemplo, nuestras lavadoras las
programamos para que el agua que utilicemos para lavar
nuestra ropa este a 37C, si el agua que entra esta abajo de
esta temperatura, automticamente el calefactor
se prender para poder llegar a esta temperatura, una vez
alcanzado los 37C el calefactor automticamente se apagara.
Con estas mismas reglas esta basado el funcionamiento del
carro, el carro avanzar a una velocidad alta a una media y
lenta, para que cuando el carro mediante el sensor ultrasnico el efecto del sistema de sample and hold de la placa
llegue a detectar un objeto a una distancia arduino acta como un zero order holder definiendo al bloque
de 15cm., el auto se detenga; la distancia de paro puede ser anterior como:
variada modificando los conjuntos difusos.
Explicar paso a paso como programar cada una de las etapas
en Arduino.
2
El periodo de muestreo sera de 25us, por tanto:
//Asignamos los pines del Arduino donde estarn conectados
a los pines de entrada de nuestro puente-H, de esta manera
podremos controlar ambos motoreductores.
const int enPin = 5; // PWM se conecta al pin 1 del puente-H
const int in1Pin = 2; // Entrada 2 del puente-H
la funcin de transferencia en lazo abierto estara definida const int in2Pin = 4; // Entrada 7 del puente-H
//Y el sensor ultrasnico.
Ultrasonic ultrasonico(7,8);
Fuzzy* fuzzy = new Fuzzy(); //Iniciando objeto
//Creamos los conjuntos difusos.
FuzzySet* demcerca = new FuzzySet(-20, -10, 5, 9);
//Conjunto difuso Distancia demasiado cerca
FuzzySet* muycerca = new FuzzySet(14.5, 15, 15.5, 16);
//Conjunto difuso Distancia muy cerca
FuzzySet* cerca = new FuzzySet(15.5, 20, 40, 50);
//Conjunto difuso Distancia cerca
FuzzySet* media = new FuzzySet(45, 50, 70, 80);
//Conjunto difuso Distancia promedio
FuzzySet* lejos = new FuzzySet(75, 80, 103, 103);
//Conjunto difuso Distancia lejos
FuzzySet* Alto = new FuzzySet(0, 0, 0, 0); //
Velocidad para detener
FuzzySet* Suave = new FuzzySet(0, 200, 500, 700); //
Velocidad suave
FuzzySet* Media = new FuzzySet(600, 1200, 1800, 2000);
// Velocidad medio
FuzzySet* Rapida = new FuzzySet(1900, 2200, 3000, 3500);
// Velocidad rpido
int dist;
El anlisis de estabilidad absoluta nos indica que hay un int RPM=0;
polo en
//Despus de haber creado los conjuntos difusos, dentro del
void setup() crearemos las entradas y las salidas de nuestros
Como se puede observar, el control lo efecta una ganancia conjuntos DISTANCIA y VELOCIDAD.
que multiplica internamente a la cantidad obtenida del sensor void setup(){
y convertida a nmero por el registro de 8 bits del ADC. [Link](9600);
pinMode(in1Pin, OUTPUT); //Configura in1Pin como
De acuerdo con el manual del sensor, el tiempo medido salida
entre el pulso de salida y el eco debe dividirse entre 58 para pinMode(in2Pin, OUTPUT); //Configura in2Pin como
obtener la distancia en cm, dicha cantidad es nuestra salida
constante Kz, el control de efectuar a travs de esta.
//Crear composicin de entrada difusa distancia
FuzzyInput* distance = new FuzzyInput(1);
distance->addFuzzySet(demcerca); //Agrega fuzzyset
III. ELABORACIN DE FIRMWARE demasiado cerca a distancia
distance->addFuzzySet(muycerca); //Agrega fuzzyset muy
cerca a distancia
distance->addFuzzySet(cerca); //Agrega fuzzyset cerca a
A continuacin se describe el cdigo con conjuntos difusos
distancia
dentro de la placa de arduino.
distance->addFuzzySet(media); //Agrega fuzzyset media a
distancia
#include <FuzzyRule.h>
distance->addFuzzySet(lejos); //Agrega fuzzyset lejos a
#include <FuzzyComposition.h>
distancia
#include <Fuzzy.h>
fuzzy->addFuzzyInput(distance); //Agrega entrada difusa al
#include <FuzzyRuleConsequent.h>
objeto difuso
#include <FuzzyOutput.h>
#include <FuzzyInput.h>
//Crear composicin de entrada difusa vel
#include <FuzzyIO.h>
FuzzyInput* vel = new FuzzyInput(2);
#include <FuzzySet.h>
vel->addFuzzySet(Alto); // Agregar fuzzyset paro
#include <FuzzyRuleAntecedent.h>
vel->addFuzzySet(Suave);// Agregar fuzzyset lento
vel->addFuzzySet(Media);// Agregar fuzzyset medio
#include "Ultrasonic.h"
vel->addFuzzySet(Rapida);//Agregar fuzzyset rapido
3
fuzzy->addFuzzyInput(vel);// Agrega entrada difusa al
objeto difuso void loop()
//Crear composicin de salida difusa velocidad {
FuzzyOutput* salPWM = new FuzzyOutput(1); //Crea
salida difusa velocidad float dist = [Link](CM);
FuzzySet* rev = new FuzzySet(-4, -4, -3, 0); int rpm = getRPM();
salPWM->addFuzzySet(rev);// Agregar fuzzyset paro a [Link](rpm, DEC);
velocidad fuzzy->setInput(1, dist); //Agrega variable de entrada dist al
FuzzySet* paro = new FuzzySet(-.5, 1, 1.5, 4); objeto difuso
salPWM->addFuzzySet(paro);// Agregar fuzzyset paro a fuzzy->setInput(2, rpm); //Agrega variable de entrada dist al
velocidad objeto difuso
FuzzySet* lenta = new FuzzySet(3.9, 5, 5.5, 6);
salPWM->addFuzzySet(lenta);// Agregar fuzzyset lento a //Asignamos las variables flotantes.
velocidad float a;
FuzzySet* medio = new FuzzySet(5.5, 6, 7, 8); float b;
salPWM->addFuzzySet(medio);// Agregar fuzzyset medio float c;
a velocidad float d;
FuzzySet* rapido = new FuzzySet(7.5, 9, 9, 9); a= muycerca->getPertinence();
salPWM->addFuzzySet(rapido);//Agregar fuzzyset rapido a b= cerca->getPertinence();
velocidad c= media->getPertinence();
fuzzy->addFuzzyOutput(salPWM);// Agrega entrada difusa d= lejos->getpertinence();
al objeto difuso fuzzy->fuzzify(); // Fuzificacin
//Una vez realizada la fuzzificacin evaluamos las reglas //Finalmente escribimos los [Link](); necesarios para
difusas. poder mostrar los resultados en nuestro Monitor Serial.
// Arma las reglas difusas. (Distancia) [Link]("Distancia: ");
// FuzzyRule 1 "IF distancia = muy cerca THEN salPWM = [Link](dist);
Paro" [Link](" cm");
FuzzyRuleAntecedent* ifdistancemuycerca = new [Link]("Pertenencia a demasiado cerca (reversa): ");
FuzzyRuleAntecedent(); // Inicializando antecedente de la [Link](demcerca->getPertinence()); //Imprime
expresin pertencia a conjunto demasiado cerca
ifdistancemuycerca->joinSingle(muycerca); // Agregando [Link]("Pertenencia a ideal: ");
FuzzySet correspondiente al antecedente [Link](muycerca->getPertinence()); //Imprime
FuzzyRuleConsequent* thensalPWMparo = new pertencia a conjunto muy cerca
FuzzyRuleConsequent(); // Inicializando consecuencia de la [Link]("Pertenencia a cerca: ");
expresin [Link](cerca->getPertinence()); //Imprime pertencia
thensalPWMparo->addOutput(paro); // Agregando a conjunto cerca
FuzzySet correspondiente a la consecuencia [Link]("Pertenencia a media: ");
// Instantiating a FuzzyRule object [Link](media->getPertinence()); //Imprime pertencia
FuzzyRule* fuzzyRule01 = new FuzzyRule(1, a conjunto media
ifdistancemuycerca, thensalPWMparo); [Link]("Pertenencia a lejos: ");
fuzzy->addFuzzyRule(fuzzyRule01); // Agrega regla difusa [Link](lejos->getPertinence()); //Imprime pertencia a
al objeto difuso. conjunto lejos
// FuzzyRule "IF distance = cerca THEN salPWM = lenta" [Link]("RPM: ");
FuzzyRuleAntecedent* ifdistancecerca = new [Link](rpm);
FuzzyRuleAntecedent(); // Inicializando antecedente de la [Link]("Pertenencia a Alto: ");
expresin [Link](Alto->getPertinence());
ifdistancecerca->joinSingle(cerca); // Agregando FuzzySet [Link]("Pertenencia a Lenta: ");
correspondiente al antecedente [Link](Suave->getPertinence());
FuzzyRuleConsequent* thensalPWMlenta = new [Link]("Pertenencia a Media: ");
FuzzyRuleConsequent(); // Inicializando consecuencia de la [Link](Media->getPertinence());
expresin [Link]("Pertenencia a Rapida: ");
thensalPWMlenta->addOutput(lenta);// Agregando [Link](Rapida->getPertinence());
FuzzySet correspondiente a la consecuencia
// Instantiating a FuzzyRule object [Link]("Salida: ");
FuzzyRule* fuzzyRule02 = new FuzzyRule(2, [Link](output1);
ifdistancecerca, thensalPWMlenta); [Link]("");
fuzzy->addFuzzyRule(fuzzyRule02); // Agrega regla difusa int ch = output1;
al objeto difuso. int speed = map(ch, 0, 9, 0, 255);
//de la misma manera creamos las reglas difusas para la if ((ch <= 0))
distancia media, distancia cerca y demasiado cerca. {
} digitalWrite(in1Pin,LOW);
//Programacin del Sensor Ultrasnico SFR05 digitalWrite(in2Pin,HIGH);
4
[Link](speed);
analogWrite(enPin, speed); }
else if ((ch >= 0))
{
digitalWrite(in1Pin,HIGH);
digitalWrite(in2Pin,LOW);
[Link](speed);
analogWrite(enPin, speed);
}
delay(200);
}
}
VI. CONCLUSIONES
Una vez creado el cdigo en C de la rutina que segua
condiciones de distancia para que el sensor ultrasnico actuara
y se determinara la funcin de los motores dependiendo si
fuese reversa, adelante o hacia los lados presentado en el corte
anterior .
Luego de observar pruebas y ejercicios en clase sobre lgica
difusa y creacin de conjuntos, definicin de entradas y
salidas, posteriormente reglas difusas en maplab, se quiso
ejecutar de igual manera conjuntos en lgica difusa pero esta
vez aplicado no a maplab si no en cdigo que pudiese
compilar en arduino.
El resultado no fue el esperado, desde que empez el proyecto
queramos ejecutar una rutina en lgica difusa, se cre los
universos difusos luego se definieron las condiciones de
entrada y salida de nuestro sistema para que generramos las
reglas las culas nos generaban necesidades que el sistema
mediante lneas de cdigo poda suplementar y obtener una
respuesta en tiempo real.
Por ltimo el cdigo no compilo en el software ardino y por
este motivo no pudimos realizar las pruebas de campo
necesarias para poder asegurar el buen funcionamiento de
nuestro modelo de carro con lgica difusa.
V. REFERENCIAS
[1] [Link] (sistemas de control en tiempo discreto).
[2] Open acces DR. Jose Guillermo Guarnizo.
[3] Aplicaciones de logica difusa (consejo superior de
investigaciones cientificas).
[4] [Link]/2014/12/logica-
[Link].
[5] [Link]/2012/09/arduinofuzzy-fuzzy-library-for-
[Link].
[6][Link]/f/Manual+Programacion+Arduin
[Link]
5
