Universidad de Costa Rica Facultad de Ingeniería Escuela de Ingeniería Eléctrica
IE – 0502 Proyecto Eléctrico
SIMULACIÓN Y CONTROL DE SISTEMAS DINÁMICOS UTILIZANDO OPENMODELICA
Por: MARIANA BARRANTES CHAVES
Ciudad Universitaria Rodrigo Facio Diciembre de 2009
SIMULACIÓN Y CONTROL DE SISTEMAS DINÁMICOS UTILIZANDO OPENMODELICA
Por: Barrantes Chaves Mariana
Sometido a la Escuela de Ingeniería Eléctrica de la Facultad de Ingeniería de la Universidad de Costa Rica como requisito parcial para optar por el grado de:
BACHILLER EN INGENIERÍA ELÉCTRICA
Aprobado por el Tribunal:
____________________________ _________________________________ _____ Ing. Víctor Alfaro Ruiz, M.Sc. Profesor Guía ____________________________ ______________________________ Ing. Guillermo Loría, PhD. Profesor lector
___________________________ _____________________________ __ Ing. Jorge Blanco Alfaro. Profesor lector
i
DEDICATORIA
A mis papás, por todo su amor, amor, dedicación y enseñanzas. enseñanzas. A mis abuelitos, por su gran gran cariño y apoyo. A tía Damaris, por querernos querernos y chinearnos tanto. Y a Mau, por ser un gran amigo y mucho más.
ii
RECONOCIMIENTOS A los profesores Víctor Alfaro, Jorge Blanco y Guillermo Loría por su colaboración en la realización de este proyecto.
iii
ÍNDICE GENERAL ÍNDICE DE FIGURAS........................................................................VI ÍNDICE DE TABLAS .......................................................................VIII RESUMEN .......................................................................................... XII CAPÍTULO 1: INTRODUCCIÓN ..................................................... 1 1.1 1.2
OBJETIVOS ....................................................................................................... 2 1.1.1 Objetivo general .................................................................................. 2 1.1.2 Objetivos específicos ........................................................................... 2 METODOLOGÍA................................................................................................. 3
CAPÍTULO 2: DESARROLLO TEÓRICO ..................................... 5 2.1 2.2 2.3 2.4 2.5
2.6
MODELICA ....................................................................................................... 5 OPENMODELICA .............................................................................................. 9 SIMFORGE ...................................................................................................... 12 MATHMODELICA LITE ................................................................................... 13 SINTAXIS DEL LENGUAJE MODELICA .............................................................. 13 2.5.1 Números, constantes, parámetros y ecuaciones ................................ 14 2.5.2 Clases................................................................................................. 14 2.5.3 Vectores y matrices ............................. .............................................. 19 2.5.4 Anotaciones ....................................................................................... 20 LA BIBLIOTECA ESTÁNDAR DE MODELICA...................................................... 21 2.6.1 Biblioteca de íconos .......................................................................... 22 2.6.2 Biblioteca de constantes .................................................................... 23 2.6.3 Biblioteca de unidades del Sistema Internacional ............................. 23 2.6.4 Biblioteca de funciones matemáticas ................................................ 24 2.6.5 Biblioteca de bloques ........................................................................ 25 2.6.6 Biblioteca de componentes eléctricos ............................................... 26 2.6.7 Biblioteca de componentes mecánicos .............................................. 27 2.6.8 Biblioteca de componentes térmicos ................................................. 28 2.6.9 Biblioteca de diagramas de estado .................................................... 29 2.6.10 Biblioteca de visualización .............................................................. 30
CAPÍTULO 3: GUÍA Y EJEMPLOS DE SIMULACIÓN ............ 31 3.1 3.2
3.3
GUÍA I NTRODUCTORIA PARA EL USO DE OPENMODELICA .............................. 31 EJEMPLOS DE SIMULACIÓN Y CONTROL UTILIZANDO OPENMODELICA ........... 35 3.2.1 Ejemplo 1: Servo-control de la velocidad de un motor ..................... 35 3.2.2 Ejemplo 2: Servo-control de la temperatura de un horno.................. 39 3.2.3 Ejemplo 3: Control del nivel de un tanque ........................................ 43 3.2.4 Ejemplo 4: Control de la velocidad de una banda transportadora ..... 50 LIMITACIONES DE OPENMODELICA Y SIMFORGE ........................................... 57 iv
CAPÍTULO 4: CONCLUSIONES Y RECOMENDACIONES ...... 58 BIBLIOGRAFÍA .................................................................................. 61 APÉNDICES......................................................................................... 64
v
ÍNDICE DE FIGURAS Figura 2.1: Jerarquía en el lenguaje Modelica [14]. ......................... ...................................... 7 Figura 2.2: Esquemáticos creados con programas que usan el lenguaje Modelica.[6] .......... 8 Figura 2.3: Arquitectura de OpenModelica. [6] ..................... .............................................. 10 Figura 2.4: Ícono de un medidor de tensión. ........................................................................ 22 Figura 2.5: Elementos de la biblioteca de bloques. ................... ........................................... 26 Figura 2.6: Elementos de la biblioteca de componentes eléctricos. ..................................... 26 Figura 2.7: Elementos de la biblioteca de componentes mecánicos traslacionales. ............. 27 Figura 2.8: Elementos de la biblioteca de componentes mecánicos rotacionales. ............... 28 Figura 2.9: Elementos de la biblioteca de componentes térmicos. ....................................... 29 Figura 2.10: Modelo realizado con la biblioteca de diagramas de estado. [19] ................... 29 Figura 2.11: Animación de un péndulo tridimensional. [5] .................................................. 30 Figura 3.1: Simulación de un circuito RC utilizando OMShell............................................ 33 Figura 3.2: Circuito RC creado en SimForge. ............................... ....................................... 34 Figura 3.3: Simulación de un circuito RC utilizando SimForge........................................... 35 Figura 3.4: Motor dc que se desea controlar. ........................................................................ 36 Figura 3.5: Diagrama de control de lazo cerrado para el motor. .......................................... 38 Figura 3.6: Respuesta al escalón con lazo cerrado para el motor. ........................................ 39 Figura 3.7: Red generalizada para el horno. ..................................... .................................... 40 Figura 3.8: Diagrama de control de lazo cerrado para el horno. .......................................... 42 Figura 3.9: Respuesta al escalón con el lazo cerrado para el horno. .................................... 43 Figura 3.10: Sistema de tanques en cascada. ........................................................................ 44 Figura 3.11: Sistema de tanques en cascada creado en SimForge. ....................................... 48 Figura 3.12: Respuesta del servo-control. ........................... ................................................. 49 Figura 3.13: Respuesta del control regulatorio. .................................................................... 49 Figura 3.14: Esquema que representa la banda transportadora. ........................................... 50 Figura 3.15: Planta para obtener la curva de reacción. ......................................................... 53 Figura 3.16: Curva de reacción de la planta. ........................................................................ 54 Figura 3.17: Diagrama de control de lazo cerrado para la banda. ........................................ 55 vi
Figura 3.18 Respuesta del servo-control de la banda transportadora. .................................. 56 Figura 3.19: Respuesta del control regulatorio de la banda transportadora.......................... 56
vii
ÍNDICE DE TABLAS Tabla 3.1: Parámetros del motor. [24] ....................................... ................... ......................................... ......................................... ........................ 36 Tabla 3.2: Parámetros del horno. [25] ....................................... ................... ......................................... ......................................... ........................ 40 Tabla 3.3: Parámetros del sistema de tanques. ....................... ......................................... .................... .......................... ..... 44 Tabla 3.4: Parámetros de la banda transportadora. ......................................... .................... ......................................... ........................ 51
viii
NOMENCLATURA *
Punto de operación.
A
Área.
A1 , A2
Área de los tanques.
a
Relación de constantes de tiempo de un modelo de segundo orden.
C(s)
Función de transferencia del controlador.
C r r(s) ( s)
Función de transferencia del controlador de valor deseado.
C T T
Capacitancia térmica.
C y(s)
Función de transferencia del controlador de realimentación.
c p
Calor específico.
Dext
Diámetro externo.
Dint
Diámetro interno.
GT
Conductancia térmica.
H(s)
Matriz de transferencia.
g
Aceleración de la gravedad.
h
Altura.
h1 , h2
Nivel de los tanques.
I a
Corriente de armadura.
J
Momento de inercia.
K c
Ganancia del controlador.
K h
Ganancia del elemento medidor de nivel.
K p
Ganancia del proceso.
K q
Ganancia del elemento actuador de caudal de entrada. Ganancia del elemento actuador de tensión de alimentación. Ganancia del elemento medidor de temperatura.
K v
Ganancia del elemento medidor de velocidad lineal. Ganancia del elemento medidor de velocidad angular.
k
Módulo de elasticidad. ix
k f , k f1 , k f2
Constante del motor.
k 1 , k 2
Constantes de las válvulas.
L(s)
Función de transferencia de lazo abierto.
L’’
Tiempo muerto de un sistema de segundo orden.
La
Inductancia de armadura.
l
Longitud.
M
Masa.
P(s)
Función de transferencia del proceso.
PI
Proporcional Integral.
PID
Proporcional Integral Derivativo.
p(s)
Polinomio característico.
pa
Presión atmosférica.
p1 , p2
Presión en los tanques.
qe
Caudal de entrada.
q1
Caudal en la válvula 1.
q2
Caudal en la válvula 2.
q3
Caudal definido manualmente.
r
Radio.
Ra
Resistencia de armadura.
RT
Resistencia térmica.
SI
Sistema Internacional de Unidades.
T’’
Constante de tiempo más grande de un sistema de segundo orden.
T a
Temperatura ambiente.
T d d
Tiempo derivativo.
T i
Tiempo integral.
T m
Torque del motor.
T 1
Temperatura del horno.
T 1 , T 2
Constantes de tiempo de un sistema de segundo orden.
t 25 25
Tiempo en que la respuesta alcanza el 25% de su valor final. x
t 50
Tiempo en que la respuesta alcanza el 50% de su valor final.
t 75
Tiempo en que la respuesta alcanza el 75% de su valor final.
u
Entrada.
V
Volumen.
V a
Tensión de armadura.
V m
Tensión contraelectromotriz.
w
Flujo de calor.
x
Vector de estados.
y
Vector de salidas. Factor de peso del valor deseado. Razón de amortiguamiento. Densidad del agua. Densidad del aire. Conductividad térmica. Constante de tiempo de lazo cerrado. Velocidad angular del motor. Frecuencia natural no amortiguada.
xi
RESUMEN Se estudiaron el lenguaje Modelica, el programa OpenModelica y su interfaz gráfica SimForge, con el fin de determinar la mejor forma de incorporarlos en el curso IE-0431 Sistemas de control. Con los resultados obtenidos se creó una guía titulada “Guía Introductoria para el uso de OpenModelica” que permite a los estudiantes conocer los principales aspectos sobre el lenguaje y los dos programas mencionados. Además se creó el documento: “Simulación y Control de Sistemas Dinámicos Utilizando OpenModelica: Ejemplos”, el cual contiene la implementación de cuatro ejemplos de sistemas dinámicos de diferentes clases y, sus respectivos sistemas de control, utilizando OpenModelica y SimForge. En el primer caso se modeló el servo-control de un motor de corriente continua con un controlador PI. El segundo ejemplo es el servo-control de un horno, también con un controlador PI. El tercer ejemplo modela el control de un sistema de tanques en cascada con un controlador PID de dos grados de libertad. El último es el control de una banda transportadora con un controlador PID, sintonizado después de obtener un modelo de orden reducido. Los ejemplos presentados pueden simularse fácilmente con los parámetros con los que fueron creados u otros elegidos por el usuario. También sirven como guía para que el estudiante pueda crear sus propios sistemas. Finalmente se indican las principales limitaciones de OpenModelica y SimForge.
xii
Capítulo 1: Introducción El control automático aplicado a la industria, permite operar los procesos de una manera más segura, eficiente y uniforme, permitiendo que la producción sea de una mayor calidad, al mismo tiempo que se reducen los costos de fabricación. Por esta razón, este es de gran importancia dentro de la ingeniería eléctrica. Su desarrollo, unido a la necesidad de estudiar los diferentes procesos que se requiere automatizar, ha llevado a la creación de una amplia variedad de programas que permiten modelar y simular diferentes tipos de sistemas. El propósito de este trabajo es estudiar la aplicación de uno de estos programas, OpenModelica, al análisis y diseño de sistemas de control que contienen elementos eléctricos, mecánicos, hidráulicos y térmicos. Además, se considerarán otras herramientas computacionales que lo complementan, como es el caso de SimForge, el cual es un programa de código abierto que funciona como interfaz gráfica. De este modo se pretende brindar a los estudiantes del curso IE-0431 Sistemas de control, un nuevo instrumento de aprendizaje, que les permita ampliar sus conocimientos tanto sobre la aplicación de las técnicas estudiadas en el curso, como sobre las herramientas computacionales disponibles para utilizarse en la ingeniería.
1
2
1.1
Objetivos
1.1.1 Objetivo general •
Estudiar las características del ambiente de programación OpenModelica para simular sistemas dinámicos y la posibilidad de utilizarlo en el curso IE-0431 Sistemas de Control.
1.1.2 Objetivos específicos •
Conocer las características del programa OpenModelica, así como sus capacidades para simular sistemas dinámicos lineales, no lineales, y sistemas de control.
•
Desarrollar programas para la simulación de sistemas lineales y no lineales mecánicos, hidráulicos, eléctricos, térmicos y combinaciones de los anteriores para el análisis de su comportamiento dinámico.
•
Elaborar un instructivo para la programación básica en OpenModelica y para la utilización de los bloques disponibles en sus diferentes bibliotecas (mecánica, eléctrica, térmica y bloques), así como una “Guía de usuario” para la utilización de los programas desarrollados.
•
Utilizar las herramientas gráficas de análisis, para el diseño de sistemas de control, tomando en cuenta los temas cubiertos en el curso IE-0431 Sistemas de control.
•
Establecer y simular los lazos de control con controladores PI y PID de uno y dos grados de libertad.
3
1.2
Metodología Se realizó una investigación bibliográfica utilizando los manuales disponibles del
programa Open Modelica y otros documentos sobre el mismo, tales como artículos publicados en revistas especializadas o conferencias y libros. Del mismo modo, se llevo a cabo una investigación bibliográfica de las herramientas que lo complementan al funcionar como interfaces gráficas, tales como SimForge y MathModelica Lite. Además, se trabajó directamente con los programas, con el fin de conocer mejor los componentes de sus bibliotecas mecánica, eléctrica, térmica y de bloques. Con los resultados obtenidos se escribió una guía que le permite al usuario introducirse en el uso de OpenModelica y SimForge. Posteriormente se diseñaron sistemas de control de lazo cerrado para sistemas eléctricos, mecánicos, hidráulicos, térmicos y combinaciones de los anteriores, utilizando Open Modelica y SimForge para su simulación y tomando en cuenta los temas cubiertos en el curso IE-0431 Sistemas de control. Debe aclararse que, cuando se comenzó a realizar el proyecto, MathModelica Lite era un programa gratuito para uso académico, basado en OpenModelica, cuya licencia debía actualizarse mensualmente utilizando la página de Internet de MathCore. Sin embargo, a partir del mes de octubre dejó de ser posible realizar dicha actualización, ya que MathCore decidió reemplazarlo por MathModelica Student. MathModelica Student es en realidad una licencia especial para estudiantes de MathModelica Professional, puede comprarse por seis meses, un año o por el tiempo que la
4 persona vaya a continuar estudiando. De acuerdo con el tipo de licencia su precio varía entre 45 USD y 140 USD. Debido a este cambio, los ejemplos de los diferentes tipos de sistemas y sus controladores se desarrollaron utilizando únicamente SimForge como interfaz gráfica.
Capítulo 2: Desarrollo teórico En este capítulo se indican las generalidades del lenguaje Modelica y de los programas OpenModelica, SimForge y MathModelica Lite. Posteriormente se explican algunos elementos del lenguaje. Finalmente se describen las principales bibliotecas.
2.1
Modelica Modelica es un lenguaje de programación orientado a objetos, desarrollado para
modelar y simular sistemas físicos que combinan elementos de diferentes dominios (eléctricos, mecánicos, hidráulicos y térmicos entre otros). Los modelos que se crean utilizando este lenguaje se describen utilizando ecuaciones algebraicas, diferenciales y discretas. [23] Surgió en 1996 cuando un grupo de investigadores de varias universidades e industrias empezaron a trabajar en su desarrollo, como una respuesta a la necesidad de crear un lenguaje que permitiera modelar y simular sistemas de diferentes ramas de la ingeniería. Esto debido a que la mayoría de los lenguajes existentes en el momento, no estaban diseñados para combinar elementos de dominios diferentes y además eran incompatibles entre sí. Por ello, uno de sus objetivos es que el lenguaje Modelica se convierta en un estándar. [1] En el año 2000 se creó una organización sin fines de lucro llamada “Modelica Association” con sede en Linköping, Suecia, que actualmente se encargan de desarrollar el lenguaje. [1] 5
6 Según [23] su uso en las industrias ha ido aumentando desde su creación, especialmente en las compañías automotrices como Audi, BMW, Daimler, Ford, Toyota y VW. También es utilizado en compañías proveedoras para plantas de generación eléctrica, tales como ABB, EDF y Siemens. Una de las principales características de Modelica es la jerarquía. Esta permite crear elementos que luego pueden utilizarse dentro de otros más complejos sin necesidad de volver a escribir el código que los define [14]. Por ejemplo, el modelo de un capacitor puede utilizarse dentro de un circuito eléctrico sin necesidad de volver a escribir las ecuaciones que lo describen. Para ello se definen varias clases, las tres principales, el Modelo (“model”) que “es un modelo de un elemento físico” [14], el Conector (“connector”) que describe “como interactúa un modelo con otros modelos” [14] (por ejemplo mediante las leyes de Kirchoff)
y el Paquete (“package”) que es “un contenedor para los modelos y la forma en la que se organizan las bibliotecas para mantener la jerarquía” (en la sección 2.5 se profundiza más
al respecto). Un ejemplo de esto se muestra en la Figura 2.1. Modelica cuenta con varias bibliotecas en las cuales se encuentran disponibles modelos de diversos elementos. Su biblioteca estándar (“Modelica Standard Library”) contiene 800 modelos y 550 funciones de diferentes dominio s [17].
7
Figura 2.1: Jerarquía en el lenguaje Modelic a [14]. Para utilizar el lenguaje y sus bibliotecas es necesario contar con un entorno de simulación, el cual puede ser comercial o de código abierto. Dentro de los comerciales están: •
Dymola de Dynasim.
•
LMSImagine.LabAMESim de LMS.
•
MapleSim de Maplesoft.
•
MathModelica Professional de MathCore.
•
Mosilab de Fraunhofer-Gesellschaft.
•
SimulationX de ITI.
Por otra parte, son programas de código abierto:
8 •
JModelica.org
•
Modelicac.
•
OpenModelica.
El uso de estos programas permite que los modelos presentes en las diferentes bibliotecas puedan utilizarse con texto directamente o mediante esquemáticos, lo cual facilita su uso. Un esquemático contiene diferentes elementos conectados mediante puertos que describen la manera en que interactúan, algunos ejemplos se muestran en l a Figura 2.2. Internamente, estos elementos están descritos mediante ecuaciones utilizando la sintaxis de Modelica. [17]
Figura 2.2: Esquemáticos creados con programas que usan el lenguaje Modelic a.[6]
9
2.2
OpenModelica Como se mencionó anteriormente, Open Modelica es un programa de código abierto
que permite realizar simulaciones utilizando Modelica como lenguaje. Es desarrollado por el laboratorio de programación de la Universidad de Linköping, llamado “Programming Environments Laboratory (PELAB)” . [21] Entre sus objetivos están: •
Brindar un entorno computacional eficiente e interactivo para el lenguaje Modelica. [1]
•
Permitir la depuración de programas creados con lenguajes con base en ecuaciones como Modelica. [1]
•
Proveer un entorno para la enseñanza del modelado y simulación, en áreas como diseño de sistemas de control, solución de sistemas de ecuaciones no lineales y desarrollo de algoritmos de optimización para sistemas complejos. [1]
•
Extender el alcance del lenguaje Modelica, para poder utilizarlo en problemas que requieren ecuaciones con derivadas parciales o modelado y simulación de sistemas discretos. [1]
•
Permitir el uso de interfaces gráficas para la simulación en algunos dominios y la visualización de resultados utilizando técnicas de animación . [1]
Open Modelica está formado por varios subsistemas que se relacionan entre sí, estos se muestran en la Figura 2.3. y se describen a continuación.
10
Figura 2.3: Arquitectura de OpenModelica . [6] •
Administrador de Sesión Interactivo (OMShell): Se encarga de interpretar los comandos para evaluar expresiones, simular y graficar. Además permite revisar el contenido de un modelo (por ejemplo, las ecuaciones que describen un elemento de las bibliotecas) mediante los comandos apropiados.
•
Subsistema de compilación de Modelica: Traduce el lenguaje Modelica a lenguaje C. También contiene herramientas que permiten crear archivos de simulación ejecutables enlazados con programas que solucionan ecuaciones diferenciales ordinarias (EDO) o algebraicas (EDA), mediante métodos numéricos.
•
Módulo de ejecución: Ejecuta el código binario que ha sido traducido por el compilador a partir de las funciones y modelos.
•
Editor de texto Emacs: GNU Emacs es un editor de texto que forma parte del proyecto GNU (creado con el objetivo de formar un sistema operativo totalmente libre). Cuenta con un modo especial para Modelica que permite programar los
11 modelos, con la ventaja de que oculta las anotaciones gráficas durante la edición (por ejemplo la ubicación de los componentes), para facilitar su lectura. •
Editor/compilador de Eclipse: Eclipse es una plataforma de código abierto que permite desarrollar ambientes en forma de extensiones para programas [20]. Con base en ella se creó un editor que forma parte de OpenModelica. Éste permite establecer jerarquías entre clases y archivos, así como editar texto (destaca las palabras reservadas). Además cuenta con un compilador y con herramientas para depurar el programa.
•
Editor en forma de cuaderno (OMNotebook): es un programa en forma de cuaderno que puede utilizarse para escribir modelos, simular y graficar. Además se usa para manejar un tutorial de Modelica llamado “DrModelica”.
•
Editor gráfico de modelos: es un editor gráfico que permite conectar elementos de las bibliotecas para crear modelos y simularlos. En realidad OpenModelica no cuenta con un editor gráfico propio, pero, permite utilizar enlazados con el programa, editores como SimForge.
•
Depurador de Modelica: Permite depurar el código escrito con Modelica, que no contiene modelos realizados con ecuaciones. Se utiliza en conjunto con el Editor/compilador de Eclipse. Actualmente existen dos tipos de OpenModelica, cada uno con un compilador
diferente. Uno de ellas permite utilizar la mayoría de las funciones estándar de Modelica, incluyendo simulación y está formada por el Administrador de Sesión Interactivo, el Editor
12 en forma de cuaderno y el editor gráfico. La otra incluye el Depurador, el Editor de Texto Emacs y el Editor de Eclipse; está orientada a la meta-programación 1 pero no permite utilizar modelos basados en ecuaciones .[5] Este trabajo se enfoca en el primer tipo, el segundo escapa de sus objetivos. La versión probada más reciente de OpenModelica es la 1.4.5., y es la que se utiliza en este trabajo. Sin embargo, el 19 de setiembre del 2009 se lanzó la versión 1.5.0Bet a [15].
2.3
SimForge SimForge es una interfaz gráfica que se utiliza con OpenModelica. Es desarrollada
por el Politecnico di Milano, en Italia. Tiene dos herramientas principales: la primera es para realizar modelos utilizando las bibliotecas de Modelica; la segunda es un editor para diagramas de escalera siguiendo la norma IEC61131-3. Este trabajo se enfoca en la primera herramienta. SimForge permite editar tanto de manera gráfica como directamente mediante texto y destaca las palabras reservadas. Además, es posible simular y graficar directamente desde este programa.
1
“La metaprogramación consiste en escribir programas que escriben o manipulan otros programas (o
a sí mismos) como datos, o que hacen en tiempo de compilación parte del trabajo que, de otra forma, se haría en tiempo de ejecución. Esto permite al programador ahorrar tiempo en la producción de código”. [22]
13
2.4
MathModelica Lite MathModelica Lite (de MathCore AB) era un editor gráfico gratuito para uso
académico [1]. Permitía editar tanto de manera gráfica como directamente mediante texto y destacaba las palabras reservadas. Sin embargo, no era posible simular utilizando este programa, por lo cual los modelos creados en él debían simularse utilizando OMShell o SimForge. En el mes de octubre MathModelica Lite fue reemplazado por MathModelica Student, que es una licencia especial para estudiantes de MathModelica Professional. Su precio varía entre 45 USD y 140 USD.
2.5
Sintaxis del lenguaje Modelica 2 Para construir modelos utilizando el lenguaje Modelica, se utilizan diferentes
elementos tales como: números, cadenas de caracteres, matrices, ecuaciones, funciones, conectores, componentes que pueden formar modelos más grandes, etc. Para formar estos elementos, es necesario realizar declaraciones de acuerdo con el lenguaje. En esta sección se explican los más importantes, las palabras que se muestran entre paréntesis y con negritas son palabras reservadas y serán destacadas si se utiliza un editor apropiado (excepto las definiciones de los tipos de datos).
2
Todos los ejemplos de esta sección se tomaron de [18].
14
2.5.1 Números, constantes, parámetros y ecuaciones Los números en Modelica pueden ser reales (Real), enteros (Integer) o binarios (Boolean); además pueden utilizarse cadenas de caracteres (String). Por ello, cuando se va a crear una constante, un parámetro, o una variable es necesario definir a cual de esos tipos de datos corresponde. Una constante ( constant) es un valor que no cambia nunca, mientras que un parámetro ( parameter) se mantiene constante durante una simulación pero puede variarse entre simulaciones, por ejemplo el valor de una inductancia. Además, al declarar la clase de dato que se va a utilizar, es posible asignarle un valor inicial con la palabra “start”, o un valor fijo mediante el signo igual. Un ejemplo de estas declaraciones sería el siguiente: Real u, y(start=1); parameter Real T=1;
En el caso de las ecuaciones, éstas deben formarse con expresiones a la izquierda y derecha del signo igual, antecedidas por la palabra “ equation”: equation T*der(y) + y = u;
donde “der” es el operador derivada con respecto del tiempo.
2.5.2 Clases Una clase (class) es una definición de un objeto que permite volver a utilizarlo sin necesidad de volverlo a describir. Debe indicarse donde termina mediante la palabra “ end”. Por ejemplo: class LowPassFilter parameter Real T=1;
Real u, y(start=1);
15 equation T*der(y) + y = u; end LowPassFilter;
es una clase que define un filtro paso bajo. Otra clase puede conectar dos filtros pasobajo en serie “llamando” a la clase que ya se creó, de este modo se aplica la jerarquía del lenguaje: class FiltersInSeries
LowPassFilter F1(T=2), F2(T=3); equation
F1.u = sin(time); F2.u = F1.y; end FiltersInSeries;
En este caso se utiliza el tiempo ( time) como variable. En este lenguaje el tiempo siempre puede utilizarse como variable, sin necesidad de declararlo previamente. Modelica cuenta con siete tipos de clases: el modelo ( model), el conector (connector), el registro (record), el bloque (block ), la función (function), el tipo (type) y el paquete (package), cada una con sus propias características. Sin embargo, en todas ellas es posible sustituir la palabra que la define por la palabra “ class” y obtener los mismos resultados. Continuando con el ejemplo anterior, se podría por ejemplo realizar un modelo que utiliza las clases creadas, pero modifica los parámetros: model ModifiedFiltersInSeries
FiltersInSeries F12(F1(T=6), F2(T=11)); // alternative 1 FiltersInSeries F34(F1.T=6, F2.T=11); // alternative 2 end ModifiedFiltersInSeries;
en el ejemplo se muestran dos alternativas equivalentes para definir los valores de los parámetros.
16 Un registro es una clase que no puede contener ecuaciones, sirve para definir parámetros, por ejemplo: record FilterData
Real T; end FilterData; record TwoFilterData
FilterData F1, F2; end TwoFilterData; model ModifiedFiltersInSeries2
TwoFilterData TwoFilterData1(F1(T=6), F2(T=11)); FiltersInSeries F12=TwoFilterData1; end ModifiedFiltersInSeries2;
Los conectores se utilizan para definir como interactúan los elementos de un sistema. Para ello Modelica utiliza pervariables y transvariables. Todas las transvariables conectadas en un mismo punto tienen el mismo valor y “la suma de todas las pervariables que inciden en un punto cualquiera es cero” [2] de acuerdo con la ley de incidencia de las
pervariables. Las pervariables se definen con la palabra “ flow” y se consideran positivas entrando al elemento: connector Pin
Real v; flow Real i; end Pin;
Los tipos ( types) son clases que se derivan de los tipos de datos (Real, Integer…) o de registros definidos previamente. Pueden servir por ejemplo para definir variables, las cuales pueden tener indicadas unidades del Sistema Internacional mediante la palabra “unit”. A continuación se presenta un ejemplo en el que se utiliza en la creación de un nodo con tres resistencias conectadas: type Voltage = Real(unit="V"); type Current = Real(unit="A"); connector Pin
17 Voltage v; flow Current i; end Pin; model Resistor
Pin p, n; // "Positive" and "negative" pins. parameter Real R(unit="Ohm") "Resistance"; equation
R*p.i = p.v - n.v; p.i + n.i = 0; // Positive currents into component. end Resistor; model SimpleCircuit
Resistor R1(R=100), R2(R=200), R3(R=300); equation connect(R1.p, R2.p); connect(R1.p, R3.p); end SimpleCircuit;
También es posible realizar modelos parciales ( partial model ), que son utilizados por otros modelos mediante el comando “ extends”. Por ejemplo, al crear los elementos de un circuito, en lugar de definir un conector para cada elemento diferente (resistencia, capacitor…) se crea un puerto mediante un modelo parcial y éste es llamado por el modelo del elemento: partial model OnePort
Pin p, n; Voltage v "Voltage drop"; equation
v = p.v - n.v; p.i + n.i = 0; end TwoPin; model Inductor "Ideal electrical inductance" extends OnePort; parameter Real L(unit="H") "Inductance"; equation L*der(i) = v; end Inductor;
Las funciones son clases que contienen entradas, salidas y un algoritmo, pero no ecuaciones. Un algoritmo es una función matemática en la cual se utilizan asignaciones en lugar de ecuaciones, definidas con el símbolo “: =”. También pueden contener lazos
18 (“while” o “for”) y condiciones si-entonces (“if” “then” “else”). Un ejemplo de función es el siguiente: function Circle input Real angle; input Real radius; output Real x; output Real y; algorithm x:= radius*Modelica.Math.cos(angle); y:= radius*Modelica.Math.sin(angle); end Circle;
Para llamar la función se indican las entradas después del nombre de la función, luego es posible asignar los resultados: >> Circle(2,2) (-0.832293673094285,1.81859485365136) >> x:=-0.832293673094285 -0.832293673094285 >> y:=1.81859485365136 1.81859485365136
Los paquetes son bloques que se usan para contener otras clases (por ejemplo modelos). De ese modo las bibliotecas se organizan jerárquicamente, por ejemplo: package Modelica package Mechanics package Rotational model Inertia // Modelica.Mechanics.Rotational.Inertia
... end Inertia; model Torque
... end Torque; end Rotational; end Mechanics; end Modelica;
Finalmente, los bloques ( block ) son clases que tienen entradas ( input) y salidas (output). Se utilizan para representar funciones de transferencia y modelos en variables de estado, entre otros. Este último caso se ejemplifica en la siguiente sección.
19
2.5.3 Vectores y matrices Los vectores y matrices se declaran especificando las dimensiones después de la declaración del tipo de dato o del nombre del elemento: Real[3] position, velocity, acceleration; Real[3,3] transformation; Real[3,2,10] table;
o equivalentemente: Real position[3], velocity[3], acceleration[3], transformation[3, 3]; Real table[3,2,10];
Las matrices pueden estar dentro de clases, por ejemplo: type Position = Real(unit="m"); type Position3 = Position[3];
Las columnas en las matrices se separan con comas (,) y las filas con punto y coma (;): [expr11, expr12, ... expr1n; expr21, expr22, ... expr2n; … exprm1, exprm2, ... exprmn]
Para indicar una posición en un vector o matriz se utilizan los corchetes después del nombre, por ejemplo: A[i], donde i es mayor o igual que 1. Utilizando esta notación se puede formar submatrices por ejemplo: A[i1:i2,j1:j2]. Es posible sumar y restar matrices con otras matrices y multiplicarlas y dividirlas por escalares. Además el lenguaje tiene funciones matriciales como el producto cruz y hallar la transpuesta. Si no se conoce el tamaño de una matriz puede declararse utilizando dos puntos (:): A[:,:] y luego obtenerse con la función “ size” como se muestra en el siguiente ejemplo para un bloque que contiene un espacio de estados:
20 block StateSpace parameter Real A[:, :], B[size(A, 1), :], C[:, size(A, 2)], D[size(C, 1), size(B, 2)]=zeros(size(C, 1), size(B, 2)); input Real u[size (B, 2)]; output Real y[size(C, 1)]; protected Real x[size(A, 2)]; equation assert(size(A, 1) == size(A, 2), "Matrix A must be square."); der(x) = A*x + B*u;
y = C*x + D*u; end StateSpace;
Por ejemplo, en este caso “ D[size(C,
1), size(B, 2)]”
implica que la matriz D
tiene tantas filas como C y tantas columnas como B. El uso de “ size” en este código permite asegurarse de que las matrices se pueden multiplicar y sumar. El comando “ protected” se utiliza para ocultar información que no es necesario que el usuario del programa vea. El comando “ assert” se utiliza para verificar condiciones, si estas no se cumplen entonces da un mensaje de error (en este caso verifica que la matriz A sea cuadrada).
2.5.4 Anotaciones Las anotaciones se usan para establecer los íconos que representan los modelos y para incluir información sobre el modelo o bibliografía adicional. Para utilizarlas se escribe la palabra “annotation” y se indica entre paréntesis la información deseada, incluyendo las características del ícono luego de la palabra “icon”. Por ejemplo: model Resistor Pin p annotation (extent=[-110, -10; -90, 10]); Pin n annotation (extent=[ 110, -10; 90, 10]); parameter R "Resistance in [Ohm]"; equation
R*p.i = p.v - n.v;
21 n.i = p.i; public annotation (Icon(
Rectangle(extent=[-70, -30; 70, 30], style(fillPattern=1)), Text(extent=[-100, 55; 100, 110], string="%name=%R"), Line(points=[-90, 0; -70, 0]), Line(points=[70, 0; 90, 0]) )); end Resistor;
2.6
La biblioteca estándar de Modelica Como ya se ha mencionado anteriormente, Modelica cuenta con una biblioteca
organizada en paquetes, que contienen modelos para diferentes tipos de sistemas. La versión incluida al instalar OpenModelica 1.4.5 contiene: •
La biblioteca de íconos.
•
La biblioteca de constantes.
•
La biblioteca de unidades del Sistema Internacional.
•
La biblioteca de funciones matemáticas.
•
La biblioteca de bloques.
•
La biblioteca de componentes eléctricos.
•
La biblioteca de componentes mecánicos.
•
La biblioteca de componentes térmicos.
•
La biblioteca de visualización.
En realidad la biblioteca estándar de Modelica cuenta con más paquetes [23], sin embargo, OpenModelica no puede interpretar adecuadamente sus componentes.
22
2.6.1 Biblioteca de íconos Este paquete (“Icons”) contiene íconos que pueden ser utilizados por otras bibliotecas para crear el ícono de un modelo. Por ejemplo, en el modelo para un sensor de tensión de la biblioteca eléctrica se utiliza el ícono de medidor rotacional: model VoltageSensor "Sensor to measure the voltage between two pins" extends Modelica.Icons.RotationalSensor;
Interfaces.PositivePin p "positive pin"; Interfaces.NegativePin n "negative pin"; Modelica.Blocks.Interfaces.RealOutput v(redeclare type SignalType= SI.Voltage ) "Voltage between pin p and n (= p.v - n.v) as output signal" annotation(Icon(coordinateSystem(extent={{-100.0,100.0},{100.0,100.0}}), graphics={Text(extent={{-29.0,11.0},{30.0,-70.0}}, textString="V", fillColor={0,0,0}),Line(points={{-70.0,0.0},{-90.0,0.0}}, color={0,0,0}),Line(points={{70.0,0.0},{90.0,0.0}}, color={0,0,0}),Line(points={{0.0,-90.0},{0.0,-70.0}}, color={0,0,255}),Text(extent={{-150.0,80.0},{150.0,120.0}}, textString="%name", fillColor={0,0,255})}), Diagram(coordinateSystem(extent={{-100.0,-100.0},{100.0,100.0}}), graphics={Line(points={{-70.0,0.0},{-96.0,0.0}}, color={0,0,0}),Line(points={{70.0,0.0},{96.0,0.0}}, color={0,0,0}),Line(points={{0.0,-90.0},{0.0,-70.0}}, color={0,0,255})})); equation
p.i=0; n.i=0; v=p.v - n.v; end VoltageSensor;
con lo cual se crea el siguiente ícono para el modelo:
Figura 2.4: Ícono de un medidor de tensión.
23
2.6.2 Biblioteca de constantes La biblioteca de constantes es un paquete (“Constant”) que contiene constantes de uso común como el número pi ( π), la aceleración de la gravedad, el factor de conversión para pasar de grados a radianes, etc. Para utilizarlas en un programa, es necesario definir una constante propia del programa que se iguala a la constante deseada. Por ejemplo, la siguiente función calcula la circunferencia utilizando la constante “pi” de la biblioteca: function Circunferencia input Real r; output Real C; constant Real pi=Modelica.Constants.pi; algorithm
C:=2*pi*r; end Circunferencia;
2.6.3 Biblioteca de unidades del Sistema Internacional Este paquete se llama “SI Units” y tiene como base las normas ISO 31-1992 “General principles concerning quantities, units and symbols” e ISO 1000-1992 “SI units and recommendations for the use of their multiples and of certain other units ” [12]. Está conformado por la definición de las magnitudes (y unidades) del Sistema Internacional y un paquete de conversiones (“Conversions”). A su vez el programa de Conversiones tiene un paquete interno con unidades que no son del Sistema Internacional pero son de uso común (como los grados (°), las horas, los grados Celsius (°C), etc.) además de las funciones para realizar las conversiones entre unas y otras. Por ejemplo, para la velocidad en unidades SI se tiene: type Velocity= Real(final quantity="Velocity", final unit="m/s");
En unidades que no son del sistema internacional:
24 type Velocity_kmh= Real(final quantity="Velocity", final unit="km/h");
y para realizar la conversión existen dos funciones dependiendo del sentido en que se desee realizarla: function from_kmh "Convert from kilometre per hour to metre per second" extends ConversionIcon; input NonSIunits.Velocity_kmh kmh "kilometre per hour value"; output Velocity ms "metre per second value"; algorithm
ms:=kmh/3.6; from_kmh; end
o function to_kmh "Convert from metre per second to kilometre per hour" extends ConversionIcon; input Velocity ms "metre per second value"; output NonSIunits.Velocity_kmh kmh "kilometre per hour value"; algorithm
kmh:=3.6*ms; to_kmh; end
En el siguiente ejemplo se muestra el uso de esta biblioteca para modelar un péndulo [14]: model SimplePendulum constant Modelica.SIunits.Acceleration g = 9.81; parameter Modelica.SIunits.Length L = 1;
Modelica.SIunits.Angle Theta; Modelica.SIunits.AngularVelocity ThetaDot; equation
ThetaDot = der(Theta); der(ThetaDot) = g/L*sin(Theta);
SimplePendulum ; end
2.6.4 Biblioteca de funciones matemáticas El paquete de funciones matemáticas (“Math”) contiene funciones matemáticas de uso común como logaritmo natural, seno, coseno hiperbólico, tangente inversa, etc. Además, cuenta con un paquete interno formado por funciones para trabajar con matrices (cálculo de la inversa, el determinante, el rango, etc.).
25 Por ejemplo, para la función seno el código es: function sin "sine" extends baseIcon1; input SI.Angle u; output Real y; external "C" y=sin(u) ; end sin;
donde la palabra external se utiliza para invocar rutinas externas escritas en otros lenguajes, en este caso C [10]. Esta biblioteca se utiliza en forma similar a las anteriores, el siguiente ejemplo muestra su uso en un bloque que modela una fuente de tensión senoidal. Este bloque también pertenece a la biblioteca estándar de Modelica: block Sine "Generate sine signal" parameter Real amplitude=1 "Amplitude of sine wave"; parameter SIunits.Frequency freqHz=1 "Frequency of sine wave"; parameter SIunits.Angle phase=0 "Phase of sine wave"; parameter Real offset=0 "Offset of output signal"; parameter SIunits.Time startTime=0 "Output=offset for
time
y=offset + (if time < startTime then 0 else amplitude*Modelica.Math.sin(2*pi*freqHz*(time - startTime)+phase)); Sine; end
2.6.5 Biblioteca de bloques La biblioteca de bloques (“Blocks”) contiene ocho paquetes: Tipos (“Types”), Fuentes (“Sources”), No Lineales (Nonlinear), Matemáticos (“Math”), Lógicos (“Logical”), Interfaces (“Interfaces”), Discretos (“Discrete”) y Continuos (“Continuos”) Permite construir diagramas de bloques gráficamente, utilizando una interfaz (como SimForge). Cuenta con bloques de funciones de transferencia, sistemas de primer y segundo orden, espacio de estados, controladores PI y PID, fuentes de escalón, senoidales, de pulso y bloques de retroalimentación entre otros.
26
Figura 2.5: Elementos de la biblioteca de bloques. 2.6.6 Biblioteca de componentes eléctricos La biblioteca de componentes eléctricos (“Electrical”) tiene un paquete formado por componentes analógicos (“Analog”). Éste a su vez está integrado por ocho paquetes: con componentes Básicos (“Basic”), Ideales (“Ideal”), Interfaces (“Interfaces”), Líneas (“Lines”), Semiconductores (“Semiconductor”), Sensores (“Sensors”), Fuentes (“Sources”) y Ejemplos (“Examples”). Esta biblioteca también permite construir diagramas de bloques gráficamente utilizando una interfaz. Cuenta con bloques de inductores, resistencias, fuentes de tensión y corriente, transistores, diodos, amplificadores operacionales, modelos de líneas de transmisión y sensores entre otros.
Figura 2.6: Elementos de la biblioteca de componentes eléctricos.
27
2.6.7 Biblioteca de componentes mecánicos La biblioteca de componentes mecánicos (“Mechanics”) está formada por tres paquetes: el de elementos mecánicos traslacionales (“Translational”), el de rotacionales (“Rotational”) y el de tres dimensiones (“Multibody”), sin embargo, este último no se puede utilizar con OpenModelica actualmente [5]. A continuación se describen los otros dos. •
Elementos Mecánicos Traslacionales: Contiene un paquete con ejemplos, otro con interfaces y otro con sensores de fuerza, velocidad, posición y aceleración. Además cuenta con amortiguadores (“Damper”), masas (“Sliding mass”), resortes (“Spring”), puntos para fijar los elementos (“Fixed”) e interfaces para generar fuerza a partir de fuentes de la biblioteca de bloques (“Force”), entre otros.
Figura 2.7: Elementos de la biblioteca de componentes mecánicos traslacionales. •
Elementos Mecánicos Rotacionales: Contiene un paquete con ejemplos, otro con interfaces y otro con sensores de torque, velocidad angular, desplazamiento angular y aceleración angular. Además cuenta con amortiguadores rotacionales (“Damper”), inercias (“Inertia”), barras de torsión (“Spring”), puntos para fijar los elementos
28 (“Fixed”), interfaces para generar torque a partir de fuentes de la biblioteca de bloques (“Torque”) y engranajes (“Ideal Gear”) entre otros.
Figura 2.8: Elementos de la biblioteca de componentes mecánicos rotacionales. 2.6.8 Biblioteca de componentes térmicos El paquete de componentes térmicos (“Thermal”) está formada por dos paquetes: uno para modelar fluídos con flujo de calor (“FluidHeatFlow”) y otro paquete llamado Transferencia de calor (“HeatTransfer”). Los modelos utilizados en el primer paquete son muy diferentes de los estudiados en los cursos IE-0431 Sistemas de Control e IE-0409 Análisis de sistemas, por lo que no se tratarán en este trabajo. El paquete de Transferencia de calor está formado por un paquete de interfaces, uno de ejemplos, uno que trabaja con las temperaturas en grados Celsius, otro en grados Fahrenheit y el último en grados Rankine. Los demás elementos trabajan con Kelvin, que es la unidad SI. La biblioteca de componentes térmicos cuenta con conductancias térmicas (“ThermalConductor”), capacitancias térmicas (“HeatCapacitor”), fuentes de temperatura (“FixedTemperature”) y de flujo de calor (“FixedHeatFlow”) entre otros. En el caso de las
29 capacitancias térmicas, su modelo provoca que su temperatura inicial sea siempre de 20°C. También tiene sensores, tanto de temperatura como de flujo de calor.
Figura 2.9: Elementos de la biblioteca de componentes térmicos. 2.6.9 Biblioteca de diagramas de estado La biblioteca de diagramas de estado (“StateGraph”) se utiliza para simular sistemas de control basados en diagramas de escalera. Toma como base las normas IEC 848 e IEC 61131-3 [19]. Sin embargo, SimForge no puede interpretar sus componentes, por lo cual es necesario utilizar otro programa que tenga interfaz gráfica para utilizarla, como MathModelica Professional. Por esta razón no se profundizará al respecto.
Figura 2.10: Modelo realizado con la biblioteca de diagramas de estado . [19]
30
2.6.10 Biblioteca de visualización La biblioteca de visualización “SimpleVisual” se utiliza para realizar animaciones de los modelos con los cuales se está trabajando. Esta posibilidad está disponible en el OMNotebook, sin embargo escapa de los objetivos de este trabajo, por lo cual no se profundizará en ella.
Figura 2.11: Animación de un péndulo tridimensional . [5]
Capítulo 3: Guía y ejemplos de simulación En esta sección se describe el trabajo llevado a cabo tanto en el desarrollo de la “Guía Introductoria para el uso de OpenModelica” como en los ejemplos de diferentes sistemas para simulación, los cuales se recopilan en el documento “Simulación y Control de Sistemas Dinámicos utilizando OpenModelica: Ejemplos”. Se realizaron dos documentos separados porque en el segundo todos los ejemplos incluyen el desarrollo de un sistema de control, por lo cual es necesario que el lector haya aprobado o esté llevando el curso IE-0431 Sistemas de control, en cambio la Guía Introductoria es más general y podría ser utilizada también por estudiantes del curso IE0409 Análisis de Sistemas. Además, al final del capítulo se describen las principales limitaciones encontradas en el uso de OpenModelica y SimForge.
3.1
Guía Introductoria para el uso de OpenModelica La “Guía Introductoria para el uso de OpenModelica” está dividida en tres
secciones: “Generalidades”, “Instalación” y “Modelado y Simulación”. En la primera se inicia indicando brevemente que son y como surgieron el lenguaje Modelica y los programas OpenModelica y SimForge. Seguidamente, se muestran los aspectos más relevantes de la sintaxis del lenguaje Modelica, esta sección no es exhaustiva porque no se busca que el lector programe normalmente mediante texto sino, que comprenda como están estructurados los elementos presentes en las diferentes bibliotecas. 31
32 Precisamente, la primera sección de la guía concluye describiendo las bibliotecas de Modelica que se utilizan mediante OpenModelica y la interfaz gráfica SimForge. La segunda sección describe los pasos necesarios para descargar la versión 1.4.5 de OpenModelica desde su página en Internet e instalarlo. El proceso es bastante sencillo, sin embargo, cabe destacar que si se utiliza Windows como sistema operativo, el programa debe instalarse en una carpeta cuyo nombre no contenga espacios en blanco. Del mismo modo indica que debe hacerse para descargar e instalar SimForge 0.8.5., para lo cual es necesario contar con Java 6 y OpenModelica 1.4.3 o superior. Además, se muestra el proceso necesario para indicarle al programa las direcciones donde están instalados OpenModelica y las bibliotecas del lenguaje, lo cual solo es necesario la primera vez que se utiliza el programa. Finalmente, en la tercera parte se muestra como crear y simular un modelo, ya sea utilizando OMShell o SimForge. Para ello se crea un circuito RC y se simula su respuesta en el tiempo ante una entrada de tensión de escalón unitario. En realidad OMShell no permite editar texto directamente, por lo cual es necesario utilizar un editor de texto e importar el programa. En el ejemplo el código es creado mediante el bloc de notas y guardado con la extensión “.mo”. A continuación se muestra dicho código: model Circ_RC Modelica.Electrical.Analog.Basic.Capacitor C1(C=0.001); Modelica.Electrical.Analog.Basic.Resistor R1(R=1000); Modelica.Electrical.Analog.Basic.Ground G1; Modelica.Electrical.Analog.Sources.StepVoltage Escalon; equation connect(Escalon.n,G1.p); connect(Escalon.p,R1.p);
33 connect(R1.n,C1.p); connect(C1.n,G1.p); end Circ_RC;
Posteriormente se importa mediante la instrucción “LoadFile” y se simula y grafica utilizando: >> simulate(Circ_RC,startTime=0.0,stopTime=8.0). >> plot({C1.v})
Los resultados obtenidos se muestran en l a Figura 3.1. En realidad utilizar OMShell para crear y simular modelos no es la mejor opción, ya que requiere programar mediante texto y en modelos grandes esto se vuelve complicado. Sin embargo, se realiza este ejemplo para que el lector comprenda como funciona OMShell y observe la sintaxis de lenguaje.
Figura 3.1: Simulación de un circuito RC utilizando OMShell.
34 A continuación, se realiza el mismo ejemplo pero utilizando SimForge. De ese modo el lector puede comparar las ventajas de utilizar una interfaz gráfica y conocer los aspectos básicos necesarios para utilizar este programa, tal como la creación de un archivo, paquete o modelo, la elección de los componentes desde las diferentes bibliotecas, la edición de estos y selección de sus parámetros, así como la forma de unirlos o alambrarlos. Además puede observar como, al crear el modelo gráficamente, se genera automáticamente el texto en lenguaje Modelica. En la Figura 3.2 se muestra el modelo obtenido y se indican los botones que se utilizan para simularlo. Por otra parte, en la Figura 3.3 se muestra el resultado de la simulación y se indican los botones que se utilizan para editar las gráficas obtenidas.
Figura 3.2: Circuito RC creado en SimForge.
35
Figura 3.3: Simulación de un circuito RC utilizando SimForge.
3.2
Ejemplos de simulación y control utilizando OpenModelica El documento “Simulación y Control de Sistemas Dinámicos utilizando
OpenModelica: Ejemplos” está formado por cuatro ejemplos de diferentes tipos de sistemas, sus aspectos más relevantes se indican a continuación. Las simulaciones se compararon con los obtenidas utilizando Matlab con resultados satisfactorios.
3.2.1 Ejemplo 1: Servo-control de la velocidad de un motor En el primer ejemplo se desea controlar la velocidad angular de un motor de corriente continua con una masa acoplada a su eje, siendo la velocidad angular la variable
36 controlada y la tensión de entrada la variable manipulada. La planta, representada en SimForge, se muestra en la Figura 3.4, donde R a corresponde a la resistencia de armadura, La a la inductancia de armadura y J1 al momento de inercia de la masa acoplada al eje. Los parámetros del motor se muestran en la Tabla 3.1.
Figura 3.4: Motor dc que se desea controlar. Tabla 3.1: Parámetros del motor. [24] Parámetro
Valor
R a
2,21 Ω
La
0,26 mH
k f1
0,024 Nm/A
k f2
0,024 Vs/A
J1
3,97·10-6 kgm2
37 La función de transferencia que describe el sistema está dada por: (3.2-1)
(3.2-2) Debido a que el polo en 66,17 es el dominante, se diseñó un controlador PI utilizando cancelación de polos y ceros, tal que el tiempo integral permita cancelar ese polo y la ganancia permita que el sistema de lazo cerrado sea críticamente amortiguado: (3.2-3) (3.2-4) (3.2-5) Como punto de operación nominal se eligió que la velocidad del motor sea de 375 rad/s. El ámbito de medición va de 0 rad/s a 500 rad/s, mientras que la señal de control varía de 0 a 1 en ese ámbito, por lo tanto la constante del elemento de medición será: (3.2-6) El ámbito de actuación para este motor es de 0 V a 12 V, por lo tanto la constante del actuador es: (3.2-7) Posteriormente se dan las instrucciones paso por paso para crear tanto la planta como el modelo de lazo cerrado en SimForge. Para ello se utilizan la resistencia, la inductancia, la fuente de tensión, la tierra y la fuerza contraelectromotriz de la biblioteca de
38 componentes eléctricos; la inercia y el sensor de velocidad angular de la biblioteca de componentes mecánicos rotacionales y, de la biblioteca de bloques, las ganancias para los elementos de medición y actuación, el controlador PI, el bloque de realimentación y la fuente “TimeTable”, la cual permite simular un escalón desde el punto de operación. El modelo obtenido se muestra en la Figura 3.5.
Figura 3.5: Diagrama de control de lazo cerrado para el motor. Posteriormente se simula de 0 s a 6 s con un paso fijo de 2·10 -5 s, un cambio escalón en el valor deseado de 375 rad/s a 400 rad/s. Graficando la respuesta al escalón en el servocontrol y realizando un acercamiento para observar el ámbito de interés se obtiene l a Figura 3.6. Allí puede observarse que el sistema a lazo cerrado es críticamente amortiguado y no tiene error permanente.
39
Figura 3.6: Respuesta al escalón con lazo cerrado para el motor. 3.2.2 Ejemplo 2: Servo-control de la temperatura de un horno En este caso se desea controlar la temperatura de un horno para cerámica, siendo la temperatura del horno la variable controlada y el flujo de calor que entra la variable manipulada. El horno se representa mediante una resistencia térmica, una capacitancia térmica y una fuente de flujo de calor. En la Figura 3.7 se muestra su red generalizada equivalente, Ta es la temperatura ambiente y T1 la temperatura interior del horno.
40
T1 CT
RT
w
Ta Figura 3.7: Red generalizada para el horno. Los datos del horno se obtuvieron a partir de [25]. En cuanto a las propiedades del aire se suponen constantes independientemente de la temperatura, sin embargo, los datos dados corresponden a una temperatura de 20 °C.
Tabla 3.2: Parámetros del horno. [25] Parámetro
Valor
Dext
59 cm
Dint
40 cm
h
30,5 cm 0,8 W/(m·K) 1,18 kg/m
c p
1,005 kJ/(kg·K)
Con estos datos se obtuvieron la resistencia térmica y la capacitancia térmica: (3.2-8) (3.2-9)
41 De acuerdo con estos datos la función que describe el sistema es: (3.2-10) Se utilizó un controlador proporcional integral, diseñado utilizando sintonización analítica del servocontrol. El objetivo es que la constante de tiempo del lazo cerrado sea la mitad de la de la planta, al mismo tiempo que se espera que responda como un sistema de primer orden sin error permanente. De ese modo se obtiene: (3.2-11) (3.2-12) Como punto de operación nominal se eligió que la temperatura del horno sea de 1800 K. El ámbito de medición va de 0 K a 3000K, por lo tanto la constante del elemento de medición es: (3.2-13) El ámbito de actuación es de 0W a 5000W, por lo tanto la constante del actuador es de: (3.2-14) Posteriormente, se explica como crear el sistema en SimForge. Para ello se utilizan la capacitancia térmica, la resistencia térmica, la fuente de flujo de calor, la fuente de temperatura y un sensor de temperatura de la biblioteca térmica. Además, de la biblioteca de bloques, las ganancias para los elementos de medición y actuación, el controlador PI, el bloque de realimentación y la fuente “TimeTable”. El sistema obtenido se muestra en la Figura 3.8.
42
Figura 3.8: Diagrama de control de lazo cerrado para el horno. Posteriormente se simula un cambio escalón en el valor de temperatura deseada de 1800 K a 2000 K. El resultado se muestra en la Figura 3.9. Allí se observa que el sistema no tiene error permanente y actúa como un sistema de primer orden. Además, se cumple la especificación para la constante de tiempo, ya que se espera que el sistema llegue a su valor final en 23,65 s (la mitad del tiempo necesario para que lo haga la planta por sí sola).
43
Figura 3.9: Respuesta al escalón con el lazo cerrado para el horno. 3.2.3 Ejemplo 3: Control del nivel de un tanque En este caso se deseaba controlar el sistema de tanques en cascada mostrado en la Figura 3.10. La variable controlada es el nivel del segundo tanque, mientras que la manipulada es el caudal de entrada. El caudal q 3 se cambia manualmente y un cambio en este valor se considera como una perturbación del sistema.
44
Figura 3.10: Sistema de tanques en cascada. Tabla 3.3: Parámetros del sistema de tanques. Parámetro
Valor
A1= A2=A
12 m
h1=h2
2m
k 1
2,5·10- m /(N·s )
k 2
1,6·10- m /(N·s ) 1000 kg/m
g
9,8 m/s
El modelo en variables de estado es: (3.2-15) (3.2-16)
45 (3.2-17) con (3.2-18) (3.2-19) (3.2-20) Además, la característica estática está dada por: (3.2-21) (3.2-22) Sustituyendo los valores de los parámetros, eligiendo un caudal de entrada (q e) de 1 m3/s y un caudal de salida (q 3) de 0,3 m3/s se obtuvo el punto de operación alrededor del cual se trabajó: (3.2-23) (3.2-24) Linealizando el modelo en variables de estado y sustituyendo los valores se obtuvo: (3.2-25) (3.2-26) donde: (3.2-27) (3.2-28)
46 A partir del modelo en variables de estado se encontró la función de transferencia que describe el sistema:
(3.2-29)
El sistema se controló con un PID de dos grados de libertad, diseñado mediante sintonización analítica [2], para ello se supone que la perturbación no está presente: (3.2-30) Además como parámetro de diseño se eligió que
sea 1. Así se obtuvo: (3.2-31) (3.2-32) (3.2-33) (3.2-34) (3.2-35) (3.2-36)
47 El ámbito de medición va de 0 m a 2 m, por lo tanto la constante del elemento de medición es de: (3.2-37) El ámbito de actuación es de 0m 3/s a 2m3/s, por lo tanto la constante del actuador es de: (3.2-38) Posteriormente se explica el proceso para crear este sistema en SimForge. En este caso se utilizan únicamente componentes de la biblioteca de bloques. La planta es representada mediante dos bloques de función de transferencia, uno para la parte que es función de la entrada y otro para la parte que es función de la perturbación. El bloque de función de transferencia modela funciones de la forma: (3.2-39) donde “nb” corresponde al número de coeficientes en el numerador y “na” al número de coeficientes en el denominador. Como parámetros es necesario introducir los coeficientes. Luego se crea el controlador de dos grados de libertad utilizando dos bloques, uno para Cr y otro para Cy. Para el bloque Cr se utiliza una función de transferencia, mientras que para Cy se utiliza un bloque PID. Dicho bloque está definido por la función de transferencia: (3.2-40)
48 lo cual permite que el controlador sea realizable, cuanto mayor sea N d más se acerca al controlador ideal. Finalmente se agregan los bloques de ganancias, realimentación y dos fuentes, una para producir un cambio escalón en el valor deseado y otra para el cambio en la perturbación. El modelo obtenido se muestra en la la Figura 3.11. 3.11. Simulando se obtiene la respuesta ante un cambio en el valor deseado (Figura 3.12) 3.12) y la respuesta ante una perturbación (Figura 3.13), 3.13), se observa que en ninguno de los dos casos hay error permanente.
Figura 3.11: Sistema de tanques en cascada creado en SimForge.
49
Figura 3.12: Respuesta del servo-control.
Figura 3.13: Respuesta del control regulatorio.
50
3.2.4 Ejemplo 4: Control de la velocidad de una banda transportadora En este caso se desea controlar una banda transportadora utilizada para trasladar chips, la variable controlada es la velocidad y la variable manipulada es la tensión del motor de corriente continua utilizado para mover la banda. El esquema que la representa se muestra en la Figura la Figura 3.14. 3.14. Los parámetros del sistema se indican en la Tabla 3.4, 3.4, donde R a corresponde a la resistencia de armadura del motor, L a a la inductancia de armadura, J al momento de inercia del motor, r es el radio, k el módulo de elasticidad de la banda y M la suma de la masa que se desea transportar y la de la banda.
Figura 3.14: Esquema que representa la banda transportadora.
51 La función de transferencia del sistema es:
(3.2-41)
Tabla 3.4: Parámetros de la banda transportadora. Parámetro
Valor
R a
4,09 Ω
La
0,55 mH
k f1= k f
0,0351 Nm/A
k f2= k f
0,0351 Vs/A
J
4,3·10- kgm
r
1·10-2 m
k
100 N/m
M
0,2 kg
El ámbito de medición va de 0 m/s a 2 m/s, por lo tanto la constante del elemento de medición es: (3.2-42) El ámbito de actuación es de 0V a 6V, por lo tanto la constante del actuador es de: (3.2-43) Como punto de operación inicial se eligió V a=3,6 V y, por lo tanto, v 2=1,0256 m/s.
52 Con el fin de obtener un modelo de orden reducido a partir de la curva de reacción, se crea el modelo en SimForge. Para ello se utilizan la resistencia, la inductancia, la fuente de tensión, la tierra y la fuerza contraelectromotriz de la biblioteca de componentes eléctricos. De la biblioteca de componentes mecánicos rotacionales se utilizan la inercia y el componente “IdealGear R2T”. Éste último permite convertir el torque y el desplazamiento angular en fuerza y desplazamiento lineal, respectivamente. Para ello su parámetro es la relación entre el ángulo y el desplazamiento, lo cual equivale al inverso del radio. De la biblioteca de componentes mecánicos traslacionales se seleccionan la masa, el resorte y el sensor de velocidad lineal. Además se agregan los componentes de la biblioteca de bloques necesarios para las ganancias y la fuente. Con el fin de realizar el escalón en el punto de operación pero graficarlo a partir de 0, se agregan además dos bloques de suma y dos fuentes constantes. En la primera se elige un valor de -0,6 y en la segunda de -0,5128, que corresponden al punto de operación normalizado. Conectando se obtiene la Figura 3.15. Finalmente, simulando de 0 s a 10 s, con un paso fijo de 1·10 -6 y realizando los acercamientos adecuados se obtiene la Figura 3.16. A partir de la curva de reacción se obtiene un modelo de segundo orden más tiempo muerto utilizando el método 123c [2]: (3.2-44)
53
Figura 3.15: Planta para obtener la curva de reacción. Con el modelo obtenido, se sintoniza un controlador PID ideal mediante la síntesis analítica del servo-control [2], con
=1. (3.2-45) (3.2-46) (3.2-47) (3.2-48) (3.2-49)
54
Figura 3.16: Curva de reacción de la planta.
55 Para simular la respuesta del lazo cerrado se agregan el controlador PID, el bloque de realimentación y el otro bloque de ganancia necesario para expresar el valor deseado sin normalizar. Además, se desea simular una perturbación representada por una fuerza que se opone al movimiento de la masa, causada por ejemplo por un objeto que se interponga en su camino. Para ello se agrega otra fuente del tipo “TimeTable” que aumenta a 1 N a los 10 s. Esta se conecta a una Fuerza de la biblioteca mecánica traslacional. El modelo obtenido se muestra en la Figura 3.17. Simulando de 0 s a 15 s con un paso fijo de 1·10 -6 y realizando los acercamientos adecuados se obtienen la Figura 3.18 que corresponde a la respuesta del servo-control y la Figura 3.19 que corresponde al control regulatorio, en ninguno de los dos casos hay error permanente.
Figura 3.17: Diagrama de control de lazo cerrado para la banda.
56
Figura 3.18 Respuesta del servo-control de la banda transportadora.
Figura 3.19: Respuesta del control regulatorio de la banda transportadora.
57
3.3
Limitaciones de OpenModelica y SimForge Como ya se mencionó anteriormente, para utilizar OpenModelica de una forma
eficiente, es necesario combinarlo con una interfaz gráfica como SimForge. Sin embargo, SimForge tiene aún limitaciones en la parte gráfica: algunas veces los esquemas pueden verse borrosos, además, al abrir archivos con una computadora diferente de la que se utilizó para crearlos, los esquemas pueden desacomodarse y volverse ilegibles. Otro problema es que no siempre indica los errores de programación, en estos casos puede volverse imposible simular o abrir el archivo nuevamente utilizando SimForge, lo que obliga a corregirlo utilizando un editor de texto. Dentro de las limitaciones de OpenModelica está que solamente permite realizar simulaciones en el dominio del tiempo, por lo tanto no es posible obtener gráficas en el dominio de la frecuencia tales como diagramas de Bode o de Nyquist. Además aún no permite utilizar todos los componentes de la biblioteca estándar de Modelica.
Capítulo 4: Conclusiones y recomendaciones Conclusiones •
Modelica es un lenguaje de programación orientado a objetos, desarrollado para modelar y simular sistemas físicos que combinan elementos de diferente naturaleza. Una de sus principales características es la jerarquía, lo cual permite utilizar sus elementos en diferentes sistemas sin necesidad de volver a crear el código que los define.
•
OpenModelica es un programa de código abierto que utiliza el lenguaje Modelica. Permite utilizar, de la biblioteca estándar de Modelica, las bibliotecas de íconos, constantes, unidades del Sistema Internacional, funciones matemáticas, bloques, componentes eléctricos, mecánicos, térmicos, diagramas de estado y visualización.
•
Crear modelos utilizando únicamente OpenModelica, es un proceso complicado, ya que sólo se puede programar mediante texto. Es más recomendable utilizarlo en combinación con una interfaz gráfica, como es el caso de SimForge, que es también de código abierto.
•
El uso conjunto de OpenModelica y SimForge permite crear y simular modelos correspondientes a diferentes tipos de plantas, por ejemplo eléctricas, mecánicas (rotacionales y traslacionales), térmicas y combinaciones de las anteriores. Además, aunque OpenModelica no trabaja con bibliotecas hidráulicas, estos sistemas pueden simularse utilizando funciones de transferencia de la biblioteca de bloques, pero deben linealizarse previamente. 58
59 •
Al ser posible combinar elementos de diferente naturaleza, también es posible diseñar controladores, crear el modelo utilizando OpenModelica y SimForge y simular la respuesta a lazo cerrado. La biblioteca de bloques de Modelica cuenta con un controlador PI y un controlador PID ideal. Aunque no cuenta con controladores de dos grados de libertad, es posible crearlos utilizando el controlador PID ideal y los bloques de función de transferencia.
•
Debido a que SimForge es aún un programa reciente (su primera versión fue lanzada en diciembre del 2008), presenta algunos problemas, por ejemplo, algunas veces las imágenes pueden verse borrosas. Además, si el usuario comete un error de programación, es posible que no lo indique pero la simulación falle o no sea posible abrir el archivo posteriormente, lo cual obliga a corregir el código utilizando un editor de texto como el bloc de notas. Recomendaciones
•
Se recomienda utilizar OpenModelica y SimForge en el curso IE-0431 Sistemas de Control como complemento, ya que permitiría a los estudiantes simular diferentes tipos de sistemas dinámicos y sus controladores en un entorno gráfico e intuitivo, además de conocer el lenguaje de programación Modelica. Sin embargo, debido a los inconvenientes que aún presentan los programas, no debería usarse como reemplazo de los programas con los que se trabaja actualmente.
•
Debido a que los componentes eléctricos, mecánicos y térmicos se modelan de forma muy similar a la estudiada en el curso IE-0409 Análisis de Sistemas, también
60 podrían utilizarse OpenModelica y SimForge como complemento en el tema de modelado de este curso. •
Se recomienda seguir los avances de OpenModelica y SimForge en versiones futuras. De acuerdo con [15], PELAB está trabajando para que las próximas versiones de OpenModelica permitan utilizar la biblioteca de fluidos (“Media/Fluid”) y elementos mecánicos tridimensionales (“Multibody”). Además estudiar la herramienta de SimForge que permite trabajar con diagramas de escalera siguiendo la norma IEC61131-3 y la posibilidad de aplicarla al curso IE-1103 Temas Especiales II Controladores Lógicos Programables.
•
También se recomienda investigar sobre programas comerciales que utilicen el lenguaje Modelica con el fin de comparar sus características y herramientas con las presentes en OpenModelica y SimForge.
BIBLIOGRAFÍA Artículos de revistas [1]
Fritzon, P et al. “ OpenModelica - A Free Open-Source Environment for System
Modeling, Simulation and Teaching ”, Proceedings on the 2006 IEEE Conference on Computer Aided Control Systems Design, 2006. Libros [2]
Alfaro, V.M. “Apuntes del Curso IE-0431 Sistemas de Control ”, Escuela de Ingeniería Eléctrica, Universidad de Costa Rica.
[3]
Alfaro, V. M. “Modelado y Análisis de los Sistemas Dinámicos utilizando la Red
Generalizada”. Escuela de Ingeniería Eléctrica, Universidad de Costa Rica. 2005. [4]
Castro, A. “Modelado y simulación de sistemas dinámicos para estudios de
control”, Proyecto de Graduación, Escuela de Ingeniería Eléctrica, Universidad de Costa Rica. 2008. [5]
Fritzon, P. et al. “ OpenModelica Users Guide ”, 2008.
[6]
Fritzon, P. “Principles of object-oriented modeling and simulation with
Modelica 2.1”,Wiley-IEEE. 2003 [7]
Leva, A et al. “ SimForge-Minimal How To, Users Guide ”, 2009.
[8]
Loría, G. “Apuntes del Curso IE-0409 Análisis de Sistemas ”, Escuela de Ingeniería Eléctrica, Universidad de Costa Rica.
[9]
Ogata, K. “Ingeniería de Control Moderna ”, Prentice Hall. España. 2006.
[10]
Tiller, M. “Introduction to physical Modeling with Modelica ”, Kluwer Academic Publishers. Estados Unidos. 2001.
Páginas web: [11]
Donida, F. “SimForge”, https://trac.ws.dei.polimi.it/simforge/ 61
62 [12]
Fritzon, P. “Introduction to Object-Oriented Modeling and Simulation with
OpenModelica Tutorial ”, http://www.ida.liu.se/~pelab/modelica/OpenModelica/Documents/ModelicaTutorial Fritzson.pdf [13]
Harvey, G. “GNU Operating System ”, http://www.gnu.org/software/emacs/
[14]
Haugwitz, S. “ Modelica basics, Part II ”. Dept. of Automatic Control, Lund University. http://www.control.lth.se/cpdc/PhDcourse07/modelica_lecture2_eight_slides.pdf
[15]
Linköping University. “ The OpenModelica Project ”, http://www.ida.liu.se/~pelab/modelica/OpenModelica.html
[16]
MathCore Engineering AB. “ Modeling and Simulation with MathModelica ”. http://www.mathcore.com/products/mathmodelica/
[17]
Modelica and the Modelica Association. “ Modelica® - A Unified Object-Oriented
Language for Physical Systems Modeling. Language Specification Version 3.1 ”, http://www.modelica.org/documents/ModelicaSpec31.pdf [18]
Modelica and the Modelica Association. “ Modelica® - A Unified Object-Oriented
Language
for
Physical
Systems
Modeling.
Tutorial
Version
1.4 ”,
http://www.modelica.org/documents/ModelicaTutorial14.pdf [19]
Otter, M et al. “StateGraph-A Modelica Library for Hierarchical State
Machines”. Proceedings on the 4 th International Modelica Conference, 2005. http://www.Modelica.org/events/Conference2005/online_proceedings/Session7/Ses sion7b2.pdf [20]
Pop, A et al, “ OpenModelica Development Environment with Eclipse
Integration for Browsing, Modeling and Debugging”,http://www.modelica.org/events/modelica2006/Proceedings/sessions/S ession5a1.pdf [21]
Pop, A. “Modelica Language Design ”, http://www.ida.liu.se/~pelab/modelica/language.shtml
[22]
“Metaprogramación”. http://es.wikipedia.org/wiki/Metaprogramaci%C3%B3n
63 [23]
“Modelica and the Modelica Association”, www.modelica.org
[24]
“MaxonMotor”. http://www.maxonmotor.com/
[25]
“TodoArt”. http://www.todoart.com/horno_ceramica_estudio_top.htm
APÉNDICES A continuación se incluyen como apéndices la “Guía Introductoria para el uso de OpenModelica” y el documento “Simulación y Control de Sistemas Dinámicos utilizando OpenModelica: Ejemplos”.
64
Universidad de Costa Rica Facultad de Ingeniería Escuela de Ingeniería Eléctrica
Guía Introductoria para el uso de OpenModelica
Elaborado por: Mariana Barrantes Chaves
Diciembre, 2009
ÍNDICE GENERAL INTRODUCCIÓN ................................................................................. 1 1 GENERALIDADES..................................................................... 2 1.1 1.2 1.3 1.4
1.5
MODELICA ....................................................................................................... 2 OPENMODELICA .............................................................................................. 4 SIMFORGE ........................................................................................................ 6 SINTAXIS DEL LENGUAJE MODELICA ................................................................ 6 1.4.1 Números, constantes, parámetros y ecuaciones .................................. 7 1.4.2 Clases................................................................................................... 7 1.4.3 Vectores y matrices ............................. .............................................. 12 1.4.4 Anotaciones ....................................................................................... 14 LA BIBLIOTECA ESTÁNDAR DE MODELICA...................................................... 14 1.5.1 Biblioteca de íconos .......................................................................... 15 1.5.2 Biblioteca de constantes .................................................................... 16 1.5.3 Biblioteca de unidades del Sistema Internacional ............................. 17 1.5.4 Biblioteca de funciones matemáticas ................................................ 18 1.5.5 Biblioteca de bloques ........................................................................ 19 1.5.6 Biblioteca de componentes eléctricos ............................................... 20 1.5.7 Biblioteca de componentes mecánicos .............................................. 20 1.5.8 Biblioteca de componentes térmicos ................................................. 22 1.5.9 Biblioteca de diagramas de estado .................................................... 23 1.5.10 Biblioteca de visualización .............................................................. 24
2
INSTALACIÓN ......................................................................... 25
2.1 2.2
DESCARGA E I NSTALACIÓN DE OPENMODELICA ............................................ 25 DESCARGA E I NSTALACIÓN DE SIMFORGE ..................................................... 27
3
MODELADO Y SIMULACIÓN .............................................. 30
3.1 3.2
CREACIÓN Y SIMULACIÓN DE UN MODELO UTILIZANDO OMSHELL ................ 30 CREACIÓN Y SIMULACIÓN DE UN MODELO UTILIZANDO SIMFORGE ................ 33
4 LIMITACIONES ....................................................................... 40 BIBLIOGRAFÍA .................................................................................. 41
i
ÍNDICE DE FIGURAS Figura 1.1: Jerarquía en el lenguaje Modelica [12]. ......................... ...................................... 3 Figura 1.2: Esquemáticos creados con programas que usan el lenguaje Modelica.[5] .......... 4 Figura 1.3: Arquitectura de OpenModelica. [5] ..................... ................................................ 5 Figura 1.4: Ícono de un medidor de tensión. ........................................................................ 16 Figura 1.5: Elementos de la biblioteca de bloques. ................... ........................................... 19 Figura 1.6: Elementos de la biblioteca de componentes eléctricos. ..................................... 20 Figura 1.7: Elementos de la biblioteca de componentes mecánicos traslacionales. ............. 21 Figura 1.8: Elementos de la biblioteca de componentes mecánicos rotacionales. ............... 22 Figura 1.9: Elementos de la biblioteca de componentes térmicos. ....................................... 23 Figura 1.10: Modelo realizado con la biblioteca de diagramas de estado. [17] ................... 23 Figura 1.11: Animación de un péndulo tridimensional. [4] .................................................. 24 Figura 2.1: Página de Internet de The OpenModelica Project. ............................................. 25 Figura 2.2: Descarga de OpenModelica. .............................................................................. 26 Figura 2.3: Vínculo para ir a la página de SimForge. ........................................................... 27 Figura 2.4: Descarga de SimForge 0.8.5zip. ......................................................................... 28 Figura 2.5: Ícono para iniciar SimForge. .............................................................................. 29 Figura 2.6: Indicación de rutas. ............................................................................................ 29 Figura 3.1: Modelo creado en el Bloc de notas. ................................................................... 31 Figura 3.2: Simulación de un circuito RC utilizando OMShell............................................ 33 Figura 3.3: Creación de un nuevo proyecto. ......................................................................... 34 Figura 3.4: Creación de un paquete. ............................. ........................................................ 34 Figura 3.5: Editor gráfico y de texto. .................................................................................... 35 Figura 3.6: Colocación del capacitor. ................................................................................... 36 Figura 3.7: Cambio en el valor de los parámetros. ............................................................... 37 Figura 3.8: Circuito RC creado en SimForge. ............................... ....................................... 38 Figura 3.9: Resultado de simulación. .................................................................................... 39 ii
Introducción El control automático aplicado a la industria, permite operar los procesos de una manera más segura, eficiente y uniforme, permitiendo que la producción sea de una mayor calidad, al mismo tiempo que se reducen los costos de fabricación. Por esta razón, éste es de gran importancia dentro de la ingeniería eléctrica. Su desarrollo, unido a la necesidad de estudiar los diferentes procesos que se requiere automatizar, ha llevado a la creación de una amplia variedad de programas que permiten modelar y simular diferentes tipos de sistemas. El propósito de esta guía, es introducir al lector al uso de uno de estos programas, OpenModelica, en conjunto con SimForge como interfaz gráfica, ambos de código abierto. Para ello se presentan los fundamentos del lenguaje Modelica así como los elementos de sus bibliotecas. Además se indica como descargar e instalar OpenModelica y SimForge. Finalmente se muestra como crear y simular un modelo mediante la creación de un circuito RC.
1
1 Generalidades 1.1 Modelica Modelica es un lenguaje de programación orientado a objetos, desarrollado para modelar y simular sistemas físicos que combinan elementos de diferentes dominios (eléctricos, mecánicos, hidráulicos y térmicos entre otros). Los modelos que se crean utilizando este lenguaje se describen utilizando ecuaciones algebraicas, diferenciales y discretas [21]. Es desarrollado por una organización sin fines de lucro llamada “Modelica Association” con sede en Linköping, Suecia Según [21] su uso en las industrias ha ido aumentando desde su creación, especialmente en las compañías automotrices como Audi, BMW, Daimler, Ford, Toyota y VW. También es utilizado en compañías proveedoras para plantas de generación eléctrica, tales como ABB, EDF y Siemens. Una de las principales características de Modelica es la jerarquía. Esta permite crear elementos que luego pueden utilizarse dentro de otros más complejos, sin necesidad de volver a escribir el código que los define [12]. Por ejemplo, el modelo de un capacitor puede utilizarse dentro de un circuito eléctrico sin necesidad de volver a escribir las ecuaciones que lo describen. Un ejemplo de esto se muestra en l a Figura 1.1.
2
Modelica cuenta con varias bibliotecas en las cuales se encuentran disponibles modelos de diversos elementos. Su biblioteca estándar (“Modelica Standard Library”) contiene 800 modelos y 550 funciones de diferentes dominio s [15].
Figura 1.1: Jerarquía en el lenguaje Modelic a [12]. Para utilizar el lenguaje y sus bibliotecas es necesario contar con un entorno de simulación, el cual puede ser comercial o de código abierto. El uso de esos programas permite que los modelos presentes en las diferentes bibliotecas puedan utilizarse con un editor de texto o mediante esquemáticos, lo cual facilita su uso. Un esquemático contiene diferentes elementos conectados mediante puertos que describen la manera en que
3
interactúan, algunos ejemplos se muestran en la Figura 1.2. Internamente, estos elementos están descritos mediante ecuaciones utilizando la sintaxis de Modelica . [15]
Figura 1.2: Esquemáticos creados con programas que usan el lenguaje Modelic a.[5]
1.2 OpenModelica Open Modelica es un programa de código abierto que permite realizar simulaciones utilizando Modelica como lenguaje. Es desarrollado por el laboratorio de programación de la Universidad de Linköping, llamado “Programming Environments Laboratory (PELAB)” [19]. Está formado por varios subsistemas que se relacionan entre sí, estos se muestran en la Figura 1.3. Para utilizar el programa es necesario conocer tres de ellos:
4
•
Administrador de Sesión Interactivo (OMShell): Se encarga de interpretar los comandos para evaluar expresiones, simular y graficar.
•
Editor en forma de cuaderno (OMNotebook): es un programa en forma de cuaderno que puede utilizarse para escribir modelos, simular y graficar. Además se usa para manejar un tutorial de Modelica llamado “DrModelica”.
•
Editor gráfico de modelos: es un editor gráfico que permite conectar elementos de las bibliotecas para crear modelos y simularlos. En realidad OpenModelica no cuenta con un editor gráfico propio, pero permite utilizar, enlazados con el programa, editores como SimForge.
Figura 1.3: Arquitectura de OpenModelica . [5] La versión probada más reciente de OpenModelica es la 1.4.5., y es la que se utiliza en esta guía. Sin embargo, el 19 de setiembre del 2009 se lanzó la versión 1.5.0Bet a [13]. 5
1.3 SimForge SimForge es una interfaz gráfica que se utiliza con OpenModelica. Es desarrollada por el Politecnico di Milano, en Italia. También es de código abierto. Tiene dos herramientas principales: la primera es para realizar modelos utilizando las bibliotecas de Modelica; la segunda es un editor para diagramas de escalera siguiendo la norma IEC61131-3. Esta guía se enfoca en la primera herramienta. SimForge permite editar tanto de manera gráfica como directamente mediante texto y destaca las palabras reservadas. Además, es posible simular y graficar directamente desde este programa.
1.4 Sintaxis del lenguaje Modelica 1 Para construir modelos utilizando el lenguaje Modelica, se utilizan diferentes elementos tales como: números, cadenas de caracteres, matrices, ecuaciones, funciones, conectores, componentes que pueden formar modelos más grandes, etc. Para formar estos elementos, es necesario realizar declaraciones de acuerdo con el lenguaje. En esta sección se explican las más importantes. Las palabras que se muestran entre paréntesis y con negritas son palabras reservadas y serán destacadas si se utiliza un editor apropiado (excepto las definiciones de los tipos de datos).
1
Todos los ejemplos de esta sección se tomaron de [16].
6
1.4.1 Números, constantes, parámetros y ecuaciones Los números en Modelica pueden ser reales (Real), enteros (Integer) o binarios (Boolean); además pueden utilizarse cadenas de caracteres (String). Por ello, cuando se va a crear una constante, un parámetro, o una variable es necesario definir a cual de esos tipos de datos corresponde. Una constante ( constant) es un valor que no cambia nunca, mientras que un parámetro ( parameter) se mantiene constante durante una simulación pero puede variarse entre simulaciones, por ejemplo el valor de una inductancia. Además, al declarar la clase de dato que se va a utilizar, es posible asignarle un valor inicial con la palabra “start”, o un valor fijo mediante el signo igual. Un ejemplo de estas declaraciones sería el siguiente: Real u, y(start=1); parameter Real T=1;
En el caso de las ecuaciones, éstas deben formarse con expresiones a la izquierda y derecha del signo igual, antecedidas por la palabra “ equation”: equation T*der(y) + y = u;
donde “der” es el operador derivada con respecto del tiempo.
1.4.2 Clases Una clase (class) es una definición de un objeto que permite volver a utilizarlo sin necesidad de volverlo a describir. Debe indicarse donde termina mediante la palabra “ end”. Por ejemplo: class LowPassFilter
7
parameter Real T=1;
Real u, y(start=1); equation T*der(y) + y = u; end LowPassFilter;
es una clase que define un filtro paso bajo. Otra clase puede conectar dos filtros pasobajo en serie “llamando” a la clase que ya se creó, de este modo se aplica la jerarquía del lenguaje: class FiltersInSeries
LowPassFilter F1(T=2), F2(T=3); equation
F1.u = sin(time); F2.u = F1.y; end FiltersInSeries;
En este caso se utiliza el tiempo ( time) como variable. En este lenguaje el tiempo siempre puede utilizarse como variable, sin necesidad de declararlo previamente. Modelica cuenta con siete tipos de clases: el modelo ( model), el conector (connector), el registro (record), el bloque (block ), la función (function), el tipo (type) y el paquete (package), cada una con sus propias características. Sin embargo, en todas ellas es posible sustituir la palabra que la define por la palabra “ class” y obtener los mismos resultados. Continuando con el ejemplo anterior, se podría por ejemplo realizar un modelo que utiliza las clases creadas, pero modifica los parámetros: model ModifiedFiltersInSeries
FiltersInSeries F12(F1(T=6), F2(T=11)); // alternative 1 FiltersInSeries F34(F1.T=6, F2.T=11); // alternative 2 end ModifiedFiltersInSeries;
8
en el ejemplo se muestran dos alternativas equivalentes para definir los valores de los parámetros. Un registro es una clase que no puede contener ecuaciones, sirve para definir parámetros, por ejemplo: record FilterData
Real T; end FilterData; record TwoFilterData
FilterData F1, F2; end TwoFilterData; model ModifiedFiltersInSeries2
TwoFilterData TwoFilterData1(F1(T=6), F2(T=11)); FiltersInSeries F12=TwoFilterData1; end ModifiedFiltersInSeries2;
Los conectores se utilizan para definir como interactúan los elementos de un sistema. Para ello Modelica utiliza pervariables y transvariables. Todas las transvariables conectadas en un mismo punto tienen el mismo valor y “la suma de todas las pervariables que inciden en un punto cualquiera es cero” [2] de acuerdo con la ley de incidencia de las
pervariables. Las pervariables se definen con la palabra “ flow” y se consideran positivas entrando al elemento: connector Pin
Real v; flow Real i; end Pin;
Los tipos ( types) son clases que se derivan de los tipos de datos (Real, Integer…) o de registros definidos previamente. Pueden servir por ejemplo para definir variables, las cuales pueden tener indicadas unidades del Sistema Internacional mediante la palabra 9
“unit”. A continuación se presenta un ejemplo en el que se utiliza en la creación de un nodo con tres resistencias conectadas: type Voltage = Real(unit="V"); type Current = Real(unit="A"); connector Pin
Voltage v; flow Current i; end Pin; model Resistor
Pin p, n; // "Positive" and "negative" pins. parameter Real R(unit="Ohm") "Resistance"; equation
R*p.i = p.v - n.v; p.i + n.i = 0; // Positive currents into component. end Resistor; model SimpleCircuit Resistor R1(R=100), R2(R=200), R3(R=300); equation connect(R1.p, R2.p); connect(R1.p, R3.p); end SimpleCircuit;
También es posible realizar modelos parciales ( partial model ), que son utilizados por otros modelos mediante el comando “ extends”. Por ejemplo, al crear los elementos de un circuito, en lugar de definir un conector para cada elemento diferente (resistencia, capacitor…) se crea un puerto mediante un modelo parcial y éste es llamado por el modelo del elemento: partial model OnePort
Pin p, n; Voltage v "Voltage drop"; equation
v = p.v - n.v; p.i + n.i = 0; end TwoPin; model Inductor "Ideal electrical inductance" extends OnePort; parameter Real L(unit="H") "Inductance"; equation
10
L*der(i) = v; end Inductor;
Las funciones son clases que contienen entradas, salidas y un algoritmo, pero no ecuaciones. Un algoritmo es una función matemática en la cual se utilizan asignaciones en lugar de ecuaciones, definidas con el símbolo “: =”. También pueden contener lazos (“while” o “for”) y condiciones si-entonces (“if” “then” “else”). Un ejemplo de función es el siguiente: function Circle input Real angle; input Real radius; output Real x; output Real y; algorithm x:= radius*Modelica.Math.cos(angle); y:= radius*Modelica.Math.sin(angle); end Circle;
Para llamar la función se indican las entradas después del nombre de la función, luego es posible asignar los resultados: >> Circle(2,2) (-0.832293673094285,1.81859485365136) >> x:=-0.832293673094285 -0.832293673094285 >> y:=1.81859485365136 1.81859485365136
Los paquetes son bloques que se usan para contener otras clases (por ejemplo modelos). De ese modo las bibliotecas se organizan jerárquicamente, por ejemplo: package Modelica package Mechanics package Rotational model Inertia // Modelica.Mechanics.Rotational.Inertia
... end Inertia; model Torque
... end Torque; end Rotational; end Mechanics;
11
end Modelica;
Finalmente, los bloques ( block ) son clases que tienen entradas ( input) y salidas (output). Se utilizan para representar funciones de transferencia y modelos en variables de estado, entre otros. Este último caso se ejemplifica en la siguiente sección.
1.4.3 Vectores y matrices Los vectores y matrices se declaran especificando las dimensiones después de la declaración del tipo de dato o del nombre del elemento: Real[3] position, velocity, acceleration; Real[3,3] transformation; Real[3,2,10] table;
o equivalentemente:
Real position[3], velocity[3], acceleration[3], transformation[3, 3]; Real table[3,2,10];
Las matrices pueden estar dentro de clases, por ejemplo: type Position = Real(unit="m"); type Position3 = Position[3];
Las columnas en las matrices se separan con comas (,) y las filas con punto y coma (;): [expr11, expr12, ... expr1n; expr21, expr22, ... expr2n; … exprm1, exprm2, ... exprmn]
Para indicar una posición en un vector o matriz se utilizan los corchetes después del nombre, por ejemplo: A[i], donde i es mayor o igual que 1. Utilizando esta notación se puede formar submatrices por ejemplo: A[i1:i2,j1:j2].
12
Es posible sumar y restar matrices con otras matrices y multiplicarlas y dividirlas entre escalares. Además el lenguaje tiene funciones matriciales como el producto cruz y hallar la transpuesta. Si no se conoce el tamaño de una matriz puede declararse utilizando dos puntos (:): A[:,:] y luego obtenerse con la función “ size” como se muestra en el siguiente ejemplo para un bloque que contiene un espacio de estados: block StateSpace parameter Real A[:, :], B[size(A, 1), :], C[:, size(A, 2)], D[size(C, 1), size(B, 2)]=zeros(size(C, 1), size(B, 2)); input Real u[size(B, 2)]; output Real y[size(C, 1)]; protected Real x[size(A, 2)]; equation assert(size(A, 1) == size(A, 2), "Matrix A must be square."); der(x) = A*x + B*u;
y = C*x + D*u; end StateSpace;
Por ejemplo, en este caso “ D[size(C,
1), size(B, 2)]”
implica que la matriz D
tiene tantas filas como C y tantas columnas como B. El uso de “ size” en este código permite asegurarse de que las matrices se pueden multiplicar y sumar. El comando “ protected” se utiliza para ocultar información que no es necesario que el usuario del programa vea. El comando “ assert” se utiliza para verificar condiciones, si estas no se cumplen entonces da un mensaje de error (en este caso verifica que la matriz A sea cuadrada).
13
1.4.4 Anotaciones Las anotaciones se usan para establecer los íconos que representan los modelos y para incluir información sobre el modelo o bibliografía adicional. Para utilizarlas se escribe la palabra “annotation” y se indica entre paréntesis la información deseada, incluyendo las características del ícono luego de la palabra “icon”. Por ejemplo: model Resistor Pin p annotation (extent=[-110, -10; -90, 10]); Pin n annotation (extent=[ 110, -10; 90, 10]); parameter R "Resistance in [Ohm]"; equation
R*p.i = p.v - n.v; n.i = p.i; public annotation (Icon(
Rectangle(extent=[-70, -30; 70, 30], style(fillPattern=1)), Text(extent=[-100, 55; 100, 110], string="%name=%R"), Line(points=[-90, 0; -70, 0]), Line(points=[70, 0; 90, 0]) )); end Resistor;
1.5 La biblioteca estándar de Modelica Modelica cuenta con una biblioteca organizada en paquetes, que contienen modelos para diferentes tipos de sistemas. La versión incluida al instalar OpenModelica 1.4.5 contiene: •
La biblioteca de íconos.
•
La biblioteca de constantes.
•
La biblioteca de unidades del Sistema Internacional.
•
La biblioteca de funciones matemáticas. 14
•
La biblioteca de bloques.
•
La biblioteca de componentes eléctricos.
•
La biblioteca de componentes mecánicos.
•
La biblioteca de componentes térmicos.
•
La biblioteca de visualización. En realidad la biblioteca estándar de Modelica cuenta con más paquetes [21], sin
embargo, OpenModelica no puede interpretar adecuadamente sus componentes.
1.5.1 Biblioteca de íconos Este paquete (“Icons”) contiene íconos que pueden ser utilizados por otras bibliotecas para crear el ícono de un modelo. Por ejemplo, en el modelo para un sensor de tensión de la biblioteca eléctrica se utiliza el ícono de medidor rotacional: model VoltageSensor
"Sensor
to
measure
the
voltage
between
two
pins" extends Modelica.Icons.RotationalSensor;
Interfaces.PositivePin p "positive pin"; Interfaces.NegativePin n "negative pin"; Modelica.Blocks.Interfaces.RealOutput v(redeclare type SignalType= SI.Voltage ) "Voltage between pin p and n (= p.v - n.v) as output signal" annotation(Icon(coordinateSystem(extent={{-100.0,100.0},{100.0,100.0}}), graphics={Text(extent={{-29.0,-11.0},{30.0,70.0}}, textString="V", fillColor={0,0,0}),Line(points={{-70.0,0.0},{90.0,0.0}}, color={0,0,0}),Line(points={{70.0,0.0},{90.0,0.0}}, color={0,0,0}),Line(points={{0.0,-90.0},{0.0,-70.0}}, color={0,0,255}),Text(extent={{-150.0,80.0},{150.0,120.0}}, textString="%name", fillColor={0,0,255})}), Diagram(coordinateSystem(extent={{-100.0,-100.0},{100.0,100.0}}), graphics={Line(points={{-70.0,0.0},{-96.0,0.0}}, color={0,0,0}),Line(points={{70.0,0.0},{96.0,0.0}}, color={0,0,0}),Line(points={{0.0,-90.0},{0.0,-70.0}}, color={0,0,255})}));
15
equation
p.i=0; n.i=0; v=p.v - n.v; end VoltageSensor;
con lo cual se crea el siguiente ícono para el modelo:
Figura 1.4: Ícono de un medidor de tensión. 1.5.2 Biblioteca de constantes La biblioteca de constantes es un paquete (“Constant.mo”) que contiene constantes de uso común como el número pi (π), la aceleración de la gravedad, el factor de conversión
para pasar de grados a radianes, etc. Para utilizarlas en un programa, es necesario definir una constante propia del programa que se iguala a la constante deseada. Por ejemplo, la siguiente función calcula la circunferencia utilizando la constante “pi” de la biblioteca: function Circunferencia input Real r; output Real C; constant Real pi=Modelica.Constants.pi; algorithm
C:=2*pi*r; end Circunferencia;
16
1.5.3 Biblioteca de unidades del Sistema Internacional Este paquete se llama “SI Units” y tiene como base las normas ISO 31-1992 “General principles principles concerning quantities, quantities, units and symbols” e ISO 1000-1992 “SI units and recommendations for the use of their multiples and of certain other units”[16]. Está conformado por la definición de las magnitudes (y unidades) del Sistema Internacional y un paquete de conversiones (“Conversions”). A su vez el programa de Conversiones tiene un paquete interno con unidades que no son del Sistema Internacional pero son de uso común (como los grados (°), las horas, los grados Celsius (°C), etc.) además de las funciones para realizar las conversiones entre unas y otras. Por ejemplo, para la velocidad en unidades SI se tiene: quantity="Velocity", final unit="m/s"); type Velocity= Real(final quantity="Velocity",
En unidades que no son del sistema internacional: type
Velocity_kmh=
Real(final
quantity="Velocity",
final
unit="km/h");
y para realizar la conversión existen dos funciones dependiendo del sentido en que se desee realizarla: function from_kmh
"Convert from kilometre per hour to metre per
second" extends ConversionIcon; input NonSIunits.Velocity_kmh kmh "kilometre per hour value"; output Velocity ms "metre per second value"; algorithm
ms:=kmh/3.6; from_kmh; from_kmh; end
o function to_kmh
"Convert from metre per second to kilometre per
hour"
17
extends ConversionIcon; input Velocity ms "metre per second value"; output NonSIunits.Velocity_kmh kmh "kilometre per hour value"; algorithm
kmh:=3.6*ms; to_kmh; to_kmh; end
En el siguiente ejemplo se muestra el uso de esta biblioteca para modelar un péndulo [12]: péndulo [12]: model SimplePendulum Modelica.SIunits.Acceleration ation g = 9.81; constant Modelica.SIunits.Acceler parameter Modelica.SIunits.Length L = 1;
Modelica.SIunits.Angle Theta; Modelica.SIunits.Angle Modelica.SIunits.AngularVelocit Modelica.SIunits .AngularVelocity y ThetaDot; equation
ThetaDot = der(Theta); der(ThetaDot) = g/L*sin(Theta); end SimplePendulum SimplePendulum ;
1.5.4 Biblioteca de funciones matemáticas El paquete de funciones matemáticas (“Math”) contiene funciones matemáticas de uso común como logaritmo natural, seno, coseno hiperbólico, tangente inversa, etc. Además, cuenta con un paquete interno formado por funciones para trabajar con matrices (cálculo de la inversa, el determinante, el rango, etc.). Por ejemplo, para la función seno el código es: function sin "sine" extends baseIcon1; input SI.Angle u; output Real y; external "C" y=sin(u) ; sin; sin; end
donde la palabra external se utiliza para invocar rutinas externas escritas en otros lenguajes, en este caso C [8]. [8]. Esta biblioteca se utiliza en forma similar a las anteriores, el siguiente
18
ejemplo muestra su uso en un bloque que modela una fuente de tensión senoidal. Este bloque también pertenece pertenece a la biblioteca estándar estándar de Modelica: block Sine "Generate sine signal" parameter Real amplitude=1 "Amplitude of sine wave"; parameter SIunits.Frequency freqHz=1 "Frequency of sine wave"; parameter SIunits.Angle phase=0 "Phase of sine wave"; parameter Real offset=0 "Offset of output signal"; SIunits.Time startTime=0 "Output=offset parameter
for
time
else
1.5.5 Biblioteca de bloques La biblioteca de bloques (“Blocks”) contiene ocho paquetes: Tipos (“Types”), Fuentes (“Sources”), No Lineales (Nonlinear), Matemáticos (“Math”), Lógicos (“Logical”), Interfaces (“Interfaces”), Discretos (“Discrete”) y Continuos (“Continuos”) Permite construir diagramas de bloques gráficamente, utilizando una interfaz (como SimForge). Cuenta con bloques de funciones de transferencia, sistemas de primer y segundo orden, espacio de estados, controladores PI y PID, fuentes de escalón, senoidales, de pulso y bloques de realimentación entre otros.
Figura 1.5: Elementos de la biblioteca de bloques. 19
1.5.6 Biblioteca de componentes eléctricos La biblioteca de componentes eléctricos (“Electrical”) tiene un paquete formado por componentes analógicos (“Analog”). Éste a su vez está integrado por ocho paquetes: con componentes Básicos (“Basic”), Ideales (“Ideal”), Interfaces (“Interfaces”), Líneas (“Lines”), Semiconductores (“Semiconductor”), Sensores (“Sensors”), Fuentes (“Sources”) y Ejemplos (“Examples”). Esta biblioteca también permite construir diagramas de bloques gráficamente utilizando una interfaz. Cuenta con bloques de inductores, resistencias, fuentes de tensión y corriente, transistores, diodos, amplificadores operacionales, modelos de líneas de transmisión y sensores entre otros.
Figura 1.6: Elementos de la biblioteca de componentes eléctricos. 1.5.7 Biblioteca de componentes mecánicos La biblioteca de componentes mecánicos (“Mechanics”) está formada por tres paquetes: el de elementos mecánicos traslacionales (“Translational”), el de rotacionales (“Rotational”) y el de tres dimensiones (“Multibody”), sin embargo, este último no se
20
puede utilizar con OpenModelica actualmente [4]. A continuación se describen los otros dos. •
Elementos Mecánicos Traslacionales: Contiene un paquete con ejemplos, otro con interfaces y otro con sensores de fuerza, velocidad, posición y aceleración. Además cuenta con amortiguadores (“Damper”), masas (“Sliding mass”), resortes (“Spring”), puntos para fijar los elementos (“Fixed”) e interfaces para generar fuerza a partir de fuentes de la biblioteca de bloques (“Force”), entre otros.
Figura 1.7: Elementos de la biblioteca de componentes mecánicos traslacionales. •
Elementos Mecánicos Rotacionales: Contiene un paquete con ejemplos, otro con interfaces y otro con sensores de torque, velocidad angular, desplazamiento angular y aceleración angular. Además cuenta con amortiguadores rotacionales (“Damper”), inercias (“Inertia”), barras de torsión (“Spring”), puntos para fijar los elementos (“Fixed”), interfaces para generar torque a partir de fuentes de la biblioteca de bloques (“Torque”) y engranajes (“Ideal Gear”) entre otros.
21
Figura 1.8: Elementos de la biblioteca de componentes mecánicos rotacionales. 1.5.8 Biblioteca de componentes térmicos El paquete de componentes térmicos (“Thermal”) está formada por dos paquetes: uno para modelar fluídos con flujo de calor (“FluidHeatFlow”) y otro paquete llamado Transferencia de calor (“HeatTransfer”). Los modelos utilizados en el primer paquete son muy diferentes de los estudiados en los cursos IE-0431 Sistemas de Control e IE-0409 Análisis de sistemas, por lo que no se tratarán en esta guía. El paquete de Transferencia de calor está formado por un paquete de interfaces, uno de ejemplos, uno que trabaja con las temperaturas en grados Celsius, otro en grados Fahrenheit y el último en grados Rankine. Los demás elementos trabajan con Kelvin, que es la unidad SI. La biblioteca de componentes térmicos cuenta con conductancias térmicas (“ThermalConductor”), capacitancias térmicas (“HeatCapacitor”), fuentes de temperatura (“FixedTemperature”) y de flujo de calor (“FixedHeatFlow”) entre otros. En el caso de las capacitancias térmicas, su modelo provoca que su temperatura inicial sea siempre de 20°C. También tiene sensores, tanto de temperatura como de flujo de calor. 22
Figura 1.9: Elementos de la biblioteca de componentes térmicos. 1.5.9 Biblioteca de diagramas de estado La biblioteca de diagramas de estado (“StateGraph”) se utiliza para simular sistemas de control basados en diagramas de escalera. Toma como base las normas IEC 848 e IEC 61131-3 [17]. Sin embargo, SimForge no puede interpretar sus componentes, por lo cual es necesario utilizar otro programa que tenga interfaz gráfica para utilizarla. Por esta razón no se profundizará al respecto.
Figura 1.10: Modelo realizado con la biblioteca de diagramas de estado . [17]
23
1.5.10 Biblioteca de visualización La biblioteca de visualización “SimpleVisual” se utiliza para realizar animaciones de los modelos con los cuales se está trabajando. Esta posibilidad está disponible en el OMNotebook, sin embargo, escapa de los objetivos de esta guía, por lo cual no se profundizará en ella.
Figura 1.11: Animación de un péndulo tridimensional . [4]
24
2 Instalación 2.1 Descarga e Instalación de OpenModelica Al ser OpenModelica un programa de código abierto, puede descargarse en forma gratuita desde el sitio WEB de The Open Source Modelica Consortium http://www.ida.liu.se/~pelab/modelica/OpenModelica.html. Para descargar la versión 1.4.5 debe visitarse la dirección electrónica mencionada y seleccionar el vínculo indicado en la Figura 2.1:
Figura 2.1: Página de Internet de The OpenModelica Project. 25
En la ventana desplegada debe seleccionarse la carpeta llamada Windows/ si trabaja con ese sistema operativo o la carpeta src/ si utiliza Linux. En la siguiente ventana se selecciona el vínculo para descargar OpenModelica y la opción Guardar:
Figura 2.2: Descarga de OpenModelica. A continuación se despliega una ventana para indicar la dirección en que desea guardar el instalador. Una vez que éste se ha guardado, se da un doble clic sobre el ícono y se selecciona ejecutar. A partir de allí deben seguirse los pasos indicados por el instalador, incluyendo definir la dirección en que desea instalar el programa. Si se utiliza Windows,
esta dirección no puede tener espacios en blanco. Cuando la instalación concluye, estarán disponibles por medio del menú los programas, OpenModelica Shell, 26
OMNotebook, un enlace para acceder a la dirección desde la cual se descargó el programa y documentos sobre el programa, incluyendo la guía de usuario.
2.2 Descarga e Instalación de SimForge En la misma dirección electrónica que se utilizó para descargar OpenModelica, se encuentra un vínculo para descargar el programa SimForge, una de sus interfaces gráficas. Para descargarlo se debe seleccionar el enlace indicado en la Figura 2.3, 2.3, con lo cual se desplegará la página en Internet de SimForge: https://trac.ws.dei.polimi.it/simforge/wiki https://trac.ws.dei.polimi.it/simforge/wiki.. En ella se debe seleccionar la pestaña llamada “Downloader” y escoger la versión que se desea descargar, en este caso la 0.8.5zip.
Figura 2.3: Vínculo para ir a la página de SimForge. 27
En ese momento se desplegará un formulario en el cual deben completarse los datos personales y seleccionar la opción “Dowload file!”. Con ello se desplegará una ventana en la cual se debe seleccionar Guardar e indicar la ruta. Además es necesario mencionar que para utilizar SimForge debe tener instalado Java versión 6 y OpenModelica 1.4.3 o superior. Para empezar a usar el programa extraiga los archivos en la carpeta que prefiera y presione doble clic en el el ícono SimForge-0.8.5jar. SimForge-0.8.5jar.
Figura 2.4: Descarga de SimForge 0.8.5zip. 28
Figura 2.5: Ícono para iniciar SimForge. La primera vez que se utiliza SimForge es necesario indicar la ruta en que están instalados OpenModelica y sus bibliotecas. Para ello debe abrirse el programa y en la barra “Tools” seleccionar “Settings”. Luego debe seleccionarse las direcciones y presionar “Check OMC Paths”, si están correctos se presiona “Save Paths” [6].
Figura 2.6: Indicación de rutas. 29
3 Modelado y simulación 3.1 Creación y simulación de un modelo utilizando OMShell Para ilustrar el uso de OMShell, se simulará la respuesta a un escalón unitario de un circuito RC con un capacitor de 1 mF y una resistencia de 1000 Ω. Por lo tanto, se espera obtener una respuesta típica de un sistema de primer orden, en este caso con una constante de tiempo de 1 s. Sin embargo, debe aclararse que OMShell no está diseñado para escribirle los programas directamente, ya que cada vez que se presiona la tecla “Enter” lo entiende como un comando para correr el programa. Por ello, para utilizar OMShell existen dos opciones:
Escribir el programa en un editor de texto, copiarlo y pegarlo.
Escribir el programa en un editor de texto como el Bloc de Notas (“Notepad” o “Notepad++”), seleccionar “Guardar como” y guardarlo con la extensión .mo.
A continuación se explica el segundo procedimiento, con lo cual se pretende también ejemplificar la sintaxis del programa. Primero debe escribirse el siguiente programa en el editor Bloc de notas: model Circ_RC Modelica.Electrical.Analog.Basic.Capacitor C1(C=0.001); Modelica.Electrical.Analog.Basic.Resistor R1(R=1000); Modelica.Electrical.Analog.Basic.Ground G1; Modelica.Electrical.Analog.Sources.StepVoltage Escalon; equation
30
connect(Escalon.n,G1.p); connect(Escalon.p,R1.p); connect(R1.n,C1.p); connect(C1.n,G1.p); end Circ_RC;
Luego se selecciona “Guardar como”, en la ventana que se despliega se escribe el nombre con la extensión .mo y en “Tipo” se selecciona “Todos los archivos”:
Figura 3.1: Modelo creado en el Bloc de notas. 31
Cabe destacar que el nombre del archivo debe ser el mismo que se le dio en el código (en este caso Circ_RC). Para ejecutarlo se abre el programa OMShell y en “File” se selecciona “Load Model”. Posteriormente se indica la ruta en la cual se encuentra el archivo. En la línea de comandos se escribirá automáticamente la instrucción LoadFile con la ruta y el nombre del archivo (también se puede cargar los archivos escribiendo este comando). Si el archivo se ha cargado correctamente el programa responderá “true”, de lo contrario escribirá “false”, indicando que es necesario corregir la sintaxis del programa. Luego es necesario cargar la biblioteca usando “File” “Load Modelica Library”. Para simular el programa se escribe: >> simulate(Circ_RC,startTime=0.0,stopTime=8.0).
Si la respuesta del programa no indica ningún error, para graficar la tensión en el capacitor se digita: >> plot({C1.v})
con lo cual se despliega una nueva ventana con el gráfico deseado, siendo posible guardarlo o exportarlo.
32
Figura 3.2: Simulación de un circuito RC utilizando OMShell.
3.2 Creación y simulación de un modelo utilizando SimForge A continuación se muestra como crear un modelo en SimForge utilizando de nuevo el ejemplo del circuito RC. Para crear un nuevo proyecto se debe seleccionar “File” “New Proyect”, indicar el nombre del proyecto (en este caso Circuito_RC) y la ruta donde desea guardarlo, como se indica en la Figura 3.3.
33
Figura 3.3: Creación de un nuevo proyecto. A continuación se creará al lado izquierdo un directorio con las carpetas “Modelica”, “IEC61131-3” y “Simulation Result”. Al dar doble clic sobre “Modelica” se despliegan “Used External Packages” que contiene la biblioteca de Modelica, “Modelica Classes” que es donde se desarrollará el nuevo proyecto y “Modelica Files”, donde se presentan los archivos con extensión .mo para su lectura o modificación (permite únicamente edición de texto). Como se explicó anteriormente, un paquete es una carpeta que contiene uno o varios modelos. Para crear un nuevo paquete debe darse clic derecho sobre “Modelica Classes” y seleccionar “Add Class”, luego se escribe el nombre del paquete (en este caso “Circuitos”) y se selecciona “Package” como tipo.
Figura 3.4: Creación de un paquete. 34
El nuevo paquete está ahora en “Modelica Classes”. Para crear un modelo se da clic derecho sobre el paquete creado y se selecciona de nuevo “Add Class”. A continuación se indica el nombre del modelo (en este caso “Circ_RC”) y en tipo se selecciona “Model”. Una vez creado al dar doble click sobre Circ_RC se despliegan el editor gráfico y el editor de texto.
Figura 3.5: Editor gráfico y de texto. Ahora se creará el circuito RC cuya respuesta al escalón desea obtenerse. Para ello debe darse doble clic en “Used External Packages”, “Modelica”, “Electrical”, “Analog”, 35
“Basic”. Luego se presiona “Capacitor” y se arrastra hasta el editor gráfico, una vez allí es necesario darle un nombre (por ejemplo C1) y al Aceptar se muestra C1 en el gráfico.
Figura 3.6: Colocación del capacitor. El tamaño puede modificarse arrastrando los puntos verdes. Para cambiar el valor del capacitor (en este caso 1mF) se le da clic derecho, luego “Properties” y se selecciona la pestaña “Parameters”, allí se digita el valor, para ello es posible utilizar notación científica, tal y como se muestra en la Figura 3.7. Para girarlo, se selecciona la pestaña “Transformations” y se indica el ángulo deseado. Del mismo modo se colocan la resistencia (con un valor de 1000Ω), la tierra y la
fuente de escalón unitario (que está en la carpeta “Sources”).
36
Para alambrar el circuito hay que colocar el puntero sobre uno de los pines, presionar shift+clic, soltar ambos, arrastrar el puntero hasta otro pin y dar clic de nuevo.
Figura 3.7: Cambio en el valor de los parámetros. Se observa como al introducir elementos o conectarlos en el editor gráfico y pasarse al editor de texto, el texto se actualiza automáticamente. Además las palabras destacadas del lenguaje se presentan en diferentes colores, facilitando su lectura. Para verificar errores y simular, se usan los íconos señalados en l a Figura 3.8. Para simular debe indicarse en que tiempo se desea iniciar y finalizar la simulación, en este caso se hará de 0s a 8s (los demás valores solicitados no son necesarios). Al concluir la simulación en la carpeta “Simulation Results” aparece en rojo Circuitos.Circ_RC.plt y se despliega una gráfica en blanco. Debe marcarse la casilla de 37
verificación que indica lo que se quiere graficar, en este caso la tensión en el capacitor. En la Figura 3.9 se muestran la casilla verificada y la gráfica deseada.
Figura 3.8: Circuito RC creado en SimForge. El resultado obtenido está almacenado en una carpeta temporal, para guardarlo se debe dar clic derecho al título en rojo y escoger “Move in simulation result”. De este modo se desplegará una ventana para indicar el nombre con que se desea guardar los resultados. Es posible guardar las gráficas obtenidas dando clic derecho sobre la figura y seleccionando “Grabar como”. Al presionar clic derecho también se presentan otras opciones que 38
permiten imprimir y acercar o alejar la gráfica. Finalmente, las herramientas encerradas en el círculo en la Figura 3.9 incluyen más opciones para las gráficas, por ejemplo, la primera a la izquierda permite, entre otros, ponerle título a la gráfica, mientras que la última a la derecha es para acercar un área de la gráfica de acuerdo con las coordenadas.
Figura 3.9: Resultado de simulación. La primera vez que se va a abrir un archivo previamente creado, debe seleccionarse “File”, “Open Project” y en la ventana que se despliega “Add to list”, e indicar la carpeta con el nombre del proyecto, en este caso “Circuito_RC”. Una vez que el proyecto se ha agregado a la lista, solo es necesario seleccionarlo y dar clic en “Open Project”. 39
4 Limitaciones Como ya se mencionó anteriormente, para utilizar OpenModelica de una forma eficiente, es necesario combinarlo con una interfaz gráfica como SimForge. Sin embargo, SimForge tiene aún limitaciones en la parte gráfica: algunas veces los esquemas pueden verse borrosos, además, al abrir archivos con una computadora diferente de la que se utilizó para crearlos, los esquemas pueden desacomodarse y volverse ilegibles. Otro problema es que no siempre indica los errores de programación, en estos casos puede volverse imposible simular o abrir el archivo nuevamente utilizando SimForge, lo que obliga a corregirlo utilizando un editor de texto. Dentro de las limitaciones de OpenModelica está que solamente permite realizar simulaciones en el dominio del tiempo, por lo tanto no es posible obtener gráficas en el dominio de la frecuencia tales como diagramas de Bode o de Nyquist. Además aún no permite utilizar todos los componentes de la biblioteca estándar de Modelica.
40
BIBLIOGRAFÍA Artículos de revistas [1]
Fritzon, P et al. “ OpenModelica - A Free Open-Source Environment for System
Modeling, Simulation and Teaching ”, Proceedings on the 2006 IEEE Conference on Computer Aided Control Systems Design, 2006. Libros [2]
Alfaro, V.M. “Apuntes del Curso IE-0431 Sistemas de Control ”, Escuela de Ingeniería Eléctrica, Universidad de Costa Rica.
[3]
Alfaro, V. M. “Modelado y Análisis de los Sistemas Dinámicos utilizando la Red
Generalizada”. Escuela de Ingeniería Eléctrica, Universidad de Costa Rica. 2005. [4]
Fritzon, P. et al. “ OpenModelica Users Guide ”, 2008.
[5]
Fritzon, P. “Principles of object-oriented modeling and simulation with
Modelica 2.1”,Wiley-IEEE. 2003 [6]
Leva, A et al. “ SimForge-Minimal How To, Users Guide ”, 2009.
[7]
Loría, G. “Apuntes del Curso IE-0409 Análisis de Sistemas ”, Escuela de Ingeniería Eléctrica, Universidad de Costa Rica.
[8]
Tiller, M. “Introduction to physical Modeling with Modelica ”, Kluwer Academic Publishers. Estados Unidos. 2001. Páginas web:
[9]
Donida, F. “SimForge”, https://trac.ws.dei.polimi.it/simforge/
[10]
Fritzon, P. “Introduction to Object-Oriented Modeling and Simulation with
OpenModelica Tutorial ”, http://www.ida.liu.se/~pelab/modelica/OpenModelica/Documents/ModelicaTutorial Fritzson.pdf [11]
Harvey, G. “GNU Operating System ”, http://www.gnu.org/software/emacs/ 41
[12]
Haugwitz, S. “ Modelica basics, Part II ”. Dept. of Automatic Control, Lund University. http://www.control.lth.se/cpdc/PhDcourse07/modelica_lecture2_eight_slides.pdf
[13]
Linköping
University.
“ The
OpenModelica
Project ”,
http://www.ida.liu.se/~pelab/modelica/OpenModelica.html [14]
MathCore Engineering AB. “ Modeling and Simulation with MathModelica ”. http://www.mathcore.com/products/mathmodelica/
[15]
Modelica and the Modelica Association. “ Modelica® - A Unified Object-Oriented
Language for Physical Systems Modeling. Language Specification Version 3.1 ”, http://www.modelica.org/documents/ModelicaSpec31.pdf [16]
Modelica and the Modelica Association. “ Modelica® - A Unified Object-Oriented
Language
for
Physical
Systems
Modeling.
Tutorial
Version
1.4 ”,
http://www.modelica.org/documents/ModelicaTutorial14.pdf [17]
Otter, M et al. “StateGraph A Modelica Library for Hierarchical State
Machines”. Proceedings on the 4 th International Modelica Conference, 2005. http://www.Modelica.org/events/Conference2005/online_proceedings/Session7/Ses sion7b2.pdf [18]
Pop, A et al, “OpenModelica Development Environment with Eclipse
Integration
for
Browsing,
Modeling
and
debugging ”,
http://www.modelica.org/events/modelica2006/Proceedings/sessions/Session5a1.pd f [19]
Pop,
A.
“Modelica
Language
Design ”,
http://www.ida.liu.se/~pelab/modelica/language.shtml [20]
“Metaprogramación”. http://es.wikipedia.org/wiki/Metaprogramaci%C3%B3n
[21]
“Modelica and the Modelica Association”, www.modelica.org
42
Universidad de Costa Rica Facultad de Ingeniería Escuela de Ingeniería Eléctrica
SIMULACIÓN Y CONTROL DE SISTEMAS DINÁMICOS UTILIZANDO OPENMODELICA: EJEMPLOS
Elaborado por: Mariana Barrantes Chaves
Diciembre del 2009
ÍNDICE GENERAL Introducción...................................................................................................... 1 1 Servo-control: Velocidad de un motor ..................................................... 2 2 Servo-control: Temperatura de un horno ............................................. 12 3 Control del nivel de un tanque................................................................ 19 4 Control de la velocidad de una banda transportadora ........................ 29 Bibliografía ..................................................................................................... 38
i
ÍNDICE DE FIGURAS Figura 1.1: Motor dc que se desea controlar. .......................................................................... 2 Figura 1.2: Modificación de la imagen de la fuente de tensión. ............................................. 7 Figura 1.3: Selección de parámetros para provocar un escalón. ............................................. 9 Figura 1.4: Impresión de pantalla con los resultados para la curva de reacción..................... 9 Figura 1.5: Diagrama de control de lazo cerrado para el motor. .......................................... 10 Figura 1.6: Respuesta al escalón con el lazo cerrado para el motor. .................................... 11 Figura 2.1: Red generalizada para el horno. ..................................... .................................... 12 Figura 2.2: Planta que representa al horno para cerámica. ................................................... 16 Figura 2.3: Diagrama de control de lazo cerrado para el horno. .......................................... 17 Figura 2.4: Respuesta al escalón con el lazo cerrado para el horno. .................................... 18 Figura 3.1: Sistema de tanques en cascada. .......................................................................... 19 Figura 3.2: Sistema de tanques en cascada creado en SimForge. ......................................... 25 Figura 3.3: Parámetros para la función de transferencia P1. ................................................ 26 Figura 3.4: Respuesta del servo-control para el sistema de tanques en cascada. ................. 28 Figura 3.5: Respuesta del control regulatorio del sistema de tanques. ................................. 28 Figura 4.1: Esquema que representa la banda transportadora. ............................................. 29 Figura 4.2: Planta para obtener la curva de reacción. ........................................................... 33 Figura 4.3: Curva de reacción de la planta. .......................................................................... 34 Figura 4.4: Diagrama de control de lazo cerrado para la banda. .......................................... 36 Figura 4.5 Respuesta del servo-control de la banda transportadora. ........................ ............ 37 Figura 4.6: Respuesta del control regulatorio de la banda transportadora............................ 37
ii
ÍNDICE DE TABLAS Tabla 1.1: Parámetros del motor. [24] .................................................................................... 3 Tabla 2.1: Parámetros del horno. [25] .................................................................................. 13 Tabla 3.1: Parámetros del sistema de tanques. ....................... .............................................. 20 Tabla 4.1: Parámetros de la banda transportadora. ............................................................... 30
iii
Introducción Existe una amplia variedad de programas que permiten modelar y simular diferentes tipos de sistemas para su automatización, entre ellos están OpenModelica y SimForge, su interfaz gráfica, ambos de código abierto. El propósito de esta guía es mostrar al lector, mediante ejemplos de diversos tipos de sistemas, el uso de estos programas para simular la respuesta de la planta, diseñar su controlador y simular la respuesta a lazo cerrado. Para ello se desarrollan cuatro ejemplos: en el primero se controla la velocidad de un motor de corriente continua, en el segundo la temperatura de un horno, en el tercero el nivel en un sistema de tanques y en el último la velocidad de una banda transportadora. Es recomendable que, antes de utilizar este documento, el usuario haya leído la “Guía Introductoria para el uso de OpenModelica”.
1
1 Servo-control: Velocidad de un motor Se desea controlar la velocidad angular de un motor de corriente continua con una masa acoplada a su eje, siendo la velocidad angular la variable controlada y la tensión de entrada la variable manipulada. La planta, representada en SimForge, se muestra en la Figura 1.1.
Figura 1.1: Motor dc que se desea controlar. En esta R a corresponde a la resistencia de armadura, L a a la inductancia de armadura y J1 al momento de inercia de la masa acoplada al eje. Los parámetros del motor se muestran en la Tabla 1.1.
2
Tabla 1.1: Parámetros del motor. [24] Parámetro
Valor
R a
2,21 Ω
La
0,26 mH
k f1
0,024 Nm/A
k f2
0,024 Vs/A
J1
3,97·10-6 kgm2
Como k f1 y k f2 son numéricamente iguales se trabaja únicamente con una constante, k f . Para este caso se encontró el modelo de la planta de forma analítica: (1-1) (1-2) (1-3) (1-4) Sustituyendo (1-3) en (1-1): (1-5) Despejando la corriente de (1-2) y sustituyendo (1-4): (1-6)
3
(1-7) Entonces: (1-8) Calculando la transformada de Laplace de (1-5): (1-9) Por lo tanto la función de transferencia está dada por: (1-10)
(1-11)
Sustituyendo los valores de los parámetros: (1-12) (1-13) (1-14) (1-15) 4
(1-16) Como el polo en 66,17 es el dominante, se decide utilizar un controlador proporcional integral sintonizado por cancelación de polos y ceros: (1-17) para que el cero del controlador cancele el polo en 66,17: (1-18) la función de lazo abierto estará dada entonces por: (1-19) (1-20) y el polinomio característico será: (1-21) que corresponde a una función de segundo orden de la forma: (1-22) Para que el sistema a lazo cerrado se comporte como un sistema críticamente amortiguado, debe cumplirse que: (1-23) (1-24) (1-25) 5
(1-26) con lo cual se obtienen los parámetros del controlador. Como punto de operación nominal se elige que la velocidad del motor sea de 375rad s-1. El ámbito de medición ira de 0 rad s -1 a 500 rad s -1, mientras que la señal de control variará de 0 a 1 en ese ámbito, por lo tanto la constante del elemento de medición será: (1-27) El ámbito de actuación para este motor es de 0 V a 12 V, por lo tanto la constante del actuador será: (1-28) Para crear el sistema en SimForge debe crearse un nuevo Paquete (“Package”) al cual en este caso se le dará el nombre de “Ej1”. Dentro de éste se creará un nuevo modelo con el nombre “Planta”. En la biblioteca de componentes eléctricos básicos se seleccionan la resistencia, la inductancia, la tierra y la fuerza contraelectromotriz (EMF), luego se modifican sus parámetros de la forma explicada en la “Guía Introductoria para el uso de OpenModelica”. Siempre en la biblioteca eléctrica, pero en la sección de fuentes (“Sources”), se encuentra la señal de tensión “SignalVoltage”, la cual funciona como interface entre los elementos de la biblioteca de bloques y los de la biblioteca eléctrica. Para colocarla en la misma forma mostrada en la Figura 1.1, es necesario cambiar en la ficha “Transformations” el ángulo por -90° y seleccionar la casilla “Horizontal Flip”. Esto con el fin de que la 6
terminal negativa de la fuente quede conectada a tierra (el sentido de giro del motor dependerá de la polarización de las terminales) y de que la entrada para los bloques quede a la izquierda, para facilitar la realización del diagrama.
Figura 1.2: Modificación de la imagen de la fuente de tensión. En la biblioteca de componentes mecánicos rotacionales, debe seleccionarse la inercia (“Inertia”) y modificar su valor en la ficha parámetros para que coincida con los datos del ejemplo. Luego, también en la biblioteca de componentes mecánicos rotacionales pero, en la parte de sensores, se selecciona el sensor de velocidad angular “SpeedSensor”. Para agregar las constantes de los elementos de medición y actuación, en la biblioteca de bloques en el paquete de funciones matemáticas se selecciona el elemento ganancia (“Gain”) y en los parámetros se indican los valores correspondientes. 7
Finalmente, en la sección de fuentes de la biblioteca de bloques se escoge “TimeTable”, esta fuente produce una señal interpolando pares ordenados. En este caso, se utiliza para simular un cambio escalón en la entrada, pero, en lugar de hacerlo de 0 a 1, provocar un cambio cerca del punto de operación normal. Por ejemplo, se puede simular un escalón de 9 V a 9,6 V, a los 5 s de operación, que equivale a un cambio del 75% de la tensión máxima al 80%. Para ello, en la primera fila de la ficha parámetros se sustituyen los valores predeterminados por “{{0,0.05},{1,0.05},{2,0.05}}”, en “offset” se elige “0.75” y en “start time” 5. Una vez que se han alambrado todos los elementos es posible realizar la simulación y obtener la curva de reacción de la planta. En este caso se decidió simular de 0 s a 10 s. Con la curva de reacción de la planta se puede obtener modelos experimentales, esto se ilustrará en el ejemplo 4. Sin embargo, para ilustrar la herramienta “TimeTable” en la Figura 1.4 se muestran el escalón en la entrada y la variación en la velocidad, normalizados. Como segunda parte se creará un nuevo modelo a lazo cerrado para incluir el controlador. Para ello es necesario agregar el controlador PI que se encuentra en la biblioteca de bloques continuos, además de ajustar los parámetros correspondientes a la ganancia y el tiempo integral. También se agrega un bloque de realimentación (“Feedback”), el cual está en el paquete de elementos matemáticos de la biblioteca de bloques.
8
Figura 1.3: Selección de parámetros para provocar un escalón.
Figura 1.4: Impresión de pantalla con los resultados para la curva de reacción. 9
Por otra parte, con el fin de que los cambios en la velocidad se puedan hacer en unidades reales, se coloca a la derecha de S1 un bloque con la ganancia
, en S1 se
cambian los parámetros de la primera fila por “{{0,25},{1,25},{2,25}}” y en “offset” por 375. De este modo se simulará un cambió escalón en la velocidad de 275 rad/s a 300 rad/s. El diagrama obtenido se muestra en la Figura 1.5.
Figura 1.5: Diagrama de control de lazo cerrado para el motor. Posteriormente se simula de 0 s a 6 s. El paso para la simulación se elige de 2·10 -5, para ello en la ventana que se despliega para simular, se indica este valor en el espacio que dice “Fixed step size”. Graficando la respuesta al escalón en el servo-control y realizando un acercamiento para observar el ámbito de interés se obtiene la Figura 1.6. Allí puede observarse que el sistema a lazo cerrado es críticamente amortiguado y no tiene error permanente. 10
Figura 1.6: Respuesta al escalón con el lazo cerrado para el motor.
11
2 Servo-control: Temperatura de un horno En este caso se desea controlar la temperatura de un horno para cerámica, siendo la temperatura del horno la variable controlada y el flujo de calor que entra la variable manipulada. El horno se representa mediante una resistencia térmica, una capacitancia térmica y una fuente de flujo de calor. En la Figura 2.1 se muestra su red generalizada equivalente, Ta es la temperatura ambiente y T1 la temperatura interior del horno. T1 CT
RT
w
Ta
Figura 2.1: Red generalizada para el horno. El sistema es de primer orden y su función de transferencia está dada por: (2-1) Los datos del horno se obtienen a partir d e [25]. En cuanto a las propiedades del aire se supondrán constantes independientemente de la temperatura, sin embargo, los datos dados corresponden a una temperatura de 20 °C.
12
Tabla 2.1: Parámetros del horno. [25] Parámetro
Valor
Dext
59 cm
Dint
40 cm
h
30,5 cm 0,8 W/(m·K) 1,18 kg/m
c p
1,005 kJ/(kg·K)
A continuación se calcula la resistencia térmica, para ello se supondrá que las pérdidas de calor por el fondo y la tapa son despreciables, ya que su grosor es mucho mayor que el de las paredes. (2-2) Para la capacitancia térmica: (2-3) (2-4) (2-5) (2-6) De acuerdo con estos datos la función que describe el sistema es: 13
(2-7) Por lo tanto su constante de tiempo es 9,46 s y el sistema llega al valor final en cinco constantes de tiempo, es decir 47,3 s. Se utilizará un controlador proporcional integral, diseñado utilizando sintonización analítica del servocontrol. El objetivo es que la constante de tiempo del lazo cerrado sea la mitad de la de la planta, al mismo tiempo se espera que el sistema a lazo cerrado responda como un sistema de primer orden sin error permanente. De ese modo se obtiene: (2-8) (2-9) Como punto de operación nominal se elige que la temperatura del horno sea de 1800 K. El ámbito de medición ira de 0 K a 3000K, mientras que la señal de control variará de 0 a 1 en ese ámbito, por lo tanto la constante del elemento de medición será: (2-10) El ámbito de actuación será de 0 W a 5000 W, por lo tanto la constante del actuador es de: (2-11) Para crear el sistema en SimForge debe crearse un nuevo Paquete (“Package”) al cual en este caso se le dará el nombre de “Ej2”. Dentro de éste se creará un nuevo modelo con el nombre “Planta”. En la biblioteca de componentes térmicos se seleccionan el 14
capacitor térmico (“HeatCapacitor”) y la conductancia térmica (“ThermalConductor”) y se ajustan sus parámetros. Para ello debe tomarse en cuenta que la conductancia térmica es el inverso de la resistencia térmica. Entonces: (2-12) Además, en la biblioteca de Modelica se considera que la capacitancia térmica tiene como valor inicial 20 °C (temperatura ambiente). Para lograr el mismo efecto con la conductancia
térmica,
se
le
conecta
una
fuente
de
temperatura
constante
(“FixedTemperature”) con un valor de 293,15 K. Luego se agrega una fuente de flujo de calor (“PrescribedHeatFlow”) y un sensor de temperatura (“TemperatureSensor”). Posteriormente se agregan las constantes de los elementos de medición y actuación, utilizando los elementos de ganancia (“Gain”) de la biblioteca de bloques. Finalmente, en la sección de fuentes de la biblioteca de bloques se escoge “TimeTable”. En este caso se utiliza para simular un cambio escalón en la entrada, del 72% al 82% del máximo flujo de calor. Para ello, en la primera fila de la ficha parámetros se sustituyen los valores predeterminados por “{{0,0.1},{1,0.1},{2,0.1}}”, en “offset” se elige “0.72” y en “start time” 500. Esto permite obtener curvas de reacción de la planta. De este modo se obtiene el esquema que representa la planta, el cual se presenta en la Figura 2.2. 15
Figura 2.2: Planta que representa al horno para cerámica. Ahora se creará un nuevo modelo a lazo cerrado para incluir el controlador. Para ello es necesario agregar el controlador PI que se encuentra en la biblioteca de bloques continuos y ajustar los parámetros correspondientes a la ganancia y el tiempo integral. Además se agrega un bloque de realimentación (“Feedback”), el cual está en el paquete de elementos matemáticos de la biblioteca de bloques. Por otra parte, con el fin de que los cambios en la temperatura se puedan hacer en unidades reales, se coloca a la derecha de S1 un bloque con la ganancia
. Además, en
S1 se cambian los parámetros de la primera fila por “{{0,200},{1,200},{2,200}}” y en “offset” por 1800. De este modo se simulará un cambió escalón en la temperatura de 1800 K a 2000 K. El diagrama obtenido se muestra en l a Figura 2.3.
16
Figura 2.3: Diagrama de control de lazo cerrado para el horno. Posteriormente se simula de 0 s a 700 s. Graficando la respuesta al escalón en el servo-control y realizando un acercamiento para observar el ámbito de interés se obtiene la Figura 2.4. Allí se observa que el sistema no tiene error permanente y actúa como un sistema de primer orden. Además se cumple la especificación para la constante de tiempo, ya que se espera que el sistema llegue a su valor final en 23,65 s (la mitad del tiempo necesario para que lo haga la planta por sí sola).
17
Figura 2.4: Respuesta al escalón con el lazo cerrado para el horno.
18
3 Control del nivel de un tanque En este caso se desea controlar el sistema de tanques en cascada mostrado en la Figura 3.1.
Figura 3.1: Sistema de tanques en cascada. La variable controlada es el nivel del segundo tanque, mientras que la manipulada es el caudal de entrada. El caudal q 3 se cambia manualmente y un cambio en este valor se considera como una perturbación del sistema. Primero se encontrará el modelo del sistema en variables de estado. Sus parámetros se indican en la Tabla 3.1.
19
Tabla 3.1: Parámetros del sistema de tanques. Parámetro
Valor
A1= A1=A
12 m2
h1=h2
2m
k 1
2,5·10- m /(N·s )
k 2
1,6·10- m /(N·s ) 1000 kg/m3
g
9,8 m/s
Las ecuaciones que describen el sistema son: (3-1) (3-2) (3-3) (3-4) como: (3-5) (3-6) se obtiene: (3-7)
20
(3-8) A partir de (3-3), (3-4), (3-7) y (3-8) se encuentra que: (3-9) (3-10) Se define que: (3-11) (3-12) (3-13) entonces el modelo en variables de estado es: (3-14) (3-15) (3-16) A continuación se calculan los jacobianos y se linealiza:
(3-17)
21
(3-18)
(3-19)
(3-20)
(3-21)
(3-22) donde: (3-23) (3-24) Además, la característica estática está dada por: (3-25)
(3-26) Sustituyendo los valores de los parámetros, eligiendo un caudal de entrada (q e) de 1 m3/s y un caudal de salida (q 3) de 0,3 m3/s se obtiene el punto de operación alrededor del cual se trabajará: 22
(3-27) (3-28) Sustituyendo los valores en el modelo linealizado se obtiene: (3-29) (3-30) donde: (3-31) (3-32) A partir del modelo en variables de estado se encuentra la matriz de transferencia que describe el sistema aplicando (3-33): (3-33) (3-34) Multiplicando por las entradas:
(3-35)
23
El sistema se controlará con un PID de dos grados de libertad, diseñado mediante sintonización analítica [3], para ello se supone que la perturbación no está presente: (3-36) (3-37) además como parámetro de diseño se elige: (3-38) Así se obtiene: (3-39) (3-40)
(3-41) (3-42) (3-43) (3-44) El ámbito de medición ira de 0 m a 2 m, mientras que la señal de control variará de 0 a 1 en ese ámbito, por lo tanto la constante del elemento de medición será: (3-45) 24
El ámbito de actuación será de 0 m 3/s a 2 m3/s, por lo tanto la constante del actuador es de: (3-46) A continuación se creará el sistema en SimForge, de acuerdo con l a Figura 3.2. Para ello debe crearse un nuevo Paquete (“Package”) al cual en este caso se le dará el nombre de “Ej3”. Dentro de éste se creará un nuevo modelo con el nombre “Lazo cerrado”.
Figura 3.2: Sistema de tanques en cascada creado en SimForge. En la biblioteca de bloques continuos se selecciona el bloque de función de transferencia (“TransferFunction”) y se le da el nombre P1, este bloque corresponderá al sistema en su estado nominal. Los bloques de función de transferencia representan sistemas de la forma: 25
(3-47) donde “nb” corresponde al número de coeficientes en el numerador y “na” al número de coeficientes en el denominador. Por lo tanto en la primera fila de los parámetros debe escribirse “{1.659}” y en el denominador “{195.02,29.7,1}” tal y como se indica en la Figura 3.3.
Figura 3.3: Parámetros para la función de transferencia P1. Del mismo modo se introduce la función de transferencia P2 para representar la función de transferencia que corresponde a la perturbación, es decir, un cambio en q 3. En este caso en los coeficientes del numerador se introduce “{1.659}” y en los del denominador “{19.9,1}”. 26
A continuación se creará el controlador de dos grados de libertad utilizando dos bloques, uno para Cr y otro para C y. Para el bloque C r se utiliza una función de transferencia donde “{37.62,5.63}” son los coeficientes del numerador y “{37.75,0}” son los del denominador. Para Cy se utiliza un bloque PID de la sección de bloques continuos. Dicho bloque está definido por la función de transferencia: (3-48) lo cual permite que el controlador sea realizable, cuanto mayor sea N d más se acerca al controlador ideal. El valor predeterminado para N d es 10 y es el que se utilizará para esta simulación. En la ganancia se introduce “5.63”, en el tiempo integral “37.75” y en el derivativo “9.41”. Luego se agregan las ganancias (“Gain”) y los bloques de realimentación necesarios para representar la planta y el controlador. Finalmente se agregan dos fuentes del tipo “TimeTable” para simular un cambio escalón en el valor deseado y otro en la perturbación. En el caso del valor deseado, se elige que éste cambie 0,05 m a los 5 s de iniciada la simulación. En cuanto a la perturbación, se aumentará el caudal de salida (q 3) 0,1 m3/s 500 s después de iniciada la simulación. Posteriormente se elige simular de 0 s a 800 s con un paso fijo de 1 s. L a Figura 4.5 muestra la respuesta ante un cambio en el valor deseado, mientras que l a Figura 4.6 muestra la respuesta ante una perturbación. En ninguno de los dos casos hay error permanente. 27
Figura 3.4: Respuesta del servo-control para el sistema de tanques en cascada.
Figura 3.5: Respuesta del control regulatorio del sistema de tanques. 28
4 Control de la velocidad de una banda transportadora Se desea controlar una banda transportadora utilizada para trasladar chips, la variable controlada es la velocidad y la variable manipulada es la tensión del motor de corriente continua utilizado para mover la banda. El esquema que la representa se muestra en la Figura 4.1.
Figura 4.1: Esquema que representa la banda transportadora. Los parámetros del sistema se indican en la Tabla 4.1, donde R a corresponde a la resistencia de armadura del motor, L a a la inductancia de armadura, J al momento de inercia 29
del motor, r es el radio, k el módulo de elasticidad de la banda y M la suma de la masa que se desea transportar y la de la banda.
Tabla 4.1: Parámetros de la banda transportadora. Parámetro
Valor
R a
4,09 Ω
La
0,55 mH
k f1= k f
0,0351 Nm/A
k f2= k f
0,0351 Vs/A
J
4,3·10- kgm
r
1·10-2 m
k
100 N/m
M
0,2 kg
Las ecuaciones que describen el sistema, en el dominio de la frecuencia, son las siguientes: (4-1) (4-2) (4-3) (4-4)
30
(4-5) (4-6) (4-7) (4-8) A partir de ellas se obtiene la función de transferencia del sistema:
(3-49)
Sustituyendo los valores de los parámetros se obtiene: (3-50) El ámbito de medición ira de 0 m/s a 2 m/s, mientras que la señal de control variará de 0 a 1 en ese ámbito, por lo tanto la constante del elemento de medición será: (3-51) El ámbito de actuación será de 0V a 6V, por lo tanto la constante del actuador es de: (3-52) Como punto de operación inicial se elige V a=3,6 V y, por lo tanto, v 2=1,0256 m/s. Con el fin de obtener un modelo de orden reducido a partir de la curva de reacción, se crea el modelo en SimForge. Para ello se crea un paquete con el nombre “Ej4” y dentro de este un modelo llamado “Planta”. De la biblioteca de componentes eléctricos se 31
seleccionan la resistencia, la inductancia, la fuerza contraelectromotriz, la fuente de tensión y la tierra, en forma semejante al Ejemplo 1, y se sustituyen los parámetros. En la biblioteca de componentes mecánicos rotacionales se eligen la inercia y el componente “IdealGear R2T”. Éste último permite convertir el torque y el desplazamiento angular en fuerza y desplazamiento lineal, respectivamente. Para ello su parámetro es la relación entre el ángulo y el desplazamiento, lo cual equivale al inverso del radio, en este caso 100. Posteriormente, en la biblioteca de componentes mecánicos traslacionales se seleccionan la masa (“SlidingMass”) y el resorte (“Spring”). Además, en esta biblioteca pero, en el paquete de sensores, se escoge el sensor de velocidad (“SpeedSensor”). Luego, en la biblioteca de bloques se eligen los bloques de ganancia y la fuente “TimeTable”. El escalón para obtener la curva de reacción se hará del 60% al 70% de la tensión
máxima.
Para
ello
en
la
primera
fila
de
los
parámetros
se
escribe“{{0,0.1},{1,0.1},{2,0.1}}”, en la segunda “0.6” y en la última 5. Con el fin de realizar el escalón en el punto de operación pero graficarlo a partir de 0, se agregan además dos bloques de suma y dos fuentes constantes. En la primera se elige un valor de -0,6 y en la segunda de -0,5128, que corresponden al punto de operación normalizado. Conectando se obtiene la Figura 4.2. Finalmente, simulando de 0 s a 10 s, con un paso fijo de 1·10 -6 y realizando los acercamientos adecuados se obtiene la Figura 4.3. 32
Figura 4.2: Planta para obtener la curva de reacción. A partir de ella se obtiene un modelo de segundo orden más tiempo muerto utilizando el método 123c [2]: (3-1) (3-2) (3-3)
33
Figura 4.3: Curva de reacción de la planta. 34
(3-4) (3-5) (3-6) (3-7) (3-8) (3-9) Con el modelo obtenido, se sintoniza un controlador PID ideal mediante la síntesis analítica del servo-control [2], con
=1. (3-10) (3-11) (3-12) (3-13) (3-14)
Para simular el lazo cerrado se crea un nuevo modelo con el nombre “Lazo_cerrado” y se copia la planta. A continuación se agregan, de la biblioteca de bloques, un controlador PID, otro bloque de ganancia y uno de realimentación. Además, se desea simular una perturbación representada por una fuerza que se opone al movimiento de 35
la banda (causada, por ejemplo, por un objeto que se interponga en el camino de la masa). Para ello se agrega otra fuente del tipo “TimeTable” con un valor inicial (“offset”) de cero y que aumenta a 1 N a los 10 s. Esta se conecta a una ganancia con un valor de -1 (para indicar que se opone al movimiento), la cual a su vez se conecta a una Fuerza (“Force”) de la biblioteca mecánica traslacional. El modelo obtenido se muestra en l a Figura 4.4.
Figura 4.4: Diagrama de control de lazo cerrado para la banda. Simulando de 0 s a 15 s con un paso fijo de 1·10 -6 y realizando los acercamientos adecuados se obtienen la Figura 4.5 que corresponde a la respuesta del servo-control y la 36
Figura 4.6 que corresponde al control regulatorio, en ninguno de los dos casos hay error permanente.
Figura 4.5 Respuesta del servo-control de la banda transportadora.
Figura 4.6: Respuesta del control regulatorio de la banda transportadora. 37
Bibliografía Artículos de revistas [1]
Fritzon, P et al. “ OpenModelica - A Free Open-Source Environment for System
Modeling, Simulation and Teaching ”, Proceedings on the 2006 IEEE Conference on Computer Aided Control Systems Design, 2006. Libros [2]
Alfaro, V.M. “Apuntes del Curso IE-0431 Sistemas de Control ”, Escuela de Ingeniería Eléctrica, Universidad de Costa Rica.
[3]
Alfaro, V. M. “Modelado y Análisis de los Sistemas Dinámicos utilizando la Red
Generalizada”, Escuela de Ingeniería Eléctrica, Universidad de Costa Rica. 2005. [4]
Castro, A. “Modelado y simulación de sistemas dinámicos para estudios de
control”, Proyecto de Graduación, Escuela de Ingeniería Eléctrica, Universidad de Costa Rica. 2008. [5]
Fritzon, P. et al. “ OpenModelica Users Guide ”, 2008.
[6]
Fritzon, P. “Principles of object-oriented modeling and simulation with
Modelica 2.1”, Wiley-IEEE. 2003 [7]
Leva, A et al. “ SimForge-Minimal How To, Users Guide ”, 2009.
[8]
Loría, G. “Apuntes del Curso IE-0409 Análisis de Sistemas ”, Escuela de Ingeniería Eléctrica, Universidad de Costa Rica.
[9]
Ogata, K. “Ingeniería de Control Moderna ”, Prentice Hall. España. 2006. 38
[10]
Tiller, M. “Introduction to physical Modeling with Modelica ”, Kluwer Academic Publishers. Estados Unidos. 2001. Páginas web:
[11]
Donida, F. “SimForge”, https://trac.ws.dei.polimi.it/simforge/
[12]
Fritzon, P. “Introduction to Object-Oriented Modeling and Simulation with
OpenModelica Tutorial ”, http://www.ida.liu.se/~pelab/modelica/OpenModelica/Documents/ModelicaTutorial Fritzson.pdf [13]
Harvey, G. “GNU Operating System ”, http://www.gnu.org/software/emacs/
[14]
Haugwitz, S. “ Modelica basics, Part II ”. Dept. of Automatic Control, Lund University. http://www.control.lth.se/cpdc/PhDcourse07/modelica_lecture2_eight_slides.pdf
[15]
Linköping
University.
“ The
OpenModelica
Project ”,
http://www.ida.liu.se/~pelab/modelica/OpenModelica.html [16]
MathCore Engineering AB. “ Modeling and Simulation with MathModelica ”. http://www.mathcore.com/products/mathmodelica/
[17]
Modelica and the Modelica Association. “ Modelica® - A Unified Object-Oriented
Language for Physical Systems Modeling. Language Specification Version 3.1 ”, http://www.modelica.org/documents/ModelicaSpec31.pdf
39
