LabVIEW Core 2 Curso.pdf

N at N ion ot a fo l In rd s is tru tri m bu en tio ts n

LabVIEW™ Core 2 Manual de Curso

ni.com/training

LabVIEW Core 2 Manual de Curso


TM

Versión del software actual 2012 Edición de Agosto 2012 Número de parte 325292D-0154 Manual de Curso LabVIEW Core 2

Copyright © 1993–2012 National Instruments. Todos los derechos reservados. En virtud de las leyes de copyright y de protección de los derechos de autor, esta publicación no puede reproducirse ni transmitirse en ninguna forma, electrónica o mecánica, incluidas las fotocopias, grabación, almacenamiento en un sistema de recuperación de información, o traducción, en su totalidad o en parte, sin el consentimiento previo por escrito de National Instruments Corporation. National Instruments respeta los derechos de propiedad intelectual de otros, y solicitamos a nuestros usuarios que hagan lo mismo. El software de NI está protegido por el derecho de autor y las normas de la propiedad intelectual. Aunque el software de NI puede utilizarse para reproducir software u otro material perteneciente a otros, el software de NI sólo podrá utilizarse para reproducir material que pueda reproducir conforme a los términos de cualquier licencia aplicable u otra restricción legal. Contrato de licencia de usuario final y avisos legales a terceros El contrato de licencia de usuario final (‘EULA’) y avisos legales a terceros se puede encontrar en las siguientes localidades: • Los avisos se localizan en los directorios \_Legal Information y . • Contrato de licencia de usuario final se localiza en el directorio \Shared\MDF\ Legal\License. • Revise \_Legal Information.txt para más información legal sobre los instaladores desarrollados con productos de NI. Marcas comerciales CVI, LabVIEW, National Instruments, NI, ni.com, el logotipo corporativo de National Instruments, y el logotipo del aguila son marcas propiedad de National Instruments Corporation. Por favor, consulte Trademark Information en la página ni.com/ trademarks para información sobre otras marcas de National Instruments. The mark LabWindows is used under a license from Microsoft Corporation. Windows is a registered trademark of Microsoft Corporation in the United States and other countries. Otros nombres de productos y de empresas mencionados aquí son marcas o nombres comerciales de sus respectivas empresas. Los miembros del National Instruments Alliance Partner Program son entidades comerciales independientes de National Instruments y no tienen relación de agencia, asociación ni empresa conjunta con National Instruments. Patentes Para obtener información sobre las patentes que protegen los productos o la tecnología de National Instruments, consulte el apartado: Help»Patents en su software, el archivo patents.txt en el soporte del mismo, o el Aviso sobre las Patentes de National Instruments (National Instruments Patent Notice) en ni.com/patents.

N at N ion ot a fo l In rd s is tru tri m bu en tio ts n Información del producto y soporte técnico mundial ni.com Oficinas internacionales Visite ni.com/niglobal para acceder a las páginas web de las oficinas internacionales, las cuales incluyen información actualizada de contacto, teléfonos de soporte técnico, direcciones de email y eventos actuales. Oficinas centrales de National Instruments Corporation 11500 North Mopac Expressway Austin, Texas 78759-3504

USA Tel: 512 683 0100

Para obtener información adicional de soporte, consulte el apéndice Información Adicional y Recursos. Para realizar comentarios a National Instruments sobre la documentación, consulte la página web de National Instruments Web ni.com/info e introduzca el código de información feedback.

Contenido Guía del estudiante A. B. C. D. E. F.

Certificación de NI................................................................................................v Descripción del curso............................................................................................v Lo que necesita para empezar ...............................................................................vi Instalación del software del curso.........................................................................vii Objetivos del curso ...............................................................................................vii Convenciones del curso ........................................................................................viii

Lección 1 Más allá del flujo de datos


A. Comunicación asíncrona.......................................................................................1-2 B. Colas .....................................................................................................................1-2 C. Programación orientada a eventos ........................................................................1-5

Lección 2 Implementando patrones de diseño A. B. C. D. E. F. G.

Patrones de diseño ................................................................................................2-2 Patrones de diseño simple.....................................................................................2-2 Patrones de diseño de bucles múltiples.................................................................2-8 Gestores de errores................................................................................................2-15 Generando códigos de error y mensajes ...............................................................2-18 Temporizar un patrón de diseño ...........................................................................2-20 Patrón de diseño variable global funcional..........................................................2-25

Lección 3 Control de la interfaz de usuario A. B. C. D.

Arquitectura del VI Server....................................................................................3-2 Nodos de Propiedad ..............................................................................................3-3 Nodos de Invocación ............................................................................................3-4 Referencias de control ..........................................................................................3-5

Lección 4 Técnicas de E/S de fichero A. B. C. D. E.

Comparando formatos de archivo.........................................................................4-2 Crear rutas de archivos y carpetas ........................................................................4-4 Lectura y escritura de archivos binarios ...............................................................4-6 Trabajar con archivos de texto y encabezados multicanal....................................4-12 Acceso de archivos TDMS en LabVIEW y Excel................................................4-17

© National Instruments | iii

Guía del estudiante Gracias por comprar el paquete del curso LabVIEW Core 2. Después de completar el curso, podrá empezar a desarrollar una aplicación. El manual del curso y el software adjunto se utilizan en el curso práctico de dos días LabVIEW Core 2. Puede aplicar la adquisición completa de este paquete de curso a la cuota de registro correspondiente, si se inscribe antes de 90 días desde la compra del paquete. Visite ni.com/training para consultar en línea la programación, el contenido, los centros de formación y la inscripción a la clase del curso.

A. Certificación de NI


El curso LabVIEW Core 2 forma parte de una serie de cursos diseñados para dominar LabVIEW y ayudarle a prepararse para el examen de Desarrollador Asociado Certificado de LabVIEW de NI. La siguiente ilustración muestra los cursos que forman parte de la serie de formación de LabVIEW. Consulte ni.com/training para obtener información adicional acerca de la certificación de NI. New User

Experienced User

Advanced User

LabVIEW Core 1*

LabVIEW Core 3*

Managing Software Engineering in LabVIEW

LabVIEW Connectivity

Advanced Architectures in LabVIEW

Courses

LabVIEW Core 2*

Object-Oriented Design and Programming in LabVIEW

Certifications

LabVIEW Performance Certified LabVIEW Developer Exam

Certified LabVIEW Architect Exam

LabVIEW Instrument Control

LabVIEW Real-Time 1

LabVIEW Real-Time 2

LabVIEW FPGA

LabVIEW DAQ and Signal Conditioning

Modular Instruments Series

Certified LabVIEW Associate Developer Exam Other Courses

*Core courses are strongly recommended to realize maximum productivity gains when using LabVIEW.

B. Descripción del curso El curso LabVIEW Core 2 le enseña conceptos, técnicas, características, VIs y funciones de programación de LabVIEW que puede utilizar para crear aplicaciones de prueba y medición, adquisición de datos, control de instrumentos, registro de datos, análisis de mediciones y generación de informes. Este manual del curso supone que está familiarizado con Windows, que tiene experiencia en escribir algoritmos en forma de diagramas de flujo o diagramas de bloques y que ha realizado el curso LabVIEW Core 1 o tiene una experiencia equivalente. Los manuales de ejercicios y del curso están divididos en lecciones, organizadas de este modo.

© National Instruments | v

Guía del estudiante

En el manual del curso, cada lección consta de lo siguiente: •

Una introducción que describe el objetivo de la lección y lo que aprenderá

•

Una descripción de los temas de la lección

•

Un cuestionario de resumen que prueba conceptos y conocimientos importantes desarrollados en la lección

En el manual de ejercicios, cada lección consta de lo siguiente: •

Un conjunto de ejercicios para reforzar esos temas

•

Algunas lecciones incluyen secciones de ejercicios opcionales y de retos o un conjunto de ejercicios adicionales para realizar si el tiempo lo permite. Para ver actualizaciones y correcciones del manual de ejercicios y del curso, consulte ni.com/info y escriba el Código de Información core2.


Nota

Varios ejercicios utilizan un dispositivo multifunción de adquisición de datos (DAQ) conectado a un Accesorio de Señales DAQ o BNC-2120 que contiene un sensor de temperatura, un generador de funciones y LEDs. Aunque no disponga de este hardware, puede realizar los ejercicios. Se ofrecen otras instrucciones para realizar los ejercicios sin hardware. También puede sustituir otro hardware por los mencionados anteriormente. Por ejemplo, puede utilizar otro dispositivo DAQ de National Instruments conectado a una fuente de señales, como un generador de funciones.

C. Lo que necesita para empezar

Antes de usar este manual del curso, debe tener todos estos elementos:



Ordenador ejecutando Windows 7/Vista/XP



Dispositivo DAQ multifunción configurado como Dev1 utilizando Measurement & Automation Explorer (MAX)



Accesorio de señales DAQ o BNC-2120, conectores y cable



LabVIEW Professional Development System 2012 o posterior



DAQmx 9.5.5 o posterior



CD del curso LabVIEW Core 2, desde donde instala las siguientes carpetas:

Directorio

Descripción

Exercises

Contiene los VIs utilizados en el curso

Solutions

Contiene los ejercicios del curso corregidos

vi | ni.com

Manual de Curso LabVIEW Core 2

D. Instalación del software del curso Complete estos pasos para instalar el software del curso. 1. Inserte el CD del curso en el ordenador. Aparecerán los cuadros de diálogo de LabVIEW Core 2 Course Setup 2. Haga clic en Install the course materials. 3. Siga las instrucciones en la pantalla para completar la instalación y configuración. Los archivos de ejercicios se encuentran en la carpeta \LabVIEW Core 2\ .


Nota Los nombres de carpetas entre corchetes angulares, como , hacen referencia a carpetas del directorio raíz de su ordenador.

E. Objetivos del curso

Este curso le prepara para hacer lo siguiente: •

Aplicar patrones de diseño comunes que utilicen notificadores, colas y eventos

•

Usar la programación de eventos de forma eficaz

•

Controlar programáticamente objetos de la interfaz de usuario

•

Evaluar formatos de E/S de ficheros binarios y utilizarlos en aplicaciones

•

Modificar código existente para mejorar la usabilidad

•

Preparar, crear y desplegar aplicaciones independientes

Este curso no describe nada de lo siguiente: •

Métodos de programación de LabVIEW tratados en el curso LabVIEW Core 1.

•

Cada VI, función u objeto integrado; consulte la Ayuda de LabVIEW para obtener información adicional acerca de las funciones de LabVIEW no descritas en este curso.

•

Desarrollar una aplicación completa para cualquier estudiante de la clase; consulte el NI Example Finder seleccionando Help»Find Examples, para ver ejemplos de VIs que puede utilizar e incorporar en los VIs que cree

© National Instruments | vii

Guía del estudiante

F. Convenciones del curso Los siguientes convenios aparecen en este manual del curso: »

El símbolo » le guía por los elementos de menú anidados y las opciones de cuadros de diálogo a una acción final. La secuencia Tools» Instrumentation»Find Instrument Drivers le guia a desplegar menú Tools , seleccionar Instrumentation , y finalmente seleccionar la opción Find Instrument Drivers. Este icono indica un consejo, que le alerta de recomendaciones. Este icono indica una nota, que le alerta de información importante.

negrita

cursiva

monospace


Este icono indica una precaución, para que tome precauciones y evite lesiones, pérdida de datos o una caída del sistema. El texto en negrita indica que debe seleccionar el software o hacer clic en él, como elementos de menú y opciones del cuadro de diálogo. El texto en negrita denota también las secciones de los cuadros de diálogo y etiquetas de hardware. El texto en cursiva indica variables, énfasis, una referencia cruzada o una introducción a un concepto clave. El texto en cursiva también indica texto que es un parámetro de sustitución para una palabra o un valor que debe proporcionar. El texto con esta fuente indica texto o caracteres que debe escribir con el teclado, secciones de código, ejemplos de programación y ejemplos de sintaxis. Esta fuente también se utiliza para los nombres propios de unidades de disco, rutas, directorios, programas, subprogramas, subrutinas, nombres de dispositivos, funciones, operaciones, variables, nombres de archivos y extensiones.

monospace bold

El texto en negrita con esta fuente indica los mensajes y las respuestas que el ordenador imprime automáticamente en la pantalla. Esta fuente también enfatiza líneas de código distintas de los otros ejemplos.

Platform

El texto con esta fuente indica una plataforma concreta y que el texto que le sigue se aplica sólo a esa plataforma.

viii | ni.com

1

Más allá del flujo de datos

Temas


Como usted aprendió en LabVIEW Core 1, LabVIEW es un lenguaje donde el flujo de datos determina el orden de ejecución de los elementos de un diagrama de bloques. Un nodo del diagrama de bloques se ejecuta cuando se reciben todas las entradas requeridas. Cuando se ejecuta un nodo, produce datos de salida y pasa los datos al siguiente nodo de la ruta del flujo de datos. El movimiento de los datos a través de los cables y nodos determina el orden de ejecución de los VIs y las funciones del diagrama de bloques. Este tipo de comunicación entre nodos se denomina comunicación síncrona.

A. Comunicación asíncrona B. Colas

C. Programación orientada a eventos

© National Instruments | 1-1

Lección 1


A. Comunicación asíncrona Aunque LabVIEW es un lenguaje de flujo de datos que utiliza cables para transferir datos entre funciones, hay situaciones en las que la comunicación asíncrona, o sin cables, es deseable. En esta lección aprenderás dos técnicas importantes para la comunicación asíncrona—colas para comunicación entre bucles paralelos y eventos para comunicación entre la interfaz de usuario y el diagrama de bloques.

B. Colas


Utilice colas para comunicar datos entre los bucles paralelos en LabVIEW. Una cola puede contener datos de cualquier tipo y además almacenar múltiples piezas de datos. De forma predeterminada las colas funcionan con la estrategia “primero en entrar, primero en salir”, en inglés First In First Out (FIFO). Por lo tanto, el primer dato de una cola es el primero en salir de ella. Use una cola cuando desee procesar todos los datos que contenga. Las variables resultan útiles en LabVIEW para pasar datos entre procesos paralelos. Sin embargo, cuando se usan variables a menudo es difícil sincronizar la transferencia de datos, que puede causar leer datos duplicados o perder datos. Adicionalmente, se debe tener cuidado para evitar las condiciones de carrera. Esta lección presenta las colas como métodos alternativos para pasar datos entre procesos paralelos. Los colas tienen ventajas respecto al uso de variables por la posibilidad de sincronizar la transferencia de datos.

Operaciones de cola

Utilice las funciones de operación de cola para crear y utilizar las colas en la comunicación de datos entre las distintas secciones del VI y otros VIs. Tabla 1-1 describe las funciones de operación de cola a utilizar en este curso. Tabla 1-1. Funciones de operación de cola

Funciones

Descripción

Dequeue Element

Elimina un elemento de la parte frontal de una cola y retorna este elemento.

Enqueue Element

Añade un elemento en la parte posterior de la cola.

Enqueue Element at Opposite End

1-2 | ni.com

Añade un elemento en la parte frontal de la cola.


Tabla 1-1. Funciones de operación de cola (Continuación)

Funciones

Descripción

Get Queue Status

Retorna información sobre el estado actual de una cola, tales como el número de elementos actualmente en la cola.

Retorna la referencia a una cola.

Release Queue

Libera la referencia de una cola.


Obtain Queue

Consulte el tema Queue Operations Functions en la Ayuda de LabVIEW para obtener una lista completa y una descripción de las operaciones de cola. Cuando se usa el patrón de diseño productor/consumidor, las colas pasan datos y sincronizan los bucles como se muestra en la figura 1-1. Figura 1-1. Patrón de diseño (datos) del productor/consumidor usando colas


Lección 1


La cola se crea antes de que los bucles empiecen a usar la función Obtain Queue. El bucle productor usa la función Enqueue Element para añadir datos a la cola. El bucle consumidor elimina los datos de la cola utilizando la función Dequeue Element. El bucle consumidor no se ejecuta hasta que haya datos en la cola. Una vez que el VI ha terminado de usar las colas, la función Release Queue las libera. Cuando se libera la cola, la función Dequeue Element genera un error, deteniendo efectivamente el bucle consumidor. Así no hay por qué utilizar una variable para detener los bucles. Estas son las ventajas de usar colas en el patrón de diseño productor / consumidor: Ambos bucles se sincronizan con el bucle productor. El bucle consumidor sólo se ejecuta cuando haya datos en la cola.

•

Puede utilizar colas para crear datos en cola disponibles globalmente, eliminando la posibilidad de pérdida de datos en la cola cuando se añadan datos nuevos a ella.

•

El uso de colas crea código eficaz. No necesita sondear para determinar cuándo habrá datos disponibles desde el bucle productor.


•

Las colas también son útiles para albergar solicitudes de estado en una máquina de estados. En la implementación de una máquina de estados que ha aprendido, si se solicitan dos estados simultáneamente, puede perder uno de ellos. Una cola almacena la segunda solicitud de estado y la ejecuta cuando ha terminado la primera.

Caso de Estudio: Proyecto de Estación Meteorológica El proyecto de la estación meteorológica adquiere datos de temperatura y de velocidad del viento y los analiza para determinar si la situación requiere una alarma. Si la temperatura es demasiado alta o baja, alerta al usuario de un peligro de golpe de calor o congelación. También controla la velocidad del viento para generar una alarma de fuerte viento en su caso. El diagrama de bloques consta de dos bucles paralelos, que se sincronizan utilizando colas. Un bucle adquiere datos para la temperatura y la velocidad del viento y el otro analiza los datos. Los bucles del diagrama funcional usan el patrón de diseño productor / consumidor y pasan los datos a través de la cola. Las colas ayudan a procesar cada lectura adquirida con el DAQ Assistant. El código para adquirir la temperatura y la velocidad del viento se sitúa en el bucle productor. El código que contiene la máquina de estados para analizar las condiciones de temperatura-tiempo se encuentra en el caso sin error del bucle consumidor. El código que utiliza una cola es más legible y eficiente que el que usa sólo arquitectura de la máquina de estados. La función Obtain Queue crea la referencia de la cola. El bucle productor usa la función Enqueue Element para añadir datos obtenidos del DAQ Assistant a la cola. El bucle consumidor usa la función Dequeue Element para obtener los datos de la cola y suministrarlos a la máquina de estados para su análisis. La función Release Queue marca el final de la cola destruyéndola. El uso de colas también elimina la necesidad de una variable compartida para detener los bucles, porque la función Dequeue Element detiene el bucle consumidor cuando se libera una cola.

1-4 | ni.com


La figura 1-2 muestra el diagrama de bloques que consta de un bucle productor y consumidor. Las funciones de cola permiten la transferencia de datos y la sincronización entre los bucles.


Figura 1-2. Transferencia de datos y sincronización de bucles paralelos usando colas

C. Programación orientada a eventos

Programación orientada a eventos es un método de programación, donde el programa espera que se produzca un acontecimiento antes de ejecutar una o varias funciones. Las características de programación orientada a eventos amplían el entorno de flujo de datos de LabVIEW, para permitir que el usuario interactúe directamente con el panel frontal y permitir otra actividad asíncrona que influya más en la ejecución del diagrama de bloques.

Eventos

¿Qué son los eventos?

Un evento es una notificación asíncrona de que algo ha ocurrido. Los eventos pueden provenir de la interfaz de usuario, E/S externa u otras partes del programa. Los eventos de la interfaz de usuario son clics del ratón, pulsaciones de teclas, etc. Los eventos de E/S externas son temporizadores o triggers de hardware que señalan cuándo se completa la adquisición de datos o cuándo ocurre una condición de error. Otros tipos de eventos pueden generarse programáticamente y utilizarse para comunicarse con distintas partes del programa. LabVIEW admite eventos generados por la interfaz de usuario o programáticamente. LabVIEW también admite eventos generados por ActiveX y .NET, que son eventos de E/S externas. En un programa orientado a eventos, los eventos que ocurren en el sistema influyen directamente en el flujo de ejecución. Por el contrario, un programa de procedimiento se ejecuta en un orden predeterminado y secuencial. Los programas orientados a eventos suelen incluir un bucle que espera que ocurra un evento, ejecuta el código para responder al evento y se vuelve a iterar para esperar al siguiente evento. El modo en que el programa responde a cada evento depende del


Lección 1


código escrito para ese evento. El orden en que se ejecuta un programa orientado a eventos depende de qué eventos ocurran y en qué orden ocurran. Algunas secciones del programa podrían ejecutarse con frecuencia porque los eventos que controlan ocurren frecuentemente. Quizá no se ejecuten otras secciones del programa porque los eventos nunca ocurren.

Sondeo vs estructura evento Use eventos de interfaz de usuario en LabVIEW para sincronizar acciones del usuario en el panel frontal con la ejecución del diagrama de bloques. Los eventos permiten ejecutar un caso de control de eventos específico cada vez que un usuario realice una acción concreta. Sin los eventos, el diagrama de bloques debe sondear el estado de objetos del panel frontal en un bucle, comprobando si ha ocurrido algún cambio. Sondear el panel frontal requiere una cantidad de tiempo significativa de la CPU y quizá no detecte cambios si ocurren con demasiada rapidez.


Al usar eventos para responder a acciones específicas del usuario, no necesita sondear el panel frontal para determinar qué acciones realizó el usuario. LabVIEW notifica activamente al diagrama de bloques cada vez que ocurre una interacción que especificó. El uso de eventos reduce los requisitos de CPU del programa, simplifica el código del diagrama de bloques y garantiza que el diagrama de bloques pueda responder a todas las interacciones que realice el usuario. Use eventos generados programáticamente para comunicarse entre varias partes del programa que no tengan dependencia del flujo de datos. Los eventos generados programáticamente comparten muchas ventajas con los eventos de la interfaz de usuario y pueden compartir el mismo código de control de eventos, lo que facilita la implementación de arquitecturas avanzadas, como las máquinas de estados con colas que usan eventos.

Componentes de la estructura Event

Use la estructura Event, mostrada a continuación, para controlar eventos en un VI.

La estructura Event funciona como una estructura Case con una función Wait on Notification integrada. La estructura Event puede tener varios casos, cada uno de los cuales es una rutina de control de eventos distinta. Puede configurar cada caso para controlar uno o más eventos, pero sólo uno de estos eventos puede ocurrir a la vez. Cuando se ejecuta la estructura Event, espera hasta que ocurra uno de los eventos configurados y después ejecuta el caso correspondiente a ese evento. La estructura Event completa su ejecución tras controlar exactamente un evento. No hace implícitamente un bucle para controlar varios eventos. Como una función Wait on Notification, la estructura Event puede superar su límite de tiempo mientras espera una notificación de evento. Cuando esto ocurre, se ejecuta un caso Timeout específico.

1-6 | ni.com


La etiqueta del selector de evento en la parte superior de la estructura Event indica que eventos hacen que el caso que se muestra actualmente sea ejecutado.

Vea otros casos de eventos haciendo clic en la flecha abajo junto al nombre del caso y seleccionando otro caso del menú contextual. El terminal Timeout de la esquina superior izquierda de la estructura Event especifica el número de milisegundos que hay que esperar antes de que un evento supere el tiempo límite.


El valor predeterminado es -1, que especifica esperar indefinidamente hasta que ocurra un evento. Si cablea un valor al terminal Timeout, debe proporcionar un caso Timeout. El Event Data Node actúa de igual modo que la función Unbundle By Name.

Este nodo se acopla al borde interior izquierdo de cada caso de evento. El nodo identifica los datos que proporciona LabVIEW cuando ocurre un evento. Puede cambiar el tamaño de este nodo verticalmente para añadir más elementos de datos y puede configurar éstos en el nodo para acceder a cualquier elemento de datos de evento. El nodo proporciona varios datos en cada caso de la estructura Event en función de qué eventos configure para que controle ese caso. Si configura que un solo caso controle varios eventos, el Event Data Node proporciona sólo los datos de evento que son comunes para todos los eventos configurados para ese caso. El Event Filter Node es similar al Event Data Node.

Este nodo se acopla al borde interior derecho de los casos de eventos de filtrado. El nodo identifica el subconjunto de datos disponibles en el Event Data Node que puede modificar el caso de evento. El nodo muestra varios datos en función de qué eventos configure para que controle ese caso. De forma predeterminada, estos elementos se encuentran en los elementos de datos correspondientes del Event Data Node. Si no cablea un valor a un dato de un Event Filter Node, ese dato permanecerá inalterado. Consulte la sección Eventos de notificación y de filtrado de esta lección para obtener información adicional acerca de los eventos de filtrado. Puede acceder a los terminales de eventos dinámicos haciendo clic con el botón derecho en la estructura Event y seleccionando Show Dynamic Event Terminals en el menú contextual.


Lección 1


Estos terminales sólo se usan para el registro de eventos dinámicos. Consulte el tema Using Events in LabVIEW de la Ayuda de LabVIEW para obtener información sobre el uso de estas terminales. Al igual que una estructura Case, la estructura Event admite túneles. Sin embargo, de forma predeterminada no tiene que cablear túneles de salida de la estructura Event en cada caso. Todos los túneles sin cablear usan el valor predeterminado para el tipo de dato de túnel. Haga clic con el botón derecho en un túnel y deseleccione Use Default If Unwired en el menú contextual para volver al comportamiento de la estructura Case predeterminada en el que debe cablear los túneles en todos los casos. También puede configurar los túneles para cablear los túneles de entrada y salida automáticamente en los casos sin cablear. Nota


Consulte la Ayuda de LabVIEW para obtener información de los valores predeterminados para cada tipo de datos.

Uso de eventos en LabVIEW

LabVIEW puede generar numerosos eventos distintos. Para evitar generar eventos indeseados, use el registro de eventos para especificar qué eventos desea que le notifique LabVIEW. LabVIEW admite dos modelos de registro de eventos: estático y dinámico. El registro estático permite especificar qué eventos del panel frontal de un VI desea controlar en cada caso de la estructura Event en el diagrama de bloques de ese VI. LabVIEW registra estos eventos automáticamente cuando se ejecuta el VI, por lo que la estructura Event empieza a esperar eventos en cuanto se ejecuta el VI. Cada evento se asocia con un control del panel frontal del VI, la ventana del panel frontal del VI en conjunto o la aplicación de LabVIEW. No puede configurar estáticamente una estructura Event para controlar eventos para el panel frontal de otro VI. La configuración es estática porque no puede cambiar en el tiempo de ejecución qué eventos controla la estructura Event. El registro de eventos dinámico evita las limitaciones del registro estático integrando el registro de eventos con el VI Server, que permite usar referencias de aplicación, VI y control para especificar en el tiempo de ejecución los objetos para los que desea generar eventos. El registro dinámico ofrece más flexibilidad en el control de qué eventos genera LabVIEW y cuándo los genera. Sin embargo, el registro dinámico es más complejo que el estático porque requiere usar referencias de VI Server con funciones del diagrama de bloques para registrar y desregistrar eventos en lugar de controlar el registro automáticamente usando la información que configuró en la estructura Event. En general, LabVIEW genera eventos de interfaz de usuario sólo como resultado de la interacción directa del usuario con el panel frontal activo. LabVIEW no genera eventos, como Value Change, cuando usa variables compartidas, variables globales, variables locales, etc. Sin embargo, puede usar la propiedad Value (Signaling) para generar un evento Value Change programáticamente. En muchos casos, se pueden usar eventos generados programáticamente en lugar de colas. Nota

1-8 | ni.com


Los datos de evento que proporciona un evento de LabVIEW siempre incluyen una marca de hora, una enumeración que indica qué evento ocurrió, así como una referencia de VI Server al objeto que activó el evento. La marca de hora es un contador de milisegundos que puede usar para calcular el tiempo transcurrido entre dos eventos o para determinar el orden en que sucedieron. La referencia al objeto que generó el evento se escribe estrictamente en la clase de VI Server de ese objeto. Los eventos se agrupan en clases según el tipo de objeto que genera el evento, como una aplicación, VI o control. Si un solo caso controla varios eventos para objetos de distintos tipos de VI Server, el tipo de referencia es la clase primaria común de todos los objetos. Por ejemplo, si configura un solo caso en la estructura Event para controlar eventos en un control numérico y un control de rampa de color, el tipo de referencia de control del origen del evento es numérico porque los controles numérico y rampa de color están en la clase Numeric. Si se registra para el mismo evento en la clase VI y Control, LabVIEW genera el evento VI primero. Los clusters son los únicos objetos contenedores para los que puede generar eventos. LabVIEW genera eventos Control para clusters, antes de generar eventos para los objetos que contienen, salvo en el caso del evento Value Change. El evento Value Change genera el evento en un elemento del cluster, después en el cluster mismo. Si el caso de la estructura Event de un evento VI o de un evento Control en un objeto de un contenedor desecha el evento, LabVIEW no generará más eventos.


Nota

Cada estructura Event y función Register For Events del diagrama de bloques posee una cola que usa LabVIEW para almacenar eventos. Cuando ocurre un evento, LabVIEW coloca una copia suya en cada cola registrada para él. Una estructura Event controla todos los eventos de su cola y los eventos de la colas de cualquier función Register For Events que cableó a los terminales de eventos dinámicos de la estructura Event. LabVIEW usa estas colas para que los eventos se entreguen correctamente a cada estructura Event registrada en el orden en que ocurren los eventos. De forma predeterminada, cuando un evento entra en una cola, LabVIEW bloquea el panel frontal que contiene el objeto que generó ese evento. LabVIEW mantiene bloqueado el panel frontal hasta que todas las estructuras Event terminen de procesar el evento. Mientras está bloqueado el panel frontal, LabVIEW no procesa la actividad del panel frontal sino que coloca las interacciones en un búfer y las controla cuando se desbloquea el panel frontal. Por ejemplo, un usuario podría prever que un caso de evento lance una aplicación que requiera introducir texto. Como el usuario ya sabe que hay que escribir texto, podría empezar a escribir antes de que la aplicación aparezca en el panel frontal. Si está habilitada la opción Lock front panel (defer processing of user action) until this event case completes, una vez que se lance la aplicación y aparezca en el panel frontal, procesará las pulsaciones de teclas en el orden en que ocurrieron. Si está inhabilitada la opción Lock front panel (defer processing of user action) until this event case completes, las pulsaciones de teclas podrían procesarse en otra parte del panel frontal, ya que LabVIEW no pone en cola su ejecución para que dependa de que termine el caso de evento. El bloqueo del panel frontal no afecta a ciertas acciones, como mover la ventana, interactuar con las barras de desplazamiento y hacer clic en el botón Abort.


Lección 1


LabVIEW puede generar eventos aunque ninguna estructura Event esté esperando para controlarlos. Como la estructura Event controla sólo un evento cada vez que se ejecuta, coloque la estructura Event en un bucle While para que ésta pueda controlar todos los eventos que ocurran. Si no se ejecuta una estructura Event para controlar un evento y se habilita el bloqueo del panel frontal, la interfaz de usuario del VI no responderá. Si esto ocurre, haga clic en el botón Abort para detener el VI. Puede desactivar el bloqueo del panel frontal haciendo clic con el botón derecho en la estructura Event y desmarcando la casilla de verificación Lock front panel (defer processing of user action) until this event case completes en el cuadro de diálogo Edit Events. No puede desactivar el bloqueo del panel frontal para eventos de filtrado.

Precaución

Registro de eventos estáticos


El registro de eventos estáticos sólo se permite para eventos de la interfaz de usuario. Use el cuadro de diálogo Edit Events para configurar una estructura Event que controle un evento registrado estáticamente. Seleccione el origen del evento, que puede ser la aplicación, el VI o un solo control. Seleccione un evento que pueda generar el origen del evento, como Panel Resize, Value Change, etc. Modifique el caso para controlar los datos de evento conforme a los requisitos de la aplicación. LabVIEW registra estáticamente eventos de forma automática y transparente, cuando ejecuta un VI que contiene una estructura Event. LabVIEW genera eventos para un VI sólo mientras se está ejecutando el VI o cuando otro VI en ejecución llama al VI como un subVI. Cuando ejecuta un VI, LabVIEW configura ese VI de alto nivel y la jerarquía de subVIs a los que llama el VI en su diagrama de bloques para un estado de ejecución llamado reservado. No puede modificar un VI ni hacer clic en el botón Run mientras el VI está en estado reservado, porque se puede llamar al VI como un subVI en cualquier momento mientras su VI primario se ejecuta. Cuando LabVIEW configura un VI al estado reservado, automáticamente registra los eventos que configuró estáticamente en todas las estructuras Event del diagrama de bloques de ese VI. Cuando el VI de alto nivel termina la ejecución, LabVIEW lo configura (y su jerarquía de subVI) al estado de ejecución inactivo y automáticamente desregistra los eventos.

Configuración de eventos Antes de configurar eventos para que los controle la estructura Event, consulte el tema Caveats and Recommendations when Using Events in LabVIEW de la Ayuda de LabVIEW. Siga estos pasos para configurar un caso de estructura Event para controlar un evento. 1. (Opcional) Si desea configurar la estructura Event para que controle el evento de un usuario, un control booleano de un control de botones de radio o un evento de interfaz de usuario que se genera basándose en una referencia a una aplicación, VI o control, primero debe registrar dinámicamente ese evento. Consulte el tema Dynamically Registering Events de la Ayuda de LabVIEW para obtener información adicional acerca de usar eventos dinámicos. 2. Haga clic con el botón derecho en el borde de la estructura Event y seleccione Edit Events Handled by This Case en el menú contextual para ver el cuadro de diálogo Edit Events y

1-10 | ni.com


modificar el caso actual. También puede seleccionar Add Event Case en el menú contextual para crear un nuevo caso. 3. Especifique un origen de evento en el panel Event Sources. 4. Seleccione el evento que desee configurar para el origen de evento, como Key Down, Timeout o Value Change en la lista Events. Cuando seleccione un origen de evento dinámico en la lista Event Sources, la lista Events mostrará ese evento. Es el mismo evento que seleccionó cuando registró el evento. Si ha registrado eventos dinámicamente y ha cableado event reg refnum out en el terminal de eventos dinámicos, los orígenes aparecerán en la sección Dynamic.


5. Si desea añadir eventos adicionales para que los gestione el caso actual, haga clic en el botón + y repita los pasos 3 y 4 para especificar cada evento adicional. La sección Event Specifiers de la parte superior del cuadro de diálogo muestra todos los eventos que controlará el caso. Cuando hace clic en un elemento de esta lista, la sección Event Sources se actualiza para resaltar el origen de evento que seleccionó. Puede repetir los pasos 3 y 4 para redefinir cada evento o hacer clic en el botón X para eliminar el evento seleccionado. 6. Haga clic en el botón OK para guardar la configuración y cerrar el cuadro de diálogo. Los casos de eventos que configuró aparecerán como opciones de selección en la etiqueta del selector de eventos en la parte superior de la estructura Event y el nodo Event Data mostrará los datos comunes a todos los eventos controlados en ese caso. 7. (Opcional) Puede usar un evento Timeout para configurar una estructura Event para que espere un tiempo determinado a que ocurra un evento. Cablee un valor al terminal Timeout en la parte superior izquierda de la estructura Event para especificar el número de milisegundos que debe esperar la estructura Event a que ocurra un evento antes de generar un evento Timeout. El valor predeterminado del terminal Timeout es -1, que especifica esperar indefinidamente hasta que ocurra un evento. 8. Repita los pasos 1 al 6 para cada caso de evento que desee configurar.

Eventos de notificación y de filtrado

Los eventos de notificación indican que ya ha ocurrido una acción del usuario, como cambiar el valor de un control. Use eventos de notificación para responder a un evento cuando haya ocurrido y LabVIEW lo haya procesado. Puede configurar cualquier número de estructuras Event para responder al mismo evento de notificación en un objeto concreto. Cuando ocurre el evento, LabVIEW envía una copia de ésta a cada estructura Event configurada para controlar el evento en paralelo. Los eventos de filtrado le informan de que el usuario ha realizado una acción antes de que LabVIEW la procese, lo que permite personalizar el modo en que el programa responde a interacciones con la interfaz de usuario. Use eventos de filtrado para participar en el control del evento, posiblemente invalidando el comportamiento predeterminado del evento. En un caso de estructura Event de un evento de filtrado, puede validar o cambiar los datos del evento antes de que LabVIEW termine de procesarlo, o puede desechar el evento totalmente para evitar que el cambio afecte al VI. Por ejemplo, puede configurar una estructura Event para desechar el evento Panel Close?, que evitará que el usuario cierre interactivamente el panel frontal del VI.


Lección 1


Los eventos de filtrado tienen nombres que terminan con un signo de interrogación, como Panel Close?, para ayudar a distinguirlos de eventos de notificación. La mayoría de los eventos de filtrado tienen un evento de notificación asociado con el mismo nombre, pero sin el interrogante, que genera LabVIEW tras el evento de filtrado si ningún caso de evento desechó el evento. Por ejemplo, puede usar los eventos de filtrado Mouse Down? y Shortcut Menu Activation? para mostrar un menú contextual cuando haga clic con el botón izquierdo en un control. Para realizar esta acción, modifique los datos que devuelve el campo de datos de evento Button del evento de filtrado Mouse Down?. El valor del botón izquierdo del ratón es 1 y el valor del botón derecho del ratón es 2. Para ver el menú contextual cuando hace clic con el botón izquierdo en un control, cambie el campo de datos de evento Button a 2, para que LabVIEW considere el clic con el botón izquierdo igual que con el derecho.


Al igual que con los eventos de notificación, puede configurar cualquier número de estructuras Event para responder al mismo evento de filtrado en un objeto concreto. Sin embargo, LabVIEW envía eventos de filtrado secuencialmente a cada estructura Event configurada para el evento. El orden en que LabVIEW envía el evento a cada estructura Event depende de en qué orden se registraran los eventos. Cada estructura Event debe completar su caso de evento para el evento en concreto, antes de que LabVIEW pueda notificar la siguiente estructura Event. Si una estructura Event cambia cualquiera de los datos del evento, LabVIEW pasa los datos cambiados a las siguientes estructuras Event de la cadena. Si una estructura Event de la cadena desecha el evento, LabVIEW no pasa éste a las estructuras Event que queden en la cadena. LabVIEW completa el procesamiento de la acción del usuario que activó el evento sólo cuando todas las estructuras Event configuradas controlen el evento sin desecharlo. National Instruments recomienda usar eventos de filtrado sólo cuando desee intervenir en el control de la acción del usuario, desechando el evento o modificando los datos del evento. Si sólo desea saber que el usuario realizó una acción concreta, use eventos de notificación. Nota

Los casos de la estructura Event que controlan eventos de filtrado tienen un Event Filter Node. Puede cambiar los datos de evento cableando nuevos valores a estos terminales. Si no cablea un valor al dato del Event Filter Node, el valor predeterminado será el valor que devuelva el elemento correspondiente del Event Data Node. Puede desechar completamente cualquier evento cableando un valor TRUE al terminal Discard?. Nota Un solo caso de la estructura Event no puede controlar eventos de notificación y de filtrado. Un caso puede controlar varios eventos de notificación, pero solo puede controlar varios eventos de filtrado si los datos del evento son idénticos para todos los eventos.

1-12 | ni.com


Consulte la sección Uso de eventos en LabVIEW de esta lección para obtener información adicional acerca del registro de eventos. En el cuadro de diálogo Edit Events, los eventos de notificación se indican con una flecha verde, mientras que los eventos de filtrado tienen una roja. Consejo

Ejemplo de eventos


La figura 1-3 muestra una estructura Event configurada con el evento Menu Selection (User). Este VI usa la estructura Event para capturar selecciones de menú realizadas con el menú definido por el usuario y llamado sample.rtm. El ItemTag devuelve el elemento del menú que se seleccionó y MenuRef devuelve el refnum a la barra de menús. Esta información se pasa a la función Get Menu Item Info. Consulte examples\general\uievents.llb para ver más ejemplos de uso de eventos. Figura 1-3. Evento Menu Selection (User)

Nota Si usa la función Get Menu Selection con una estructura Event configurada para controlar el mismo elemento de menú, la estructura Event tiene prioridad, y LabVIEW ignora la función Get Menu Selection. En cualquier VI, use la estructura Event o la función Get Menu Selection para controlar eventos de menú, no ambas.

Advertencias y recomendaciones

La siguiente lista describe algunas de las advertencias y recomendaciones que hay que considerar al incorporar eventos en aplicaciones de LabVIEW. •

Evite utilizar una estructura Event fuera de un bucle. LabVIEW puede generar eventos aunque ninguna estructura Event esté esperando para controlarlos. Como la estructura Event controla sólo un evento cada vez que se ejecuta, coloque la estructura Event en un bucle While que se termine cuando el VI ya no esté interesado en eventos y para que ésta pueda controlar todos los eventos que ocurran.

•

Recuerde leer el terminal de un control booleano bloqueado en su caso de evento Value Change. Cuando active un evento en un control booleano configurado con una acción mecánica de bloqueo, el control booleano no se reinicia a su valor predeterminado hasta que el diagrama de bloques lea el terminal en el control booleano. Debe leer el terminal dentro del caso de evento para que la acción mecánica funcione correctamente.


Lección 1

•


Evite colocar dos estructuras Event en un bucle. National Instruments recomienda que coloque sólo una estructura Event en un bucle. Cuando ocurre un evento en esta configuración, la estructura Event gestiona el evento, el bucle se itera y la estructura Event espera a que ocurra el siguiente evento. Si coloca dos estructuras Event en un solo bucle, éste no puede iterarse hasta que ambas estructuras Event gestionen un evento. Si ha habilitado el bloqueo del panel frontal para las estructuras Event, la interfaz de usuario del VI quizá no responda, en función de cómo interactúe el usuario con el panel frontal.


Consulte el tema Caveats and Recommendations when Using Events in LabVIEW de la Ayuda de LabVIEW para ver más advertencias y recomendaciones cuando utilice eventos en LabVIEW.

1-14 | ni.com


Autorrevisión: Cuestionario 1. ¿Cuál de los siguientes elementos almacena temporalmente datos? a. Colas b. Eventos c. Variables locales

2. Una los siguientes elementos: Destruye la referencia de la cola


Obtain Queue

Get Queue Status

Asigna el tipo de datos de la cola

Release Queue

Añade un elemento a la parte posterior de la cola

Enqueue Element

Determina el número de elementos actualmente en cola

3. ¿Cuáles de los siguientes elementos son tipos de datos válidos para colas? a. Cadena de caracteres b. Numérico c. Enumerar d. Array de booleanos e. Cluster de una cadena de caracteres y un valor numérico

4. La estructura Event gestiona sólo un evento cada vez que se ejecuta. a. Verdadero b. Falso




Autorrevisión: Respuestas 1. ¿Cuál de los siguientes elementos almacena temporalmente datos? a. Colas b. Eventos c. Variables locales

2. Una los siguientes elementos: Asigna el tipo de datos de la cola


Obtain Queue

Get Queue Status

Determina el número de elementos actualmente en cola

Release Queue

Destruye la referencia de la cola

Enqueue Element

Añade un elemento a la parte posterior de la cola

3. ¿Cuáles de los siguientes elementos son tipos de datos válidos para colas? a. Cadena de caracteres b. Numérico

c. Enumerar d. Array de booleanos e. Cluster de una cadena de caracteres y un valor numérico

4. La estructura Event gestiona sólo un evento cada vez que se ejecuta. a. Verdadero b. Falso


Lección 1



Notas

1-18 | ni.com

Implementando patrones de diseño

2

Puede desarrollar mejores programas en LabVIEW y en otros lenguajes de programación si sigue técnicas de programación sistemáticas. Los patrones de diseño representan técnicas que han resultado siempre útiles. Para facilitar el desarrollo, LabVIEW incluye plantillas para varios patrones de diseño comunes. Esta lección describe dos tipos de patrones de diseño de programación: bucles simples y bucles múltiples.


Los patrones de diseño de bucle simple incluyen el VI simple, el VI general y la máquina de estados. Los patrones de diseño de múltiples bucles son el VI de bucles paralelos, el maestro/esclavo y el productor/consumidor. Comprender el uso apropiado de cada patrón de diseño ayuda a crear VIs de LabVIEW más eficientes.

Temas

A. Patrones de diseño

B. Patrones de diseño simple

C. Patrones de diseño de bucles múltiples D. Gestores de errores

E. Generando códigos de error y mensajes F. Temporizar un patrón de diseño

G. Patrón de diseño variable global funcional


Lección 2


A. Patrones de diseño Los patrones de diseño de aplicaciones representan implementaciones y ténicas de código de LabVIEW que son soluciones para problemas concretos en el diseño de software. Los patrones de diseño normalmente evolucionan gracias a los esfuerzos de muchos desarrolladores y se ajustan para conseguir simplicidad, mantenibilidad y legibilidad. Los patrones de diseño representan las técnicas que han resultado siempre útiles. Además, a medida que gana aceptación un modelo, resulta más fácil de reconocer, lo que le ayuda a leer y realizar cambios en el código.

B. Patrones de diseño simple


Usted aprendió a diseñar tres tipos distintos de patrones de diseño en el curso LabVIEW Core 1: la arquitectura simple, la arquitectura general y la máquina de estados.

Patrones de diseño de VI simple

Para realizar cálculos o mediciones rápidas en el laboratorio, no necesita una arquitectura complicada. Su programa podría constar de un solo VI que realice una medición o un cálculo y muestre los resultados o los grabe en el disco. El patrón de diseño del VI simple normalmente no requiere una acción de inicio o parada específica por parte del usuario. El usuario sólo hace clic en el botón Run. Use esta arquitectura para aplicaciones sencillas o para componentes funcionales dentro de aplicaciones más grandes. Puede convertir estos VIs simples en subVIs que use como bloques de construcción para aplicaciones más grandes. La figura 2-1 muestra el diagrama de bloques del VI Determine Warnings, que era el proyecto del curso LabVIEW Core 1. Este VI ejecuta una sola tarea: determina qué alarma generar en función de un conjunto de entradas. Puede utilizar este VI como un subVI cuando tenga que determinar el nivel de alarma. Observe que el VI de la figura 2-1 no contiene acciones de inicio o parada por parte del usuario. En este VI todos los objetos del diagrama de bloques se conectan mediante el flujo de datos. Puede determinar el orden general de las operaciones siguiendo el flujo de datos. Por ejemplo, la función Not Equal no se puede ejecutar hasta que se hayan ejecutado las funciones Greater Than or Equal, Less Than or Equal y ambas funciones Select.

2-2 | ni.com


Figura 2-1. Arquitectura del VI simple


Patrón de diseño del VI general

Un patrón de diseño de VI general tiene tres fases principales: arranque, aplicación principal y cierre. Cada una de estas fases puede contener código que usa otro tipo de patrón de diseño. •

Arranque: inicializa el hardware, lee la información de configuración de los archivos o solicita al usuario ubicaciones de archivos de datos.

•

Aplicación principal: consta de al menos un bucle que se repite hasta que el usuario decida salir del programa o éste termine por otras razones, como la finalización de E/S.

•

Cierre: cierra archivos, escribe información de configuración en el disco o restablece E/S al estado predeterminado.

La figura 2-2 muestra el patrón de diseño del VI general.

Figura 2-2. Patrón de diseño del VI general

En la figura 2-2, los cables del cluster de error controlan el orden de ejecución de las tres secciones. El bucle While no se ejecuta hasta que el VI Start Up termine de ejecutarse y devuelva los datos del cluster de error. Como consecuencia, el VI Shut Down no puede ejecutarse hasta que termine la aplicación principal del bucle While y los datos del cluster de error abandonen el bucle.


Lección 2


La mayoría de los bucles requieren una función Wait, especialmente si ese bucle monitoriza la interacción del usuario con el panel frontal. Sin la función Wait, el bucle podría ejecutarse continuamente y usar todos los recursos del sistema. La función Wait obliga al bucle a ejecutarse asíncronamente aunque especifique 0 milisegundos como periodo de espera. Si las operaciones del bucle principal reaccionan a las entradas del usuario, puede aumentar el periodo de espera a un nivel aceptable para los tiempos de reacción. Una espera de 100 a 200 ms suele ser buena porque la mayoría de los usuarios no puede detectar ese retardo entre hacer clic en un botón del panel frontal y la ejecución del evento siguiente. Consejo


Para aplicaciones simples, el bucle de la aplicación principal es obvio y contiene código que utiliza el patrón de diseño del VI simple. Cuando la aplicación incluye interfaces de usuario complicadas o varias tareas como acciones del usuario, triggers de E/S, etc., la fase de la aplicación principal se complica más.

Patrón de diseño de máquina de estados (Por sondeo) El patrón de diseño de máquina de estados es una modificación del patrón de diseño general. Normalmente tiene una fase de arranque y de cierre. Sin embargo, la fase de la aplicación principal consta de una estructura Case embebida en el bucle. Esta arquitectura permite ejecutar código diferente cada vez que se ejecuta el bucle, en función de alguna condición. Cada caso define un estado de la máquina, de ahí el nombre máquina de estados. Use este patrón de diseño para VIs que se dividan fácilmente en varias tareas más simples, como VIs que actúan como una interfaz de usuario. Una máquina de estados en LabVIEW consta de un bucle While, una estructura Case y un registro de desplazamiento. Cada estado de la máquina de estados es un caso distinto en la estructura Case. Debe colocar los VIs y el resto de código que el estado deba ejecutar dentro del caso apropiado. Un registro de desplazamiento almacena el estado que debe ejecutarse en la siguiente iteración del bucle. La figura 2-3 muestra el diagrama de bloques de un VI de máquina de estados con cinco estados. La figura 2-4 muestra los otros casos, o estados, de la máquina de estados. Figura 2-3. Máquina de estados con estado de arranque

2-4 | ni.com



Figura 2-4. Estados Idle (predeterminado), Event 1 y Event 2

En el patrón de diseño de máquina de estados, usted diseña la lista de posibles tareas, o estados, y después los asigna a cada caso. Para el VI del ejemplo anterior, los posibles estados son Startup, Idle, Event 1 y Event 2. Una constante de enumeración guarda los estados. Cada estado tiene su propio caso en la estructura Case. El resultado de un caso determina qué caso ejecutar después. El registro de desplazamiento almacena el valor que determina el próximo caso a ejecutar. El patrón de diseño de máquina de estados puede hacer el diagrama de bloques mucho más pequeño y, por lo tanto, más fácil de leer y de depurar. Otra ventaja de la arquitectura de la máquina de estados es que cada caso determina el siguiente estado, a diferencia de las estructuras Sequence, que deben ejecutar cada marco secuencialmente. Una desventaja del patrón de diseño de máquina de estados es que con el enfoque del ejemplo anterior, es posible saltar estados. Si se llama a dos estados de la estructura a la vez, este modelo gestiona sólo uno de ellos mientras que el segundo no se ejecuta. Saltar estados puede producir errores difíciles de depurar porque son complicados de reproducir. Versiones más complejas del patrón de diseño de la máquina de estados contienen código adicional que crea una cola de eventos, o estados, para que no se pierda un estado. Consulte la lección 1, Más allá del flujo de datos, para obtener información adicional acerca de las máquinas de estados basadas en colas.


Lección 2


Patrón de diseño de máquina de estados (Basada en eventos) El patrón de diseño de la máquina de estados basada en sondeo, monitorea la actividad en el panel frontal usando técnicas estándar de flujo de datos. Una máquina de estados basada en eventos, combina el poder de la interacción del usuario en una interfaz de usuario de un controlador de eventos con la flexibilidad de transición de una máquina de estados. Debido a que esta combinación es tan útil para una amplia gama de aplicaciones, LabVIEW proporciona una plantilla basada en proyectos, la máquina de estados simple, para simplificar el proceso de creación de una aplicación basada en este patrón de diseño.


La plantilla de la máquina de estados simple es una aplicación personalizable que se encuentra en forma de un archivo .lvproj con soporte de los VIs y los controles de definición tipo. La aplicación se basa en el patrón de diseño de una máquina de estados basada en eventos. La plantilla incluye una amplia documentación acerca de cómo modificar el código para crear una aplicación personalizada con máquinas de estados. Utilice el cuadro de diálogo de Crear Proyecto para crear un proyecto a partir de una plantilla o muestra. Las plantillas proporcionan arquitecturas comunes que se pueden modificar para lograr metas específicas. Proyectos de ejemplo demuestran cómo una plantilla se puede modificar para lograr metas específicas. Consulte el proyecto de ejemplo Single Shot Measurement, disponible en el cuadro de diálogo de Crear Proyecto, para un ejemplo de la adaptación de la plantilla de una máquina de estados simple en una aplicación de medición. Figura 2-5. Diagrama de transición de estados en una máquina de estados simple.

Initialize

Wait for Event

Stop

User State 1 User State 2

Después de la inicialización, la máquina de estados transiciona al estado Esperar Evento. Este estado contiene una estructura Event que espera los cambios en el panel frontal. Cuando un usuario hace clic en un botón, LabVIEW reconoce el evento y cambia al subdiagrama apropiado en la estructura Event. Este subdiagrama inicia una transición al estado apropiado. Sólo un estado se ejecuta a la vez, y el único bucle While ejecuta todas las tareas en un solo ciclo. Si usted necesita tareas con distintas velocidades o en paralelo, considere un patrón de diseño multi-bucle. En esta lección usted aprenderá sobre el patrón de diseño del productor/consumidor.

2-6 | ni.com


En los cursos posteriores se aprenderá acerca de otros patrones de diseño de otros LabVIEW para los cuales se dispone de plantillas, como las plantillas Queued Message Handler o Actor Framework. El estado Esperar por Evento es el único que reconoce la entrada del usuario. La máquina de estados debe estar en este estado para aceptar cualquier entrada del usuario. Por lo tanto, cada estado debe ser rápido para que el código pueda volver al estado Esperar por Eventos.

Patrón de diseño del controlador de eventos de la interfaz de usuario


El patrón de diseño del controlador de eventos de la interfaz de usuario incluye una arquitectura potente y eficaz para controlar la interacción del usuario con LabVIEW. Use el controlador de eventos de la interfaz de usuario para detectar cuándo un usuario cambia el valor de un control, mueve el ratón, hace clic en él o pulsa una tecla. La plantilla estándar del controlador de eventos de la interfaz de usuario consta de una estructura Event contenida en un bucle While, como en la figura 2-6. Configure la estructura Event para tener un caso para cada categoría de evento que desee detectar. Cada caso de evento contiene el código de control que se ejecuta inmediatamente después de que ocurra un evento. Como el bucle del controlador de eventos se activa precisamente cuando ocurre un evento y se suspende entre eventos, no tiene que sondear ni leer valores de control constantemente para detectar cuándo un usuario hace clic en un botón. El controlador de eventos de la interfaz de usuario permite minimizar el uso del procesador sin sacrificar la interactividad. Figura 2-6. Patrón de diseño del controlador de eventos de la interfaz de usuario

3 2 1 4

1 2

Estructura Event Bucle While

3 4

Terminal Timeout Event Data Node

Un problema común al usar el controlador de eventos de la interfaz de usuario es que computa la condición de terminación del bucle While antes de que se ejecute la estructura Event. Esto puede hacer que el bucle While se itere una vez más de lo esperado. Para evitar esta situación, calcule el final del bucle While en todo el código de control de eventos.


Lección 2


El código del controlador de eventos debe ejecutarse rápidamente, en general en menos de 200 ms. Si es más lento, puede parecer que la interfaz de usuario se bloquea. Asimismo, si el código del controlador de eventos tarda mucho en ejecutarse, la estructura Event podría bloquearse. De forma predeterminada, el panel frontal se bloquea mientras se controla un evento. Puede desactivar el bloqueo del panel frontal para cada caso de evento para que la interfaz de usuario sea más sensible. Sin embargo, los nuevos eventos que se generen mientras se está controlando un evento no se controlarán inmediatamente. Por lo tanto, la interfaz de usuario aún parecerá que no responde. Todo código que esté en un caso de evento no puede compartirse con otra estructura Event. Debe utilizar un buen diseño de código al usar la estructura Event. Modularice el código que se compartirá entre varios casos de estructura Event.


La estructura Event incluye un evento Timeout, que permite controlar cuándo se ejecuta el evento Timeout. Por ejemplo, si configura un Timeout de 200 ms, el caso del evento Timeout se ejecuta cada 200 ms en ausencia de otros eventos. Puede usar el evento Timeout para realizar la temporización crítica de su código.

C. Patrones de diseño de bucles múltiples

Hay varios patrones de diseño de bucles múltiples, algunos de los cuales están más allá del alcance de este curso. Este curso se enfoca en el patrón de diseño del productor/consumidor debido a su versatilidad y flexibilidad .

Patrón de diseño de productor / consumidor

El patrón de diseño de productor / consumidor se basa en el patrón de diseño de maestro / esclavo y mejora la compartición de datos entre varios bucles que se ejecutan a distintas velocidades. Al igual que el patrón de diseño de maestro / esclavo, el patrón de diseño de productor / consumidor separa tareas que producen y consumen datos a distintas velocidades. Los bucles paralelos en el patrón de diseño de productor / consumidor están separados en dos categorías: los que producen datos y los que consumen los datos producidos. Las colas de datos comunican datos entre los bucles. Las colas de datos también almacenan temporalmente datos en un búfer entre los bucles productor y consumidor. Un búfer es un dispositivo de memoria que almacena datos temporales entre dos dispositivos o, en este caso, múltiples bucles.

Consejo

Use el patrón de diseño de productor / consumidor cuando tenga que adquirir varios conjuntos de datos que deben procesarse en orden. Suponga que desea crear un VI que acepte datos mientras procesa los conjuntos de datos en el orden en que se recibieron. El patrón de productor / consumidor es ideal para este tipo de VI, porque poner en cola (producir) los datos se realiza mucho más rápidamente que el procesamiento de éstos (consumir). Podría colocar al productor y al consumidor en el mismo bucle para esta aplicación, pero la cola de procesamiento no podría recibir más datos hasta que el primer dato se procesara completamente. El enfoque de productor / consumidor para este VI pone en cola los datos en el bucle productor y procesa los datos en el bucle consumidor, como en la figura 2-7.

2-8 | ni.com


Las funciones de manejo de colas permiten almacenar un conjunto de datos que puede pasarse entre bucles múltiples que se ejecutan simultáneamente o entre VIs. Consulte la lección 1, Más allá del flujo de datos, para obtener información adicional acerca de colas e implementación de aplicaciones que utilicen el patrón de diseño productor / consumidor. Consejo


Figura 2-7. Patrón de diseño de productor / consumidor

Este patrón de diseño permite que el bucle consumidor procese los datos a su propio ritmo, mientras que el bucle productor sigue poniendo en cola datos adicionales. También puede usar el patrón de diseño de productor / consumidor para crear un VI que analice la comunicación de red. Este tipo de VI requiere dos procesos simultáneos y a distintas velocidades. El primer proceso sondea constantemente la línea de red y captura paquetes. El segundo proceso analiza los paquetes que captura el primer proceso. En este ejemplo, el primer proceso actúa como productor porque suministra datos al segundo proceso, que actúa de consumidor. El patrón de diseño de productor / consumidor es una arquitectura efectiva para este VI. Los bucles paralelos productor y consumidor controlan la captura y el análisis de datos fuera de la red. La comunicación en cola entre los dos bucles permite el almacenamiento temporal de los paquetes de red recuperados. El uso del búfer puede ser importante si la comunicación de red es intensa. Mediante el búfer, los paquetes pueden capturarse y comunicarse más rápidamente de lo que pueden analizarse.


Lección 2


Patrón de diseño de productor/consumidor (Datos) El patrón de diseño del productor/consumidor mejora el intercambio de datos entre múltiples bucles que funcionan a diferentes velocidades. Hay dos categorías de bucles paralelos en el patrón de diseño productor/consumidor—los que producen los datos y los que consumen los datos. Las colas de datos comunican datos entre los bucles. Las colas de datos también almacenan temporalmente datos en un búfer entre los bucles productor y consumidor. Utilice el patrón de diseño productor/consumidor para adquirir varios conjuntos de datos que se deben procesar en orden, por ejemplo, un VI que acepta datos al procesar los conjuntos de datos en el orden en que se reciban. Introducir datos en la cola (producir) ocurre mucho más rápido que el procesamiento de datos (consumidos). El enfoque de productor/consumidor pone en cola los datos en el bucle productor y procesa los datos en el bucle consumidor, como en la figura 2-8.


Figura 2-8. Patrón de diseño de productor/consumidor (Datos)

Este patrón de diseño permite que el bucle consumidor procese los datos a su propio ritmo, mientras que el bucle productor sigue poniendo en cola datos adicionales. También puede utilizar el productor/consumidor para crear un VI que analice la comunicación de red en la que dos procesos operan al mismo tiempo y a diferentes velocidades. El primer proceso sondea constantemente la línea de red y captura paquetes. El segundo proceso analiza los paquetes que captura el primer proceso. El primer proceso actúa como productor porque suministra datos al segundo proceso, que actúa de consumidor. Los bucles paralelos productor y consumidor controlan la captura y el análisis de datos fuera de la red. La comunicación en cola entre los dos bucles permite el almacenamiento temporal de los paquetes de red recuperados.

2-10 | ni.com


La figura 2-8 muestra cómo puede usar los VIs de Sincronización y las funciones para añadir funcionalidad al patrón de diseño. Las colas pueden transferir cualquier tipo de datos. El tipo de datos transferido de la figura 2-8 es una cadena de caracteres. Una cadena de caracteres no es el tipo de datos más eficaz para pasar datos en patrones de diseño. Un tipo de datos más eficaz para pasar datos en patrones de diseño es un cluster que consta de un estado y elementos de datos.

Demostración de Productor/consumidor (datos)


El proyecto de productor/consumidor, ubicado en el directorio \LabVIEW Core 2\Demonstrations\Producer Consumer - Data, demuestra el patrón de diseño. El panel frontal incluye un botón que controla cuando el valor de la cadena de caracteres es añadido a la cola. El control deslizante cableado a la función Wait (ms) en el del blucle Consumidor simula el tiempo de procesamiento intensivo dentro del bucle. Esto demuestra el efecto sobre la ejecución general del programa. Mientras que el bucle consumidor se ejecuta, el usuario puede poner en cola más elementos. La cola retiene cada elemento y los ejecuta en orden después del procesamiento simulado del elemento en el bucle consumidor. Con esta implementación, cuando el bucle consumidor está ocupado, la interfaz de usuario sigue respondiendo y los comandos de usuario siguen siendo registrados.

Patrón de diseño Productor/Consumidor (Eventos)

Uno de los patrones de diseño más versátiles y flexibles combina los patrones de diseño productor/ consumidor y el controlador de eventos de interfaz de usuario. Un VI creado usando el patrón de diseño productor/consumidor (eventos) responde a la interfaz de usuario asíncronamente, para que la interfaz de usuario pueda responder continuamente al usuario. El bucle consumidor de este patrón responde cuando ocurren eventos, al igual que el bucle consumidor del patrón de diseño de (datos) productor / consumidor. El patrón de diseño productor / consumidor (eventos) usa la misma implementación que el patrón de diseño productor / consumidor (datos), salvo que el bucle productor usa una estructura Event para responder a los eventos de la interfaz de usuario, como se ve en la figura 2-9. La estructura Event permite la respuesta continua a la interacción del usuario.


Lección 2



Figura 2-9. Patrón de diseño Productor/Consumidor (Eventos)

Demostración de productor/consumidor (eventos)

El proyecto de productor/consumidor, ubicado en el directorio \LabVIEW Core 2\Producer Consumer - Event, demuestra el patrón de diseño. El panel frontal incluye botones para poner en cola un mensajes con una prioridad normal o bien un mensaje con una prioridad alta. Cuando un mensaje con prioridad normal es puesto en la cola, el estado del consumidor se establece a prioridad normal, los datos booleanos se establecen a falso, y el valor del dato numerico se establece a la cantidad de iteraciones en el bucle While. Cuando un mensaje con prioridad alta es puesto en la cola, el estado del consumidor se establece a prioridad alta, los datos booleanos se establecen a verdadero, y el valor del dato numerico se establece a 1000. El indicador State to Execute muestra el estado actual a ser ejecutado en el bucle del Consumidor. El bucle consumidor se implementa con una espera de 1 segundo para demostrar el efecto del tiempo de procesamiento intensivo. Mientras que el bucle consumidor se ejecuta, el usuario puede poner en cola más elementos (hacer clic en otros botones). Con esta implementación, cuando el bucle consumidor está ocupado, la interfaz de usuario sigue respondiendo y los comandos de usuario siguen siendo registrados. Debido a que el bucle de productores recurre a una estructura Event, menos procesamiento se produce debido a que los controles dentro de la estructura Event son de sólo lectura cuando sus valores cambian. La interfaz de usuario es totalmente responsable de determinar las acciones a ser realizadas en el bucle consumidor. Incluso si hay un retraso acumulado de elementos con prioridades normales en la cola, un elemento de cola de prioridad alta se añade en la parte delantera de la cola y se procesa antes que los mensajes de prioridad normal. Cuando el usuario hace clic en el botón Stop, un mensaje de apagado se envía al bucle consumidor el cual termina enviando un valor True al terminal condicional del bucle.

2-12 | ni.com


Ayuda de Trabajo Use la tabla 2-1 para determinar la mejor forma de usar los patrónes de diseño descritos en esta lección. Tabla 2-1. Comparación entre patrones de diseño

Patrones de diseño

Simple

Uso

subVIs estándar Cálculos / algoritmos, procesamiento modular

Ventajas

Desventajas

Permite aplicaciones modulares

No es adecuado para el diseño de la interfaz de usuario o VIs de alto nivel

General


Equivalente de LabVIEW de una subrutina en otros lenguajes de programación Control de flujo estándar

Bueno para prototipos rápidos o aplicaciones sencillas y directas que no crecen en complejidad

Máquina de estados (sondeo)

Controla la funcionalidad de un VI mediante la creación de una secuencia

Diferencia entre fases de inicialización, ejecución y de parada

No puede retornar a una fase anterior

Secuencias de control

Una Interfaz de usuario basada en sondeo no es escalable a medida que la aplicación crece

Mantenimiento del código es sencillo porque se pueden añadir fácilmente nuevos estados.

Para aplicaciones simples, no tienen que manejar ambos diagramas: eventos y máquinas de estados.

No es apto para el paralelismo


Lección 2


Tabla 2-1. Comparación entre patrones de diseño (Continuación)

Patrones de diseño

Máquina de estados (Basada en eventos)

Uso

Controla la funcionalidad de un VI mediante la creación de una secuencia

Ventajas

Secuencias de control

Desventajas

No es apto para el paralelismo

Mantenimiento del código es sencillo porque se pueden añadir fácilmente nuevos estados.


El uso de la estructura de eventos es más eficiente que un control por sondeo

Controlador de eventos de interfaz de usuario

Procesa mensajes desde la interfaz de usuario

Maneja los mensajes de la interfaz de usuario

No permite el procesamiento intensivo No es apto para el paralelismo

Productor/consumidor (datos)

2-14 | ni.com

Procesa o analiza los datos en paralelo con otro procesamiento de datos o análisis

Comunicación por medio de un búfer entre procesos de una aplicación

No proporciona sincronización entre bucles Limitado a un tipo de dato, a menos que los datos estén contenidos en un cluster


Tabla 2-1. Comparación entre patrones de diseño (Continuación)

Patrones de diseño

Uso

Ventajas

Desventajas

Productor/consumidor (eventos)

Responde a la interfaz de usuario con aplicaciones de uso intensivo del procesador

Separa la interfaz de usuario del código de procesamiento intensivo

No integra eventos no realcionados con la interfaz de usuario

Variables globales funcionales

Utilizar como un subVI que necesita mantener los datos globales y realizar acciones en esos datos.

Almacena datos siempre que el VI está en memoria

No es adecuado para VIs reentrantes


Ejecuta operaciones en función de la selección de entrada

Problemático al duplicar o ampliar los datos globales con múltiples copias y realizar acciones en dichas copias

Una buena manera de proteger las secciones críticas de código para eliminar las condiciones de carrera

D. Gestores de errores

De forma predeterminada, LabVIEW controla automáticamente cualquier error cuando un VI se ejecuta suspendiendo la ejecución, resaltando el subVI o la función donde ocurrió el error y mostrando un cuadro de diálogo de error. La gestión automática de errores es conveniente para el desarrollo de prototipos rápidos y pruebas de concepto, pero no se recomienda para el desarrollo de aplicaciones profesionales. Si confía en la gestión automática de errores, su aplicación podría detenerse en una parte crítica de su código por un cuadro de diálogo de error. Quizá el usuario no pueda continuar ejecutando la aplicación o solucionar el problema. Al implementar manualmente la gestión de errores, usted controla cuándo aparecen cuadros de diálogo emergentes. Si piensa crear una aplicación independiente, debe incorporar la gestión manual de errores porque LabVIEW no muestra cuadros de diálogo de gestión automática de errores en LabVIEW Run-Time Engine. Un gestor de errores es un VI o código que cambia el flujo normal del programa cuando ocurre un error. El VI Simple Error Handler es un ejemplo de un gestor de errores integrado que se utiliza en LabVIEW. Puede aplicar otros gestores de errores personalizados para su aplicación. Por ejemplo, puede elegir registrar información del error en un archivo. Otro gestor de errores común es un VI que redirecciona código a una rutina de limpieza o cierre cuando ocurre un error, para que su aplicación salga correctamente. La figura 2-10 muestra un gestor de errores de máquina de estados que configura el siguiente estado en Shutdown cuando un error tiene el estado TRUE.


Lección 2


Figura 2-10. Gestor de errores de la máquina de estados

Gestión de errores en el patrón de diseño productor/consumidor (eventos)


El diagrama del productor/consumidor que se muestra en la Figura 2-9 es útil para la comprensión de la arquitectura fundamental del patrón de diseño. Además de pasar comandos y datos entre los bucles, el patrón de diseño para ambos bucles cuando el usuario hace clic en el botón Stop. Sin embargo, si se produce un error en cualquier bucle, no existe ningún mecanismo para comunicar esta información al otro bucle. Por lo tanto, es posible que uno de los bucles se ejecute indefinidamente después de que el otro se haya detenido. Por lo tanto, es necesario añadir el código de gestor de errores con el patrón de diseño para que los bucles productor y consumidor se detengan elegantemente cuando se produce un error. Hay muchas técnicas para comunicar información de error entre los dos bucles, algunos de los cuales están cubiertos en cursos posteriores. Algunas técnicas implican la adición de un canal de comunicación adicional, como una cola adicional. Otra técnica es utilizar el cluster de cola actual para ejecutar un caso de apagado en el bucle consumidor. Este enfoque se demuestra usando el VI gestor de errores que se muestra en la figura 2-11 y el productor/consumidor llamando al VI Error Handler ilustrado en la figura 2-12.

2-16 | ni.com



Figura 2-11. VI gestor de errores

Figura 2-12. Productor/Consumidor llamando al VI Error Hander

Si se produce un error en el bucle productor, el VI Error Handler pone en cola el estado de apagado junto con la información de cluster de error. Puesto que se desearía volver a utilizar este VI Error Handler en el bucle consumidor, es necesario eliminar el error en el cable de error después de poner en cola la información. De lo contrario, el bucle consumidor terminaría antes de que tuviera la oportunidad de ejecutar el caso de apagado. Si falla la función Enqueue en el VI Error Handler, la


Lección 2


comunicación entre los bucles se detiene por lo que el único curso razonable de acción es dar por terminada la ejecución del bucle inmediatamente. Dado que el estado de procesamiento, incluyendo el procesamiento de cierre, se produce en el bucle consumidor y no en el bucle de productor, todavía necesita algún mecanismo en el bucle consumidor para informar al bucle productor que detenga la ejecución. Un enfoque, como se muestra en la figura 2-13, es utilizar una variable local que se sondea en el caso del evento Timeout. Si se produce un error en el bucle consumidor, el caso de apagado se ejecuta y detiene el bucle. La variable local Consumer Shutdown? puede entonces detener el bucle productor.


Figura 2-13. Productor/Consumidor usando una variable local

E. Generando códigos de error y mensajes La gestión de errores en LabVIEW sigue el modelo de flujo de datos. Al igual que los valores de datos fluyen por un VI, también lo hace la información de errores. Mientras se ejecuta el VI, LabVIEW comprueba si hay errores en cada nodo de ejecución. Si LabVIEW no encuentra errores, el nodo se ejecuta con normalidad. Si LabVIEW detecta un error, el nodo pasa el error al siguiente

2-18 | ni.com


nodo sin ejecutar esa parte del código. El siguiente nodo hace lo mismo y así sucesivamente. Al final del flujo de ejecución, el error se expresa a través del Simple Error Handler.vi o a través de un cluster de error. Configurar un error cuando un nodo o VI falla no debería estar limitado a los errores cuyas funciones y VIs de LabVIEW ya reportan. Como desarrollador de un VI, también se deben detectar las condiciones de error y el reporte de estos errores los subVIs. Hay muchas situaciones en las que puede que desee reportar una condición de error que se detectó en su código. A continuación se presentan algunos ejemplos para configurar o invalidar los códigos de error y mensajes: Comprobar las entradas no válidas a subVIs o algoritmos. Verificar si existen arrays o cadenas de caracteres vacías antes de procesar. Si una entrada es inválida, se debe configurar un código de error y mensaje apropiados. Un ejemplo podría ser comprobar si una entrada es un valor positivo antes de intentar obtener la raíz cuadrada del número. Si un valor es negativo, se generará un error con un mensaje apropiado con el fin de notificar al usuario como se podría arreglar el valor de la entrada.

•

Verificar salidas inválidas en diferentes algoritmos. Por ejemplo, la función Search 1D Array retorna un valor índice de -1 si la búsqueda de un elemento no es exitosa en un array. En esta situación, es posible que desee informar de un error con un mensaje que indica que el valor del elemento no se encuentra en el array.

•

Sobrescribir mensajes de error de LabVIEW con detalles más específicos. La función Open/Create/Replace devuelve el código de error 7 al intentar abrir un archivo que no existe. El código de error 7 está asociado al mensaje de error genérico “file not found”. En lugar del mensaje de error genérico, es posible que se desee un mensaje de error más específico teniendo en cuenta la ruta del archivo específico que falló, además de información sobre cómo el usuario puede corregir el problema y volver a intentar la operación.


•

Error Ring

Se utiliza el Error Ring para seleccionar y pasar de forma rápida códigos de error personalizados a través de un VI. Se puede configurar el ring para devolver un mensaje de error integrado, o se puede crear un mensaje de error personalizado para un solo uso. De forma predeterminada, la cadena de caracteres de origen del cluster de error contiene la cadena de llamadas del VI de nivel superior para el VI que se está ejecutando. La figura 2-14 ilustra un Error Ring configurado. Figura 2-14. Error Ring

Una vez seleccionado el error, puede cambiar el tipo (error o advertencia) e incluir la cadena de llamada haciendo clic en los iconos del ring. También puede cambiar el tipo de error y las opciones de llamada de la cadena, haga clic con el botón derecho en en el Error Ring y seleccione: Generate Error, Generate Warning, Include Call Chain, o Exclude Call Chain, en el menú contextual.


Lección 2


Definiendo un codigo de error personalizado La creación de un código de error personalizado es útil si se desea definir un código de error simple o sobrescribir uno único incorporado en el código de error. Si se tienen varios errores personalizados que se deseen utilizar en el Error Ring, utilice el cuadro de diálogo Error Code Editor.

F. Temporizar un patrón de diseño Esta sección describe dos formas de temporización: de ejecución y control del software. La temporización de ejecución usa funciones de temporización facilitando tiempo al procesador para completar otras tareas. La temporización de control del software temporiza una operación del mundo real para realizarla en un periodo de tiempo concreto.


Temporización de ejecución

La temporización de ejecución implica temporizar un patrón de diseño explícitamente o en función de eventos que ocurren en el VI. La temporización explícita utiliza una función que facilita específicamente tiempo al procesador para completar otras tareas, como la función Wait Until Next ms Multiple. Cuando la temporización se basa en eventos, el patrón de diseño espera a que ocurra alguna acción antes de continuar y permite que el procesador complete otras tareas mientras espera. Utilice sincronización explícita de los patrones de diseño basados en sondeo, tales como el patrón de diseño (datos) de productor/consumidor o la máquina de estados basada en sondeo. El sondeo es el proceso de realizar solicitudes continuas de datos desde otro dispositivo. En LabVIEW, esto normalmente significa que el diagrama de bloques pregunta continuamente si hay datos disponibles, en general desde la interfaz de usuario.

Consejo

Por ejemplo, el patrón de diseño de productor/consumidor de la figura 2-15 usa un bucle While y una estructura Case para implementar el bucle productor. El productor se ejecuta continuamente y sondea un evento de algún tipo, como cuando el usuario hace clic en un botón. Cuando ocurre el evento, el productor envía un mensaje al consumidor. Se debe temporizar el productor para que no acapare la ejecución del procesador. En este caso, normalmente use la función Wait (ms) para regular la frecuencia de sondeo del maestro. Consejo Use siempre una función de temporización como Wait (ms) o Wait Until Next ms Multiple en cualquier patrón de diseño que se ejecute continuamente y deba regularse. Si no usa una función de temporización en una estructura que se ejecuta continuamente, LabVIEW usará todo el tiempo del procesador y quizá no se ejecuten los procesos en segundo plano.

2-20 | ni.com



Figura 2-15. Patrón de diseño de productor / consumidor

Tenga en cuenta que el bucle consumidor no contiene ninguna forma de temporización. El uso de colas para pasar los datos y mensajes proporciona una forma inherente de temporización en el bucle consumidor debido a que el bucle consumidor espera a la función Queue para recibir un elemento de la cola. Después de que la función Queue recibe un elemento de la cola, el bucle consumidor se ejecuta sobre los datos o mensajes pasados. Así se crea un diagrama de bloques eficiente que no malgasta ciclos del procesador al sondear mensajes. Éste es un ejemplo de temporización de ejecución esperando un evento. Al implementar patrones de diseño basados en temporización de aparición de eventos, se puede utilizar los mecanismos de sincronización de eventos para la ejecución temporizada y control temporizada por software. Funciones de sincronización y la estructura Event incluyen una función de Timeout. El valor predeterminado para un Timeout es -1, esto indica una espera infinita. Con un Timeout infinito, la ejecución de un patrón de diseño solamente ocurre cuando un evento se produce. El VI del patrón de diseño (Eventos) productor/consumidor que se muestra en la figura 2-16 no requiere funciones de temporización porque la sincronización es inherente en la ejecución del bucle productor y consumidor. La estructura Event en el bucle productor controla cuando el bucle productor se ejecuta. La función Dequeue Element en el bucle consumidor espera hasta que un elemento es puesto en cola, controlando así la ejecución en el bucle consumidor. Patrones de diseño tales como el productor/consumidor (eventos), no requieren temporización, debido a que su temporización es controlada por eventos externos.


Lección 2



Figura 2-16. Patrón de diseño Productor/Consumidor (Eventos) con tiempo de espera indefinido

Especificar un valor de Timeout permite la funcionalidad de ser ejecutado a intervalos regulares. Por ejemplo, el patrón de diseño productor/consumidor (eventos) que se ilustra en la figura 2-17 muestra cómo se puede ejecutar código a intervalos regulares tanto en el bucle productor como en el consumidor. En la figura 2-17, el bucle productor se ejecuta cada 100ms incluso si no han ocurrido eventos. Cableando un valor en milisegundos a la terminal de Timeout de una estructura Event despierta la estructura Event y ejecuta el código en el caso de que el Timeout se agote. El bucle consumer se ejecuta cada 50 ms incluso si la cola está vacía.

2-22 | ni.com



Figura 2-17. Caso de eventos con Timeout en patrones de diseño productor/consumidor con ejecución temporizada

Temporización de control del software

Muchas aplicaciones que crea deben ejecutar una operación durante un tiempo específico. Piense en la implementación de un patrón de diseño de máquina de estados para un sistema de adquisición de datos de temperatura. Si las especificaciones requieren que el sistema adquiera los datos de temperatura durante 5 minutos, usted podría permanecer en el estado de adquisición durante 5 minutos. Sin embargo, durante ese tiempo no puede procesar ninguna acción de la interfaz de usuario como detener el VI. Para procesar acciones de la interfaz de usuario, debe implementar la temporización, de modo que el VI se ejecute continuamente durante el tiempo especificado. Implementar este tipo de temporización conlleva que la aplicación se esté ejecutando mientras monitoriza un reloj en tiempo real. En el curso LabVIEW Core 1 implementó temporización de control de software para controlar el tiempo hasta que el VI adquiría el siguiente dato, como en la figura 2-18. Observe el uso del Elapsed Time Express VI para realizar el seguimiento de un reloj.


Lección 2



Figura 2-18. Uso del Elapsed Time Express VI

Si usa las funciones Wait (ms) o Wait Until Next ms Multiple para realizar temporización de software, la ejecución de la función que está temporizando no ocurrirá hasta que termine la función de espera. Estas funciones de temporización no son el método preferido para realizar la temporización de control de software, sobre todo para VIs en los que debe ejecutarse continuamente el sistema. Un método mejor para la temporización de control de software utiliza la función Get Date/Time In Seconds para obtener el tiempo actual y realizar su seguimiento mediante registros de desplazamiento. Figura 2-19. Temporización de software usando la función Get Date/Time In Seconds

La función Get Date/Time In Seconds, conectada al terminal izquierdo del registro de desplazamiento, inicializa éste con la hora del sistema actual. Cada estado usa otra función Get Date/Time In Seconds y compara la hora actual con la hora de inicio. Si la diferencia entre estas dos horas es mayor o igual que el tiempo de espera, el estado terminará de ejecutarse y se ejecutará el resto de la aplicación.

2-24 | ni.com


Use siempre la función Get Date/Time In Seconds en lugar de la función Tick Count (ms) para este tipo de comparación, porque el valor de la función Tick Count (ms) puede volver a 0 durante la ejecución. Consejo

G. Patrón de diseño variable global funcional


A medida que continúe desarrollando sus habilidades en LabVIEW e interactuando con otros desarrolladores, aprenderá acerca de los patrones de diseño de otros con nombres como Maestro/Esclavo y controlador de mensajes de cola. Algunos patrones de diseño, como el actor Framework, están bastante avanzados y requieren un conocimiento adicional de características de programación orientados a objetos en LabVIEW. Algunos patrones de diseño son componentes muy útiles en aplicaciones más grandes. El patrón de diseño variable global funcional es uno de estos. Para poder entender este nuevo patrón de diseño, es bueno comprender en profundidad un tipo de condición de carrera llamado lectura-modificación-escritura.

Condiciones de carrera lectura-modificación-escritura Una condición de carrera ocurre cuando la temporización de eventos o la programación de tareas afecta involuntariamente a un valor de salida o de datos. Las condiciones de carrera suponen un problema común en los programas que ejecutan varias tareas en paralelo y comparten datos entre ellos. Piense en el ejemplo de la figura 2-20. Figura 2-20. Ejemplo de Condición de Carrera

Ambos bucles modifican una variable local durante cada iteración del bucle. Un bucle incrementa el contador, mientras que el otro decrementa el contador. Si ejecuta este VI, el resultado esperado después de hacer clic en el botón Stop es que la variable Running Total es igual a Loop Count Difference. Dado que los dos bucles están funcionando a la misma velocidad, el valor debe ser cero o próximo a cero. Dependiendo de cuando se detiene el VI, es posible que se vea el resultado esperado. Sin embargo, es también probable que la variable Running Total no sea igual a Loop Count Difference porque este VI contiene una condición de carrera.


Lección 2


En un ordenador con un solo procesador, las acciones de un programa multitarea como este ejemplo realmente suceden secuencialmente, pero LabVIEW y el sistema operativo cambian rápidamente las tareas para que se ejecuten a la vez. La condición de carrera de este ejemplo se produce cuando el cambio de una tarea a la otra ocurre en un determinado momento. Observe que ambos bucles realizan las siguientes operaciones: •

Leer la variable local

•

Aumentar o disminuir el valor a ser leído

•

Escribir el valor modificado en la variable local

¿Qué sucede ahora si las operaciones del bucle se han programado en este orden?: 1. El bucle 1 lee la variable local. 2. El bucle 2 lee la variable local.


3. El bucle 1 incrementa el valor leído. 4. El bucle 2 incrementa el valor leído.

5. El bucle 1 escribe el valor incrementado en la variable local.

6. El bucle 2 escribe el valor decrementado en la variable local.

En este ejemplo, el incremento del primer bucle es sobrescrito por el bucle 2 de forma efectiva. Si la variable local comenzó con un valor cero, el valor resultante sería menos uno. Esto genera una condición de carrera, lo que puede causar problemas serios si se desea que el programa calculae una diferencia exacta. En este ejemplo en particular, existen varias instrucciones que ocurren mientras la variable local es leída y cuando es escrita. Por lo tanto, el VI tiene menos probabilidad de cambiar entre los bucles en el momento equivocado. Esto explica por qué este VI se ejecuta con precisión durante cortos periodos y sólo pierde varios recuentos durante periodos más largos. Las condiciones de carrera son difíciles de identificar y de depurar, porque el resultado depende del orden en que el sistema operativo ejecuta tareas programadas y la temporización de eventos externos. El modo en que las tareas interactúan entre sí y el sistema operativo, así como la temporización arbitraria de los eventos externos convierten este orden en esencialmente aleatorio. A menudo el código con una condición de carrera puede devolver el mismo resultado miles de veces en las pruebas, pero aun así puede devolver un resultado distinto, que puede aparecer cuando se está usando el código. Para evitar condiciones de carrera, lo mejor es seguir estas técnicas: •

Control y limitación de recursos compartidos

•

Identificar y proteger secciones críticas del código

•

Especificar el orden de ejecución

2-26 | ni.com


Controlar y limitar recursos compartidos Las condiciones de carrera son muy comunes cuando dos tareas tienen acceso tanto de lectura como de escritura en un recurso, como en el caso del ejemplo anterior. Un recurso es cualquier entidad compartida entre los procesos. Cuando se trata con condiciones de carrera, los recursos compartidos más comunes son el almacenamiento de datos, como las variables. Otros ejemplos de recursos son archivos y referencias a recursos de hardware.


Permitir que un recurso se altere desde varias ubicaciones suele introducir la posibilidad de una condición de carrera. Por lo tanto, una forma ideal de evitar condiciones de carrera es minimizar recursos compartidos y el número de escritores en los recursos compartidos restantes. En general, no es perjudicial tener varios lectores y monitores para un recurso compartido. Sin embargo, intente usar sólo un escritor o controlador para un recurso compartido. La mayoría de las condiciones de carrera sólo ocurren cuando un recurso tiene varios escritores. En el ejemplo anterior, puede reducir la dependencia de recursos compartidos, si cada bucle mantiene su recuento localmente. A continuación, comparta los recuentos finales tras hacer clic en el botón Stop. Esto supone sólo una única lectura y una única escritura en un recurso compartido y elimina la posibilidad de una condición de carrera. Si todos los recursos compartidos tienen sólo un único escritor o controlador y el VI tiene un orden de instrucciones bien secuenciado, no habrá condiciones de carrera.

Protección de secciones críticas

Una sección crítica de código es código que debe actuar con coherencia en todas las circunstancias. En los programas multitarea, una tarea puede interrumpir otra que se está ejecutando. En casi todos los sistemas operativos modernos esto sucede constantemente. Normalmente esto no tiene efecto en el código que se ejecuta, pero cuando la tarea que interrumpe altera un recurso compartido que la tarea interrumpida supone que es constante, ocurre una condición de carrera. Cada bucle en la figure 2-20 contiene una sección de código crítico. Si uno de los bucles interrumpe al otro bucle mientras está ejecutando el código en su sección crítica, puede ocurrir una condición de carrera. Una forma de eliminar las condiciones de carrera es identificar y proteger las secciones críticas del código. Existen numerosas técnicas para proteger secciones críticas. Dos de las más eficaces son las variables globales funcionales y los semáforos.

Semáforos Los semáforos son mecanismos de sincronización específicamente diseñados para proteger recursos y secciones críticas de código. Puede evitar que las secciones críticas de código se interrumpan entre sí encerrándolas entre un VI Acquire Semaphore y Release Semaphore. De forma predeterminada, un semáforo sólo permite que una tarea lo adquiera simultáneamente. Por lo tanto, una vez que una de las tareas entra en una sección crítica, las otras tareas no pueden entrar en sus secciones críticas hasta que se complete la primera tarea. Si se hace correctamente, esto elimina la posibilidad de una condición de carrera.


Lección 2


Puede usar semáforos para proteger las secciones críticas de código mostrado en la figura 2-20. Para eliminar la condición de carrera, abra el semáforo antes de comenzar cada ciclo. Dentro de cada bucle, utilice el VI Acquire Semaphore justo antes de la sección crítica y usar el VI Release Semaphore después de la sección crítica. La figura 2-21 muestra una solución a la condición de carrera usando semáforos.


Figura 2-21. Protección de secciones críticas utilizando semáforos


Una forma de proteger secciones críticas es colocarlas en subVIs. Puede llamar sólo a un subVI no reentrante desde una ubicación a la vez. Por lo tanto, si coloca código crítico en un subVI no reentrante, evitará que otros procesos que llaman al subVI interrumpan el código. Usar la arquitectura de variables globales funcionales para proteger secciones críticas resulta especialmente eficaz, ya que los registros de desplazamiento pueden sustituir métodos de almacenamiento menos protegidos como las variables compartidas globales o de tipo single-process. Las variables globales funcionales también sirven para crear subVIs multifuncionales que controlen todas las tareas asociadas con un recurso concreto. Tras identificar cada sección de código crítico en su VI, agrupe las secciones por los recursos a los que acceden y cree una variable global funcional para cada recurso. Las secciones críticas que realizan distintas operaciones pueden convertirse en un comando para la variable global funcional. Puede agrupar secciones críticas que realicen la misma operación en un comando, reutilizando el código.

2-28 | ni.com


Puede utilizar variables globales funcionales para proteger secciones críticas del código de la figura 2-20. Para eliminar la condición de carrera, sustituya las variables locales por una variable global funcional y coloque el código para incrementar el contador de la variable global funcional, como en la figura 2-22.


Figura 2-22. Uso de variables globales funcionales para la protección de secciones de código


Una variable global funcional es un VI no reentrante que utiliza registros de desplazamiento sin inicializar para almacenar los datos globales. El VI a menudo permite acciones a realizar sobre los datos. Cuando un VI es no reentrante, hay un espacio de datos para el VI. Por lo tanto, sólo una llamada puede ejecutar el VI en cualquier momento dado. Otras llamadas tienen que “esperar su turno” para usar el VI. Puede utilizar registros de desplazamiento sin inicializar en bucles For o While para almacenar datos, siempre que el VI esté en la memoria. El registro de desplazamiento retiene el último valor de los datos. Un bucle con un registro de desplazamiento no inicializado se conoce como una variable global funcional. La ventaja de este método frente a una variable global es que puede controlar el acceso a los datos en el registro de desplazamiento. Además, la variable global funcional elimina la posibilidad de condiciones de carrera, porque sólo una instancia de una variable global funcional a la vez, puede ser cargada en la memoria. La forma general de un VI de variable global funcional incluye una estructura Case y un registro de desplazamiento sin inicializar con un bucle While de una sola iteración, como en la figura 2-23.


Lección 2


Figura 2-23. Formato de variables globales funcionales

1

Functional Global Variable Code

1

Registro de desplazamiento sin inicializar


Una variable global funcional normalmente tiene un parámetro de entrada action que especifica qué tarea realiza el VI. El VI usa un registro de desplazamiento sin inicializar en un bucle While para retener el resultado de la operación. La figura 2-24 muestra una variable global funcional simple con funcionalidad set y get. Figura 2-24. Variable global funcional con funcionalidad set y get

En este ejemplo, los datos pasan al VI y se almacena en el registro de desplazamiento si el tipo de datos enumerado está configurado en Set. Los datos se capturan desde el registro de desplazamiento si el tipo de datos enumerado se configura en Get. Antes de utilizar una variable local o global, asegúrese de que una variable global funcional no habría funcionado en su lugar.

Consejo

Aunque puede usar variables globales funcionales para implementar variables globales simples, como en el ejemplo anterior, resultan especialmente útiles para implementar estructuras de datos más complejas, como una pila o un búfer de puesta en cola. También puede usar variables globales

2-30 | ni.com


funcionales para proteger el acceso a recursos globales, como archivos, instrumentos y dispositivos de adquisición de datos, que no puede representarse con una variable global.

Uso de variables globales funcionales para la temporización Una aplicación potente de las variables globales funcionales es realizar la temporización en su VI. Muchos VIs que realizan medición y automatización requieren alguna forma de temporización. A menudo un instrumento o dispositivo de hardware necesita tiempo para inicializarse. Debe crear temporización explícita en su VI para tener en cuenta el tiempo físico requerido para inicializar un sistema. Usted puede crear una variable global funcional que mida el tiempo transcurrido entre cada vez que se llama al VI, como en la figura 2-25.


Figura 2-25. Variable global funcional Elapsed Time

El caso Elapsed Time obtiene la fecha y hora actuales en segundos y lo resta del tiempo que está almacenado en el registro de desplazamiento. El caso Reset Time inicializa la variable global funcional con un valor de tiempo conocido.




Autorrevisión: Cuestionario 1. ¿Cuál de los siguientes elementos son motivos para utilizar un patrón de diseño de múltiples bucles? a. Ejecutar varias tareas a la vez b. Ejecutar distintos estados en una máquina de estados c. Ejecutar tareas a distintas velocidades d. Ejecutar el código de arranque, el bucle principal y el código de cierre

2. ¿Cuáles de los siguientes son ejemplos de código gestor de errores?


a. Mostrar un cuadro de diálogo que se utiliza para corregir un VI roto. b. Genera un código de error definido por el usuario

c. Muestra un cuadro de diálogo cuando se produce un error

d. Transición de un estado de la máquina de estados a un estado de apagado cuando se produce un error

3. ¿Cuál es el valor de tiempo de espera predeterminado de una estructura Event? a. 0

b. 100 ms

c. Ningún tiempo de espera

d. El valor de entrada de la función Wait (ms) que exista en el mismo bucle que la estructura Event




Autorrevisión: Respuestas 1. ¿Cuál de los siguientes elementos son motivos para utilizar un patrón de diseño de múltiples bucles? a. Ejecutar varias tareas a la vez b. Ejecutar distintos estados en una máquina de estados c. Ejecutar tareas a distintas velocidades d. Ejecutar el código de arranque, el bucle principal y el código de cierre

2. ¿Cuáles de los siguientes son ejemplos de código gestor de errores?


a. Mostrar un cuadro de diálogo que se utiliza para corregir un VI roto. b. Genera un código de error definido por el usuario

c. Muestra un cuadro de diálogo cuando se produce un error

d. Transición de un estado de la máquina de estados a un estado de apagado cuando se produce un error

3. ¿Cuál es el valor de tiempo de espera predeterminado de una estructura Event? a. 0

b. 100 ms

c. Ningún tiempo de espera

d. El valor de entrada de la función Wait (ms) que exista en el mismo bucle que la estructura Event


Lección 2



Notas

2-36 | ni.com

3

Control de la interfaz de usuario

Al escribir programas, a menudo debe cambiar los atributos de los objetos del panel frontal programáticamente. Por ejemplo, quizá desee hacer un objeto invisible hasta cierto punto de la ejecución del programa. En LabVIEW, puede utilizar el VI Server para acceder a las propiedades y métodos de los objetos del panel frontal. Esta lección explica el VI Server, Nodos de Propiedad, referencias de control y Nodos de Invocación.

Temas


A. Arquitectura del VI Server B. Nodos de Propiedad

C. Nodos de Invocación

D. Referencias de control


Lección 3


A. Arquitectura del VI Server El VI Server es una tecnología independiente de plataforma orientada a objetos que ofrece acceso programático a LabVIEW y a aplicaciones de LabVIEW. VI Server realiza muchas funciones; sin embargo, esta lección se concentra en el uso del VI Server para controlar objetos del panel frontal y editar las propiedades de un VI y de LabVIEW. Para entender cómo usar el VI Server, es útil entender la terminología asociada a él.

Terminología orientada a objetos La programación orientada a objetos se basa en objetos. Un objeto es un miembro de una clase. Una clase define lo que puede hacer un objeto, qué operaciones puede realizar (métodos) y qué propiedades tiene, como color, tamaño, etc.


Los objetos pueden tener métodos y propiedades. Los métodos realizan una operación, como reinicializar el objeto a su valor predeterminado. Las propiedades son los atributos de un objeto. Las propiedades de un objeto pueden ser su tamaño, color, visibilidad, etc.

Clases de control

Los objetos del panel frontal de LabVIEW heredan propiedades y métodos de una clase. Cuando crea un control Stop, es un objeto de la clase booleana y tiene propiedades y métodos asociados con esa clase, como en la figura 3-1. Figura 3-1. Ejemplo de clase booleana Control

Boolean

Stop

Control Class Example Property: Visible Example Method: Reinitialize to Default

Boolean Sub-Class Example Property: Boolean Text

Array

Array Sub-Class Example Property: Number of Rows

Stop Object Visible: Yes Reinitialize to Default: No Boolean Text: Stop

Clase VI Los controles no son los únicos objetos de LabVIEW que pertenecen a una clase. Un VI pertenece a la clase VI y tiene sus propias propiedades y métodos asociados a ella. Por ejemplo, puede usar los métodos de clase VI para abortar un VI, para ajustar la posición de la ventana del panel frontal y para obtener una imagen del diagrama de bloques. Puede usar las propiedades de la clase VI para cambiar el título de una ventana del panel frontal, para recuperar el tamaño del diagrama de bloques y para ocultar el botón Abort.

3-2 | ni.com


B. Nodos de Propiedad Los Nodos de Propiedad acceden a las propiedades de un objeto. En algunas aplicaciones quizá desee modificar programáticamente el aspecto de objetos del panel frontal como respuesta a ciertas entradas. Por ejemplo, si un usuario introduce una contraseña no válida, quizá desee que parpadee un LED rojo. Otro ejemplo es cambiar el color de un trazo en un gráfico tipo “chart”. Cuando los puntos de datos superan cierto valor, quizá desee mostrar un trazo rojo en lugar de uno verde. Los Nodos de Propiedad permiten realizar estas modificaciones programáticamente. También puede usar Nodos de Propiedad para cambiar el tamaño de objetos de paneles, ocultar partes del panel frontal, añadir cursores a gráficos, etc.


Los Nodos de Propiedad en LabVIEW son muy potentes y tienen muchos usos. Consulte la Ayuda de LabVIEW para obtener información adicional acerca de Nodos de Propiedad.

Creación de Nodos de Propiedad

Cuando cree una propiedad desde un objeto del panel frontal haciendo clic con el botón derecho en el objeto, seleccionando Create»Property Node y seleccionando una propiedad del menú contextual, LabVIEW creará un Nodo de Propiedad en el diagrama de bloques que está implícitamente vinculado al objeto del panel frontal. Si el objeto tiene una etiqueta, el Nodo de Propiedad tendrá la misma etiqueta. Puede cambiar la etiqueta tras crear el nodo. Puede crear varios Nodos de Propiedad para el mismo objeto del panel frontal.

Uso de Nodos de Propiedad

Cuando crea un Nodo de Propiedad, al principio tiene un terminal que representa una propiedad que puede modificar para el objeto correspondiente del panel frontal. Si usa este terminal en el Nodo de Propiedad, puede set (escribir) la propiedad o get (leer) el estado actual de esa propiedad. Por ejemplo, si crea un Nodo de Propiedad para un control numérico digital usando la propiedad Visible, aparecerá una pequeña flecha a la derecha del terminal Property Node, indicando que está leyendo el valor de esa propiedad. Puede cambiar la acción a escribir haciendo clic con el botón derecho en el terminal y seleccionando Change to Write en el menú contextual. Si cablea un valor booleano False al terminal de la propiedad Visible, el control numérico desaparecerá del panel frontal cuando el Nodo de Propiedad reciba los datos. Si cablea un valor booleano True, el control reaparecerá. Figura 3-2. Uso de Nodos de Propiedad

Para obtener información de la propiedad, haga clic con el botón derecho en el nodo y seleccione Change All to Read en el menú contextual. Para configurar información de la propiedad, haga clic con el botón derecho en el nodo y seleccione Change All to Write en el menú contextual. Si una propiedad es de sólo lectura, Change to Write se atenuará en el menú contextual. Si la flecha de dirección del Nodo de Propiedad apunta a la derecha, está obteniendo el valor de la propiedad. Si


Lección 3


la flecha de dirección del Nodo de Propiedad apunta a la izquierda, está configurando el valor de la propiedad. Si el Nodo de Propiedad de la figura 3-2 se configura en Read, cuando se ejecute producirá un valor True si el control es visible o False si es invisible. Algunas propiedades son sólo de lectura, como la propiedad Label, o sólo de escritura, como la propiedad Value (Signaling). Consejo

Para añadir terminales al nodo, haga clic con el botón derecho en la zona blanca del nodo y seleccione Add Element en el menú contextual o use la herramienta de posicionamiento para cambiar el tamaño del nodo. A continuación, puede asociar cada terminal Property Node con otra propiedad desde su menú contextual. Los Nodos de Propiedad ejecutan cada terminal en orden de arriba a abajo.


Consejo

Algunas propiedades usan clusters. Estos clusters contienen varias propiedades a las que puede acceder usando las funciones del cluster. Para escribir en estas propiedades como grupo necesita la función Bundle y para leer en estas propiedades se necesita la función Unbundle. Para acceder a las propiedades unidas, seleccione All Elements en el menú contextual. Por ejemplo, puede acceder a todos los elementos de la propiedad Position seleccionando Properties»Position»All Elements en el menú contextual. Sin embargo, puede acceder a los elementos del cluster como propiedades individuales, como en la figura 3-3. Figura 3-3. Propiedades que usan clusters

C. Nodos de Invocación

Los Nodos de Invocación acceden a los métodos de un objeto. Use el Nodo de Invocación para realizar acciones o métodos en una aplicación o VI. A diferencia del Nodo de Propiedad, un solo Nodo de Invocación ejecuta únicamente un método o una aplicación o VI. Seleccione un método utilizando la herramienta de operaciones para hacer clic en el terminal del método o haciendo clic con el botón derecho en la zona blanca del nodo y seleccionando Methods en el menú contextual. También puede crear un Nodo de Invocación implícitamente vinculado haciendo clic con el botón derecho en un objeto del panel frontal, seleccionado Create»Invoke Node y seleccionando un método del menú contextual. El nombre del método es siempre el primer terminal de la lista de parámetros del Nodo de Invocación. Si el método devuelve un valor, el terminal del método muestra el valor devuelto. De lo contrario, el terminal del método no tendrá valor.

3-4 | ni.com


El Nodo de Invocación muestra los parámetros de arriba a abajo con el nombre del método en la parte superior y los parámetros opcionales, que están atenuados, en la parte inferior.

Métodos de ejemplo Un ejemplo de método común a todos los controles es Reinitialize to Default. Use este método para reinicializar un control a su valor predeterminado en algún punto del VI. La clase VI tiene un método similar llamado Reinitialize All to Default. La figura 3-4 es un ejemplo de método asociado con la clase Waveform Graph. Este método exporta la imagen del gráfico “waveform graph” al Portapapeles o a un archivo.


Figura 3-4. Nodo de Invocación para el método Export Image

D. Referencias de control

Un Nodo de Propiedad creado desde el objeto del panel frontal o el terminal del diagrama de bloques es un Nodo de Propiedad vinculado implícitamente. Esto significa que el Nodo de Propiedad está vinculado al objeto del panel frontal. ¿Qué ocurre si usted debe colocar los Property Nodes en un subVI? Entonces los objetos ya no se encuentran en el panel frontal del VI que contiene los Property Nodes. En este caso, necesita un Nodo de Propiedad explícitamente vinculado. Un Nodo de Propiedad explícitamente vinculado se crea cableando una referencia a un Nodo de Propiedad genérico. Si está creando un VI que contiene varios Nodos de Propiedad o si está accediendo a la misma propiedad para varios controles e indicadores distintos, puede colocar el Nodo de Propiedad en un subVI y usar referencias de control para acceder a ese nodo. Una referencia de control es una referencia a un objeto concreto del panel frontal. Esta sección muestra una forma de usar referencias de control. Consulte el tema Controlling Front Panel Objects de la Ayuda de LabVIEW para obtener información adicional acerca de las referencias de control.


Lección 3


Creación de un SubVI con Nodos de Propiedad Como en la figura 3-5, el modo más sencillo de crear Nodos de Propiedad explícitamente vinculados es completar los siguientes pasos: 1. Cree el VI. 2. Seleccione la parte del diagrama de bloques que se encuentre en el subVI, como se muestra en la primera parte de la figura 3-5. 3. Seleccione Edit»Create SubVI. LabVIEW crea automáticamente las referencias de control necesarias para el subVI. 4. Personalice y guarde el subVI. Como puede ver en la segunda parte de la figura 3-5, el subVI usa el icono predeterminado.


Figura 3-5. Uso de Edit»Create SubVI para crear referencias de control

Objetos seleccionados para crear el subVI

Edit»Create SubVI utilizado

La figura 3-6 muestra el subVI creado. Observe que los controles Control Refnum del panel frontal se han creado y conectado a un Nodo de Propiedad del diagrama de bloques. Figura 3-6. SubVI creado usando Edit»Create SubVI

Panel frontal del subVI creado

Diagrama de bloques del subVI creado

Una estrella roja en el control Control Reference indica que el refnum es de tipo estricto. Consulte la sección Strictly Typed and Weakly Typed Control Refnums del tema Controlling Front Panel Objects de la Ayuda de LabVIEW para obtener información adicional acerca de las referencias de control de tipo débil y estricto.

Nota

3-6 | ni.com


Creación de referencias de control Para crear una referencia de control para un objeto del panel frontal, haga clic con el botón derecho en el objeto o en su terminal del diagrama de bloques y seleccione Create»Reference en el menú contextual. Puede cablear esta referencia de control a un Nodo de Propiedad genérico. Puede pasar la referencia del control a un subVI usando un terminal de refnum de control.

Uso de referencias de control


Configurar propiedades con una referencia de control resulta útil para configurar la misma propiedad para varios controles. Algunas propiedades se aplican a todas las clases de controles, como la propiedad Disabled. Algunas propiedades sólo se aplican a ciertas clases de control, como la propiedad Lock Boolean Text in Center. El siguiente ejemplo muestra cómo crear un VI que use una referencia de control en el subVI para configurar el estado Enable/Disable de un control en el panel frontal del VI principal. Figura 3-7. Referencias de control

1

1

VI principal

2

2

SubVI


Lección 3


El VI principal envía una referencia para el control numérico digital al subVI junto con un valor cero, uno o dos desde el control enumerado. El subVI recibe la referencia mediante el Ctl Refnum en su ventana del panel frontal. A continuación, la referencia se pasa al Nodo de Propiedad. Como el Nodo de Propiedad ahora se vincula con el control numérico del VI principal, el Nodo de Propiedad puede cambiar las propiedades de ese control. En este caso, el Nodo de Propiedad manipula el estado enabled/disabled.


Observe el aspecto del Nodo de Propiedad en el diagrama de bloques. No puede seleccionar una propiedad en un Nodo de Propiedad genérico hasta que se elija la clase. La clase se elige cableando una referencia al Nodo de Propiedad. Éste es un ejemplo de un Nodo de Propiedad explícitamente vinculado. No se vincula a un control hasta que el VI se esté ejecutando y se pase una referencia al Nodo de Propiedad. La ventaja de este tipo de Nodo de Propiedad es su naturaleza genérica. Como no tienen vínculo explícito a un control, puede reutilizarse para varios controles. El Nodo de Propiedad genérico está disponible en la paleta de Funciones.

Selección de la Clase VI Server

Cuando añade un Control Refnum al panel frontal de un subVI, a continuación debe especificar la VI Server Class del control. Esto especifica el tipo de referencias de control que aceptará el subVI. En el ejemplo anterior, se seleccionó Control como tipo de VI Server Class, como en la figura 3-7. Esto permite que el VI acepte una referencia a cualquier tipo de control del panel frontal. Sin embargo, puede especificar una clase más concreta para el refnum de manera que el subVI sea más restrictivo. Por ejemplo, puede seleccionar Digital como la clase. Así, el subVI sólo podrá aceptar referencias a controles numéricos de la clase Digital. Si selecciona una clase más genérica para un refnum de control, permitirá que acepte un rango de objetos mayor, pero limitará las propiedades disponibles que se aplican a todos los objetos que pueda aceptar el Nodo de Propiedad. Para seleccionar una clase específica de control, haga clic con el botón derecho en el control y seleccione Select VI Server Class»Generic»GObject»Control en el menú contextual. A continuación, seleccione la clase concreta de control.

3-8 | ni.com


Creación de propiedades y métodos con la ventana Class Browser Puede utilizar la ventana Class Browser para seleccionar una librería de objetos y crear una nueva propiedad o método. Complete los siguientes pasos para crear una nueva propiedad o método utilizando la ventana Class Browser.


1. Seleccione View»Class Browser para mostrar la ventana Class Browser.

2. En el menú desplegable de la librería Object, seleccione una librería.

3. Seleccione una clase en el menú desplegable Class. Use los siguientes botones para navegar por las clases. •

Haga clic en el botón Select View para alternar entre una vista alfabética y una vista jerárquica de los elementos del menú desplegable Class y la lista Properties y métodos.

•

Haga clic en el botón Search para lanzar el cuadro de diálogo Class Browser Search.


Lección 3


4. En la lista Properties and Methods de la ventana Class Browser, seleccione una propiedad o método. La propiedad o método que seleccione aparecerá en el cuadro Selected property or method. 5. Haga clic en el botón Create o Create Write para añadir un nodo con la propiedad o método seleccionados al cursor del ratón y añadir el nodo al diagrama de bloques. El botón Create crea una propiedad para lectura o un método. Este botón se atenúa cuando selecciona una propiedad de sólo escritura. Para crear una propiedad para escritura, haga clic en el botón Create Write. Este botón se atenúa cuando selecciona un método o una propiedad de sólo lectura. También puede arrastrar una propiedad o método desde la lista Properties and Methods directamente al diagrama de bloques.


6. Repita los pasos 2 al 5 para otras propiedades o métodos que desee crear y añadir al diagrama de bloques.

3-10 | ni.com


Autorrevisión: Cuestionario 1. Para cada uno de estos elementos, determine si funcionan en una clase VI o en una clase Control. •

Format and Precision

•

Visible

•

Reinitialize to Default Value

•

Show Tool Bar


2. Usted tiene un refnum de control numérico, se muestra a la izquierda, en un subVI. ¿Cuál de las siguientes referencias de control podría cablear al terminal de refnum de control del subVI? (varias respuestas)

a. Referencia de control de un mando

b. Referencia de control de un array numérico

c. Referencia de control de un indicador de termómetro d. Referencia de control de un LED




Autorrevisión: Respuestas 1. Para cada uno de estos elementos, determine si funcionan en una clase VI o en una clase Control. •

Format and Precision: Control

•

Visible: Control

•

Reinitialize to Default Value: Control

•

Show Tool Bar: VI


2. Usted tiene un refnum de control numérico, se muestra a la izquierda, en un subVI. ¿Qué referencias de control podría cablear al terminal de refnum de control del subVI?

a. Referencia de control de un mando

b. Referencia de control de un array numérico

c. Referencia de control de un indicador de termómetro d. Referencia de control de un LED


Lección 3



Notas

3-14 | ni.com

LabVIEW Core 2 Curso.pdf

Recommend Documents