Sistemas de control de motores en Tiempo Real mediante Matlab

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
1.
2.
3.
Introducción................................................................................................................... 6
Objetivos........................................................................................................................ 6
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
i
Índice
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
ii
Índice
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
iii
Memoria Técnica
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.
6
Memoria Técnica
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.
7
Memoria Técnica
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.
8
Memoria Técnica
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.
9
Memoria Técnica
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.
10
Memoria Técnica
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.
11
Memoria Técnica
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
12
Memoria Técnica
Alimentación
Rampa
Sentido de giro
Errores
Entradas/Salidas
Velocidad
Driver Motor CC
MOTOR
Realimentación
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.
13
Memoria Técnica
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
14
Memoria Técnica
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.
15
Memoria Técnica
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.
16
Memoria Técnica
Ilustración 4: Patillaje del conector de la placa de adquisición de datos
17
Memoria Técnica
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 Ω
1A fused
—
—
—
DIO<0..7>
DIO
—
Short-circuit to
ground
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
18
Memoria Técnica
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.
19
Memoria Técnica
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)
0,5
1
10
100
Voltaje máximo de trabajo de ±11 V
Potección contra sobretensiones
Signal
ACH<0..15>
AISENSE
Range
±10 V
±5 V
±500 mV
±50 mV
Powered
On
±42
±40
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
20
Powered
Off
±35
±25
Memoria Técnica
Entradas/Salidas Digitales
DIO<0..7>
Digital logic levels
Level
Input low voltage
Input high voltage
Input low current (Vin= 0 V)
Input high current (Vin= 5 V)
Output low voltage (IOL= 24 mA)
Output high voltage (IOH= 13 mA)
Min
0V
2V
—
—
—
4.35 V
Max
0.8 V
5V
–320 µA
10 µA
0.4 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.
21
Memoria Técnica
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.
22
Memoria Técnica
Cuadrante Velocidad
1º
+
2º
+
3º
4º
-
Par
+
+
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
Vmed = ∫
0
(1)
f (t )
⋅ dt
T
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.
Vmed =
(2)
VH × TH VL × TL
+
T
T
El ancho de la parte positiva respecto el periodo T se conoce como ciclo de trabajo:
23
Memoria Técnica
D=
(3)
Ton
T
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
24
Memoria Técnica
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.
25
Memoria Técnica
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.
26
Memoria Técnica
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:
Ea = K ⋅ φ ⋅ w
(4)
Ti = K ⋅ φ ⋅ Ia
(5)
Va = Ia ⋅ Ra + Vb + Ea
(6)
Al trabajar con rpm substituimos w por 0.1047·n, quedando la expresión de Ea:
(7)
Ea = K ⋅ φ ⋅ 0.1047 ⋅ n
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 ):
K ⋅φ =
(8)
Va − Vb − Ia ⋅ Ra
0.1047 ⋅ n
Vb se desprecia al ser poco significativa, con lo que la ecuación final queda:
K ⋅φ =
(9)
Va − Ia ⋅ Ra
0.1047 ⋅ n
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
Intensidad nominal
Potencia nominal
220 V Tensión excitación
1,8 A
Intensidad nominal de excitación
0,3 kW Velocidad nominal
Tabla 7: Valores placa de características
27
220 V
0,25 A
2000 rpm
Memoria Técnica
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
ERR 1
ERR 2
ERR 3
ERR 4
ERR 5
ERR 6
Descripción
Generator operation
Temperature of the DUT
Overvoltage in the link circuit of the control unit
Temperature of the D & B Unit
Temperature of the control unit
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.
28
Memoria Técnica
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.
29
Memoria Técnica
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
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.
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.
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).
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.
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.
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
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).
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
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
11 L1OUT, L2OUT, L3OUT
Output sockets for connection of different
DUT-machines (DC, AC, 3~)
12 INTERN / EXTERN-switch
30
Memoria Técnica
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).
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).
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.
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).
16 Connection socket to supply the D & B Unit.
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).
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.
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).
18 Digital speed output (TACHOOUT)
The signals of the tacho-generator are automatically
forwarded.
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.
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 l s o b e
c a r r i e d o u t u s i n g t h e s o ft w a r e C B M 1 0 V 5 ,
cat. no. 728 421.
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.
31
Memoria Técnica
29 3-digit 7-segment display to indicate the torque
error codes. To acknowledge error see RESET (8)!
30 4-digit 7-segment display for the indication of the
speed, the condition of DUT ENABLE output and
32
Memoria Técnica
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
33
Memoria Técnica
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.
34
Memoria Técnica
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.
1
3
2
5
4
7
6
9
8
11
10
13
12
17
15
16
20
18
21
19
14
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.
35
Memoria Técnica
Item
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Tag
Select
Push Button
Slider
Radio Button
Check Box
Edit Box
Static Text
Pop-up menu
List Box
Toggle Button
Axes
Panel
Button Group
Activex
Control
Align objects
Menu Editor
Tab order
Editor
M-file Editor
Property
inspector
Object
Browser
Run
Detalles
Selección de un objeto
Botón
Barra de desplazamiento
Botón de selección circular
Botón de selección tipo lista
Casilla de edición
Casilla de texto fijo
Menú desplegable
Menú en lista
Botón con memoria
Pantalla para visualización de gráficos
Opción para generar un panel
Opción para agrupar botones
Opción para generar controles ActiveX
Opción para alinear objetos
Editor de opciones de menú
Opción para cambiar el orden de las ventanas en el
editor
Editor de los ficheros .m
Editor propiedades de los controles
Buscador de Objetos
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.
36
Memoria Técnica
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.
Panel
Pantalla
Ventana 1
(figure)
Ejes 1 (axes)
Ejes 2 (axes)
Líneas (lines)
Ventana 2
(figure)
Controles
(uicontrol)
Superfícies
(surfaces)
Menús
(uimenu)
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
37
Memoria Técnica
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).
38
Memoria Técnica
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.
DRIVER
VARIADOR DE TENSIÓN
220Vca
Vcc+
SH_OUT
0V
IDE20-E/S
SH_IN
Vcc_puente
GND_puente
M+
M-
F1
M+
M-
0V
MODULO
CONTROL
n (V)
9PIN 25 PIN
CON CON
SALIDAS
Varmadura
ENTRADAS
F2
Vexcitación
25 PIN 9PIN
CON CON
MOTOR+CARGA
PLACA DAQ
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.
39
Memoria Técnica
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.
1
2
3
4
5
1
2
3
Descripción de la señal
ENTRADAS
Medida Sensor Hall
Sobrecorriente Shall y
MC33153
Cruce Rama B
Cruce Rama A
Lectura Velocidad (modulo
ext.)
SALIDAS
Velocidad
Rampa
Sentido de giro
Pin
IDE
Placa# Pin DAQ#
Rango
Tensión
(V)
20 ACH0
±12
11 DIO3
12 DIO2
13 DIO1
0-5
0-5
0-5
- ACH1
±10
19 DAC0OUT
18 DAC1OUT
17 DIO0
Tabla 10: Resumen de conexiones entre driver y placa DAQ
La distribución de pines en el conector IDE de 20 pines del driver:
40
0-5
0-5
0-5
Memoria Técnica
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
IN/OUT de la placa al PC
OUT
OUT
OUT
OUT
N.C.
N.C.
N.C.
N.C.
N.C.
N.C.
OUT
OUT
OUT
IN
OUT
IN
IN
IN
IN
OUT
Descripción
-12 V
+12 V
GND
+5 V
Sobrecorriente (Shall i MC33153)
Cruce rama B
Cruce rama A
Entrada al pic (libre)
Salida del pic (libre)
reset/rearme por soft (no implement.)
Sentido de giro: 0 izq., 1 derecha
Señal analógico rampa
Señal analógico velocidad
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.
41
Memoria Técnica
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:
42
Memoria Técnica
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 MEXfiles 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
******************************************************
43
Memoria Técnica
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
44
Memoria Técnica
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:
Parameters
Name
Address
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
45
Memoria Técnica
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)
46
Memoria Técnica
(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).
G( s) =
( 10 )
K
τ ⋅ s +1
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.
47
Memoria Técnica
( 11 )
y ss = lim s ⋅ Y ( s )
s →0
El valor de K es 6,376. Por tanto la expresión que define el sistema es la siguiente:
G( s) =
( 12 )
6,376
s + 5,762
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.
( 13 )
 -1 1 − e −Ts


G ( z ) = Z L 
⋅ G ( s)

  s
 t =nT 
Se sustituye la expresión ( 12 ) en la ( 13 ) y se obtiene:
( 14 )
 1 − e −Ts 6,376 

G ( z ) = Z L -1 
⋅


s + 5,762  t = nT 
  s
Descomponiendo en fracciones simples y haciendo la transformada Z se obtiene la
planta discretizada dependiente del tiempo de muestreo.
G ( z ) = 1,1066 ⋅
( 15 )
1 − e −5, 762T
z − e −5,762T
4.3.1.1. Frecuencia de muestreo
Para la elección de la frecuencia de muestreo habrá que recurrir al teorema de NyquistShanon. El teorema establece que la frecuencia mínima de muestreo necesaria para
evitar el aliasing debe ser:
( 16 )
f s > 2 BW
Siendo el ancho de banda:
48
Memoria Técnica
( 17 )
BW = f max − f min
Para nuestro sistema consideramos que f min = 0 , por tanto la expresión ( 16 ) quedará:
( 18 )
f s > 2 f max
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.
( 19 )
f s ≈ 10 f max
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 s → f =
1
τ
( 20 )
= 5,67 Hz
La frecuencia y periodo de muestreo imponiendo ( 19 ) es:
( 21 )
f s = 113,44 Hz → Ts ≤ 0,0088
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.
49
Memoria Técnica
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,06196
( 22 )
G( z ) =
0,01
z − 0,944
0,00636
( 23 )
G( z) =
0,001
z − 0,994
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
50
Memoria Técnica
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
+
E
H
+
ki·z/(z-1)
+
kd·(z-1)/z
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).
H ( z ) (kp + ki + kd ) ⋅ z 2 − (kp + 2 ⋅ kd ) ⋅ z + kd
=
E( z)
z2 − z
( 24 )
Acción proporcional e integral
( 25 )
H ( z ) (kp + ki) ⋅ z − kp
=
E ( z)
z −1
Acción proporcional
( 26 )
H ( z)
= kp
E( z)
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.
51
Memoria Técnica
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
R(z)
Controlador
Planta
Y(z)
+
kp
G(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.
( 27 )
Y ( z)
kp ⋅ G ( z )
=
R ( z ) 1 + kp ⋅ G ( z )
La expresión del error:
E( z) =
( 28 )
R( z )
1 + kp ⋅ G ( z )
Haciendo el desarrollo de la expresión ( 27 ) y sustituyendo el valor del tiempo de
muestreo, se aplica el Teorema del Valor Final:
( 29 )
( z − 1)
⋅ Y ( z)
z →1
z
yss = lim
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 ).
52
Memoria Técnica
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.
-4
Root Locus
Root Locus
x 10
1
6
0.8
0.6
4
0.4
Imaginary Axis
Imaginary Axis
2
0.2
0
-0.2
0
-2
-0.4
-0.6
-4
-0.8
-6
-1
-1
-0.5
0
0.5
0.9936
1
0.9938
0.994
0.9942
0.9944
0.9946
0.9948
0.995
Real Axis
Real Axis
Ilustración 29: Lugar de las raíces del sistema
Lo que interesa es estudiar la respuesta obtenida con la simulación.
12
5
Step Response
Step Response
x 10
1
0.9
0
0.8
0.7
-5
Amplitude
Amplitude
0.6
-10
0.5
0.4
0.3
-15
0.2
0.1
-20
0
2
4
6
8
10
12
14
16
18
20
Time (sec)
0
0
2
4
6
8
10
12
14
16
18
Time (sec)
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
53
20
Memoria Técnica
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.
( 30 )
P ( z ) = a0 z n + a1 z n −1 + ... + a n −1 z + a 0
Las condiciones del test de Jury para un sistema de primer orden:
( 31 )
P (1) > 0
(−1) n ·P (−1) > 0
El margen de valores posibles en que el sistema se comportorá de manera estable:
31,35 > kp > −0,888
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.
4
1.5
Step Response
Step Response
x 10
2
1.8
1
1.6
1.4
0.5
Amplitude
Amplitude
1.2
0
1
0.8
-0.5
0.6
0.4
-1
0.2
0
-1.5
0
50
100
150
200
250
0
50
100
150
200
250
Time (sec)
Time (sec)
(a) kp = 32
(b) kp = 31
Step Response
Step Response
1
0.7
0.9
0.6
0.8
0.7
0.5
Amplitude
Amplitude
0.6
0.5
0.4
0.4
0.3
0.3
0.2
0.2
0.1
0.1
0
0
2
4
6
8
10
12
14
16
18
20
Time (sec)
0
0
5
10
15
20
25
30
Time (sec)
(c) kp=15
(d) kp = 1
Ilustración 31: Respuestas simuladas con los valores obtenidos en el test de Jury
54
35
40
45
Memoria Técnica
Los margenes de estabilidad de la constante proporcional obtenidos con el test de Jury
para el tiempo de muestreo a 0,001 segundos es:
313,52 > kp > −0,943
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.
Linear Simulation Results
3.5
3
Amplitude
2.5
2
1.5
1
0.5
0
0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1
Time (sec)
(a) Representación tensión de salida en (b) Representación tensión de salida en función del
función del número de muestras. Respuesta tiempo. Respuesta simulación controlador a
real controlador a Ts=0,001s kp=93,4
Ts=0,001s con kp=93,4
6.376
93.4
s+5.762
Step
Gain
Saturation
Transfer Fcn
Zero-Order
Hold
Scope
(c) Representación tensión de salida en (d) Modelo con controlador proporcional y
función del número de muestras. Error real saturación a Ts=0,001s
Controlador a Ts=0,001s
Ilustración 32: Comparación entre controlador P real y simulado
55
Memoria Técnica
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.
Error simulado con saturación
300
2.5
250
2
200
Amplitud (V)
Amplitud (V)
Respuesta simulada con saturación
3
1.5
150
1
100
0.5
50
0
0
0.1
0.2
0.3
0.4
0.5
0.6
Tiempo (s)
0.7
0.8
0.9
0
1
0
0.1
0.2
0.3
0.4
0.5
0.6
Tiempo (s)
0.7
0.8
0.9
(a) Representación tensión de salida en (b) Representación tensión de salida en
función del tiempo. Respuesta simulación función del tiempo. Error real a
controlador a Ts=0,001s con kp=93,4
Ts=0,001s con kp=93,4
Ilustración 33: Respuestas obtenidas teniendo en cuenta la saturación
56
1
Memoria Técnica
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.
R(z)
+
-
Controlador PI
Planta
( kp + ki ) ⋅ z − kp
z −1
G(z)
Y(z)
Ilustración 34: Diagrama de bloques del controlador PI con la planta del sistema
La expresión del controlador PI:
( 32 )
Y ( z)
z
= kp + ki ⋅
R( z )
z −1
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.
Root Locus
x 10
1
0.8
3
0.6
2
Root Locus
1
0.2
Imaginary Axis
Imaginary Axis
0.4
-3
0
-0.2
0
-1
-2
-0.4
-0.6
-3
-0.8
-4
-1
-1
-0.8
-0.6
-0.4
-0.2
0
0.2
0.4
0.6
0.8
1
0.992
Real Axis
0.994
0.996
0.998
Real Axis
Ilustración 35: Lugar geométrico de las raíces de la planta y el controlador
57
1
1.002
Memoria Técnica
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.
Linear Simulation Results
3
2.5
Amplitude
2
1.5
1
0.5
0
0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1
Time (sec)
(a) Representación tensión de salida en función (b) Representación tensión de salida en función
del número de muestras. Respuesta real del tiempo. Respuesta simulación controlador a
controlador a Ts=0,001s
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.
58
Memoria Técnica
Tiempo de muestreo (s) Función de Transferencia Discreta (Z)
z − 0,996
( 33 )
D( z ) =
0,01
z −1
z − 0,98
( 34 )
D( z ) =
0,001
z −1
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.
∆t representado Npt max.
Duración
Ts (s)
fs (kHz) (s)
representados (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
59
Memoria Técnica
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:
Npt =
( 35 )
pt
⋅ ∆t
Ts
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.
SR =
( 36 )
Npt
[ puntos ]
=
t
[segundos ]
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.
∆t max =
( 37 )
Ts ⋅ Npt
= Ts 2 ⋅ SR
pt
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.
60
Memoria Técnica
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
61
Memoria Técnica
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
62
Memoria Técnica
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.
63
Memoria Técnica
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.
64
Memoria Técnica
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
65
Memoria Técnica
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
66
Memoria Técnica
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.
67
Memoria Técnica
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 (ANDOR-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
68
Memoria Técnica
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
69
Memoria Técnica
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.
70
Memoria Técnica
Inicio de Programa:
RTWT_OpeningFcn
No
Lazo
Cerrado? Sin
Control
Lazo
Cerrado?
Control Z
No
Si
No
Lazo
Abierto?
Si
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 parametros
modelo a las editboxes de la
aplicación
- Invisibilidad de los comandos:
inversión de giro y parametros
del controlador.
- Limitación puntos simulación
- Inicialización de variables
generales
- Captura de la ruta de trabajo
- Transferencia de parametros
modelo a las editboxes de la
aplicación
- Visibilidad de los comandos:
inversión de giro y parametros
del controlador.
- Limitación puntos simulación
- Inicialización de variables
generales
- Captura de la ruta de trabajo
- Transferencia de parametros
modelo a las editboxes de la
aplicación
- Invisibilidad de los comandos:
inversión de giro y parametros
del controlador.
- Limitación puntos simulación
- Inicialización de variables
generales
Transferencia de los valores de las editboxes a el modelo en funcionamiento
Si
Evento?
No
Ejecución de la acción demandada y actualización de las variables
Cerrar?
Si
Fin Programa
Si
Ilustración 52: Diagrama de flujo general de la GUI
71
Cerrar
Salvando?
Memoria Técnica
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
72
Memoria Técnica
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
% en el modelo y ponerlos en la GUI, en el caso que sea la
% se haya abierto el programa.
% % % % % % % % % % % % INICIO PARAM.GENERALES % % % % % %
% %
% Se capturan los valores de los parametros generales, son
no
% dependen del modelo escogido
que tiene
primera vez
% % % % % % %
aquellos que
% 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
73
Memoria Técnica
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
74
Memoria Técnica
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
75
Memoria Técnica
% 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);
76
Memoria Técnica
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);
77
Memoria Técnica
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'));
78
Memoria Técnica
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.
79
Memoria Técnica
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.
80
Memoria Técnica
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...');
81
Memoria Técnica
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);
82
Memoria Técnica
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);
83
Memoria Técnica
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);
84
Memoria Técnica
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
85
Memoria Técnica
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
86
Memoria Técnica
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
87
Memoria Técnica
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
88
Memoria Técnica
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)');
89
Memoria Técnica
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.
90
Memoria Técnica
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
91
Memoria Técnica
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
92
Memoria Técnica
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
93
Memoria Técnica
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.
94
Memoria Técnica
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).
95
Anexos
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
Additional Math and
Discrete: Additional
Discrete
Additional Math and
Discrete: Additional
Discrete
Additional Math and
Block
Fixed-Point State-Space
Support Notes
SN1
Transfer Fen Direct Form II
SN1, SN2
Transfer Fen Direct Form II Time
Varying
Unit Delay Enabled
SN1. SN2
Unit Delay Enabled External IC
SN1, SN2
Unit Delay Enabled Resettable
SN1. SN2
Unit Delay Enabled Resettable
External IC
SN1. SN2
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
Unit Delay With Preview Enabled
Resettable
SN1. SN2
Unit Delay With Preview Enabled
Resettable External RV
SN1. SN2
Unit Delay With Preview Resettable
SN1. SN2
Unit Delay With Preview Resettable
External RV
SN1. SN2
Decrement Real World
SN1
96
SN1. SN2
Anexos
Discrete:
Increment/Decrement
Continuous
Discontinuities
Discrete
Decrement Stored Integer
SN1
Decrement Time To Zero
—
Decrement To Zero
SN1
Increment Real World
SN1
Increment Stored Integer
SN1
Derivative
Integrator
State-Space
SN3. SN4
SN3. SN4
SN3. SN4
Transfer Fen
SN3. SN4
Transport Delay
SN3. SN4
Variable Time Delay
SN3. SN4
Variable Transport Delay
SN3. SN4
Zero-Pole
Backlash
Coulomb & Viscous Friction
SN3. SN4
SN2
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
Difference
Discrete Derivative
SN1
SN2. SN6
Discrete Filter
SN2
Discrete State-Space
SN2
97
Anexos
Logic and Bit
Operations
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
Weighted Moving Average
SN2
—
Zero-Order Hold
—
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
—
98
Anexos
Lookup Tables
Math Operations
Relational Operator
—
Shift Arithmetic
—
Cosine
Direct Lookup Table (n-D)
SN1
SN2
Interpolation (n-D)
—
Lookup Table
—
Lookup Table (2-D)
—
Lookup Table (n-D)
—
Lookup Table Dynamic
—
PreLookup Index Search
—
Sine
Abs
Algebraic Constraint
SN1
—
Not supported
Assignment
Bias
Complex to Magnitude-Angle
SN2
—
—
Complex to Real-lmag
—
Concatenate
Dot Product
Gain
Maanitude-Anale to Complex
SN2
—
—
—
A
Math Function (10 u)
Math Function (conj)
Math Function (exp)
Math Function (hermitian)
Math Function (hypot)
Math Function (log)
Math Function (Iog10)
A
Math Function (maanitude 2)
Math Function (mod)
Math Function (pow)
Math Function (reciprocal)
Math Function (rem)
Math Function (square)
Math Function (sqrt)
Math Function (transpose)
MinMax
99
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
Anexos
Model Verification
Ports & Subsystems
MinMax Running Resettable
—
Polynomial
Product
Real-lmaa to Complex
—
SN2
—
Reshape
Rounding Function
—
—
Sign
Sine Wave Function
—
—
Slider Gain
Sum
Trigometric Function
—
—
SN7
Unary Minus
Weighted Sample Time Math
—
—
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
—
Code Reuse Subsystem
—
Configurable Subsystem
—
Enabled Subsystem
—
Enabled and Triaaered Subsystem
—
For Iterator Subsystem
—
100
Anexos
Signal Attributes
Signal Routing
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
—
Data Type Conversion Inherited
—
Data Type Duplicate
—
Data Type Propogation
—
Data Type Scaling Strip
—
JC
Probe
Rate Transition
SN4
—
SN2. SN5
Sianal Conversion
—
Signal Specification
—
Weighted Sample Time
—
Width
Bus Assianment
—
—
Bus Creator
Bus Selector
Data Store Memory
—
—
—
Data Store Read
—
Data Store Write
—
Demux
Environment Controller
—
—
101
Anexos
Sinks
Sources
From
Goto
Goto Tag Visibility
—
—
—
Index Vector
Manual Switch
—
SN4
Merge
Multiport Switch
—
SN2
Mux
Selector
—
—
Switch
Display
Floating Scope
SN2
SN8
SN8
Output (Out1)
Scope
—
SN8
Stop Simulation
Terminator
Not supported
—
To File
SN4
To Workspace
SN8
XY Graph
SN8
Band-Limited White Noise
SN5
Chirp Signal
SN4
Clock
SN4
Constant
—
Counter Free-Running
Counter Limited
SN4
SN1
Diaital Clock
SN4
From File
SN8
From Workspace
SN8
Ground
Inport(lni)
Pulse Generator
—
—
SN5. SN9
Ramp
SN4
102
Anexos
User-Defined
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
Uniform Random Number
SN4
—
Embedded MATLAB Function
—
Fen
MATLAB Fen
—
SN11
S-Function
S-Function Builder
SN12
—
Tabla 17: Listado de bloques de Simulink y sus compatibilidades
Symbol
—
SN1
SN2
SN3
SN4
SN5
SN6
SN7
SN8
SN9
Note
Real-Time Workshop supports the block and requires no special notes.
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.
Generated code relies on memepy or memset (string, h) under certain
conditions.
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.
Not recommended for production code.
Cannot use inside a triggered subsystem hierarchy.
Depends on absolute time when used inside a triggered subsystem
hierarchy.
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.
Ignored for code generation.
Does not refer to absolute time when configured for sample-based
operation. Depends on absolute time when in time-based operation.
103
Anexos
SN10
SN11
SN12
Consider using the Repeating Sequence Stair or Repeating Sequence
Interpolated block instead.
Consider using the Embedded MATLAB block instead.
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: august.cilento@estudiants.urv.es
Sent: 5/4/2005 1:31:21 PM
To: soporte@mathworks.es
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
104
Anexos
“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
De: support@mathworks.de
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/118N6Z.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
precendente si su casilla tiene un valor
tienen un valor -1 es igual al tiempo de
Configuration Parameters). He añadido un
al valor del bloque
-1. Si todos los bloques
muestra fundamental (en
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: august.cilento@estudiants.urv.cat
Sent: 2006-08-21 11:48:33 AM
To: soporte@mathworks.es
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).
105
Anexos
Can you help me?
Best regards,
August Cilento
----- Missatge original ----De: soporte@mathworks.es
Data: Dilluns, Agost 21, 2006 9:40
Assumpte: RE: RE: RE: RE: Respondre el missatge: RE:
Matlabtrabajandoentiemporeal
Per a: august.cilento@estudiants.urv.cat
>
>
>
>
>
>
>
>
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
De: soporte@mathworks.es
Data: Dimarts, Agost 22, 2006 16:28
Assumpte: RE: RE:Matlabtrabajandoentiemporeal
Per a: august.cilento@estudiants.urv.cat
> 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.
>
106
Anexos
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
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: august.cilento@estudiants.urv.cat
Sent: 2006-08-24 04:50:16 AM
To: soporte@mathworks.es
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
De: soporte@mathworks.es
Data: Dimarts, Desembre 04, 2006 16:28
Assumpte: RE: RE:Matlabtrabajandoentiemporeal
Per a: august.cilento@estudiants.urv.cat
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)
107
Anexos
http://www.mathworks.com/access/helpdesk/help/toolbox/simulink/slref/s
cope.shtml
Regards Tobias
108