Taller Práctico: Diseño y Simulación de Control con NI myDAQ Derechos de Autor © 2011 National Instruments Corporation. Todos los derechos reservados. Bajo las leyes de autor, esta publicación no deberá ser reproducida o transmitida en ninguna forma, electrónica o mecánica, incluyendo fotocopia, grabación, almacenando en un sistema de recuperación de información o trasladar completo o en partes sin el consentimiento por escrito de National Instruments Corporation. National Instruments respeta la propiedad intelectual de otros y pedimos a nuestros usuarios hacer lo mismo. El software de NI está protegido por derechos de autor y otras leyes de propiedad intelectual. En donde el software de NI sea usado para reproducir software u otros materiales pertenecientes a otros, usted podrá usar el software sólo para reproducir materiales que usted posiblemente reproduzca de acuerdo a los términos de cualquier licencia aplicable u otra restricción legal. Marca Registrada National Instruments, NI, ni.com y LabVIEW son marcas registradas de National Instruments Corporation. Refiérase a los términos de uso en ni.com/legal para más información acerca de marcas registradas de National Instruments. Otros nombres de productos y compañías mencionados aquí son marcas registradas de sus respectivas compañías. Los Miembros de National Instrumets del Programa de Miembros de Alianza son entidades de negocio independientes de National Instruments y no tienen sociedad de la agencia o relación conjunta con National Instruments. Patentes Para patentes referentes a Productos/tecnología de National Instruments diríjase a la localidad apropiada Help»Patents en su software, el archivo patents.txt en su media de reproducción o en National Instruments Patent Notice en ni.com/patents. Derechos Reservados © 2011 National Instruments Corporation. Todos los derechos reservados.
Ejercicio 1. Identificación de Sistemas En este ejercicio aprenderemos a usar LabVIEW para poder obtener la definición matemática de nuestro sistema de demostración. Usaremos los bloques del System Identification Toolkit para hacer la identificación paramétrica de un motor de DC. La base de la identificación paramétrica de cualquier sistema es comparar las características de entrada (o excitación) de la planta con su característica de salida (o respuesta). Se cuenta con un sistema de demostración didáctico, construido con componentes simples y de bajo costo. Conectar este dispositivo a nuestra tarjeta NI MyDAQ, nos permitirá construir un controlador de velocidad para los motores de corriente directa. El sistema consta principalmente de un motor de corriente directa, y además, se incorporó un optointerruptor que nos ayudará a medir la velocidad de giro del motor. El dispositivo también tiene un sistema electrónico de potencia que alimenta a la planta y que conecta a todo el sistema con el conector de la NI MyDAQ. Este panel de conectores nos permite conectar el sistema con nuestra tarjeta. El sistema electrónico de potencia ya tiene conectadas las señales que nos interesan medir. La primera parte del ejercicio consta en generar una señal de excitación aleatoria para nuestra planta. Los sistemas de control se suelen modelar en el dominio de la frecuencia por lo que la teoría de identificación de sistemas recomienda usar señales binarias aleatorias. Esto es, poder verificar el comportamiento de la planta ante una cierta amplitud y con una frecuencia variable (barrido de frecuencias). Una vez generada la señal de excitación, la mandaremos por la salida analógica A0 de la tarjeta NI MyDAQ. Asegúrate de que los dos interruptores del dispositivo estén apuntando hacia el circuito 1 (C1) Posteriormente, realizaremos la adquisición de datos de esa señal de excitación y de la respuesta que detecta el motor. Una vez que adquirimos estas señales, pasaremos a usar los bloques Express del System Identification Toolkit de LabVIEW para hacer la identificación paramétrica. Finalmente, usando los bloques del Control Design Toolkit de LabVIEW crearemos la representación de estado y función de transferencia de nuestra planta. Nota: Este curso fue diseñado para mostrar cómo usar los Toolkits de LabVIEW en la creación de sistemas de control por lo que no ahondamos mucho en la utilización LabVIEW. A lo largo de la realización de los ejercicios de este seminario, algunas interfaces gráficas del panel frontal y ciertos códigos del diagrama de bloques ya están hechos para ti y sólo tendrás que completar el código como se te indicará en los ejercicios. Sigue estas instrucciones: 1. Abre LabVIEW si no se encuentra abierto dando clic en el ícono del programa o con la ruta de acceso del menú de inicio en Windows: Start > All Programs > National Intruments > LabVIEW 2011> LabVIEW.
2. Abre el archivo que se encuentra en el escritorio en la carpeta LabVIEW Control Design HandsOn\Exercises\Ejercicio1 – Identificación de Sistemas. 3. El panel frontal ya contiene la base de lo que será la interfaz gráfica de este programa y el diagrama de bloques contiene ya algunos controles así como un ciclo While, dos estructuras CASE y la creación de la tarea que se encargarán de transmitir las diferentes señales de control a la tarjeta DAQ y posteriormente al circuito del motor.
4. Ahora, conecta el control Stop a la terminal de la condición para el ciclo While. Para hacer esto, conecta primero este control a la terminal condicional de la estructura CASE interna (tanto para el caso verdadero como para el falso). Observa la ilustración:
Después, cámbiate a la pestaña FALSE de la estructura CASE exterior y conecta el control STOP a la terminal como se muestra a continuación:
5. Para generar nuestra señal aleatoria de excitación, dentro del ciclo while en la parte superior, coloca un ciclo For que encontrarás bajo Programming > Structures > For Loop. Asegúrate de que la estructura CASE interior quede localizada dentro de este nuevo ciclo FOR. Observa la figura.
En la terminal STOP, a un costado de la estructura FOR que acabas de colocar, deshabilita la opción de autoindexado como lo indica la siguiente imagen:
6. Da clic derecho en la terminal “N” del ciclo For para definir el número de iteraciones a realizar. Elige la opción Create Constant del submenu que aparece. Fija su valor en 1000.
7. Las iteraciones pares generarán un pulso en alto y las iteraciones impares generarán un pulso en bajo generando así la señal binaria que buscamos. Cerca de la terminal de iteración del ciclo For y dentro de la estructura CASE interior coloca un bloque Quotient & Remainder que encontraras bajo Programming > Numeric > Quotient & Remainder. Conecta la terminal “i” del número de iteración del ciclo a la terminal “x” del bloque que acabas de colocar.
8. Da clic derecho sobre la terminal “y” del bloque Quotient & Remainder y elige la opción Create > Constant del submenu que aparece. Fija el valor de la constante en 2. Con esto podremos determinar si la iteración es par o impar.} 9. Coloca un bloque de comparación Equal to 0? que encontrarás bajo Programming > Comparison > Equal to 0? Conecta la terminal “R” del bloque Quotient & Remainder al bloque Equal to 0?
10. Coloca un bloque Select que encontraras bajo Programming > Comparison > Select. Conecta la salida del bloque Equal to 0? a este bloque. Además, crea las constantes par el
valor de True (fija un valor de 5) y para el valor de False (fija un valor de 0). Así terminamos de definir la amplitud de nuestra señal aleatoria.
11. Ahora definiremos el periodo de espera de cada estado de la señal (alto y bajo). Para esto, coloca dentro del ciclo For un bloque Wait que encontrarás bajo Programming > Timing > Wait (ms). Si es necesario, modifica el tamaño de las estructuras. 12. Ahora coloca un bloque Multiply seguido de un bloque Round to Nearest antes del bloque Wait. Estos dos bloques los encontrarás bajo Programming > Numeric > Multiply/Round to Nearest.
13. Después de conectar los bloques que colocaste, pon un bloque Random Number que encontrarás bajo Programming > Numeric > Random Number y conéctalo a la terminal “x” del bloque Multiply. 14. En la terminal “y” del bloque Multiply, crea una constante y fija su valor en 5. De esta forma, el valor máximo de cada estado (alto o bajo) de la señal binaria aleatoria no podrá ser de más de 5ms. Con esto terminamos de definir nuestra señal binaria aleatoria que servirá de excitación para nuestra planta.
15. Ahora usaremos los bloques de DAQmx para poder mandar esta señal binaria aleatoria por la salida analógica AO0. En la esquina superior izquierda se encuentran los bloques de DAQmx Create Channel y DAQmx Start Task los cuales, respectivamente permiten la habilitación de los canales donde la señal será enviada así como el inicio de la asignación de las tareas a estos canales. 16. Ahora coloca dentro del ciclo For un bloque DAQmx Write que encontrarás bajo Measurement I/O > NI-DAQmx > DAQmx Write. 17. Ahora, coloca fuera del ciclo For en el lado derecho un bloque DAQmx Stop Task que encontrarás bajo Measurement I/O > NI-DAQmx > DAQmx Stop Task. Realiza las conexiones que se muestran en la imagen incluyendo la conexión del valor de salida del bloque Select a la terminal “data” del bloque DAQmx Write.
Nota: Al realizar las conexiones, puede que la salida de la tarea de escritura en el puerto muestre una X roja en el cable que lo conecta con el bloque DAQmx Stop Task. Esto indica que los cables no están bien conectados. Esto se debe a que el ciclo For indexa (crea un arreglo) los valores de salida del ciclo. Para resolver este problema, da clic derecho en el nodo de conexión entre el ciclo For y el bloque DAQmx Stop Task y da clic en la opción Disable Indexing.
En la estructura CASE, cámbiate al caso true y justo en el cuadro blanco formado al realizar la conexión entre el DAQmx write y el select, haz clic derecho y selecciona Create < Constant, y dale el valor de 0.
18. Ya que generamos la señal de excitación, ahora debemos realizar la adquisición de esta misma señal y de la respuesta de la planta. Pero primero observamos la estructura Case alrededor de todo el código que acabamos de hacer. Este sirve para que la señal de excitación y la adquisición de los datos sólo se realice cuando se presione el botón “Obtener Modelo” que aparece en el panel frontal y que se muestra en el diagrama de bloques como un control booleano llamado “OK Button”. 19. En la parte superior de la estructura Case, da clic en el combo box y elige la opción “False”. Esto nos permitirá hacer el código que se ejecutará en caso de que el botón “Obtener Modelo” no esté siendo presionado. Lo que queremos que suceda mientras el botón no es presionado es que la señal de excitación de la planta sea 0. Por lo tanto, mandaremos constantemente el valor 0 por la salida analógica 0 (ao0). Coloca un bloque DAQmx Write que encontrarás bajo Measurement I/O > NI-DAQmx > DAQmx Write. En la terminal de “Data” crea una constante de valor 0. Agrega un bloque DAQmx Stop Task que encontrarás bajo Measurement I/O > NI-DAQmx > DAQmx Stop Task.
20. Regresa a la opción “True” de la estructura Case. Para realizar la adquisición de datos, usaremos una opción alternativa a los bloques de NI-DAQmx que es usar el bloque Express DAQ Assistant. Coloca un bloque DAQ Assistant que encontrarás bajo Express > Input > DAQ Assistant. Permite que se inicialice el asistente y realiza las siguientes configuraciones: Acquire Signals > Analog Input > Voltage, dejando la tecla Ctrl presionada, elige las entradas “ai0” y “ai1” del DevX(NIMyDAQ) y da clic en Finish. En la ventana que se abre, dentro del recuadro “Channel Setings” en la pestaña
“Configuration” da clic en el botón “Show Details >>”. Cambia el nombre de los canales dando clic derecho sobre cada canal y eligiendo la opción “Rename”. Al canal “ai0” llámalo “Estímulo” y al canal “ai1” llámalo “Respuesta”. Da clic sobre el botón “Hide Details” y en la opción “Terminal Configuration” elige Differential En el recuadro “Timing Settings” deja la opción “N Samples” como modo de adquisición, modifica el valor de “Simples to Read” a 40,000 y cambia el valor de “Rate (Hz)” a 5k. Al terminar, da clic en OK.
21. Agregaremos una escala debido a la naturaleza en la que se presenta la señal de respuesta. En la opción de “Custom Scalling” >> “Create New” damos la opción Linear y damos nombre a nuestra escala. En la pantalla siguiente ponemos en el parámetro de slope la constante -1 y damos OK. Importante: Esta opción puede o no ser necesaria y depende de la conexión del motor. Si tu función de transferencia al final del ejercicio resulta negativa, quita esta escala para resolver el problema.
22. Para poder obtener por separado las dos señales de la adquisición de datos, coloca un bloque Split Signals que encontrarás bajo Express > Signal Manipulation > Split Signals. Conecta la salida del bloque DAQ Assistant al bloque Split Signals. Para obtener las dos señales, expande el bloque Split Signals hacia abajo y verás la nueva terminal de salida.
23. Ahora si comenzaremos a utilizar los bloques del System Identification Toolkit de LabVIEW para poder hacer la identificación paramétrica de nuestra planta. Coloca un bloque Model Estimation que encontrarás bajo Control Design & Simulation > System ID > Parametric > SI Model Estimation. Permite que se abra el asistente y realiza las siguientes configuraciones: dentro del recuadro “Select Model Type” elige State-Space, en el recuadro “Select Model Dims” elige SISO, en el recuadro “Select Data Type” elige Waveform, en el recuadro “Set Model Orders” elige 2 bajo “Number of States”, al finalizar da clic en OK. Este VI nos ayudará a calcular un modelo de espacio-estado de orden 2 de nuestra planta.
24. Ahora colocaremos un bloque TF Estimation que encontrarás bajo Control Design & Simulation > System ID > Parametric > SI Transfer Function Estimation. Permite que se abra el asistente y realiza las siguientes configuraciones: dentro de la pestaña “Input Info” elige Waveform, dentro de la pestaña “Model Settings” elige Continuous, ahí mismo elige como orden del numerador 1 y como orden del denominador 2, al finalizar da clic en OK.
25. Ya que terminamos de hacer estos pasos podemos conectar a estos dos bloques del toolkit de identificación de sistemas las señales de la adquisición de datos. Dado que la primera señal que pedimos adquirir es la señal llamada “Estímulo”, esa será la señal que saldrá por la parte superior del bloque Split Signals. Conecta esta señal a las terminales “Stimulus Signal” de los bloques de estimación paramétrica. Conecta la segunda señal (de arriba hacia abajo) del bloque Split Signals a las terminales “Response Signal” de los mismos bloques.
26. Ahora mandaremos imprimir al panel frontal los modelos de la planta calculados por el System Identification Toolkit de LabVIEW. Para poder hacer esto, tenemos que armar la representación de espacio-estado y la función de transferencia con el Control Design Toolkit de LabVIEW. Primero armaremos la representación de espacio-estado. Coloca un bloque Unbundle by Name que encontrarás en Programming > Cluster & Variant > Unbundle by Name. Conecta este bloque a la terminal de salida “Model Coeficients” del bloque Estimate State-Space Model. Expande el bloque Unbundle by Name hacia abajo hasta que aparezcan las terminales “A”, “B” y “C”.
27. Dado que los valores de los coeficientes son un tipo de dato de arreglo, tenemos que pasarlo a tipo de dato matriz que reconoce el bloque que arma una representación de espacio-estado. Coloca un bloque Array to Matriz a cada una de las terminales del bloque Unbundle by Name que encontrarás en Programming > Array > Array to Matrix.
28. La matriz C presenta la particularidad de que sale del modelo como un vector vertical. Cuando armamos la representación de espacio-estado, necesitamos que esta matriz entre como un vector horizontal por lo que es necesario trasponer esta matriz. Coloca un bloque Transpose Matrix que encontrarás bajo Mathematics > Linear Algebra > Transpose Matrix. Conecta la terminal de la matriz C a este bloque para trasponer el vector. 29. Ahora ya tenemos todo para construir la representación de espacio-estado con los bloques del Control Design Toolkit de LabVIEW. Coloca un bloque Construct State-Space Model que encontrarás bajo Control Design & Simulation > Control Design > Model Construction > CD Cunstruct State-Space Model. Conecta las terminales de las matrices A, B y C transpuesta al bloque que acabas de colocar.
30. Para poder imprimir la representación de espacio-estado que acabamos de crear, coloca un bloque Draw State-Space Equation que encontrarás bajo Control Design & Simulation > Control Design > Model Construction > CD Draw State-Space Equation. Conecta este bloque a la representación de espacio-estado que creamos y también conecta la salida de este bloque al indicador llamado “Ecuación de Estado” que teníamos en el programa desde el principio.
31. Pasaremos a construir ahora la representación de función de transferencia siguiendo pasos similares a la representación de espacio estado. Coloca un bloque Unbundle by Name que encontrarás en Programming > Cluster & Variant > Unbundle by Name. Conecta este bloque a la terminal de salida “Model Coeficients” del bloque TF Estimation. Expande el bloque Unbundle by Name hacia abajo hasta que aparezcan las terminales “Numerator” y “Denominator”.
32. Coloca un bloque Construct Transfer Function Model que encontrarás bajo Control Design & Simulation > Control Design > Model Construction > CD Cunstruct Transfer Function Model. Conecta las terminales “Numerator” y “Denominatior” al bloque que acabas de colocar. 33. Para poder imprimir la representación de función de transferencia que acabamos de crear, coloca un bloque Draw Transfer Function Equation que encontrarás bajo Control Design & Simulation > Control Design > Model Construction > CD Draw Transfer Function Equation. Conecta este bloque a la representación de función de transferencia que creamos y también conecta la salida de este bloque al indicador llamado “Función de Transferencia” que teníamos en el programa desde el principio.
34. A partir de la representación de función de transferencia que acabamos de crear, podemos obtener otras representaciones similares. Crearemos una representación de función de transferencia pero en forma factorizada o forma Zero-Pole-Gain. Coloca justo sobre el bloque Draw Transfer Function Equation un bloque Convert to Zero-Pole-Gain Model que encontrarás bajo Control Design & Simulation > Control Design > Model Conversion > CD Convert to Zero-Pole-Gain Model. Conecta la terminal de entrada de este bloque al cable rosa que sale del bloque Construct Transfer Function Model hacia el bloque Draw Transfer Function Equation. 35. Para poder imprimir la representación que acabamos de crear, coloca un bloque Draw Zero-Pole-Gain Equation que encontrarás bajo Control Design & Simulation > Control Design > Model Construction > CD Draw Zero-Pole-Gain Equation. Conecta este bloque a la representación de ZPK que creamos y también conecta la salida de este bloque al indicador llamado “FT en forma ZPK” que teníamos en el programa desde el principio.
36. Dado que nos interesa poder usar el modelo calculado por el System Identification Toolkit de LabVIEW en futuros ejercicios del seminario, guardaremos el modelo de función de transferencia. Coloca un bloque Save System Model to File que encontrarás bajo Control Design & Simulation > System ID > Management > Save System Model to File. Conecta la terminal “System Model” de este bloque a la terminal “System Model Out” del bloque Transfer Function Estimation. Da clic derecho sobre la terminal “File Path” del bloque Save System Model to File y elige Create > Control. Como nombre de este control, teclea “Guardar Modelo en:”. Esto creará un browser para poder definir la localización del archivo
que contendrá la información del modelo. Finalmente da clic derecho sobre la terminal “Default Name” y elige la opción Create > Constant. Teclea el nombre “ModPlanta” que será el nombre del archivo por default.
37. También incluiremos una gráfica que nos permita ver tanto la señal de estímulo como la respuesta de la planta. Pasa al panel frontal y agrega un indicador gráfico de tipo Waveform Graph que encontrarás bajo Modern > Graph > Waveform Graph en la paleta de controles. Coloca el indicador gráfico como se muestra en la imagen y realiza las siguientes configuraciones: da clic derecho sobre el eje de las “y” e inhabilita la opción “Auto-scale Y”, da doble clic sobre el valor máximo de la escala en Y y cambia su valor a 0.015, da doble clic sobre el valor mínimo de la escala en Y y cambia su valor a -0.015. De igual manera en el eje de las “x” inhabilita la opción “Auto-scale X” y pon como valor mínimo 0 y como máximo 0.15 Puedes aprovechar para acomodar el control “File Path” que llamamos “Guardar Modelo en:” como se muestra en la imagen.
38. Pasa al diagrama de bloques y conecta la terminal del indicador gráfico directamente a la salida del bloque DAQ Assistant antes de que el cable azul llegue al bloque Split Signal. Ese cable azul contiene las dos señales y basta con conectarlo directamente al indicador gráfico para poder visualizar las dos señales al mismo tiempo. El código final del programa se debe de ver como en la siguiente imagen.
39. Finalmente, guarda el archivo dando clic sobre la opción Save que encontrarás en el panel frontal desde el menú File > Save. Ejecuta el programa dando clic sobre el icono que contiene una flecha blanca en la barra de herramientas del panel frontal. Cada vez que aprietes el botón “Obtener Modelo” se ejecutará el código en la estructura Case con valor “True” y se te pedirá que indiques la dirección sonde deseas guardar el archivo que contiene la información del modelo obtenido. Presiona el botón “Salir” para detener el programa. Nota: Cuando ejecutes el programa, obtén varias veces el modelo de la planta y compara cada resultado con el anterior. Notarás que hay cambios en los modelos que obtienes. Esto se debe a que la señal aleatoria es diferente cada vez que pides obtener el modelo de la planta. También esto se puede ver afectado por interferencias de fricción en el acoplamiento mecánico entre los dos motores. Nota: Si deseas que solo te pida la dirección donde deseas guardar el modelo calculado una vez, ejecuta una vez el programa, detenlo y da clic sobre el icono del browser. Navega hasta donde guardaste el modelo y elige el archivo ModPlanta.sim. Cuando vuelvas a ejecutar el programa, ya no se te pedirá que indiques la dirección nuevamente.
Fin Ejercicio 1.
Ejercicio 2a. Análisis de Sistemas Continuos En este ejercicio aprenderemos a analizar sistemas de control continuos definidos matemáticamente en el dominio de la frecuencia. Una vez que tenemos definido un sistema (polos, ceros y ganancia) podemos usar el Control Design Toolkit de LabVIEW para hacer análisis de respuesta transitoria, estacionaria y harmónica. Usaremos una interfaz gráfica muy poderosa desarrollada en LabVIEW y que sirve como ejemplo de lo que podríamos llegar a desarrollar en este lenguaje de programación con la cual podemos agregar definiciones de diferentes modelos así como importar con esta interfaz el modelo que guardamos de nuestra planta en el ejercicio anterior. Sigue estas instrucciones: 1. Abre LabVIEW si no se encuentra abierto dando clic en el ícono del programa o con la ruta de acceso del menú de inicio en Windows: Start > All Programs > National Intruments > LabVIEW 2011> LabVIEW. 2. Abre el archivo que se encuentra en el escritorio en la carpeta de LabVIEW Control Design HandsOn\Exercises\Ejercicio 2a – Análisis de Sistemas. 3. Observa detenidamente la interfaz gráfica que se proporciona en el panel frontal. Navega por las pestañas de la interfaz. Ahora pasa al diagrama de bloques y observa el código de esta interfaz. Navega por las opciones de la estructura case conectada al indicador de las pestañas (Tab Control). Repetimos que el objetivo de este curso es aprender a usar los toolkits de LabVIEW que nos permiten construir sistemas de control y no así mostrar las bases de programación en LabVIEW. Con los conocimientos suficientes de programación en LabVIEW armar una interfaz gráfica de esta calidad no es complicado. 4. En el diagrama de bloques, en el combo box de la estructura Case, elige la opción “Respuesta Transitoria”. En esta parte del código empezaremos a construir nuestro análisis en el dominio del tiempo de nuestro sistema. Coloca un bloque Construct Zero-Pole-Gain Model que encontrarás bajo Control Design & Simulation > Control Design > Model Construction > CD Cunstruct Zero-Pole-Gain Model. Conecta las terminales que vienen de fuera de la estructura Case “Ceros”, “Polos” y “Gain” a las terminales correspondientes del bloque que acabas de colocar.
5. Ya que construimos el modelo, ahora colocaremos su ecuación en el panel frontal, para esto, coloca un bloque Draw Zero-Pole-Gain Equation que encontrarás bajo Control Design &
Simulation > Control Design > Model Construction > CD Draw Zero-Pole-Gain Equation. Conecta este bloque a la representación de ZPK que creamos. Da clic derecho en la terminal de salida de este bloque y elige la opción Create > Indicator. Modifica el nombre del indicador dando doble clic sobre la etiqueta “Equation” y llamándolo “G(s):”.
6. Pasa al panel frontal y acomoda el indicador “G(s):” en la parte superior izquierda dentro de la pestaña “Respuesta Transitoria”.
Nota: Puede que el indicador no aparezca dentro de la pestaña “Respuesta Transitoria” automáticamente. Si no encuentras el indicador, pasa al diagrama de bloques y dando clic derecho sobre el indicador “G(s):” elige la opción “Find Indicador”. Una vez que hayas ubicado el indicador, colócalo en la posición correcta.
7. Podemos hacer ahora un análisis de la respuesta del sistema a un escalón unitario. En el diagrama de bloques, coloca un bloque Step Response que encontrarás bajo Control Design & Simulation > Control Design > Time Response > CD Step Response. Conecta a la terminal “State-Space Model” (nombre de la terminal que aparece por default) de este bloque la salida del modelo ZPK que construimos. Da clic derecho sobre la terminal de salida “Step Response Graph” del bloque Step Response y elige la opción Create > Indicator.
8. Pasa al panel frontal y da clic derecho sobre el indicador gráfico. Elige la opción Visible Ítems > Plot Legend para quitar la leyenda superior del indicador gráfico. Coloca el indicador gráfico dentro de la pestaña “Respuesta Transitoria”.
9. Ahora agregaremos algunos datos importantes del análisis de nuestro sistema. Podemos obtener directamente una cadena de texto que nos indique si el sistema es estable o inestable. Coloca un bloque Stability que encontrarás bajo Control Design & Simulation > Control Design > Dynamic Characteristics > CD Stability. Conecta a este bloque la salida del modelo ZPK que construimos. Da clic derecho sobre la terminal de salida “Stability” y elige la opción Create > Indicator.
10. Pasa al panel frontal y coloca el indicador enumerado “Stability” dentro del pequeño recuadro que se tiene dentro de la pestaña “Respuesta Transitoria”. 11. Agregaremos también el coeficiente de amortiguamiento del sistema así como su frecuencia natural. Coloca un bloque Camping Ratio and Natural Frequency que encontrarás bajo Control Design & Simulation > Control Design > Dynamic Characteristics > CD
Damping Ratio and Natural Frequency. Conecta a la terminal de entrada de este bloque la salida del modelo ZPK que creamos. Crea un indicador para las terminales de salida “Damping Ratios” y “Natural Frequencies”.
12. Pasa al panel frontal y coloca los dos indicadores dentro del recuadro de la pestaña “Respuesta Transitoria”. Dado que estos indicadores son de tipo arreglo, los puedes colapsar para que solo se vea un renglón del arreglo. Tu panel frontal se debe de ver como la siguiente imagen.
13. Ahora pasaremos a hacer el análisis del comportamiento harmónico (o de la frecuencia) de nuestro sistema. En el panel frontal, selecciona la pestaña “Respuesta Harmónica”. Ahora pasa al diagrama de bloques y dentro del combo box de la estructura case elige la opción “Respuesta Harmónica”. 14. Crea de nuevo un modelo de tipo ZPK colocando un bloque bloque Construct Zero-Pole-Gain Model que encontrarás bajo Control Design & Simulation > Control Design > Model Construction > CD Cunstruct Zero-Pole-Gain Model. Conecta las terminales de la estructura Case “Ceros”, “Polos” y “Gain” al bloque que acabas de colocar. 15. Pasa al panel frontal. Crearemos un separador de pestañas dentro de la pestaña “Respuesta Harmónica”. Este separador lo encuentras bajo Modern > Containers > Tab Control de la paleta de controles.
16. Agranda el separador de pestañas a que abarque todo el espacio de la pestaña “Respuesta Harmónica”. Ahora, dando doble clic sobre el nombre de las pestañas, cambia el nombre de la primera pestaña a “Bode”. En esta pestaña pondremos los diagramas de Bode de nuestro sistema. A la segunda pestaña llámala “Nyquist”. Para poder agregar más pestañas, da clic derecho sobre alguna de las pestañas y elige la opción “Add Page After”. Agrega dos pestañas más para tener en total 4 pestañas. Llama a las dos pestañas siguientes “Nichols” y “Márgenes de Estabilidad”.
17. Pasa ahora al diagrama de bloques donde colocaras una pequeña estructura Case dentro de la estructura Case que ya había desde el principio y bajo la opción “Respuesta Harmónica” Conecta a la terminal “?” de la estructura Case el indicador del separador de pestañas “Tab Control 2”.
18. Dentro del combo box de la estructura Case, elige la opción “Bode”. Dentro de la estructura Case coloca un bloque Bode que encontrarás bajo Control Design & Simulation > Control Design > Frequency Response > CD Bode. Conecta a este bloque la salida del modelo ZPK que creamos anteriormente bajo el caso “Respuesta Harmónica”. Crea un indicador gráfico para las terminales de salida del bloque Bode “Bode Magnitude” y “Bode Phase” dando clic derecho sobre la terminal y eligiendo la opción Create > Indicator.
19. Pasa al panel frontal. Ubica los dos indicadores gráficos que corresponden al diagrama de bode para la magnitud y la fase. Haz estos indicadores gráficos más pequeños para que los dos quepan dentro de la pestaña llamada “Bode” como se muestra en la imagen.
20. Dentro del combo box de la nueva estructura Case, elige la opción “Nyquist”. Dentro de la estructura coloca un bloque Nyquist que encontrarás bajo Control Design & Simulation > Control Design > Frequency Response > CD Nyquist. Conecta a la terminal de entrada de este bloque la salida del modelo ZPK que creamos. Ahora crea un indicador dando clic derecho a la terminal de salida del bloque Nyquist llamada “Nyquist Plot”.
21. Pasa al panel frontal y coloca el indicador “Nyquist Plot” dentro de la pestaña Nyquist. Puedes agrandar el indicador para que abarque todo el espacio de esta pestaña. 22. En el diagrama de bloques, ahora agregaremos un bloque Nichols para poder visualizar el diagrama de Nichols que relaciona la frecuencia con la magnitud del sistema. Para poder hacerlo, necesitamos agregar el caso Nichols dentro de nuestra estructura Case. Da clic derecho sobre la estructura case y elige la opción “Add Case After”. Automáticamente se crea el caso “Nichols”. Repite de nuevo esta operación para tener el caso “Márgenes de Estabilidad”. 23. Ahora si, coloca un bloque Nichols dentro del caso con el mismo nombre. Este bloque lo encontrarás bajo Control Design & Simulation > Control Design > Frequency Response > CD Nichols. Conecta el bloque a la salida del modelo ZPK que habíamos creado y crea el indicador para la terminal “Nichols Plot”.
24. En el panel frontal, coloca este indicador dentro de la pestaña “Nichols”. Puedes expandir el indicador para que abarque toda el área de la pestaña.
25. De regreso al diagrama de bloques, dentro del caso Márgenes de Estabilidad, coloca un bloque Gain and Phase Margin que encontrarás bajo Control Design & Simulation > Control Design > Frequency Response > CD Gain and Phase Margin. Conecta el bloque al modelo ZPK y crea un indicador para las terminales de salida “Magnitude Plot” y “Phase Plot”.
26. En el panel frontal, coloca los dos indicadores dentro de la pestaña “Márgenes de Estabilidad”. Estos gráficos indican hasta que ganancia y fase es estable e sistema. Ajusta el tamaño de estos indicadores para poderlos acomodar dentro de la pestaña. Tu panel frontal se debe de ver como la siguiente imagen.
27. Pasa a la pestaña “Función de Transferencia” y ejecuta el programa. Analizaremos un sistema que propondremos a través de la interfaz gráfica. Sube la ganancia a 2.75 y presiona el botón “Actualizar”. Agregaremos un cero por lo que en la parte real teclea -3.47 y en la imaginaria 0. Da clic al botón “Agregar”. Realiza el mismo proceso para agregar un polo en (0.93,0) y (-4.22,±0.88). Si cometes un error, puedes seleccionar el polo o cero que hayas agregado y luego presiona el botón “Borrar” para poder quitar ese polo o cero. Cuando quites polos o ceros complejos, recuerda quitar los dos conjugados para que no haya conflicto con la función de transferencia. 28. Navega por las diferentes pestañas del análisis transitorio y del análisis harmónico para ver los resultados del análisis. 29. Presiona el botón “Stop” para detener la ejecución del programa. 30. Vuelve a ejecutar el programa, pero ahora, en lugar de agregar la definición de un sistema (su ganancia, polos y ceros) da clic sobre el botón “Importar Modelo”. Navega hasta la dirección donde guardaste el archivo que contiene la información del modelo obtenido en el ejercicio 1. Selecciona el archivo ModPlanta.sim y verás que el modelo se agrega automáticamente a la interfaz gráfica. 31. Navega por las diferentes pestañas del análisis transitorio y del análisis harmónico para ver los resultados del análisis. 32. Finalmente, guarda el archivo dando clic sobre la opción Save que encontrarás en el panel frontal desde el menú File > Save.
Fin Ejercicio 2a.
Ejercicio 2b. Análisis de Sistemas Discretos (opcional) En este ejercicio aprenderemos a analizar sistemas de control discretos definidos matemáticamente en el dominio de la variable z. En realidad no hay diferencia entre este ejercicio y el ejercicio anterior. La única especificación que cambia en todos los casos es que hay que definir el tiempo de muestreo de la función de transferencia que estamos utilizando. Sigue estas instrucciones: 1. Abre LabVIEW si no se encuentra abierto dando clic en el ícono del programa o con la ruta de acceso del menú de inicio en Windows: Start > All Programs > National Intruments > LabVIEW 2011> LabVIEW. 2. Abre el archivo que se encuentra en el escritorio, en la carpeta de LabVIEW Control Design HandsOn\Exercises\Ejercicio 2b – Análisis de Sistemas. 3. A partir de este punto, sigue exactamente las mismas instrucciones que en el ejercicio anterior. La facilidad que encontramos con el Control Design Toolkit de LabVIEW es que para modelar sistemas discretos y poderlos analizar, se usan los mismos bloques. La única diferencia es que cuando creamos un modelo (ZPK por ejemplo) tenemos que definir el tiempo de muestreo de la función de transferencia. Automáticamente, se detecta entonces que es un sistema discreto y se pasa la función de transferencia al dominio de la variable z. En todos los casos, al momento de crear un modelo ZPK, conecta la terminal del control “Tiempo de Muestreo (s)” a la terminal “Sampling Time” del bloque Construct Zero-PoleGain Model. Antes de agregar una función de transferencia en la interfaz gráfica de la pestaña “Función de Transferencia”, define el tiempo de muestreo primero. 4. Realiza los mismos dos ejemplos (el sistema de control que proponemos e importar el modelo que tenemos del ejercicio 1) ejecutando el programa cuando haya terminado de construir el código. Observa las diferencias en la estabilidad del sistema dado que ahora es discreto. 5. Finalmente, guarda el archivo dando clic sobre la opción Save que encontrarás en el panel frontal desde el menú File > Save.
Fin Ejercicio 2b.
Ejercicio 3. Diseño de un Controlador PID En este ejercicio mostraremos cómo podemos sintetizar de una manera sencilla los parámetros de un controlador PID. En sí, veremos cómo responde nuestro sistema ante diferentes ganancias del controlador PID. El ejercicio contiene una interfaz gráfica sencilla que muestra la estructura del controlador en un diagrama de bloques mostrando la función de transferencia de cada parte del controlador. Modificaremos en tiempo real los valores de las ganancias proporcional, derivativa e integral para conseguir el mejor desempeño posible. Además, aprenderemos a usar el Simulation Toolkit de LabVIEW para construir diagramas de bloques y ver la respuesta de nuestro sistema. Compararemos la facilidad de uso de los bloques del Control Design Toolkit y del Simulation Toolkit para simular y hacer la síntesis de nuestro controlador PID. Sigue estas instrucciones: 1. Abre LabVIEW si no se encuentra abierto dando clic en el ícono del programa o con la ruta de acceso del menú de inicio en Windows: Start > All Programs > National Intruments > LabVIEW 2011 > LabVIEW. 2. Abre el archivo que se encuentra en el escritorio en la carpeta de LabVIEW Control Design HandsOn\Exercises\Ejercicio 3 – Diseño de PID. 3. En este ejercicio solo agregaremos el código de la estructura Case para poder construir la estructura del controlador PID primero usando los bloques del Control Design Toolkit y luego usando los bloques del Simulation Toolkit de LabVIEW. Pasa al diagrama de bloques y en el combo box de la estructura Case elige la opción “Control Design Toolkit”. 4. Como podemos ver, las funciones de transferencia de la planta, del bloque proporcional, del bloque derivador y del bloque integrador ya están construidas. Ahora tenemos que unir estas funciones de transferencia para armar el controlador. Primero conectaremos en paralelo los bloques proporcional y derivador. Coloca un bloque Parallel que encontrarás bajo Control Design & Simulation > Control Design > Model Interconection > CD Parallel. Conecta las terminales “Model 1” y “Model 2” de este bloque a las salidas de los modelos de los bloques proporcional y derivador.
5. El siguiente paso es conectar el modelo en paralelo entre el bloque proporcional y derivador en paralelo con el bloque integral. Coloca un bloque Parallel que encontrarás bajo Control Design & Simulation > Control Design > Model Interconection > CD Parallel. Conecta las terminales “Model 1” y “Model 2” de este bloque a la salidas del modelo en paralelo que creamos en el paso anterior y el modelo del bloque integral.
6. Ahora conectaremos el paralelo de los bloques que formal al controlador PID en serie con el modelo de la planta que se importa directo del archivo en el que guardamos la información de nuestra planta. Coloca un bloque Series que encontrarás bajo Control Design & Simulation > Control Design > Model Interconection > CD Series. Conecta las terminales “Model 1” y “Model 2” de este bloque a la salida del bloque paralelo de los componentes del PID y la salida del modelo de la planta que calculamos en el ejercicio 1.
7. Una vez conectado en serie la planta y los bloques del controlador PID tenemos que cerrar el lazo para poder tener presente la retroalimentación del sistema según el diagrama de la interfaz gráfica. Coloca un bloque Feedback que encontrarás bajo Control Design & Simulation > Control Design > Model Interconection > CD Feedback. Conecta a la terminal “Model 1” de este bloque la salida de la conexión en serie de la planta y el PID. En la terminal “Model 2” conectaremos un modelo que crearemos en el siguiente paso que en realidad no es más que un modelo de valor 1 que cierre el lazo.
8. Coloca un bloque Construct Zero-Pole-Gain Model que encontrarás bajo Control Design & Simulation > Control Design > Model Construction > CD Cunstruct Zero-Pole-Gain Model. Da clic derecho sobre la terminal “Gain” de este bloque y crea una constante de valor 1 eligiendo la opción Create > Constant. Conecta la salida de este bloque a la terminal “Model 2” del bloque Feedback.
9. Hemos terminado de generar nuestro modelo representado en la interfaz gráfica. El interés ahora es ver que pasa ante un escalón unitario con la respuesta de nuestro sistema. Coloca un bloque Step Response que encontrarás bajo Control Design & Simulation > Control Design > Time Response > CD Step Response. Conecta a la terminal “State-Space Model” (nombre de la terminal que aparece por default) de este bloque la salida del modelo
generado en el bloque Feedback que construimos. Da clic derecho sobre la terminal “Time Info” y crea las constantes de esta terminal. Verifica que los valores de esta terminal sean (0,0.001,20) en ese orden. Da clic derecho sobre la terminal de salida “Step Response Graph” del bloque Step Response y elige la opción Create > Indicator.
10. Pasa al panel frontal y coloca el indicador gráfico en la pestaña “Control Design Toolkit”. Puedes expandir el indicador de manera que abarque todo el espacio de la pestaña. Da clic derecho sobre el indicador gráfico y elige la opción Visible Ítems > Plot Legend para desactivar la leyenda del indicador. Da clic derecho sobre el eje de las “y” y selecciona la opción “Auto-scale Y”. Esto desactivará la auto-escala. Da doble clic sobre el valor máximo en el eje de las “y” y teclea 1.1. Da doble clic sobre el valor mínimo en el eje de las “y” y teclea 0.
11. Pasa de nuevo al diagrama de bloques. Ahora usaremos el Simulation Toolkit de LabVIEW para construir la misma estructura del PID con la planta pero de una manera más sencilla. En el combo box de la estructura Case, elige “Simulation Toolkit”. Ahora colocaremos la interfaz que nos permite usar los bloques de este toolkit. Coloca un bloque Simulation Loop que encontrarás bajo Control Design & Simulation > Simulation > Simulation Loop. Expande este loop de manera que abarque todo el interior de la estructura Case. 12. Da doble clic sobre la lengüeta del lado superior izquierdo del Simulation Loop y realiza las siguientes configuraciones: Initial Time: 0, Final Time: 20, ODE Solver: Runge-Kutta 23 (variable), Minimum Step Size: 1E-10, Maximum Step Size: 1, Relative Tolerance: 0.001 y Absolute Tolerante: 1E-7.
13. Coloca dentro del Simulation Loop, un bloque Step Signal que encontrarás bajo Control Design & Simulation > Simulation > Signal Generation > Step Signal.
14. Da doble clic sobre el bloque Step Signal y realiza las siguientes configuraciones: inicial value: 0, final value: 1 y step time: 0.
15. Coloca junto al bloque Step Signal un bloque Sumation que encontrarás bajo Control Design & Simulation > Simulation > Signal Arithmetic > Sumation. 16. Junto a este bloque coloca un bloque Derivative y un bloque Integrator que encontrarás bajo Control Design & Simulation > Simulation > Continuous Linear Systems > Derivative/Integrator.
17. Coloca tres bloques Multiply que encontrarás bajo Programming > Numeric > Multiply. Coloca uno a lado del derivador, uno al lado del integrador y el tercero arriba del bloque del derivador. 18. Coloca de nuevo un bloque Sumation que encontrarás bajo Control Design & Simulation > Simulation > Signal Arithmetic > Sumation. Da doble clic sobre este bloque y realiza las siguientes configuraciones: Icon Shape: Rectangle, Inputs: 3, da clic sobre la terminal negativa hasta que aparezca un signo “+” y haz lo mismo con la terminal que aparece con un círculo rojo cruzado.
19. Coloca junto al último bloque Sumation un bloque Transfer Function que encontrarás bajo Control Design & Simulation > Simulation > Continuous Linear Systems > Transfer Function. Da doble clic sobre este bloque y realiza la siguiente configuración: Parameter Source: Terminal.
20. Coloca un bloque Build Array que encontrarás bajo Programming > Array > Build Array. Expande este bloque hasta tener dos entradas. Lo que estamos haciendo es crear un arreglo de la salida del sistema con la señal de entrada para poderlas graficar las dos en un solo indicador gráfico.
21. Coloca un bloque SimTime Waveform que encontrarás bajo Control Design & Simulation > Simulation > Graph Utilities > SimTime Waveform. Realiza las conexiones como se muestra en la siguiente imagen.
22. Ahora solo nos resta conectar los valores de las ganancias del proporcional, del derivador y del integral así como la función de transferencia de la planta para poder tener nuestro sistema armado. Conecta la terminal “Kp” de la estructura Case al primer bloque Multiply (de arriba hacia abajo). Conecta la terminal “Kd” al segundo bloque Multiply. Conecta la terminal “Ki” al tercer bloque Multiply. Finalmente conecta el cable rosa que trael el modelo de la planta directamente a la terminal “Transfer Function” del bloque Transfer Function.
23. Dado que el Simulation Toolkit de LabVIEW genera los cálculos de la simulación de un golpe (no genera dato por dato sino que realiza todos los cálculos antes de entregar el resultado) pondremos un bloque Wait para que los datos se muestren durante un cierto tiempo antes de que se vuelvan a realizar los cálculos y se actualicen los valores. Coloca un bloque Wait que encontrarás bajo Programming > Timing > Wait (ms). Da clic derecho sobre su terminal del lado izquierdo y crea una constante de valor 1500 (1.5 segundos).
24. Pasa al panel frontal y coloca el indicador gráfico que aparece dentro de la pestaña “Simulation Toolkit”. Puedes expandir el indicador de manera que abarque todo el espacio de la pestaña. Da clic derecho sobre el indicador gráfico y elige la opción Visible Ítems > Plot Legend para desactivar la leyenda del indicador. Da clic derecho sobre el eje de las “y” y selecciona la opción “Auto-scale Y”. Esto desactivará la auto-escala. Da doble clic sobre el valor máximo en el eje de las “y” y teclea 1.1. Da doble clic sobre el valor mínimo en el eje de las “y” y teclea 0.
25. En el panel frontal, da clic sobre el icono del browser para importar el modelo obtenido en el ejercicio 1. Navega hasta la dirección del archivo ModPlanta.sim y selecciónalo.
26. Ejecuta el programa. Cambia los valores de las ganancias del controlador y observa la respuesta del sistema. Puedes cotejar los resultados de los dos: el Control Design Toolkit y del Simulation Toolkit. Da clic en el botón “Stop” para detener el programa. Nota: Puede ser que haya leves diferencias entre los resultados de los dos toolkits. Incluso, puede ser que el Simulation Toolkit marque un error al tratar de resolver las ecuaciones diferenciales que se programaron en forma de diagrama de bloques dentro del Simulation Loop. Esto se debe a que los algoritmos de resolución de ecuaciones diferenciales son distintos y con diferentes parámetros. 27. Los valores recomendados para las ganancias del controlador PID son: Kp=2.5, Kd=0.05, Ki=7.5. 28. Finalmente, guarda el archivo dando clic sobre la opción Save que encontrarás en el panel frontal desde el menú File > Save.
Fin Ejercicio 3.
Ejercicio 4. Implementación de un Controlador PID En este ejercicio, conectaremos nuestro sistema de demostración a la tarjeta NI MyDAQ e implementaremos directamente un controlador PID por software. La ventaja de este tipo de controlador por software es que en tiempo real se está generando una señal de control para la planta sin necesidad de crear un PID físico (con amplificadores operacionales por ejemplo) conectado a nuestra planta. El controlador por software hace los cálculos en la computadora y produce la señal de control deseada según los parámetros de las ganancias del proporcional, el derivador y el integrador. La desventaja que tiene este tipo de control es que puede ser lento dependiendo de la velocidad de procesamiento de la computadora. Sigue estas instrucciones: 1. Abre LabVIEW si no se encuentra abierto dando clic en el ícono del programa o con la ruta de acceso del menú de inicio en Windows: Start > All Programs > National Intruments > LabVIEW 2011> LabVIEW. 2. Abre el archivo que se encuentra en la ruta C:\Hands On\Seminars\LabVIEW Control Design HandsOn\Exercises\Ejercicio 4 – Implementa PID. 3. Notarás que en el ejercicio se encuentran algunas estructuras ya hechas: funciones de DAQ para le lectura y escritura de datos, tres ciclos while y una estructura case.
4. Comenzaremos a armar nuestra medición de la velocidad del motor usando el sensor opto interruptor. Lo que haremos es medir cuantas veces por segundo pasa la muesca del círculo en el acoplamiento por el opto interruptor y así calcularemos la velocidad. 5. Empezaremos a trabajar en el segundo ciclo while. Colocamos la función de comparación “mayor que” que se encuentra en Programming > Comparison > Greater? ; en la primera entrada conectaremos la salida de datos del bloque de la lectura analógica del ciclo while. En la segunda entrada daremos clic derecho Create > Constant y le damos el valor de 1.
6. Agregamos la función de Numeric Compound que se encuentra en Programming > Numeric > Compound Arithmetic. Le damos clic derecho Change Mode > AND. Conectamos la salida del operador “Mayor que” a la primera entrada del Numeric Compound. Afuera del segundo ciclo while, creamos una constante booleana FALSE – Programming > Boolean > False Constant. Conectamos ésta al ciclo while, y a su vez a la segunda entrada del Numeric Compound.
7. Da clic sobre el contorno del ciclo While donde se encuentra la entrada booleana y elige la opción “Replace with Shift Register”. Coloca el otro Shift Register en el otro extremo del ciclo While. Conéctalo de la siguiente manera:
8. Agregaremos una estructura Case dentro del ciclo While, que se encuentra en Programming > Structures > Case Structure. Conectaremos la salida de nuestro Compound Arithmetic a la entrada de condición de la estructura Case.
9. En nuestro programa, haremos uso de un Sub VI llamado CUENTA. Su objetivo es el de ir contando la cantidad de cambios que detecta el opto interruptor y regresar este valor en un momento determinado. La actividad que realiza el VI depende de la función descrita en la etiqueta que tenga como entrada. Coloca el Sub VI Cuenta junto al ciclo While y conéctalo. Da clic derecho en la parte izquierda del Sub VI y elije Create Constant.
10. De las opciones que aparecen, selecciona la opción de Reset. Copia el Sub VI y agrega la copia dentro del Case Structure en la opción de TRUE. Crea otra constante y en este caso selecciona la opción Add. Conecta la entrada y salida de error, como se muestra en la siguiente figura:
11. Agregaremos una estructura Unbundle by Name que se encuentra en Programming > Clusters > Unbundle by Name y lígalo al cable de error de la función de lectura de DAQ. Agrega una función OR que se encuentra en Programming > Boolean > OR y conéctalo a la estructura. La otra entrada del OR la conectaremos después.
12. El ciclo que trabajamos se encarga de la parte de adquisición de los cambios detectados en el opto interruptor debido a las muescas del encoder. Cuando se da una variación de 0 a cualquier valor arriba de 1V, este cambio se registrará en el sub VI cuenta. Ahora trabajaremos en el ciclo de abajo, que nos ayudará a calcular las revoluciones por segundo utilizando el resultado de los cambios medidos. Coloca la función Elapsed Time que se encuentra dentro de Programming > Timing > Elapsed Time, y colócalo dentro del ciclo. Cuando salga el cuadro de texto selecciona 0.1 (segundos). Conecta la salida del “Time has Elapsed?” a la condición de la estructura CASE.
13. Dentro de la estructura CASE en el caso TRUE, agrega dos copias del sub VI Cuenta. Crea una constante en cada uno de ellas; uno con la opción RETURN y el otro RESET. Conecta los dos Sub VIs por medio de un cable de error.
14. Utiliza la función de división y multiplicación que encontraras en Programming > Numeric > Multiply/Divide. Crea constantes dando clic derecho en las funciones Create > Constant y conéctalas de la siguiente manera:
15. Al hacer esto hacemos que cada 0.1s se cuenten cuántos cambios detectó el opto interruptor, y lo dividimos por las 4 muescas del encoder (1 vuelta representa que se detecten los cambios en las cuatro muescas) y lo multiplicamos 10 para obtener revoluciones por segundo. Agregaremos un Shift Register a este ciclo dando clic derecho en el borde “Shift Register.” Agregaremos una constante de valor 0 en Programming > Numeric > DBL Numeric.
16. Pasa al caso false, sólo pasaremos el valor tal cual se lee del shift register. Haz las conexiones siguientes:
17. La terminal de paro del ciclo lo dejaremos sin conectar por el momento. Crearemos un indicador de las revoluciones por segundo dando clic derecho en el cable Create > Indicator, nombralo Rev/sec
18. Crea una variable local de este indicador. Da click derecho en el indicador, Create > Local Variable. Colócalo en el primer ciclo while del programa
19. Pasaremos a trabajar en el primer ciclo. Agrega la función de PID que se encuentra en Control Design and Simulation > PID > PID.vi , conecta el control de Speed Control a la entrada Setpoint de la función PID. Da click derecho en la variable local que creamos y da click en Change to Read. Esta variable irá conectado a la entrada Process Variable de la función PID.
20. Da click derecho en las entradas Output Range y PID Gains y en ambos casos elige la opción Create > Control. Pasa al panel frontal (CTRL + E ) y acomoda tus nuevos controles. En el control de Output Range establece los valores de Output Low como 0.2 y 0.9 como Output High (controlaremos la velocidad del motor por medio del ciclo de trabajo por lo que aquí establecemos que la salida del controlador PID será de 20 al 90%). Establece las ganancias de 20 para la parte proporcional, 0.002 para la parte integral y 0.1 para la parte derivativa.
21. Agrega un ciclo FOR Programming > Structures > FOR. En la Count Terminal del ciclo crea una constante de 10.
22. Agrega una función de multiplicación Numeric > Multiply. Agrega dos shift registers al ciclo FOR y realiza las siguientes conexiones:
23. Agrega una función de escritura de DAQ: Measurement I/O > NI DAQmx > Write. Da click en la función y elige Digital > Single Channel > Single Sample > Boolean (1 line). Agrega una función de temporización Programming > Timing > Wait Until Next ms y conecta una constante de 0.1
24. Usaremos la función Greater? que se encuentra en Programming > Comparison > Greater? Utiliza en la primer entrada la salida de la multiplicación y en la segunda el índice del ciclo FOR. La salida de la comparación irá al dato de entrada de la función de escritura de DAQ. Agregaremos la función Boolean to (0,1) que se encuentra en Programming > Boolean > Boolean to (0,1), y ésta a su vez a la salida Output.
25. Graficaremos en cada momento tanto el setpoint definido por el usuario como la respuesta del sistema. Para esto agregaremos la función Merge Signals que se encuentra en Express > Signal Manipulation > Merge Signals. Expande la función para que tenga dos entradas y la primera conecta el control de Speed Control y en la segunda la variable de rev/sec.
26. Da clic derecho a la condición de stop del ciclo y elige Create > Control. Esto te creará un botón de stop. Crea dos variables locales dando click derecho Create > Local Variable. Da click en cada una de ellas y elige Change to Read y agrégalas (una en el segundo ciclo while en la entrada del OR, y el segundo en el tercer ciclo directamente en la condición de paro). El programa completo se debe ver de la siguiente manera:
27. Puede que el número del dispositivo no coincida con el ejemplo. Sólo cambia estas opciones para el correcto funcionamiento del programa. Asegúrate de que la línea digital sea por la línea 3 y la adquisición de la señal analógica se haga por el canal 1. Nota: Asegúrate que los interruptores en el dispositivo de demostración estén apuntando hacia el circuito 2 (C2). Nota: Es posible que tengas que ajustar los parámetros de tu sistema PID para obtener mejores respuestas. Utiliza los valores obtenidos en los ejercicios anteriores, y haz comparaciones acerca de su funcionamiento.
Fin Ejercicio 4.
