LabVIEW Core 2 Curso.pdf
-
Upload
alejandro-noriega -
Category
Documents
-
view
741 -
download
80
Transcript of LabVIEW Core 2 Curso.pdf
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 1/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
LabVIEW™ Core 2
Manual de Curso
ni.com/training
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 2/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
LabVIEWTM Core 2Manual de Curso
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 puedeutilizarse 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 <National Instruments>\_Legal Information y <National
Instruments>.
• Contrato de licencia de usuario final se localiza en el directorio <National Instruments>\Shared\MDF\
Legal\License.
• Revise <National Instruments>\_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 sonmarcas 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 3/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 4/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
© National Instruments | iii
Contenido
Guía del estudianteA. Certificación de NI................................................................................................ v
B. Descripción del curso............................................................................................ v
C. Lo que necesita para empezar ...............................................................................vi
D. Instalación del software del curso......................................................................... vii
E. Objetivos del curso ...............................................................................................vii
F. Convenciones del curso ........................................................................................viii
Lección 1
Más allá del flujo de datosA. 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ñoA. Patrones de diseño ................................................................................................2-2
B. Patrones de diseño simple.....................................................................................2-2
C. Patrones de diseño de bucles múltiples................................................................. 2-8
D. Gestores de errores................................................................................................ 2-15
E. Generando códigos de error y mensajes ...............................................................2-18
F. Temporizar un patrón de diseño ...........................................................................2-20
G. Patrón de diseño variable global funcional..........................................................2-25
Lección 3Control de la interfaz de usuario
A. Arquitectura del VI Server....................................................................................3-2
B. Nodos de Propiedad ..............................................................................................3-3
C. Nodos de Invocación ............................................................................................3-4
D. Referencias de control ..........................................................................................3-5
Lección 4
Técnicas de E/S de ficheroA. Comparando formatos de archivo.........................................................................4-2
B. Crear rutas de archivos y carpetas ........................................................................4-4C. Lectura y escritura de archivos binarios ...............................................................4-6
D. Trabajar con archivos de texto y encabezados multicanal.................................... 4-12
E. Acceso de archivos TDMS en LabVIEW y Excel................................................4-17
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 5/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
© National Instruments | v
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.
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.
Advanced User
LabVIEW Core 1*
LabVIEW Core 2*
Certified LabVIEWArchitect Exam
New User Experienced User
Advanced Architecturesin LabVIEW
*Core courses are strongly recommended to realize maximum productivity gains when using LabVIEW.
Courses
Certifications
Other Courses
Certified LabVIEWAssociate Developer Exam
LabVIEW Instrument Control
Modular Instruments Series
LabVIEW Real-Time 2
LabVIEW FPGA
LabVIEW Real-Time 1
LabVIEW DAQ and Signal Conditioning
Managing SoftwareEngineering in LabVIEW
LabVIEW Performance
Ob ject-Oriented Designand Programming
in LabVIEW
LabVIEW Connectivity
Certified LabVIEWDeveloper Exam
LabVIEW Core 3*
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 6/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Guía del estudiante
vi | ni.com
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.
Nota 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.
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 generadorde 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
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 7/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | vii
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 <Exercises>\LabVIEW Core 2\ .
Nota Los nombres de carpetas entre corchetes angulares, como <Exercises>, 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
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 8/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Guía del estudiante
viii | ni.com
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.
Este icono indica una precaución, para que tome precauciones y evite
lesiones, pérdida de datos o una caída del sistema.
negrita 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.
cursiva 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.
monospace 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 desintaxis. 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 9/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
© National Instruments | 1-1
1Más allá del flujo de datos
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.
Temas
A. Comunicación asíncronaB. Colas
C. Programación orientada a eventos
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 10/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 1 Más allá del flujo de datos
1-2 | ni.com
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 eldiagrama 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 colaUtilice 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
Añade un elemento en la parte frontal de la cola.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 11/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 1-3
Consulte el tema Queue Operations Functions en la Ayuda de LabVIEW para obtener una listacompleta 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
Get Queue Status Retorna información sobre el estado actual de una cola, tales
como el número de elementos actualmente en la cola.
Obtain Queue Retorna la referencia a una cola.
Release Queue Libera la referencia de una cola.
Tabla 1-1. Funciones de operación de cola (Continuación)
Funciones Descripción
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 12/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 1 Más allá del flujo de datos
1-4 | ni.com
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ógicaEl 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ónRelease 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 13/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 1-5
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
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 14/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 1 Más allá del flujo de datos
1-6 | ni.com
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 eventoUse 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 eldiagrama 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. Laestructura 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 15/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 1-7
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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 16/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 1 Más allá del flujo de datos
1-8 | ni.com
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.
Nota 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.
Consulte la Ayuda de LabVIEW para obtener información de los valores predeterminados para cada
tipo de datos.
Uso de eventos en LabVIEWLabVIEW 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 configurarestá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.
Nota 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 17/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 1-9
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.
Nota 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 elcaso 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.
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 frontalque 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) untilthis 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 18/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 1 Más allá del flujo de datos
1-10 | ni.com
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.
Precaución 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.
Registro de eventos estáticosEl 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 eventosAntes 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
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 19/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 1-11
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ó cuandoregistró 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 deeventos 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 filtradoLos 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 ainteracciones 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 20/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 1 Más allá del flujo de datos
1-12 | ni.com
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.
Nota 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.
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 loseventos.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 21/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 1-13
Consulte la sección Uso de eventos en LabVIEW de esta lección para obtener información adicional
acerca del registro de eventos.
Consejo 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.
Ejemplo de eventosLa 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 recomendacionesLa 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 22/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 1 Más allá del flujo de datos
1-14 | ni.com
• 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 usuariodel 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 23/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 1-15
Autorrevisión: Cuestionario
1. ¿Cuál de los siguientes elementos almacena temporalmente datos?
a. Colas
b. Eventosc. Variables locales
2. Una los siguientes elementos:
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
Obtain Queue Destruye la referencia de la cola
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
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 24/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 25/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 1-17
Autorrevisión: Respuestas
1. ¿Cuál de los siguientes elementos almacena temporalmente datos?
a. Colas
b. Eventosc. Variables locales
2. Una los siguientes elementos:
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
Obtain Queue Asigna el tipo de datos de la cola
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
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 26/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 1 Más allá del flujo de datos
1-18 | ni.com
Notas
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 27/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
© National Instruments | 2-1
2Implementando patrones de diseño
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 erroresE. Generando códigos de error y mensajes
F. Temporizar un patrón de diseño
G. Patrón de diseño variable global funcional
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 28/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 2 Implementando patrones de diseño
2-2 | ni.com
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 lasté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 arquitecturacomplicada. 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 29/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 2-3
Figura 2-1. Arquitectura del VI simple
Patrón de diseño del VI generalUn 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 30/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 2 Implementando patrones de diseño
2-4 | ni.com
Consejo 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.
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
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 31/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 2-5
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 producirerrores 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 32/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 2 Implementando patrones de diseño
2-6 | ni.com
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 lograrmetas 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.
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.
Initialize
Wait forEvent
Stop
UserState 2
UserState 1
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 33/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 2-7
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ódigode 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
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.
1 Estructura Event2 Bucle While
3 Terminal Timeout4 Event Data Node
3
2
1
4
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 34/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 2 Implementando patrones de diseño
2-8 | ni.com
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 / consumidorEl 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.
Consejo Un búfer es un dispositivo de memoria que almacena datos temporales entre
dos dispositivos o, en este caso, múltiples bucles.
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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 35/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 2-9
Consejo 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.
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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 36/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 2 Implementando patrones de diseño
2-10 | ni.com
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 dediseñ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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 37/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 2-11
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 <Exercises>\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ónde 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 38/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 2 Implementando patrones de diseño
2-12 | ni.com
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 <Exercises>\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 valordel 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 Eventson 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 39/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 2-13
Ayuda de TrabajoUse 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 Uso Ventajas Desventajas
Simple subVIs estándar
Cálculos / algoritmos,
procesamiento
modular
Equivalente de
LabVIEW de una
subrutina en otros
lenguajes de
programación
Permite aplicaciones
modulares
No es adecuado para
el diseño de la
interfaz de usuario o
VIs de alto nivel
General Control de flujo
estándar
Bueno para prototipos
rápidos o aplicaciones
sencillas y directas
que no crecen en
complejidad
Diferencia entre
fases de
inicialización,
ejecución y de
parada
No puede retornar a
una fase anterior
Máquina de estados
(sondeo)
Controla la
funcionalidad de unVI mediante la
creación de una
secuencia
Secuencias de
control
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.
Una Interfaz de
usuario basada ensondeo no es
escalable a medida
que la aplicación
crece
No es apto para el
paralelismo
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 40/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 2 Implementando patrones de diseño
2-14 | ni.com
Máquina de estados
(Basada en eventos)
Controla la
funcionalidad de un
VI mediante lacreación de una
secuencia
Secuencias de
control
Mantenimiento delcó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
No es apto para el
paralelismo
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)
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 losdatos 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
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 41/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 2-15
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 eldesarrollo 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 unerror. 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.
Productor/consumidor
(eventos)
Responde a la interfaz
de usuario con
aplicaciones de usointensivo del
procesador
Separa la interfaz de
usuario del código de
procesamientointensivo
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
Ejecuta operaciones
en función de la
selección de entrada
Una buena manera
de proteger las
secciones críticas de
código para eliminar
las condiciones de
carrera
No es adecuado para
VIs reentrantes
Problemático al
duplicar o ampliar los
datos globales con
múltiples copias y
realizar acciones en
dichas copias
Tabla 2-1. Comparación entre patrones de diseño (Continuación)
Patrones de diseño Uso Ventajas Desventajas
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 42/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 2 Implementando patrones de diseño
2-16 | ni.com
Figura 2-10. Gestor de errores de la máquina de estados
Gestión de errores en el patrón de diseñoproductor/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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 43/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 2-17
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
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 44/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 2 Implementando patrones de diseño
2-18 | ni.com
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
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 45/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 2-19
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 estasituació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 RingSe 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 46/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 2 Implementando patrones de diseño
2-20 | ni.com
Definiendo un codigo de error personalizadoLa 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ónLa 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 facilitaespecí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.
Consejo 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.
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 ejecutacontinuamente, LabVIEW usará todo el tiempo del procesador y quizá no se ejecuten los
procesos en segundo plano.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 47/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 2-21
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 decolas 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 unelemento de la cola. Después de que la función Queue recibe un elemento de la cola, el bucleconsumidor 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 detemporización de ejecución esperando un evento.
Al implementar patrones de diseño basados en temporización de aparición de eventos, se puedeutilizar los mecanismos de sincronización de eventos para la ejecución temporizada y controltemporizada por software. Funciones de sincronización y la estructura Event incluyen una funciónde Timeout. El valor predeterminado para un Timeout es -1, esto indica una espera infinita. Con unTimeout 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 unelemento es puesto en cola, controlando así la ejecución en el bucle consumidor. Patrones de diseñotales como el productor/consumidor (eventos), no requieren temporización, debido a que sutemporización es controlada por eventos externos.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 48/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 2 Implementando patrones de diseño
2-22 | ni.com
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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 49/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 2-23
Figura 2-17. Caso de eventos con Timeout en patrones de diseño productor/consumidor conejecución temporizada
Temporización de control del softwareMuchas 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 durante5 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 50/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 2 Implementando patrones de diseño
2-24 | ni.com
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 desoftware, 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 dedesplazamiento, 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 51/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 2-25
Consejo 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.
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-escrituraUna 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 esperadodespué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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 52/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 2 Implementando patrones de diseño
2-26 | ni.com
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
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 53/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 2-27
Controlar y limitar recursos compartidosLas 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 compartidoy 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íticasUna 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áforosLos 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 seinterrumpan 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 54/76
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 55/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 2-29
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
Variables globales funcionalesUna 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 suturno” 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 56/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 2 Implementando patrones de diseño
2-30 | ni.com
Figura 2-23. Formato de variables globales funcionales
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.
Consejo Antes de utilizar una variable local o global, asegúrese de que una variable
global funcional no habría funcionado en su lugar.
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
1 Registro de desplazamiento sin inicializar
Functional Global Variable Code
1
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 57/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 2-31
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ónUna 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. Amenudo 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 58/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 59/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 2-33
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 esperad. El valor de entrada de la función Wait (ms) que exista en el mismo bucle que la estructura
Event
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 60/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 61/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 2-35
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 esperad. El valor de entrada de la función Wait (ms) que exista en el mismo bucle que la estructura
Event
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 62/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 2 Implementando patrones de diseño
2-36 | ni.com
Notas
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 63/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
© National Instruments | 3-1
3Control 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
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 64/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 3 Control de la interfaz de usuario
3-2 | ni.com
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 útilentender la terminología asociada a él.
Terminología orientada a objetosLa 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 controlLos 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
Clase VI
Los controles no son los únicos objetos de LabVIEW que pertenecen a una clase. Un VI pertenecea 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.
Array Sub-ClassExample Property: Number of Rows
Stop ObjectVisible: YesReinitialize to Default: NoBoolean Text: Stop
Boolean Sub-ClassExample Property: Boolean Text
Control ClassExample Property: VisibleExample Method: Reinitialize to Default
Boolean
Stop
Array
Control
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 65/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 3-3
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 PropiedadCuando 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 PropiedadCuando 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
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 66/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 3 Control de la interfaz de usuario
3-4 | ni.com
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.
Consejo Algunas propiedades son sólo de lectura, como la propiedad Label, o sólo de
escritura, como la propiedad Value (Signaling).
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.
Consejo Los Nodos de Propiedad ejecutan cada terminal en orden de arriba a abajo.
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 alas 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 yseleccionando 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 67/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 3-5
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 ejemploUn 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 68/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 3 Control de la interfaz de usuario
3-6 | ni.com
Creación de un SubVI con Nodos de PropiedadComo 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 enla 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
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
Nota 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ónadicional acerca de las referencias de control de tipo débil y estricto.
Objetos seleccionados para crear el subVI Edit»Create SubVI utilizado
Panel frontal del subVI creado Diagrama de bloques del subVI creado
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 69/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 3-7
Creación de referencias de controlPara 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 lareferencia del control a un subVI usando un terminal de refnum de control.
Uso de referencias de controlConfigurar 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 VI principal 2 SubVI
1 2
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 70/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 3 Control de la interfaz de usuario
3-8 | ni.com
El VI principal envía una referencia para el control numérico digital al subVI junto con un valorcero, 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. Comoel Nodo de Propiedad ahora se vincula con el control numérico del VI principal, el Nodo dePropiedad puede cambiar las propiedades de ese control. En este caso, el Nodo de Propiedadmanipula 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 cableandouna referencia al Nodo de Propiedad. Éste es un ejemplo de un Nodo de Propiedad explícitamentevinculado. 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. Comono tienen vínculo explícito a un control, puede reutilizarse para varios controles. El Nodo dePropiedad 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 laVI 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 seamá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 yseleccione Select VI Server Class»Generic»GObject»Control en el menú contextual. Acontinuación, seleccione la clase concreta de control.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 71/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 3-9
Creación de propiedades y métodos con la ventana ClassBrowserPuede 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 72/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 3 Control de la interfaz de usuario
3-10 | ni.com
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 propiedadde 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.
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 73/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Manual de Curso LabVIEW Core 2
© National Instruments | 3-11
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
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 74/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 75/76
7/22/2019 LabVIEW Core 2 Curso.pdf
http://slidepdf.com/reader/full/labview-core-2-cursopdf 76/76
N a t i o n a l I
n s t r u
m e n t s
N o t f o
r d i s t r i b u
t i o n
Lección 3 Control de la interfaz de usuario
Notas