miércoles, 23 de noviembre de 2016

Medidor de Frecuencia Respiratoria Máxima y Mínima


Buenos Días a todos. Se que me eh desaparecido horriblemente de mi Blog, eh de decir que a sido por fuerzas mayores que mas adelante les platicaré :) no es nada malo, todo lo contrario :D.
En fin, procederé a explicarles el siguiente proyecto.



Medidor de Frecuencia Respiratoria

Introducción

La frecuencia respiratoria suele medirse por medio de la observación, o bien en el caso de los cuidados intensivos, con máquinas de alta precisión pero que suelen ser de alto costo.
En este trabajo se sugiere elaborar un circuito que sea capaz de medir la frecuencia respiratoria a partir de la exhalación de aire caliente por medio de las fosas nasales. El principio es colocar un sensor de temperatura en alguna de las fosas nasales, el sensor debe ser capaz de detectar el cambio de temperatura entre cada inhalación y exhalación, así como detectar el tiempo en que tarda cada uno de ellos para así poder determinar la frecuencia respiratoria.


Uno de los sensores más comunes de temperatura es el LM35, el cual es el sensor sugerido para el desarrollo del medidor de frecuencia respiratoria.

Materiales

* Arduino Uno
* Sensor de temperatura LM35

Tabla de diferentes Frecuencias Respiratorias

El sensor de temperatura LM35 es un sensor de circuito integrado con una salida lineal proporcional a la escala Celsius. Tiene un alcance de -55°C a 150°C, y una exactitud aproximada de 0.25°C.

Especificaciones


-          * Rango de Medida: -55°C-150°C
-         *  Función de TRANSFERENCIA: 10mV/°C
-         *  Rango de trabajo: -55°C a 150°C
-         * Voltaje de alimentación: 4-30VDC
-          * Consumo de corriente: 60 uA
-          * Auto calentamiento:  menor a 0.08 en espacios sin flujo de aire

-          * Resolución: ±1/4°C

Sensor LM35

Desarrollo

El sensor que se utiliza en el presente proyecto es el LM35DZ, es seleccionado debido a que el encapsulado es el adecuado para colocarlo cerca de una fosa nasal.

Como el LM35DZ en sí tiene una tensión de salida muy baja (en el orden de los mV) es necesario emplear una etapa de amplificación, esto para poder observar con mejor claridad los cambios de voltaje y poder emplearlo como un sensor de exhalaciones.
Para amplificar la tensión de salida del LM35DZ se propone utilizar amplificadores operacionales en configuración de amplificador de instrumentación, se selecciona debido a que con ella sólo se requiere cambiar el valor de una sola resistencia para regular la ganancia de tensión del circuito, entre sus características es que es capaz de aumentar la tensión de entrada hasta 100 veces, además de que elimina ruidos que posiblemente causen problemas en el medidor de frecuencia respiratoria.

En la siguiente figura se muestra en esquemático de un amplificador de instrumentación con OPAMP’s.

Esquema Amplificador de Instrumentación

Esquema Final (etapa de amplificación y sensado de la frecuencia respiratoria)

Después de comprobar el funcionamiento de la amplificación mediante la simulación, reemplazamos la fuente de voltaje por el sensor LM35.

Con el multímetro se mide la tensión en R8 a temperatura ambiente, durante la tarde la medida es de 2.2V, mientras que, en las mañanas, dicho valor está aproximadamente en 2V.

Se coloca el LM35DZ en una fosa nasal y se procede a respirar para poder verificar algún cambio de tensión en R8. Independientemente de la temperatura ambiente, se observa que al respirar en el sensor la temperatura varía entre + 0.5 a + 0.9 V, por lo que se establece un umbral de tensión de 2.6 V.

Se retira la resistencia R8 para colocar un cable que irá a una entrada analógica del Arduino Uno® (al pin A0), una vez colocado, también hay que conectar una tierra del Arduino Uno® a la tierra común del circuito.


Código en Arduino 


//  Medidor de Frecuencia Máxima y Minima  //
// Rafael Bayareh y Adriana Manzanárez /

//int sensor= 0;    // Pin analogico 0
#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

int medidor = 0;
int bandera = 0;
int umbral =  620;
int contador = 0;
double frecuencia = 0;

void setup(){
  lcd.begin(16, 2);        // 16 columnas y 2 filas
  lcd.setCursor(2,0);
  lcd.print("ELECTRONICA");  //Imprimir mensaje
  lcd.setCursor(4,1);
  lcd.print("DIGITAL");  //Imprimir mensaje
  delay(2000);
  lcd.clear();
  lcd.setCursor(3,0);
  lcd.print("BIENVENIDO ");
  delay(3000);
  lcd.clear();
  lcd.setCursor(3,0);
  lcd.print("Medidor De ");
  lcd.setCursor(2,1);
  lcd.print(" Frecuencia ");
  delay(3000);
  lcd.clear();
  Serial.begin(9600);
}


void loop(){

  for(int ciclos= 0; ciclos <100; ciclos++){
    medidor = analogRead(A1);
    // Conteo
    if (medidor > umbral)
    {
      bandera =1;
    }
    if (medidor < umbral && bandera ==1)
    {
      contador = contador+1;
      bandera=0;
    }
    // Tiempo de espera
   // delay (50);
    delay (100);
  }


  frecuencia = contador*6;
 Serial.println(medidor);
  Serial.print("F");
  Serial.print("R");
  Serial.print("E");
  Serial.print("Q");
  Serial.print("/");
  Serial.print("M");
  Serial.print("I");
  Serial.print("N");
  Serial.print(":");
  Serial.println(frecuencia);
   if (frecuencia >= 12 && frecuencia <= 20)
    {
      //Serial.println("Rango Normal");
      lcd.setCursor(0,1);
      lcd.clear();
      lcd.print("Fre_Normal 12-20");
      lcd.setCursor(1,6);
      lcd.print(frecuencia);
    }
   if (frecuencia < 12)
    {
      // Serial.println("Rango Bajo");
       lcd.setCursor(0,1);
       lcd.clear();
       lcd.print("Freq_Baja <12");
       lcd.setCursor(1,6);
       lcd.print(frecuencia);
    }
     if (frecuencia > 20)
    {
      // Serial.println("Rango Alto");
        lcd.setCursor(0,1);
      lcd.clear();
      lcd.print("Freq_Maxima >20");
      lcd.setCursor(1,6);
      lcd.print(frecuencia);
    }

 // Serial.print("La Frecuancia Respiratoria es: ");
  //Serial.println(frecuencia);
  contador =0;
}
 

Frecuancia Normal



Espero les sea de utilidad esta entrada, saben que son libres de escribir y opinar en este Blog :D


Gracias por leerme :)
Que tengan lindo día.


"La educación es el principal vestido para la fiesta de la vida"

- Carolina Herrera

viernes, 30 de octubre de 2015

Ball and Beam

Hola muy Buenos días  :)

Aquí me tienen nuevamente con otra entrada muy interesante, para la implementación del proyecto, utilizamos la tarjeta de Arduino Uno. 

Espero que sea de su interés y claro lo mas importante, que les sea de gran utilidad para la realización de algún trabajo similar :) 

Ball and Beam

El sistema de ball and beam (bola y viga) es uno de los sistemas mas importantes para el estudio de los sistemas de control. Muchos métodos de control clásico y moderno se han utilizado para estabilizar el sistema de ball and beam. 

Una bola se coloca sobre una viga (figura siguiente), donde se le permite rodar con 1 grado de libertad a lo largo de la longitud de la viga. Un brazo de palanca esta unido a la viga en un extremo y del otro extremo un servomotor. A medida que el servomotor gira en un ángulo $\theta$, la palanca cambia el ángulo de la viga por un ángulo  $\alpha$.
Cuando el ángulo se cambia desde la posición horizontal, la gravedad hace que la bola ruede a largo de la viga.

Sistema Ball and Beam

Material


Arduino Uno
Servomotor


* Un balin (tamaño pequeño)

* Una viga (yo adapte dos reglas pequeñas pegandolas de los costados con forma de V)



Una vez explicado como funciona el sistema ball and beam, procedo a mostrarles el código implementado en Arduino.

Código Arduino


//Programa Ball and Beam
//Adriana Manzanárez 

///////////////////////////////
  #include <Servo.h>
  Servo myservo;                      // Creamos el objeto servo.
  const int numReadings = 15;
  int readings[numReadings];
  int index = 0;
  int total = 0;
  int input = 0;
  int angle = 0;                           //Variable del servomotor.
  int kp= 10;//2.4                       //Ganancia Proporcional
  float ki = 3.3;//1.7 - 2.4            //Ganancia Integral
  float kd = 17;  //3.3 -2.6          //Ganancia Derivativa
  float Pterm = 0; 
  float Iterm = 0; 
  float Dterm = 0; 
  int t = 10;
  int error = 0;
  int setpoint = 0;
  float val_1 = 0;
  float val_2 = 0;
  float delta = 0;
  float aceleracion = 0;
  
  int inputPin = 0;                        // Declaramos la entrada analogica
  
    void setup(){
      //Serial.begin(9600);
         for (int thisReading = 0; thisReading < numReadings; thisReading++ )
         readings[thisReading] = 0;
         myservo.attach(9);
   }
    void loop(){
   val_1 = analogRead(inputPin); //Lee el valor del pin analogico
   val_1 = map(val_1,77, 810, -366, 3669)   ; // 0, 1023, 0, 17//77, 810, -366, 366
   delay(t);
   val_2 = analogRead(inputPin); //Lee el valor del pin analogico
   val_2 = map(val_2,77, 810, -366, 366)   ;   
   delta = delta + val_2 - val_1;       //Se calclula la posición de delta.
   aceleracion = delta/t;       //Se calcula la aceleración del balin 
  
   total = total - readings[index];              // Sustrae la última posición
   readings[index] = analogRead(inputPin);       // Es leido desde el sensor
   total = total + readings[index];              //Agrega la siguiente posición.
   index = index + 1;                            //Establece la siguiente posición.
   if (index <= numReadings)
   index = 0;
   input = total/numReadings;                          //Calcula el promedio
   
   input = map(input, 77, 810, -366, 366);        //Se crea una regresión lineal. 
   error = input - setpoint;                               // Calculamos el error.
   
   Pterm = error * input;                      //Calculamos el valor proporcional
   Iterm = input;                                  //Calculamos el valor integral.
   Dterm = aceleracion;                       // Calculamos el valor derivativo.
   
  angle = (kp*Pterm) + (ki*Iterm) + (kd*Dterm); //Multiplicamos el controlador PID con las   ganancias del PID
   angle = map(angle, -366, 366, 100, 125);
   
   Serial.print ("Pocisión del Balin = ");
   Serial.print (input,DEC);
   Serial.print ("Ángulo del Servomotor = ");
   Serial.print (angle,DEC);
   Serial.print ("Error = ");
   Serial.print (error,DEC);
   
   myservo.write(angle);
   delay(t);
  }


Dejen comentarios si tienen alguna duda o sugerencias :)  Muchas gracias por leerme!!! <3
Que tengan un gran día
   .
-La única diferencia entre un buen y mal día es tu actitud.-Dennis S. Brown.



domingo, 25 de octubre de 2015

Convertidor de Código Binario a Gray en VHDL

Hola nuevamente! :) eh estado un poco desaparecida por estos lares, el día de hoy les dejo un programa de un Convertidor de Código Binario a Gray que realice en VHDL. 
Espero que sea de gran utilidad para ustedes, es un código muy sencillo y fácil de entender ;) cualquier duda o comentario es bienvenido. 

El código binario reflejado o código Gray, nombrado así en honor del investigador Frank Gray, es un sistema de numeración binario en el que dos valores sucesivos difieren solamente en uno de sus dígitos. El código Gray fue diseñado originalmente para prevenir señales ilegales (señales falsas o viciadas en la representación) de los switches electromecánicos, y actualmente es usado para facilitar la corrección de errores en los sistemas de comunicaciones, tales como algunos sistemas de televisión por cable y la televisión digital terrestre.
El Código Gray es un caso particular del sistema binario. Consiste en una ordenación de 2n números binarios de tal forma que cada número sólo tenga un dígito binario distinto a su predecesor. Esta técnica de codificación se originó cuando los circuitos lógicos digitales se realizaban con válvulas de vacío y dispositivos electromecánicos. Los contadores necesitaban potencias muy elevadas a la entrada y generaban picos de ruido cuando varios bits cambiaban simultáneamente. El uso de código Gray garantizó que en cualquier transición variaría tan sólo un bit. En la actualidad, el código Gray se sigue empleando para el diseño de cualquier circuito electrónico combinatorio, ya que el principio de diseño de buscar transiciones más simples y rápidas entre estados sigue vigente, a pesar de que los problemas de ruido y potencia se hayan reducido.
Es posible realizar esta conversión mediante una operación lógica XOR entre el número binario a convertir y el mismo número con un desplazamiento lógico a la derecha.

Objetivo

Realizar la descripción en VHDL del convertidor de código Binario a Gray mediante el algoritmo de conversión mencionado.

Tabla de Conversión

Código en VHDL

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity convertidor is
  Port (b : in bit_vector (7 downto 0);
           g : out bit_vector (7 downto 0));
end convertidor;
architecture Behavioral of convertidor is
begin
g <= b xor (b srl 1);
end Behavioral;


Código de Simulación 

LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
  
ENTITY sim IS
END sim;

ARCHITECTURE behavior OF sim IS
 -- Component Declaration for the Unit Under Test (UUT)
 COMPONENT convertidor
 PORT(  b : in bit_vector (7 downto 0);
       g : out  bit_vector (7 downto 0));
    END COMPONENT;
   
--Inputs
signal b :bit_vector(7 downto 0) := (others => '0');

--BiDirs
   signal g :  bit_vector (7 downto 0);
   -- No clocks detected in port list. Replace <clock> below with
   -- appropriate port name

BEGIN
 -- Instantiate the Unit Under Test (UUT)
   uut: convertidor

PORT MAP (
          b => b,
          g => g    );

  -- Stimulus process
   stim_proc: process
   begin         
      -- hold reset state for 100 ns.
     wait for 100 ns;    

--  wait for <clock>_period*10;

      -- insert stimulus here
                  
          b <= "00000000"; wait for 100 ns;
              b <= "00000001"; wait for 100 ns;
              b <= "00000010"; wait for 100 ns;
              b <= "00000011"; wait for 100 ns;
              b <= "00000100"; wait for 100 ns;
              b <= "00000101"; wait for 100 ns;               
              b <= "00000110"; wait for 100 ns;              
              b <= "00000111"; wait for 100 ns;               
              b <= "00001000"; wait for 100 ns;          
              b <= "00001001"; wait for 100 ns;         
              b <= "00001010"; wait for 100 ns;
              b <= "00001011"; wait for 100 ns;
              b <= "00001100"; wait for 100 ns;
              b <= "00001101"; wait for 100 ns;
              b <= "00001110"; wait for 100 ns;
              b <= "00001111"; wait for 100 ns;


           wait;
   end process; 
END;

Implementación del código en la tarjeta Spartan 3E

Con las siguientes imágenes se demuestra que el código funciona, podemos observar que el encendido de los leds corresponde al numero Gray correspondiente al Decimal. 

Implementación del convertidor para el número 3.

Convertidor binario a gray para el número 4.


En verdad espero que sea de gran utilidad este código, si necesitan ayuda pueden escribirme. Gracias por leerme y que tengan un gran día :).

Saludos a todos!!





viernes, 5 de diciembre de 2014

Lógica Difusa y Sensor Ultrasónico

Carro Controlado mediante Lógica Difusa

Hola chicos!!, Bienvenidos nuevamente a mi blog, el día de hoy les explicare como armar un carro controlado mediante la Lógica Difusa, cuya programación será en Arduino.

El control Fuzzy esta basado en la toma de decisiones, esto lo hace una tecnología accesible, ya que las reglas están mas cerca del sentido común que de algún modelo matemático o ecuaciones. 
Varios artefactos que usamos hoy en día, están basados en la lógica difusa, por ejemplo, nuestras lavadoras las programamos para que el agua que utilicemos para lavar nuestra ropa este a 37°C, si el agua que entra esta abajo de esta temperatura, automáticamente el calefactor se prenderá para poder llegar a esta temperatura, una vez alcanzado los 37°C el calefactor automáticamente 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 ultrasónico llegue a detectar un objeto a una distancia de 15cm., el auto se detenga; la distancia de paro puede ser variada modificando los conjuntos difusos.
Explicaré paso a paso como programar cada una de las etapas en Arduino.
lógica difusa
Carro controlado mediante lógica difusa 

Materiales

* Sensor ultrasónico SFR05
* Arduino UNO
* Carro con 3 llantas, la de frente es una rueda loca, y un par de llantas traseras con motoreductores


Procedimiento

Escribimos las librerías en Arduino que perteneces al Control Fuzzy y al sensor ultrasónico.
// ***      ADRIANA     ***  //
 // ***          CONTROL NEURODIFUSO         ***  //
 // *** CARRO CONTROLADO CON LOGICA DIFUSA   ***  //

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

 #include "Ultrasonic.h" 

Asignamos los pines del Arduino donde estarán 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
 const int in2Pin = 4; // Entrada 7 del puente-H

Y el sensor ultrasónico.
 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 rápido 
 int dist;

Después de haber creado los conjuntos difusos, dentro del void setup() crearemos las entradas y  las salidas de nuestros conjuntos DISTANCIA y VELOCIDAD.
  void setup(){
  Serial.begin(9600);
  pinMode(in1Pin, OUTPUT); //Configura in1Pin como salida
  pinMode(in2Pin, OUTPUT); //Configura in2Pin como salida

//Crear composición de entrada difusa distancia
  FuzzyInput* distance = new FuzzyInput(1);
  distance->addFuzzySet(demcerca); //Agrega fuzzyset demasiado cerca a distancia
  distance->addFuzzySet(muycerca); //Agrega fuzzyset muy cerca a distancia
  distance->addFuzzySet(cerca);    //Agrega fuzzyset cerca a distancia
  distance->addFuzzySet(media);    //Agrega fuzzyset media a distancia
  distance->addFuzzySet(lejos);    //Agrega fuzzyset lejos a distancia
  fuzzy->addFuzzyInput(distance);  //Agrega entrada difusa al objeto difuso
 
  //Crear composición de entrada difusa vel
  FuzzyInput* vel = new FuzzyInput(2);
  vel->addFuzzySet(Alto); // Agregar fuzzyset paro
  vel->addFuzzySet(Suave);// Agregar fuzzyset lento
  vel->addFuzzySet(Media);// Agregar fuzzyset medio
  vel->addFuzzySet(Rapida);//Agregar fuzzyset rapido
  fuzzy->addFuzzyInput(vel);// Agrega entrada difusa al objeto difuso

//Crear composición de salida difusa velocidad
  FuzzyOutput* salPWM = new FuzzyOutput(1);  //Crea salida difusa velocidad
  FuzzySet* rev = new FuzzySet(-4, -4, -3, 0);
  salPWM->addFuzzySet(rev);// Agregar fuzzyset paro a velocidad
  FuzzySet* paro = new FuzzySet(-.5, 1, 1.5, 4);
  salPWM->addFuzzySet(paro);// Agregar fuzzyset paro a velocidad
  FuzzySet* lenta = new FuzzySet(3.9, 5, 5.5, 6);
  salPWM->addFuzzySet(lenta);// Agregar fuzzyset lento a velocidad
  FuzzySet* medio = new FuzzySet(5.5, 6, 7, 8);
   salPWM->addFuzzySet(medio);// Agregar fuzzyset medio a velocidad
  FuzzySet* rapido = new FuzzySet(7.5, 9, 9, 9);
  salPWM->addFuzzySet(rapido);//Agregar fuzzyset rapido a velocidad
  fuzzy->addFuzzyOutput(salPWM);//  Agrega entrada difusa al objeto difuso

Una vez realizada la fuzzificación evaluamos las reglas difusas.
  // Arma las reglas difusas. (Distancia)
  // FuzzyRule 1 "IF distancia =  muy cerca THEN salPWM = Paro"
  FuzzyRuleAntecedent* ifdistancemuycerca = new FuzzyRuleAntecedent(); // Inicializando antecedente de la expresión
  ifdistancemuycerca->joinSingle(muycerca); // Agregando FuzzySet correspondiente al antecedente
  FuzzyRuleConsequent* thensalPWMparo = new FuzzyRuleConsequent(); // Inicializando consecuencia de la expresión
  thensalPWMparo->addOutput(paro); // Agregando FuzzySet correspondiente a la consecuencia
  // Instantiating a FuzzyRule object
  FuzzyRule* fuzzyRule01 = new FuzzyRule(1, ifdistancemuycerca, thensalPWMparo);  
  fuzzy->addFuzzyRule(fuzzyRule01); // Agrega regla difusa al objeto difuso.

// FuzzyRule "IF distance = cerca THEN salPWM = lenta"
  FuzzyRuleAntecedent* ifdistancecerca = new FuzzyRuleAntecedent(); // Inicializando antecedente de la expresión
  ifdistancecerca->joinSingle(cerca); // Agregando FuzzySet correspondiente al antecedente
  FuzzyRuleConsequent* thensalPWMlenta = new FuzzyRuleConsequent(); // Inicializando consecuencia de la expresión
  thensalPWMlenta->addOutput(lenta);// Agregando FuzzySet correspondiente a la consecuencia
  // Instantiating a FuzzyRule object
  FuzzyRule* fuzzyRule02 = new FuzzyRule(2, ifdistancecerca, thensalPWMlenta);  
  fuzzy->addFuzzyRule(fuzzyRule02); // Agrega regla difusa al objeto difuso.

de la misma manera creamos las reglas difusas para la distancia media, distancia cerca y demasiado cerca.

Programación del Sensor Ultrasónico SFR05
 void loop(){
  float dist = ultrasonico.Ranging(CM);
  int rpm=getRPM();
  Serial.println(rpm, DEC);
  fuzzy->setInput(1, dist); //Agrega variable de entrada dist al objeto difuso
  fuzzy->setInput(2, rpm); //Agrega variable de entrada dist al objeto difuso

Asignamos las variables flotantes.
  float a;
  float b;
  float c;
  float d; 
 a= muycerca->getPertinence();
 b= cerca->getPertinence();
 c= media->getPertinence();
 d= lejos->getPertinence();
 fuzzy->fuzzify(); // Fuzificación

Finalmente escribimos los Serial.print(); necesarios para poder mostrar los resultados en nuestro Monitor Serial.
Serial.print("Distancia: "); 
  Serial.print(dist);  
  Serial.println(" cm");
  Serial.print("Pertenencia a demasiado cerca (reversa):  ");
  Serial.println(demcerca->getPertinence()); //Imprime pertencia a conjunto demasiado cerca
  Serial.print("Pertenencia a ideal:  ");
  Serial.println(muycerca->getPertinence()); //Imprime pertencia a conjunto muy cerca
  Serial.print("Pertenencia a cerca:  ");
  Serial.println(cerca->getPertinence());  //Imprime pertencia a conjunto cerca
  Serial.print("Pertenencia a media: ");
  Serial.println(media->getPertinence());  //Imprime pertencia a conjunto media
  Serial.print("Pertenencia a lejos: ");
  Serial.println(lejos->getPertinence());  //Imprime pertencia a conjunto lejos

Serial.print("RPM: ");   
  Serial.println(rpm);  
  Serial.print("Pertenencia a Alto:  ");
  Serial.println(Alto->getPertinence());
  Serial.print("Pertenencia a Lenta:  ");
  Serial.println(Suave->getPertinence());
  Serial.print("Pertenencia a Media: ");
  Serial.println(Media->getPertinence());
  Serial.print("Pertenencia a Rapida: ");
  Serial.println(Rapida->getPertinence());

Serial.print("Salida: ");
  Serial.println(output1);
  Serial.println("");
  int ch = output1;
  int speed = map(ch, 0, 9, 0, 255);   

  if ((ch <= 0))
  {
   digitalWrite(in1Pin,LOW);
  digitalWrite(in2Pin,HIGH);
  Serial.println(speed);
  analogWrite(enPin, speed); }

  else if ((ch >= 0))
 {
  digitalWrite(in1Pin,HIGH);
  digitalWrite(in2Pin,LOW);
  Serial.println(speed);
  analogWrite(enPin, speed);
 }
 delay(200);
 }

Para que nuestro auto tenga un sentido de giro con forme a las manecillas del reloj y anti horario, caracterizamos la salida mapeando con valores de 0 a 9, los cuales hacen referencia el rango que va de 0 a 255 bits del PWM, donde el 9 es el valor más rápido y cero el mínimo valor.


Como pueden ver, el sistema de control del carro está basado en la evaluación de reglas, utilizando lógica difusa, su implementación es muy sencilla, ya que describimos su comportamiento mediante reglas, no es necesario realizar una modelización exacta, sino que basta con entender conceptualmente su comportamiento. Está característica lo hace particularmente apropiado para sistemas muy alineales, cuya modelización por los métodos tradicionales suele ser compleja. Diseñar sistemas borrosos es fácil, ya que reflejan de una manera general lo que la gente realmente piensa de un problema.


Gracias por leerme :)
Que tengan lindo día.