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



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.



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.



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



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*



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


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



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 | 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



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


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.



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



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.



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



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



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


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.



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



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



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


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.



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



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.



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


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.



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



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.



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


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



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



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.



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


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.



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



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.



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


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.



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



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



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



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



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



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


1-18 | ni.com

Notas



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


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



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.



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



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.



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


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



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



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.



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


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



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



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



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


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.



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



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.



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


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.



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



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.



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


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.



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



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



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


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)




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



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)




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


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.



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



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



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


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



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



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.



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


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.



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



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.



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


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.



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



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.



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


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.



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



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.



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


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



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



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.



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



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.



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


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



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



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.



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



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




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



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



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



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



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


2-36 | ni.com

Notas



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


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



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



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



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



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


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.



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



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.



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


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



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



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



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


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.



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



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.



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


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.



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




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



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



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


Notas

labview core 2 curso.pdf

Documents