qwertyuiopasdfghjklzxcvbnmqwertyui

opasdfghjklzxcvbnmqwertyuiopasdfgh
jklzxcvbnmqwertyuiopasdfghjklzxcvb
nmqwertyuiopasdfghjklzxcvbnmqwer
Desarrollo De Un Sistema De 
Control Difuso En Plataforma 
DSP Para Un Motor AC 
tyuiopasdfghjklzxcvbnmqwertyuiopas
Eduardo Alejandro Gallo
dfghjklzxcvbnmqwertyuiopasdfghjklzx
UNIVERSIDAD DEL QUINDÍO 
INGENIERÍA ELECTRÓNICA
cvbnmqwertyuiopasdfghjklzxcvbnmq
Armenia 2008

wertyuiopasdfghjklzxcvbnmqwertyuio
pasdfghjklzxcvbnmqwertyuiopasdfghj
klzxcvbnmqwertyuiopasdfghjklzxcvbn
mqwertyuiopasdfghjklzxcvbnmqwerty
uiopasdfghjklzxcvbnmqwertyuiopasdf
 Desarrollo De Un Sistema De
Control Difuso En Plataforma
DSP Para Un Motor AC

Eduardo Alejandro Gallo R.

Trabajo en Modalidad
Asistencia a la Investigación
Proyecto 336

Universidad Del Quindío

Facultad De Ingeniería
Programa De Ingeniería Electrónica
Armenia, Quindío
Octubre de 2008
AGRADECIMIENTOS

Es grato terminar este trabajo y saber que culmino gracias a la ayuda y

colaboración de varias personas, inicialmente a mis padres María del Carmen
Roncancio y Mario Alfonso Gallo, que me brindaron apoyo moral y económico en su
momento, también a mi amada esposa Blanca Elineth Barreiro que estuvo
incondicionalmente a mi lado brindándome su colaboración, compañía y esfuerzo
durante toda la realización del proyecto, a mis amigos Efraín y Fabián que me
brindaron su entusiasmo, Al director del Proyecto José Gabriel Hoyos, por su
acompañamiento, disponibilidad y asesorías, por dirigirme en todo este proceso y
brindarme la oportunidad de trabajar en el proyecto de investigación, principalmente
le agradezco a Dios por darme la vida y rodearme de todas las personas que
estuvieron con migo en esta etapa.

I
RESUMEN

Este trabajo describe el desarrollo de un sistema de control difuso sintonizado

con algoritmos genéticos, se usa el controlador para regular la velocidad de un
sistema compuesto por un modulo de potencia y un motor de inducción trifásico AC,
se realiza la identificación del modelo de este sistema usando un algoritmo genético.
Este modelo se utiliza en la sintonización del controlador difuso, finalmente este se
implementa en un procesador digital de señales TMS320R2812, se presentan
simulaciones y pruebas sobre el sistema real.

Palabras Claves
Algoritmo Genético (AG), Controlador difuso, Modelo Discreto, Procesador digital
de señales (DSP).

II
ABSTRACT

The work describe the development of a fuzzy control system tuned with
genetic algorithms, the control is used for regulating the velocity of system composed
by a power module and a motor of three–phase induction AC, the identification of
model of this system is done using a genetic algorithm. This model is utilized in the
tuning of the fuzzy control, finally this is implemented in a digital signal processor
TMS320R2812, present oneself simulations and proof on the real system.

Key Words
Genetic Algorithm (AG), Fuzzy Controller (FC), Discrete Model, Digital Signal
Processor (DSP).

III
TABLA DE CONTENIDO

AGRADECIMIENTOS ................................................................................................. I 
RESUMEN................................................................................................................... II 
ABSTRACT ................................................................................................................ III 
INTRODUCCION ........................................................................................................ 1 
OBJETIVOS ................................................................................................................. 3 
2.1.  Objetivo General: ...................................................................................................... 3 
2.2.  Objetivos Específicos:............................................................................................... 3 
CAPITULO 3 
MARCO DE REFERENCIA ........................................................................................ 5 
3.1.  Algoritmos Genéticos ............................................................................................... 5 
3.1.1.  Orígenes ............................................................................................................ 6 
3.1.2.  Codificación De Problemas .............................................................................. 7 
3.1.3.  Algoritmo .......................................................................................................... 8 
3.1.4.  Operadores Genéticos ....................................................................................... 9 
3.1.5.  Características De Los Algoritmos Genéticos ................................................ 14 
3.1.6.  Algoritmos Genéticos En Identificación De Sistemas .................................... 15 
3.2.  Lógica Difusa .......................................................................................................... 20 
3.2.1.  Conjuntos Difusos ........................................................................................... 21 
3.2.2.  Variable Lingüística ........................................................................................ 24 
3.2.3.  Operaciones Difusas ....................................................................................... 24 
3.2.4.  Reglas Difusas ................................................................................................ 25 
3.2.5.  Dispositivo de Inferencia ................................................................................ 26 
3.2.6.  Fuzzificación ................................................................................................... 26 

IV
 3.2.7.  Defuzzificación ............................................................................................... 27 
3.3.  Sistemas De Control Difusos .................................................................................. 28 
3.3.1.  Ejemplo De Diseño ......................................................................................... 29 
3.3.2.  Sintonización difusa de Controladores PID .................................................... 35 
3.3.3.  Algoritmos Genéticos En optimización De Controladores Difusos................ 37 
CAPITULO 4
RESULTADOS ........................................................................................................... 38 
4.1.  Descripción Del Sistema ......................................................................................... 38 
4.1.1.  Tarjeta De Desarrollo Microchip dsPic30F y Modulo De Potencia ............... 39 
4.1.2.  Descripción Tarjeta de desarrollo eZdspTM R2812 ....................................... 40 
4.1.3.  Funcionamiento............................................................................................... 41 
4.2.  Identificación Del Sistema Con AG........................................................................ 43 
4.2.1.  Estructura y codificación del modelo .............................................................. 44 
4.2.2.  Función De Coste ............................................................................................ 45 
4.2.3.  Operadores Genéticos ..................................................................................... 45 
4.2.4.  Implementación del algoritmo genético .......................................................... 46 
4.2.5.  Prueba Identificación de un Sistema ............................................................... 47 
4.2.6.  Prueba Con El Sistema ACIM–dsPic30F ....................................................... 51 
4.3.  Controlador ............................................................................................................. 55 
4.3.1.  Algoritmo Controlador Difuso ........................................................................ 62 
4.4.  Sintonización Del Controlador Difuso Mediante Algoritmo Genético ................... 65 
4.4.1.  Diseño Del Algoritmo Genético ..................................................................... 65 
4.4.2.  Resultados del AG .......................................................................................... 69 
4.5.  Implementación Del Controlador En La Tarjeta De Desarrollo eZdspTM R2812 . 72 
4.5.1.  Resultados de la Técnica De Evolución Diferencial Implementada En El
Proyecto 336 ................................................................................................................... 75 
4.6.  Diseño Tarjeta Del Bus Can.................................................................................... 76 
CONCLUSIONES ...................................................................................................... 80 
PROYECCIONES ...................................................................................................... 82 

V
BIBLIOGRAFIA ........................................................................................................ 84 
ANEXO 1 .................................................................................................................... 88 

VI
INDICE DE FIGURAS

Figura 1 – (a) codificación de un individuo genético binario… ................................... 7 

Figura 2 – Algoritmo Genético ..................................................................................... 9 
Figura 3 – Ejemplo cruce de un punto ........................................................................ 12 
Figura 4 – Cruce de codificación no binaria con operador media .............................. 13 
Figura 5 – Ejemplo mutación binaria y no binaria ...................................................... 13 
Figura 6 – Proceso de identificación usando AG ........................................................ 19 
Figura 7 – Ejemplo de funciones de pertenencia para la variable nivel del tanque. .. 21 
Figura 8 – Función de pertenencia trapezoidal ........................................................... 22 
Figura 9 – Función de pertenencia tipo triangular ...................................................... 23 
Figura 10 – Función de pertenencia tipo singleton ..................................................... 23 
Figura 11 – Algunas funciones de pertenencia típicas ................................................ 23 
Figura 12 – Proceso de fuzzificación para un valor de entrada .................................. 27 
Figura 13 – Estructura de un controlador difuso......................................................... 28 
Figura 14 – Péndulo invertido ..................................................................................... 29 
Figura 15 – funciones de pertenencia para FLC del péndulo invertido ...................... 32 
Figura 16 – Calculo de las premisas para las reglas R1 y R2 ..................................... 34 
Figura 17 – Conjuntos difusos de salida ..................................................................... 35 
Figura 19 – Auto – sintonizador PID fuzzy ................................................................ 36 
Figura 20 – Esquema de conexiones del sistema para control de un Motor AC ........ 39 
Figura 21 – Tarjeta De Desarrollo Microchip DSPIC30F y Modulo De Potencia ..... 40 
Figura 22 – Modulo de variación de velocidad con Motor AC .................................. 42 
Figura 23 – Modulo para control por DSP .................................................................. 43 
Figura 24 – Respuesta del sistema para un escalón de valor 0.5. ............................... 48 
Figura 25 – fitness – Generaciones ............................................................................. 49 

VII
Figura 26 – Salida estimada para 10 generaciones ..................................................... 50 
Figura 27 – Salida estimada para 1000 generaciones ................................................. 50 
Figura 28 – comparación de la señal de la planta real (A) .......................................... 51 
Figura 29 – Datos de la respuesta del sistema (ACIM–dsPic30F) ............................. 52 
Figura 30 – Evolución del fitness del individuo Elite ................................................. 52 
Figura 31– Comparación de la salida estimada y la salida real . ................................ 54 
Figura 32 – Comparación de la salida estimada y la salida real ................................. 54 
Figura 33 – Diagrama de bloques del sistema de control difuso ................................ 56 
Figura 34 – Funciones de pertenencia tipo trapezoidal para la variable EV ............... 58 
Figura 35 – funciones de pertenencia tipo trapezoidal para la variable ∆EV ............ 59 
Figura 36 – funciones de pertenencia tipo singleton para la salida............................. 60 
Figura 36 – Ejemplo de operación de la función pertaps ............................................ 63 
Figura 38 – Diagrama de operación de la función fuzzy ............................................ 64 
Figura 39 – Evolución del fitness del individuo Elite ................................................. 69 
Figura 40– Salida del modelo del sistema (ACIM–dsPic30F) controlada.................. 72 
Figura 41– Salida del sistema real controlado para distintos valores ........................ 74 
Figura 42– Salida del sistema controlado para distintos valores en la referencia ....... 75 
Figura 43 – Referencia (línea punteada), velocidad alcanzada .................................. 76 
Figura 45 – interfaz CAN de la tarjeta dsPic30F ........................................................ 77 
Figura 46 – diagrama de bloques y circuito de interfaz . ............................................ 78 
Figura 47 – Red CAN Típica ...................................................................................... 78 
Figura 48 – Diseño del circuito para la trasmisión mediante bus CAN ...................... 79 
Figura 44 – Diagrama de funcionamiento de los programas ................................... 104 

VIII
1. CAPITULO 1

INTRODUCCION

En el proyecto de investigación 336 se busca explorar técnicas de control basadas en

algoritmos evolutivos que permitan su implementación en un procesador digital de
señal DSP y aplicarlas al control de plantas reales, el controlador difuso sintonizado
con algoritmo genético se realiza con el fin de usar los resultados obtenidos como
punto de comparación con las técnicas implementadas en el proyecto 336, además de
indagar sobre el desempeño de los algoritmos genéticos en la identificación de
sistemas, la sintonización de controladores y la implementación de estos en un DSP.
En este proyecto se pretende controlar la velocidad del sistema Modulo de potencia –
Motor de Inducción AC, este controlador se implementara en un DSP.

En este informe se presentan todas las etapas del desarrollo del controlador,
inicialmente se presentan los conceptos referentes a los Algoritmos Genéticos,
identificación de sistemas, lógica difusa, Controladores difusos, sintonización de
controladores difusos con algoritmos genéticos, posteriormente se muestran las etapas
de diseño y los resultados obtenidos en cada etapa empezando por el algoritmo de
identificación, donde se encuentra un modelo matemático discreto para el sistema a
continuación se presenta el diseño del controlador difuso y del algoritmo genético que

1
lo sintoniza, más adelante se presentan los resultados que se obtienen con el
controlador difuso sobre el sistema simulado usando el modelo encontrado
anteriormente. Posteriormente se presenta la implementación de estos algoritmos en
el DSP TMS320R2812, las pruebas y los resultados sobre el sistema real. Se muestra
una comparación de los resultados obtenidos en el proyecto 336 mediante técnicas
evolutivas, con el controlador por lógica difusa implementado en este trabajo.
Finalmente se presenta el diseño de la tarjeta para el bus CAN.

2
2. CAPITULO 2

OBJETIVOS

2.1. Objetivo General:

Implementar un controlador difuso en un procesador digital de señal

TMS320F2812, los parámetros del controlador se ajustaran mediante algoritmos
genéticos fuera de línea. El controlador se probara en un sistema variador electrónico
y motor de corriente alterna.

2.2. Objetivos Específicos:

Elaborar un algoritmo genético que permita a partir de datos tomados en lazo

abierto identificar la planta del sistema variador–motor.

Elaborar un algoritmo genético que a partir del modelo del sistema variador–
motor, permita generar fuera de línea los parámetros del controlador difuso.

3
Implementar y probar el controlador difuso para el modelo del sistema
variador–motor en el DSP TMSR2812 y realizar las pruebas pertinentes para
verificar su correcto funcionamiento.

Diseñar la tarjeta de interfaz para el bus CAN utilizada para realizar

comunicaciones entre el DSP y el sistema variador electrónico del motor.

4
3. CAPITULO 3

MARCO DE REFERENCIA

3.1. Algoritmos Genéticos

Los Algoritmos Genéticos (AG) son métodos adaptativos, generalmente usados

en problemas de búsqueda y optimización de parámetros, basados en la reproducción
sexual y en el principio de supervivencia del más apto.

Mas formalmente, y siguiendo la definición dada por Goldberg, “los Algoritmos

Genéticos son algoritmos de búsqueda basados en la mecánica de selección natural y
de la genética natural. Combinan la supervivencia del más apto entre estructuras de
secuencias con un intercambio de información estructurado, aunque aleatorizado,
para constituir así un algoritmo de búsqueda que tenga algo de las genialidades de las
búsquedas humanas" [1]. Para alcanzar la solución a un problema se parte de un
conjunto inicial de individuos, llamado población, generado de manera aleatoria, cada
uno de estos representa una posible solución al problema. Estos individuos
evolucionaran tomando como base los esquemas propuestos por Darwin sobre la
selección natural, y se adaptarán en mayor medida tras el paso de cada generación a
la solución requerida.
3.1.1. Orígenes

El desarrollo de los Algoritmos Genéticos se debe en gran medida a John

Holland, investigador de la Universidad de Michigan. A finales de la década de los 60
desarrolla una técnica que imitaba en su funcionamiento a la selección natural.
Aunque originalmente esta técnica recibió el nombre de planes reproductivos, a raíz
de la publicación en 1975 de su libro “Adaptation in Natural and Artificial Systems"
[2] se conoce principalmente con el nombre de Algoritmos Genéticos.

Un Algoritmo Genético consiste en una población de soluciones codificadas de

forma similar a cromosomas. Cada uno de estos cromosomas tendrá asociado una
salud, valor de bondad, ajuste o fitness, que cuantifica su validez como solución al
problema. En función de este valor se le darán más o menos oportunidades de
reproducción. Además, con cierta probabilidad se realizaran mutaciones de estos
cromosomas.

Mediante la selección natural que es el mecanismo que relaciona los cromosomas

con la eficiencia respecto al medio de la entidad que representan se otorga a los
individuos mas adaptados al medio un mayor número de oportunidades de
reproducirse.

El proceso evolutivo tiene lugar durante la etapa de reproducción. Aunque existe

una larga serie de mecanismos que afectan a la reproducción los más comunes son la
mutación, causante de que los cromosomas de la descendencia sean diferentes a los
de los padres, y el cruce o recombinación, que combina los cromosomas de los padres
para producir la descendencia.

6
3.1.2. Codificación De Problemas

Cualquier solución potencial a un problema puede ser presentada dando valores a

una serie de parámetros. El conjunto de todos los parámetros (genes en la
terminología de AG) se codifica en una cadena de valores denominada cromosoma.

El conjunto de los parámetros representado por un cromosoma particular recibe el

nombre de genotipo. El genotipo contiene la información necesaria para la
construcción del organismo, es decir, la solución real al problema, denominada
fenotipo. Por ejemplo, en términos biológicos, la información genética contenida en
el ADN de un individuo seria el genotipo, mientras que la expresión de ese ADN (el
propio individuo) sería el fenotipo.

Desde los primeros trabajos de John Holland la codificación suele hacerse

mediante valores binarios. Figura 1, Sin embargo, también pueden existir
representaciones que codifiquen directamente cada parámetro con un valor entero,
real o en punto flotante. Estas representaciones permiten el desarrollo de operadores
genéticos más específicos al campo de aplicación del Algoritmo Genético.

Figura 1 – (a) codificación de un individuo genético binario – (b) codificación de un

individuo no binario

En general se puede usar cualquier codificación siempre y cuando permita aplicar

sobre ella los operadores genéticos.

7
3.1.3. Algoritmo

Los Algoritmos Genéticos trabajan sobre una población de individuos. Cada uno
de ellos representa una posible solución al problema que se desea resolver.

Todo individuo tiene asociado un ajuste o fitness de acuerdo a la bondad con

respecto al problema de la solución que representa (en la naturaleza el equivalente
sería una medida de la eficiencia del individuo en la lucha por los recursos).

Un AG simple se puede describir mediante los siguientes pasos:

I. Inicializar la población
II. Mientras no se cumpla el criterio de terminación.
III. Evaluar el fitness.
IV. Ejecutar el proceso de selección
V. Ejecutar el proceso de cruce
VI. Ejecutar el proceso de mutación
VII. Generar una nueva población.
Un diagrama de bloques para un AG se muestra en la Figura 2, Una generación
se obtiene a partir de la anterior por medio de los operadores de reproducción. Existen
2 tipos:

Cruce: Se trata de una reproducción de tipo sexual. Se genera una descendencia a

partir del mismo número de individuos (generalmente 2) de la generación anterior.
Existen varios tipos de cruce que se mencionaran más adelante.

Copia: Se trata de una reproducción de tipo asexual. Un determinado número de

individuos pasa sin sufrir ninguna variación directamente a la siguiente generación.

Una vez generados los nuevos individuos se realiza la mutación, Se sale de este
proceso cuando se alcanza alguno de los criterios de parada fijados.

8
 Figura 2 – Algoritmo Genético

También puede usarse como operador de reproducción, a la mutación, aplicando

este operador a una cierta parte de la población para generar la nueva población,
aunque no es muy común hacerlo [22].

3.1.4. Operadores Genéticos

Para el paso de una generación a la siguiente se aplican una serie de operadores

genéticos. Los más empleados son los operadores de selección, cruce, y mutación.

9
3.1.4.1. Selección

Los algoritmos de selección serán los encargados de escoger que individuos van a
disponer de oportunidades de reproducirse y cuáles no. Puesto que se trata de imitar
lo que ocurre en la naturaleza, se otorgara un mayor número de oportunidades de
reproducción a los individuos más aptos. Por lo tanto la selección de un individuo
estará relacionada con su valor de ajuste. No se debe sin embargo eliminar por
completo las opciones de reproducción de los individuos menos aptos, pues en pocas
generaciones la población se volvería homogénea.

Selección Por Ruleta

Propuesto por DeJong, es posiblemente el método más utilizado desde los
orígenes de los Algoritmos Genéticos [3]. A cada uno de los individuos de la
población se le asigna una parte proporcional a su ajuste de una ruleta, de tal forma
que la suma de todos los porcentajes sea la unidad. Los mejores individuos recibirán
una porción de la ruleta mayor que la recibida por los peores. En la bibliografía se
suele referenciar a este método con el nombre de Selección de Montecarlo.

Selección Por Torneo

La idea principal de este método consiste en realizar la selección en base a
comparaciones directas entre individuos.

Un caso particular es el elitismo global. Se trata de un torneo en el que participan

todos los individuos de la población y los individuos Elite serán aquellos que posean
una mejor salud. Cuando el tamaño del torneo es reducido, la presión de selección
disminuye y los peores individuos tienen más oportunidades de ser seleccionados.

3.1.4.2. Cruce

Una vez seleccionados los individuos, estos son recombinados para producir la
descendencia que se insertara en la siguiente generación. Tal y como se ha indicado

10
anteriormente el cruce es una estrategia de reproducción sexual. Su importancia para
la transición entre generaciones es elevada puesto que las tasas de cruce con las que
se suele trabajar rondan el 90%.

La idea principal del cruce se basa en que, si se toman dos individuos

correctamente adaptados al medio y se obtiene una descendencia que comparta genes
de ambos, existe la posibilidad de que los genes heredados sean precisamente los
causantes de la bondad de los padres. Al compartir las características buenas de dos
individuos, la descendencia, o al menos parte de ella, debería tener una bondad mayor
que cada uno de los padres por separado. Si el cruce no agrupa las mejores
características en uno de los hijos y la descendencia tiene un peor ajuste que los
padres no significan que se está dando un paso atrás. Existen multitud de algoritmos
de cruce. Algunos de los más empleados son:

Cruce de 1 punto

Es la más sencilla de las técnicas de cruce. Una vez seleccionados dos

individuos se cortan sus cromosomas por un punto seleccionado aleatoriamente para
generar dos segmentos diferenciados en cada uno de ellos: la cabeza y la cola. Se
intercambian las colas entre los dos individuos para generar los nuevos descendientes.
De esta manera ambos descendientes heredan información genética de los padres.

Cruce de 2 puntos

Se trata de una generalización del cruce de 1 punto. En vez de cortar por un

único punto los cromosomas de los padres como en el caso anterior se realizan dos
cortes.

11
 Figura 3 – Ejemplo cruce de un punto

Cruces específicos de codificaciones no binarias.

Los dos tipos de cruce mencionados son validos para cualquier tipo de
representación del genotipo. Si se emplean genotipos compuestos por valores enteros
o reales pueden definirse otro tipo de operadores de cruce:

Media
El gen de la descendencia toma el valor medio de los genes de los padres Figura 4.

Media geométrica
Cada gen de la descendencia toma como valor la raíz cuadrada del producto de
los genes de los padres. Presenta el problema añadido de que signo dar al resultado si
los padres tienen signos diferentes.

Extensión
Se toma la diferencia existente entre los genes situados en las mismas posiciones
de los padres y se suma al valor más alto o se resta del valor más bajo. Solventa el
problema de generar un único descendiente.

12
 Figura 4 – Cruce de codificación no binaria con operador media

3.1.4.3. Mutación

La mutación de un individuo provoca que alguno de sus genes, generalmente uno

solo, varié su valor de forma aleatoria, Figura 5.

Aunque se pueden seleccionar los individuos directamente de la población actual

y mutarlos antes de introducirlos en la nueva población, la mutación se suele utilizar
de manera conjunta con el operador de cruce. Primeramente se seleccionan dos
individuos de la población para realizar el cruce. Si el cruce tiene éxito entonces uno
de los descendientes, o ambos, se muta con cierta probabilidad Pm Se imita de esta
manera el comportamiento que se da en la naturaleza.

Figura 5 – Ejemplo mutación binaria y no binaria

La mutación más usual es el reemplazo aleatorio. Este consiste en variar

aleatoriamente un gen de un cromosoma. Si se trabaja con codificaciones binarias
consiste simplemente en negar un bit. También es posible realizar la mutación
intercambiando los valores de dos alelos del cromosoma. con codificaciones no
binarias también existen otras opciones:

13
 Incrementar o decrementar a un gen una pequeña cantidad generada
aleatoriamente.
Multiplicar un gen por un valor aleatorio próximo a 1.

3.1.4.4. Evaluación

Para el correcto funcionamiento de un AG se debe de poseer un método que

indique si los individuos de la población representan o no buenas soluciones al
problema planteado. Por lo tanto para cada tipo de problema que se desee resolver
debería derivarse un nuevo método, al igual que ocurre con la propia codificación de
los individuos.

De esto se encarga la función de evaluación, que establece una medida numérica

de la bondad de una solución. Esta medida recibe el nombre de ajuste o fitness.

En la naturaleza el ajuste (o adecuación) de un individuo puede considerarse

como la probabilidad de que ese individuo sobreviva hasta la edad de reproducción y
se reproduzca. La aproximación más común consiste en crear explícitamente una
medida de ajuste para cada individuo de la población. A cada uno de los individuos se
les asigna un valor de ajuste escalar por medio de un procedimiento de evaluación
bien definido. Tal y como se ha comentado, este procedimiento de evaluación seria
especifico del dominio del problema en el que se aplica el AG. Si el fitness es lo
suficientemente bueno este individuo podrá heredar todas sus características a los
individuos de las siguientes generaciones.

3.1.5. Características De Los Algoritmos Genéticos

Los algoritmos genéticos (AGs) son algoritmos de búsqueda basados en la

mecánica de la selección natural, sobreviven los mejores. Algunas características de
los AGs son:

14
 Trabaja con un código correspondiente a los parámetros, no con los
parámetros,
Los parámetros se codifican dependiendo del problema.
Permiten una búsqueda rápida en el espacio de parámetros y evitan mínimos y
máximos locales.
Explotan la información de la función objetivo, no se requieren cálculos de
gradiente.
Se tiene una población de posibles soluciones no una solución. Se pueden
obtener varias soluciones. Cuando encuentra una, se remueve de la población
(realizar la función objetivo para esa solución) y continuar la optimización
Son rápidos y robustos.
Los mecanismos de los algoritmos genéticos simples son sorprendentemente
fáciles, dado que los mecanismos que utiliza son el mecanismo de copia y el
de intercambio de partes de las cadenas de cromosomas.

Los principales inconvenientes son:

El número de operaciones y por tanto el coste computacional puede ser muy

alto si no se toman precauciones.
No hay ninguna teoría matemática hasta el momento, que nos asegure la
convergencia.

3.1.6. Algoritmos Genéticos En Identificación De Sistemas

3.1.6.1. Identificación

La identificación de sistemas es la teoría y el arte de construir modelos

matemáticos de sistemas dinámicos basándonos en las entradas y salidas observadas.

15
Como disciplina científica data de los primeros intentos de modelar series de tiempo
usando técnicas Auto–Regresivas. Aunque una parte sustancial del desarrollo de las
técnicas está ligado a la Comunidad de Control, está básicamente construida a partir
de técnicas estadísticas, en particular en los métodos de regresión lineal y no–lineal.

Construir modelos para sistemas desconocidos es un objetivo importante de la

Ingeniería de control. Estos modelos necesitan simular el comportamiento real en los
casos en que existe un conocimiento previo limitado de la estructura de un sistema.

La identificación de sistemas no lineales se considera un problema difícil. La

razón es que identificar un sistema no–lineal conlleva dos grandes etapas: la selección
de la estructura del modelo con un cierto número de parámetros y la selección de un
algoritmo que estime dichos parámetros. En la literatura han sido propuestos
numerosos modelos lineales como solución al proceso de identificación. Estos
modelos son simples, como (Output Error) OE y ARX (Auto–Regressive with
eXogenous inputs) [5]. Los modelos pueden ser paramétricos, que tienen la ventaja
de estar dados por un conjunto pequeño de coeficientes, o bien no paramétricos como
las redes neuronales, que tienen la ventaja de no estar restringidas a un cierto número,
posiblemente pequeño, de descripciones posibles del modelo.

El término Identificación de sistemas fue acuñado por Lofti Zadeh [4] en 1962, como:

“Identificación es la determinación, en base a la entrada y la

salida, de un sistema, dentro de una clase de sistemas
especificada, al cual el sistema probado es equivalente.”

3.1.6.2. Modelos de Sistemas Dinámicos

Cuando trabajamos con un modelo de un sistema, tenemos una cierta idea de

cómo unas variables están relacionadas entre sí. Desde un punto de vista general,
podemos decir que las relaciones observadas son un modelo del sistema. Está claro

16
que los modelos pueden venir dados por diferentes estructuras y con distintas
formulaciones matemáticas. El uso deseado del modelo también determina el grado
de sofisticación requerido. El modelado e identificación de sistemas no lineales es, en
buena medida, un problema dependiente de las aplicaciones y que frecuentemente
tiene sus raíces en la tradición y en las técnicas específicas del área de aplicación.

Son de interés los Modelos paramétricos No–lineales, entre los cuales

encontramos a las series de volterra [5], y los modelos NARMAX (Non– linear
Auto–Regressive Moving Average with eXogenous inputs), que son una
generalización de las series de Volterra y que puede ser descrito como:

1 ,…, , ,…., 1 ,
1 ,…,

Ecuación 3.1-1

Donde t representa el tiempo discreto, y (t), u (t) y ε (t) son la salida, la entrada, y
el error de predicción, respectivamente, ny , nu y nε son los órdenes correspondientes,
F[.] es una función no lineal y d es el mínimo retardo de la entrada. El modelo
polinomial NARMAX tiene como expresión:

   

   

   

Ecuación 3.1-2

Este nos permite una descripción buena y sencilla de una amplia clase de
sistemas no lineales, además de ser de fácil implementación en un computador
digital.

17
3.1.6.3. IDENTIFICACION DEL SISTEMA CON AG.

La identificación de sistemas no lineales mediante modelos lineales o no lineales

es un trabajo laborioso. La mayoría de las veces se debe partir de los conocimientos
heurísticos sobre la dinámica del sistema. La identificación posterior de los
parámetros se realiza usando métodos matemáticos, utilizando las propiedades de
cada familia de modelos.

Los métodos más usuales en la identificación de sistemas están basados en

mínimos cuadrados o en el método de máxima verosimilitud que son métodos locales
guiados por el gradiente y necesitan una función de pérdidas diferenciable y un
espacio de búsqueda suave. Estos a menudo fallan en la búsqueda de un óptimo
global cuando la función no es diferenciable o es no lineal en sus parámetros.

Los métodos de optimización basados en algoritmos genéticos pueden mejorar

los resultados porque no utilizan las propiedades de diferenciabilidad o de linealidad
en los parámetros.

Para el diseño del AG enfocado a la identificación de sistemas, se debe tener en

cuenta lo siguiente:

Lo que se desea encontrar en estos casos son los coeficientes de un modelo,

Lo más recomendable es usar una codificación no binaria para los
cromosomas, ya que los coeficientes del modelo por lo regular son valores
reales, los cromosomas estarán conformados por los n coeficientes del
modelo, la longitud del cromosoma dependerá del modelo que se use, lineal o
no lineal.
Comúnmente se utiliza como criterio de ajuste una función que depende del
error el cual se calcula como la salida del sistema real menos la salida del
modelo del sistema. Esta función puede ser la sumatoria del valor absoluto del
error o de los cuadrados del error.

18
 Definir adecuadamente los operadores de selección cruce y mutación.
Adicionalmente se deben probar un número suficiente de condiciones sobre el
sistema a fin de que el modelo encontrado logre representar todos los estados
del sistema a identificar.

En la Figura 6 se presenta un diagrama de bloques del proceso de

identificación usando un AG, El algoritmo genético se encarga de probar
coeficientes sobre el modelo, con la salida estimada y la salida real se calcula el
error y este se realimenta al AG con el fin de evaluar la salud de los individuos
del respectivo ciclo, esto se repite hasta que se encuentren unos coeficientes que
hagan que el error se minimice lo suficiente.

Figura 6 – Proceso de identificación usando AG

En 1992, Kristinsson y Dumont [6] hicieron un primer estudio de la

identificación de sistemas y del control off–line con algoritmos genéticos de sistemas
dinámicos continuos y discretos. Comprobaron que los algoritmos genéticos son
efectivos en ambos dominios y que es posible identificar directamente parámetros
físicos, o bien, polos y ceros. Hicieron simulaciones con sistemas de fase mínima y
no mínima y de un sistema con dinámica no modelada. En 1993, Flockton y White

19
[7] utilizan los algoritmos genéticos para hacer otra identificación off–line de polos y
ceros con algunas pequeñas mejoras. Posteriormente, en 1995, Tan, Li y Murray–
Smith [8] usan los algoritmos genéticos con "simulated anneling" para hacer una
identificación off–line y la linealización de sistemas no lineales, invariantes del
tiempo con un modelo ARMAX.

3.2. Lógica Difusa

La lógica difusa se fundamenta en el razonamiento humano, maneja información

ambigua como, está muy frio, hace mucho calor, por medio de reglas de sentido
común del tipo: si hace mucho frio entonces calienta mucho el cuarto. Los sistemas
difusos tienen especial aplicación en problemas no lineales o que no estén bien
definidos, también permiten modelar cualquier proceso no lineal, son particularmente
fáciles de implementar gracias a la simplicidad de los cálculos necesarios (sumas y
comparaciones, fundamentalmente), normalmente pueden realizarse en sistemas
económicos y rápidos.

La teoría de conjuntos difusos se considera una generalización de la teoría clásica

de conjuntos, añadiendo a cada conjunto una función de pertenencia μΑ(t), que indica
el grado en el cual está relacionado el valor t al respectivo conjunto identificado por
una etiqueta lingüística A. como puede verse en la Figura 7, para el valor lingüístico
nivel del tanque pueden definirse tres conjuntos difusos, cada uno identificado por
una etiqueta, {Bajo, Medio, Alto}, y con una función de pertenencia {μBajo(t),
μMedio(t), μAlto(t)}.

De esta manera si el nivel del tanque se mide de 0 a 1, un nivel igual a 0.5

pertenece al conjunto medio, y un valor igual a 0.7 pertenece en cierta proporción al
conjunto medio y también al conjunto alto.

20
 Figura 7 – Ejemplo de funciones de pertenencia para la variable nivel del tanque.

3.2.1. Conjuntos Difusos

En los conjuntos difusos un valor pertenece parcialmente a uno o más conjuntos,

por ejemplo, la temperatura puede ser 30% frio y 70 % templado, a diferencia de los
conjuntos de la lógica clásica donde la temperatura es fría o caliente y no se admiten
niveles intermedios.

Sea U un conjunto de objetos, por ejemplo, U = Rn, que se denominará universo

de discurso. En términos matemáticos [9], un conjunto difuso F en U queda
caracterizado por una función de pertenencia μF que toma valores en el rango [0,1], es
decir, μF: U → [0,1]; donde μF(u) representa el grado en el que u ∈ U pertenece al
conjunto difuso representado por la etiqueta F el cual consiste en un conjunto de
pares ordenados F = {u, μF (u) / u ∈ U}. para definir estas funciones de pertenencia
se utilizan convencionalmente ciertas familias de formas estándar, por coincidir con
el significado lingüístico de las etiquetas más utilizadas. Las más frecuentes son la
función de tipo trapezoidal, singleton, triangular, S, exponencial y tipo π.

La función de tipo trapezoidal se define por cuatro puntos a, b, c, d. esta función

es cero para valores menores de a y mayores de d vale uno entre b y c, y toma valores
en [0,1] entre a y b, y entre c y d. Se utiliza habitualmente en sistemas difusos
sencillos, pues permite definir un conjunto difuso con pocos datos, y encontrar su

21
valor de pertenencia con pocos cálculos. Se emplea especialmente en sistemas
basados en microprocesador, pues con similar formato pueden codificarse también
funciones de tipos, triangular y singleton, según se distribuyan los puntos a, b, c y d
de la Figura 8 (por ejemplo juntando b y c se forma una función triangular). Esta
función se define matemáticamente como se muestra en la Ecuación 3.2-1

; , , , 1

Ecuación 3.2-1

A partir de esta expresión se puede obtener La función de tipo triangular Figura

9, haciendo b = c, una función de tipo singleton, haciendo a = b = c = d, la función
de tipo singleton, Figura 10, tienen un único valor para un punto a y 0 para el resto, se
utiliza en sistemas simples para definir los conjuntos difusos de las particiones de las
variables de salida, pues permite simplificar los cálculos y requiere de poca memoria
para almacenarla base de reglas. La forma de algunas de las funciones de pertenencia
se muestran en la Figura 11, para ampliar el tema revisar [10]

Figura 8 – Función de pertenencia trapezoidal

22
 Figura 9 – Función de pertenencia tipo triangular

Figura 10 – Función de pertenencia tipo singleton

Figura 11 – Algunas funciones de pertenencia típicas

23
3.2.2. Variable Lingüística

Una variable lingüística es aquella que puede tomar por valor términos del
lenguaje cotidiano, como grande, pequeño, positivo, negativo, etc., que son las
palabras que desempeñan el papel de etiquetas en un conjunto difuso, una variable
lingüística también puede tomar valores numéricos.

Dada una variable lingüística A, definida en un rango entre u1 y u2, se deben

definir para ella los distintos valores que puede tomar, estos se conocen como
partición. Un ejemplo son las particiones de la variable nivel del tanque Figura 7, con
tres conjuntos difusos, cada uno identificado por una etiqueta, {Bajo, Medio, Alto}, y
una función de pertenencia, {μBajo(t), μMedio(t), μAlto(t)}.

Para la realización de controladores basados en lógica difusa se han de definir

particiones de las variables del controlador. Los nombres de los conjuntos borrosos
que forman una partición se suelen expresar en forma abreviada por sus iníciales; así,
una partición típica como {Negativo Grande, Negativo Pequeño, Cero, Positivo
Pequeño, Positivo Grande} se representa como {NG, NP, CE, PP, PG} o, en ingles,
{NL, NS, ZE, PS, PL} (Negative Large, Negative Small, Zero, Positive Small,
Positive Large).

3.2.3. Operaciones Difusas

Dados A y B conjuntos difusos en U, con funciones de pertenencia ,

, se definen las siguientes operaciones básicas: complemento Ecuación 3.2-2,
unión Ecuación 3.2-3 e intersección Ecuación 3.2-4, en términos de sus funciones de
pertenencia. Estas operaciones funcionan de igual forma que las correspondientes a
las de la teoría de conjuntos clásicos.

24
 1
Ecuación 3.2-2

,
Ecuación 3.2-3

,
Ecuación 3.2-4

3.2.4. Reglas Difusas

Una Regla difusa describe el comportamiento del sistema difuso usando

expresiones del tipo IF –THEN (SI -ENTONCES), mediante estas reglas se combinan
los conjuntos de entrada, llamados premisas, a un conjunto de salida, llamado
consecuente. Los conjuntos de la premisa se asocian mediante conectores lógicos
como y, o, etc. Una regla típica para un sistema de control sería "Si error es positivo
pequeño y derivada de error es negativo pequeño Entonces acción es positiva
grande", que se suele expresar abreviadamente mediante expresiones del tipo Si e es
PP y de es NP Entonces u es PG.

Mediante las reglas se expresa el conocimiento que se tiene sobre la relación que
hay entre antecedentes y consecuentes, se usan varias reglas agrupadas en un
conjunto denominado base de reglas para expresar el conocimiento de la forma más
completa posible. También es común expresar la base de reglas como una tabla de las
reglas que la conforman o como una memoria asociativa borrosa o FAM (Fuzzy
Associative Memory). [10]. Las FAM son matrices que representan la consecuencia
de cada regla definida para cada combinación de dos entradas. Las FAM permiten
realizar una representación gráfica clara de las relaciones entre dos variables
lingüísticas de entrada y la variable lingüística de salida, pero requiere que se indique
explícitamente todas las reglas que se pueden formar con estas dos variables de
entrada.

25
Formalmente, una base de reglas difusas es una colección de reglas R con el formato:

:         …              

Donde  ,…,  y  son conjuntos difusos, respectivamente, y

,… , y , son variables lingüísticas. Este formato de reglas se conoce como
difuso puro o de tipo Mamdani.

3.2.5. Dispositivo de Inferencia

Los dispositivos de inferencia se encargan de interpretan las reglas del sistema,

con el fin de obtener los valores de salida a partir de los valores de las variables
lingüísticas de entrada. Los dispositivos de inferencia se fundamentan en las distintas
formas de implicación difusa.

Implicación difusa por la regla del mínimo:

,   ,

Ecuación 3.2-5

Implicación difusa por la regla del producto:

Ecuación 3.2-6

3.2.6. Fuzzificación

El fuzzificador establece una relación entre los conjuntos difusos de entrada y el

valor de entrada no difuso, el fuzzificador singleton, es el método más utilizado,
principalmente en sistemas de control, y consiste en considerar los propios valores
discretos como conjuntos borrosos. De otra forma, para cada valor de entrada x se

26
define un conjunto A que lo soporta, con función de pertenencia μA(x) de modo que
μA(x) = 1, μA(x’) = 0 para todos los otros x’ ∈ U en los que x’ ≠ x.

Una simplificación de este proceso es encontrar los valores numéricos de la

función de pertenencia para los cuales está definido un valor de entrada. Como se
muestra en la Figura 12. El valor de entrada no difuso es 45 se establece la relación
45 es 0.5 medio y 0.2 alto.

Figura 12 – Proceso de fuzzificación para un valor de entrada

3.2.7. Defuzzificación

El defuzzificador se encarga de transformar el conjunto difuso de salida, en un

valor real. Para esta tarea se pueden utilizar diversos métodos [10], [12].

Defuzzificador por máximo.

Defuzzificador por centro de área.
Defuzzificador Centro de gravedad.
Defuzzificador por media de centros.

La expresión matemática del fuzzificador por media de centros tiene la forma

mostrada en la Ecuación 3.2-7.

27
 ∑
∑
Ecuación 3.2-7

Donde  son los centros de las funciones de pertenencia de la salida,  son los
valores agregación que resulta de cálculo de los consecuentes usando la implicación
difusa por cualquiera de los métodos [20]. Obteniendo así la implicación de cada
regla activada por las premisas de una entrada en particular.

3.3. Sistemas De Control Difusos

La estructura típica de un controlador basado en un sistema difuso puede verse en

la Figura 13, El Controlador lógico difuso (FLC) se compone de cuatro bloques
básicos, Una base de reglas, que habitualmente es basada en el conocimiento
experiencia de un experto acerca de cómo lograr un buen control, un bloque
fuzzificador que realiza la conversión de valores reales a términos difusos. Su salida
es utilizada por el dispositivo de inferencia borrosa para aplicarla a cada una de las
reglas, siguiendo un método de inferencia seleccionado. Finalmente el defuzzificador
se encarga de transformar las conclusiones del mecanismo de inferencia en las
entradas reales para el proceso, en las etapas de pre–procesado y pos–procesado de
los datos a la entrada y salida del FLC se realizan cálculos y escalados de las
variables, según lo requiera la aplicación.

Figura 13 – Estructura de un controlador difuso

28
 Normalmente el objetivo del control es mantener r = y, por ejemplo en un caso
de calefacción domestica, el controlador recibe la referencia de temperatura que fija
el usuario, mide la temperatura de la habitación por medio de un sensor. En función
de estas dos entradas el sistema de control conecta o desconecta el sistema de
calentamiento para mantener la temperatura deseada.

3.3.1. Ejemplo De Diseño

Se explicaran cada uno de los componentes del controlador difuso para un problema
simple de balanceo uno péndulo invertido en un carro, como se muestra en la Figura
14. En este, y denota el ángulo que el péndulo hace con la vertical (en radianes), l es
el la mitad de la longitud del péndulo (en los metros), y u es la entrada de fuerza que
mueve el carro (en Newtons). Usaremos r para denotar la posición angular deseada
del péndulo, el objetivo del control es mantener el péndulo en posición vertical así
que el valor de r siempre será 0. Este ejemplo se encuentra analizado con más detalle
en [13].

Figura 14 – Péndulo invertido

Como primer paso escogemos las entradas y salidas del FLC, Considerando a un
Experto en el lazo de control como el responsable de ejercer la acción de control, las
entradas son las variables en las cuales el experto va a fundar sus decisiones.

Podemos escoger el error e(t) = r(t) − y(t) y su derivada o cambio . Ciertamente,

hay más opciones de elección como por ejemplo La integral del error, pero el elegir

29
estas nos da un buen sentido intuitivo. Después, debemos identificar la variable a
controlar. Para el péndulo invertido, únicamente podemos controlar la fuerza que
mueve la carreta, así es que la elección es simple, para diseños más complejos la
elección de estos parámetros puede no ser tan simple.

Ahora debemos definir unas descripciones lingüísticas para cada una de estas
variables, podemos decir por ejemplo “el error es cero”, “el error es positivo
pequeño”, o “es negativo”, se deben definir suficientes descripciones para todo el
rango de variación de las variables.

Se definen las siguientes etiquetas par el error, el cambio del error y la fuerza.

“NG” NEGATIVO GRANDE

“NP” NEGATIVO PEQUEÑO
“Z” CERO
“PP” POSITIVO PEQUEÑO
“PG” POSITIVO GRANDE.

Se puede usar cualquier etiqueta que defina adecuadamente los estados de las
variables.

Estas etiquetas definen el estado del sistema por ejemplo:

La declaración “el error es PG” puede representar la situación donde el péndulo

queda a un ángulo significativo a la izquierda de la vertical.

La declaración “el error es PG” y “el cambio del error es PP” puede representar la
situación donde el péndulo esta la izquierda de la vertical y dado que el cambio de
error es negativo, el péndulo se aleja de la posición de equilibrio (en este caso el
péndulo se mueve contrario al sentido de las manecillas del reloj).

30
 Ahora usamos esta cuantificación lingüística para definir una base de reglas que
capture el conocimiento del experto en cuanto al control de la planta, recordemos que
el formato de estas reglas es.

Si premisa Entonces consecuente, estas reglas deben considerar todas las

posibles situaciones en las que se pueda encontrar el sistema.

Algunas de las reglas pueden ser:

• Si error es NG Y cambio de error es NG Entonces fuerza es PG.

• Si error es Z Y cambio de error es PP Entonces fuerza es NP.
• Si error es PG Y cambio de error es NP Entonces fuerza es NP …

Recordemos que esta base de reglas puede ser fácilmente codificada mediante
una FAM como la de la Tabla 3.3–1, en esta tabla se asocia a cada combinación de
las entradas una consecuencia.

Tabla 3.3–1
FAM para el control del péndulo invertido. A cada combinación de las variables de
entrada se asocia una consecuencia

Error e
Fuerza “u”
NG NP Z PP PG

NG PG NP NP NP Z
“Cambio en el error”

NP NP Z PP Z NP

Z NP PP Z NP PP

PP NP Z NP Z PP

PG Z PP PP PP PG

31
Funciones de pertenencia.
Se debe tener en cuenta que las funciones de pertenencia cubran todo el rango de
variación de las variables. Se usaran particiones de cinco elementos, con funciones de
tipo triangular centradas en torno a un punto, como se puede apreciar en la Figura 15.

Figura 15 – funciones de pertenencia para FLC del péndulo invertido

Ahora debe seleccionarse un método para la fuzzificación de las entradas,

mecanismo de inferencia, y defuzzificación para las salidas. Para la elección de estas
se ha de considerar fundamentalmente los aspectos relativos a la eficiencia
computacional y a la facilidad de adaptación expuestos anteriormente. Así, en el caso
frecuente de realizar el sistema en un micro controlador de 8 bits y sin funciones de
aprendizaje, la opción más adecuada será un sistema borroso con fuzzificador tipo
singleton, implicación difusa por la regla del mínimo y defuzzificador por media de
centros.

32
Operación del FLC

Para entender como operaria el FLC diseñado, es decir, dadas unas determinadas
entradas como se obtiene la salida realizaremos algunos cálculos para un caso
simplificado, dadas las entradas:

/4 y / /16.

El proceso de fuzzificación equivale a encontrar los valores de las funciones de

pertenencia para estos valores de entrada.

/4 1

Esto quiere decir que el valor del error pertenece en un 100 % al PP, a todos los
demás 0%.

0.5
16

0.5
16

Esto quiere decir que el cambio de error pertenece un 50 % a Z y un 50 % al PP,

y 0 % a todas las demás.

Estas entradas activan dos reglas,

R1: Si error es PP Y cambio de error es PP Entonces fuerza es NP.

R2: Si error es PP Y cambio de error es Z Entonces fuerza es Z.
La premisa de cada regla se calcula usando la regla del mínimo. Figura 16

R1: µA x min 1 , 0.5 0.5

R2: µA x min 1 , 0.5 0.5

33
 El conjunto de salida bien dado por

µB y min   µA x  ,  

Esto supone el truncado de los conjuntos difusos de salida con los valores
obtenidos de las premisas Figura 17.

Figura 16 – Calculo de las premisas para las reglas R1 y R2

Por último queda calcular el valor final de la salida, siguiendo el procedimiento

de la media de centros cuya expresión y calculo se muestra en la Ecuación 3.3-1.

∑ min  ,…,
∑ min  ,…,
Ecuación 3.3-1

0.5 10 0.5 0
5
0.5 0.5

34
Esto indica que la regla R1, cuya salida es NP (de centro –10), se cumple en una
cantidad de 0.5, mientras que la regla R2, cuya salida es Z (de centro 0), se cumple
0.5. La salida F es una media ponderada de los centros de los conjuntos de salida
correspondientes a cada regla, es decir, la F que actúa sobre el sistema no es –10 ni 0
sino que es el promedio ponderado –5.

Figura 17 – Conjuntos difusos de salida

3.3.2. Sintonización difusa de Controladores PID

Más del 90 % de los controladores en operación hoy son de tipo PID. Esto debido
a que este tipo de controlador es fácil de entender, fácil de explicar a otros y fácil de
implementar. Además, su costo es reducido y a menudo vienen incorporados en
controladores lógicos programables (PLCs) los que se usan para el control en muchos
procesos industriales. Desafortunadamente, muchos de los controladores PID que
están en operación tienen una necesidad continua de monitoreo y ajuste ya que
fácilmente pueden desintonizarse (debido a variaciones de parámetro de la planta o
los cambios de condición en operación), hay una necesidad significativa para
desarrollar métodos para la sintonización automática de controladores PID.

35
 Figura 18 – Auto – sintonizador PID fuzzy

Un esquema de cómo puede operar un auto – sintonizador PID difuso se muestra

en Figura 18. El identificador de comportamiento trata de caracterizar el
comportamiento actual de la planta de un modo que será útil para el diseñador PID.
El supervisor completo puede ser implementado en forma similar a un controlador
difuso directo, donde se pueden usar reglas simples, las premisas de las reglas se
pueden tomar del identificador de comportamiento y los consecuentes pueden ser los
valores del controlador PID. Algunos candidatos para reglas del sistema difuso
pueden ser:

Si error de estado estable es grande Entonces incrementar la ganancia

proporcional.
Si la respuesta es oscilatoria Entonces incrementar la ganancia derivativa.
Si la respuesta es lenta Entonces incrementar la ganancia proporcional.
Si el error de estado estable es muy grande Entonces ajustar la ganancia integral
Si el sobre impulso es muy grande Entonces decrementar la ganancia
proporcional.

36
3.3.3. Algoritmos Genéticos En optimización De
Controladores Difusos

Un aspecto clave en el empleo de AG en la optimización de un controlador difuso

es decidir que se ha de optimizar y como codificarlo en forma de genoma. Respecto a
que se ha de optimizar caben cuatro opciones básicas:

1. Optimización de coeficientes
Ganancias de entrada salida
Partición de las variables de entrada
Partición de las variables de salida
2. Optimización de las reglas
3. Optimización de la estructura de la base de reglas
4. Optimización completa.

Codificación
Dependiendo de la alternativa de optimización seleccionada se debe escoger una
codificación para los parámetros a optimizar, algunas sugerencias para la codificación
de estos parámetros se encuentran en [10],[16].

Operadores genéticos

Estos deben elegirse de acuerdo a la codificación seleccionada para los genomas,

sin embargo, los mecanismos usados se fundamentan en los mencionados en la
sección 3.1.4. Que trata sobre los operadores genéticos convencionales.

Función de coste

Como función de coste puede elegirse algún cálculo relacionado con la característica
que se desea mejorar del controlador, usualmente se utiliza la suma cuadrática del
error entre la referencia y la salida, otras alternativas se pueden observar en [17], [18].

37
4. CAPITULO 4

RESULTADOS

4.1. Descripción Del Sistema

El sistema está conformado por un motor AC asíncrono o motor de inducción AC

(ACIM) trifásico, un encoder, una tarjeta de desarrollo Microchip dsPIC30F para el
control del motor (dsPIC MCU), un modulo de potencia trifásico de alto voltaje
Microchip, un modulo para control por DSP que incluye una etapa de interfaz y
adquisición de datos, una tarjeta de desarrollo eZdspTM R2812 que contiene un DSP
TMS320R2812, En la Figura 19, se presenta el esquema de conexión de los
elementos del sistema.

El Motor AC es un motor de inducción YASKAWA TYPE SK 0.3B – 4, 1570 rpm

220/440 V a 60 Hz.
El “Encoder” ELTRA EL63E.1V1000 de 1000 pulsos por revolución.
 Figura 19 – Esquema de conexiones del sistema para control de un Motor AC

4.1.1. Tarjeta De Desarrollo Microchip dsPic30F y Modulo

De Potencia

La tarjeta puede ser usada en dos formas diferentes. La primera forma es en

conjunto con uno de los módulos personalizados de potencia que han sido
desarrollados para complementar la tarjeta de desarrollo. La conexión se efectúa por
el conector de tipo–D de 37 clavijas – J1. De este modo, todo lo que el usuario tiene
que suministrar es un motor y no hay que preocuparse por la etapa de potencia y el
acondicionamiento de la señal. El módulo de poder tiene su propia protección contra
fallas y un sistema de circuitos de aislamiento de señal. Hay muchas señales de
retroalimentación diferentes entre las que el usuario puede hacer una selección para
hacer medidas en el sistema dependiendo de la aplicación que pretenda. Estas señales
son seleccionadas internamente dentro del módulo de poder.

39
 El segundo uso del tablero es para los usuarios que ya tienen su propia etapa de
poder sino están interesados en evaluar al dsPIC MCU en su aplicación. En este caso,
el usuario fácilmente puede conectarlo a su sistema usando los conectores provistos
en el tablero.

Aunque primordialmente se enfoca en aplicaciones de control del motor, la

tarjeta también se puede usar en aplicaciones estáticas de conversión de potencia,
como son, los sistemas de potencia ininterrumpida (UPS), corrección del factor de
potencia (PFC) y Suministro De potencia en modo de conmutación (SMPS). Para más
información revisar [23]

Figura 20 – Tarjeta De Desarrollo Microchip DSPIC30F y Modulo De Potencia

4.1.2. Descripción Tarjeta de desarrollo eZdspTM R2812

El eZdspTM R2812 es una tarjeta autónoma que permite a los usuarios examinar
el procesador de señales digitales del TMS320R2812 (DSP). Este módulo es una
plataforma excelente para desarrollar y correr software para el procesador del
TMS320R2812. [24]; las características más importantes del eZdspTM R2812 son:

Procesador digital de señales TMS320R2812

Velocidad de operación 150 MIPS

40
 20K words on–chip SARAM
64K words off–chip memoria SRAM
256K bits memoria EEPROM serial
Reloj 30 MHz.
Conectores de expansión (memoria, analógico, I/O)
TI R28xx Code Composer Studio tools driver.

4.1.3. Funcionamiento.

El sistema se divide en dos etapas:

• Modulo De Variación De Velocidad Electrónica Con Motor AC.

• Modulo Para Control Por DSP.

A continuación describiremos en detalle cada una.

4.1.3.1. Modulo De Variación De Velocidad Con Motor AC.

Este modulo se conforma por la tarjeta de desarrollo Microchip dsPIC30F el

modulo de potencia, el motor de inducción y el encoder.

El modulo de potencia es manejado mediante la tarjeta de desarrollo Microchip

dsPIC30F, el modulo de potencia envía el voltaje trifásico al motor de inducción, en
el cual se mide la velocidad usando el encoder.

Usando la tarjeta de desarrollo Microchip dsPIC30F se pueden variar la velocidad

del motor usando diferentes técnicas, el programa que esta implementado en esta
tarjeta es un control simple de velocidad basado en [25] que permite variar la
velocidad del motor de inducción AC se usa la técnica Volts – Hertz que controla la
frecuencia y amplitud del voltaje del motor.

41
 Por medio de las entradas analógicas del dspic30F se cambia el valor de voltaje y
frecuencia del motor de esta forma se controla la velocidad, cabe mencionar que esta
estrategia no tiene que ver con el control externo que se desarrollara en la Tarjeta de
desarrollo eZdspTM R2812, así que el sistema ” (ACIM) y el modulo de potencia”
serán vistos como una caja negra cuya entrada será el voltaje analógico y una salida que
es el voltaje de salida del encoder que representa la velocidad del motor. Figura 21.

Figura 21 – Modulo de variación de velocidad con Motor AC

4.1.3.2. Modulo Para Control Por DSP

Este modulo está conformado por la tarjeta de desarrollo eZdspTM R2812, una
etapa de interfaz y adquisición conformada por un circuito de conversión de 3.3 v –
5v, un circuito de comunicación serial y un circuito de adquisición de datos. Un
diagrama se presenta en la Figura 22.

Debido a que el eZdspTM R2812 trabaja únicamente con voltaje de 3.3 v en

operaciones de entrada / salida un circuito acopla los voltajes de 3.3 v a 5 v y luego a
una interfaz RS–232 el cual a su vez se conecta con otro circuito basado en un
microcontrolador que sirve como circuito de adquisición y permite el ingreso de 2
señales digitales D1 y D2, 2 entradas análogas A1 y A2 y una salida análoga SA, este
modulo también provee 5 v.

42
 La velocidad de transmisión entre el DSP y el microcontrolador de adquisición es
de hasta 38400 baudios, eventualmente este modulo también podría servir para
comunicarse con algún otro instrumento o tarjeta que tenga puerto serial.

En la tarjeta de desarrollo eZdspTM R2812 se implementa el controlador, por

medio de la tarjeta de adquisición se envía el voltaje de control usando la salida
análoga y la salida del encoder se conecta a la entrada digital 1 como realimentación
del sistema.

Figura 22 – Modulo para control por DSP

4.2. Identificación Del Sistema Con AG.

Para la identificación off–line del Modulo De Variación De Velocidad Con

Motor AC (ACIM – dsPic30F) se usa un AG. Para esto se usan los datos de la
respuesta del sistema a unas determinadas referencias estos son tomados en lazo
abierto en el sistema. El modelo encontrado se usara posteriormente para diseñar el
controlador difuso.

43
 La estimación de los parámetros de un modelo de identificación usando AGs
consta de un conjunto de etapas generales, siendo la elección y construcción del
modelo a identificar la primera de dichas etapas.

4.2.1. Estructura y codificación del modelo

Debido a que la dinámica del ACIM es no lineal como se muestra en [19], se

usara un modelo no lineal, entre estos, uno de los más interesantes, es el modelo
NARMAX mencionado anteriormente en la sección 3.1.6.2 cuya representación
matemática general del modelo se puede ver en la Ecuación 3.1-2

El número de coeficientes del modelo NARMAX crece exponencialmente con el

orden de desarrollo. Por este motivo, se utiliza para el modelo una expansión de
orden dos y se ha obviado la modelación de ruido. De esta forma nuestro modelo a
identificar tiene como expresión:

  1   1   1   2
  1 1   1 2
  2 1   2 2   1
  1   2   2
Ecuación 4.2-1

Donde y es la salida, u es la entrada.

, , , , , , , , , ,  , , ;  Son los parámetros del
modelo que deben identificarse usando AG.
Por lo tanto el cromosoma será
                                 

44
4.2.2. Función De Coste

Los parámetros del modelo a identificar se inicializan de forma aleatoria y

posteriormente se optimizan basados en la minimización del criterio definido por las
ecuaciones:

Ecuación 4.2-2

| |

Ecuación 4.2-3

Ecuación 4.2-4

Donde es la salida del modelo NARMAX, y la salida del sistema real

ambas para una misma referencia,  es el error, es le fitness o función de coste,
este se calcula como la sumatoria del error al cuadrado o la sumatoria del valor
absoluto del error. La minimización de cualquiera de estas ecuaciones implica que la
salida del modelo NARMAX, tienda a ser igual a la del sistema dinámico
desconocido en su entorno de operación.

4.2.3. Operadores Genéticos

Como operadores genéticos se utilizan la Selección, el cruce y la mutación.

Selección se escogerá la población de la posterior generación de la siguiente

forma un individuo elite, este será el cromosoma con mejor (mínimo) fitness y este se

45
pasa a la siguiente generación, el resto de los hijos serán resultado del cruce y la
mutación.

El cruce se efectúa usando el operador media usado comúnmente para valores

reales como se menciona en [22]. Se seleccionan aleatoriamente dos individuos
distintos como padres y el promedio de estos dos será el nuevo individuo de la
población, se da una probabilidad de escogencia del 50 % al elite es decir que este
porcentaje de los cruces se realizan con el individuo elite de la población anterior con
el fin de conservar las características bondadosas de este.

La mutación se realiza con una probabilidad del 1%, es un algoritmo con cierto
grado de adaptabilidad; inicialmente se realiza una mutación normal es decir un
reemplazo aleatorio del 50% de los coeficientes del cromosoma; en cuanto el fitness
baje de cierto umbral, el algoritmo de mutación cambia a sumar un numero aleatorio
entre –0.1 y 0.1 al 50% de los coeficientes del cromosoma, esto con el fin de
optimizar la búsqueda local.

4.2.4. Implementación del algoritmo genético

El algoritmo es el siguiente.
I. Inicializar la población.
i. Se inicializa con valores aleatorios entre –2 y 2.
II. Proceso de los datos para cada individuo de la población
i. Se calcula la salida del modelo NARMAX usando la misma referencia
que se uso en la planta real y se calcula el error.
III. Se calcula la función de costo (fitness) para cada individuo de la población
IV. Se selecciona el individuo elite (menor fitness)
V. Se realiza cruce para generar la nueva población.
VI. Se realiza mutación con una probabilidad del 5% sobre los hijos del cruce
i. Cuando el fitness es menor que cierto valor la mutación cambia.

46
VII. Se genera la nueva población el elite es el primer individuo después se ubican
los individuos resultado del cruce y la mutación.
VIII. Con esta nueva población se regresa al procesado de los datos.
IX. Se repite el proceso por un determinado número de generaciones hasta que el
fitness tenga un valor adecuado.
Para realizar los cálculos se requiere de información sobre la respuesta de la
planta a alguna referencia, para obtener esta información se tomaron datos para 800
muestras, con cambios en el valor de referencia cada 100 muestras, con un tiempo de
muestreo de 10 ms.

4.2.5. Prueba Identificación de un Sistema

Con el fin de validar el funcionamiento del algoritmo de identificación se realizaron

pruebas usando los datos de un sistema conocido. El sistema usado tiene la forma
mostrada en la
Ecuación 4.2-5.

y k 0.6 · u k 1 0.1 · u k 2 0.5 · y k 1 0.1 · y k 2

Ecuación 4.2-5

Que corresponde a la forma digital de un sistema de segundo orden, la respuesta del

sistema a un escalón de amplitud 0.5 se presenta en la Figura 23.

Para la identificación del sistema se usaron únicamente los coeficientes a1, b1, a2, b2
del modelo, el AG tomo 19.775 generaciones en encontrar un modelo aproximado del
sistema y el fitness obtenido fue de 1 x 10–10, que corresponde al valor del criterio de
parada del algoritmo. En la Figura 24 se puede observar la evolución del valor de la
función de coste del individuo elite, en el transcurso de las generaciones. Como
resultado del cambio del algoritmo de mutación cuando fitness es menor a 1 x 10–3 se
observa que en la grafica un cambio en la forma del descenso, esto debido a que la

47
evolución se centra en torno al individuo elite produciendo cambios pequeños como
se menciono anteriormente.

0.7

0.6

0.5
Salida 

0.4

0.3

0.2

0.1

20 40 60 80 100
Numero de Muestras

Figura 23 – Respuesta del sistema para un escalón de valor 0.5.

48
 x 10 ‐3 
5 

4.5

4 

3.5

3 
Fitness 

2.5
Cambio en la
2 
mutación
1.5

1 

0.5

0
2000 4000 6000 8000 1000012000140001600018000
Generaciones

Figura 24 – fitness – Generaciones

Los coeficientes encontrados por el AG para el sistema son:

   5.9999 10      1.0002 10
  5.0005 10      9.9962 10

En la
Figura 25 y  
Figura 26 se puede apreciar la evolución del AG, en estas se puede observar la salida
estimada para un determinado número de generaciones, vemos que la salida estimada
se aproxima cada vez más a la salida real cuanto mayor es el número de generaciones.

49
 0.3

0.25

0.2

0.15

0.1 Salida estimada

0.05 Referencia
Salida
0 
5 10 5 20 25 30
muestras

Figura 25 – Salida estimada para 10 generaciones

0.25

0.2

0.15

0.1 Salida estimada
Referencia
0.05 Salida

5 10 15 20
muestras
 
Figura 26 – Salida estimada para 1000 generaciones

En la Figura 27 se observa la comparación de la señal de la planta real y la

salida del modelo identificado para algunos valores de la referencia, el modelo
coincide perfectamente.

50
 1 A 1 B
0.8 0.8
Salida

Salida
0.6 0.6

0.4 0.4

0.2 0.2

0 0
0 50 100 150 0 50 100 150
Muestras Muestras

Figura 27 – comparación de la señal de la planta real (A) y la salida del modelo

identificado (B)

4.2.6. Prueba Con El Sistema ACIM–dsPic30F

Para la identificación de este sistema, se tomaron datos de la salida en lazo

abierto para distintas referencias. La grafica de algunos de estos datos se puede
observar en la Figura 28.

Para este sistema se usara el modelo NARMAX mencionado anteriormente y

que tiene la forma de la Ecuación 4.2-1, el AG debe hallar 13 coeficientes para el
modelo. El AG se corrió durante 80000 generaciones para obtener un resultado
satisfactorio, el fitness del mejor individuo fue de 10.1351 y en la Figura 29, se puede
apreciar la evolución del fitness del individuo elite.

51
 1

0.8

0.6

0.4

referencia
0.2 salida

0
0 1 2 3 4

Figura 28 – Datos de la respuesta del sistema (ACIM–dsPic30F) para distintos

valores en la referencia.

18
17
16
15
14
13
12
11
10
9
0 2 4 6 8
4
x 10

Figura 29 – Evolución del fitness del individuo Elite

52
Los Coeficientes que el AG encontró para el sistema (ACIM–dsPic30F) fueron:

0.0145  0.1011
0.2099 0.0762
0.3892   0.0919
0.0227   0.0121
0.3737 0.0253
0.1489     0.1209 
0.0572

El modelo del sistema será entonces:

0.0145  0.2099 1 0.3892 1 0.0227 1

0.3737 2 0.1489  1 1
0.0572 1 2 0.1011 2 1
0.0762 2 2 0.0919 1 0.0253 1
0.0121 2 0.1209 2
Ecuación 4.2-6

En la Figura 30 se observa la comparación de los datos reales con la respuesta

del sistema identificado para diferentes entradas en una misma grafica, en la Figura
31 se observa la salida real y la estimada en dos graficas distintas, la salida estimada
coincide muy bien con la salida del sistema real como se puede ver en estas graficas.

53
 1
Entrada

0.8 Salida real

Salida estimada

0.6

0.4

0.2

0
0 1 2 3

Figura 30– Comparación de la salida estimada y la salida real del modelo del
sistema (ACIM–dsPic30F) para distintas referencias.

0.7 0.7
Entrada Salida Estimada
0.6 Salida Real 0.6 Entrada

0.5 0.5

0.4 0.4
Salida
Salida

0.3 0.3

0.2 0.2

0.1 0.1

0 0
0 1 2 3 0 1 2 3
Tiempo (s) Tiempo (s)

Figura 31 – Comparación de la salida estimada y la salida real del modelo del

sistema (ACIM–dsPic30F) para distintas referencias.

54
4.3. Controlador

Para regular la velocidad del sistema (ACIM – dsPic30F) se diseño un control

PID difuso, este se escogió dado que es un controlador típico.

La estructura digital de un controlador PID:

1 2 1
Ecuación 4.3-1

Donde representa la salida del controlador y representa la entrada y los

respectivos retrasos. El controlador difuso actuara sobre las constantes K1 K2 y K3
del PID, haciendo de este un controlador de ganancia programable [21]. La salida del
controlador PID digital es el voltaje que se enviara al sistema (ACIM – dsPic30F). Se
diseñara un sistema difuso independiente para cada variable del PID, K1, K2 y K3,
Estos tres sistemas difusos tienen la misma estructura, un diagrama de bloques del
sistema se muestra en la Figura 32.

El diseño del controlador difuso se puede dividir en cuatro partes:

Primero se deben definir el numero de variables de entrada y salida, también

dentro de qué intervalos varían estas, segundo se definen las etiquetas lingüísticas y
sus respectivas funciones de pertenencia estas se usaran en la fuzzificación y la
defuzzificación de entradas y salidas respectivamente, tercero un experto define la
base de reglas usando variables lingüísticas, cuarto se selecciona un método de
defuzzificación para la salida del sistema.

Variables de Entrada y Salida

Como variables de entrada se seleccionan: el error de velocidad (EV), el cambio

de EV (∆EV), estas varían en un universo de discurso enmarcado entre [–1, 1]. Como
variables de salida se tienen los valores de las tres constantes K1, K2 y K3, cada

55
constante es la salida de uno de los sistemas difusos. Y varían en un universo de
discurso enmarcado entre [–2, 2].

Figura 32 – Diagrama de bloques del sistema de control difuso

Etiquetas Lingüísticas y Funciones De Pertenencia

Inicialmente se definieron etiquetas lingüísticas para describir el comportamiento

de las variables y posteriormente se definieron funciones de pertenencia para cada
etiqueta, los parámetros de estas se establecen teniendo en cuenta que deben cubrir
todo el rango de variación de las variables, finalmente se adecuan manualmente
mediante un proceso de ensayo y error. Para las entradas se usaron funciones de
pertenencia trapezoidal y triangular, para la salida se usaron funciones de pertenencia
tipo singleton, el uso de este tipo de funciones para entradas y salidas se fundamenta
en que no requieren de operaciones complejas para sus cálculos y gracias a esto son
fáciles de implementar, y esto es una ventaja dado que este algoritmo se
implementara en un DSP.

Para EV se definieron cinco etiquetas lingüísticas, en la Tabla 4.3–1 se muestran

los parámetros de las funciones de pertenecía trapezoidal, junto a sus respectivas
etiquetas lingüísticas.

56
 Tabla 4.3–1
Codificación de las funciones de pertenencia trapezoidal para EV

Etiqueta Lingüística a b c d

Grande. (G) 2 1 0.75 0.5

Medio. (M) 1 0.5 0.3 0

Cero. (Z) – 0.05 0.01 0.01 0.05

Medio Negativo. (MN) –1 0.5 –0.3 0

Grande Negativo. (GN) –2 –1 –0.75 0.5

Para ∆EV se definieron también 5 etiquetas lingüísticas y sus respectivas

funciones de pertenencia trapezoidal en la tabla se presentan los parámetros
codificados y sus respectivas etiquetas.

Tabla 4.3–2
Codificación de las funciones de pertenencia trapezoidal para ∆EV

Etiqueta Lingüística a b c d

Grande. (G) 0.2 0.3 0.4 1

Medio. (M) 0 0.1 0.2 0.3

Cero. (Z) – 0.05 0 0 0.05

Medio Negativo. (MN) –0.3 –0.2 –0.1 0

Grande Negativo. (GN) –1 –0.4 –0.3 –0.2

En la Figura 33 se muestra la grafica de las funciones de pertenencia trapezoidal para

el error de velocidad EV,

57
 1

0.8 
GN  MN  Z M G 

0.6 

0.4 

0.2 

0
‐1 -0.5 0 0.5 1
Figura 33 – Funciones de pertenencia tipo trapezoidal para la variable EV

En la Figura 34 las funciones de pertenencia trapezoidal para el cambio del error de

velocidad ∆EV.

Para las variables de salida se usaran funciones de pertenencia de tipo Singleton,

para garantizar un fácil cálculo a la hora de obtener el resultado determinístico de la
variable de salida del controlador, además de disminuir el tiempo computacional
empleado para obtener el resultado, se definen 33 funciones de pertenencia, por lo
que se obvia la definición de etiquetas lingüísticas, cabe mencionar que esto se puede
hacer dado que posteriormente quien diseñara el sistema difuso será un AG, que no
trabaja con la información lingüística, si el diseño lo realiza un experto es necesario
definir una etiqueta o identificador para las funciones de pertenencia de salida.

58
 GN MN Z M G
1 

0.8

0.6

0.4

0.2

0 
‐1 ‐0.5 0 0.5 1 

Figura 34 – funciones de pertenencia tipo trapezoidal para la variable ∆EV

Solo se necesita de un número para definir una función de pertenencia de tipo

singleton. Las 33 funciones de pertenencia están igualmente espaciadas a intervalos
de 0.125, cubriendo todo el rango de variación de la salida. Esto se muestra en la
Figura 35.

Base De Reglas
Todo sistema difuso se fundamenta en reglas de inferencia del tipo:

Si A es x y B es y entonces C es z

Donde A, B, C son variables difusas y < x, y, z > son etiquetas como grande,
pequeño, alto, bajo, etc…

La base de reglas se codificara usando Memoria Asociativa Borrosa (FAM) que

en nuestro caso es una matriz de 5 x 5 como la de la Tabla 4.3–3

59
 1

0.8

0.6

0.4

0.2

0
‐2 ‐1 0 1 2
Figura 35 – funciones de pertenencia tipo singleton para la salida del sistema difuso

Tabla 4.3–3
FAM para el sistema de control difuso

Voltaje de Control Error de Velocidad EV

“u” GN MN Z M G

GN ng ng z m g
“Cambio en el error”

MN g m nm m z
∆EV

Z ng ng z m g

M g z N g m

G g z m m g

Debido a que en la salida se usan funciones de pertenecía tipo singleton, a cada

etiqueta se le asigna un valor numérico, lo que hace más fácil la codificación de la

60
base de reglas, o (las etiquetas [ng, nm, z, m, g] se usan a modo de ejemplo) para
calcular el grado de aplicación de las reglas se usa el operador ‘y’, por lo tanto la
matriz de reglas se interpreta así:

Por ejemplo para la fila MN y la columna Z: Si EV es MN (premisa1) y ∆EV es

Z (premisa2), entonces Salida es ng; de esta forma se tienen 25 reglas en cada matriz
y el grado de aplicación de cada regla se calcula usando la regla del producto que se
puede expresar como se muestra en la Ecuación 4.3-2

μr = μp1 · μp2
Ecuación 4.3-2

Donde μp1 es el nivel de pertenencia de la premisa 1 y μp2 es el nivel de pertenecía de

la premisa 2 y μr es el nivel de pertenencia de la salida.

El AG se encargara de encontrar los parámetros para las FAM de cada

controlador difuso, por lo que no es necesario definir exactamente estos valores en
este momento.

Defuzzificación
La defuzzificación es necesaria para trasladar la salida del controlador difuso a
una representación numérica, se usa el método de media de centros, usando funciones
de pertenencia singleton para la salida, que se puede representar matemáticamente
mediante la Ecuación 4.3-3.

∑
∑

Ecuación 4.3-3

Donde  son los centros de las funciones de pertenencia de la salida, como son
de tipo singleton estos equivalen a los valores de la FAM,  es la matriz de valores
de agregación que resulta de multiplicar los niveles de pertenencia del EV por los del

61
∆EV. Obteniendo la implicación de cada regla activada por las premisas de una
entrada en particular.

Con esto queda concluido el diseño de controlador difuso.

4.3.1. Algoritmo Controlador Difuso

Este algoritmo se implementa en MATLAB con el fin de realizar posteriormente

el ajuste de la FAM usando el AG, posteriormente el algoritmo se implementa en el
DSP TMS R2812. A continuación se describe paso a paso el algoritmo implementado

1. Se inicializan las funciones de pertenencia para EV y ∆EV

2. Se inicializan las FAM para K1, K2 y K3
3. Se define una referencia de velocidad para el sistema
4. Se inicializan las variables, contadores y constantes.
5. Se calcula la salida del sistema usando el modelo identificado anteriormente.
6. Se calcula el Error de velocidad como e(k) = Referencia – Salida.
7. Se calcula el ∆EV como de(k) = e(k) – e(k–1). Donde e(k) es el error en el
instante actual y e(k–1) el error en el instante anterior.
8. Se calcula los niveles de pertenencia de EV y de ∆EV

Para calcular los niveles de pertenencia, se usan dos funciones, la primera calcula
el nivel de pertenencia de un valor a una función trapezoidal usando las
ecuaciones relacionadas con esta. En MATLAB la función se llama pertrap y
recibe como parámetros un valor y la función de pertenencia codificada en un
vector de 4 elementos como se menciono anteriormente.

La segunda función usa la primera recursivamente para calcular el nivel de

pertenecía de el valor a las n funciones de pertenencia que se requiera esta
función retorna un vector donde se encuentran los niveles de pertenecía a cada

62
 función de las que se paso como parámetro. En MATLAB la función se llama
pertraps y recibe como parámetros un valor y un conjunto de funciones de
pertenecía, codificadas en una matriz en este caso de 4 x 5, la función retorna en
un vector de 5 componentes los niveles de pertenencia del valor a cada una de las
funciones de pertenencia. En la Figura 36 se observa un ejemplo de la operación
de esta función usando solo tres componentes, el valor de la variable E es –0.15,
este valor pertenece a dos funciones de las funciones trapezoidales, como se
muestra en la figura a la primera función pertenece en una proporción de 0.65 y a
la segunda función en una proporción de 0.7, el valor no pertenece a la tercera
función por lo que el valor correspondiente es 0, estos valores forman un vector
[0.65 0.7 0].

Figura 36 – Ejemplo de operación de la función pertaps

9. Calcula K1, K2 y K3 usando los niveles de pertenencia del EV, ∆EV y las FAM
correspondientes a cada constante.

Para realizar este cálculo se implemento la Ecuación 4.3-3, se hace uso de los
operadores para matrices que ofrece MATLAB, de esta forma la codificación
del controlador difuso es relativamente sencilla y usa pocas instrucciones.

63
 En la Figura 37 se muestra un diagrama de bloques de esta función, se
calcula la matriz de aplicación (A) μ multiplicando los vectores de
pertenencia de EV (PEV) y ∆EV (PDEV), se multiplica la matriz de
aplicación por la matriz de reglas (B) y se realiza la sumatoria de sus valores
(D), se realizan la sumatoria de los valores de la matriz de aplicación (C) y se
dividen estos dos resultados (E), la función en MATLAB se llama fuzzy y
recibe como parámetros las funciones de pertenencia de EV y ∆EV y la FAM
correspondiente y como salida entrega alguna de las constantes (K1, K2 y K3),
este función se ejecuta para cada una de las constantes.

Figura 37 – Diagrama de operación de la función fuzzy

10. Se calcula la acción de control usando la siguiente ecuación

1 0.1 · · 0.1 · · 1 0.1 · · 2

Ecuación 4.3-4

11. Se regresa al paso 5 cálculo de la salida de la planta.

En el cálculo de la acción de control se usa una constante (0.1) como

preescalador de las constantes K1, K2, K3, Esta constante se utilizo por facilidad en la
definición del universo de discurso de las variables su valor se encontró
empíricamente durante el proceso de experimentación.

64
4.4. Sintonización Del Controlador Difuso Mediante
Algoritmo Genético

Usando el AG lo que se busca es encontrar unas bases de reglas (FAM), que

logren un buen rendimiento del controlador difuso sobre el sistema (ACIM–
dsPic30F). Esto es lo que busca un experto que desarrolla un controlador difuso, lo
que este debe hacer de forma manual es someter el controlador a algunas situaciones
determinadas donde se sabe cuál es la respuesta que debería tener y evaluarla. Si ésta
no cumple con el comportamiento esperado se deben modificar los valores de las
bases de reglas o de las funciones de pertenencia y volver a evaluar, así hasta que se
logre dar con una distribución aceptable para el controlador. La automatización de
este proceso se vuelve una necesidad ya que se puede mejorar el tiempo de diseño y
también la calidad de éste puesto que un AG probará (quizás) muchas más
distribuciones para las FAM de las que probaría un experto en forma manual.

4.4.1. Diseño Del Algoritmo Genético

Inicialmente se deben definir los individuos de la población del AG y una

adecuada codificación para estos, se usara una codificación que difiere un poco de las
codificaciones ordinarias ya que no se usa una cadena de genes, sino que se usa una
matriz de 5×5 conformada por números reales entre –2 y 2, que representa a la
matriz de reglas (FAM) del controlador difuso, un ejemplo de esta se muestra en la
Tabla 4.4–1; Así una matriz será un individuo y la población estará conformada por
un conjunto de estas matrices de 5×5.

La función de coste (fitness)

La selección adecuada de la función de coste es un aspecto de suma importancia

ya que el AG optimiza el controlador siguiendo los parámetros definidos por esta, El
desempeño del controlador depende de la elección adecuada de una función de coste.

65
 Tabla 4.4–1
FAM ejemplo de codificación para el AG

Voltaje de Error de Velocidad EV

Control “u” GN MN Z M G

GN 0.5 0.3 –0.2 0.4 –0.7

“Cambio en el error”

MN 0.1 0.2 0 –0.5 0.4

∆EV

Z 0.2 –0.6 0 0.1 –0.3

M –0.2 0.8 –0.2 –0.1 0.7

G –0.5 0.1 0.2 0 0.4

En cualquier sistema de control, el error representa el aspecto fundamental, junto

a este se puede también considerar el cambio del error, y la energía invertida para
llevar el proceso a la referencia deseada, un sistema óptimo debe realizar esta tarea
con el mínimo costo de energía. Se usa entonces la siguiente función de costo:

· Δ ·

Ecuación 4.4-1

La expresión presentada se divide en tres partes:

1. la sumatoria de los cuadrados del error que se calcula como:

e = salida – referencia
2. la sumatoria de los cuadrados del cambio del error multiplicada por una constante
que pondera la importancia de esta, el cambio del error se calcula como:
“∆e = e(k) – e(k–1)”
3. la sumatoria de los cuadrados de la señal de control multiplicada por una
constante que pondera la importancia de esta.

66
 El AG establece que los mejores individuos tienen mayor probabilidad de
sobrevivir y heredar sus características genéticas a las próximas generaciones, así
los individuos que posean el menor valor de fitness serán los individuos elite.

Operadores Genéticos

Como operadores genéticos se utilizan El elitismo, el cruce y la mutación.

Como elite se selecciona únicamente al individuo con mejor (mínimo) fitness y este
se pasa a la siguiente generación.

El cruce se efectúa usando el operador media usado comúnmente para valores

reales, se seleccionan aleatoriamente dos FAM distintos como padres y el promedio
de estos dos será el nuevo individuo de la población, se da una probabilidad de
escogencia del 50 % al elite es decir que el 50 % de los cruces realizados se realizan
con el individuo elite de la población con el fin de conservar las características
bondadosas de este.

El algoritmo de mutación cambia la mitad de los valores de la FAM

aleatoriamente, el individuo elite tiene un 50 % de probabilidad de ser escogido para
mutación.

La selección de la población de la siguiente generación será 1 individuo elite, un

porcentaje estará conformado por los hijos resultados de cruce y otro porcentaje por
los hijos resultados de la mutación.

Implementación Del Algoritmo Genético

El algoritmo se implementa en MATLAB; se sintonizaran paralelamente las

FAM para las tres constantes del controlador PID: “K1, K2, K3” es decir un individuo
de la población está conformado por las tres FAM (FAMK1, FAMK2, FAMK3), La
población será de 40 individuos.

67
 Se plantea una señal de referencia que posee cambios suficientes para el
entrenamiento, la señal posee 2000 muestras y tiene cambios en la referencia cada
125 muestras.

Se define el número de individuos que será mutados (1/4 de la población) y el

número de individuos que será cruzados ((3/4) de la población menos 1 individuo),
solo se selecciona un individuo elite.

El algoritmo es el siguiente.

1. Inicializar la población.
Se inicializa cada matriz (FAMK1, FAMK2, FAMK3) de la población usando la
Ecuación 4.4-2 para generar cada elemento de la matriz, esta ecuación genera
números aleatorios en el intervalo [–2, 2] en pasos de 0.125; en esta ecuación
“rand” genera números aleatorios con distribución uniforme en el intervalo [0,1],
y la función “round” aproxima el numero al entero más cercano.

0.5 32
8
Ecuación 4.4-2 

2. Proceso de los datos para cada individuo de la población.

Se evalúa el desempeño del controlador difuso usando cada individuo de la
población sobre el sistema, se calcula el EV y el ∆EV y se almacenan en forma de
arreglos, al igual que la señal de control (u).
3. Se calcula la función de costo (fitness) para cada individuo de la población.
La función de costo se calcula usando la Ecuación 4.4-1.
4. Se selecciona el individuo elite (menor fitness).
5. Se realiza cruce.
6. Se realiza mutación.
7. Se genera la nueva población donde el elite es el primer individuo después en
orden se ubican los individuos resultado del cruce y después los de la mutación.

68
8. Con esta nueva población se regresa al proceso de los datos.
Todo esto se realiza por un determinado número de generaciones hasta que el fitness
tenga un valor adecuado, el código correspondiente al algoritmo genético y a las
funciones explicadas se encuentra en el anexo A.

4.4.2. Resultados del AG

Se diseño un AG que encuentra las FAM de un controlador PID difuso.

Entrenamiento
Se obtuvieron resultados satisfactorios en el control con 300 generaciones. En la
Figura 38 se puede observar la evolución del fitness del sistema con el transcurrir de
las generaciones. Las FAM encontrada por el algoritmo genético se presentan en la
Tabla 4.4–2 para K1, Tabla 4.4–3 para K2,
Tabla 4.4–4 para K3.

42

40

38
Fitness

36

34

32

0 50 100 150 200 250 300

GENERACION

Figura 38 – Evolución del fitness del individuo Elite

69
 Tabla 4.4–2
FAM K1

Error de Velocidad EV
K1
GN MN Z M G

GN 1.25 1.5 1.375 1.625 0.875

“Cambio en el error”

MN 1.125 –0.5 0.25 1.75 0.75

∆EV

Z 0.375 –1.5 –0.5 1.5 1.0

M 0.875 1.875 –1.5 1.125 0.375

G 0.25 0.875 –0.125 0.75 1.125

Tabla 4.4–3
FAM K2

Error de Velocidad EV
K2
GN MN Z M G

GN –0.75 1.625 0 0.375 1.375

“Cambio en el error”

MN 0.625 –1.25 –1.5 1.5 –2

∆EV

Z 0 –1.0 –0.625 –1.375 –0.625

M 1.375 –1.375 –0.5 –2.0 0.125

G –0.125 –0.875 0.875 0.75 –0.75

70
 Tabla 4.4–4
FAM K3

Error de Velocidad EV
K3
GN MN Z M G

GN 0.5 –1.25 0 1.875 1.375

“Cambio en el error”

MN 0 1.25 –0.625 0 –0.5

∆EV

Z 1.625 0.5 1.875 2 –0.875

M 1.5 –0.875 –0.75 –0.375 –1.75

G 0.125 –1.0 0.75 –1.625 0

Prueba Del Controlador PID Difuso En La Planta Simulada

El resultado de la simulación con un Tiempo de muestreo de 10ms usando

estas FAM para diferentes referencias se muestra en la Figura 39, podemos ver que
el controlador compensa satisfactoriamente la velocidad del sistema, llevándolo a la
referencia sin error también vemos que el tiempo de subida es rápido de alrededor de
15 muestras, 1.5 s. Lo que supone un buen desempeño del sistema.

71
 0.8

0.6

0.4

0.2

0
Salida
Referencia
‐0.2
0 100 200 300 400 500

Figura 39– Salida del modelo del sistema (ACIM–dsPic30F) controlada

4.5. Implementación Del Controlador En La Tarjeta

De Desarrollo eZdspTM R2812

La tarjeta de desarrollo eZdspTM R2812 se programa usando el software “Code

Composer Studio 3.1”, en esta plataforma se codificara el controlador difuso usando
lenguaje C, Los códigos de estas funciones se muestran en detalle en el Anexo A.

Para codificar el controlador difuso se diseñaron varias funciones a continuación se

describe y explica cada una de ellas en detalle:
float fuzzy (float *, float *, float *[]);
Función que realiza la inferencia difusa, recibe los niveles de pertenencia del delta de
error, el error y la matriz de reglas, retorna la acción de control, su funcionamiento es

72
igual que el de la función fuzzy implementada en MATLAB, un diagrama de bloques
de la operación de esta función es mostrado en la Figura 37.

void multimat (float *[], float *[], float *[]);

Función que multiplica dos matrices, recibe como parámetro un puntero a cada una
de las matrices y retorna un puntero a una matriz con el resultado de la
multiplicación.

void multivect (float *, float *, float *[]);

Función que multiplica dos vectores, recibe como parámetro un puntero a cada uno
de los vectores y retorna un puntero a una matriz con el producto de los dos vectores.

float pertrap ( float, float []);

Función que calcula el nivel de pertenencia de un valor a una función de pertenencia
trapezoidal, recibe como parámetro el valor y un vector con la codificación de los
valores de la función de pertenencia, retorna el nivel de pertenecía, funciona de igual
forma que la función “pertrap” elaborada en MATLAB.

void pertraps (float, float *[], float *);

Función que calcula el nivel de pertenencia de un valor a un conjunto de funciones de
pertenencia trapezoidal, recibe como parámetros el valor, una matriz con los
parámetros de la n funciones de pertenencia, y retorna un vector con los niveles de
pertenencia correspondientes a cada función, su funcionamiento es igual que el de la
función “pertraps” elaborada en MATLAB.

float sumamatriz (float *[], int, int);

Función que suma todos los elementos de una matriz, recibe como parámetros una
matriz y retorna un valor con la suma de los elementos de la matriz.

73
El algoritmo implementado es el mismo descrito en 4.3.1 teniendo en cuenta que al
usar el sistema real en el paso 5, los datos de la salida no son los del sistema simulado
sino los del sistema real. En el Anexo A se encuentran los códigos de las funciones y
del algoritmo de control.

En la Figura 40 y Figura 41, se muestran los resultados del control sobre el sistema
(ACIM – dsPic30F) usando el PID difuso con un tiempo de muestreo de 10 ms, la
operación del sistema controlado es satisfactoria, este sigue la referencia sin error y el
tiempo de subida es rápido al igual que en las simulaciones.

0.9

0.8

0.7

0.6

0.5

0.4

0.3

0.2 Salida
Referencia
0.1
0 100 200 300 400

Figura 40– Salida del sistema real controlado para distintos valores en la referencia.

74
 1
Salida
0.9 Referencia
0.8

0.7

0.6

0.5

0.4

0.3

0.2
100 200 300 400 500

Figura 41– Salida del sistema controlado para distintos valores en la referencia

4.5.1. Resultados de la Técnica De Evolución Diferencial

Implementada En El Proyecto 336

A continuación se presentan algunos de los resultados obtenidos en el proyecto 336

usando la técnica de evolución diferencial en línea.
Dado que la técnica funciona con un entrenamiento en línea, en las primeras muestras
el funcionamiento del control no es muy bueno, podemos ver en la Figura 42, que el
sistema a partir de la muestra 600 el sistema ya está entrenado, tiene un tiempo de
subida muy bueno y se mantiene en la referencia.
En comparación con el controlador difuso, la técnica de evolución diferencial
consiguió un mejor tiempo de subida. La desventaja es que durante las primeras
muestras su funcionamiento no es adecuado.

75
 Figura 42 – Referencia (línea punteada), velocidad alcanzada (línea continua),
pruebas con la técnica de evolución diferencial

4.6. Diseño Tarjeta Del Bus Can

CAN es un protocolo de comunicaciones desarrollado por la firma alemana Robert

Bosch GMBH, basado en una topología de bus para la transmisión de mensajes en
ambientes distribuidos, además ofrece una solución a la gestión de la comunicación
entre múltiples unidades centrales de proceso.
El protocolo de comunicaciones CAN proporciona beneficios como por ejemplo que
es un protocolo de comunicaciones normalizado, con lo que se simplifica y
economiza la tarea de comunicar subsistemas de diferentes fabricantes sobre una red
común o bus. También que el procesador anfitrión (host) delega la carga de
comunicaciones a un periférico inteligente, por lo tanto el procesador anfitrión
dispone de mayor tiempo para ejecutar sus propias tareas. Y por otro lado, al ser una
red multiplexada, reduce considerablemente el cableado y elimina las conexiones
punto a punto.

76
Ya que las tarjetas de desarrollo usadas en el proyecto contaban con la interfaz para el
bus can se diseñaron e implementaron los circuitos necesarios para la interfaz CAN,
En la tarjeta de desarrollo Microchip dsPIC30F la interfaz CAN se encuentra
fácilmente accesible. En forma de conector RS232, el circuito que lleva
implementado se muestra en la Figura 43.

Figura 43 – interfaz CAN de la tarjeta dsPic30F

En la tarjeta eZdspTM R2812, las líneas CANH y CANL para el bus CAN no está
directamente disponibles, se debe diseñar una tarjeta de interfaz para el bus can como
se muestra en la Figura 43, este se diseña basándose en el circuito integrado
SN65HVD230 el cual es un transceptor CAN diseñado por Texas Instrument [29].

77
Figura 44 – diagrama de bloques y circuito de interfaz para la tarjeta eZdspTM
R2812.

Figura 45 – Red CAN Típica

78
 Figu
ura 46 – Diseño del circuuito para la trasmisión mediante
m bus CAN

E la Figu
En ura 46 se muestra
m el diseño del cirrcuito impleementado, ell cual es muy
m
s
sencillo, la salida
s D y R (pines 1 y 4) del DSP
P se conectann a las entraadas D y R del
d
c
circuito, la alimentación
a n del circuitto es de 3.3 v (pines 2 y 3), y las salida CAN
NH
(
(pin7) y CANL(pin
C 8 se dejaan disponibbles para conexión
8), c directa al buus.
A
Adicionalme
ente se ubicca la resistenncia de 120 Ω (R1) quee debe ir en paralelo a las
l
l
líneas del bu
us CAN com
mo muestra la Figura 45, con un juumper para su conexiónn o
d
desconexión
n.

79
5. CONCLUSIONES

Se diseño e implemento un sistema de control difuso sintonizado fuera de línea

con algoritmos genéticos y se realizaron las simulaciones en MATLAB y pruebas
en el sistema real usando el DSP TMS320F2812.

Se diseño un AG para la identificación del sistema y se realizo la identificación

del sistema ACIM–dsPic30F, encontrando para este un modelo NARMAX de 13
coeficientes sin modelar el ruido, este modelo presento resultados satisfactorios
coincidiendo en gran forma con el comportamiento del sistema real.

Se diseño la estructura de un controlador difuso en MATLAB, de forma que las

matrices de reglas pudieran ser modificadas fácilmente.

Se elaboro un Algoritmo genético que haciendo uso del modelo del sistema
ACIM–dsPic30F y la estructura de un controlador difuso, encontró y optimizo las
matrices de reglas (FAM) requeridas por el controlador para tener un buen
desempeño.

Se realizo la simulación del sistema de control difuso sobre el modelo encontrado

y se obtuvieron resultados satisfactorios.

80
Se implemento el controlador difuso en la tarjeta de desarrollo eZdspTM R2812 y
se probo en el sistema real, se obtuvieron muy buenos resultados en el control de
velocidad del sistema.

Se diseño la tarjeta de interfaz para CAN, requerida para la conexión del tarjeta de
desarrollo eZdspTM R2812 al bus CAN usado para la transmisión de datos en el
sistema.

81
6. PROYECCIONES

Enfocados en los temas centrales de este proyecto, se pueden plantear desarrollos

futuros en el ámbito de los AG y de la Lógica Difusa, Aunque ya hay bastantes
desarrollos en el área de la inteligencia artificial a nivel mundial, en nuestro país es
poca la investigación y el desarrollo relacionado con este tema.

Inicialmente se podría plantear una optimización de varias de las características de los

algoritmos Genéticos, algunas alternativas pueden ser el uso de AG en paralelo [26],
la optimización de la velocidad de ejecución de los algoritmos mediante recocido
simulado, implementación de algoritmos de optimización basados en estrategias
evolutivas como la optimización de colonias de hormigas, programación genética,
algoritmos culturales etc.[27].

El uso de la lógica difusa en control proporciona varias ventajas con respecto a las
técnicas tradicionales, y es común escuchar de dispositivos electrónicos que
funcionan con lógica difusa, un trabajo futuro interesante es la implementación de
controladores difusos adaptativos, que son aun mejores que los controladores difusos
normales, el diseño e implementación de este tipo de controladores también es más
complejo.

Las técnicas de control inteligente como son los algoritmos genéticos y la lógica
difusa se pueden utilizar casi en cualquier tipo de sistema, en este proyecto se uso el
sistema ACIM– dsPic30F, de esta forma el control se puede hacer únicamente sobre
la velocidad del sistema, como desarrollo futuro se puede plantear un control del
torque y de la posición del ACIM, ya sea usando técnicas de control inteligente u

82
otras técnicas como el control vectorial, el desarrollo de este tipo de control se facilita
de cierta forma ya que la tarjeta de desarrollo dsPic30F proporciona acceso a las
medidas de corrientes y voltajes del ACIM. Con lo que se facilita la instrumentación
del sistema de control.

83
7. BIBLIOGRAFIA

[1] Goldberg David E. Genetic Algorithms in search optimization and machine

learning Massachusetts – Addison Wesley 1989.

[2] Holland, J. H. 1975. Adaptation in Natural and Artificial Systems. Press, Ann:
University of Michigan, Arbor, 1975.

[3] Blickle, T. and Thiele, L.. A comparison of selection schemes used in genetic
algorithms. Technical Report 11, Computer Engineering and Communication
Network Lab (TIK), Gloriastrasse 35, 8092 Zurich, Switzerland, 1995.

[4] L. A. Zadeh. From circuit theory to system theory. In Proc. IRE 50, pages
856–865, 1962.

[5] Garrido, S. Identificación, Estimación y Control de Sistemas No–lineales

mediante RGO, Universidad Carlos III, Leganés, 1999.

[6] K. Kristinson and G. Dumont. System identification and control using genetic
algorithms. IEEE Transactions on Systems, Man, and Cybernetics,
22(5):1033–1046, 1992.

84
[7] S. J. Flockton and M. J. White. Pole–zero system identification using genetic
algorithms. In Proceedings 5th International Conference on Genetic
Algorithms, pages 531–535. University of Illinois at Urbana Champaign,
USA, 17–21 July 1993.

[8] K. C. Tan, Y. Li, D. J. Murray–Smith, and K. C. Sharman. System

identification and linearization using genetic algorithms with simulated
annealing. Sheffield, UK., 1995

[9] Wang, Li–Xing. Adaptative Fuzzy Systems And Control. Prentice Hall, 1994.

[10] Martin del Brio, B. y Molina, S. Redes neuronales y sitemas difusos. Alfa
omega, 2002.

[11] Sugeno, J., Nishida, M. Fuzzy Control of model car. Fuzzy set and systems.
vol26, n° 2, pp. 151–164, 1985.

[12] Sugeno, J. Industrial Applications of fuzzy control, Elsevier, 1985.

[13] Passino, K., Yurkovich, S. Fuzzy Control. Addison Wesley, 1998

[14] Zhao, Z. Y., Tomizuka, M., Isaka, S. Fuzzy gain scheduling of PID
controllers. Procedings of the IEEE,23,5,1392–8, 1993

[15] Bruijin, C. devan der Wal, A.J. Fine – Tunning of a PID controller by fuzzy
logic. Fuzzy logic 93, A211–5, Sanfransisco,1993

85
[16] Kinzel, J. and Clawon, F. Modification of Genetic Algorithms For Designing
and Optimizing Fuzzy Controllers, Department of computer science technical
university of braunschweig D38106 braunschweig, Germany, 1994.

[17] Michael A. LEE and Hideyuki TAKAGI, Integrating Design Stages of Fuzzy
Systems using Genetic Algorithms. Proc. of the 2nd Int. Conf. on Fuzzy
Systems (FUZZ–IEEE’93), Vol.1, pp. 612–617, 1993.

[18] Mazon, I. Ramirez H., Ajuste De Controladores Difusos Mediante Algoritmos

genéticos. Ingenieria 9(1,2): 95–107, San José Costa Rica, 1999

[19] N.S.Gehlot and P.J.Alsina, “A Discrete Model Of Induction Motors For Real
Time Control Applications” IEEE Trans. Ind. Electron, Vol. 40, pp. 317–
325, June 1993.

[20] Velasco, J. and Magdalena, L. Genetic Algorithms in fuzzy control systems.

Universidad politécnica de Madrid, 1995.

[21] R. E. KING and A. STATHAKI2 Fuzzy Gain–Scheduling Control of

Nonlinear Processes, Department of Electrical & Computer Engineering
University of Patras, Patras 26110 Disponible http//:www.lar.ee.upatras.gr

[22] Posse, M. Introducción a los Algoritmos Genéticos, disponible en

http://sabia.tic.udc.es/~mgestal.

[23] dsPICDEM™MC1 Motor Control development BoardUser’s Guide

Microchip Technology Inc. – 2003 available in “www.microchip.com”.

86
[24] eZdspTM R2812 USB_ tech_ref. available in “www.spectrumdigital.com”

[25] AN984 – An Introduction to AC Induction Motor Control Using the dsPIC30F

MCU. Microchip Technology Inc. – 2005, available in www.microchip.com

[26] Cantu–Paz E. ”Efficient And Accurate Parallel Genetic Algorithms”,

Lawrence Livermore National Lab, U.S.A.,2001.

[27] Haupt, R. L. and Haupt, S. E.” Practical Genetic Algorithms” , John Wiley
& Sons, INC., Publication, 1998

[28] C281x C/C++ Header Files and Peripheral Examples Quick Start, Version
1.11, September 26, 2007.

[29] Datasheet 3.3–V Can Transceivers, SN65HVD232, revised May 2005. Texas
Instrument.

87
ANEXO 1

Programas en MATLAB

Algoritmo Genético Para La Identificación de Sistemas

clear all; close all; 
% Algoritmo Genético 
c   13;     % cantidad coeficientes  
N   40;     % Tamaño De La Población 
g   80000;   % numero de generaciones 
pe   0.5;    % probabilidad de escogencia del elite para cruce y mutación 
pm   0.01;    % probabilidad de nutación 
m 1; 
y1    textread 'data.dat' ;       % se lee el archivo con los datos de la salida 
y1   y1/130;  
NN   800;      % Longitud del vector de datos 
Y   seros  NN,1 ; 
z    0.9 0.5 0.3 0.7 0.2 0.8 0.3 0.4 ; 
u      z 1 *ones 1,100 , z 2 *ones 1,100 , z 3 *ones 1,100 ,... 
           z 4 *ones 1,100 , z 5 *ones 1,100 , z 6 *ones 1,100 ,... 
           z 7 *ones 1,100 , z 8 *ones 1,100 ;  %se genera la señal de entrada 
 
%se genera aleatoriamente la población 
for n   1:N 
    for i   1:c 
      coeficientesp n,i     rand–0.5 *2; 
    end 
end 
 

88
while m   g,   % condición de parada se detiene al completar el numero de  
 % generaciones 
 
%Evalúa la población actual 
    for n   1:N 
        coef   coeficientesp n,: ; 
 
        for k   4:NN, 
            y k    coef 1 coef 2 *u k–1 coef 3 *u k–2 coef 4 *y k–1 ...   
                     coef 5 *y k–2 coef 6 *y k–1 *u k–1 coef 7 *y k–1 *u k–2 ... 
                     coef 8 *y k–2 *u k–1 coef 9 *y k–2 *u k–2 ... 
                     coef 10 *u k–1 *u k–1 *coef 11 *u k–2 *u k–2 ... 
                     coef 12 *y k–1 *y k–1 coef 13 *y k–2 *y k–2 ; 
        end 
         
        %calcula el error 
        err   y – y1; 
        % Calcula el fitness. 
        fitness n    sum abs err ; 
    end 
 
    %Selecciona el elite. 
     elite,ind    min fitness ; 
    %genera la nueva población. 
    coeficientesp 1,:    coeficientesp ind,: ; 
    E m    elite; 
    m m 1   %incrementa el contador de generaciones. 
    p 1; 
 
% Realiza cruce promedio de dos individuos sobre toda la población. 
    for i   1:N 
         p   p 1; 
         i1   ceil rand*N ; 
         i2   ceil rand*N ;  %escoge dos individuos aleatoriamente para cruce 
         if rand pe  
             i1 1;  %eventualmente se escoge el elite para cruce  
         end 
         while  i1   i2  

89
             i2   ceil rand*N ;  %evita que se seleccione el mismo individuo 
         end 
         ind1   coeficientesp i1,: ; 
         ind2   coeficientesp i2,: ; 
 
         coeficientesp p,:    0.5* ind1 ind2 ;   
    end 
     
    p 1; 
     
% realiza mutación 
    for i   1:N 
        p   p 1; 
        coeficiente   coeficientesp p,: ; 
        if  rand pm  
            if  rand pe  
              q   p;    %escoge el elite para cruce con una probabilidad de 50% 
              p   1; 
              coeficiente   coeficientesp p,: ; 
              p   q; 
            end 
            for  i1 1:c  
                 if  rand 0.5  
                     coeficiente i1     rand–0.5 *2; % realiza la mutación. 
                 end 
            end 
         end 
         coeficientesp p,:    coeficiente; 
    end 
end 
 
coef   coeficientesp 1,: ;  % almacena el mejor individuo en coef 

Funciones requeridas para el controlador difuso

 
–––––––––––––––––––––––pertrap––––––––––––––––––––––– 
 
function  NP    pertrap  valor, FP    

90
% retorna en NP el nivel de pertenencia del  valor a FP 
        
        if  valor   FP 4  ||  valor   FP 1  
            NP   0; 
        elseif  valor    FP 2  &  valor   FP 3  
            NP   1; 
        elseif  valor   FP 2  &  valor   FP 1  
            NP    valor – FP 1  /  FP 2  – FP 1 ; 
        elseif  valor   FP 4  &  valor   FP 3  
            NP    valor – FP 4  /  FP 3  – FP 4 ; 
        end 
 
–––––––––––––––––––––––pertraps––––––––––––––––––––––– 
 
function  Npert    pertraps  valor,FPS  
 
% retorna en Npert las pertenecías de valor a las funciones almacenadas en la 
% matriz FPS  
        
N   size FPS ; 
 
for i 1:N 1 , 
    Npert i    pertrap  valor,FPS i,: ; 
end  
 
–––––––––––––––––––––––fuzzy––––––––––––––––––––––– 
% toma como parámetros la pertenencia del error y el cambio de error y la FAM  
% y entrega el nivel de pertenencia de la salida. 
 
function  u    fuzzy perterror, pertdeltaerror, FAM  
               
U perterror'*pertdeltaerror; 
u sum sum U*FAM /sum sum U ; 
 
–––––––––––––––––––––––controlador difuso––––––––––––––––––––––– 
 
Se  presenta  la  estructura  completa  del  controlador  difuso,  al  momento  de 
realizar la sintonización, no se inicializan las FAM.  el archivo se llama “sistema” 

91
 
NN 2001; 
u zeros NN,1 ; 
y zeros NN,1 ; 
 
coef; 
% referencia  
ref 0.3*ones 1,126 , 0.6*ones 1,125 , 0.4*ones 1,125 ,... 
         0.7*ones 1,125 , 0.2*ones 1,125 , 0.8*ones 1,125 ,... 
         0.5*ones 1,125 , 0.9*ones 1,125 , 0.65*ones 1,125 ,... 
         0.45*ones 1,125 ,0.75*ones 1,125 ,0.55*ones 1,125 ,... 
         0.15*ones 1,125 , 0.35*ones 1,125 ,0.65*ones 1,125 ,0.25*ones 1,125 ; 
 
% definición de FAM  
FAMK1          2.000,  1.375,   0.750,   1.125,   1.125   
              0.500,  0.500, –0.375, –0.250, –0.625 
             0.875,  0.125,   1.000,   1.875,   0.625 
              1.750,  0.375,   1.000,   0.750, –1.250 
                    –0.125,  0.875,   1.750,   1.375,   0.625 ; 
            
FAMK2   –1.250,   0.125, –0.750,   1.125,   0.625 
         0.125,   1.375,   0.250, –1.000, –1.250 
         1.750, –1.750, –0.750,   2.000,   1.750 
                    0.250, –0.500, –0.250, –0.625,   0.500 
                    1.375,   0.500, –0.875, –2.000,   0.375 ; 
 
FAMK3    –1.375, –1.625, –0.875,   1.375,  1.125 
                  –1.125,   0.000, –0.875, –0.500,   1.875 
                 –1.500, –1.500, –1.375, –0.125, –1.375 
          0.750, –0.125,   0.500, –1.750,   0.000 
        –0.500, –1.375,   1.500, –0.875,   1.750 ; 
  
% definición de funciones de pertenencia 
FPe        –2.00    –1.00   –0.75   –0.50; 
     –1.00    –0.50   –0.30     0.00; 
     –0.05    –0.01     0.01     0.05; 
       0.00      0.30     0.50     1.00; 
       0.50      0.75     1.00     2.00 ; 

92
    
FPde      –1.00  –0.40    –0.30    –0.20; 
      –0.30  –0.20    –0.10     0.00; 
      –0.05    0.00      0.00     0.05; 
        0.00    0.10      0.20     0.30; 
        0.20    0.30      0.40     1.00 ; 
     
for k   3:NN, 
    % cálculo de la salida del sistema 
    y k    coef  1 coef 2 *u k–1 coef 3 *u k–2 coef 4 *y k–1 ...   
                coef 5 *y k–2 coef 6 *y k–1 *u k–1 ... 
                coef 7 *y k–1 *u k–2 coef 8 *y k–2 *u k–1 ... 
                coef 9 *y k–2 *u k–2 coef 10 *u k–1 *u k–1 ... 
                coef 11 *u k–2 *u k–2 coef 12 *y k–1 *y k–1   ... 
                coef 13 *y k–2 *y k–2 ;  
    
   if  y k 1 , y k 1;end 
   if  y k –1 , y k –1;end  % validación útil durante la sintonización 
    
    e k    ref k – y k ;    % cálculo del error 
    
    if  e k 1 , e k 1; end 
    if  e k –1 , e k –1; end % validación útil durante la sintonización 
    
    de k  e k  – e k–1 ;   % calculo de cambio de error 
       
    perterror   pertraps e k ,FPe ;         % cálculo de las pertenencias 
    pertdeltaerror   pertraps de k ,FPde ;  % cálculo de las pertenencias 
         
    % calulo de las tres constantes mediante el sistema difuso. 
    K1  fuzzy  perterror, pertdeltaerror, FAMK1 ; 
    K2  fuzzy  perterror, pertdeltaerror, FAMK2 ; 
    K3  fuzzy  perterror, pertdeltaerror, FAMK3 ; 
     
    % cálculo de la señal de control 
    u k    u k–1    0.1*K1*e k    0.1*K2*e k–1    K3*0.1*e k–2 ; 
end 
 

93
 –––––––––––––––––––––––Algoritmo Genético––––––––––––––––––––––– 
 
clear all; close all 
 
NN 2001; 
u zeros NN,1 ; 
y zeros NN,1 ; 
 
ref 0.3*ones 1,126 , 0.6*ones 1,125 , 0.4*ones 1,125 ,... 
         0.7*ones 1,125 , 0.2*ones 1,125 , 0.8*ones 1,125 ,... 
         0.5*ones 1,125 , 0.9*ones 1,125 , 0.65*ones 1,125 ,... 
         0.45*ones 1,125 ,0.75*ones 1,125 ,0.55*ones 1,125 ,... 
         0.15*ones 1,125 , 0.35*ones 1,125 ,0.65*ones 1,125 ,0.25*ones 1,125 ; 
 
coef; 
 
g 1     % numero de generaciones. 
N   20; % tamaño de la población. 
ncruces   N/4;      % numero de cruces. 
nmut    3*N/4 –1;   % numero de mutaciones. 
l 13;     %  número de elementos a mutar en cada individuo. 
m   0; 
 
% definición de funciones de pertenencia 
FPe        –2.00    –1.00   –0.75   –0.50; 
     –1.00    –0.50   –0.30     0.00; 
     –0.05    –0.01     0.01     0.05; 
       0.00      0.30     0.50     1.00; 
       0.50      0.75     1.00     2.00 ; 
    
FPde      –1.00  –0.40    –0.30    –0.20; 
      –0.30  –0.20    –0.10     0.00; 
      –0.05    0.00      0.00     0.05; 
        0.00    0.10      0.20     0.30; 
        0.20    0.30      0.40     1.00 ; 
 
% se genera la población, 20 individuos de 5x5 de cada FAM 
 

94
for n 1:N 
for i 1:5 
    for j  1:5 
        FAMpK1 i, j, n round rand–0.5 *32 /8; 
    end 
end 
end 
 
for n 1:N 
for i 1:5 
    for j  1:5 
        FAMpK2 i, j, n round rand–0.5 *32 /8; 
    end 
end 
end 
 
for n 1:N 
for i 1:5 
    for j  1:5 
        FAMpK3 i, j, n round rand–0.5 *32 /8; 
    end 
end 
end 
 
while m   g, 
 
%Evalúa la población FAMs actual 
 
m   m   1 
ifampk1   1; 
ifampk2   1; 
ifampk3   1; 
 
    for n   1:N 
        %se inicializan las FAM con los individuos correspondientes a  cada 
        %iteración 
        FAMK1   FAMpK1 :, :, n ; 
        FAMK2   FAMpK2 :, :, n ; 

95
        FAMK3   FAMpK3 :, :, n ; 
 
        Sistema;     %se ejecuta el controlador  
         
        % se calcula el fitness usando el vector e, de y u 
 
        fitness  n    1*sum e.*e 2*sum de.*de 0.085*sum u.*u ;  
 
    end  
 
% Selecciona el elite 
elite, ind    min fitness ; 
E m elite; 
FAMpK1 :, :, 1    FAMpK1 :, :, ind ; 
FAMeliteK1   FAMpK1 :, :, ind ; 
FAMpK2 :, :, 1    FAMpK2 :, :, ind ; 
FAMeliteK2   FAMpK2 :, :, ind ; 
FAMpK3 :, :, 1    FAMpK3 :, :, ind ; 
FAMeliteK3   FAMpK3 :, :, ind ; 
 
ifampk1   ifampk1 1; % posición nuevo individuo en la población 
ifampk2   ifampk2 1; 
ifampk3   ifampk3 1; 
 
% genera la nueva población 
 
% Realiza cruce promedio de dos individuos 
    for i   1:ncruces 
         i1   ceil rand*N ; 
         i2   ceil rand*N ;  
         if rand 0.5  
             i1 1;      %probabilidad de cruzar con elite 
         end 
         while  i1   i2  
             i2   ceil rand*N ; % evita que se repita el individuo   
         end 
         ind1   FAMpK1 :, :, i1 ; 
         ind2   FAMpK1 :, :, i2 ; 

96
 
%calcula  el  promedio  y  aproxima  teniendo  en  cuenta  el  intervalo  de  0.125  que 
%hay entre los individuos. 
 
         FAMnk1   round 0.5* ind1*8 ind2*8 /8;  
         FAMpK1 :, :, ifampk1    FAMnK1; 
         ifampk1   ifampk1 1; 
    end 
 
    for i   1:ncruces 
         i1   ceil rand*N ; 
         i2   ceil rand*N ;   
         if rand 0.5  
             i1 1; 
         end 
         while  i1   i2  
             i2   ceil rand*N ;   
         end 
         ind1   FAMpK2 :, :, i1 ; 
         ind2   FAMpK2 :, :, i2 ; 
         FAMnK2  round 0.5* ind1*8 ind2*8 /8; 
         FAMpK2 :, :, ifampk2    FAMnK2; 
         ifamk2   ifampk2 1; 
    end 
 
    for i   1:ncruces 
         i1   ceil rand*N ; 
         i2   ceil rand*N ;   
         if rand 0.5  
             i1 1; 
         end 
         while  i1   i2  
             i2   ceil rand*N ;   
         end 
         ind1   FAMpK3 :, :, i1 ; 
         ind2   FAMpK3 :, :, i2 ; 
         FAMnK3  round 0.5* ind1*8 ind2*8 /8 ; 
         FAMpK3 :, :, ifampk3    FAMnK3; 

97
         ifamk3   ifampk3 1; 
    end 
 
% realiza mutación 
     for i   1:nmut 
         i1   ceil rand*N ;    %selecciona un individuo aleatoriamente 
         if rand 0.5  
             i1 1;                     % el 50% de las veces es probable que seleccione el elite 
         end 
         FAMnK1   FAMpK1 :, :, i1 ; 
         for i   1:l 
              % selecciona los elementos de cada matriz aleatoriamente y los cambia 
              i4   ceil rand*5 ; 
              i5   ceil rand*5 ; 
              FAMnK1  i5 , i4     round rand–0.5 *32 /8; 
         end 
        FAMpK1 :, :, ifampk1    FAMnK1; 
        ifampk1   ifampk1 1; 
    end 
 
 
    for i   1:nmut 
         i1   ceil rand*N ; 
         if rand 0.5  
             i1 1; 
         end 
         FAMnK2   FAMpK2 :, :, i1 ; 
         for i   1:l 
              i4   ceil rand*5 ; 
              i5   ceil rand*5 ; 
               FAMnK2  i5 , i4    round rand–0.5 *32 /8; 
         end 
        FAMpK2 :, :, ifampk2    FAMnK2; 
        ifampk2   ifampk2 1; 
    end 
 
 
    for i   1:nmut 

98
 
         i1   ceil rand*N ; 
         if rand 0.5  
             i1 1; 
         end 
         FAMnK3   FAMpK3 :, :, i1 ; 
         for i   1:l 
              i4   ceil rand*5 ; 
              i5   ceil rand*5 ; 
              FAMnK3  i5 , i4    round rand–0.5 *32 /8; 
         end 
         FAMpK3 :, :, ifampk3    FAMnK3; 
         ifampk3   ifampk3 1; 
    end 
 
end 
FAMK1 FAMeliteK1 
FAMK2 FAMeliteK2 
FAMK3 FAMeliteK3 
plot E ; 
 
 
Programas en C ++ implementados en el Code Composer Studio

Se implementaron todos los programas necesarios para realizar el control difuso 
de  la  velocidad  del  ACIM.  a  continuación  se  presentan  los  códigos  de  todas  las 
funciones utilizadas. 
––––––––––––––––pertrap–––––––––––––––– 
//función  que  calcula  el  nivel  de  pertenencia  de  un  valor  a  una  función 
trapezoidal  
// Requiere: FP que son los parámetros de la función de pertenencia, valor que 
es del cual se quiere conocer un nivel de pertenencia 
 
// Retorna: el nivel de pertenencia de valor 
 
float pertrap  float valor, float FP  
 
 

99
static float NP; //Nivel de pertenencia 
 
if valor   FP 3  ||  valor   FP 0  
  NP   0.0;  
 
if  valor    FP 1  &  valor   FP 2  
  NP   1.0;  
             
if  valor   FP 1  &  valor   FP 0  
  NP    valor – FP 0  /  FP 1  – FP 0 ;  
         
if  valor   FP 3  &  valor   FP 2  
  NP    valor – FP 3  /  FP 2  – FP 3 ;  
            
return  NP ; 
 
 
––––––––––––––––pertraps–––––––––––––––– 
//función  que  calcula  el  nivel  de  pertenecía  de  un  valor  a  un  conjunto  de 
funciones trapezoidales 
//requiere  valor,  FPS  que  es  una  matriz  con  los  valores  de  las  funciones 
trapezoidales, Npert es un vector donde se almacena los niveles de pertenecía a 
cada función de la matriz 
 
void pertraps float valor, float *FPS , float *Npert  
 
int i; 
for i 0;i 5;i  
   
     Npert i    pertrap valor,FPS i ; 
   
 
 
–––––––––––––––– multivect –––––––––––––––– 
 
//función que multiplica dos vectores y el resultado lo retorna en una matriz 
//como  parámetros  recibe  los  dos  vectores  y  la  matriz  donde  se  guardara  el 
resultado 

100
 
void multivect float *Y, float *Z, float *M  
 
int i,j; 
for i 0;i 5;i  
   
  for j 0;j 5;j  
     
    M i j    Y i *Z j ; 
     
   
 
 
–––––––––––––––– multimat –––––––––––––––– 
 
//función  que  multiplica  dos  matrices  de  5*5  y  el  resultado  lo  pone  en  una 
tercera matriz 
//recibe como parámetros tres matrices A, B, C  
//retorna en C  la multiplicación A x B 
 
void multimat float *A , float *B , float *C  
 
int i,j,k; 
float f 0; 
 
for i 0;i 5;i  
   
  for j 0;j 5;j  
     
    f 0; 
    for k 0;k 5;k  
       
      f A i k *B k j ; 
       
    C i j    f; 
     
   
 

101
 
–––––––––––––––– sumamatriz –––––––––––––––– 
 
//función  que  suma  los  elementos  de  un  matiz  de  nfilas  x  mcolumnas  y  el 
resultado lo retorna como un flotante. 
//recibe como parámetro una matriz C. 
//retorna en la suma como flotante. 
 
float sumamatriz float *X ,int nfil, int ncol  
 
int i,j; 
float sum 0; 
for i 0;i nfil;i  
   
  for j 0;j ncol;j  
     
    sum  sum X i j ; 
     
   
return sum; 
 
 
 
–––––––––––––––– fuzzy –––––––––––––––– 
 
//Función que realiza la inferencia difusa 
//recibe  los  niveles  de  pertenencia  del  delta  de  error  y  el  error  y  la  matriz  de 
reglas 
//retorna la acción de control 
 
float fuzzy float *perterror, float *pertdeltaerror, float *FAM  
 
float U 5 5 ; 
float C 5 5 ; 
float *ptU 5 ; 
float *ptC 5 ; 
float aux1 0,aux2 0; 
float u; 

102
int i; 
 
for  i 0;i 5;i  
  ptU i U i ; 
for  i 0;i 5;i  
  ptC i C i ; 
 
multivect  perterror,pertdeltaerror,ptU ; 
 
multimat  ptU,FAM,ptC ; 
aux1 sumamatriz  ptC,5,5 ; 
aux2 sumamatriz  ptU,5,5 ; 
u aux1/aux2; 
return u; 
 

Para la programación de los periféricos del DSP2812 se uso como referencia el 
documento  28  y los archivos de ejemplo proporcionados con este. 
Esta  ayuda  contiene  los  archivos  de  cabecera  para  los  dispositivos  periféricos 
del  DSP281x  y  algunos  proyectos  de  ejemplo  que  facilitan  escribir  en  C/C  
para los Texas Instruments ‘281x DSPs. El código puede ser utilizado como una 
herramienta educativa o como plataforma de desarrollo para las aplicaciones del 
usuario. 
 
Las  siguientes  funciones  se  encuentran  en  el  ejemplo  “DSP281x  Device  SCI 
Echoback”,  que  explica  la  configuración  de  los  puertos  para  transmisión  serial 
Mostrado en  28 , en la Figura 47 se muestra un diagrama del proceso que ejecutan los 
programas de ejemplo para DSP281x. 

103
 Figura 47 – Diagrama de funcionamiento de los programas de ejempló para el 
DSP281x 

––––––Funciones necesaria para la transferencia de datos serial–––––– 

/ /Test 1,SCIA  DLB, 8–bit word, baud rate 0x000F, default, 1 STOP bit, no parity 
// Función que inicializa el Puerto serial. 
void scia_echoback_init  
 
    // Note: Clocks were turned on to the SCIA peripheral 
    // in the InitSysCtrl  function 
 
   SciaRegs.SCICCR.all  0x0007;      // 1 stop bit,  No loopback 
                                            // No parity,8 char bits, 

104
                                           // async mode, idle–line protocol 
  SciaRegs.SCICTL1.all  0x0003;     // enable TX, RX, internal SCICLK, 
                                          // Disable RX ERR, SLEEP, TXWAKE 
  SciaRegs.SCICTL2.all  0x0003; 
  SciaRegs.SCICTL2.bit.TXINTENA  1; 
  SciaRegs.SCICTL2.bit.RXBKINTENA  1; 
 
  SciaRegs.SCIHBAUD     0x0001;  // 9600 baud @LSPCLK   37.5MHz. 
  SciaRegs.SCILBAUD     0x00E7; 
 
  SciaRegs.SCICTL1.all  0x0023;  // Relinquish SCI from Reset 
 
 
// Transmit a character from the SCI – transmite un caracter por el puerto serial  
void scia_xmit int a  
 
    while  SciaRegs.SCIFFTX.bit.TXFFST !  0    
    SciaRegs.SCITXBUF a; 
 
// Transmit a string from the SCI – transmite una cadena 
void scia_msg char * msg  
 
    int i; 
    i   0; 
    while msg i  !  '\0'  
      
        scia_xmit msg i ; 
        i ; 
      
 
 
// Initalize the SCI FIFO ‐ inicializa el SCI FIFO 
void scia_fifo_init  
 
    SciaRegs.SCIFFTX.all 0xE040; 
    SciaRegs.SCIFFRX.all 0x204f; 
    SciaRegs.SCIFFCT.all 0x0; 
 

105
 ––––––––––––––función principal para control del sistema–––––––––––––– 
#include  stdio.h  
#include  math.h  
// DSP281x Headerfile Include File 
#include "DSP281x_Device.h"      
#include "DSP281x_Examples.h"  
#include "FAMPID_fin gen.h" // contiene la definición de las FAM 
 
//declaración de las funciones 
float fuzzy float *, float *, float * ; 
void multimat float * , float * , float * ;  
void multivect float *, float *, float * ; 
float pertrap  float,  float  ; 
void pertraps float, float * , float * ; 
float sumamatriz float * , int, int ; 
 
void scia_fifo_init ;     
void scia_msg char * ;     
void scia_xmit int a ;     
void scia_echoback_init ; 
void Gpio_select void ; 
 
char Y 800 ; 
 
void main  
 
// Step 1. Initialize System Control: 
// PLL, WatchDog, enable Peripheral Clocks   
// This example function is found in the DSP281x_SysCtrl.c file. 
  InitSysCtrl ; 
// Step 2. Initalize GPIO: 
// This example function is found in the DSP281x_Gpio.c file and 
// illustrates how to set the GPIO to it's default state. 
// For this example use the following configuration: 
  EALLOW; 
  GpioMuxRegs.GPFMUX.all 0x0030;  // Select GPIOs to be Scia pins 
                                            // Port F MUX – x000 0000 0011 0000 
  EDIS; 
// Step 3. Clear all interrupts and initialize PIE vector table: 

106
// Disable CPU interrupts 
  DINT; 
 
// Initialize PIE control registers to their default state. 
// The default state is all PIE interrupts disabled and flags 
// are cleared. 
// This function is found in the DSP281x_PieCtrl.c file. 
// InitPieCtrl ; no required for this example 
 
// Disable CPU interrupts and clear all CPU interrupt flags: 
   IER   0x0000; 
   IFR   0x0000; 
// Initialize the PIE vector table with pointers to the shell Interrupt 
// Service Routines  ISR . 
// This will populate the entire table, even if the interrupt 
// is not used in this example.  This is useful for debug purposes. 
// The shell ISR routines are found in DSP281x_DefaultIsr.c. 
// This function is found in DSP281x_PieVect.c. 
//InitPieVectTable ;; no required for this example 
 
// Step 4. Initialize all the Device Peripherals: 
// This function is found in DSP281x_InitPeripherals.c 
// InitPeripherals ; // Not required for this example 
 
// Step 5. User specific code: 
   
    scia_fifo_init ; // Initialize the SCI FIFO 
    scia_echoback_init ; // Initalize SCI for echoback 
   
int i,j5,j6,conta,salida 1;  //contador 
int a 0; 
int dat_sal 0,dat_ent 0; 
float r_k 0;      //referencia escalón  
char car2; 
float u_k 0,u_k_1 0;         //señales de control en el instante actual y anterior 
float e_k 0,e_k_1 0,e_k_2 0;   
//señales de error en el instante actual y anterior 
float y_k 0,de_k 0;   //salida, delta de error y  en el instante actual 
float K1 0,K2 0,K3 0;  //constantes del controlador PID 
 

107
float perterror 5 ;    //niveles de pertenencia del error 
float pertdeltaerror 5 ;  //niveles de pertenencia del delta de error 
 
//punteros 
float *pt1; 
float *pt_e 5 ; 
float *pt_de 5 ; 
float *pt_FAM_k1 5 ; 
float *pt_FAM_k2 5 ; 
float *pt_FAM_k3 5 ; 
 
//valores para las funciones de pertenencia del error 
float Fp_e 5 5 –5000,   –1,   –0.75,  –0.5  ,  
              –1,   –0.5,   –0.3,   0 , 
                  –0.05,     –0.01,   0.01,   0.05 ,  
               0,    0.3,    0.5,   1    , 
               0.5,      0.75,    1,      5000 ; 
 
//valores para las funciones de pertenencia del delta de error 
float Fp_de 5 5 –5000,   –0.4,    –0.3,    –0.2,  ,    
                –0.3,    –0.2,    –0.1,     0,    ,   
                –0.05,     0,       0,       0.05  ,   
                 0,       0.1,     0.2,     0.3,  , 
                 0.2,     0.3,     0.4,     5000 ; 
 
            
//inicialización de los punteros 
for  i 0;i 5;i  
  pt_e i Fp_e i ; 
 
for  i 0;i 5;i  
  pt_de i Fp_de i ; 
 
for  i 0;i 5;i  
  pt_FAM_k1 i FAM_k1 i ; 
 
for  i 0;i 5;i  
  pt_FAM_k2 i FAM_k2i ; 

108
 
for  i 0;i 5;i  
  pt_FAM_k3 i FAM_k3 i ; 
 
conta 0; 
 
do  
  scia_xmit 45 ; // se envía un voltaje para activar el puerto serial 
  // Wait for inc character 
  while SciaRegs.SCIFFRX.bit.RXFIFST! 1   
     // wait for XRDY  1 for empty state 
  // Get character 
  car2  SciaRegs.SCIRXBUF.bit.RXDT; 
 
  conta ; 
  for j5 0;j5 1000;j5  
  for j6 0;j6 200;j6 ; 
while conta 300 ;  
//  Se genera un retardo antes de empezar a controlar el sistema  
 
 
//ciclo de control 
do 
 
// Definición de la señal de referencia. 
if i 100  
     r_k 0.4;  
if i 100 && i 200  
     r_k 0.7;  
if i 200 && i 300  
     r_k 0.5;  
if i 300 && i 400  
     r_k 0.3;  
if i 400 && i 500  
     r_k 0.8;  
if i 500 && i 600  
     r_k 0.6;  
if i 600 && i 700  

109
     r_k 0.9;  
if i 700 && i 800  
     r_k 0.2;  
if i 800  
     salida 0;  
 
e_k   r_k – y_k; //calculo de error 
de_k   e_k – e_k_1; //calculo delta error 
pt1 perterror; 
pertraps e_k,pt_e,pt1 ; //calcula los niveles de pertenencia del error 
pt1 pertdeltaerror; 
pertraps de_k,pt_de,pt1 ;//calcula los niveles de pertenecía del delta error 
 
//calcula el valor de K1, K2, K3.  Usando lógica difusa 
K1   fuzzy perterror, pertdeltaerror, pt_FAM_k1 ;   
K2   fuzzy perterror, pertdeltaerror, pt_FAM_k2 ;   
K3   fuzzy perterror, pertdeltaerror, pt_FAM_k3 ;   
 
//Calcula la ley de control "Control PID" 
u_k   u_k_1   0.01*K1*e_k   0.1*K2*e_k_1  0.1*K3*e_k_2;   
 
if u_k 0.1  u_k 0.1;   
if u_k 0.9  u_k 0.9; 
 
//dado que solo se pueden enviar datos tipo entero se realiza esta multiplicación, 
dat_sal    u_k *255;   
 
scia_xmit dat_sal ; //envía la señal de control a la planta 
 
//Espera por dato en el puerto serial 
while SciaRegs.SCIFFRX.bit.RXFIFST! 1       
//almacena el dato leído en la variable dat_ent 
 
dat_ent   SciaRegs.SCIRXBUF.bit.RXDT & 0xFE;  
y_k   dat_ent/130.0; 
 
//actualización de variables 
u_k_1 u_k; 
e_k_2 e_k_1; 

110
e_k_1 e_k; 
i ; 
 
// T   10 ms   
//ciclos de retardo para lograr el tiempo de muestreo 
  for j5 0;j5 1000;j5  
  for j6 0;j6 98;j6 ; 
     a ~a; 
      
while salida ; 
 

111