Embed Size (px)
Citation preview
Sistemas de control de motores en Tiempo Real mediante Matlab
Memoria Técnica
TITULACIÓN: Enginyeria Automàtica i Electrònica Industrial (1998)
AUTOR: Augusto Cilento DIRECTOR: Enric Vidal
FECHA: Febrero 2007.
Tengo que agradecer mucho en el transcurso de este largo trayecto, ya que he tenido otras ocupaciones que me han absorbido por completo además del presente proyecto. Es por ello que sería injusto no reconocer el apoyo de aquellos que han estado conmigo, codo con codo. Gracias a Alberto por todos los conocimientos profesionales que has compartido conmigo y la amistad demostrada. A mi tutor Enric por la paciencia y la fe depositada en mí. A mi trainer y hermano Renato por su disponibilidad y buenos consejos. A mi madre Anna por su apoyo incondicional. Y a todos aquellos que no aparecen, pero que me han tenido que padecer, sinceramente gracias.
La tarea de un hombre es sencilla. No debe permitir que su existencia se convierta en un accidente casual.
Nietzsche
Índice
i
1. Introducción................................................................................................................... 6 2. Objetivos........................................................................................................................ 6 3. Memoria descriptiva ...................................................................................................... 7
3.1. Introducción a MATLAB ...................................................................................... 7 3.2. Entorno en tiempo real con MATLAB.................................................................. 7
3.2.1. Real Time Windows Target ........................................................................... 7 3.2.2. Real-Time Windows Kernel ........................................................................... 8 3.2.3. Aplicación Real-Time .................................................................................... 9 3.2.4. Análisis y adquisición de señales .................................................................. 9 3.2.5. Ajuste de parámetros ..................................................................................... 9 3.2.6. Entorno del hardware.................................................................................. 10
3.2.6.1. Compatibilidad del PC ........................................................................ 10 3.2.6.2. Soporte del driver de entrada/salida ................................................... 10
3.2.7. Entorno del software ................................................................................... 11 3.2.7.1. Simulación en tiempo no real .............................................................. 11 3.2.7.2. Ejecución en tiempo real ..................................................................... 11
3.2.8. Simulink en modo externo............................................................................ 12 3.2.9. Buffers y transferencia de datos .................................................................. 12
3.3. Elementos físicos de la aplicación en Tiempo Real ............................................ 12 3.3.1. PC ................................................................................................................ 13
3.3.1.1. Placa de adquisición de datos ............................................................. 14 3.3.1.1.1. Sensores y actuadores ......................................................................... 14 3.3.1.1.2. Hardware de adquisición de datos ...................................................... 14 3.3.1.1.3. Hardware de acondicionamiento de la señal ...................................... 15 3.3.1.1.4. La computadora................................................................................... 15 3.3.1.1.5. Software ............................................................................................... 15 3.3.1.1.6. Hardware de la adquisición de datos.................................................. 15 3.3.1.1.6.1. Descripción de la placa de adquisición de datos NI-6024-E .............. 15 3.3.1.1.6.2. Conexión Entrada/Salida .................................................................... 16 3.3.1.1.6.3. Características del bus PCI................................................................. 19
3.3.2. Driver del Motor CC ................................................................................... 21 3.3.2.1. Microcontrolador ................................................................................ 21 3.3.2.2. GAL (Gate Array Logic)...................................................................... 22 3.3.2.3. Puente en H ......................................................................................... 22 3.3.2.4. Cuadrantes de trabajo de un motor..................................................... 22 3.3.2.5. Pulse Width Modulation ...................................................................... 23
3.3.3. Motor de corriente continua........................................................................ 24 3.3.3.1. Excitación independiente..................................................................... 25 3.3.3.2. Determinación de la constante K·Φ .................................................... 27 3.3.3.3. Placa de características del motor de corriente continua .................. 27
3.3.4. Modulo de Control ...................................................................................... 28 3.3.5. Fuente de Alimentación Variable ................................................................ 33
3.4. Elementos de Software ........................................................................................ 34 3.4.1. Herramienta GUIDE ................................................................................... 34
3.4.1.1. Paleta de componentes ........................................................................ 37 3.4.1.2. Iconos varios ....................................................................................... 37
3.4.2. Estructura de los gráficos en MATLAB....................................................... 37 3.4.2.1. Jerarquía de MATLAB ........................................................................ 37 3.4.2.2. Identificadores (handles) ..................................................................... 38 3.4.2.3. Propiedades de los objetos .................................................................. 38
Índice
ii
4. Memoria de cálculo ..................................................................................................... 39 4.1. Configuración de los elementos Hardware.......................................................... 39
4.1.1. Esquema de conexionado ............................................................................ 39 4.1.2. Tabla de conexiones .................................................................................... 40
4.2. Configuración elementos de Software................................................................. 41 4.2.1. Instalación MATLAB ................................................................................... 41 4.2.2. Instalación Compilador............................................................................... 42 4.2.3. Configuración Compilador ......................................................................... 42 4.2.4. Instalación del Kernel Real-Time Windows Target .................................... 44 4.2.5. Obtención de información de estado del kernel .......................................... 44
4.3. Modelado de la planta.......................................................................................... 45 4.3.1. Discretización de la planta.......................................................................... 48
4.3.1.1. Frecuencia de muestreo....................................................................... 48 4.3.1.2. Efecto aliasing ..................................................................................... 49 4.3.1.3. Funciones de transferencia discretas .................................................. 50
4.4. Diseño de controladores ...................................................................................... 50 4.4.1. Controlador P.............................................................................................. 52 4.4.2. Controlador PI ............................................................................................ 57 4.4.3. Limitaciones en la frecuencia de muestreo ................................................. 59
4.5. Funcionamiento del interfaz gráfico.................................................................... 61 4.5.1. Elección del modelo de trabajo ................................................................... 62
4.5.1.1. Modelo en lazo cerrado con controlador y carga ............................... 62 4.5.1.2. Modelo en lazo abierto ........................................................................ 63 4.5.1.3. Modelo en lazo cerrado sin controlador y con carga ......................... 64
4.5.2. Parámetros de entrada ................................................................................ 65 4.5.3. Parámetros del controlador ........................................................................ 65 4.5.4. Parámetros de ejecución ............................................................................. 66 4.5.5. Visualización de gráficos ............................................................................ 66
4.5.5.1. Opciones para la visualización de datos de entrada/salida................ 67 4.5.5.2. Selección datos a visualizar ................................................................ 68 4.5.5.3. Opciones de zoom y de centrado ......................................................... 68
4.5.6. Guardar y cargar datos ............................................................................... 69 4.5.7. Casilla de diálogo........................................................................................ 70 4.5.8. Botones para cerrar la aplicación............................................................... 70 4.5.9. Diagrama de flujo general .......................................................................... 70
4.6. Código fuente de la GUI...................................................................................... 72 4.6.1. Función de Apertura.................................................................................... 72 4.6.2. Parámetros de entrada ................................................................................ 76
4.6.2.1. Consigna.............................................................................................. 76 4.6.2.2. Rampa .................................................................................................. 77 4.6.2.3. Inversión de giro.................................................................................. 77 4.6.2.4. Tiempo de retardo ............................................................................... 77
4.6.3. Parámetros del controlador ........................................................................ 77 4.6.3.1. Constante proporcional....................................................................... 77 4.6.3.2. Constante integral ............................................................................... 78 4.6.3.3. Constante derivativa............................................................................ 78 4.6.3.4. Ajuste manual por función de transferencia ....................................... 78 4.6.3.5. Función controlador............................................................................ 78
4.6.4. Parámetros de ejecución ............................................................................. 79 4.6.4.1. Tiempo inicial ...................................................................................... 79
Índice
iii
4.6.4.2. Tiempo final......................................................................................... 79 4.6.4.3. Tiempo discreto ................................................................................... 79 4.6.4.4. Conexión y ejecución de la aplicación ................................................ 80 4.6.4.5. Parada de la ejecución ........................................................................ 80 4.6.4.6. Compilación ........................................................................................ 81
4.6.5. Limitación de puntos de ejecución .............................................................. 82 4.6.6. Visualización de gráficos ............................................................................ 83
4.6.6.1. Opción de gráfico AND ....................................................................... 83 4.6.6.2. Opción de gráfico OR.......................................................................... 84 4.6.6.3. Opción de gráfico SCOPE................................................................... 84 4.6.6.4. Selección de variable a visualizar ....................................................... 85 4.6.6.5. Borrar pantalla.................................................................................... 85 4.6.6.6. Activación de la cuadrícula de pantalla.............................................. 85 4.6.6.7. Casillas de selección de área de visualización ................................... 86 4.6.6.8. Zoom in ................................................................................................ 86 4.6.6.9. Zoom out .............................................................................................. 86 4.6.6.10. Selección automática de visualización ................................................ 87 4.6.6.11. Área de visualización de gráficos........................................................ 87 4.6.6.12. Visualización de gráficos .................................................................... 87
4.6.7. Parámetros de guardar y cargar datos ....................................................... 90 4.6.7.1. Nombre de la variable ......................................................................... 90 4.6.7.2. Ruta para salvar/guardar datos .......................................................... 91 4.6.7.3. Salvar/guardar datos........................................................................... 91
4.6.8. Parámetros de casilla de diálogo y cerrar aplicación ................................ 93 4.6.8.1. Casilla de diálogo................................................................................ 93 4.6.8.2. Salvar................................................................................................... 93
5. Conclusiones................................................................................................................ 94 6. Bibliografía.................................................................................................................. 95 7. Anexos......................................................................................................................... 96
7.1. Compatibilidad de bloques de Simulink y RTWT .............................................. 96 7.2. Preguntas realizadas al servicio técnico de Matlab ........................................... 104
Memoria Técnica
6
1. Introducción Desde que Michael Faraday descubrió en el siglo XIX que mediante la generación de una corriente eléctrica en un conductor en movimiento en el interior de un campo magnético producía el fenómeno de la inducción, se ha evolucionado mucho respecto a los primeros prototipos de motores eléctricos. Existen una gran variedad de tipos de motores según su tamaño, funcionamiento, tensión de alimentación, etc. En la actualidad, se hace un gran uso de estas máquinas tanto en el ámbito industrial, como en el doméstico. Hay que decir que la electrónica de potencia y los avances tecnológicos han contribuido a dar mayor cabida a estos dispositivos, tanto por la reducción del tamaño, de los consumos y de los rendimientos. Ello hace posible verlos en el interior de un teléfono móvil, de un ordenador, o en juguetes.
Pero es en la industria donde se hace más latente el uso de estas máquinas, y es donde se incorporan sistemas realimentados para el control de velocidad, de par o de ángulo. Ya desde el 300 a.C. los griegos y los árabes tuvieron la necesidad de querer medir el tiempo, conduciéndoles a realizar grandes aportes en la teoría y práctica del control automático. Pero no fue hasta el siglo XVIII, a manos del movimiento ideológico de la Ilustración, que se hicieron los avances más significativos. Durante la Revolución Industrial, con la implementación de máquinas más complejas: molinos de grano avanzados, hornos, calderas y motores a vapor; se llevaron a cabo reguladores de flotador, temperatura, presión, y control de velocidad. Los controladores proporcionan una mayor fiabilidad; lo que conlleva una mejora de cualquier proceso de fabricación, tanto en calidad como en cantidad de producción.
2. Objetivos El objetivo principal que se plantea es la realización de un entorno gráfico que permita el control ajustable de la velocidad de una máquina de corriente continua en tiempo real. Para ello se deberá conocer los siguientes entornos para desarrollar la aplicación:
La herramienta para el desarrollo del interfaz gráfico (GUIDE). Las herramientas de programa, y en especial las de Tiempo Real
(RTWT/Simulink). Los elementos físicos de la aplicación, como el driver de corriente continua
elaborado en el laboratorio, y los módulos de la casa LEYBOLD-DIDACTIC. Mediante el desarrollo de la aplicación en Tiempo Real se pretende dar una visión práctica del diseño de controladores que se imparte en las clases de teoría, permitiendo al alumno entender y visualizar gráficos del controlador que el mismo haya diseñado. Se tendrán que establecer unas protecciones para acotar los valores de tensión de entrada y salida, y así evitar desperfectos en los elementos físicos del sistema.
Memoria Técnica
7
3. Memoria descriptiva
3.1. Introducción a MATLAB El nombre de MATLAB proviene de la contracción de los términos MATrix LABoratory y fue concebido para el fácil acceso a las librerías que son de gran importancia en el campo de la computación y el cálculo matricial. MATLAB es un entorno de computación y desarrollo de aplicaciones totalmente integrado, orientado para el desarrollo de proyectos con elevados cálculos matemáticos y la visualización gráfica de estos. MATLAB integra análisis numérico, cálculo matricial, procesado de señal, todo ello en un entorno fácil para el usuario. Tanto en el mundo universitario como en el industrial, MATLAB se ha convertido en una herramienta básica para la resolución de complejos problemas matemáticos en diferentes áreas como la computación, el cálculo numérico, prototipaje algorítmico, teoría de control automático, estadística, etc. MATLAB consta de diferentes aplicaciones o toolboxes especializados orientados a ingenieros, científicos y todo tipo de profesionales técnicos. Entre ellos destacan: Sistemas de Control, Adquisición de Datos, Tiempo Real, Lógica Fuzzy, Procesamiento de imágenes, Redes Neuronales, Optimización, Procesamiento de Señal, etc.
3.2. Entorno en tiempo real con MATLAB MATLAB presenta una aplicación para hacer simulaciones en tiempo real, la toolbox Real Time Windows Target. Esta herramienta permite realizar aplicaciones de control y simulaciones en tiempo real para plantas físicas, como puede ser el caso que nos ocupa: un motor de corriente continua.
3.2.1. Real Time Windows Target
Real Time Windows Target es una herramienta de MATLAB que permite capturar y generar señales en tiempo real mediante diagramas de bloques generados con Simulink. Además, se pueden visualizar estas señales, cambiando y controlando parámetros, todo en tiempo real. Para hacerlo posible tiene que haber un elemento físico que interactúe entre Simulink y el elemento exterior que queremos controlar, recoger señales,... este elemento es la placa de adquisición de datos DAQ, que es la que permite operar con señales de entrada y/o salidas analógicas y digitales. La integración entre Simulink en modo externo y Real Time Windows Target permite utilizar el modelo de Simulink con un interfaz gráfico para:
Visualización de señales: se puede utilizar el bloque “Scope” para visualizar señales en tiempo real.
Memoria Técnica
8
Ajuste de parámetros: se realiza mediante las cajas de diálogo de los bloques en Simulink durante la ejecución en tiempo real.
3.2.2. Real-Time Windows Kernel
Un componente clave del Real Time Windows Target es un kernel en tiempo real que hace de interfaz con el sistema operativo Windows para asegurar que la aplicación en tiempo real se está ejecutando en el tiempo de muestreo seleccionado. El kernel asigna la prioridad más elevada de ejecución para la aplicación en tiempo real, y lo hace utilizando el reloj interno del ordenador como fuente principal de tiempo.
Interrupciones de tiempo: el kernel intercepta la interrupción del reloj del PC antes que el sistema operativo Windows la reciba, y bloquea cualquier llamada al sistema operativo. Entonces, el kernel utiliza la interrupción para iniciar la ejecución del modelo compilado. Para garantizar un periodo de muestreo preciso el kernel reprograma el reloj del PC a una frecuencia mayor. Debido a que el reloj del PC es también la principal fuente de tiempo para el sistema operativo, el kernel envía una interrupción al sistema operativo manteniendo la tasa de interrupción inicial.
Planificador: las interrupciones hacen de base de tiempo para un sencillo
planificador que se encarga de ejecutar las aplicaciones en tiempo real. El número de tareas es igual al número de períodos de muestreo utilizados en el modelo, configurado en modo multitasking. En modo single-tasking sólo existirá una tarea. El máximo número de tareas es 32, y las tareas más rápidas tienen más prioridad de ejecución que las más lentas. Durante la ejecución la aplicación en tiempo real almacena los datos en buffers, y posteriormente el contenido de los buffers es recuperado por el bloque Scope (ya sea para guardarlas en una variable en el Workspace o bien para imprimirlas en pantalla).
Comunicación con el hardware: el kernel hace de interfaz y comunica con el
hardware de E/S utilizando los correspondientes drivers que comprueban que la instalación de la placa DAQ sea correcta. En el caso que esto no suceda, no se nos permitirá ejecutar la aplicación en tiempo real.
Simulink en modo externo: la comunicación entre Simulink y la aplicación en
tiempo real se hace mediante Simulink con el modo External. Este es un módulo que se comunica directamente con el kernel y es utilizado para comenzar una aplicación en tiempo real, cambiar parámetros, recuperar datos del bloque Scope.
Compilador de C incorporado: las aplicaciones de Real Time Windows Target
pueden ser compiladas con LCC (solo C), que es el que viene por defecto con MATLAB.
Memoria Técnica
9
3.2.3. Aplicación Real-Time
Una aplicación en tiempo real tiene las siguientes características:
Código compilado: es el resultado de compilar el código fuente. En nuestro caso el código es el modelo.
Relación con el modelo de Simulink: el ejecutable contiene una relación
binaria de todos los componentes del modelo, conexiones entre bloques, dependencias de tiempo y variables.
Relación con el kernel: el modelo tiene que ser cargado y ejecutado
directamente por el kernel del Real Time Windows Target. Esta nunca podrá ser ejecutada sin el kernel.
Checksum: el modelo y el ejecutable de Simulink contienen un valor de
Checksum. El kernel utiliza este valor para comparar el modelo y el ejecutable, si estos son coherentes permitirá realizar la ejecución. Cuando se haga un cambio en el modelo de Simulink el valor de Checksum no varía hasta que no se hace un “rebuild”. Esto permite que cuando se cambian valores de los parámetros durante la ejecución, el mapeo de parámetros a memoria se haga de manera correcta.
3.2.4. Análisis y adquisición de señales
Se puede adquirir, visualizar y salvaguardar señales utilizando el bloque Scope de Simulink, trabajando en modo externo. Quiere decir que se puede observar el comportamiento del modelo en tiempo real y guardar los datos en el Workspace. Existen dos modalidades de captura y visualización de las señales:
Signal Tracing: proceso mediante el cual se puede adquirir y visualizar señales durante la ejecución de una aplicación en tiempo real. Es decir, nos permitirá visualizar los datos mientras que los está capturando, sin tener que esperar a que acabe la simulación (sólo se permite mediante el bloque Scope, no permite exportarlos a medida que los captura).
Signal Logging: proceso mediante el cual se puede adquirir y visualizar señales
procedentes de la aplicación en tiempo real, una vez haya acabado la ejecución o bien se haya parado manualmente. Hasta que no se cumpla alguna de las dos condiciones no se permite visualizar, guardar y/o exportar las señales (es un problema cuando se trabaja con una interfaz gráfica externa a Simulink).
3.2.5. Ajuste de parámetros
Cambiar parámetros y observar los cambios que se producen durante la ejecución en tiempo real es posible desde Simulink o bien a través de una interfaz gráfica externa.
Memoria Técnica
10
Modo External en Simulink: trabajar en este modo nos permite cambiar valores
de parámetros y transferirlos automáticamente mientras se ejecuta la aplicación en tiempo real.
Durante la ejecución en tiempo real se pueden cambiar parámetros en los siguientes elementos:
Parámetros de bloques Parámetros de bloques de subsistemas. MATLAB variables
3.2.6. Entorno del hardware
El hardware está formado por un ordenador y una placa de adquisición de datos compatibles.
3.2.6.1. Compatibilidad del PC Se pueden utilizar ordenadores que utilicen Windows NT 4.0, Windows 2000 o Windows XP.
3.2.6.2. Soporte del driver de entrada/salida El Real Time Windows Target utiliza tarjetas de adquisición estándar y económicas para ordenadores compatibles tipo PC. Cuando se ejecuta un modelo en tiempo real, el Real Time Windows Target captura los datos muestreados por medio de uno o más canales de entrada, inmediatamente son procesados en los bloques del modelo creados y los datos obtenidos se envían a los canales de salida que correspondan.
Tarjetas de adquisición: el Real Time Windows Target soporta una variedad gama y cantidad de tarjetas (ISA, PCI y PCMCIA). El número de placas soportadas está por encima de las 200. Un listado completo y las posibles autorizaciones se pueden encontrar la siguiente dirección:
http://www.mathworks.com/products/supportedio.html?prodCode=WT.
Librería de bloques para DAQ: el Real Time Windows Target provee una
librería de bloques para Simulink que contienen los drivers universales para todas las placas compatibles. Esta librería es la “rtwinlib” y contiene los bloques: Analog Input, Analog Output, Digital Input, Digital Output, Counter Input y Encoder Input.
Memoria Técnica
11
3.2.7. Entorno del software
El entorno de software es un sitio para diseñar, construir, y testear en tiempo no real y en tiempo real.
3.2.7.1. Simulación en tiempo no real Se crea un modelo con Simulink y se pone en modo “normal” para llevar a cabo una simulación en tiempo no real. Al realizar una simulación en tiempo no real, Simulink utiliza un vector de tiempo para gestionar el modelo. Después de que las salidas sean computadas por un determinado valor de tiempo, Simulink inmediatamente repite esta operación para el siguiente valor del vector de tiempo y así sucesivamente. Este proceso finalizará en el momento en que se para la simulación o bien cuando se llegue al tiempo final. Dado que este vector de tiempo no está asociado a ningún reloj, las salidas son calculadas en tiempo no real, y lo hacen tan rápido como el ordenador le permita.
3.2.7.2. Ejecución en tiempo real Para ejecutar una aplicación en tiempo real, se crea un modelo en Simulink y se pone en modo External. Para hacer una aplicación en tiempo real intervienen Real-Time Workshop, Real Time Windows Target y el compilador C/C++. La respuesta del compilador es un ejecutable que el kernel puede ejecutar en tiempo real. Esta aplicación utiliza como parámetros iniciales los que hay en el modelo en el momento de la generación del código. Durante la ejecución en tiempo real, utilizando el tiempo de muestreo fijado por el usuario, el Real Time Windows Target utiliza las interrupciones para gestionar la aplicación en tiempo real. En cada nueva interrupción el ejecutable computa los valores de salida de los bloques del modelo. Para generar código con Real-Time Workshop se utiliza el algoritmo Fixed-Step Discrete. Este algoritmo calcula el valor del tiempo para la siguiente muestra añadiendo un incremento de tiempo al actual. La precisión de la señal a representar y la longitud del tiempo de simulación resultante dependen del tiempo de muestreo escogido. Es decir, cuanto menor sea el tiempo de muestreo escogido mayor será la calidad de la señal muestreada, pero menor será el tiempo de simulación máximo. En caso que el usuario no seleccione un tiempo de muestreo, Simulink escoge uno por defecto dividiendo por 50 la diferencia del tiempo final e inicial. También hay que remarcar que este algoritmo no permite simular estados continuos.
Memoria Técnica
12
3.2.8. Simulink en modo externo
El modo externo requiere una interfaz de comunicación para pasar parámetros externos a Simulink, y al acabar la recepción, el mismo protocolo de comunicación tiene que ser utilizado para aceptar nuevos valores e insertarlos en la correspondiente posición de memoria para que sean utilizados por la aplicación en tiempo real. En algunas tarjetas de Real-Time Workshop la interfaz de comunicación utiliza protocolo TCP/IP. En el caso de Real Time Windows Target, el ordenador servidor también sirve como ordenador objetivo. Entonces, sólo se necesita un driver virtual para intercambiar parámetros entre MATLAB, el espacio de memoria de Simulink, y la memoria que es accesible para la aplicación en tiempo real. Hay que recordar que trabajando en este modo se puede obtener y visualizar señales con el bloque Scope, así como ajustar parámetros. Cuando se modifica algún parámetro de un bloque de entrada, la simulación queda pausada hasta que no se cierra la ventana de diálogo.
3.2.9. Buffers y transferencia de datos
Para cada intervalo de muestreo de la aplicación en tiempo real, Simulink almacena de manera continua datos en memoria hasta que el buffer de datos se llena. Una vez el buffer está lleno, Simulink suspende la captura de datos hasta que éstos no hayan sido transferidos a MATLAB a través del modo externo de Simulink. Cuando esto sucede, la aplicación en tiempo real continúa ejecutándose. Los datos capturados dentro del buffer son continuos. Cuando el buffer ha sido transferido a Simulink, se visualiza inmediatamente en el bloque Scope. Existe la posibilidad de poder guardar estos datos directamente en un fichero MAT.
3.3. Elementos físicos de la aplicación en Tiempo Real El conjunto del hardware que forma la aplicación en Tiempo Real se puede desglosar en seis bloques de elementos que interactúan entre sí.
PC Entradas/Salidas Driver del motor de corriente continua Motor de corriente continua Alimentación externa Realimentación
Memoria Técnica
13
En
trad
as/S
alid
as
Driver Motor CC
Alimentación
MOTOR
Realimentación
Velocidad
Rampa
Sentido de giro
Errores
Ilustración 1: Representación en bloques de los componentes del controlador.
3.3.1. PC
El ordenador personal es el encargado de capturar los datos que transmite el usuario al driver (velocidad, rampa, etc), y los datos obtenidos del motor (errores, datos de la realimentación, etc), para realizar los cálculos algorítmicos necesarios y así actualizar los valores del modelo en cada intervalo de tiempo. Es decir, la computadora y el modulo de entrada/salida, o también placa de adquisición de datos, establecerán un intercambio de parámetros para cada instante de tiempo. El PC aloja en su interior la tarjeta de adquisición de datos, los drivers de la misma, el programa MATLAB, la aplicación en tiempo real, y Simulink. Las características de la computadora utilizada y su sistema operativo son:
Procesador INTEL PENTIUM 4 a 1,80 GHz 512 MB de RAM WINDOWS 2000 (Service Pack 4) MATLAB R2006a v7.2.0.232 SIMULINK R2006a v6.4 VISUAL C/C++ v6.0
Hay que decir que estas características contribuirán a la restricción del tiempo de muestreo máximo, el número máximo de bloques en Simulink o por ejemplo la velocidad de compilación de la aplicación durante el desarrollo, entre otros.
Memoria Técnica
14
3.3.1.1. Placa de adquisición de datos La tarjeta de adquisición de datos permite capturar y/o generar señales reales e interactuar con ellas desde la aplicación en tiempo real. Un sistema de adquisición de datos esta formado por un hardware y un software que permite a un sistema digital conectarse al mundo real. El sistema de adquisición de datos típico está formado por:
Sensores y actuadores Hardware de adquisición de datos Hardware de acondicionamiento de señal Computadora o procesador Programa
Ilustración 2: Esquema del proceso de adquisición de datos
3.3.1.1.1. Sensores y actuadores
Los sensores y actuadores son aquellos que actúan como transductores, es decir estos elementos transforman una señal capturada de una naturaleza en otra señal de salida de otra naturaleza. En el caso que nos ocupa, el sensor seria el tacómetro que lee las vueltas que realiza el eje del motor y genera una señal eléctrica proporcional. El actuador es el que mediante una señal eléctrica hace que el motor gire a determinada velocidad.
3.3.1.1.2. Hardware de adquisición de datos
Es el corazón de cualquier sistema de adquisición de datos. Su función es convertir señales analógicas provenientes del mundo real a señales digitales, o bien convertir señales digitales a analógicas
Memoria Técnica
15
3.3.1.1.3. Hardware de acondicionamiento de la señal
Normalmente las señales de los sensores son incompatibles con el hardware de adquisición de datos. Para lograr esta compatibilidad habrá que acondicionar la señal, es decir que si la señal es muy pequeña habrá que amplificarla, de lo contrario atenuarla. También es muy común eliminar componentes frecuenciales de las señales.
3.3.1.1.4. La computadora
La computadora proporciona un procesador, un reloj, un bus para transferir datos y espacio de memoria o disco para almacenar datos.
3.3.1.1.5. Software
El software de adquisición de datos permite intercambiar información entre la computadora y el hardware. Por ejemplo, los programas típicos permiten configurar la tasa de muestreo de una tarjeta de adquisición y adquirir un número concreto de muestras.
3.3.1.1.6. Hardware de la adquisición de datos
El hardware de la adquisición de datos es una tarjeta de la empresa National Instruments, modelo NI-6024-E.
3.3.1.1.6.1. Descripción de la placa de adquisición de datos NI-6024-E
Las características de la placa son las siguientes:
16 canales de entrada analógica (8 diferenciales) 2 canales de salida analógica 8 líneas de entrada/salida digital conector de 86 pines Sistema de control de tiempo propio (DAQ-STC). Consta de tres grupos para
control de entradas y salidas analógicas, y para funciones de contador para propósitos generales. Estos grupos incluyen un total de siete contadores de 24 bits i tres de 16 bits con una resolución máxima de tiempo de 50 ns.
Sistema específico que permite la sincronización de varias funciones de medida a un mismo disparo o evento de reloj, y lo hacen mediante los sistemas de bus de integración en tiempo real (Real-Time System Integration, RTSI).
Conexión a bus de PC mediante ranura PCI.
Memoria Técnica
16
Ilustración 3: Diagrama de bloques de la PCI-6024E
Para hacer funcionar la placa DAQ es necesario tener los drivers e instalarlos en el PC. Para poder trabajar en el entorno de Matlab, la Toolbox Real-Time es la encargada de detectar automáticamente el dispositivo para darle funcionalidad.
3.3.1.1.6.2. Conexión Entrada/Salida
A continuación se muestra la disposición de pines de la placa de adquisición de datos, así como una breve descripción de las entradas/salidas y sus rangos.
Memoria Técnica
17
Ilustración 4: Patillaje del conector de la placa de adquisición de datos
Memoria Técnica
18
En la Tabla 1 se muestran las señales de entrada/salida con más relevancia. AIGND Analog input ground—these pins are the reference point for
single-ended measurements in RSE configuration and the bias current return point for DIFF measurements. All three ground references—AIGND, AOGND, and DGND—are connected on your device.
ACH<0..15> AIGND Input Analog input channels 0 through 15—you can configure each channel pair, ACH<i, i+8> (i = 0..7), as either one DIFF input or two single-ended inputs.
AISENSE AIGND Input Analog input sense—this pin serves as the reference node for any of channels ACH <0..15> in NRSE configuration.
DAC0OUT AOGND Output Analog channel 0 output—this pin supplies the voltage output of analog output channel 0.
DAC1OUT AOGND Output Analog channel 1 output—this pin supplies the voltage output of analog output channel 1.
AOGND Analog output ground—the analog output voltages are referenced to this node. All three ground references—AIGND, AOGND, and DGND—are connected together on your device.
DGND Digital ground—this pin supplies the reference for the digital signals at the I/O connector as well as the +5 VDC supply. All three ground references—AIGND, AOGND, and DGND—are connected on your device.
DIO<0..7> DGND Input or Output
Digital I/O signals—DIO6 and 7 can control the up/down signal of general-purpose counters 0 and 1, respectively.
+5V DGND Output +5 VDC Source—these pins are fused for up to 1 A of +5 V supply on the PCI and PXI devices, or up to 0.75 A from a DAQCard device. The fuse is self-resetting.
Tabla 1: Descripción de las señales de entrada y salida
En la Tabla 2 se reflejan los rangos y características eléctricas de las entradas/salidas de la NI-6024-E.
Signal Name Signal Type and Direction
Impedance Input/ Output
Protection (Volts) On/Off
Source (mA at V) Sink (mA atV)
Rise Time (ns)
Bias
ACH<0..15> AI 100 GΩ in parallel with
100 pF
42/35 ±200 pA
AISENSE AI 100 GΩ in parallel with
100 pF
40/25 ±200 pA
AIGND AO — — — — — —
DAC0OUT (6024E and 6025E only)
AO 0.1 Ω Short-circuit to ground
5 at 10 5 at-10 10 V/us
—
DAC1OUT (6024E and 6025E only)
AO 0.1 Ω Short-circuit to ground
5 at 10 5 at-10 10 V/jis
—
AOGND AO — — — — — —
DGND DO — — — — — —
VCC DO 0.1 Ω Short-circuit to ground
1A fused — — —
DIO<0..7> DIO — Vcc +0.5 13 at (Vcc -0.4) 24 at 0.4 1,1 50kΩpu
AI = Analog Input AO = Analog Output Note: The tolerance on the 100 kΩ
DIO = Digital Input/Output pu = pullup DO = Digital Output 50 kΩ pullup and pulldown resistors is very large. Actual value can range between
17 kΩ and
Tabla 2: Características eléctricas de las entradas/salidas de la placa de adquisición de datos
Memoria Técnica
19
En la Ilustración 5 se muestra el esquema de los canales 0 y 1 de las correspondientes salidas analógicas: DAC0OUT y DAC1OUT, que darán una tensión de salida referenciada respecto a AOGND. En la figura de la derecha hay las entradas/salidas digitales DIO<0…7> que se podrán configurar individualmente como entrada o salida según interese. En este caso, concretamente, las DIO<0…3> están configuradas como entradas y las DIO<4…7> como salidas. Las entradas digitales pueden recibir señales TTL y sensar señales de dispositivos externos, como por ejemplo el estado de un interruptor como el de la figura. Las salidas digitales pueden enviar señales TTL y controlar dispositivos externos como un LED.
Ilustración 5: Esquema salidas analógicas y entradas/salidas digitales respectivamente
3.3.1.1.6.3. Características del bus PCI
Está claro que las características del bus son un factor a tener en cuenta respecto a posibles limitaciones en el tiempo de muestreo, tamaño de los datos, transformaciones ADC y DAC, etc. Sin entrar en mucho detalle, se comentan algunas de las características más destacables. En el manual del fabricante nos advierten que estas especificaciones se han determinado a una temperatura de 25 ºC.
Memoria Técnica
20
Entrada Analógica
Características de entrada
Conversión ADC por aproximaciones succesivas
Error ±1,5 LSB en modo no diferencial
Resolución de 12 bits, 1 bit 4096
Velocidad de muestreo de 200 kS/s garantizada
Board Gain (Software-Selectable) Range
0,5 ±10 V
1 ±5 V
10 ±500 mV
100 ±50 mV
Voltaje máximo de trabajo de ±11 V
Potección contra sobretensiones
Signal Powered
On Powered
Off
ACH<0..15> ±42 ±35
AISENSE ±40 ±25
FIFO buffer size: 512 S
Configuration memory size: 512 words
Tabla 3: Características entrada analógica
Salida Analógica
Características de salida
2 canales
Resolución de 12 bits
Error ±1,5 LSB (solo no diferencial)
Tiempo máximo de actualización
DMA: 10 kHz, system dependent
Interrupts: 1 kHz, system dependent
Conversión DAC: Double buffering, multiplying
FIFO buffer size: No
Transferencia de datos: DMA, Interrupciones, E/S programadas
Voltage de salida
Rango: ± 10 V
Impedancia de salida: 0.1 Ω max
Corriente de salida: ±5 mA max
Protección contra cortocircuitos a masa
Estado de equilibrio al enceder: ±200 mV
Tabla 4: Características salida analógica
Memoria Técnica
21
Entradas/Salidas Digitales
DIO<0..7>
Digital logic levels
Level Min Max
Input low voltage 0 V 0.8 V
Input high voltage 2 V 5 V
Input low current (Vin= 0 V) — –320 µA
Input high current (Vin= 5 V) — 10 µA
Output low voltage (IOL= 24 mA) — 0.4 V
Output high voltage (IOH= 13 mA) 4.35 V —
Estado al encender: Alta impedancia en la entrada.50 kΩ pull up to +5 VDC
Transferencia de datos: E/S programadas
Tabla 5: Características de las Entradas/Salidas Digitales
3.3.2. Driver del Motor CC
El driver del motor de corriente continua está formado por toda aquella circuiteria electrónica que ha sido diseñada para gobernar la tensión de armadura del motor, entre otras funciones. Para poder realizar sus funciones consta de dos partes: la de control y la de potencia. En la de control tendremos el microcontrolador y la GAL (Gate Array Logic) que controlan al puente en H que se encarga de suministrar la potencia necesaria según mande el driver.
3.3.2.1. Microcontrolador Para realizar la gestión de las consignas de velocidad y rampa se utilizará el PIC18F252. Este elemento dispone de seis entradas analógicas y dos salidas de pwm. Sus funciones serán:
Generar una señal de salida PWM en función de la consigna de velocidad, que variará tan rápido como lo permita el valor de la rampa.
Mediante un bit externo se indicará al microcontrolador el sentido de giro del
motor. En función del valor se activará una diagonal u otra del puente en H, lo que permite girar a derechas o a izquierdas. Es decir, se genera un bit para cada transistor del puente, siendo el valor cero como el corte y uno la saturación.
Memoria Técnica
22
3.3.2.2. GAL (Gate Array Logic) El dispositivo Lógico Programable GAL es el que confiere seguridad y fiabilidad a los elementos de potencia, protegiéndolos de la recirculación de sobrecorrientes, evita cruces en las ramas de los puentes y trasmite el PWM a la señal de activación de la parte alta de los transistores del puente. El modelo de GAL es el Ispv22v10 y este tipo de dispositivos destacan por la gran rapidez - del orden de nanosegundos - , característica importante para la protección de sobrecorrientes.
3.3.2.3. Puente en H La configuración del puente en H se basa en el funcionamiento de cuatro interruptores controlados, que gestionan en todo momento la tensión media y la recirculación de la corriente de armadura. La excitación del puente en H se realiza mediante modulación por anchura de pulsos y existen dos estrategias:
Mantener una diagonal bloqueada y actuar en los dos transistores opuestos - superior e inferior -. Para invertir el sentido de giro habrá que realizar la situación contraria.
Mantener una diagonal bloqueada y actuar con el PWM en el transistor superior y dejando el inferior de la otra diagonal activado. Para invertir el sentido de giro se intercambian los papeles de las diagonales.
Ilustración 6: Estructura de puente en H típica mediante transistores IGBT
3.3.2.4. Cuadrantes de trabajo de un motor El motor de corriente continua puede trabajar en cuatro cuadrantes en función de la polaridad de la tensión y del sentido de la corriente de armadura. Modificando estos dos parámetros podremos variar velocidad o par en el eje del motor, respectivamente. Partiendo de las analogías par-intensidad y velocidad-tensión, se puede construir la siguiente tabla.
Memoria Técnica
23
Cuadrante Velocidad Par 1º + + 2º + - 3º - - 4º - +
Tabla 6: Tabla cuadrantes Par-Velocidad
Para entender el funcionamiento hay que pensar en un montacargas, que es el ejemplo más completo al respecto de los cuatro cuadrantes. En el primer cuadrante velocidad y par son positivos, lo que se pretende es subir la carga a velocidad máxima. El segundo cuadrante sería cuando se está llegando al destino y hay que frenar, entonces el par – o análogamente intensidad – se invierte para continuar subiendo pero frenando. El tercero hace bajar la carga a velocidad máxima, es la situación inversa del primer cuadrante, velocidad y par negativos. El cuarto cuadrante pasa al revés que en el segundo, se está llegando al destino y se disminuye la velocidad invirtiendo el sentido del par – el motor trabaja como generador - . Este sistema de trabajo se llama freno a contramarcha. Con una buena gestión del motor se pueden controlar todas las situaciones que pueda demandar una carga. Para ello es necesaria una topología en H.
3.3.2.5. Pulse Width Modulation La técnica del PWM está basada en que el valor medio de una señal periódica es igual a la integral entre cero y el periodo de la función de la señal respecto el tiempo, según la expresión ( 1 ).
∫ ⋅=T
dtT
tfVmed
0
)(
( 1 )
En el caso de una señal digital y considerando el periodo constante, se puede considerar que la función no es continua sino definida a trozos. Entonces, se puede decir que el valor medio de la señal durante un periodo fijo es igual al producto del valor de la señal en estado alto y su tiempo más el producto del valor y tiempo en estado bajo, todo ello divido por el periodo.
T
TLVL
T
THVHVmed
×+
×=
( 2 )
El ancho de la parte positiva respecto el periodo T se conoce como ciclo de trabajo:
Memoria Técnica
24
T
TD on=
( 3 )
Se modifica el valor de la velocidad mediante la utilización de una tensión variable de armadura, que además es modulada por amplitud de pulsos (PWM). Disponiendo de una sola fuente de tensión a valor constante y con la ayuda de un interruptor controlado se puede trocear esta tensión hasta conseguir el valor necesario en cada momento. Si el interruptor está cerrado un 5% de su ciclo y el resto abierto, la tensión media resultante será un 5% de la tensión máxima de entrada. Por otra parte, si el interruptor queda cerrado todo el ciclo, el valor medio de salida será igual a la totalidad del valor máximo de entrada. Se puede ver el efecto en la Ilustración 7.
Ilustración 7: PWM en los 4 cuadrantes
3.3.3. Motor de corriente continua
Un motor eléctrico de corriente continua se entiende como el convertidor electromecánico rotativo que mediante los fenómenos de inducción y de par electromecánico transforma la corriente continua en energía eléctrica. Las expresiones que definen el funcionamiento de un motor de corriente continua son relativamente sencillas. Si se considera que el flujo de excitación o también flujo de campo es constante se pueden tomar las siguientes consideraciones:
Par proporcional a la intensidad de inducido o de armadura.
Velocidad proporcional a la f.e.m interna. Esto nos simplifica mucho el control ya que modificando la tensión de armadura podremos regular la velocidad. Obtener una tensión continua variable es relativamente sencillo, además si se alimenta el motor cc con una etapa de potencia adecuada y se
Memoria Técnica
25
escoge una técnica de control adecuada, se consigue una muy buena respuesta dinámica (fiable y rápida). Existen diversos tipos de motores cc: con escobillas, sin escobillas (brushless) y los motores pasos a paso. Nos centraremos en el de escobillas porqué es el caso que nos ocupa.
Ilustración 8: Estator, rotor y motor cc montado (se señala una escobilla), sucesivamente.
La función del colector de delgas y las escobillas es alimentar correctamente las bobinas del devanado de armadura del rotor. El colector de delgas está unido al rotor y las escobillas al estator. En ciertas potencias existen diferentes configuraciones para las conexiones entre el devanado de excitación y armadura: excitación independiente, paralelo o shunt, serie y la compuesta. La que se va utilizar es la independiente por tanto nos centraremos en solo en esta configuración.
3.3.3.1. Excitación independiente En la Ilustración 9 se puede observar el esquema eléctrico equivalente de una máquina cc con excitación independiente, menospreciando la inductancia de armadura, trabajando como generador.
Memoria Técnica
26
Ilustración 9: Esquema eléctrico de una máquina cc con excitación independiente.
La nomenclatura es la siguiente: Va: tensión en bornes de la armadura. Ia: intensitat de armadura. Ea: f.e.m interna de inducido. Ra: resistencia de inducido o armadura. Incluye la resistencia ohmica del devanado de armadura, de las escobillas y de los devanados de compensación. La: inductancia del bobinado de inducido o armadura. Vb: caída de tensión del arco eléctrico a las escobillas (brush). w : Velocidad mecánica en el eje del motor (rad/s). n : Velocidad mecánica en el eje en r.p.m. Ti: par interno en N·m. Ts: par externo en N·m. En la Ilustración 10 se muestran las curvas características par-velocidad de un motor cc a flujo constante y con tensiones de alimentación de armaduras diferentes. El hecho más interesante de estas curvas es que tienen una característica dura para un elevado margen de tensiones. Esto quiere decir que si varia la demanda de par de la carga mecánica la velocidad varía poco, lo que permitirá regular fácilmente la velocidad de este tipo de motor.
Ilustración 10: Curvas características par-velocidad de un motor cc a flujo constante.
Memoria Técnica
27
3.3.3.2. Determinación de la constante K·Φ En este apartado se explica el proceso practico para encontrar las constantes K·Φ. Determinando este parámetro y con las formulas de Ea y Ti se puede saber teóricamente el valor de la tensión e intensidad que debe aplicar al motor para conseguir una determinada velocidad o par en el eje de salida. Para el estudio se parten de las siguientes constantes:
wa ⋅⋅= φK E ( 4 )
Ia⋅⋅= φK Ti ( 5 )
EaVbRaaa ++⋅= I V ( 6 )
Al trabajar con rpm substituimos w por 0.1047·n, quedando la expresión de Ea:
na ⋅⋅⋅= 1047.0K E φ ( 7 )
De las ecuaciones ( 4 ) y ( 5 ) se pueden llegar a conocer el voltaje de Va, la resistencia Ra y la intensidad Ia. Para hallar la constante K·Φ se igualan la ( 6 ) y la ( 7 ):
n
RaIaVbVa
⋅
⋅−−=⋅
1047.0K φ
( 8 )
Vb se desprecia al ser poco significativa, con lo que la ecuación final queda:
n
RaIaVa
⋅
⋅−=⋅
1047.0K φ
( 9 )
3.3.3.3. Placa de características del motor de corriente continua El valor de la placa de característiques del motor de LEYBOLD-DIDACTIC VDE 0530 Tensió nominal 220 V Tensión excitación 220 V Intensidad nominal 1,8 A Intensidad nominal de excitación 0,25 A Potencia nominal 0,3 kW Velocidad nominal 2000 rpm
Tabla 7: Valores placa de características
Memoria Técnica
28
3.3.4. Modulo de Control
El modulo de control se tiene que utilizar conjuntamente con la unidad de motor y carga. El modulo es un dispositivo controlador que tiene integrado un variador de frecuencia para suministrar la energía eléctrica y poder realizar el control de máquinas trifásicas, así como mostrar los valores medidos de velocidad y par en la pantalla de 7 segmentos. Existe la posibilidad conectarse mediante una comunicación serie a través de un PC y registrar valores. Las características técnicas:
Alimentación 230V, a frecuencia de 47 a 62 Hz, 2 kW Control automático de velocidad (5000 a -5000 rpm) Control automático de par (±9 N·m) Los valores se pueden modificar mediante un potenciómetro externo Simulación de diferentes cargas: k·n2, k/n, características arbitrarias Mi ~ ni, etc Permite realizar un control externo inyectando una valor de continua de -10 V a
10 V Visualización de cuadrantes de trabajo leds de siete segmentos de 25 mm, 4 dígitos para la velocidad y 3 para el par Monitorización de la temperatura: Device Under Test (DUT) de la unidad de
motor y carga Medida directa de voltaje para el DUT Comunicación serie para (RS232) para la transmisión de valores medidos y el
control remoto Comunicación serie para la conexión de equipos adicionales
Existen 6 tipos de error que puede dar el dispositivo según la Tabla 8. Tipo de Error Descripción ERR 1 Generator operation ERR 2 Temperature of the DUT ERR 3 Overvoltage in the link circuit of the control unit ERR 4 Temperature of the D & B Unit ERR 5 Temperature of the control unit
ERR 6 DUT is switched off via the output DUT ENABLE by removing the coupling guard or the shaft end guard
Tabla 8: Descripción tipos de errores en modulo de control de Leybold-Didactic
La interconexión entre el modulo y el conjunto motor-carga se realiza mediante dos conectores: uno de 7 pines (16) y otro de 25 pines (17) según la Ilustración 11.
Memoria Técnica
29
Ilustración 11: Modulo de control de velocidad y par.
La descripción de los puntos que se reflejan en la Ilustración 11 se lista a continuación. Estos son un extracto del datasheet que se ha creído oportuno dejar constancia al lector.
Memoria Técnica
30
Description of the individual operating elements: 1 Main switch S: ON / OFF switch for the control electronics and supply voltages for the pendulum machine.
2 2- or 4-quadrant operation (ONLY MOTOR OPERATION) If this LED lights up the control unit automatically switches off when the DUT is operating in the 2nd or 4th quadrants (generator operation). This is a function used to protect power sources which are not energy recovery-proof, if the DUT is being supplied by such a source. After the device is switched on at switch S ,the LED lights up (only 2-quadrant operation possible). If the device is switched on by pressing the START button (directly under the LED), the LED does not light up (4-quadrant operation possible). 3 Pushbutton to start automatic recording of the characteristics. If the operating mode load characteristic or run-up characteristic is actice, automatic recording of characteristics can be started by pressing pushbutton. In the case of the load characteristic the speed range, starting from the momentary speed value and automatically proceeding up to the stop speed. For the run-up characteristic the machine-generator set is rapidly braked to the stop speed in order to run up again to the speed applicable for start or recording. Before starting the characteristic recording the momentary speed can be changed using the incremental control knob . At the end of the characteristic recording the machine-generator set sheds its load and the stop speed flashes for approx. 7 seconds.
4 The pushbutton M = 0 serves to interrupt any given operating state. Any given operating state can be interrupted by pressing the pushbutton. At the same time the torque display shows OFF. The D & B Unit no longer develops any torque, comes to a standstill or is set to its no-load speed by the machine under test. Consequently, the activation of the pushbutton M = 0 results at all times to the load shedding of the machine-generator set. Reactivation of the pushbutton M = 0 results in the reactivation of the control unit and therewith the frequency converter.
5 Operating mode switch (MODE) Switchover to the next operating mode occurs each time this pushbutton is pressed. The current operating mode is displayed by an LED (7). 6 Error message LED: ERROR A multicolored LED is situated with the following significance: green: No error at all! red: An error appears and is displayed as ERR n
(n stands for 1 to 6) Acknowledge by pressing RESET button (8). 7 Modes of operation: 7.1 Load characteristic The rotation speed, specified by the incremental control knob or externally, is kept constant. The load
of the DUT is the product of its speed/ torque characteristic. The recording of the characteristic is started by pressing the START button. 7.2 Run-up characteristic The speed, which is preset using the incremental control knob or externally, is kept constant. The load of the DUT is the product of its speed/ torque characteristic. The recording of the characteristic is started by pressing the START button. 7.3 Automatic torque control (TORQUE CONTROL) The torque, which is set by means of the incremental control knob or externally, is kept constant. The DUT operates under constant load.
7.4 Load simulation M ~ k n The D & B Unit simulates the load response of a fan (M ~ k n2). 7.5 Load simulation M ~ k / n The D & B Unit simulates the load response of a winding drive (M ~ k / n). 7.6 Load simulation Mi ~ ni The D & B Unit simulates the load response with arbitrary characteristic edited by the user. 7.7 Load simulation flywheel The D & B Unit simulates the load response of a flywheel. 8 RESET If an error message is displayed or switch off has been carried out because the torque limit has been exceeded, the control unit can be switched on using this button. However, this is only possible if the corresponding error has been eliminated. In the case of switch-off due to overheating this entails a cooling off of the corresponding components. 9 Four-quadrant display Display of the instantaneous load type of the DUT. Quadrant Load type Rotation direction 1st quadrant Motor operation clockwise 2nd quadrant Generator operation couterclockwise 3rd quadrant Motor operation counterclockwise 4th quadrant Generator operation clockwise
10 L1IN, L2IN, L3IN Input sockets to the internal DUT's measurement circuits for connection of external power supply: Input ranges for voltages: 0... 600 VAC/DC
currents: 0... 10 A AC/DC
frequenties: 0... 120 Hz
11 L1OUT, L2OUT, L3OUT Output sockets for connection of different DUT-machines (DC, AC, 3~)
12 INTERN / EXTERN-switch
Memoria Técnica
31
INTERN: Depending on the operating mode reference variable is set for speed, or torque via the incremental control knob. EXTERN: Depending on the operating mode the reference variable is set for speed or torque via the external input CONTROLIN (13).
13 External control input CONTROLIN This input is active if the INTERN / EXTERN-switch is set to EXTERN. For external operation the setpoint value for the control loop selected by the MODE button is supplied via this socket. Here the following linear relationships apply to some extent: Automatic torque control (TORQUE CONTROL): ±10 V corresponds to ±10 N Automatic speed control (SPEED CONTROL): ±10 V corresponds to ±5000 rpm The setpoint value is supplied to the selected controller via a run-up generator. This means that setpoint step changes are possible and lead to a slight overshoot of the controller in question.
14 Temperature monitoring of the DUT: TERR This input is connected to the thermal contact of the DUT. This connection is always established as otherwise there would be no overload protection for the DUT. 15 DUT ENABLE-sockets Potential-free relay-driven output sockets in the operation mode as a switcher used with the /INH input of Control Unit PWM Characterisitc Method, cat. no. 735 291, a cut-off used with power circuit breakers e.g. cat. no. 745 561. The operation modes dut nc (normally closed) and dut no (normally open) can be changed by pressing the MODE key (5) during the first seconds when control unit is switched on. With each pressing a delay time will be started. The default mode of DUT ENABLE is dut no.
16 Connection socket to supply the D & B Unit.
17 Control connection input Multifunction Input for the connection of the D & B unit's build-in incremental tacho-generator, torque measurement- and protection circuits.
18 Digital speed output (TACHOOUT) The signals of the tacho-generator are automatically forwarded.
19 Serial interface (SERIAL OTHER) Available for connection of the control unit PWM characterisitc method, cat.no. 735 291. As such the device can be operated on the same PC interface as the control unit.
20 Serial interface (SERIAL PC) This interface is electrically isolated and outputs the speed and torque of the D & B Unit. If the sockets in the DUT sockets field are connected, also the current consumption and the voltage supply of the DUT is transmitted. Control of the control unit can a lso be ca r r i ed ou t us in g th e so ftware CBM10 V5 , cat. no. 728 421.
21 Incremental control knob to change the reference variable and the limit The reference variable to be changed depends on the operating mode set and thus on the control loop currently activated. The speed setpoint is varied in the operating modes load characteristic and run-up characteristic Setting range: -5000 rpm...0 rpm...5000 rpm In the automatic torque control mode (TORQUE CONTROL) the setpoint value for the torque control loop is varied. Setting range: -9.99 Nm...0 Nm...+9.99 Mm In the case of external operation the incremental control knob cannot induce a change in the setpoint. If the stop speed or the torque limit is displayed (by pressing or, the incremental control knob can be used to vary the value currently being displayed. Setting range stop speed: 0
rpm...5000 rpm Setting range
torque limit: 0 Nm...9.99 Nm The load simulation operating modes only permit an effective setting of the torque limit, for load simulation of a winding drive (M ~ k/n) the maximum adjustable torque limit is at 5 Nm (this torque has to be overcome during start up).
22 Auxiliary ground sockets
23 Analog DUT's current output (I [ 1 V / A ]) The voltage is proportional to the DUT's supply current when connected to DUT socket field (1 V corresponds to 1 A).
24 Analog DUT's voltage output (U [ 1 V / 100 V ]) The voltage is proportional to the DUT's supply voltage when connected to DUT socket field (1 V corresponds to 100 V).
25 Analog torque output (M [ 1 V / Nm ]) The voltage is proportional to the instantaneous torque of the D & B Unit (1 V corresponds to 1 Nm).
26 Analog speed output (n [ 1 V / 500 rpm ]) The voltage is proportional to the momentary speed of the machine-generator set (1 V corresponds to 500 rpm).
27 Pushbutton to display torque limit (|MMAX|) When operated switchover occurs between the torque limit and the momentary torque. If the torque limit is being displayed, the display flashes. This value can now be changed using the incremental control knob. If the display flashes, max. limit switch off (machine torque > set torque limit) is performed at the value now shown in the display. The DUT sheds its load: M = 0. 28 Pushbutton to display speed limit nSTOP When operated switchover occurs between stop speed and current speed. If the stop speed is displayed, the display flashes. This value can now be changed using the incremental control knob.
Memoria Técnica
32
29 3-digit 7-segment display to indicate the torque
30 4-digit 7-segment display for the indication of the speed, the condition of DUT ENABLE output and
error codes. To acknowledge error see RESET (8)!
Memoria Técnica
33
3.3.5. Fuente de Alimentación Variable
La fuente de alimentación variable servirá para alimentar la excitación y el driver del motor de corriente continua. La fuente nos da la posibilidad de dar tensión alterna o continua, además de poder modificarla de 0 a 250 V. La fuente está formada por un transformador con un potenciómetro, proporcionando una relación de transformación variable. En la salida del transformador hay un rectificador que elimina la parte negativa, dando en la salida una señal de potencia continua.
Ilustración 12: Vistas de la fuente de alimentación variable
En su interior lleva un condensador para filtrar la tensión de salida del rectificador y conseguir una continua sin rizamiento. Para evitar los picos de intensidad de hasta 50 A producidos por la presencia del condensador, se provoca que el condensador se cargue a través de una resistencia con la intención de minimizar los efectos de la capacitancia en la salida. Una vez se haya cargado el condensador el circuito de disparo del relé se activarà cortocircuitando la resistencia para en la salida haya el valor deseado de tensión.
Ilustración 13: Circuito de protección de sobreintensidad y fotografía de situación en la fuente variable
Memoria Técnica
34
3.4. Elementos de Software
3.4.1. Herramienta GUIDE
Para el desarrollo de la aplicación en tiempo real, se trabaja con una herramienta de MATLAB llamada GUIDE (Graphical Use Interface Development Environment). Esta herramienta esta pensada para desarrollar GUIs (Graphical User Interfaces) fácil y rápidamente haciendo sencillo el diseño y presentación de los controles de la interfaz, reduciendo la labor en el momento de seleccionar, deshacer, arrastrar y centrar controles, así como la personalización de las propiedades de estos. El proceso a seguir para el desarrollo de un programa mediante GUIDE es que una vez se tienen todos los controles en posición, se editan las funciones de llamada (Callback) de cada uno de ellos, escribiendo el código de MATLAB que se ejecutará cuando el control sea utilizado. GUIDE está diseñado para hacer menos tedioso el proceso de desarrollo de la interfaz gráfica, para ello cuenta con un editor de propiedades (property editor) con el que se podrá modificar en cualquier momento los nombres, valores por defecto y las propiedades de los elementos. Para poder acceder a la herramienta GUIDE se puede de tres maneras:
Tecleando el comando >>guide desde el prompt de Matlab A través del Launch Pad Pinchando en File -> New ->GUI dentro de Matlab, como se muestra a
continuación
Ilustración 14: Inicio de la aplicación GUIDE mediante menú
Una vez iniciemos la aplicación aparece la siguiente interfaz, y nos pedirá si queremos realizar una aplicación nueva o bien abrir una existente. En el caso que se cree una nueva aplicación se puede partir de aplicaciones prefabricadas, como por ejemplo: con controles, con una pantalla para gráficos y menú, o un cuadro de dialogo.
Memoria Técnica
35
Ilustración 15: Menú de la herramienta GUIDE
En este caso se pide que comience el GUI en blanco, siendo nosotros quienes tengamos absoluto control y seamos quienes añadamos los controles que necesitemos. Aparecerá la ventana de la Ilustración 16.
3 2
5 4
7 6
9 8
11 10
13 12
14
1
15
16
17 18
19
20
21
Ilustración 16: Editor de la GUI en blanco y sus iconas
Las correspondencias de los botones se han ordenado en la Tabla 9 a modo de resumen con un breve apunte de su utilización.
Memoria Técnica
36
Item Tag Detalles 1 Select Selección de un objeto 2 Push Button Botón 3 Slider Barra de desplazamiento 4 Radio Button Botón de selección circular 5 Check Box Botón de selección tipo lista 6 Edit Box Casilla de edición 7 Static Text Casilla de texto fijo 8 Pop-up menu Menú desplegable 9 List Box Menú en lista
10 Toggle Button Botón con memoria 11 Axes Pantalla para visualización de gráficos 12 Panel Opción para generar un panel 13 Button Group Opción para agrupar botones
14 Activex Control Opción para generar controles ActiveX
15 Align objects Opción para alinear objetos 16 Menu Editor Editor de opciones de menú
17 Tab order Editor
Opción para cambiar el orden de las ventanas en el editor
18 M-file Editor Editor de los ficheros .m
19 Property inspector Editor propiedades de los controles
20 Object Browser Buscador de Objetos
21 Run Botón de compilación
Tabla 9: Explicación de los botones de la Ilustración 16
Cuando se crea una GUI se generan dos ficheros:
Un archivo .FIG, que es el que contiene los elementos gráficos así como las propiedades de la interfaz.
Un archivo .M que es el contiene el código con las correspondencias de los botones de control de la interfaz. Cada vez que se introduzca un elemento gráfico en el .FIG se generará unas líneas de programa automáticamente asociadas a ese tipo de control. Estas líneas de programas son vacías, es decir, es como un contenedor que necesita que ser llenado para llevar a cabo alguna acción durante la ejecución del programa. Este modo de trabajo es como el de LABWINDOWS, VISUAL BASIC, etc
Para que haya una correspondencia entre elemento gráfico y el código, cada vez que se pulse un botón se genera un evento, que provoca la ejecución de la función asociada a este elemento. Esta función es la callback que se anunciaba con anterioridad. A través de la Ilustración 16 se pueden diferenciar 2 barras: la paleta de componentes, y la de iconos varios.
Memoria Técnica
37
3.4.1.1. Paleta de componentes Siguiendo la Ilustración 16, la paleta de componentes va desde los número 1 hasta el 14. Son los controles (objetos) que aparecen en la GUI.
3.4.1.2. Iconos varios Siguiendo la Ilustración 16, la paleta de componentes va desde los número 15 hasta el 21.
3.4.2. Estructura de los gráficos en MATLAB
Para entender mejor el entorno de programación se explicará las jerarquías de los gráficos, identificadores, propiedades de objetos, etc
3.4.2.1. Jerarquía de MATLAB Los gráficos en MATLAB tienen una jerarquía formada por objetos de distintos tipos. Esta jerarquía tiene una distribución de árbol con el aspecto como el que se muestra en la Ilustración 17.
Ventana 1(figure)
Ventana 2(figure)
PanelPantalla
Ejes 1 (axes) Ejes 2 (axes)Controles(uicontrol)
Menús(uimenu)
Líneas (lines)Superfícies(surfaces)
Texto (text)Imagen(image)
Polígono(patch)
Ilustración 17: Diagrama de bloques de la jerarquía de MATLAB
El objeto más general es la pantalla o panel, es la raíz de todos los demás y solo puede haber un objeto pantalla. Una pantalla puede contener una o más ventanas (figures). A su vez cada una de las ventanas puede tener uno o más ejes de coordenadas (axes) en los que se puede representar objetos de más bajo nivel. Una ventana puede también puede tener también controles (uicontrols) como botones de selección o de opción,… y menús. Finalmente, los ejes pueden contener los cinco tipos de elementos gráficos que permite
Memoria Técnica
38
MATLAB: líneas (lines), polígonos (patch), superficies (surfaces), imágenes tipo bitmap (image) y texto (text). La jerarquía de objetos indica que en MATLAB hay objetos padre e hijos. Por ejemplo, el objeto ventana es hijo de pantalla, y a su vez cada objeto ventana es padre de los ejes. En el momento que se borre un objeto de MATLAB se borrarán todos todos los objetos que son descendientes. Es decir, al borrar el objeto eje se borrarán las líneas, superficies, texto, imagen y polígono.
3.4.2.2. Identificadores (handles) Cada uno de los objetos de MATLAB tiene un identificador único a los que se les llamará handle o id. Algunos gráficos tienen muchos objetos, en cuyo caso tienen múltiples handles. El objeto raíz (pantalla) es siempre único y su identificador siempre es cero. El identificador de las ventanas siempre es un entero que aparece en la barra de nombre de dicha ventana. Los identificadores de otros elementos gráficos son números float. En Matlab puede haber múltiples ventanas abiertas pero solo una esta activa. Cada una de estas ventanas puede tener ejes abiertos, pero solo se dibuja en los ejes activos. Los identificadores de la ventana activa, de los ejes activos y del objeto activo se pueden obtener con los siguientes comandos:
gcf (get current figure): Devuelve el entero que es el handle de la ventana activa. gca(get currant axis): Devuelve handle de los ejes activos. gco(get current object): Devuelve handle del objeto activo. delete handle: borra el objeto correspondiente y todos sus hijos.
3.4.2.3. Propiedades de los objetos Los objetos de Matlab pueden tener distintas propiedades:
Children Clipling Parent Type UserData Visible
Las propiedades tienen valores por omisión que se utilizan cuando el usuario no indique otra cosa. Es posible cambiar las propiedades por omisión y también devolverles el valor original. Hay propiedades que solo pueden ser consultados sus valores, sin poder ser modificados, y otros que tendrán un conjunto limitado de valores (p.e. on/off).
Memoria Técnica
39
4. Memoria de cálculo En esta parte se verá la parte práctica del proyecto, en la que se explicará la configuración de hardware y de software, así como los cálculos realizados para el diseño del controlador y la explicación del programa mediante un diagrama de flujo.
4.1. Configuración de los elementos Hardware Antes de nada hay que tener claro cuales son los elementos que se van a utilizar para que el motor de corriente continua pueda girar, y que se pueda implantar un lazo de velocidad y un controlador que haga cumplir nuestras exigencias de diseño. También será de suma importancia establecer las conexiones y asignar las entradas/salidas en la placa de adquisición de datos.
4.1.1. Esquema de conexionado
Siguiendo lo establecido en el apartado 3.3, y utilizando los elementos descritos en el, tenemos el siguiente esquema de conexionado con el que se ha desarrollado la aplicación en tiempo real. Este esquema corresponde a un sistema realimentado.
VARIADOR DE TENSIÓN
Vcc+
0V
220Vca
SH_IN
SH_OUT
Vcc_puente
GND_puente
M-
M+
DRIVER
Vexcitación
F2 F1 M+ M-
9PIN CON
25 PIN CON
Varmadura
MOTOR+CARGA
25 PIN CON
9PIN CON
n (V)
0 V
MODULO CONTROL
PLACA DAQ
ENTRADAS
SALID
AS
IDE20-E/S
Ilustración 18: Esquema de conexionado
En la Ilustración 19 se muestra el puente del modulo de velocidad de Leybold-Didactic, de esta manera se evita el error 6, explicado en el apartado 3.3.3.3.
Memoria Técnica
40
Ilustración 19: Puente de de entrada de sensado de temperatura
4.1.2. Tabla de conexiones
A continuación se muestra una tabla resumen que engloba el conexionado desde el IDE de 20 pines hasta la placa de adquisición (DAQ) que hay en la Ilustración 18, así como: los pines de la DAQ y el rango de tensión, diferenciando las entradas de las salidas.
Descripción de la señal
Pin IDE Placa# Pin DAQ#
Rango Tensión
(V) ENTRADAS
1 Medida Sensor Hall 20 ACH0 ±12
2 Sobrecorriente Shall y MC33153 11 DIO3 0-5
3 Cruce Rama B 12 DIO2 0-5 4 Cruce Rama A 13 DIO1 0-5
5 Lectura Velocidad (modulo ext.) - ACH1 ±10
SALIDAS 1 Velocidad 19 DAC0OUT 0-5 2 Rampa 18 DAC1OUT 0-5 3 Sentido de giro 17 DIO0 0-5
Tabla 10: Resumen de conexiones entre driver y placa DAQ
La distribución de pines en el conector IDE de 20 pines del driver:
Memoria Técnica
41
Ilustración 20: Conector IDE de 20 pines en vista frontal
El listado de pines del conector IDE del driver de corriente continua se muestra en la siguiente tabla.
N°PIN IN/OUT de la placa al PC Descripción 1 OUT -12 V 2 OUT +12 V 3 OUT GND 4 OUT +5 V 5 N.C.
6 N.C.
7 N.C.
8 N.C.
9 N.C.
10 N.C.
11 OUT Sobrecorriente (Shall i MC33153) 12 OUT Cruce rama B 13 OUT Cruce rama A 14 IN Entrada al pic (libre) 15 OUT Salida del pic (libre) 16 IN reset/rearme por soft (no implement.) 17 IN Sentido de giro: 0 izq., 1 derecha 18 IN Señal analógico rampa 19 IN Señal analógico velocidad 20 OUT Medida de corriente al Shall (±12 V)
Tabla 11: Lista de entradas salidas en el conector IDE de 20 pins del driver cc
4.2. Configuración elementos de Software A continuación se explica como instalar y configurar todos los elementos de MATLAB para trabajar con la toolbox de real-time.
4.2.1. Instalación MATLAB
En el caso que haya que instalar MATLAB, hay que tener en cuenta que durante el proceso hay que seleccionar la instalación de SIMULINK y TOOLBOX REAL-TIME. Es aconsejable una instalación completa en caso de dudas.
Memoria Técnica
42
Ilustración 21: Proceso de instalación con MATLAB
Una vez concluido el proceso de instalación es necesario agregar el driver de la mochila, o dongle, así como tenerla conectada físicamente al PC, porque es lo que nos permite arrancar satisfactoriamente la sesión de trabajo. La versión utilizada es MATLAB R2006a.
4.2.2. Instalación Compilador
Para poder desarrollar la aplicación en tiempo real es necesario un compilador que traduzca las líneas de programa escritas en el fichero .m, así el depurador de Matlab permitirá visualizar los errores, detener el programa en un determinado punto de la ejecución, permitir la ejecución paso a paso, etc. El compilador es externo, y por lo tanto habrá que instalarlo y configurarlo para que Matlab lo reconozca y pueda trabajar con él. Se instala un compilador C/C++, en nuestro caso se ha escogido el Visual C/C++, ya que el Open Watcom C/C++ daba problemas en las pruebas que se realizaron con Matlab.
4.2.3. Configuración Compilador
Para que Matlab pueda trabajar correctamente y reconozca el compilador habrá que seguir los siguientes pasos: Teclear el siguiente comando para determinar que compiladores reconoce
>> mex –setup
El comando provoca la respuesta:
Please choose your compiler for building external
interface (MEX) files:
Memoria Técnica
43
Would you like mex to locate installed compilers
[y]/n? y
Le decimos que queremos ver todos los compiladores instalados
Select a compiler:
[1] Lcc C version 2.4.1 in C:\ARCHIVOS DE
PROGRAMA\MATLAB\R2006A\sys\lcc
[2] Open WATCOM C/C++ version 1.3 in c:\watcom
[3] Microsoft Visual C/C++ version 6.0 in c:\visual
[0] None
Compiler:
Se marca la opción 3, el compilador de Microsoft, y aparece el siguiente mensaje:
Please verify your choices:
Compiler: Microsoft 6.0
Location: C:\visual
Are these correct?([y]/n):
Se confirma con un yes, y se muestra por pantalla siguiente mensaje confirmando la actualización de la opción. Trying to update options file: C:\Documents and
Settings\user\Application
Data\MathWorks\MATLAB\R2006a\mexopts.bat
From template: C:\ARCHIVOS DE
PROGRAMA\MATLAB\R2006A\BIN\win32\mexopts\lccopts.bat
Done . . .
******************************************************
Warning: The file extension of 32-bit Windows MEX-
files was changed
from ".dll" to ".mexw32" in MATLAB 7.1
(R14SP3). The generated
MEX-file will not be found by MATLAB
versions prior to 7.1.
Use the -output option with the ".dll" file
extension to
generate a MEX-file that can be called in
previous versions.
For more information see:
MATLAB 7.1 Release Notes, New File
Extension for MEX-Files on Windows
******************************************************
Memoria Técnica
44
4.2.4. Instalación del Kernel Real-Time Windows Target
El kernel del RTWT de la placa es imprescindible para que la aplicación en tiempo real se conecte con el sistema operativo Windows y se ejecuten las interrupciones de manera acorde al tiempo de muestreo seleccionado. El kernel es el gestor de las tareas y los tiempos de ejecución de cada una de ellas, sin él no se podría ejecutar ninguna aplicación en tiempo real. Aunque el kernel es copiado automáticamente durante el proceso de instalación, hay que instalarlo manualmente mediante el siguiente comando:
>>rtwintgt -setup
You are going to install the Real-Time Windows Target
kernel.
Do you want to proceed? [y] :
Se confirma con un yes, entonces el programa confirma la correcta instalación del kernel.
The Real-Time Windows Target kernel has been
successfully installed.
Para comprobar la correcta instalación del kernel y la versión instalada, se teclea el comando:
>> rtwintgt -version
The installed version of the Real-Time Windows Target
kernel is 2.6.1.
4.2.5. Obtención de información de estado del kernel
Con Real-Time Windows Target disponemos de una herramienta para poder acceder a la información de estado del kernel. Tecleando el siguiente comando:
>> rtwho
Real-Time Windows Target version 2.6.1 (C) The
MathWorks, Inc. 1994-2005
Running on Uniprocessor APIC computer.
MATLAB performance = 100.0%
Kernel timeslice period = 1 ms
En la respuesta que produce debería haber reconocido el driver de la placa de adquisición de datos. Para indicarle manualmente el driver de la placa de adquisición habrá que teclear:
>> rtload
Memoria Técnica
45
Y aparecerá la siguiente ventana:
Ilustración 22: Pantalla de selección manual del driver de la placa de adquisición de datos
Vamos a la carpeta de Nacional Instruments (NI) y seleccionamos el fichero correspondiente a nuestra placa: pci-6024e.rwd Hacemos la comprobación para ver si ha cogido el driver, y efectivamente nos muestra el correcto, además de la dirección que ocupa.
>> rtwho
Real-Time Windows Target version 2.6.1 (C) The
MathWorks, Inc. 1994-2005
Running on Uniprocessor APIC computer.
MATLAB performance = 100.0%
Kernel timeslice period = 1 ms
DRIVERS: Name Address
Parameters
National Instruments PCI-6024E 0x2
[0 0 0 0 0]
Para deshacer los cambios existe un comando que deshace la selección del driver:
>>rtunload
4.3. Modelado de la planta Para diseñar un controlador sobre un sistema real se podría realizar de diferentes formas: empiríricamente o analíticamente. Los métodos empíricos se pueden englobar en 3 grupos: el analítico, el de lazo abierto y el de lazo cerrado. El analítico se basa en calcular y simular las diferentes acciones, solas y conjuntamente e ir viendo el comportamiento de la respuesta hasta que sea satisfactoria. El de lazo abierto y el lazo
Memoria Técnica
46
cerrado son métodos en que la sintonía de los parámetros del controlador se realiza aplicando las variables obtenidas empíricamente sobre las formulas de unas tablas. El método escogido es el analítico porque se ha pensado que era el más interesante, ya que permite utilizar los conocimientos de teoría de control y es más atractivo para el alumnado. Para la consecución de este método es necesario determinar la planta de todo el sistema que controla el motor de corriente continua. Para ello se hacen pruebas en lazo abierto del sistema según la Ilustración 23. Se utiliza la carga y el modulo de Leybold para obtener la lectura de velocidad.
Ilustración 23: Diagrama de bloques del sistema
Para capturar los parámetros que definen la respuesta del sistema se utiliza un modelo en Simulink que permita introducir una consigna y visualizar los valores de la salida, aunque también se utilizado el osciloscopio para asegurar que la respuesta sea correcta. Los valores de salida permitirán reconstruir y estudiar los valores que definen la respuesta del motor de corriente contínua en lazo abierto. La frecuencia de muestreo escogida es superior a 10 veces la frecuencia del sistema, para evitar el fenómeno de aliasing, y así obtener una buena representación.
(a) (b)
Memoria Técnica
47
(c) (d)
Ilustración 24: Modelo creado para la obtención de la planta y la respuesta obtenida para el escalón unitario (figura a y b) con un tiempo de muestreo de 0,001s. Y la obtención de la planta mediante el osciloscopio (figura c y d).
La respuesta obtenida se aproxima a una función de primer orden, cuya expresión y respuesta característica quedan definidas en la ecuación ( 10 ) y la Ilustración 25.
Ilustración 25: Respuesta de un sistema de primer orden a una entrada de tipo escalón unitaria.
A partir de la gráfica de la Ilustración 24 se obtiene la constante de tiempo que define el sistema de primer orden de la planta del motor de cc. La constante τ corresponde al 63,2% del valor final de la respuesta y(t).
1)(
+⋅=
s
KsG
τ
( 10 )
A través del valor final – que es 1,1241 – se podrá obtener el valor de la constante de tiempo que corresponde al 63,2% del valor final, gráficamente el valor es de 0,1763 s. El valor de la ganancia K se determina mediante el Teorema del Valor Final. Es decir, se impone en régimen permanente el valor final de salida conocido.
Memoria Técnica
48
)(lim0
sYsys
ss ⋅=→
( 11 )
El valor de K es 6,376. Por tanto la expresión que define el sistema es la siguiente:
762,5
376,6)(
+=
ssG
( 12 )
4.3.1. Discretización de la planta
Dado que se trabaja en un sistema digital mediante PC, habrá que discretizar la planta del sistema continuo ( 12 ) para poder diseñar el controlador discreto. Para discretizar la planta se aplica el método analítico de la inclusión de un término de mantenimiento.
⋅
−=
=
−
nTt
Ts- sG
s
eZzG )(
1)( 1
L
( 13 )
Se sustituye la expresión ( 12 ) en la ( 13 ) y se obtiene:
+⋅
−=
=
−
nTt
Ts-
ss
eZzG
762,5
376,61)( 1
L
( 14 )
Descomponiendo en fracciones simples y haciendo la transformada Z se obtiene la planta discretizada dependiente del tiempo de muestreo.
T
T
ez
ezG
762,5
762,511066,1)(
−
−
−
−⋅=
( 15 )
4.3.1.1. Frecuencia de muestreo Para la elección de la frecuencia de muestreo habrá que recurrir al teorema de Nyquist-Shanon. El teorema establece que la frecuencia mínima de muestreo necesaria para evitar el aliasing debe ser:
BWf s 2> ( 16 )
Siendo el ancho de banda:
Memoria Técnica
49
minmax ffBW −= ( 17 )
Para nuestro sistema consideramos que 0min =f , por tanto la expresión ( 16 ) quedará:
max2 ff s > ( 18 )
El teorema de Nyquist sólo indica el valor mínimo necesario para que el muestreo resulte eficaz. Por encima de este valor, cuanto mayor sea el número de muestras tomadas más fiable será la representación. Cuantas más muestras se tengan, mejor se podrá reconstruir la señal; aunque, a mayor frecuencia de muestreo mayor será el ancho de banda, es decir que necesitaremos mayor número de bits, mayor tamaño de buffer, lo que ralentiza el procesado de la señal y encarece el equipo, que necesitará más memoria, más procesador, etc. Otro factor a tener en cuenta es que aunque se siga aumentando la frecuencia de muestreo, la calidad de la señal reconstruida no continua incrementándose indefinidamente. Por ello, la experiencia establece un valor aproximado para determinar la frecuencia de muestreo.
max10 ff s ≈ ( 19 )
Partiendo de la expresión ( 12 ), que corresponde a la función de transferencia continua que define el sistema del conjunto motor y carga, se extrae la constante de tiempo y se impone como la inversa de la frecuencia de nuestro sistema. Hay que tener en cuenta que este parámetro es muy restrictivo porque es el tiempo que tarda en llegar al 63,2% del valor final, y el valor que nos interesa es el tiempo que tarda en llegar al 100% del valor final. La frecuencia del sistema es:
==→ 0,1763 = Hzfs 67,51
ττ
( 20 )
La frecuencia y periodo de muestreo imponiendo ( 19 ) es:
0088,044,113 ≤→ = ss THzf ( 21 )
4.3.1.2. Efecto aliasing El efecto aliasing aparece cuando se utiliza una frecuencia de muestreo inferior a la establecida por el teorema de Nyquist-Shanon, entonces se produce este fenómeno, que también se conoce como solapamiento. El aliasing impide recuperar correctamente la señal original.
Memoria Técnica
50
Ilustración 26: Efecto aliasing
En la Ilustración 26 se aprecia el resultado de la mala elección del tiempo de muetreo. Los cuadrados corresponden a las muestras recogidas y resiguiendo estos se obtiene que la señal reconstruida difiere respecto a la original.
4.3.1.3. Funciones de transferencia discretas Dado que la aplicación de MATLAB/SIMULINK en tiempo real trabaja mejor para frecuencias de muestreo menores. Entonces, se puede afirmar que cuanto menor sea la frecuencia de muestreo:
Mayor es el intervalo de tiempo que se podrá visualizar/ejecutar en la aplicación en tiempo real.
Mayor es el número de bloques que se podrán insertar en Simulink sin errores de buffer.
Rescatando la expresión ( 15 ) de la transformada Z de la planta calculada anteriormente confeccionamos la siguiente tabla resumen que servirá para el cálculo del controlador, ya que la dinámica y la ganancia del sistema nos variará en función del tiempo de muestreo escogido. Tiempo de muestreo (s) Función de Transferencia Discreta (Z)
0,01 944,0
06196,0)(
−=
zzG ( 22 )
0,001 994,0
00636,0)(
−=
zzG ( 23 )
Tabla 12: Funciones de transferencia discreta en función del tiempo de muestreo
4.4. Diseño de controladores Un sistema de control realimentado o también conocido como sistema de control en lazo cerrado es aquel sistema que mantiene una relación entre la salida y la entrada de referencia, comparándolas y usando la diferencia como medio de control. La ventaja de un sistema de control en lazo cerrado es que el uso de la realimentación vuelve la respuesta del sistema relativamente insensible a las perturbaciones externas y
Memoria Técnica
51
a las variaciones internas en los parámetros del sistema. Aunque, en sistemas sin perturbaciones y donde se conozcan con anticipación las entradas es aconsejable utilizar un control en lazo abierto. Algunos aspectos que habrá que tener en cuenta en el diseño del controlador es la frecuencia de muestreo a seleccionar en la aplicación en tiempo real, porque afectará a la planta del sistema, modificando la ganancia y la dinámica del sistema. Por lo tanto, el diseño de los controladores se hará para los tiempos de muestreo reflejados en la Tabla 12, mediante el método de diseño del lugar de las raíces. A continuación se muestra la estructura básica de un controlador PID discreto.
kp
ki·z/(z-1)
kd·(z-1)/z
+
+
+
E H
Ilustración 27: Estructura de controlador discreto con acciones proporcional, integral y derivativa
Desarrollando analíticamente la Ilustración 27, se obtiene la función de transferencia de un controlador con todas las acciones (proporcional, integral y derivativa).
zz
kdzkdkpzkdkikp
zE
zH
−
+⋅⋅+−⋅++=
2
2 )2()(
)(
)(
( 24 )
Acción proporcional e integral
1
)(
)(
)(
−
−⋅+=
z
kpzkikp
zE
zH
( 25 )
Acción proporcional
kpzE
zH=
)(
)(
( 26 )
En los siguientes apartados se estudian las acciones del controlador por separado y combinadas, para la consecución de un control que nos conserve las propiedades de la planta original y que realice una gestión adecuada de la velocidad.
Memoria Técnica
52
4.4.1. Controlador P
La estructura de un controlador P introduce una ganancia a la entrada de la planta. La estructura es la que se muestra en la Ilustración 28. Para sistemas de tipo cero, el efecto del controlador proporcional es el siguiente:
Disminuye el tiempo de subida Aumenta el sobrepico No provoca grandes cambios en el tiempo de establecimiento Disminuye el error en régimen permanente, pero no lo elimina
+kp G(z)
-
Y(z)PlantaControlador
R(z)
Ilustración 28: Diagrama de bloques del controlador P con la planta del sistema
Para realizar el ajuste de la constante proporcional hay que obtener la función de transferencia en lazo cerrado con la incógnita kp. Mediante la regla de Mason se cierra el lazo quedando la expresión siguiente.
)(1
)(
)(
)(
zGkp
zGkp
zR
zY
⋅+
⋅=
( 27 )
La expresión del error:
)(1
)()(
zGkp
zRzE
⋅+=
( 28 )
Haciendo el desarrollo de la expresión ( 27 ) y sustituyendo el valor del tiempo de muestreo, se aplica el Teorema del Valor Final:
)()1(
lim1
zYz
zy
zss ⋅
−=
→
( 29 )
A continuación se muestra un resumen de los valores obtenidos para cada tiempo de muestreo. Se considera la entrada como un escalón unitario y el error en estado estacionario es del 1%, lo que quiere decir que el valor de la salida (yss) es 0,99. El valor de la constante proporcional se obtiene aislando ( 29 ).
Memoria Técnica
53
Tiempo de muestreo (s) Valor Constante Proporcional kp 0,01 89,5 0,001 93,4
Tabla 13: Valores kp en función del tiempo de muestreo
En este caso, al ser un sistema de primer orden, mirar el lugar de las raíces no aporta información significativa debido a que no se introduce ningún polo o cero. Por tanto no habrá grandes cambios dentro de los valores de ganancia para los que el sistema es estable.
-1 -0.5 0 0.5 1-1
-0.8
-0.6
-0.4
-0.2
0
0.2
0.4
0.6
0.8
1Root Locus
Real Axis
Imagin
ary
Axis
0.9936 0.9938 0.994 0.9942 0.9944 0.9946 0.9948 0.995
-6
-4
-2
0
2
4
6
x 10-4 Root Locus
Real Axis
Imagin
ary
Axis
Ilustración 29: Lugar de las raíces del sistema
Lo que interesa es estudiar la respuesta obtenida con la simulación.
0 2 4 6 8 10 12 14 16 18 20-20
-15
-10
-5
0
5x 10
12 Step Response
Time (sec)
Am
plit
ude
0 2 4 6 8 10 12 14 16 18 200
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1Step Response
Time (sec)
Am
plit
ud
e
Ilustración 30: Respuestas del sistema en lazo cerrado para tiempos 0,01 y 0,001 con sus respectivos valores calculados de la constante proporcional.
La respuesta obtenida para el valor calculado en el tiempo de muestreo de 0,01 segundos es inestable. Esto es debido a que se ha calculado el valor de la constante proporcional mediante el teorema del valor final, sin tener en cuenta ningún criterio de seguimiento para la estabilidad. Al utilizar el valor obtenido a través del teorema del valor final, el denominador de la función de transferencia en lazo cerrado crece tanto
Memoria Técnica
54
que se hace positivo y mayor que la unidad, es decir que tenemos inestabilidad en nuestro sistema de primer orden. Habrá que utilizar un metodo discreto que permita dimensionar un valor de kp que obligue al sistema a comportarse de manera estable, el escogido es el test de Jury.
011
10 ...)( azazazazP nnn ++++= −
− ( 30 )
Las condiciones del test de Jury para un sistema de primer orden:
0)1(·)1(
0)1(
>−−
>
P
Pn
( 31 )
El margen de valores posibles en que el sistema se comportorá de manera estable:
888,035,31 −>> kp
En los resultados obtenidos se puede ver que hay que escoger un valor de la constante que cumpla nuestras exigencias, es decir, que no haya ni soprepico, ni oscilaciones, que el valor llegue a la unidad con el mínimo error en estado estacionario posible y lo suficientemente rapido.
0 50 100 150 200 250-1.5
-1
-0.5
0
0.5
1
1.5x 10
4 Step Response
Time (sec)
Am
plit
ude
0 50 100 150 200 2500
0.2
0.4
0.6
0.8
1
1.2
1.4
1.6
1.8
2Step Response
Time (sec)
Am
plit
ude
(a) kp = 32 (b) kp = 31
0 2 4 6 8 10 12 14 16 18 200
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1Step Response
Time (sec)
Am
plit
ude
0 5 10 15 20 25 30 35 40 450
0.1
0.2
0.3
0.4
0.5
0.6
0.7Step Response
Time (sec)
Am
plit
ude
(c) kp=15 (d) kp = 1
Ilustración 31: Respuestas simuladas con los valores obtenidos en el test de Jury
Memoria Técnica
55
Los margenes de estabilidad de la constante proporcional obtenidos con el test de Jury para el tiempo de muestreo a 0,001 segundos es:
943,052,313 −>> kp Los valores definitivos de la constante proporcional teniendo en cuenta la estabilidad se muestran en la Tabla 14.
Tiempo de muestreo (s) Valor Constante Proporcional kp 0,01 15 0,001 93,4
Tabla 14: Valores kp en función del tiempo de muestreo, siendo el sistema estable
A continuación se muestran los valores reales obtenidos, para un tiempo de muestreo de 0,001 segundos y una consigna de 3.
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 10
0.5
1
1.5
2
2.5
3
3.5Linear Simulation Results
Time (sec)
Am
plit
ude
(a) Representación tensión de salida en función del número de muestras. Respuesta real controlador a Ts=0,001s kp=93,4
(b) Representación tensión de salida en función del tiempo. Respuesta simulación controlador a Ts=0,001s con kp=93,4
Zero-Order
Hold
6.376
s+5.762
Transfer FcnStep ScopeSaturation
93.4
Gain
(c) Representación tensión de salida en función del número de muestras. Error real Controlador a Ts=0,001s
(d) Modelo con controlador proporcional y saturación a Ts=0,001s
Ilustración 32: Comparación entre controlador P real y simulado
Memoria Técnica
56
En la Ilustración 32 se puede observar como las características de las respuestas real y simulada difieren en que la real tiene sobrepico y tarda más en alcanzar el valor final, es diez veces más lenta. El sobrepico es debido a que la planta real de un motor de corriente contínua es un segundo orden, en cambio, la de la simulada es una aproximación a un primer orden. El retraso en alcanzar el valor final es debido a saturaciones que se producen en el sistema real, y que no han sido contempladas en la simulación. A través del modelo propuesto en la Ilustración 32-d se puede explicar el fenómeno de la saturación, que es debido a la limitación de la tensión de control del driver, que puede oscilar entre los valores de 0 y 5 V. Los resultados obtenidos sobre la aproximación de primer orden se muestran en la Ilustración 33, estos se ajustan a las reales pero sin sobrepico porque es un primer orden.
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 10
0.5
1
1.5
2
2.5
3
Tiempo (s)
Am
plitu
d (
V)
Respuesta simulada con saturación
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 10
50
100
150
200
250
300
Tiempo (s)
Am
plit
ud (
V)
Error simulado con saturación
(a) Representación tensión de salida en función del tiempo. Respuesta simulación controlador a Ts=0,001s con kp=93,4
(b) Representación tensión de salida en función del tiempo. Error real a Ts=0,001s con kp=93,4
Ilustración 33: Respuestas obtenidas teniendo en cuenta la saturación
Memoria Técnica
57
4.4.2. Controlador PI
El controlador PI, al contener la parte integral, a diferencia del anterior incrementa el tiempo de establecimiento y elimina el error en estado estacionario. Con la acción combinada de la parte integral y proporcional habrá que reducir el sobrepico y el tiempo de establecimiento. En la siguiente ilustración se muestra el esquema de bloques típico de un sistema en lazo cerrado con un controlador PI.
+G(z)
-
Y(z)PlantaControlador PI
R(z)
1
)(
−
−⋅+
z
kpzkikp
Ilustración 34: Diagrama de bloques del controlador PI con la planta del sistema
La expresión del controlador PI:
1)(
)(
−⋅+=
z
zkikp
zR
zY
( 32 )
Para realizar la sintonía del controlador se recurre al método del lugar geométrico de las raíces, combinando las simulaciones con MATLAB como comprobación. A modo de ejemplo se utilizará el caso en que el tiempo de muestreo es de 0,001 s. La planta introduce un polo en 0,994 y, según la expresión ( 25 ), al introducir el controlador PI estamos introduciendo un polo en +1 y un cero que habrá que decidir su colocación para obtener la respuesta deseada. Para la búsqueda de las variables que definen el sistema se impondrá el valor de la constante proporcional como 10. Ahora quedará buscar el valor de la constante ki. Mediante simulación se determina que la mejor posición del cero del controlador está entre el origen y el polo de la planta, es decir en 0,98.
-1 -0.8 -0.6 -0.4 -0.2 0 0.2 0.4 0.6 0.8 1-1
-0.8
-0.6
-0.4
-0.2
0
0.2
0.4
0.6
0.8
1Root Locus
Real Axis
Imag
ina
ry A
xis
0.992 0.994 0.996 0.998 1 1.002
-4
-3
-2
-1
0
1
2
3
x 10-3 Root Locus
Real Axis
Ima
gin
ary
Ax
is
Ilustración 35: Lugar geométrico de las raíces de la planta y el controlador
Memoria Técnica
58
Las respuestas obtenidas en la simulación y en la aplicación Real Time para el tiempo de muestreo de 0,001 segundos e introduciendo una consigna escalón de 3 se representan en la Ilustración 37.
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
0
0.5
1
1.5
2
2.5
3Linear Simulation Results
Time (sec)
Am
plit
ude
(a) Representación tensión de salida en función del número de muestras. Respuesta real controlador a Ts=0,001s
(b) Representación tensión de salida en función del tiempo. Respuesta simulación controlador a Ts=0,001s
(c) Representación tensión de salida en función del número de muestras. Error real Controlador a Ts=0,001s
Ilustración 36: Comparación entre controlador PI real y simulado
Se puede comprobar en las ilustraciones a y b, que el diseño se ha realizado correctamente, aunque en la ejecución real se alcanza el valor final unas décimas de segundo antes que en la simulada. Respecto al diseño del controlador P, se ha conseguido reducir el error y el sobrepico. En la Ilustración 36.c se puede apreciar como el error en la entrada del controlador decrece hasta alcanzar un valor próximo a cero. Las funciones de transferencia de los controladores se reflejan en la siguiente tabla.
Memoria Técnica
59
Tiempo de muestreo (s) Función de Transferencia Discreta (Z)
0,01 1
996,0)(
−
−=
z
zzD ( 33 )
0,001 1
98,0)(
−
−=
z
zzD ( 34 )
Tabla 15: Funciones de transferencia en función del tiempo de muestreo
4.4.3. Limitaciones en la frecuencia de muestreo
La elección de la frecuencia de muestreo máxima está sujeta a diferentes parámetros. El primero es asegurar que se está cumpliendo el teorema de Shanon-Nyquist, es decir que estamos dentro de la frecuencia mínima (la frecuencia 100 Hz se considera dentro de la mínima). La segunda concierne a los diferentes parámetros de ejecución de la aplicación en tiempo real como: tiempos inicial y final, número de bloques utilizados en el modelo, así como las características de velocidad de procesador, RAM y disco duro del ordenador de sobremesa que se disponga. Se han realizado diferentes pruebas para la determinación de la relación de estos parámetros, pero sin demasiado éxito. Pero si que se ha conseguido establecer unos márgenes que reflejan las limitaciones del sistema como se verá más adelante. La primera prueba que se ha realizado es poner un modelo muy sencillo con dos bloques: uno que reciba la señal de entrada procedente de un generador de funciones exterior y el otro que lo muestre en un bloque Scope. Con esta estructura se han realizado pruebas a diferentes frecuencias. Se han ordenado los resultados y se han concentrado en la siguiente tabla resumen.
Ts (s) fs (kHz) ∆∆∆∆t representado (s)
Npt max. representados
Duración (106 s) Ejecución
0,0001 10 100 1.000.000 1 Correcto 0,0001 10 200 2.000.000 2 Correcto
0,00001 100 0,01 1.000 1 Correcto 0,00001 100 2 819 2 Error 0,00001 100 1 820 2 Error 0,00001 100 0,01 1.000 2 Correcto 0,00001 100 0,02 2.000 2 Error
0,000001 1000 0,0001 100 2 Error grave
Tabla 16: Ensayos para determinación de limitaciones en la aplicación en tiempo real, con MATLAB 7
El valor mostrado en la tercera columna corresponde al intervalo de tiempo que es representado gráficamente en Matlab. La cuarta columna refleja el número de puntos que tiene la variable que se visualizará, o mejor dicho, los puntos que se utilizarán en la representación. El parámetro duración es la capacidad máxima que le hemos establecido
Memoria Técnica
60
a Matlab para la captura de variables a visualizar. La última columna es el indicador si el sistema ha respuesto correctamente a la frecuencia de trabajo. Para conocer la relación entre los parámetros anteriores se ha determinado la siguiente expresión:
tTs
ptNpt ∆⋅=
( 35 )
Donde: Npt: Es el numero total de puntos que se pueden visualizar durante la ejecución de la aplicación en tiempo real. pt: Es el numero de puntos que se capturan por intervalo de tiempo muestreado. Por defecto es igual a la unidad, y es aconsejable que se deje así. Ts: Es el periodo de muestreo seleccionado en la aplicación en tiempo real. ∆t: Es el intervalo de tiempo total que se desea representar en la aplicación en tiempo real. Es la diferencia entre el tiempo inicial y final seleccionado por el usuario en la apliación en tiempo real. La expresión ( 35 ) tiene matices, ya que está acotada por otras dos expresiones. Una es la limitación que tiene el sistema en cuanto a la velocidad de capturar puntos por unidad de tiempo, se ha decido llamarlo slew rate (SR) como en los operacionales.
[ ][ ]segundos
puntos
t
NptSR ==
( 36 )
La otra expresión sería la que resultaría de las expresiones ( 35 ) y ( 36 ), el intervalo máximo de tiempo representable para un determinado periodo de muestreo. Se considera pt = 1.
SRTspt
NptTst ⋅=
⋅=∆ 2
max
( 37 )
Estas expresiones funcionan en la teoría, pero en la práctica vemos que no se cumplen porque existen limitaciones de memoria del sistema de adquisición con la aplicación. Puede suceder que determinemos un SR para un determinado modelo, y que no sirva en para otro modelo diferente. Esto es debido a que le afecta el número de bloques utilizados en Simulink, los procesos que corren detrás de la aplicación Matlab, los recursos que disponga la máquina, la versión de Matlab y todas sus herramientas.
Memoria Técnica
61
4.5. Funcionamiento del interfaz gráfico A continuación se presenta el interfaz gráfico realizado con la herramienta de Matlab, GUIDE. El interfaz permitirá controlar la velocidad de un motor y su carga en lazo cerrado, pudiendo modificar parámetros como: velocidad, rampa, sentido de giro, valores de controlador, tiempo de simulación, tiempo de muestreo, etc. y una vez acabada la simulación se podrán visualizar los parámetros y grabarlos en un fichero .MAT. Otra característica interesante es poder decirle al programa si queremos trabajar en lazo abierto o cerrado, según convenga. Más adelante se explicará con detalle que opciones tiene el programa, como trabaja, y cual es el código que lo hace funcionar. Para hacer mucho más ameno el seguimiento del funcionamiento de la aplicación se divide el programa según las partes más relevantes, que son las siguientes:
Elección del modelo de trabajo Parámetros de entrada Parámetros del controlador Parámetros de ejecución Visualización de datos Guardar datos Casilla de diálogo Función de cierre de programa
Ilustración 37: Interfaz gráfica en fase de diseño
Memoria Técnica
62
4.5.1. Elección del modelo de trabajo
A través de las casillas de selección se puede escoger el modelo de Simulink con el que se desea trabajar. Existen tres opciones:
Modelo en lazo cerrado con controlador discreto (en Z) y con carga Modelo en lazo abierto Modelo en lazo cerrado sin controlador y con carga
A continuación se explican más en profundidad cada una de estas opciones.
4.5.1.1. Modelo en lazo cerrado con controlador y carga Esta es la elección por defecto con la que arranca el programa. El modelo que se abre es el fichero rtw.mdl y tiene el aspecto de la Ilustración 38. Por defecto arranca con un controlador PI diseñado para las condiciones con las que inicia. Aunque también es posible diseñar cualquier otro controlador que tenga las partes proporcional, integral y/o derivativa. El patrón utilizado en este modelo es el mismo que se utiliza en los otros modelos, de esta manera las rutas y los nombres de las variables y bloques serán aprovechables en la parte de programación, lo que simplificará mucho el trabajo.
Ilustración 38: Aspecto del modelo de Simulink en lazo cerrado con controlador y con carga
Observando la parte principal del modelo, es decir el control, podemos ver que mediante la variación del bloque Constant se podrá modificar el valor del escalón. El
Memoria Técnica
63
bloque Sortida9 permitirá visualizar las diferencias entre el valor de entrada respecto al de salida. Mediante el bloque Sortida2 se podrá visualizar el error del controlador. Se ha puesto un limitador en la salida para absorber cualquier variación imprevista superior a unos valores de 0 a 5 V. De esta manera se protege la entrada del driver CC que trabaja con rangos de tensiones TTL. Después del limitador se encuentra el bloque de salida que inyectará el valor de la velocidad al driver de cc en ese instante de tiempo. El valor real de la velocidad del conjunto motor+carga es capturado por el tacómetro de la carga y reinyectado en el sumador para volver a calcular el valor velocidad en el siguiente instante de tiempo, haciendo que el error tienda a cero. El valor de la constante Constante2 es el valor de la rampa, que como hemos dicho anteriormente el driver cc trabaja con lógica TTL, los valores admisibles son de 0 a 5 V y para que se cumpla esta condición esta el limitador. Cuanto más alto sea el valor de la constante más lenta será la aceleración y la frenada. El valor de la constante Constant1 es el valor para modificar el sentido de giro, que en este modelo la opción queda deshabilitada a través del GUI debido a conflictos con el modulo D&B de LEYBOLD. A mano de derecha de la Ilustración 38 quedan las entradas:
Sobreintensidad en la rama A Sobreintensidad en la rama B Sobreintensidad en el sensor Hall Medición procedente del sensor Hall
Todos los valores se guardan y pueden ser visualizados a posteriori.
4.5.1.2. Modelo en lazo abierto Esta es la segunda elección posible y el fichero que abre es el rtwol.mdl, y en caso que existiera cualquier otro modelo abierto lo cerraría guardando los cambios. El modelo no tiene ningún control como es lógico, ya que es un lazo abierto. El patrón que sigue es como el explicado en el anterior apartado.
Memoria Técnica
64
Ilustración 39: Aspecto del modelo en lazo abierto
En esta opción es posible realizar cambios en el sentido de giro del motor, además de poder regular la rampa de aceleración y deceleración como se puede hacer en los otros modelos.
Ilustración 40: Inversión de giro y aceleración/deceleración del motor cc.
La Ilustración 40 muestra el cambio en el sentido de giro del motor, se puede ver como primeramente como acelera a una rampa de valor 2 hasta conseguir el valor de la consigna que es 4, es a partir de este momento que se solicita el cambio de giro. Cuando se realiza el cambio de giro sería de esperar que fuera decrementando hasta el valor de -4, pero por lo contrario el tramo de 2 a -2 lo realiza de manera vertiginosa. Cuando alcanza el valor de -4 lo obligamos a ir a consigna cero.
4.5.1.3. Modelo en lazo cerrado sin controlador y con carga Esta es la tercera opción posible, y abrirá el modelo rtw_cl2.mdl que es una réplica del rtw.mdl pero sin controlador. De esta manera se deja una puerta abierta a un posible control diferente al Z, como por ejemplo mediante la utilización de lógica borrosa.
Memoria Técnica
65
Ilustración 41: Aspecto del modelo en lazo cerrado sin controlador y con carga
Para conocer los detalles del modelo ir al apartado 4.5.1.1, ya que siguen el mismo patrón.
4.5.2. Parámetros de entrada
La interfaz de los parámetros de entrada permite modificar la consigna, la rampa, el sentido de giro (solo en lazo abierto) y el tiempo de retardo, de cualquiera de los tres modelos.
Ilustración 42: Aspecto de la interfaz para la entrada de parámetros de entrada
Cuando se abra un modelo en lazo cerrado, como por ejemplo la opción 1 ó 3, el botón del sentido de giro permanecerá invisible.
4.5.3. Parámetros del controlador
Mediante el marco de los parámetros del controlador es posible modificar las constantes de este, y será el programa el encargado de calcular la función de transferencia del control. Esta opción ha sido pensada para hacer un ajuste manual afinando
Memoria Técnica
66
empíricamente el diseño, o bien simplemente para ver el efecto de la variación de una acción (proporcional, integral o derivativa). También existe la posibilidad de hacer un ajuste manual directamente sobre el bloque de la función de transferencia. Esta última opción se ha contemplado para el caso que se haga un diseño en papel del controlador, en que sea calculado todo el bloque.
Ilustración 43: Aspecto del marco del ajuste de parámetros de controlador
4.5.4. Parámetros de ejecución
La interfaz de los parámetros de ejecución permite modificar el instante de tiempo inicial, final, el tiempo de muestreo, la conexión de la placa con la aplicación real time, la ejecución del modelo, la parada de la ejecución y la compilación. La compilación es necesaria cada vez que se realice algún cambio en modelo, es decir, cada vez que se cambien conexiones, se generen bloques nuevos o se cambien características de simulación como el periodo de muestreo o los valores de tiempo inicial o final. No es necesario realizar una compilación cuando se realice el cambio del Value de los bloques, por ejemplo, cuando se cambie el valor de la consigna del escalón, o la rampa, o del sentido de giro.
Ilustración 44: Marco con los parámetros de ejecución
Existe la posibilidad de conectar la placa y ejecutar la aplicación bajo un mismo control, como también existe la posibilidad de parar la ejecución.
4.5.5. Visualización de gráficos
Para la visualización de gráficos se ha implementado esta herramienta, que permitirá visualizar datos en tiempo real (mediante el bloque Scope) y en post-procesado (mediante la GUI). Una limitación importante en Matlab es que no podemos capturar o visualizar datos si la ejecución en tiempo real no ha finalizado. Esto hecho solo se produce trabajando en modo externo y no trabajando en modo normal. Lo que ocurre cuando se hace una ejecución en tiempo real (en modo externo) es que las variables no son accesibles hasta que ha finalizado el tiempo de ejecución, es solo en
Memoria Técnica
67
ese momento cuando los datos son pasados al Workspace de Matlab y pueden ser utilizados para hacer gráficas u operaciones. Esta limitación ha sido confirmada por el servicio técnico de Matlab, que respondió que en futuras versiones lo resolverían (consultar anexos de cartas a Matlab).
Ilustración 45: Aspecto de la interfaz para la visualización de datos
4.5.5.1. Opciones para la visualización de datos de entrada/salida Para visualizar datos de entrada/salida existen tres posibles soluciones:
Opción AND: Cada vez que se selecciona este radiobutton nos permite visualizar gráficos conservando el anterior cada vez que se selecciona un dato en la lista desplegable. Pudiendo visualizar de 1 hasta n gráficos en la ventana, solo se borrará la pantalla cuando se le indique a través del botón de borrar pantalla. A cada gráfico se le asigna un color diferente para poder ser diferenciados cuando estén solapados. La visualización es a post-procesado.
Opción OR: Esta opción solo permite la visualización de un gráfico a la vez.
Cuando haya un gráfico en pantalla y se seleccione un dato a visualizar, el nuevo machacará al anterior. El color de los valores gráficos por defecto es el azul. La visualización es a post-procesado.
Opción Scope: Esta opción se diferencia de las anteriores porqué permite la
visualización de datos en tiempo real. Es posible accediendo directamente al bloque Scope que tenemos en el modelo.
Memoria Técnica
68
Ilustración 46: Opciones de gráfico de las de la interfaz, opción AND y Scope respectivamente
4.5.5.2. Selección datos a visualizar Los pasos para visualizar un gráfico son: seleccionar el modo de visualización (AND-OR-Scope), seleccionar el dato que queremos en el gráfico mediante la listbox:
Velocidad Error Controlador Sensor Hall Sobreintensidad Rama A Sobreintensidad Rama B Sobreintensidad Sensor Hall Entrada Velocidad de Salida Control Velocidad Salida Control sin limitador, y
Por último confirmar con el botón Plota.
Ilustración 47: Lista desplegable de variables a visualizar
4.5.5.3. Opciones de zoom y de centrado Cuando se tenga un gráfico en pantalla se podrá hacer un zoom para ampliar una región de visualización de datos (zoom out), o bien para reducirla (zoom in). A parte de todo estos podemos marcar los limites del gráfico que más interese marcando las
Memoria Técnica
69
coordenadas: Xmax, Xmin, Ymax e Ymin. Para que los valores tengan efecto se deberá deseleccionar la configuración automática de los ejes (el radiobutton Eixos Auto). Cuando se marque la opción de Eixos Auto el gráfico volverá a tener los valores por defecto, es decir se visualizará todo el gráfico. En ambos casos se deberá confirmar con el botón plota.
Ilustración 48: Marco con las opciones para visualizar las zonas que sean de interés
4.5.6. Guardar y cargar datos
Existe la posibilidad de guardar los datos procedentes de la ejecución en tiempo real en un fichero .MAT. Como también existe la posibilidad de recuperar esos datos y visualizarlos en la GUI. Para poder guardar los datos habrá que:
Especificar la ruta donde se desea guardar los ficheros, se aconseja que sea la que coge por defecto, que es la del directorio de trabajo de nuestra sesión de trabajo con Matlab.
Escribir el nombre del fichero que se desea guardar. En caso que no se escriba un nombre escogerá el nombre por defecto matlab.dat.
Pulsar el botón de guardar. Para poder cargar un fichero el procedimiento es similar:
Especificar la ruta donde se encuentra el fichero. Escribir el nombre del fichero que deseamos cargar. En caso que no exista o no
se introduzca un nombre en la casilla, la ventana de dialogo se quejará y nos pedirá que volvamos a introducir un nombre correcto, o que lo introduzcamos respectivamente.
Pulsar el botón de cargar.
Ilustración 49: Aspecto de la interfaz antes de grabar o cargar y una vez se carga la variable y su ruta
Memoria Técnica
70
4.5.7. Casilla de diálogo
En ocasiones se hace interesante que la aplicación en tiempo real establezca mensajes de respuesta a acciones realizadas por el usuario. Es decir, que de mensajes de error, que avise el inicio o fin de las compilaciones, o la conexión y desconexión con la placa de adquisición, etc. Pues bien, se ha contemplado esta opción mediante la casilla de diálogo, que no es nada más que un texto estático. Esto quiere decir que es un texto que puede ser leído, pero no puede ser modificado por el usuario.
Ilustración 50: Ejemplos de mensajes generados por la aplicación en la casilla de diálogo
4.5.8. Botones para cerrar la aplicación
Ilustración 51: Botones para cerrar la aplicación
En la Ilustración 51 se pueden apreciar los botones que nos permiten cerrar la aplicación de tiempo real, es decir, la GUI y el modelo que se esté utilizando. La diferencia entre Tanca y Tanca i Salva, es que el primero cierra la aplicación sin guardar cambios y el segundo cierra guardando los cambios producidos en el modelo. Hay que remarcar que al arrancar la GUI la siguiente vez, se actualizarán todos los datos del modelo en los campos correspondientes de la aplicación: consigna, valor retraso, tiempos de muestreo, inicial y final, etc.
4.5.9. Diagrama de flujo general
A continuación se muestra el diagrama de bloques general de la aplicación desarrollada para trabajar en tiempo real. El siguiente diagrama no intenta entrar en detalle, sino resumir el principio de funcionamiento de la GUI.
Memoria Técnica
71
Inicio de Programa:RTWT_OpeningFcn
LazoCerrado? Sin
Control
Si
No LazoCerrado?Control Z
- Captura de la ruta de trabajo- Transferencia de parametrosmodelo a las editboxes de laaplicación- Invisibilidad de los comandos:inversión de giro y parametrosdel controlador.- Limitación puntos simulación- Inicialización de variablesgenerales
Si
No LazoAbierto?
No
Si
Abrir modelo:rtw_cl2
(si es que no está abierto)
Abrir modelo:rtw_cl
(si es que no está abierto)
Abrir modelo:rtw
(si es que no está abierto)
- Captura de la ruta de trabajo- Transferencia de parametrosmodelo a las editboxes de laaplicación- Visibilidad de los comandos:inversión de giro y parametrosdel controlador.- Limitación puntos simulación- Inicialización de variablesgenerales
- Captura de la ruta de trabajo- Transferencia de parametrosmodelo a las editboxes de laaplicación- Invisibilidad de los comandos:inversión de giro y parametrosdel controlador.- Limitación puntos simulación- Inicialización de variablesgenerales
Transferencia de los valores de las editboxes a el modelo en funcionamiento
Evento?Si
No
Ejecución de la acción demandada y actualización de las variables
Fin ProgramaCerrar?Si Cerrar
Salvando?Si
Ilustración 52: Diagrama de flujo general de la GUI
Memoria Técnica
72
4.6. Código fuente de la GUI De la misma manera que en el apartado anterior se separaban los elementos que componen la GUI para poder explicar el funcionamiento de esta. En este apartado se separa el código que compone la GUI para poder hacer más inteligible los contenidos. Las partes que los compondrán se ajustarán bastante a la estructura anterior, es interesante que así sea, ya que permitirá relacionar más fácilmente la operatibilidad de la GUI y su código.
Función de apertura Parámetros de entrada Parámetros del controlador Parámetros de ejecución Visualización de gráficos Guardar y cargar datos Ventana de diálogo y cerrar aplicación
4.6.1. Función de Apertura
En el momento en que se inicie el programa de la aplicación en tiempo real, la primera función que se ejecuta es la OpeningFcn, o traducido literalmente función de apertura. Dentro de ella se inicializan las variables globales que indican con que modelo se comienza la aplicación en tiempo real. El modelo que se arranca por defecto es lazo cerrado con controlador. Posteriormente se hace una llamada a la función inici y actualitza. function RTWT_OpeningFcn(hObject, eventdata, handles, varargin) %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % Se comienza con el modelo el lazo cerrado y controlador por defecto set(handles.rboto_cl,'Value',1); cl=1;ol=0;cl2=0; assignin('base','cl',cl); assignin('base','ol',ol); assignin('base','cl2',cl2);
inici(handles); actualitza(handles);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Choose default command line output for RTWT handles.output = hObject;
% Update handles structure guidata(hObject, handles);
La función inici se ejecuta al arrancar la aplicación por primera vez y lo que hace es capturar todos los valores que tiene el modelo y pasarlos a la GUI o aplicación. Esta
Memoria Técnica
73
rutina se encarga de capturar la ruta de trabajo que será la utilizada para grabar los datos del Wokspace de Matlab, es decir, los parámetros obtenidos en la ejecución que podrán ser visualizados posteriormente y siempre que se desee. Como se ha dicho con anterioridad, la rutina se encarga de capturar los valores del modelo y los pone dentro de las editboxes correspondientes. Por ejemplo, se capturan los valores de:
Consigna Rampa Tiempo de retardo Valor de la inversión de giro Inicialización del contador del grid. Inicialización de los valores para plotar por defecto
Antes de capturar los valores del modelo determinará que modelo es el que está abierto para saber la ruta donde buscarlos. function inici(handles) cl=evalin('base','cl'); ol=evalin('base','ol'); cl2=evalin('base','cl2'); % Se abre por primera vez el modelo para coger los valores que tiene % en el modelo y ponerlos en la GUI, en el caso que sea la primera vez % se haya abierto el programa. % % % % % % % % % % % % INICIO PARAM.GENERALES % % % % % % % % % % % % %
% % % Se capturan los valores de los parametros generales, son aquellos que
no % dependen del modelo escogido
% Se coge la ruta por defecto de matlab para poder grabar las variables
en % un fichero .MAT ruta=cd; set(handles.edit_ruta,'String',ruta); % Se hace invisible la editbox del nombre de la variable a guardar en el
WS set(handles.edit_nomvar,'Visible','off'); % Variable para el grid para que actue como un pushbutton pero sin % enclavarse cnt=0; assignin('base','cnt',cnt); % Parametros para plotar por defecto set(handles.rboto_and,'Value',1); set(handles.rboto_or,'Value',0); set(handles.rboto_scope,'Value',0); set(handles.popupmenu1,'Value',1); pand=1;or=0;scope_stat=0;popval=1; assignin('base','pand',pand); assignin('base','or',or); assignin('base','scope',scope_stat); assignin('base','popval',popval); % % % % % % % % % % % % FIN PARAM.GENERALES % % % % % % % % % % % % % %
% % %
if cl==1
Memoria Técnica
74
if isempty(find_system('Name','rtw'))open_system('rtw');end if isempty(find_system('Name','rtwol')) else
close_system('rtwol',1);end if isempty(find_system('Name','rtw_cl2')) else
close_system('rtw_cl2',1);end % Se cogen los valores del modelo y se ponen dentro de las editboxes % Consigna
set(handles.edit_consigna,'String',get_param('rtw/Constant','Value')); % Rampa set(handles.edit_rampa,'String',get_param('rtw/Constant2','Value')); % Tiempo de retardo para la rampa y el escalón set(handles.edit_td, 'String',get_param('rtw/Step','time')); limitapunts(handles); controlador(handles); end
if ol==1
if isempty(find_system('Name','rtwol'))open_system('rtwol');end if isempty(find_system('Name','rtw')) else close_system('rtw',1);end if isempty(find_system('Name','rtw_cl2')) else
close_system('rtw_cl2',1);end % Se cogen los valores del modelo y se ponen dentro de las editboxes % Consigna
set(handles.edit_consigna,'String',get_param('rtwol/Constant','Value')); % Rampa
set(handles.edit_rampa,'String',get_param('rtwol/Constant2','Value')); % Tiempo de retardo para la rampa y el escalón set(handles.edit_td, 'String',get_param('rtwol/Step','time')); %Sentido de giro
set(handles.tboto_inversio,'Value',str2num(get_param('rtwol/Constant1','
Value'))); limitapunts(handles); end
if cl2==1
if isempty(find_system('Name','rtw_cl2'))open_system('rtw_cl2');end if isempty(find_system('Name','rtwol')) else
close_system('rtwol',1);end if isempty(find_system('Name','rtw')) else close_system('rtw',1);end % Se cogen los valores del modelo y se ponen dentro de las editboxes % Consigna
set(handles.edit_consigna,'String',get_param('rtw_cl2/Constant','Value')
); % Rampa
set(handles.edit_rampa,'String',get_param('rtw_cl2/Constant2','Value')); % Tiempo de retardo para la rampa y el escalón set(handles.edit_td, 'String',get_param('rtw_cl2/Step','time')); limitapunts(handles); end
Memoria Técnica
75
La rutina actualitza viene a ser la inversa de la rutina inici, ya que su función es capturar los valores que se encuentran dentro de las editboxes y ponerlos dentro de los bloques del modelo para que los cambios realizados en la GUI tengan efecto durante la ejecución de la aplicación. La filosofía de funcionamiento es la misma que en la rutina inici, donde tenemos unos parámetros generales y unos parámetros específicos de cada modelo. A continuación se pueden ver las líneas de programa que detallan lo explicado. function actualitza(handles) ol=evalin('base','ol'); cl=evalin('base','cl'); cl2=evalin('base','cl2');
if cl==1 if isempty(find_system('Name','rtw'))open_system('rtw');end if isempty(find_system('Name','rtwol')) else
close_system('rtwol',1);end if isempty(find_system('Name','rtw_cl2')) else
close_system('rtw_cl2',1);end %figure(RTWT); % Se coge el valor de la editbox i lo pone el bloque del modelo set_param('rtw/Constant','Value',... get(handles.edit_consigna,'String'))
set_param('rtw/Constant2','Value',... get(handles.edit_rampa,'String')) % Tiempo de retardo para el escalon y la rampa set_param('rtw/Step','Time',get(handles.edit_td,'String')); set_param('rtw/Step1','Time',get(handles.edit_td,'String')); % Se coge el valor de la editbox y se coloca como parametro general
de % la simulación %PARAMETROS DE LA SIMULACION set_param('rtw','FixedStep',get(handles.edit_ts, 'String')); set_param('rtw','Starttime',get(handles.edit_ti,'String')); set_param('rtw','Stoptime',get(handles.edit_tf,'String'));
limitapunts(handles); controlador(handles); end
if ol==1 if isempty(find_system('Name','rtwol'))open_system('rtwol');end if isempty(find_system('Name','rtw')) else close_system('rtw',1);end if isempty(find_system('Name','rtw_cl2')) else
close_system('rtw_cl2',1);end %figure(RTWT);
set_param('rtwol/Constant1','Value',num2str(get(handles.tboto_inversio,'
Value'))); % Se coge el valor de la editbox i lo pone el bloque del modelo
set_param('rtwol/Constant','Value',get(handles.edit_consigna,'String'));
set_param('rtwol/Constant2','Value',get(handles.edit_rampa,'String')); % Tiempo de retardo para el escalon y la rampa set_param('rtwol/Step','Time',get(handles.edit_td,'String')); set_param('rtwol/Step1','Time',get(handles.edit_td,'String')); % Se coge el valor de la editbox y se coloca como parametro general
de
Memoria Técnica
76
% la simulación %PARAMETROS DE LA SIMULACION set_param('rtwol','FixedStep',get(handles.edit_ts, 'String')); set_param('rtwol','Starttime',get(handles.edit_ti,'String')); set_param('rtwol','Stoptime',get(handles.edit_tf,'String')); limitapunts(handles); end
if cl2==1
if isempty(find_system('Name','rtw_cl2'))open_system('rtw_cl2');end if isempty(find_system('Name','rtwol')) else
close_system('rtwol',1);end if isempty(find_system('Name','rtw')) else close_system('rtw',1);end %figure(RTWT); % Se coge el valor de la editbox i lo pone el bloque del modelo set_param('rtw_cl2/Constant','Value',... get(handles.edit_consigna,'String'))
set_param('rtw_cl2/Constant2','Value',... get(handles.edit_rampa,'String')) % Tiempo de retardo para el escalon y la rampa set_param('rtw_cl2/Step','Time',get(handles.edit_td,'String')); set_param('rtw_cl2/Step1','Time',get(handles.edit_td,'String')); % Se coge el valor de la editbox y se coloca como parametro general
de % la simulación %PARAMETROS DE LA SIMULACION set_param('rtw_cl2','FixedStep',get(handles.edit_ts, 'String')); set_param('rtw_cl2','Starttime',get(handles.edit_ti,'String')); set_param('rtw_cl2','Stoptime',get(handles.edit_tf,'String'));
limitapunts(handles); end
4.6.2. Parámetros de entrada
Los parámetros de entrada se utilizan en dos casos. El primero cuando se genera un evento provocado por el clic del ratón o bien por la pulsación de la tecla enter. El segundo cuando existe una función que solicita conocer su valor actual, a través de un get o bien cuando hay una función que cambia el valor de este parámetro a través de la función set. A continuación se listan los parámetros de entrada y se muestran sus rutinas.
4.6.2.1. Consigna Este parámetro es un editbox y como tal le corresponde un tag de la forma edit_consigna. Cada vez que se genere un evento se realiza una llamada a actualitza, que actualiza el valor de todos los elementos, incluido el presente. function edit_consigna_Callback(hObject, eventdata, handles) actualitza(handles);
Memoria Técnica
77
4.6.2.2. Rampa Este parámetro es un editbox y como tal le corresponde un tag de la forma edit_rampa. Cada vez que se genere un evento se realiza una llamada a actualitza, que actualiza el valor de todos los elementos, incluido el presente. function edit_rampa_Callback(hObject, eventdata, handles) actualitza(handles);
4.6.2.3. Inversión de giro Este parámetro es un togglebutton y como tal le corresponde un tag de la forma tbutton_inversio. Cada vez que se genere un evento se realiza una llamada a actualitza, que actualiza el valor de todos los elementos, incluido el presente. function tboto_inversio_Callback(hObject, eventdata, handles) actualitza(handles);
4.6.2.4. Tiempo de retardo Este parámetro es un editbox y como tal le corresponde un tag de la forma edit_td. Cada vez que se genere un evento se realiza una llamada a actualitza, que actualiza el valor de todos los elementos, incluido el presente. function edit_td_Callback(hObject, eventdata, handles) actualitza(handles);
4.6.3. Parámetros del controlador
Los parámetros del controlador se utilizan en dos casos. El primero cuando se genera un evento provocado por el clic del ratón o bien por la pulsación de la tecla enter. El segundo cuando existe una función que solicita conocer su valor actual, a través de un get o bien cuando hay una función que cambia el valor de este parámetro a través de la tecla set. A continuación listamos los parámetros del controlador y mostramos sus rutinas.
4.6.3.1. Constante proporcional Este parámetro es un editbox y como tal le corresponde un tag de la forma edit_kp. Cada vez que se genere un evento se realiza una llamada a la función controlador, que actualizará el valor de todos los elementos, incluido el presente. function edit_kp_Callback(hObject, eventdata, handles) controlador(handles);
Memoria Técnica
78
4.6.3.2. Constante integral Este parámetro es un editbox y como tal le corresponde un tag de la forma edit_ki. Cada vez que se genere un evento se realiza una llamada a la función controlador, que actualizará el valor de todos los elementos, incluido el presente. function edit_ki_Callback(hObject, eventdata, handles) controlador(handles);
4.6.3.3. Constante derivativa Este parámetro es un editbox y como tal le corresponde un tag de la forma edit_kd. Cada vez que se genere un evento se realiza una llamada a la función controlador, que actualizará el valor de todos los elementos, incluido el presente. function edit_kd_Callback(hObject, eventdata, handles) controlador(handles);
4.6.3.4. Ajuste manual por función de transferencia Este parámetro es un radiobutton y como tal le corresponde un tag de la forma rboto_ajustFcnTf. Cuando se selecciona esta opción, lo primero hace invisible las casillas de ajuste de las constantes y abre el bloque de la función de transferencia del controlador para que se modifique directamente, sin necesidad de poner los valores de cada una de las constantes. En caso contrario, cuando se vuelva a seleccionar la opción, las casillas de las constantes se harán visibles. function rboto_ajustFcnTf_Callback(hObject, eventdata, handles) if(get(hObject,'Value')) set(handles.edit_kp,'Visible','off'); set(handles.edit_ki,'Visible','off'); set(handles.edit_kd,'Visible','off'); open_system('rtw/Discrete Transfer Fcn'); else set(handles.edit_kp,'Visible','on'); set(handles.edit_ki,'Visible','on'); set(handles.edit_kd,'Visible','on'); end
4.6.3.5. Función controlador Esta función es la encargada de coger los valores de las editboxes y realiza las operaciones oportunas para obtener los coeficientes del numerador y del denominador de la función de transferencia del controlador. function controlador(handles)
kd=str2double(get(handles.edit_kd,'String')); ki=str2double(get(handles.edit_ki,'String')); kp=str2double(get(handles.edit_kp,'String'));
Memoria Técnica
79
p=(kp+ki+kd); q=-(kp+2*kd); r= kd; u=1; v=-1; w=0;
num=[p q r]; den=[u v w]; numdz=strcat('[', num2str(num),']'); dendz=strcat('[', num2str(den),']'); set_param('rtw/Discrete Transfer Fcn','Denominator',dendz); set_param('rtw/Discrete Transfer Fcn','Numerator',numdz);
4.6.4. Parámetros de ejecución
Los parámetros de ejecución son aquellos que conciernen a la ejecución de la aplicación en tiempo real, y como tales necesitan ser compilados cada vez que se modifiquen. De la misma manera que los parámetros anteriores, se vuelven activos en dos casos: eventos de ratón o teclado y consultas o modificaciones de su valor. A continuación listamos los parámetros de ejecución y sus rutinas.
4.6.4.1. Tiempo inicial Este parámetro es un editbox y como tal le corresponde un tag de la forma edit_ti. Cada vez que se genere un evento se realiza una llamada a la función actualitza, que actualizará el valor de todos los elementos, incluido el presente. function edit_ti_Callback(hObject, eventdata, handles) actualitza(handles);
4.6.4.2. Tiempo final Este parámetro es un editbox y como tal le corresponde un tag de la forma edit_tf. Cada vez que se genere un evento se realiza una llamada a la función actualitza, que actualizará el valor de todos los elementos, incluido el presente. function edit_tf_Callback(hObject, eventdata, handles) actualitza(handles);
4.6.4.3. Tiempo discreto Este parámetro es un editbox y como tal le corresponde un tag de la forma edit_ts. Cada vez que se genere un evento se realiza una llamada a la función actualitza, que actualizará el valor de todos los elementos, incluido el presente.
Memoria Técnica
80
function edit_ts_Callback(hObject, eventdata, handles) actualitza(handles);
4.6.4.4. Conexión y ejecución de la aplicación Este parámetro es un pushbutton y como tal le corresponde un tag de la forma boto_connecta. Cada vez que se pulse este botón se imprime un mensaje en la casilla de diálogo diciendo que se está conectando y ejecutando. Y las acciones que lleva a cabo es poner el modelo con el que se esté trabajando en modo externo, conectar la placa y seguidamente comenzar a ejecutar la aplicación. function boto_connecta_Callback(hObject, eventdata, handles) ol=evalin('base','ol'); cl=evalin('base','cl'); cl2=evalin('base','cl2');
if cl==1 set(handles.text_dialeg,'String',... 'Connectant i executant...'); set_param('rtw','SimulationMode','external'); set_param('rtw','SimulationCommand','connect'); set_param('rtw','SimulationCommand','start'); end
if ol==1 set(handles.text_dialeg,'String',... 'Connectant i executant...'); set_param('rtwol','SimulationMode','external'); set_param('rtwol','SimulationCommand','connect'); set_param('rtwol','SimulationCommand','start'); end
if cl2==1 set(handles.text_dialeg,'String',... 'Connectant i executant...'); set_param('rtw_cl2','SimulationMode','external'); set_param('rtw_cl2','SimulationCommand','connect'); set_param('rtw_cl2','SimulationCommand','start'); end assignin('base','cl',cl); assignin('base','ol',ol); assignin('base','cl2',cl2);
4.6.4.5. Parada de la ejecución Este parámetro es un pushbutton y como tal le corresponde un tag de la forma boto_stop. Al pulsar este botón se para automáticamente la ejecución que se esté llevando a cabo y desconecta la placa de adquisición de la aplicación en tiempo real.
Memoria Técnica
81
function boto_stop_Callback(hObject, eventdata, handles) ol=evalin('base','ol'); cl=evalin('base','cl'); cl2=evalin('base','cl2');
if cl==1 set_param('rtw','SimulationCommand','stop'); set_param('rtw','SimulationCommand','disconnect'); set(handles.text_dialeg,'String',... 'S´ha parat l´Execució de l´aplicació "Real
Time"!'); end
if ol==1 set_param('rtwol','SimulationCommand','stop'); set_param('rtwol','SimulationCommand','disconnect'); set(handles.text_dialeg,'String',... 'S´ha parat l´Execució de l´aplicació "Real
Time"!'); end
if cl2==1 set_param('rtw_cl2','SimulationCommand','stop'); set_param('rtw_cl2','SimulationCommand','disconnect'); set(handles.text_dialeg,'String',... 'S´ha parat l´Execució de l´aplicació "Real
Time"!'); end
assignin('base','cl',cl); assignin('base','ol',ol); assignin('base','cl2',cl2);
4.6.4.6. Compilación Este parámetro es un pushbutton y como tal le corresponde un tag de la forma boto_compila. Al pulsar este botón se inicia la compilación del modelo que corresponda indicando el comienzo y el final de este proceso a través de la casilla de diálogo. function boto_compila_Callback(hObject, eventdata, handles) ol=evalin('base','ol'); cl=evalin('base','cl'); cl2=evalin('base','cl2');
if cl==1 set(handles.text_dialeg,'String',... 'Compilant...'); pause(0.5); rtwbuild('rtw'); %figure(RTWT); set(handles.text_dialeg,'String',... 'Finalitzada tasca de compilar'); end
if ol==1 set(handles.text_dialeg,'String',... 'Compilant...');
Memoria Técnica
82
pause(0.5); rtwbuild('rtwol'); %figure(RTWT); set(handles.text_dialeg,'String',... 'Finalitzada tasca de compilar'); end
if cl2==1 set(handles.text_dialeg,'String',... 'Compilant...'); pause(0.5); rtwbuild('rtw_cl2'); %figure(RTWT); set(handles.text_dialeg,'String',... 'Finalitzada tasca de compilar'); end
assignin('base','cl',cl); assignin('base','ol',ol); assignin('base','cl2',cl2);
4.6.5. Limitación de puntos de ejecución
Con la intención de acotar las posibilidades de error del usuario se ha ideado esta función. Durante el diseño de la aplicación en tiempo real se ha tenido deshabilitada está opción porque interesaba ver los límites tanto de la captura como de la representación de datos. Es decir, sin esta opción activada puede ser que conduzca al error al usuario y de errores de compilación, o lo más probable, dará representaciones erróneas por insuficiencia de datos. Mediante esta rutina se indica al usuario si el incremento de tiempo es correcto con el tiempo de muestreo seleccionado, la corrección es instantánea, si se excede el número de puntos máximos de representación estimados se utilizará el valor máximo. Por el contrario, si el valor es inferior al máximo no se hará ninguna corrección. function limitapunts(handles) ol=evalin('base','ol'); cl=evalin('base','cl');
ti=str2num(get_param(gcs,'Starttime')); tf=str2num(get_param(gcs,'Stoptime')); At=tf-ti; if cl==1 && ol==0 Ts=str2num(get_param('rtw','FixedStep')); elseif cl==0 && ol==1 Ts=str2num(get_param('rtwol','FixedStep')); end % puntos máximos de representación pt=str2num(get_param(gcs,'Decimation')); % Calculo del numero de puntos div=pt/Ts; Npt=At*div; Nptmax=40000; if(Npt>Nptmax) At=(Nptmax*Ts)/pt; ti=0; tf=num2str(At);
Memoria Técnica
83
msge='S´ha excedit el número máxim de punts...Recàlcul amb la
freqüència de mostreig seleccionada:'; msge2='tf='; msge3=strcat(msge,msge2,tf); set(handles.text_dialeg,'String',... msge3); end
% Se ponen los valores en las casillas correspondientes set(handles.edit_ti,'String',num2str(ti)); set(handles.edit_tf,'String',num2str(tf)); set(handles.edit_ts,'String',num2str(Ts));
% Se actualizan los valores en el modelo if cl==1 && ol==0 set_param('rtw','Starttime',num2str(ti)); set_param('rtw','Stoptime',num2str(tf)); set_param('rtw','FixedStep',num2str(Ts)); elseif cl==0 && ol==1 set_param('rtwol','Starttime',num2str(ti)); set_param('rtwol','Stoptime',num2str(tf)); set_param('rtwol','FixedStep',num2str(Ts)); end
4.6.6. Visualización de gráficos
En la visualización de gráficos intervienen hasta 15 elementos, y son de los tipos: radiobutton, pushbutton, editbox, popupmenu y axes. Dado que en el apartado anterior se ha descrito el funcionamiento, a continuación se numeran los elementos y las líneas de programa que contienen.
4.6.6.1. Opción de gráfico AND Este parámetro es un radiobutton y como tal le corresponde un tag de la forma rboto_and. Permite la visualización múltiple de gráficos poniendo su flag a 1 (a través de la variable pand). function rboto_and_Callback(hObject, eventdata, handles) pand = get (hObject,'Value'); if pand == 1 set(handles.rboto_or, 'Value',0); set(handles.rboto_scope, 'Value',0); scope_stat=0 pand=1; or=0; else set(handles.rboto_or, 'Value',0); set(handles.rboto_and, 'Value',1); set(handles.rboto_scope, 'Value',0); scope_stat=0; or=0; pand=1; end assignin('base','pand',pand); assignin('base','or',or); assignin('base','scope_stat',scope_stat);
Memoria Técnica
84
4.6.6.2. Opción de gráfico OR Este parámetro es un radiobutton y como tal le corresponde un tag de la forma rboto_or. Permite la visualización exclusiva de un solo gráfico poniendo su flag a 1 (a través de la variable por). function rboto_or_Callback(hObject, eventdata, handles) or = get (hObject,'Value'); if or == 1 set(handles.rboto_and, 'Value',0); set(handles.rboto_scope, 'Value',0); scope_stat=0; or=1; pand=0; else set(handles.rboto_and, 'Value',0); set(handles.rboto_or, 'Value',1); set(handles.rboto_scope, 'Value',0); scope_stat=0; pand=0; or=1; end assignin('base','or',or); assignin('base','pand',pand); assignin('base','scope_stat',scope_stat);
4.6.6.3. Opción de gráfico SCOPE Este parámetro es un radiobutton y como tal le corresponde un tag de la forma rboto_scope. Permite la visualización en tiempo real sobre el modelo de un gráfico poniendo su flag a 1 (a través de la variable scope_stat). function rboto_scope_Callback(hObject, eventdata, handles) scope_stat=get(hObject,'Value'); assignin('base','scope_stat',scope_stat); if scope_stat== 1 set(handles.rboto_and, 'Value',0); set(handles.rboto_or, 'Value',0); scope_stat=1; or=0; pand=0; else set(handles.rboto_and, 'Value',0); set(handles.rboto_or, 'Value',0); set(handles.rboto_scope, 'Value',1); scope_stat=1; pand=0; or=0; end assignin('base','or',or); assignin('base','pand',pand); assignin('base','scope_stat',scope_stat);
Memoria Técnica
85
4.6.6.4. Selección de variable a visualizar Este parámetro es un popupmenu y como tal le corresponde un tag de la forma popupmenu1. Permite la visualización de 9 tipos de variables descritas en el apartado 4.5.5.2rmite la visualización de 9 tipos de variables descritas en el apartado 4.5.5.2. En esta rutina simplemente recogemos el valor de la opción seleccionada en la variable popval para luego en la rutina de boto_plota imprimirla en pantalla. function popupmenu1_Callback(hObject, eventdata, handles) popval = get(hObject,'Value');
assignin('base','popval',popval);
4.6.6.5. Borrar pantalla Este parámetro es un pushbutton y como tal le corresponde un tag de la forma boto_esborrap. Esta rutina tiene una variable que permite conocer el estado de la cuadrícula, en caso de que se borre pantalla evitará la desaparición del grid. function boto_esborrap_Callback(hObject, eventdata, handles) hold off; newplot quadricula=evalin('base',quadricula);
if cnt==1 grid on; end
4.6.6.6. Activación de la cuadrícula de pantalla Este parámetro es un pushbutton y como tal le corresponde un tag de la forma boto_grid. Mediante esta función conseguimos que un pushbutton se comporte como un togglebutton, y la variable que actúa como memoria es cnt. Cada vez que se pulse el botón que activa la cuadrícula, el valor de cnt irá oscilando de 0 a 1 de la misma manera que el grid de la pantalla se desactivará o activará respectivamente. De esta manera, cuando se borre la pantalla de visualización se recuperará el estado del grid en la siguiente gráfica. function boto_grid_Callback(hObject, eventdata, handles)
quadricula=get(hObject,'Value') cnt=evalin('base','cnt'); if quadricula==1 cnt=~cnt assignin('base','cnt',cnt) end if cnt==1 hold on; grid on elseif cnt==0 hold off grid off end
Memoria Técnica
86
4.6.6.7. Casillas de selección de área de visualización Estos parámetros son cuatro, indicando el valor mínimo y máximo de las coordenadas x e y. Son del tipo editbox y sus respectivos tags se corresponden a edit_xmin, edit_xmax, edit_ymin y edit_ymax. Su función es la de marcar una superficie de visualización que vendrá siempre acompañada de un zoom in o un zoom out para que surta efecto, por tanto no tendrá una rutina concreta. Esto quiere decir que su valor solo será consultado por las rutinas que se generan con boto_zi y boto_zo.
4.6.6.8. Zoom in Este parámetro es un pushbutton y como tal le corresponde un tag de la forma boto_zi. Cada vez que se pulse este botón, se reduce un 61,8% el tamaño del área de visualización. function boto_zi_Callback(hObject, eventdata, handles) %handles.axes_plot.zoomIn if 1 xm = str2double(get(handles.edit_xmin, 'String')); xM = str2double(get(handles.edit_xmax, 'String')); ym = str2double(get(handles.edit_ymin, 'String')); yM = str2double(get(handles.edit_ymax, 'String')); axis ([0.618*xm 0.618*xM 0.618*ym 0.618*yM]); eixos_e = axis; set(handles.edit_xmin, 'String', num2str(eixos_e(1,1))); set(handles.edit_xmax, 'String', num2str(eixos_e(1,2))); set(handles.edit_ymin, 'String', num2str(eixos_e(1,3))); set(handles.edit_ymax, 'String', num2str(eixos_e(1,4))); end
4.6.6.9. Zoom out Este parámetro es un pushbutton y como tal le corresponde un tag de la forma boto_zo. La función que realiza es la contraria a la que realiza el zoom in, es decir, que cada vez que se pulse este botón se aumenta el 61,8% del área de visualización. function boto_zo_Callback(hObject, eventdata, handles) % hObject handle to boto_zo (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) if 1 xm = str2double(get(handles.edit_xmin, 'String')); xM = str2double(get(handles.edit_xmax, 'String')); ym = str2double(get(handles.edit_ymin, 'String')); yM = str2double(get(handles.edit_ymax, 'String')); axis ([1.618*xm 1.618*xM 1.618*ym 1.618*yM]); eixos_e = axis; set(handles.edit_xmin, 'String', num2str(eixos_e(1,1))); set(handles.edit_xmax, 'String', num2str(eixos_e(1,2))); set(handles.edit_ymin, 'String', num2str(eixos_e(1,3))); set(handles.edit_ymax, 'String', num2str(eixos_e(1,4))); end
Memoria Técnica
87
4.6.6.10. Selección automática de visualización Este parámetro es un radiobutton y como tal le corresponde un tag de la forma rboto_eixosauto. La función que realiza este control es la de recuperar la visualización global de la gráfica cuando se presiona el botón de plotar.
4.6.6.11. Área de visualización de gráficos Este elemento es del tipo axes y tiene el nombre de axes_plot, que tiene la función de recibir todos los datos que deben ser plotados.
4.6.6.12. Visualización de gráficos Este parámetro es un pushbutton y como tal le corresponde un tag de la forma boto_plot. En esta rutina se recogen todos los valores de opción de visualización, así como el modelo que se encuentra abierto y el modo de visualización. Si se selecciona un parámetro que no exista en el modelo seleccionado, entonces aparecerá un mensaje en la editbox box indicando que la selección no es válida. function boto_plot_Callback(hObject, eventdata, handles) pand=evalin('base','pand'); or=evalin('base','or'); popval=evalin('base','popval'); scope_stat=evalin('base','scope_stat'); cnt=evalin('base','cnt'); ol=evalin('base','ol'); cl=evalin('base','cl'); cl2=evalin('base','cl2');
if scope_stat==1
if cl==1 if popval==1 open_system('rtw/Sortida3') elseif popval==2 open_system('rtw/Sortida2') elseif popval==3 open_system('rtw/Entrada1') elseif popval==4 open_system('rtw/Sortida5') elseif popval==5 open_system('rtw/Sortida6') elseif popval==6 open_system('rtw/Sortida7') elseif popval==7 open_system('rtw/Sortida9') elseif popval==8 open_system('rtw/Sortida1') elseif popval==9 open_system('rtw/Sortida4') end
Memoria Técnica
88
end
if ol==1 if popval==1 open_system('rtwol/Sortida3') elseif popval==2 set(handles.text_dialeg,'String',... 'Opció no valida amb el model seleccionat'); elseif popval==3 open_system('rtwol/Entrada1') elseif popval==4 open_system('rtwol/Sortida5') elseif popval==5 open_system('rtwol/Sortida6') elseif popval==6 open_system('rtwol/Sortida7') elseif popval==7 open_system('rtwol/Sortida9') elseif popval==8 open_system('rtw/Sortida3') elseif popval==9 open_system('rtw/Sortida2') end end
if cl2==1 if popval==1 open_system('rtw/Sortida3') elseif popval==2 open_system('rtw/Sortida2') elseif popval==3 open_system('rtw/Entrada1') elseif popval==4 open_system('rtw/Sortida5') elseif popval==5 open_system('rtw/Sortida6') elseif popval==6 open_system('rtw/Sortida7') elseif popval==7 open_system('rtw/Sortida9') elseif popval==8 open_system('rtw/Sortida1') elseif popval==9 open_system('rtw/Sortida4') end end
end
if pand==1 hold if popval == 1 x = evalin('base','velocitat(:,2)'); plot(x,'b'); elseif popval==2 x = evalin('base','error(:,2)'); plot(x,'r');
elseif popval==3
Memoria Técnica
89
x = evalin('base','shall(:,2)'); plot(x,'y');
elseif popval==4 x = evalin('base','sia(:,2)'); plot(x,'g');
elseif popval==5 x = evalin('base','sib(:,2)'); plot(x,'c'); elseif popval==6 x = evalin('base','sishall(:,2)'); plot(x,'m'); elseif popval==7 x = evalin('base','entrada(:,2)'); plot(x,'r'); elseif popval==8 x = evalin('base','sortida(:,2)'); plot(x,'y'); elseif popval==9 x = evalin('base','sortida3(:,2)'); plot(x,'g'); end
auto = get(handles.rboto_eixosauto, 'Value');
if auto == 1 axis auto; eixos_e = axis; set(handles.edit_xmin, 'String', num2str(eixos_e(1,1))); set(handles.edit_xmax, 'String', num2str(eixos_e(1,2))); set(handles.edit_ymin, 'String', num2str(eixos_e(1,3))); set(handles.edit_ymax, 'String', num2str(eixos_e(1,4))); else xm = str2double(get(handles.edit_xmin, 'String')); xM = str2double(get(handles.edit_xmax, 'String')); ym = str2double(get(handles.edit_ymin, 'String')); yM = str2double(get(handles.edit_ymax, 'String')); axis ([xm xM ym yM]); end
hold; end %fin del while and==1
if or == 1
if popval == 1 x = evalin('base','velocitat(:,2)'); plot(x); elseif popval==2 x = evalin('base','error(:,2)'); plot(x); elseif popval==3 x = evalin('base','shall(:,2)'); plot(x); elseif popval==4 x = evalin('base','sia(:,2)');
Memoria Técnica
90
plot(x); elseif popval==5 x = evalin('base','sib(:,2)'); plot(x); elseif popval==6 x = evalin('base','sishall(:,2)'); plot(x); elseif popval==7 x = evalin('base','entrada(:,2)'); plot(x); elseif popval==8 x = evalin('base','sortida(:,2)'); plot(x,'y'); elseif popval==9 x = evalin('base','sortida3(:,2)'); plot(x,'g'); end
auto = get(handles.rboto_eixosauto, 'Value');
if auto == 1 axis auto; eixos_e = axis; set(handles.edit_xmin, 'String', num2str(eixos_e(1,1))); set(handles.edit_xmax, 'String', num2str(eixos_e(1,2))); set(handles.edit_ymin, 'String', num2str(eixos_e(1,3))); set(handles.edit_ymax, 'String', num2str(eixos_e(1,4))); else xm = str2double(get(handles.edit_xmin, 'String')); xM = str2double(get(handles.edit_xmax, 'String')); ym = str2double(get(handles.edit_ymin, 'String')); yM = str2double(get(handles.edit_ymax, 'String')); axis ([xm xM ym yM]); end
end %fin while or==1
if cnt==1 grid on; else grid off; end
4.6.7. Parámetros de guardar y cargar datos
Para realizar la función de cargar y guardar datos en formato .mat, correspondientes a las simulaciones, intervienen 4 elementos.
4.6.7.1. Nombre de la variable Este parámetro es un editbox y como tal le corresponde un tag de la forma edit_nomvar. Mediante esta casilla se captura el nombre del fichero .mat que se desea guardar o cargar.
Memoria Técnica
91
function edit_nomvar_Callback(hObject, eventdata, handles) a=get(hObject,'String'); assignin('base','a',a);
4.6.7.2. Ruta para salvar/guardar datos Este parámetro es un editbox y como tal le corresponde un tag de la forma edit_ruta. Mediante esta casilla se captura el nombre del fichero .mat que se desea guardar o cargar. function edit_ruta_Callback(hObject, eventdata, handles) ruta=get(handles.edit_ruta,'String'); cd(ruta)
4.6.7.3. Salvar/guardar datos Estos dos elementos son del tipo pushbutton y tienen el formato boto_guarda y boto_carga. function boto_guarda_Callback(hObject, eventdata, handles) %Es mira que la var a existeixi, que es la que porta el nom evalin('base','exist a'); f=evalin('base','ans');
if (f) a=evalin('base','a'); assignin('base','a',a); set(handles.edit_nomvar,'Visible','on'); set(handles.edit_nomvar,'String',a); set(handles.text_dialeg,'String',... 'Miri si el nom de la variable i la ruta son correctes i premi
"guarda"'); a=get(handles.edit_nomvar,'String'); assignin('base','a',a);
if(~isempty(a)) cola='.mat'; assignin('base','cola',cola) g=evalin('base','strcat(a,cola)'); if(exist(g,'file')) set(handles.text_dialeg,'String',... 'Nom Fitxer Existent.Vol Sobreescriue? Premi Guarda
(SI).'); if(handles.boto_guarda) evalin('base','save (a)'); set(handles.text_dialeg,'String',... 'Fitxer .MAT Guardat'); end
else evalin('base','save (a)'); set(handles.text_dialeg,'String',... 'Fitxer .MAT Guardat'); end end
Memoria Técnica
92
else set(handles.edit_nomvar,'Visible','on'); set(handles.text_dialeg,'String',... 'Introduiexi el nom pel fitxer .MAT a guardar'); a=get(handles.edit_nomvar,'String'); assignin('base','a',a); %Es torna a comprovar que shagui introduit un nom evalin('base','exist a'); f=evalin('base','ans'); if(f) evalin('base','save (a)'); set(handles.text_dialeg,'String',... 'Fitxer .MAT Guardat'); else set(handles.text_dialeg,'String',... 'Si us plau, introduiexi el nom pel fitxer .MAT a guardar'); end end
function boto_carga_Callback(hObject, eventdata, handles) evalin('base','exist a'); f=evalin('base','ans');
if (f) a=evalin('base','a'); assignin('base','a',a); set(handles.edit_nomvar,'Visible','on'); set(handles.edit_nomvar,'String',a); set(handles.text_dialeg,'String',... 'Miri si el nom de la variable i la ruta son correctes i premi
"carrega"'); a=get(handles.edit_nomvar,'String'); assignin('base','a',a);
if(~isempty(a)) cola='.mat'; assignin('base','cola',cola) g=evalin('base','strcat(a,cola)'); if(exist(g,'file')) evalin('base','load (a)'); set(handles.text_dialeg,'String',... 'Fitxer .MAT Carregat'); else set(handles.text_dialeg,'String',... 'Fitxer .MAT NO Existent. Torna-hi'); end end
else set(handles.edit_nomvar,'Visible','on'); set(handles.text_dialeg,'String',... 'Introdueix a la casella el nom del fitxer .MAT a carregar'); a=get(handles.edit_nomvar,'String'); assignin('base','a',a); %Es torna a comprovar que shagui introduit un nom
Memoria Técnica
93
evalin('base','exist a'); f=evalin('base','ans'); e=evalin('base','isempty(a)');
if(f==1 && e==0) evalin('base','load (a)'); set(handles.text_dialeg,'String',... 'Fitxer .MAT Carregat'); else set(handles.text_dialeg,'String',... 'Introdueix a la casella el nom del fitxer .MAT a
carregar'); end end
4.6.8. Parámetros de casilla de diálogo y cerrar aplicación
4.6.8.1. Casilla de diálogo Este elemento es del tipo text y tiene le corresponde el tag del tipo text_dialeg.
4.6.8.2. Salvar Existen dos elementos que son del tipo pushbutton y tienen el formato boto_tanca y boto_s_i_g. function boto_tanca_Callback(hObject, eventdata, handles) if isempty(find_system('Name','rtw')) else close_system('rtw');end if isempty(find_system('Name','rtwol')) else close_system('rtwol');end close
function boto_s_i_g_Callback(hObject, eventdata, handles) close_system('rtw',1); close_system('rtwol',1); close
Memoria Técnica
94
5. Conclusiones Se puede decir que se han cumplido satisfactoriamente los propósitos planteados inicialmente, aunque han quedado temas por desarrollar y se han detectado limitaciones del sistema RTWT de Matlab, que en futuro podrán ser solventadas. Pero lo que es más importante, es que se ha conseguido sentar las bases para trabajos futuros en un entorno muy desconocido como es el trabajo con sistemas reales y en tiempo real mediante Matlab. Se ha utilizado con éxito y ha quedado documentada la información referente a las herramientas:
GUIDE Toolbox de Real-Time con Simulink Controlador discreto para un motor de corriente continua, y que podrá ser
utilizado para el control de velocidad de cualquier otro motor con algunas adaptaciones.
Driver de corriente continua desarrollado íntegramente en el laboratorio de la URV.
El modulo de control de Leybold. Todo ello se ha relacionado con la teoría de control para la obtención de un sistema realimentado para la regulación de la velocidad de un motor de corriente continua. A través de la aplicación ideada se podrá diseñar cualquier tipo de controlador soportado por Simulink (fuzzy, discreto o continuo), para posteriormente visualizar las gráficas reales y corroborarlas con las teóricas. También se ha abierto un canal de comunicación con el servicio técnico de Matlab, a través de e-mail. De esta manera se podrá solventar cuestiones y sugerir mejoras futuras como ya se ha hecho. Se han detectado deficiencias y para enmendarlas se proponen posibles trabajos futuros:
Poner un PC con mayores características: RAM, procesador y disco duro. Se conseguirá reducir el tiempo de compilación, mayor rapidez de respuesta de la aplicación en tiempo real, mayor frecuencia de muestreo y tamaño de modelos en Simulink.
Prescindir del modulo de control de LEYBOLD, tomando las señales directamente de la carga y llevándolas al driver de cc y la placa de adquisición.
Añadir un filtro en el modelo de Simulink para eliminar el ruido provocado por la conmutación de los IGBTs del puente en H.
Estar pendiente de las nuevas actualizaciones de Matlab para la resolución del problema de la imposibilidad para capturar datos y/o realizar operaciones con las variables hasta que no haya acabado la ejecución en tiempo real de la aplicación.
Memoria Técnica
95
6. Bibliografía [1] Pol Toldrà Fernández, Implementació d’un driver commutat a alta freqüència per un accionament regulat amb motor DC, PFC URV,2004. [2] Rafael Moragues, Sistema de control en temps real a través de MATLAB/SIMULINK, PFC URV, 2004. [3] David Oliveras, Desenvolupament d'una Plataforma Hardware/Software per a l'Experimentació d'Accionaments DC, PFC URV, 2005. [4] Pedro Garcés, Apuntes de la asignatura de Ingeniería de Control II, URV 2004. [5] Sistemas de control en tiempo discreto, Katsuhiko Ogata, Ed. Pentice Hall, 2 edición. [6] Ayudas de Matlab dentro de Programa. [7] http://www.mathworks.com [8] The MathWorks, Real-Time Windows Target User’s Guide (Version 2).
Anexos
96
7. Anexos En el siguiente capítulo se dará aquella información que es interesante pero que no es imprescindible para entender el funcionamiento de la aplicación en tiempo real, y que de alguna manera no ha tenido cabida en la memoria técnica.
7.1. Compatibilidad de bloques de Simulink y RTWT En la Tabla 17 se muestran los bloques de Simulink separados por categorías y unas notas explicativas. Estos bloques son compatibles con la toolbox de tiempo real de Matlab, ya que RTWT no puede trabajar con todos los bloques de Simulink. Sublibrary Block Support Notes
Additional Math and Fixed-Point State-Space SN1
Discrete: Additional Discrete
Transfer Fen Direct Form II
SN1, SN2
Transfer Fen Direct Form II Time SN1. SN2
Varying
Unit Delay Enabled
SN1. SN2
Unit Delay Enabled External IC
SN1, SN2
Unit Delay Enabled Resettable
SN1. SN2
Unit Delay Enabled Resettable SN1. SN2
External IC
Unit Delay External IC
SN1, SN2
Unit Delay Resettable
SN1. SN2
Unit Delay Resettable External IC
SN1, SN2
Unit Delay With Preview Enabled
SN1, SN2
Additional Math and Unit Delay With Preview Enabled SN1. SN2
Discrete: Additional Resettable
Discrete
Unit Delay With Preview Enabled SN1. SN2
Resettable External RV
Unit Delay With Preview Resettable
SN1. SN2
Unit Delay With Preview Resettable SN1. SN2
External RV
Additional Math and Decrement Real World SN1
Anexos
97
Discrete: Increment/Decrement
Decrement Stored Integer
SN1
Decrement Time To Zero
—
Decrement To Zero
SN1
Increment Real World
SN1
Increment Stored Integer
SN1
Continuous Derivative SN3. SN4
Integrator SN3. SN4
State-Space
SN3. SN4
Transfer Fen
SN3. SN4
Transport Delay
SN3. SN4
Variable Time Delay
SN3. SN4
Variable Transport Delay
SN3. SN4
Zero-Pole SN3. SN4
Discontinuities Backlash SN2
Coulomb & Viscous Friction
SN1
Dead Zone —
Dead Zone Dynamic
SN1
Hit Crossing
SN4
Quantizer —
Rate Li miter
SN5
Rate Limiter Dynamic
SN1. SN5
Relay —
Saturation —
Saturation Dynamic
SN1
Wrap To Zero
SN1
Discrete Difference SN1
Discrete Derivative
SN2. SN6
Discrete Filter
SN2
Discrete State-Space
SN2
Anexos
98
Discrete Transfer Fen
SN2
Discrete Zero-Pole
SN2
Discrete-Time Integrator
SN2. SN6
First-Order Hold
SN4
Integer Delay
SN2
Memory —
Transfer Fen First Order
SN1
Transfer Fen Lead or Lag
SN1
Transfer Fen Real Zero
SN1
Unit Delay SN2
Weighted Moving Average
—
Zero-Order Hold
—
Logic and Bit Operations
Bit Clear —
Bit Set —
Bitwise Operator
—
Combinatorial Logic
—
Compare to Constant
—
Compare to Zero
—
Detect Change
SN2
Detect Decrease
SN2
Detect Fall Neaative
SN2
Detect Fall Nonpositive
SN2
Detect Increase
SN2
Detect Rise Nonnegative
SN2
Detect Rise Positive
SN2
Extract Bits —
Interval Test —
Interval Test Dynamic
—
Loaical Operator —
Anexos
99
Relational Operator
—
Shift Arithmetic
—
Lookup Tables Cosine SN1
Direct Lookup Table (n-D)
SN2
Interpolation (n-D)
—
Lookup Table
—
Lookup Table (2-D)
—
Lookup Table (n-D)
—
Lookup Table Dynamic
—
PreLookup Index Search
—
Sine SN1
Math Operations Abs —
Algebraic Constraint
Not supported
Assignment SN2
Bias —
Complex to Magnitude-Angle
—
Complex to Real-lmag
—
Concatenate SN2
Dot Product —
Gain —
Maanitude-Anale to Complex
—
Math Function (10Au) —
Math Function (conj) —
Math Function (exp) —
Math Function (hermitian) —
Math Function (hypot) —
Math Function (log) —
Math Function (Iog10) —
Math Function (maanitudeA2) —
Math Function (mod) —
Math Function (pow) —
Math Function (reciprocal) —
Math Function (rem) —
Math Function (square) —
Math Function (sqrt) —
Math Function (transpose) —
MinMax —
Anexos
100
MinMax Running Resettable
—
Polynomial —
Product SN2
Real-lmaa to Complex
—
Reshape —
Rounding Function
—
Sign —
Sine Wave Function
—
Slider Gain —
Sum —
Trigometric Function
SN7
Unary Minus —
Weighted Sample Time Math
—
Model Verification Assertion —
Check Discrete Gradient
—
Check Dynamic Gap
—
Check Dynamic Lower Bound
—
Check Dynamic Range
—
Check Dynamic Upper Bound
—
Check Input Resolution
—
Check Static Gap
—
Check Static Lower Bound
—
Check Static Range
—
Check Static Upper Bound
—
Atomic Subsystem Ports & Subsystems
—
Code Reuse Subsystem
—
Configurable Subsystem
—
Enabled Subsystem
—
Enabled and Triaaered Subsystem
—
For Iterator Subsystem —
Anexos
101
Function-Call Generator
—
Function-Call Subsystem
—
If —
If Action Subsystem
—
Model —
Subsystem —
Switch Case —
Switch Case Action Subsystem
—
Triggered Subsystem
—
While Iterator Subsystem
—
Data Type Conversion Signal Attributes
—
Data Type Conversion Inherited
—
Data Type Duplicate
—
Data Type Propogation
—
Data Type Scaling Strip
—
JC SN4
Probe —
Rate Transition
SN2. SN5
Sianal Conversion
—
Signal Specification
—
Weighted Sample Time
—
Width —
Bus Assianment Signal Routing
—
Bus Creator —
Bus Selector —
Data Store Memory
—
Data Store Read
—
Data Store Write
—
Demux —
Environment Controller —
Anexos
102
From —
Goto —
Goto Tag Visibility
—
Index Vector —
Manual Switch
SN4
Merge —
Multiport Switch
SN2
Mux —
Selector —
Switch SN2
Sinks Display SN8
Floating Scope SN8
Output (Out1) —
SN8 Scope
Stop Simulation Not supported
Terminator
—
To File SN4
To Workspace SN8
XY Graph
SN8
Band-Limited White Noise SN5 Sources
Chirp Signal
SN4
Clock SN4
Constant
—
Counter Free-Running SN4
Counter Limited SN1
Diaital Clock SN4
From File
SN8
From Workspace SN8
Ground —
Inport(lni) —
Pulse Generator SN5. SN9
Ramp SN4
Anexos
103
Random Number
—
Repeating Sequence SN10
Repeating Sequence Interpolated
SN1. SN5
Repeating Sequence Stair SN1
Signal Builder
SN4
Sianal Generator SN4
Sine Wave SN6. SN9
Step SN4
Uniform Random Number
—
Embedded MATLAB Function User-Defined
—
Fen —
MATLAB Fen
SN11
S-Function SN12
S-Function Builder
—
Tabla 17: Listado de bloques de Simulink y sus compatibilidades
Symbol Note
— Real-Time Workshop supports the block and requires no special notes.
SN1 Real-Time Workshop does not explicitly group primitive blocks that constitute a nonatomic masked subsystem block in the generated code. This flexibility allows for more optimal code generation. In certain cases, you can achieve grouping by configuring the masked subsystem block to execute as an atomic unit by selecting the Treat as atomic unit option.
SN2 Generated code relies on memepy or memset (string, h) under certain conditions.
SN3 Consider using the Simulink Model Discretizer to map continuous blocks into discrete equivalents that support code generation. To start the Model Discretizer, click Tools > Control Design.
SN4 Not recommended for production code.
SN5 Cannot use inside a triggered subsystem hierarchy.
SN6 Depends on absolute time when used inside a triggered subsystem hierarchy.
SN7 The three functions — asinh, acosh, and atanh—are not supported by all compilers. If you use a compiler that does not support these functions, Real-Time Workshop issues a warning message for the block and the generated code fails to link.
SN8 Ignored for code generation.
SN9 Does not refer to absolute time when configured for sample-based operation. Depends on absolute time when in time-based operation.
Anexos
104
SN10 Consider using the Repeating Sequence Stair or Repeating Sequence Interpolated block instead.
SN11 Consider using the Embedded MATLAB block instead.
SN12 S-functions that call into MATLAB are not supported for code generation.
Tabla 18: Notas referentes a la Tabla 17
7.2. Preguntas realizadas al servicio técnico de Matlab Este apartado ha sido concebido para solucionar posibles dudas que hayan podido surgir a lo largo de la lectura de la memoria técnica, y con la intención de dar continuidad al trabajo realizado en el presente proyecto. Esto dará la posibilidad a la persona que prosiga en esta misma línea de investigación o en otra similar las limitaciones de las toolboxes de Real-Time para esta versión de Matlab, y posibles mejoras que se van implementar en un futuro como nos aseguran en una de estas cartas. A continuación se mostrarán algunos de los e-mails de Matlab. From: [email protected]
Sent: 5/4/2005 1:31:21 PM
Subject: Matlab trabajando en tiempo real
Estimados Srs. De MathWorks,
Estoy trabajando en la Universidad Rovira y Virgili de Tarragona en un
proyecto de control de un motor de CC mediante una placa de
adquisición en tiempo real (RTWT).
En la página de Mathworks he visto que la placa puede llegar a
trabajar de 10 a 40 kHz con Windows. He estado haciendo pruebas y he
visto que no puedo trabajar a frecuencias de muestreo tan altas. He
podido comprobar que con una frecuencia de muestreo de 10 kHz y
tomando como entrada una señal sinusoidal a 1 kHz, el sistema
operativo se vuelve inestable, cuando no se reinicia la computadora, y
solo captura unos 1000 puntos.
Nuestro hardware es el siguiente:
- PCI NI-6024e como placa de adquisición en Tiempo Real
- Computadora:
Intel Pentium 4 a 1,86 GHz
256 MB Ram
El software:
- Matlab 6.5 R13
- Windows 2000 (Service Pack)
- Ejecutando el comando “rtwho” da como respuesta:
o Real Time Windows Target v 2.2.
o MATLAB performance = 100%
o Kernel timeslice period = 1ms
Mis preguntas son:
- Con el hardware y software que tenemos se puede muestrear hasta los
40 kHz?
- Cual es la limitación de puntos guardando datos en Tiempo Real con
Anexos
105
“To Workspace” o “Scope”? – He observado que el máximo numero de
puntos es de 1000 puntos –
- Cual es la relación entre el tiempo de muestreo del “Simulation
Parameters” del Simulink y el tiempo de cada uno de los bloques.
Atentamente,
Augusto Cilento
Data: Dilluns, Juny 6, 2005 9:40 am
Assumpte: RE: Matlab trabajando en tiempo real
Hola Sr Cliento
- Con el hardware y software que tenemos se puede muestrear hasta los
40 kHz?
Esto no se sabe hasta que se prueba. Por favor mira la pagina
siguiente:
http://www.mathworks.com/support/solutions/data/1-
18N6Z.html?solution=1-18N6Z
- Cual es la limitación de puntos guardando datos en Tiempo Real con
“To Workspace” o “Scope”? – He observado que el máximo numero de
puntos es de 1000 puntos –
En el bloque Scope y To Workspace hay una casilla "Limit Data Points
To Last". Tiene el valor 1000?
- Cual es la relación entre el tiempo de muestreo del “Simulation
Parameters” del Simulink y el tiempo de cada uno de los bloques.
El tiempo de muestro del bloque es igual al valor del bloque
precendente si su casilla tiene un valor -1. Si todos los bloques
tienen un valor -1 es igual al tiempo de muestra fundamental (en
Configuration Parameters). He añadido un ejemplo.
Necesito conocer su número de licencia. Puede utilizar el comando
"ver" dentro de la ventana de comandos de MATLAB y devolvernos su
salida. Si tiene màs preguntas esciribemelas.
Un saludo cordial,
Tobias Gemperli
From: [email protected]
Sent: 2006-08-21 11:48:33 AM
Subject: RE: RE: RE: RE: Respondre el missatge:
RE:Matlabtrabajandoentiemporeal
Hello Tobias,
Can you explain me, how can I display a block scope into a GUI and see
that in real-time by means of "external mode" ? Can I export this data
to grafical user interface axes? I need work in signal tracing mode
(acquiring and visualizing signals while running a target
application).
Anexos
106
Can you help me?
Best regards,
August Cilento
----- Missatge original -----
Data: Dilluns, Agost 21, 2006 9:40
Assumpte: RE: RE: RE: RE: Respondre el missatge: RE:
Matlabtrabajandoentiemporeal
Per a: [email protected]
> Hello August
>
> I tried to call you on the number +34 977 55 96 59. The person
> who took off the phone said that he doesn't know you. Do you
> have another phone number?
>
> Thank you
> Tobias
Data: Dimarts, Agost 22, 2006 16:28
Assumpte: RE: RE:Matlabtrabajandoentiemporeal
Per a: [email protected]
> Hello August
>
> I'm still investigating if the data can be displayed in a GUI. I
> will tell you when I have further information about it.
>
> You wrote:
>
https://estudiants.urv.cat/popup.html?nopop
2 de 4 14/09/2006 16:40
>
> 2. Granted that the size of buffer of data is very
> small, would be possible to do more than a simulation and chain
> all the values obtained within a same variable, thus to obtain
> more points for a representation?
>
> Unfortunately this is not possible. Please check if the
> following hints help:
>
>
> Solution Id: 1-1J9KLJ
>
> Summary: Why do I receive an error stating that the external
> mode packet buffer is too small in Real-Time Windows Target
> 2.5.2 (R14SP2)?
>
> Solution:
> There is a bug in Real-Time Windows Target 2.5.2 (R14SP2) in
> the way that Real-Time Windows Target interacts with external
> mode. This bug is under investigation and no fully tested
> workarounds exist. However, the following are three techniques
> that may resolve the problem. This is a machine-dependent issue,
> and the techniques cannot be guaranteed to work on all machines.
>
Anexos
107
> 1) Minimize the number of external mode communication channels,
> such as scopes and displays. Users often attach scopes and
> displays to signals "just in case". While this approach is
> acceptable for simulation, it wastes packet buffer space, which
> is one of the most critical resources when running in external mode.
>
> 2) Reduce the amount of data transmitted through external mode
> channels. In the External Mode Control Panel, set the Duration
> (which must be a positive integer) as low as possible. The
> shorter duration reduces the number of samples in one buffer.
>
> 3) If the computer supports hyperthreading, disable
> hyperthreading in the BIOS setup. Hyperthreading helps few
> applications. For real-time applications it does not help at
> all, and can cause additional problems. You should have your
> System Administrator do this for your machine.
>
>
> 3. Which is approximately the number of points
> maximum/frequency of sampling for a simulation? But as it could
> obtain the relation?
>
> Do you mean the number of points that can be saved?
>
> Un saludo,
> Tobias Gemperli
From: [email protected]
Sent: 2006-08-24 04:50:16 AM
Subject: RE: RE:Matlabtrabajandoentiemporeal
Hello Tobias,
You clarified me some doubts about buffer size, I will prove it.
3. Which is approximately the maximum number of points/frequency of
sampling for asimulation? But as it could obtain the relation?
Do you mean the number of points that can be saved?
Yes, I mean the maximum I number of points by unit of time (at minimum
increase of time or maximum frequency).
Thank you
Data: Dimarts, Desembre 04, 2006 16:28
Assumpte: RE: RE:Matlabtrabajandoentiemporeal
Per a: [email protected]
Dear August
I'm sorry about the delay in my reply. Unfortunately there is no
formula to calculate the maximum buffer size. I have made tests on
several
computers. I found out that the "out of memory" error occurs between
20'000'000 and 40'000'000 time steps. Unfortunately it is not yet
possible to
prealocate the memory which will be used by the scopes. I have
forwarded such a request to development to be considered in a future
release of
matlab.
Do you need to log every sample or can you just log every tenth? If
the second applies please specify the field "Sampling" in the scope
block:
Scope, Floating Scope, Signal Viewer Scope :: Blocks (Simulink)
Anexos
108
http://www.mathworks.com/access/helpdesk/help/toolbox/simulink/slref/s
cope.shtml
Regards Tobias
