TODOPIC

Microcontroladores PIC => Lenguaje C para microcontroladores PIC => Mensaje iniciado por: jmkonty en 24 de Mayo de 2009, 21:16:25

Título: Pasar lógica difusa a lenguaje C
Publicado por: jmkonty en 24 de Mayo de 2009, 21:16:25

Buenas

Perdonad por mis meteduras de pata pero soy novato en esto y necesito ayuda.

Estoy haciendo como proyecto fin de carrera un balancing robot, con un PIC18f252. El controlador que debo utilizar usa lógica difusa y aquí viene mi problema. En las simulaciones con Matlab utilizo el Fuzzy toolbox y el controlador funciona perfectamente pero para meterlo en el PIC debo traducirlo al lenguaje C. Sé que debo hacerlo mediante una tabla que me implemente mis entradas y salidas y que lo tengo que hacer mediante if y switch pero no me queda claro del todo cómo hacerlo pues no sé tampoco cómo generar todos los posibles valores de entrada y salida que tiene mi controlador. He pensado meterle más memoria al PIC mediante una EEPROM externa por si la tabla se extendiera más allá de la memoria que tiene.

Si alguno que haya hecho algo por estilo me puede echar una mano sería de gran ayuda.

Un saludo.

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: MLO__ en 24 de Mayo de 2009, 21:28:14

Hola.

El ToolBox de Matlab tambien trae una herramienta para generar el C correspondiente para el Fuzzy. Otro programa es el FuzzyTech ...

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: jmkonty en 25 de Mayo de 2009, 16:30:20

Gracias por la respuesta.

He estado mirando el help del toolbox logic fuzzy de matlab pero no me queda muy claro como crear el codigo en C. Si me pudieses echar una mano te lo agradecería mucho.

Un saludo

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: MLO__ en 25 de Mayo de 2009, 22:11:33

Voy a buscar la info ... eso lo hice hace años ya ... en la U, y esa info esta refundida por algun lado ....

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: migsantiago en 26 de Mayo de 2009, 13:56:07

El comando que yo he visto para compilar programas en EXE o generar el código en C o C++ es mcc. Busca en la ayuda de matlab cómo llamarlo escribiendo >>help mcc.

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: jmkonty en 26 de Mayo de 2009, 16:45:20

El comando mcc sirve para pasar archivos *.m de Matlab a archivos *.c propios del lenguaje C, pero en el caso de logica fuzzy que el archivo es *.fis no me sirve. Gracias por la respuesta de todos modos.

MLO_ si encuentras la información de como hacerlo me serás de gran ayuda.

Muchas gracias a todos.

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: migsantiago en 26 de Mayo de 2009, 17:16:42

OK. ¿No podrías incluir el llamado de la librería fuzzy (fis) en un m y después compilar el m?

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: jmkonty en 26 de Mayo de 2009, 19:03:16

De esa forma que dices creo que lo que haría sería traducir el archivo *.fis pero en su formato de texto a lenguaje C y creo que eso no me serviría luego para implementarlo en un PIC. Lo mismo me equivoco pero creo que con eso no conseguiría lo necesario para meterlo luego como controlador en un PIC.

Muchas gracias

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: MLO__ en 26 de Mayo de 2009, 22:57:26

Hola.

Que recuerde, el fuzzy se lo trabaja en otro entorno diferente. Hay un proceso especial para pasar al .c, dejame y lo busco si? seria bueno recordar viejos conceptos

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: jmkonty en 01 de Junio de 2009, 16:30:20

Muchas gracias por tu interés. Has encontrado algo de lo que me puede interesar o que me puede venir bien?

Gracias de nuevo

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: MLO__ en 01 de Junio de 2009, 23:32:18

Hola.

Solo encontre este pdf de una expo que hice ......

Presentacion Real Time Work Shop (http://www.4shared.com/file/109291246/20e9e1c0/presentacion.html)

Espero te sirva.

Saludos

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: D@niel`s en 17 de Junio de 2009, 13:11:44

Saludos a todos.

Soy nuevo en el foro... y me interesó bastante el tema ya que estoy en una situación similar a la de jmkonty.

Bien, si se hace la lógica difusa en matlab se necesita crear una tabla de datos que relacione las entradas y la salida o look up table, que es la que se inserta en el micro.
Para hacer esto, se necesita crear un pequeño programa en el mismo matlab que vaya evaluando cada entrada para ver el resultado de salida. El comando que se utiliza para evaluar el archivo *.fis es el evalfis() y debe ser guardado en una matriz donde se muestren los valores evaluados de entradas con su correspondiente salida.

yo pude lograr todo eso, pero la tabla no la puedo declarar en el micro y no se cual es la razón!!! estoy trabajando con un pic 16f877 y estoy programando en C. si alguien me puede ayudar a resolver este inconveniente se lo agradecería muchísimo.

si necesitan ayuda para la lógica difusa escríbanme al correo: dajeroab83@hotmail.com

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: sebastianfpr en 29 de Julio de 2009, 21:51:20

Hola a todos, pues les comento primero que todo que soy nuevo en el foro y es la primera vez que hago un comentario por aquí.

a que no adivinan?

Yo con mi propias manos e ingenio realice lo siguiente:

 - Convierto Un Sistema Lógico Difuso tipo Mamdani creado mediante el Toolbox de Fuzzy Logic de Matlab a Lenguaje C para ser llevado al microcontrolador PIC18F452. (Uso el MC18).

 - Es un programa que hice en Matlab con Interfaz Grafica que toma el sistema logico difuso tipo mamdani .fis y lo pasa a C para el PIC18F452.

Espero seguirles hablando del tema si les interesa.

Una pregunta. Cómo pongo una imgamen para que aparezca visualizada? Gracias.

Cordial Saludo desde Colombia.
Sebastián

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: MLO__ en 29 de Julio de 2009, 22:02:03

Hola.

Cuelga la imagen en imageshak y luego pegas el link que te dan ahi entre [ img ] e [ /img ]

Esta muy interesante lo que comentas y puedes hablar y postear tooodo lo que gustes, aca es muy bien recibida tu informacion, ademas, le servira a alguien mas.

Saludos

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: sebastianfpr en 30 de Julio de 2009, 16:48:15

Bueno por aquí de nuevo.

Bueno ese proyecto que les comento fue mi Proyecto de Pregrado que realice para ser Ingeniero Electrónico.

El proyecto es de la siguiente Manera:

A este Sistema lo llame FuzzyPic 1.0

(Bueno espero sepan respetar los derechos de autor ya que estamos entre caballeros)

Involucra dos subsistemas o partes, las cuales, poseen las siguientes especificaciones generales.

Especificaciones Del Sistema Lógico Difuso Tipo Mamdani General

Como parte fundamental del Módulo se desarrollo el código en C para un Sistema Lógico Difuso tipo Mamdani en forma general. Algunas partes del código son modificadas por medio del software del Módulo de acuerdo a las características fijadas por el usuario. Las partes que se modifican son las siguientes:

   Definición de los conjuntos difusos. Esta parte se modifica de acuerdo al número de conjuntos difusos, al tipo de cada uno de los conjuntos y a sus respectivos parámetros.

   Obtención de las entradas. De acuerdo al tipo de entradas; análogas o digitales, el código será modificado para la debida lectura de cada una de las entradas del Sistema.

   Base de Reglas. De acuerdo a las reglas difusas establecidas durante el diseño del Sistema Lógico Difuso por el usuario, se creará la base de reglas específica siguiendo la forma general establecida en la creación del código general o estándar para el Sistema Lógico Difuso (SLD).

   Ajustes específicos. Las partes del código que dependen del número de entradas, los respectivos conjuntos y el número de reglas, el código será ajustado de acuerdo a estas características.

El código general del SLD puede manejar las siguientes características: (Bueno Aclaro que esto lo fije de acuerdo al PIC18F452 viendo sus prestaciones y limitaciones)

   Tipos de conjuntos difusos: triangular, trapezoidal y gaussiano.
   Número de entradas: Se pueden tener como máximo 3 entradas.
   Tipo de SLD: Tipo Mamdani.
   Tipo de Sistemas: Sistemas tipo MISO (Múltiples entradas y única salida).
   Conector Antecedentes de las reglas: conector AND.
   Evaluación Antecedentes: Operador MÍNIMO.
   Método Implicación: Operador MÍNIMO.
   Método Agregación: Operador MÁXIMO.
   Método Desdifusión: CENTROIDE.

Especificaciones Del Software Del Modulo

El software para el Módulo denominado FuzzyPic 1.0 es el encargado de recibir todas las características específicas; definición de las variables de entrada y la variable de salida, definición de los conjuntos difusos que conforman cada variable, reglas difusas o base de conocimiento, tipos de conjuntos difusos a usar entre otras, requeridas por el usuario para el diseño del Sistema Lógico Difuso (SLD) deseado.

El diseño del SLD se realiza mediante la integración de las diferentes funciones que ofrece el Fuzzy Logic Toolbox de Matlab. Después de especificar el SLD deseado, el software procede a verificar todas las características vistas en la sección anterior para proceder a crear el código en C del SLD. En la figura 3.1 pude verse el diagrama en bloques del software desarrollado en Matlab para el Módulo.

(http://img197.imageshack.us/img197/9210/img20f.jpg)

Diagrama en Bloques general del software para el Módulo.

Requerimientos de Sistema

Debido a que el software se desarrollo en Matlab, los requerimientos de sistema necesarios, son los mismos que los de este lenguaje. Necesita por supuesto, que Matlab esté instalado en la PC.

Título: Pasar lógica difusa a lenguaje C
Publicado por: udolpho en 26 de Noviembre de 2009, 09:40:59

hermano ¿puedes compartir tu programa con el resto de los mortales?, jejeje. Gracias

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: sebastianfpr en 12 de Febrero de 2010, 11:33:42

Dejame tu correo

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: udolpho en 13 de Febrero de 2010, 11:40:37

Oye te lo agradesco mucho, el correo es udoalejandro@gmail.com

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: Algec en 13 de Febrero de 2010, 11:53:56

Tambien estoy muy interesado, si puedes el correo de aqui serviria
Mil gracias

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: sebastianfpr en 18 de Febrero de 2010, 15:33:25

Bueno, Hola a todos

Que pena por tener tan abandonado este foro, pero por cuestiones de mi Maestría no he tenido mucho tiempo de sentarme aquí y seguir compartiendo con todos ustedes.

Bueno ante la solicitud de algunos participantes del foro de que les envié el programa, tome la siguiente decisión:

Voy a poner acá en el foro, como pueden hacer un Sistema Lógico Difuso tipo Mamdani en C, especialmente para el PIC18F452, pero igual haciendo algunas modificaciones pues podrá ser valido para cualquier PIC 18F. no pondre el programa total que realize (FuzzyPic 1.0) por el momento, cuestiones de derecho de autor, pero si les pondre un ejemplo de un Sistema Lógico Difuso hecho en C y lo iré explicando paso a paso.

El siguiente programa en C, lo generó la herramienta que diseñe (FuzzyPic 1.0) de acuerdo a un SLD configurado con el ToolBox de Logica Difusa de Matlab, mas adelante les explico en mas detalle, por ahora se los pongo para que lo miren bien y tengan una idea general de la manera como esta hecho el Sistema Lógico Difuso tipo Mamdani en C y me comenten.

Como buenos colegas, caballeros y personas de bien que somos, y como estudiante de Maestría y amante de la Ciencia, les digo que saber reconocer el trabajo de los demás es cuestión de ética y honradez, así que si a alguien le sirve lo mencionado acá, sepan referenciar y respetar los derechos de autor. Muchas gracias.

El siguiente Sistema Lógico Difuso es un Control de Temperatura para una Incubadora, mas adelante les visualizo bien los conjuntos difusos, las reglas, etc.

/********************************************************************************
*   FUZZY PIC 1.0 - SISTEMA LOGICO DIFUSO TIPO MAMDANI PARA EL PIC18F452        *
*   Entradas: 2 Salidas: 1                                          *
*********************************************************************************
*   Autor: Sebastian F. Puente Reyes                      *
*   Trabajo De Grado: Modulo de desarrollo para la implementacion en   *
*                     microcontrolador,de Sistemas Logicos Difusos tipo Mamdani   *
*   Universidad de los Llanos. Mayo de 2007, Villavicencio - Colombia                  *
********************************************************************************/

//-------------------------------------------------------------------------------
#include <p18f452.h>
#include <adc.h>
#include <math.h>
#include <delays.h>

//-------------------------------------------------------------------------------
#pragma config OSC = HSPLL, OSCS = OFF
#pragma config WDT = OFF
#pragma config PWRT = ON
#pragma config LVP = OFF

//-------------------------------------------------------------------------------
int in1,in2;
float norma1,norma2;
char tipo_conjunto;
unsigned char n;
unsigned char f;
unsigned char limite;
unsigned char muestras = 80;
const float paso = 0.0125;
float maxana = 1023;
float maxdig = 255;
float a,b,c,d;
float
grado,
area,
pond,
sal_regla,
soporte,
tempo,
crisp
;

//-------------------------------------------------------------------------------
#pragma udata bigdata
float salida[80];
#pragma udata

#pragma romdata segdata1
rom float conj11[] = {0.2017,0.138,0,0,3};
rom float conj12[] = {0.1062,0.5,0,0,3};
rom float conj13[] = {0.1168,0.863,0,0,3};
#pragma romdata

#pragma romdata segdata2
rom float conj21[] = {0.1344,0.092,0,0,3};
rom float conj22[] = {0.07088,0.333,0,0,3};
rom float conj23[] = {0.07219,0.5,0,0,3};
rom float conj24[] = {0.07054,0.667,0,0,3};
rom float conj25[] = {0.07797,0.908,0,0,3};
#pragma romdata

#pragma idata consal = 0x100
float sal1[] = {0,0,0.12667,0.5,2,0,0.5};
float sal2[] = {0.12667,0.5,0.87333,0,1,0.12667,0.87333};
float sal3[] = {0.5,0.87333,1,1,2,0.5,1};
#pragma idata

#pragma idata grado = 0x200
float per1[] = {0,0,0};
float per2[] = {0,0,0,0,0};
#pragma idata

//-------------------------------------------------------------------------------
void setup(void);
void salida_cero(void);
void conversor(void);
void fusificacion(void);
void reglas(void);
void inferencia(float uno, float dos, float *conjsal);
float desfusificacion(float *fp);
float evaluafp(float num, rom float *param, float *parametros);

//-------------------------------------------------------------------------------
void main(void)
{
   setup();
   while(1)
   {
      salida_cero();
      conversor();
      fusificacion();
      reglas();
      crisp = desfusificacion(salida);
      PORTD = crisp * 255;
   }
}

//-------------------------------------------------------------------------------
void setup(void)
{
   TRISD = 0;
}

//-------------------------------------------------------------------------------
float evaluafp(float num, rom float *param, float *parametros)
{
   if(param == 0)
   {
      a = parametros[0];
      b = parametros[1];
      c = parametros[2];
      d = parametros[3];
      tipo_conjunto = parametros[4];
   }
   else
   {
      a = param[0];
      b = param[1];
      c = param[2];
      d = param[3];
      tipo_conjunto = param[4];
   }

   switch(tipo_conjunto)
   {
      case 1:      if(num < a)
               { grado = 0; break; }
               if(num > c)
               { grado = 0; break; }
               if(num >= a && num <=b)
               { grado = (num - a) / (b - a); break; }
               if(num >= b && num <= c)
               { grado = (c - num) / (c - b); break; }
               break;

      case 2:      if(num < a)
               { grado = 0; break; }
               if(num > d)
               { grado = 0; break; }
               if(num >= b && num <=c)
               { grado = 1; break; }
               if(num >= a && num <= b)
               { grado = (num - a) / (b - a); break; }
               if(num >= c && num <= d)
               { grado = (d - num) / (d - c); break; }
               break;

      case 3:      grado = ((num - b) * (num - b)) / (2 * a * a);
               grado = exp(-grado);
               break;

      default:   grado = 0;
               break;
   }
   return(grado);
}

//-------------------------------------------------------------------------------
void fusificacion(void)
{
   norma1 = in1 / maxana;
   norma2 = in2 / maxana;

   per1[0] = evaluafp(norma1,conj11,0);
   per1[1] = evaluafp(norma1,conj12,0);
   per1[2] = evaluafp(norma1,conj13,0);

   per2[0] = evaluafp(norma2,conj21,0);
   per2[1] = evaluafp(norma2,conj22,0);
   per2[2] = evaluafp(norma2,conj23,0);
   per2[3] = evaluafp(norma2,conj24,0);
   per2[4] = evaluafp(norma2,conj25,0);
}

//-------------------------------------------------------------------------------
void reglas(void)
{
   inferencia(per1[0],per2[0],sal3);
   inferencia(per1[0],per2[1],sal3);
   inferencia(per1[0],per2[2],sal3);
   inferencia(per1[0],per2[3],sal2);
   inferencia(per1[0],per2[4],sal1);
   inferencia(per1[1],per2[0],sal2);
   inferencia(per1[1],per2[1],sal2);
   inferencia(per1[1],per2[2],sal1);
   inferencia(per1[1],per2[3],sal1);
   inferencia(per1[1],per2[4],sal1);
   inferencia(per1[2],per2[0],sal1);
   inferencia(per1[2],per2[1],sal1);
   inferencia(per1[2],per2[2],sal1);
   inferencia(per1[2],per2[3],sal1);
   inferencia(per1[2],per2[4],sal1);
}

//-------------------------------------------------------------------------------
void inferencia(float uno, float dos, float *conjsal)
{
   if(uno == 0 || dos == 0) return;

   if(uno > 0 && dos > 0)
   {
      if(uno < dos) sal_regla = uno;
      else sal_regla = dos;
   }

   soporte = conjsal[5];
   f = conjsal[5] * muestras;
   limite = conjsal[6] * muestras;

   for(f; f < limite; f++)
   {
      tempo = evaluafp(soporte,0,conjsal);
      if(tempo >= sal_regla) tempo = sal_regla;
      if(tempo > salida[f]) salida[f] = tempo;
      soporte = soporte + paso;
   }
}

//-------------------------------------------------------------------------------
float desfusificacion(float *fp)
{
   area = 0;
   pond = 0;
   soporte = 0;

   for(n = 0; n < muestras; n++)
   {
      if(fp[n] == 0)
      {
         soporte = soporte + paso;
         continue;
      }
      area = fp[n] + area;
      pond = fp[n]*soporte + pond;
      soporte = soporte + paso;
   }

   if(pond == 0 && area == 0) return(0);
   else return(pond / area);
}

//-------------------------------------------------------------------------------
void conversor(void)
{
   OpenADC(ADC_FOSC_64 & ADC_RIGHT_JUST & ADC_7ANA_1REF,
         ADC_CH0 & ADC_INT_OFF);
   Delay10TCYx(10);
   ConvertADC();
   while ( BusyADC() );
   in1 = ReadADC();

   SetChanADC( ADC_CH1 );
   Delay10TCYx(10);
   ConvertADC();
   while( BusyADC() );
   in2 = ReadADC();
}

//-------------------------------------------------------------------------------
void salida_cero(void)
{
   for(n = 0; n < muestras; n++)
   {
      salida[n] = 0;
   }
}

Este programa es propiedad intelectual de Sebastian Puente Reyes
y hace parte del trabajo de grado: Módulo de desarrollo para la implementación
en microcontrolador, de Sistemas Lógicos Difusos tipo Mamdani del mismo autor.

Villavicencio, Bogotá, COLOMBIA

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: sebastianfpr en 13 de Abril de 2010, 15:36:17

Buenas a todos, tengo un poco abandonado esto, pero son muchas ocupaciones. pero bueno.

Aqui les voy a dejar los conjuntos difusos para las dos entradas de este control difuso de temperatura para una incubadora, asi como tambien las reglas difusas.
Este es un ejemplo de Control de temperatura para una incubadora donde las entradas son: Temperatura del Neonato y Temperatura del Habitaculo.
La Salida es el tiempo en que la carga que calienta el habitaculo debe de estar funcionando.

Conjuntos para la Entrada Uno (Temperatura Neonato):
(http://img35.imageshack.us/img35/2519/entrada1h.jpg)

Conjuntos para la Entrada Dos (Temperatura Habitaculo):
(http://img688.imageshack.us/img688/3730/entrada2.jpg)

Conjuntos para la Salida (Tiempo Activación Carga):
(http://img168.imageshack.us/img168/8590/salidab.jpg)

y Estas son las Reglas del Sistema:
(http://img13.imageshack.us/img13/7236/reglasdifusas.jpg)

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: turok_gt en 23 de Mayo de 2010, 14:25:44

Cita de: sebastianfpr en 12 de Febrero de 2010, 11:33:42

Dejame tu correo

Amigo yo tambien necesito implementar un controlador fuzzy en un pic, me podrias compartir tu programa?, muchas gracias

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: sebastianfpr en 27 de Mayo de 2010, 01:51:34

Amigo en la pagina anterior esta el programa en C
del Sistema lógico difuso teniendo en cuenta los conjuntos de entrada, de salida y las reglas difusas, guíate de el.

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: ncasadiego en 08 de Enero de 2011, 02:34:04

Hola a todos... verán creo que soy la unica niña  del foro  y creanme estoy muy interesada en este tema...
Sebastian estuve leyendo tus comentarios y me interesa mucho el algoritmo en lenguaje c que has mostrado; la verdad no entiendo mucho de c o c++ así que tambien tengo para mi tesis de pregrado un conjunto difuso y hasta ahora solo he desarrolado un modelo en matlab generalizado pues la planta a controlar aun no ha sido montada (es una planta real). sin embargo mi tutor me exige un algoritmo basico de logica difusa en c, y es por eso que me interesa tu trabajo. aclaro que no es el programa de conversion el que necesito, sino la explicacion del algoritmo que colgaste y la planta que controlaste, pues basicamente estos sld utilizan los mismos pasos que en este caso serian las subrutinas.
Agradezco tu colaboración, tu disculpa te agregue en el facebook en realidad es urgente , asi que cuando veas alguien desconocida de barranquilla, pues esa soy yo...

Título: Re: Pasar lógica difusa a lenguaje C
Publicado por: hector915 en 17 de Abril de 2013, 23:45:39

Realmente interesante podrias explicar procedimientos para el desarrollo.