LabVIEW Instrumentación Virtual

Instituto gfghf Instituto Superior Politécnico

CUJAE
Automática y Computación
"José Antonio Echeverría",
CUJAE, Marianao, Ciudad
Habana, Apdo. Postal 19390,
260 6778 , 260-2055
/ FAX: 267 29 64

PROGRAMACIÓN EN LABVIEW. PROGRAMACIÓN EN LENGUAJE “G”. TIPOS DE DATOS
SIMPLES Y COMPLEJOS. ESTRUCTURAS DE CONTROL DE FLUJO. TRABAJO CON
FICHEROS, TRABAJO CON TARJETAS DE ADQUISICIÓN DE DATOS, PUERTO SERIE Y
PARALELO, TCP-IP Y DDE.

Monografía elaborada por Dr. Valery Moreno Vega y Msc. Adel Fernández Prieto para el curso
de Instrumentación Virtual dictado dentro de la asignatura Automática III en la carrera de
Automática de la Facultad de Ingeniería Eléctrica del ISPJAE.

Direcciones de Contacto:
Email:
valery@electrica.cujae.edu.cu y adel@electrica.cujae.edu.cu
Teléfonos: 2663342, 2602055.

1ra Versión Revisada en Abril 2005.

Departamento de Automática y Computación 18/11/2006

Indices

Índice 1
Introducción 2
Tema I Conceptos básicos 4
Tema II LabVIEW básico 9
Tema III Tipos de datos simples 29
Tema IV Control de flujo de programa en LabVIEW. Estructuras repetitivas. 55
Tema V Más estructuras de control de flujo. 79
Tema VI Tipos de datos complejos. arreglos y clusters 95
Tema VII Controles forma de onda. implementación de funciones en LabVIEW 117
Tema VIII Trabajo con ficheros 142
Tema IX. Tarjetas de adquisición de datos (PCL-818L). 161
Tema X Trabajo con puerto serie en LabVIEW 200
Tema XI Trabajo con puerto paralelo en LabVIEW 213
Tema XII Comunicación TCP-IP en LabVIEW 221
Tema XIII Comunicación DDE 235

Dr.Valery Moreno Vega y Msc.Adel Fernández Prieto. 1


Introducción:

En esta monografía el lector encontrará una introducción a algunos temas relacionados con la
instrumentación virtual y específicamente sobre la herramienta de programación LabVIEW.
Los temas abordados comprenden:

1. LabVIEW básico
a. Los Instrumentos virtuales.
b. Los conceptos de control e indicador.
c. El ambiente de desarrollo.
d. Tipos de datos simples.
e. Estructuras de control de flujo.
f. Tipos de datos complejos.
g. Confección de funciones (subVI).
h. Trabajo con ficheros.
2. LabVIEW avanzado
a. Trabajo con tarjetas de adquisición de datos.
b. Trabajo con puerto serie y paralelo.
c. Trabajo con TCP-IP.
d. Trabajo con DDE.

El primer tema es necesario como introducción a cualquier lenguaje de programación, y en el
mismo se abordan los conceptos en que se basa la programación gráfica.

Es de destacar que en la programación gráfica todo esta muy ligado a la iconografía con que
se representan los diferentes elementos. Un lector que esté acostumbrado a los lenguajes por
comandos, llega a identificarse con las palabras claves que forman determinado lenguaje, por
ejemplo: un for, int, switch en C++, sin embargo, con LabVIEW este concepto cambia, para
ahora asociar una forma o icono en vez de un conjunto de caracteres con las palabras claves.

LabVIEW es un lenguaje de programación construido sobre la base de objetos, sin embargo no
es posible construir nuevos objetos, como pudiera hacerse con otros lenguajes como C++,
Java, Pascal etc, es por ello que la manera de construir aplicaciones es a través de una
metodología de programación estructurada, utilizando como recurso la implementación de
funciones, que en este caso se denominan “SubVI”.

El presente trabajo comienza con una breve explicación de los conceptos básicos relacionados
con esta herramienta de trabajo, para luego exponer la totalidad de los temas mediante
ejercicios resueltos, que el lector puede realizar desde su computadora personal o laboratorio.
De esta manera se introducen los tipos de datos, las sentencias de control de flujo y la
biblioteca de funciones básica y especializada, a través de ejemplos. También a lo largo de
estos temas se proponen ejercicios como estudio independiente.

El segundo tema que aquí hemos denominado como LabVIEW avanzado, no incluye ni mucho
menos todos los temas que por este nombre pudieran estar. Simplemente nos a parecido que
se salen del modulo básico de esta herramienta. Es de destacar que el trabajo con las tarjetas
de adquisición de datos se realiza basado en la PCL-818L, esta es solo una, de muchísimas
variantes que existen actualmente en el mercado, sin embargo, el estudio detallado que se
hace de la misma, y la metodología de diseño de su controlador, nos parece un punto de
partida práctico que puede ser utilizado por los interesados para generalizarlo a tarjetas de
otros fabricantes.

Quedan fuera temas tan interesantes como el estudio de las funciones de análisis matemático,
el uso de filtros para señales de entrada. Además, el estudio de los DataSockets que se basan
en el protocolo TCP-IP. También el trabajo con OLE/Active X y la conexión con Bases de Datos
profesionales.

Sin embargo, ya el volumen de esta edición es suficiente mente largo. Es de destacar que su
estructura esta completa, siguiendo una secuencia donde lo aprendido sirve de base a lo que
se aprende y donde ningún concepto queda fuera de lo que se ha abordado anteriormente.



Esta edición un poco abre una primera puerta a la escasez de bibliografía que existe alrededor
del Lenguaje de programación LabVIEW. Sabemos que estos lenguajes son susceptibles de
actualizaciones, pero también el hecho de que los temas abordados son los suficientemente
básicos, incluyendo aquellos que se denominaron como avanzados, nos da suficiente paz,
como para pensar que este volumen se pueda utilizar por algunos años, no diez o veinte, pero
si hasta tres años.

Esperamos disfrute y encuentre útil esta monografía. Es ese el deseo de los autores.

Los autores.



TEMA I Conceptos Básicos

Primeramente antes de entrar en que es el LabView vamos a conocer nuevos conceptos
acerca de la Instrumentación Virtual. Semánticamente virtual es algo aparente, que no es real
pero que se comporta como tal. En la actualidad se manejan términos como los de
instrumentación virtual, laboratorio virtual, ambientes virtuales, y realidad virtual. No se debe
confundir laboratorio virtual con instrumento virtual aunque existe una estrecha relación. Se
habla de laboratorio virtual cuando se simula un proceso o sistema que se parece y se
comporta como un proceso o sistema real, para poder observar su comportamiento. Se habla
de instrumento virtual cuando se emplea la computadora para realizar funciones de un
instrumento clásico pudiendo agregarle al instrumento otras funciones a voluntad. A pesar de
esta pequeña diferencia, un laboratorio con instrumentos virtuales es un laboratorio virtual.

En el campo de la instrumentación quien introdujo por primera vez el termino virtual fue la
compañía National Instrument en 1986, al elaborar un programa que de manera simple y
gráfica permitiera simular un instrumento en una PC, con lo cual dio origen al concepto de
instrumento virtual; definido como “un instrumento que no es real, corre en una computadora y
tiene funciones definidas por programación”. El instrumento tradicional ya está definido, con
capacidades de entrada/salida de señales y una interfaz de usuario fija. El fabricante define la
funcionalidad del instrumento, el usuario no puede cambiarla. Dada la arquitectura abierta de
los PCs y las estaciones de trabajo, la funcionalidad de los instrumentos virtuales esta definida
por el usuario. Además, la capacidad de procesamiento de los instrumentos virtuales es
superior a la de instrumentos estándares, debido a la rápida evolución de la tecnología de los
PCs y de las estaciones de trabajo como resultado de las grandes inversiones que se efectúan
en la industria.

En 1986 National Instruments introdujo LabView 1.0 con el propósito de proveer una
herramienta de software que permitiera a los ingenieros desarrollar sistemas a la medida de
sus necesidades, del mismo modo que la hoja de cálculo permitía a los hombres de negocios
analizar datos financieros. Este nombre LabView viene de las siglas en ingles Laboratory
Virtual Instrument Engineering Workbench.

La versión del LabView 6.1 y los requerimientos mínimos son:
1. 32 MB de RAM y 65 MB de HD / Parcial, 300MB Completa.
2. Incluye Windows NT 4.0 o superior

¿Que es el LabView?.

El LabView es un programa para el desarrollo de aplicaciones de propositos generales, tales
como el C, el Basic, el Pascal.

Herramientas de Desarrollo de Software

Ambiente de + Lenguaje de
desarrollo Programación
Figura1: Esquema general



Ambiente de Desarrollo

Todo ambiente de desarrollo testa formado por los siguientes elementos. Es importante que se
busque y se practiquen con frecuencia ya que esto permite que el desarrollo de las
aplicaciones se realice con mayor rapidez y calidad.

Depuración
• Puntos de ruptura.
• Ejecución paso a paso.
• Ventana de seguimiento a variables
Facilidades de desarrollo
• Panel frontal: Para observar el estado de las pantallas que estamos desarrollando.
• Paletas de funciones y controles para adicionar a nuestro proyecto.
• Herramientas para alinear los controles y funciones.

Lenguaje de Programación.

LabVIEW usa el lenguaje de programación gráfico Lenguaje G. Las posibilidades son
normalmente las mismas que presenta cualquier lenguaje de programación:

Sentencias (Gráficos) de control de Flujo y repetitivas.
Posibilidad de declaración de variables.
Modularidad a través de la confección de funciones. Trabajo con los eventos y
propiedades de los controles y variables.
Incluye bibliotecas de funciones extendidas para cualquier tarea de programación.
Basado en objetos pero no permite nuevas declaraciones.
Mecanismos de conexión con lenguaje C y C++ y DLL.

Algo muy característico de LabVIEW y es por ello que se considera una herramienta para el
desarrollo de instrumentos virtuales, es su extensa biblioteca de funciones especializada en la
adquisición, acceso a buses de campo, procesamiento matemático y procesamiento de señales

Tarjetas de adquisición de datos
Bus GPIB.
Entrada/ Salida (Puerto serie y paralelo). Arquitectura VISA.
Análisis de señales.
Almacenamiento de datos.
Comunicación (TCP-IP, UDP y otros).
Matemáticas.

¿Cómo se trabaja con el LabVIEW?

Los programas en LabVIEW son llamados Instrumentos Virtuales (y son salvados con la
extensión .VI).

Los programas de LabVIEW constan de un panel frontal y un diagrama de bloques. En el panel
frontal se diseña la interfaz con el usuario, viene a ser la cara del VI y en el diagrama de
bloques se programa en lenguaje G el funcionamiento del VI.



Programas de LabView (*.vi)

Panel Frontal + Diagrama Bloques

• Diseño de interfaz • Lenguaje G
• Cara del • Lógica del programa
instrumento virtual

El Panel Frontal

El panel frontal de un VI es una combinación de controles e indicadores. Los controles son
aquellos elementos que entregan datos al diagrama en bloques desde el panel frontal por
entrada desde teclado o con el mouse, simulan los dispositivos de entrada de datos del VI y
pasan los datos al diagrama en bloque del VI. Los indicadores son aquellos elementos que
entregan datos al panel frontal desde el diagrama en bloques para ser visualizados en el
display, simulan los dispositivos de salida de datos del VI que toman los datos desde el
diagrama en bloque del VI.
Para adicionar controles o indicadores al panel frontal se seleccionan estos de la paleta de
controles que se encuentra en una ventana flotante y a la cual se accede a través de accionar
el botón derecho del ratón sobre el panel frontal. A los controles e indicadores se les puede
cambiar el tamaño, la forma, y la posición, además cada control o indicador tiene un pop-up
menú en el cual se pueden cambiar varios atributos o seleccionar diferentes opciones.

Los controles:
Entregan datos al diagrama en bloques por mediación del teclado o el ratón,
Simulan dispositivos de entrada de datos del VI

Los indicadores
Muestran datos en el panel frontal desde el diagrama en bloques para ser visualizados
Simulan los dispositivos de salida de datos del VI.

El Diagrama en Bloques



La ventana Diagrama almacena el diagrama en bloques del VI, el código fuente gráfico
(Lenguaje G) del Instrumento Virtual.

Se construye este diagrama con bloques funcionales denominados nodos,
conectándose o uniéndose entre sí según sea el objetivo.

Estos nodos realizan todas las funciones específicas necesarias para el VI y controlan
el flujo de la ejecución del VI.

Tipos de Datos en LabView

Tabla 3.1 Tipos de Datos en LabView
Long I32 32 (4 bytes) -2147483648 hasta 2147483647
Word I16 16 (2 bytes) -32768 hasta 32767
Byte I8 8 (1 bytes) -128 hasta 127
Long Unsigned U32 32 (4 bytes) 0 hasta 4294967295
Word Unsigned U16 16 (2 bytes) 0 hasta 65535
Byte Unsigned U8 8 (1 bytes) 0 hasta 255
Extended EXT 96 (12 bytes) -1.00E–507 hasta 9.00E+515
Double DBL 64 (8 bytes) -5.00E-324 hasta 1.70E+308
Single SGL 32 (4 bytes) -1.40E-45 hasta 3.40E+38
Complex Extended CXT 192 (24 bytes) -1.00E–507 hasta 9.00E+515
Complex Double CDB 128 (16 bytes) -5.00E-324 hasta 1.70E+308
Complex Single CSG 64 (8 bytes) -1.40E-45 hasta 3.40E+38
Cadena(String) abc 1 byte/caracter Conjunto de Caracteres ascii.
Arreglos(Array) [...] Según el tipo de los elementos del arreglo
Grupos (Cluster)
Path
Device

¿Cómo se declaran los tipos de variables numéricas ?

• Cuando se pone un control o indicador en el panel frontal, LabView pone un terminal
correspondiente a este control o indicador en el diagrama en bloque.
• Este terminal desaparece solo cuando se borra el control o indicador.
• Los enlaces o alambres son los caminos de los datos entre los terminales fuente y los
terminales destino.
• No se permite enlazar dos terminales fuentes ni dos terminales destinos, y si se
permite enlazar un terminal fuente a varios terminales destino.
Configuración Representación



Variables locales

Las variables locales permiten hacer lecturas y escrituras sobre el control o indicador al cual
está asociado.

// esto es C
int a = 0 ; //declaración
a = x +y *z; // escritura
m = a* c; // lectura



TEMA II LabVIEW Básico

• Familiarizarse con el entorno de trabajo de LabView, la pantalla de diseño o
panel frontal, y la pantalla o ventana de flujo de programa.
• Conocer los principales indicadores y botones y las acciones más comunes
de los mismos.
• Conocer las teclas de acceso directo y las principales opciones de la ayuda y
de la ejecución del programa.

Ejercicio 1:

Elabore un programa en LabView que permita conectar a un termómetro y un tanque dos
controles de sintonía de manera tal que cuando varíen su valor el nuevo adquirido se refleje en
los indicadores tipo termómetro y en el tipo tanque.

Solución:

Cuando se ejecuta LabView por primera vez aparece una pantalla similar a la siguiente:

En esa pantalla podemos seleccionar varias opciones entre las cuales están el abrir un nuevo
Intrumento Virtual (New VI), abrir uno ya existente, buscar ejemplos, demos, tutoriales, etc.

Para crear un nuevo programa (VI) damos clic en el botón . A
continuación aparece una ventana simular a la que se presenta a continuación:



La primera pantalla que aparece es el panel frontal o ventana de diseño de la aplicación
mientras que la que aparece en segundo plano es la ventana de flujo de programa o de
diagrama. Recuerde que puede conmutar entre uno y otro. Compruébelo con la combinación
Ctrl+E. Muchas veces es conveniente organizar las dos ventanas de forma tal que se dividan la
pantalla cada una en una mitad. Esto facilita el desarrollo del programa. Para lograr dicha
distribución LabView dispone de la combinación Ctrl+T (también se puede realizar mediante la
opción del menú Windows/Tile Left and Right). Una vez que se realiza esta acción se obtiene la
siguiente distribución:



Ya estamos listo para comenzar a darle solución al ejercicio.

Primero seleccionemos los controles que podremos. Para ello seleccionamos mediante un clic
la ventana izquierda (panel frontal) y a continuación damos clic derecho. Debe aparecer un
menú emergente llamado controls. Seleccionamos en controls la primera de las opciones,

que se llama numerics y se representa en el menú controls con el símbolo . Aparecerá
algo similar a:



Observe que en ambas ventanas, la de Controls y la Numeric, en el caption de las mismas
aparece el nombre de la ventana precedido de una especie de tachuela, o sea, . Este
símbolo aparece aquí porque si queremos dejar la ventana fija (para evitar que cada vez que
se quiera poner un nuevo control tengamos que dar clic derecho y buscar la opción que nos
interesa) podemos hacerlo cambiando el ¨estado¨ de la tachuela dando clic encima de ella.
Como en esta aplicación vamos a ubicar más de un control y algunos indicadores, dejemos fija
la ventana de Numeric. Si se procede a ubicar el puntero del mouse en la tachuela que
aparece justo antes de numeric en el caption de la ventana del mismo nombre se observa que
dicha tachuela cambia de posición o forma:

y si en ese momento damos clic obtenemos:



Los controles tipo sintonía son los que se identifican por knob y dial. Son los primeros que
aparecen en la tercera fila de la pantalla anterior. Para incorporarlos a nuestro panel frontal
simplemente los seleccionamos (el tipo de cursor debe ser el de selección que se comentó en
conferencia) que es el que por defecto debemos tener en estos momentos. Si no es ese el que
tenemos podemos cambiarlo visualizando la ventana de herramientas (opción windows/Show
Tools Palette) y seleccionando el mencionado tipo de cursor. El procedimiento se muestra en
las dos ventanas siguientes (el cursor seleccionado aparece “hundido” en comparación con el
resto:



Continuando con la idea original de insertar los controles en el panel frontal, seleccionamos los
de tipo sintonía (1ero y segundo de la tercera fila) en la paleta o ventana numeric mostrada en
las figuras precedentes. La selección se realiza dando clic encima del de interés y colocándolo
en el panel frontal (de la forma usual con que se hace esto en lenguajes visuales como el C++
Builder).
Después de realizada la operación las pantallas deben tener una apariencia como sigue (se
muestra el segmento de interés de las ventanas):



y:

Note que a medida que se introducen los controles en el panel frontal en la pantalla de
diagrama (figura anterior) van apareciendo variables asociadas a los controles. Dichas
variables se identifican con un nombre (el mismo del control, de manera que si se cambia en el
control se cambia en la pantalla de diagrama). En dependencia del tipo de elemento numérico
que se seleccione las variables declaradas serán de escritura (fijan valores) o de lectura
(reciben valores). En este caso los controles del panel frontal tienen variables de escritura. Es



fácil identificar cuando una variable es de lectura o escritura pues LabView nos lo indica con
una especie de saeta, que indica la dirección del flujo de los datos. En el ejemplo anterior
ambas variables están representadas con los símbolos . Note que en dicho símbolo
aparece la saeta indicando salida, o sea, escritura.
En el símbolo anterior también se puede leer la cadena DBL que nos dice de que tipo de datos
es esa variable. Cuando se estudien los tipos de datos simples veremos que este tipo (que por
defecto tienen los controles) es el tipo Double. Los tipos de datos que se definen por defecto
pueden cambiarse. Para ello seleccionamos la variable en la pantalla de diagrama y damos clic
derecho. En el menú emergente que aparece buscamos la opción Representation:

Note que hay varios tipos de datos. El que actualmente está seleccionado aparece encerrado
en un recuadro azul como en la figura anterior. Si se quiere seleccionar otro basta con
seleccionarlo con clic izquierdo. Observe que en dependencia de la variable se podrá
seleccionar para ella distintas representaciones o tipos de datos, pero no todos. En este caso
hay varios tipos de datos que aparecen en gris (los últimos), indicándonos que no se admiten
esos tipos para el actual elemento o control.
Hagamos un cambio, y del tipo DBL por defecto que tiene llevémoslo a U8 que es un tipo de
dato entero corto sin signo (8 bits, de 0 a 255 como posibles valores). Para ello seleccionamos
en el menú de representation el elemento identificado como U8. Los cambios se manifiestan
en la pantalla de diagrama cambiando el color de la variable para indicar el otro tipo (cada tipo
tiene un color). Debemos obtener:



Note que en el panel frontal la escala del control también cambió para adaptarse al nuevo tipo
de variable (por ejemplo, no tiene valores decimales pues es el control es de tipo entero).
De igual forma (clic derecho sobre el control) la apariencia del control en el panel frontal y de su
escala se puede modificar, así como algunas de sus propiedades. En las figuras que aparecen
a continuación se ponen algunos ejemplos:



Otras opciones incluyen escalas logarítmicas (Mapping), espaciado arbitrario o uniforme, etc.
El control también se puede redimensionar, o sea, el tamaño y posición inicial que aparece en
el panel frontal son atributos que se pueden modificar en tiempo de diseño. Cada control lo
indica de una manera fácil de identificar, usualmente mediante un rectángulo que encierra al
control o parte de este durante el movimiento del mouse sobre el elemento. A continuación se
muestra un ejemplo:

Note que se han señalado cuatro esquinas. Moviendo el puntero del
mouse para cualquiera de esas esquinas se puede modificar el radio
de la circunferencia que representa el botón de sintonía. El resto de
los elementos del control, excepto la etiqueta (en este caso Dial),
se redimensionan al redimensionarse la circunferencia.

A continuación se representa al mismo elemento redimensionado.

Hasta este punto se han situado en la pantalla los elementos gráficos que harán la función de
“controles”. Ahora corresponde seleccionar los indicadores que mostrarán su valor de acuerdo



a los controles. Estos indicadores están situados en la misma paleta, o sea en la paleta de
controles numéricos. En este caso utilizaremos el indicador “Tank” y el “thermometer”, que se
seleccionan de la siguiente manera:

Para luego obtener el siguiente diseño:

Para terminar y como se ha mencionado en los talleres, debemos colocar un botón que permita
a los usuarios terminara la aplicación. Para ello debemos seleccionar este control de la paleta
de funciones numéricas. Esto se realiza de la siguiente forma:



El diseño final del “Panel Frontal” queda:

Ahora corresponde trabajar en la ventana del diagrama en bloques. Para ello podemos utilizar
las teclas de acceso rápido (Ctrl+E). En esta ventana debemos utilizar el lenguaje de
programación G para establecer la lógica de nuestra aplicación. Antes de comenzar tenemos
las cinco variables que corresponden a los cinco controles que hemos colocado en la pantalla.
El código luce de la siguiente forma:



El primer código G que debemos programar es el necesario para comenzar y terminar la
aplicación. Para ello se tiene el control “Stop Button” representado por la variable booleana
“stop” (verde ), en la ventana del diagrama. Mientras esta variable sea verdadera se debe
ejecutar nuestro programa. En caso contrario debe terminar la aplicación. Esta situación se
modela en programación a través de un “ciclo while”.

Para incorporar un “ciclo while” a nuestra aplicación se selecciona en la paleta de funciones el

boton: y luego se busca la opción “while loop”.

Una vez que se seleccione, debe irse a la pantalla del diagrama. Ahora el cursor de la
aplicación cambia para indicarle que usted debe seleccionar el área que ocupará el ciclo, esto
se realiza arrastrando el ratón de manera que seleccione el área necesaria, como ilustra la
siguiente pantalla.



Al finalizar se obtiene la siguiente estructura de programa G:

Para finalizar el programa solo nos resta realizar las asignaciones correspondientes. Es fácil
darse cuenta de que las variables que corresponden a los controles deben ser asignadas a las
variables que representan a los indicadores. Para ello debemos utilizar el cursor que se
puede obtener utilizando la tecla (Tab) o seleccionándolo directamente en la paleta de
herramientas “tools Palette”. Una vez conectados el código queda como sigue:



Note que el flujo de los datos va desde el control hacia el indicador y note también que la
representación gráfica de ambas variables pese a ser del mismo tipo de datos no es igual: El
borde es más grueso en los controles que en los indicadores, así como la flecha es de salida
en los primeros y de entrada en los segundos.

Finalmente debemos conectar el control booleano a la condición de salida del ciclo do..While
. Para ello debemos utilizar un “negador” ya que el botón por defecto está en falso. Para ello
se utilizan los operadores boolenos que se encuentran en la paleta de funciones según se
muestra debajo:

Al conectarlos queda de la siguiente forma:



Con ello queda resuelto el problema planteado. Sin embargo ahora debemos correr la
aplicación, para ello se debe utilizar la barra de botones colocada en la ventana del diagrama:

El botón permite ejecutar la aplicación, mientras qué el botón permite terminar de
ejecutar la aplicación.

Para realizar una pausa debemos utilizar el botón , luego podemos utilizar los botones
para ejecutar paso a paso la aplicación. El primero ejecuta instrucción por
instrucción, entrando en las funciones si las hubiera, mientras que el segundo si encontrara
una función, la ejecuta como si fuera un solo paso. El tercer tipo de botón termina la ejecución
paso a paso.

Un botón muy interesante es que ejecuta la aplicación de manera continua pero
introduciendo una demora entre instrucción e instrucción para que pueda depurarse la
aplicación. Además se puede observar los valores asignados a las variables y funciones así
como los valores devueltos por estas.

Si quisiéramos utilizar una ventana de depuración se debe situar el ratón en una de las
conexiones o asignaciones relacionadas con la variable que se debe depurar y dar clic
derecho: A continuación seleccionar la opción “Probe” como se muestra a continuación:

Luego se ve el valor de la variable en una ventana contextual como la siguiente:



Si en el paso anterior a este hubiéramos seleccionado la opción “Set Breakpoint” entonces el
código se ve de la siguiente forma:

Y la aplicación se ejecutará hasta este punto, interrumpiéndose antes de realizar la asignación.

El segundo ejercicio que se propone para este laboratorio permitirá conocer los
diferentes tipos de botones que existen en el Labview. Una vez realizado el mismo se
deberá conocer cuando utilizar uno u otro en dependencia de la aplicación.

Como toda aplicación esta debe comenzar con la realización del código necesario para
ejecutar y terminar la aplicación. Para ello debe colocar un botón booleano de salida y realizar
el código siguiente:

Ahora completamos la interfaz de la aplicación (Panel de Control) con los seis tipos de botones
que se pueden colocar en LabView, además colocaremos seis “leds” que nos indicarán la
manera en que funcionan estos tipos de botones. La interfaz debe quedar de la siguiente
manera:



Luego usted debe programar la opción “Mechanical Action” de los tipos de controles voléanos,
según se indica en el texto. Para ello debe dar clic derecho sobre el botón de la siguiente
manera:

Luego en la ventana del código se asigna a cada botón un “led” que estará encendido solo
cuando el valor del botón es verdadero. Esto queda así:



El funcionamiento de los tres primeros botones es muy parecido. En el primer caso el led se
encenderá si se presione el botón, y permanecerá en ese estado hasta que se vuelva a
presionar el botón. El segundo caso es idéntico pero en este caso cambiará cuando se deje de
presionar el botón. En el tercer caso se encenderá el led mientras se tenga presionado el
botón.

Los siguientes tipos de botones tienen relación con el tiempo que demora el Labview en leer el
cambio de estado de los botones. En el cuarto caso, inmediatamente después que se presione
el ratón sobre el botón este cambiará de estado y permanecerá en él hasta tanto el Labview
pueda leer el cambio de estado. Luego se retornará al estado anterior. La quinta variante es
muy parecida pero en este caso el botón no cambiará de estado hasta que se deje de
presionar el ratón.
La sexta variante funciona de manera que el botón cambia de estado con solo presionar el
botón y permanece encendido todo el tiempo en que se tiene presionado el ratón sobre le
botón. Una vez que se suelte el ratón, el botón permanecerá en este estado hasta tanto el
labview sea capaz de notarlo, luego se retornará al estado anterior.

Para poder entender bien el funcionamiento de los diferentes tipos de botones, sobre todo los
tres últimos, es necesario que ejecute la aplicación utlizando la herramienta de depuración
que hace que el Labview lea con mayor lentitud los controles. Esto hace que se pueda
observar claramente cuando es que se produce la lectura del estado de los botones por el
labview.



TEMA III Tipos de Datos simples

• Familiarizarse con el entorno de trabajo de LabView, la pantalla de diseño o
panel frontal, y la pantalla o ventana de flujo de programa.
• Conocer los tipo de datos principales: numéricos, booleanos y de cadena.
• Conocer los operadores y funciones básicas para el trabajo con los tipos de
datos simples.

Ejercicio 1:

Elabore un programa en LabView que permita indicar el nivel de un tanque en un elemento
gráfico de Labview. El valor del nivel varía entre 0 y 100 unidades y debe obtenerse a través de
una función aleatoria. El programa debe indicar un estado de alarma cuando el nivel sobrepase
un valor de referencia que los usuarios deben establecer. El estado de alarma se indicará por
medio del color del elemento gráfico seleccionado: Azul: estado normal, Rojo: estado de
alarma.

Solución:

Cuando se ejecuta LabView por primera vez aparece una pantalla similar a la siguiente:

En esa pantalla podemos seleccionar varias opciones entre las cuales están el abrir un nuevo
Intrumento Virtual (New VI), abrir uno ya existente, buscar ejemplos, demos, tutoriales, etc.

Para crear un nuevo programa (VI) damos clic en el botón . A
continuación aparece una ventana simular a la que se presenta a continuación:



La primera pantalla que aparece es el panel frontal o ventana de diseño de la aplicación
mientras que la que aparece en segundo plano es la ventana de flujo de programa o de
diagrama. Recuerde que puede conmutar entre uno y otro. Compruébelo con la combinación
Ctrl+E.

Pasos de la solución

1. Primero seleccionemos los controles que pondremos. Para ello seleccionamos mediante un
clic la ventana izquierda (panel frontal) y a continuación damos clic derecho. Debe aparecer un
menú emergente llamado “controls”. Seleccionamos en “controls” la primera de las opciones,

que se llama “numerics” y se representa en el menú “controls” con el símbolo .
Aparecerá algo similar a:



Como se puede observar el elemento “Tank” es el más indicado para representar el nivel que
es requerido en el ejercicio. Para colocarlo en el “panel frontal” del instrumento virtual que
estamos diseñando, debemos seleccionarlo en la paleta de controles y luego soltarlo en el
“panel frontal”.

El resultado es el siguiente:

Existen varias propiedades que podemos variar para este control. Para ello debemos dar clic
derecho sobre el control y seleccionar por ejemplo la opción de mostrar el indicador digital,
como se muestra en la figura siguiente:



2. Según el enunciado del problema debemos colocar la escala del tanque entre los valores de
0 y 100 unidades. Para ello debemos seleccionar el cursor en la paleta de herramientas o

pulsar la tecla “tab”, hasta que el cursor en la pantalla quede de la siguiente manera: .
Una vez que se tiene seleccionado este cursor se da doble-clic sobre el máximo valor de la
escala del indicador “tank”, se cambia la escala de 10 a 100 y se presiona la tecla “enter”. Esto
se realiza de la siguiente manera:

Paso 1 Paso 2

3. El otro elemento gráfico necesario para resolver este ejercicio es un control numérico para
establecer la referencia de la alarma. De la misma manera que se seleccionó el elemento
“Tank” ahora debemos seleccionar un control digital:

Luego la pantalla queda como sigue:



Obsérvese que el nombre del control queda seleccionado, si en este momento se utiliza el
teclado, se puede cambiar directamente el encabezado del control. En este caso debemos
colocar el nombre: referencia de nivel.

4. Para terminar la interfaz de usuario se debe colocar un botón “booleano” que permita
terminar la ejecución de un programa. Esto se realiza en la paleta de controles seleccionando

los elemento booleanos para luego escoger “Stop Button”:

La interfaz final queda como sigue:



Ya estamos en condiciones de programar, en base a los elementos gráficos seleccionados
para nuestra interfaz, la lógica que dará solución a nuestro ejercicio. Para ello pasamos
directamente a la ventana del diagrama (Ctrl+E).

6. El primer código G que debemos programar es el necesario para comenzar y terminar la





7. Una vez que se seleccione, debe irse a la pantalla del diagrama. Ahora el cursor de la
siguiente pantalla.




8. El ciclo tiene dos variable implícitas: la iteración representada por y la condición de
salida, representada por . Si negamos la variable booleana y la conectamos a la condición
de salida, se construye la lógica necesaria para la ejecución y salida del programa.

Para negar la variable booleana “stop” debemos utilizar los operadores booleanos que se
seleccionan en la paleta de funciones como sigue:

9. Allí debemos seleccionar como nuestra la figura, el operdor “Not”. Y colocarlo en nuestra
ventana del diagrama de la siguiente forma:

Antes de conectarlos Después de conectarlos

10. El tipo de datos que representa a nuestro tanque y al controlador de referencia es por
defecto Double . Pero esto se puede cambiar de la misma manera que se hizo en el
laboratorio anterior.

Antes de seguir debemos verificar que la variable “Tank” esté configurada como “indicador” y la
variable “referencia de nivel” esté configurada como “control”.
(Recordar la simbología)

11. Según el enunciado del ejercicio el tanque debe recibir el valor de nivel de una función
aleatoria. En el caso de labview esta función se encuentra entre las funciones numéricas y se
puede escoger como sigue:



12. Esta función brinda un valor aleatorio de tipo “double” entre 0 y 1. Sin embargo nuestra
aplicación requiere que el nivel varía entre 0-100. Para ello debemos multiplicar la salida de
esta función por el valor entero 100. Con ello se logra nuestro objetivo. La función de
multiplicación se encuentra en la misma paleta de funciones numérica y se representa por el
símbolo: que recibe dos valores y devuelve la multiplicación de ambos. Además de esta
propia paleta debe utilizarse una constante numérica entera que contenga el valor 100
que será el otro elemento necesario.

Después de colocar estas funciones y variables se obtiene el siguiente diagrama:

13. Ahora debemos conectar los elementos según la lógica a seguir. En nuestro caso queda
como sigue:



En cada iteración del ciclo el resultado de la función aleatoria se multiplica por 100 y este valor
se asigna a la variable que representa al control tanque.

14. Ahora debemos comparar el valor del tanque con la referencia entrada por el usuario. Si
este valor es mayor que la referencia se cambiará el color del tanque a rojo, sino, el tanque
será de color azul.

Para ello es necesario una función de comparación, que se puede encontrar en la paleta de
funciones “Comparison”:

Ahora la pantalla queda como sigue:

Para modificar el color del tanque debemos utilizar la propiedad FillColor que se
selecciona de la siguiente manera:

15. De clic derecho sobre la variable “Tank” y seleccione la opción Create, a continuación
seleccione la opción “Property Node” según se muestra a continuación:



En la pantalla del diagrama se muestra el siguiente código:

16. En este caso la propiedad de la variable “tank”que se muestra por defecto es “Visible”, sin
embargo si damos clic derecho sobre ella y seleccionamos la opción “Properties” y luego la
opción “Fill Color” entonces nuestra propiedad se convierte en la que buscamos. El código es el
que sigue:



17. Si se observa detenidamente podemos ver que la propiedad “Fill Color” de la variable
“Tank” es de lectura, sin embargo se necesita variar la misma en dependencia del resultado de
la comparación del valor y la referencia. Para cambiar esta propiedad a escritura debemos dar
clic derecho sobre la misma y seleccionar la opción “Change To Write”. Con ello el resultado
grafico es de a .

18. Para continuar nuestra aplicación es necesario un bloque de toma de decisión (bloque if-
then-else) que permita escribir un color u otro en dependencia del resultado de la comparación.
Este bloque puede encontrarse en la “paleta de funciones”, específicamente en la paleta

“Comparison” la función “Select” esta instrucción retorna el valor conectado en “t” o “f”
en dependencia del valor de “s”. Si “s” es verdadero retorna “t”, en caso contrario retorna “f”. “t”
y “f”pueden ser de cualquier tipo de dato. Al colocarlo en nuestro diagrama de bloque, podemos
presionar Ctrl+H para obtener la ayuda contextual que se muestra debajo. El diagrama G ahora
luce como sigue:



El valor que debe retornar la función “Select” debe ser Rojo, si la condición es verdadera y Azul
si es falsa. Para ello es necesario utilizar constantes enteras que representen los colores
deseados.

19. Esto es posible utilizando la paleta de funciones y escogiendo dos constantes “Color Box
Constant”, una para el rojo y otra para el azul. La manera de hacerlo se muestra abajo.



El código queda como sigue:

20. Por defecto el color que toman es negro, para cambiar esto debemos tomar el cursor
En la paleta de herramientas y presionar sobre la constante para escoger el color deseado.
Esto se realiza de la manera mostrada arriba.

El código queda como sigue:

Sin conexión Con conexión

21. La aplicación está casi lista, ahora debemos ejecutarla, para ello presionamos el botón de
menú y si se quiere ejecutar en modo de depuración se pueden escoger las variantes ya
estudiadas. .

Al ejecutarla podemos percibir la rapidez con que varia el nivel, para que sea más efectiva la
simulación se puede introducir un bloque de demosra dentro del ciclo iterativo.

22. Para ello debemos ir a la paleta de funciones y utilizar la función “Wait Until Next ms
Multiple” y colocar una constante de demora de 500 ms. Como se muestra a continuación.



Ejercicio 2

Elabore un programa en Labview que: dado el nombre y la edad de una persona. Elabore una
cadena de salida que diga lo siguiente: Usted se llama: nombre y nació en el año: YYYY donde
las cadenas subrayadas son: el nombre y la resta del año actual con la edad respectivamente.

Para diseñar la interfaz de usuario de este programa debemos utilizar 1 controles de cadena
para entrar el nombre, 1 control numérico de tipo entero sin signo, de 8 bytes, ya que la edad
siempre es positiva y nunca mayor que 256 que es el entero más pequeño que se puede
declarar y 1 indicador de cadena para la salida. Además debemos colocar un control booleano
que permita terminar la ejecución del programa.

Los pasos para construir la interfaz son los siguientes:

1. Abrir un nuevo VI, tal y como lo hicimos en los ejercicios anteriores.
2. Adicionar un control de cadena.

Selección del control Panel Frontal

3. Adicionar un control numérico.




4. Cambiar el tipo de dato asociado con el control numérico.

6. Adicionar un indicador de cadena.


7. Adicionar un control booleano.




Ya estamos en condiciones de programar, en base a los elementos gráficos seleccionados
para nuestra interfaz, la lógica que dará solución a nuestro ejercicio. Para ello pasamos
directamente a la ventana del diagrama (Ctrl+E).

6. El primer código G que debemos programar es el necesario para comenzar y terminar la





7. Una vez que se seleccione, debe irse a la pantalla del diagrama. Ahora el cursor de la
siguiente pantalla.


8. El ciclo tiene dos variable implícitas: la iteración representada por y la condición de
salida, representada por . Si negamos la variable booleana y la conectamos a la condición
de salida, se construye la lógica necesaria para la ejecución y salida del programa.



Para negar la variable booleana “stop” debemos utilizar los operadores booleanos que se
seleccionan en la paleta de funciones como sigue:

9. Allí debemos seleccionar como nuestra la figura, el operdor “Not”. Y colocarlo en nuestra
ventana del diagrama de la siguiente forma:

Antes de conectarlos Después de conectarlos

10. La cadena de salida que queremos formar debe ser construida a partir de las variables que
ya declaramos y de un conjunto de cadenas constantes. Una de ellas debe almacenar el valor
“Usted se llama: ” otra el valor “Y nació en el año: ” para ellos se va a la paleta de funciones y
se busca la paleta readicionada con el tratamiento de cadenas. A continuación se muestra su
localización:



11. Se colocan dos controles del tipo y se selecciona el cursor en la paleta de
herramientas se utiliza la tecla “tab”, hasta que el cursor en la pantalla quede de la siguiente

manera: para introducir el valor de las constantes como muestra la figura.

12. En este caso debemos concatenar cada una de las cadenas en el orden mostrado en la
figura anterior. Además, hay que restarle al valor de la edad el año actual para obtener el año
de nacimiento y este resultado añadirlo a las cadenas. Para ello se puede utilizar la función
“Format Into String” que se encuentra:

13. Esta función retorna una cadena de caracteres que esta formada por cada uno de los
elementos que se le pasan como parámetros. Estos parámetros pueden ser de cualquier tipo
de dato simple (DBL, SGL, EXT, U8, U16, U32, I8, I16, I32) sin embargo el formato debe ser
especificado de manera similar a como lo hace la función de C “printf” o sea : %d para enteros,
%f para números con coma, %s para cadenas. En nuestro caso el formato será: “%s%s%s%d”,
ya que son tres cadenas y un valor entero (el año). Para ello debe introducirse en el código de
nuestro programa una constante de la misma forma que se realizó en el paso 11 y se inicializa
así: %s%s%s%d para luego conectarla a la función según se muestra a continuación:



14. Como se observa esta función solo tiene una posible conexión de entrada pero eso es solo
por el momento. Usted debe pararse justo en la base de la función y esperar a que cambie el
tipo de cursor. Cuando esto suceda, debe presionar el botón izquierdo del ratón y arrastrar
hasta tener exactamente cuatro entradas que deben coincidir con los tipos de datos
seleccionados con anterioridad. El diagrama queda así:

15. Para obtener el año debemos introducir una constante numérica entera para almacenar el
valor del año actual 2002 y un operador de resta desde la paleta de funciones numéricas. Al
efectuar la resta del año menos la edad se tiene el año de nacimiento.

16 Ahora solo nos resta conectar las funciones con las variables para terminar. Para ejecutar e
programa, presionamos el botón de menú y si se quiere ejecutar en modo de depuración
se pueden escoger las variantes ya estudiadas. .

Ejercicio 3



Se desea construir un programa que permita desglosar una fecha introducida bajo el formato
“DD/MM/YYYY”. El programa debe mostrar el día en un indicador de cadena; el mes, por su
nombre, en un “ComboBox” y el año en un indicador de cadena.

1. Para realizar este ejercicio es necesario utilizar un control de cadena para introducir la
fecha. Debemos utilizar los dos indicadores que mostrarán el día y el año. Estos controles
se deben introducir de la misma manera que se hizo en el ejercicio anterior (pasos 2 y 6).
Como en los ejemplos anteriores se debe colocar un control booleano que sirva para
finalizar la aplicación. El resultado debe ser como se muestra a continuación.

2. Para mostrar el mes por su nombre debemos utilizar un indicador de tipo enumerado “Enum”
que se encuentra en la paleta de controles bajo el botón “Ring & Enum”

3. Al introducir el elemento “Enum”, este toma la propiedad de control. Sin embargo, el uso que
se le va dar es como indicador. Es por ello que se debe dar clic derecho sobre él y seleccionar
la opción “Change To Indicator”. Ahora estamos listos para introducir cada uno de los doce
meses del año. Para ello se selecciona el cursor en la paleta de herramientas o se utiliza la



tecla “tab” hasta que el cursor en la pantalla quede de la siguiente manera . Luego se
coloca el cursor dentro del indicador y se introduce el primer nombre “enero”, para introducir
otro mes se da clic derecho sobre el control y se selecciona la opción “Add Item After”. De esta
manera se entran todos los nombres de los meses.

`

La figura que se muestra encima es el “panel frontal” correspondiente a nuestro programa.

En estos momentos estamos listos para programar el código que de solución a nuestro
problema. Para ello debemos movernos hacia la pantalla del diagrama (Ctrl+E).

Al igual que los ejercicios anteriores debemos programar en primer lugar el código G que nos
permita terminar la ejecución de nuestro programa. Los pasos son similares a los vistos
anteriormente y finalmente debe quedar de la siguiente forma:

Es de señalar que la variable correspondiente al indicador de tipo “Enum” es entera y cada mes
tiene un número entero asociado. Para “enero” será el “0”, febrero el “1” y así sucesivamente.



4. Para desglosar la fecha es necesario encontrar el carácter “/” que limita el día del mes, y el

mes del año. La función “Search/Split String” que se encuentra en la paleta de funciones
permite encontrar un carácter específico dentro de una cadena. Esta función necesita como
parámetros la cadena donde debe buscar, el carácter que se quiere encontrar y el
desplazamiento a partir del inicio de la cadena donde se comenzará la búsqueda. La función
retorna tres valores. La subcadena que se forma hasta el carácter que se busca, la subcadena
a partir del carácter que se busca (incluyendo el carácter buscado) y el índice o desplazamiento
donde se encontró el carácter.

El resultado de aplicar esta función a la cadena que contiene la fecha es el siguiente:

Si la fecha es: 12/01/2005

Subcadena hasta el carácter “/”: “12”
Subcadena restante: “/01/2005”

5. Para tomar el mes es necesario eliminar el primer carácter “/” de la cadena restante
“/01/2005”y volver aplicar la función anterior. Para ello se puede utilizar la función “String
Subset” que recibe como parámetros una cadena, la cantidad de caracteres que se
quieren tomar y el desplazamiento o índice a partir de donde se tomara la subcadena.



6. El resultado de aplicar esta función a la cadena “/01/2005” es: “01/2005”. Ahora se debe
repetir el paso 4 para obtener el mes. Sin embargo este resultado se debe mostrar en el control
“Enum”. Como se dijo esta es una variable de tipo entera, por lo que debemos convertir el
resultado de la función, que es una cadena con el número del mes, a un valor numérico entero.
Para ello el labview cuenta con funciones de conversión de tipos. En nuestro caso esto se
realiza con la función “Decimal String To Number” . El diagrama queda como sigue:

Para obtener el año se debe repertir el paso 5. con lo cual se elimina el carácter “/”y se
obtiene el año. El diagrama final queda así:

Para ejecutar e programa, presionamos el botón de menú y si se quiere ejecutar en modo
de depuración se pueden escoger las variantes ya estudiadas. . Al correr el
programa se puede percibir que el mes que se obtiene está desplazado en uno con el que
sería el correcto. Eso es así por que en la variable de tipo “Enum” el mes de enero tiene
asignado el valor 0, este mes no existe. Para resolver este problema, después de la conversión
de cadena a número se debe restar una unidad. El diagrama queda de la siguiente manera:



TEMA IV Control de Flujo de programa en LabVIEW. Estructuras repetitivas.

• Lazos de control de programa (While y For).
• Shift Registers (Registros de Desplazamiento).
• Nodo fórmula. Visualización gráfica de datos.

Ejercicio 1:

Realice un programa que permita encontrar el máximo de 100 números generados
aleatoriamente. Represente gráficamente los números generados.

Desarrollo:

El ejercicio una vez terminado debe conducir a una representación en Lenguaje G como la que
se muestra a continuación en la ventana de diagrama o código del LabView:

Veamos como desarrollar paso a paso dicho ejercicio. Primero, una explicación de lo que se
nos pide.
Se necesitan generar 100 números aleatorios, lo que implica utilizar un generador de números
aleatorios y un lazo de control de programa o repetición que permita que ese generador de
números aleatorios nos entregue 100 de dichos números.
Cada vez que se nos entregue un número, o sea, con cada iteración del bucle o lazo, se debe
comparar el número generado con el número máximo hasta ahora generado. Eso nos indica
que debemos realizar una comparación que busque el máximo y almacenarlo para comparar
en cada iteración con el nuevo número.
Se nos pide que representemos gráficamente dichos números por lo que debemos agregar un
gráfico a nuestro diseño encargado de plotear en cada iteración el número aleatorio a procesar.
Como descomponer entonces con LabView dichas operaciones?
1. Primero debemos crear el lazo de control o bucle. Para ello seleccionamos de la paleta
de funciones del LabView las funciones de estructuras y dentro de ella la del ciclo For.
El ciclo for es el escogido porque en este caso necesitamos repetir la operación de
comparación en la búsqueda de un máximo 100 veces, invariablemente. Si
estuviéramos sujetos a alguna condición entonces deberíamos de haber seleccionado
un lazo condicional, o sea, un While. La siguiente figura ilustra como hacer la selección:



2. Una vez que se ha puesto el ciclo for debemos definir el alcance del mismo. Se
recuerda que un ciclo for en LabView siempre va desde 0 hasta N-1, siendo N el valor
a definir. Aquí queremos realizar las operaciones 100 veces por lo que debemos definir
para N un valor de 100. Esto se realiza creando una constante y conectándola con N.
Es muy sencillo, la siguiente figura ilustra como hacerlo. El menú que allí aparece se
obtiene dando clic derecho encima de N:

3. Cuando la constante se crea, aparece con valor 0. Debemos cambiar dicho valor y
poner 100, como se muestra en la siguiente figura:



4. Necesitamos ahora generar un número aleatorio y compararlo con algún máximo. Por
supuesto, el primer número aleatorio no tiene referencia de comparación, pero como
debemos comparar dentro del ciclo for, basta con compararlo con el menor valor
posible que se pudiera generar, en este caso 0, con lo cual garantizamos que el primer
número aleatorio siempre será el primer máximo contra el cual comparar después los
sucesivos que se generarán. LabView presenta un componente que realiza la
comparación entre dos fuentes o números, y devuelve el mínimo valor de entre los dos
y el máximo. La siguiente figura muestra como seleccionar dicho componente
(Functions/Comparison/Max & Min):

Se inserta en la ventana de diagrama dentro del ciclo for:



5. Necesitamos ahora encontrar alguna función que genere números aleatorios. LabView
tiene un componente en Functions/Numeric/Random Number (0-1):

Si quisiéramos generar un número aleatorio en un rango diferente podemos multiplicar el
número generado con esta función por el valor máximo que queremos generar. Puede
modificar el ejercicio como estudio independiente ahora intentando buscar el máximo de 100
números aleatorios en el rango de 0-50.
Una vez introducidos en el diagrama el generador de números aleatorios y la función que
devuelve el máximo entre dos números debemos entonces buscar la forma de almacenar el
máximo que resulta de cada iteración para compararlo con el número generado en la siguiente
iteración. Si se analiza bien esto lo que necesitamos es comparar el número generado en la
iteración i (denotemos por n(i) a dicho número) con el máximo que resultó de la iteración i-1.
Esta es una de las funciones que puede brindarnos el registro de desplazamiento o shift
register de LabView.



El shift register desde el punto de vista de la programación es una estructura tipo arreglo
asociada con lazos de control o bucles de programa como el for y el while y que almacena
valores anteriores producidos en dichos lazos. Así, por ejemplo, si obtenemos como resultado
de una iteración i un valor v(i) al final de dicha iteración, al comienzo de la próxima al i
incrementarse en uno, dicho valor se almacena como v(i-1). Dos iteraciones hacia delante será
v(i-2) y así sucesivamente. La siguiente tabla ilustra dicho concepto con ejemplos numéricos:

Iteración V(i) V(i-1) V(i-2) V(i-3) V(i-4) V(i-5)
0 5 - - - - -
1 3 5 - - - -
2 0.7 3 5 - - -
3 1 0.7 3 5 - -
4 -1 1 0.7 3 5 -
5 0 -1 1 0.7 3 5
6 2 0 -1 1 0.7 3

y así sucesivamente....

6. Para adicionar Shift Registers con LabView se selecciona la estructura for y se da clic
derecho sobre ella. El siguiente menú aparece:

Al seleccionar de dicho menú la última opción, Add Shift Register (Adicionar registro de
desplazamiento) se inserta en el diagrama como se muestra en la siguiente figura:

7. Antes de realizar las conexiones entre los elementos debemos además seleccionar
algún componente que nos permita visualizar gráficamente los números aleatorios que



se van generando. Para ello nos vamos al panel frontal y con clic derecho visualizamos
el siguiente menú:

Al seleccionar la opción Controls/Graph/Waveform Chart obtenemos un gráfico como el que se
representa en la pantalla frontal de la siguiente figura, donde también se representa el
contenido de la ventana de diagrama hasta este momento:

8. A continuación se realizan las conexiones entre los elementos. La salida del generador
de números aleatorios se conecta al bloque de comparación de números, y a la entrada
del control gráfico. El shift register de la derecha debe almacenar el último valor del
máximo calculado y que se obtiene como salida del módulo de comparación. La
siguiente figura muestra las conexiones a realizar:



9. Una vez realizadas estas conexiones el ejercicio está prácticamente concluido. Note
que la primera vez que se compara en el bloque de comparación se hace entre un
primer número aleatorio y el valor del shift register. Ya se explicó como funciona el shift
register y debemos notar que antes de concluir la primera iteración no tenemos un
valor con el cual comenzar para el shift register que adquiere uno al final de cada
iteración. Eso nos indica que tenemos que inicializarlo, darle un valor inicial con el
cual empezar y evaluar la iteración 0 . Note además que cuando se llega a la última
iteración el valor actual que contiene el shift register es el del último máximo calculado,
y por tanto el valor que debemos reportar como resultado. Es por ello que entonces
debemos crear un indicador para visualizar el último máximo y una constante para
definir la condición inicial del shift register. Las figuras que se muestran a continuación
ilustran como hacerlo. Los menús que allí aparecen se obtienen al dar clic derecho
encima de los shift registers.



El resultado final se muestra en la siguiente figura. Note que el valor inicial del shift register es
0.00 pues es el mínimo que puede tomar el número aleatorio y no afectará la selección del
primer máximo.

10. Antes de ejecutar el programa es conveniente modificar algunos parámetros del
gráfico, en particular los relacionados con los ejes, que debemos modificar para
permitir la auto escala. Las figuras a continuación muestran la manera de hacerlo
(siempre clic derecho en el objeto para obtener el menú):



11. Finalmente salvamos el ejercicio y lo ejecutamos. Un ejemplo de ejecución se muestra
en la siguiente figura:



Por último, señalar que si queremos que el gráfico se represente más lentamente podemos
incluir una demora (Functions/Time & Dialog/ Wait Until Next ms Multiple) o seleccionar el
indicador de ejecución paso a paso. La siguiente figura muestra como quedaría el ejercicio
para una demora de 50 milisegundos:

En la figura anterior también se a insertado otro indicador, llamado max(x,y). Que función
tendría?

Ejercicio 2:
En este ejercicio se propone realizar la descomposición de la fecha introducida en un control
tipo Edit (Edición) de una manera más eficiente (comparada con la primera solución a este
ejercicio que ya se vio en una guía anterior), haciendo uso de los shift registers.

Desarrollo:

En clases anteriores se ofreció una solución al problema de desglose de una fecha en sus
componentes de día, mes y año. Aquella solución introducía algunos componentes para el
procesamiento de cadenas que se encuentran dentro de las funciones de LabView. En dicha



solución los componentes se repetían, pero hay una forma más eficiente de resolverlo
haciendo uso de los shift registers. La solución final se ofrece en la siguiente figura:

Se recuerda la función y terminales de los dos elementos principales involucrados:

Antes de pasar a una explicación más o menos detallada de como construir la solución en la
pantalla de diagrama veamos algunos razonamientos de como proceder con los shift registers:

1. Se quiere dividir una cadena que representa la fecha en sus tres elementos
constitutivos, o sea, el día, el mes y el año que la conforman.
2. La operación siempre es la misma: se extrae de la cadena una subcadena que
representa un componente de la fecha (o el día, o el mes o el año) y se elimina de la
subcadena que resulta de extraer dicho componente el separador /.
3. El proceso se repite 3 veces.



El punto 3 nos indica que podemos utilizar un lazo condicional, o sea, un while, pues siempre
dentro del while se hará lo mismo (punto 2). La subcadena que representa el componente
extraído debe almacenarse para brindar los resultados finales. Como entonces utilizar los shift
registers? Quizá una manera en que podemos verlo es representando el proceso, para una
fecha ejemplo, a través de las iteraciones. La siguiente tabla lo ilustra:

Cadena inicial Iteración Componente Subcadena Subcadena
resultante después de después de
extraído el extraer el
componente separador (/)
8/02/2005 0 8 /02/2005 02/2005
02/2005 1 02 /2005 2005
2005 2 2005 “” “”

Como se puede apreciar por cada iteración se obtiene un componente resultante, primero el
día, después el mes y por último el año. Si denotamos por c(i) al componente resultante se
puede ver que después de la iteración 2 c(i)=2005, c(i-1)=02 y c(i-2)=8. Dicha secuencia es la
que precisamente nos pueden brindar los shift register si creamos los suficientes en el
diagrama como para almacenar los valores c(i-2), c(i-1) y c(i). Necesitamos además de una
iteración a otra almacenar la subcadena resultante después de extraer el separador que será la
nueva cadena inicial con la cual trabajar en la próxima iteración. Veamos pues como hacerlo.
1. Primero debemos de crear el lazo condicional while en nuestra aplicación:

2. Debemos ahora definir la condición de parada. Queremos que el lazo funcione
mientras la iteración no sea mayor que dos, por tanto, la condición de ejecución del
while debe ser i<=2. La siguiente figura nos indica como quedaría (el componente de
comparación aparece en Functions/Comparison/Less or Equal?):



3. En el panel Frontal debemos insertar un control de tipo String para poder teclear la
fecha que se quiere descomponer (Controls/String & Path/String Control):

Note que en la siguiente figura el control generado en el panel frontal tiene asociado una
variable que debemos ubicar fuera del lazo while pues es la cadena inicial que hay que
descomponer.
4. Insertamos ahora en la ventana de diagrama el componente Search/Split String
(Functions/String/Aditional String Functions/Search Split String):

5. Una vez introducido dicho componente se crea el primer shift register, que tendrá la
función de almacenar la subcadena resultante después de cada iteración. En la
siguiente figura aparece representado. A la función de dividir (Split) cadenas se le
asigna en cada iteración la cadena inicial (ver tabla página 13) que está almacenada en
el shift register (por ejemplo, si en la iteración que acaba de concluir quedó 02/2005
ese valor se almacena en el shift register de la derecha y cuando se incrementa i para
iniciar una nueva iteración esa cadena (ahora, después de incrementada i es el
resultado de la iteración i-1) LabView la pasa o ubica en el shift register de la izquierda
para que sea usada en la iteración i).



Como ya mencionamos anteriormente, los shift register tienen que tener un valor inicial, para
que sea el valor con el cual comienza a trabajar la iteración 0. En este caso el valor inicial es la
cadena inicial introducida en el edit, o sea, la fecha completa que se quiere dividir. En la figura
anterior se mostró la conexión que inicializa al shift register.
6. Una vez introducido este registro de desplazamiento hay que completar las entradas
del modulo de división de cadena. Para ello se agregan dos constantes en la entrada, y
se le dan, respectivamente, valores de / (que es el separador) y 0. Dichos valores le
indican al Labview que la cadena que tiene en su entrada y que será dividida en dos se
comenzará a explorar desde el primer elemento (elemento 0) hasta detectar el carácter
/.

Esta función tiene dos salidas, la primera es la subcadena encontrada antes del carácter que
divide la cadena de entrada en dos cadenas (en nuestro ejemplo /). La segunda salida es la
cadena que se encuentra desde el separador hasta el final. Note que incluye al separador.
Las dos salidas serán de utilidad, la que está delante del separador es el componente de la
fecha que estamos separando (día, mes o año) y la segunda la que hay que seguir separando.
Que hacer con la primera? Hay que almacenarla pues de lo contrario en la próxima iteración
tendré otra componente resultante de la comparación que cambiará la salida de la función
Search/Split String.
7. Para ello debemos utilizar un nuevo shift register, en este caso, uno que tendrá la
función de los componentes resultantes. La siguiente figura indica la forma de
insertarlo:



8. Que conectar al shift register que no aparece conectado en la figura anterior?
Recuerde que será el encargado de almacenar la cadena que en la próxima iteración
servirá de inicio para buscar el nuevo componente de la fecha. Note además que no se
puede conectar directamente a la salida de la primera función (Search/Split Function)
pues esa salida incluye todavía el separador (ver tabla pág. 13) y hay que eliminarlo.
Para ello se usa la función que se representa en la siguiente figura
(Functions/String/String Subset)

También se pudo utilizar una segunda función split, pero la que se ha escogido es la más
representativa de lo que se quiere hacer puesto que recibe a su entrada una cadena y
devuelve la subcadena que se encuentra desde la posición k hasta la l, donde k y l son otras
entradas de la función. Nosotros queremos tomar la cadena que sale de la función
Search/Split... y quitarle el separador, o sea, quedarnos con el subconjunto o subcadena que
se encuentra desde la posición 1 (en la posición 0 está el separador hasta el final):



9. Ahora si podemos conectar la salida de esta función String Subset al shift register de
su derecha:

10. Hasta aquí lo que está programado funciona bien pero no nos permite visualizar todos
los resultados. El resultado se obtiene en el shift register que en la figura anterior no
está conectado. Que componente se obtiene ahí después de concluida la última (i=3)
iteración? La respuesta es que se obtiene el valor del shift register asociado (el de la
parte derecha a su mismo nivel) en la iteración i-1. Cual es ese valor? Del ejemplo de
la Tabla en la Página 13 podemos ver que es el año. Note que al final de la última
iteración el valor del shift register asociado de la derecha era “”. Conectemos entonces
un indicador tipo string al shift register no conectado hasta ahora (clic derecho, en el
menú que aparece seleccionar Create/Indicator). Cambiando el nombre del indicador
por el de año obtenemos:



11. Eso nos permite visualizar el año. Pero y el mes? Si el año fue el valor resultante en la
iteración i-1, es de suponer que el mes es el valor resultante en la iteración i-2. Pero
ese valor no lo tenemos almacenado. Hay que almacenarlo. Crear elementos del shift
register para las iteraciones i-2, i-3, i-4,.... es fácil . Solo hay que agregar un elemento
al shift register ya creado. La siguiente figura muestra como hacerlo. El menú que
aparece en ella se obtiene con clic derecho sobre el shift register de la derecha (el
conectado al indicador de año):

El resultado:

12. Debemos agregar otro nivel, (el de i-3) para el componente día de la fecha:



A cada nivel creado se le asocia el indicador de cadena correspondiente, de la misma forma
que se hizo con el año:

13. Antes de concluir debemos realizar una operación más. Hay 3 elementos en el registro
de desplazamiento asociado con el año, el mes y el día que no han sido inicializados.
Que valor les corresponde? Aquí en realidad no tiene importancia el valor que le demos
pues solo están conectados (los elementos del shift register) y por lo tanto el valor que
al concluir el while mostrarán serán los componentes de la cadena fecha. Sin
embargo, es una práctica sana inicializarlos, y por eso se hará, dándole un valor inicial
de “” que indicará cadena vacía. La siguiente figura muestra como hacerlo:



La constante de cadena vacía se encuentra definida en la biblioteca de funciones de LabView
Functions/String/Empty String constant.
En la ventana o panel frontal nuestro diseño sería más o menos así. Para probar que nuestro
programa se ejecuta debemos antes de ejecutarlo darle un valor inicial a la fecha que se
descompondrá, editando en el control Fecha el valor:

Después de una ejecución, y para esa cadena se obtiene:



Ejercicio 3:

Realice un programa en LabView que permita gráficar la función seno hasta que se oprima el
botón parar.

Desarrollo:

Este ejercicio nos permitirá conocer como trabajar con el Nodo Fórmula. Que se nos pide?
Graficar la función seno(x) hasta que se oprima un botón. Eso nos indica que debemos ubicar
un lazo o bucle de repetición condicional, o sea, un while. La condición de parada del while la
producirá el clic sobre un botón. Dentro del while debemos de estar evaluando, para cada
iteración a la función seno(x). Que valor le damos a x? Podemos usar el mismo valor de la
iteración i. El único problema es que el seno(x) espera el valor en radianes por lo que hay que
convertir el valor de i a dicha unidad, y después calcular el seno. Este es un caso típico en que
un nodo fórmula nos simplifica mucho el trabajo. Veamos la solución.

1. Primero comenzamos creando el ciclo while y un botón (ya se sabe como hacerlo de
clases anteriores):

En la figura anterior aparece nuevo el elemento negado, que conecta al botón con la condición
de ejecución del while. En clases anteriores vimos que se podía también cambiar la condición
de ejecución del while con clic en ella: aparece un circulo rojo. En versiones anteriores a la 6.0
no existía dicha posibilidad.
2. Después de introducido el while se crea el nodo fórmula según se muestra en la
siguiente figura:



3. Una vez creado el nodo fórmula tenemos que indicar cuales serán las variables de
entrada de dicho nodo y cuales las de salida. Comenzando por las de entrada se
adicionan de la siguiente manera (el menú aparece al dar clic derecho en el nodo
fórmula):

4. A dicha entrada le damos el valor de nx:



5. Ahora debemos editar dentro del nodo fórmula el contenido de lo que se quiere
calcular. Para este caso son 3 lineas. Note la similitud entre C++ o Matlab y el lenguaje
que admite el nodo fórmula. Dicho nodo es compatible con ANSI C.
6. La fórmula convierte de grados a radianes y calcula el seno. El valor calculado lo
devuelve en la variable y, que hay que declararla como salida del nodo de la misma
forma que la entrada pero ahora seleccionando la opción Add Output. Una vez hecho
esto se realiza la conexión entre el indicador de iteración i y la variable de entrada nx.
La siguiente figura muestra como debe quedarnos la aplicación hasta este momento en
la ventana de diagrama:

7. La salida, que se produce en cada iteración, podemos conectarla a un componente
para plotear gráficos de la misma manera a como lo hicimos en el ejercicio 1:



La salida “y” del nodo fórmula se conecta al gráfico:

La figura que se muestra a continuación es el resultado de la ejecución del programa:



TEMA V Mas estructuras de control de flujo.

• Dominar la estructura de control CASE. (if-then-else ó switch[C++] )
• Dominar la estructura “Secuence” para secuenciar el flujo de programa
(alternativa a la programación por nodos).
• Dominar la estructura de manejo de eventos.

Ejercicio 1:

Elabore un programa en LabView que permita calcular la raíz cuadrada a un número real. El
programa debe analizar si valor introducido es menor que cero (situación de error) e indicar al
usuario por medio de un cuadro de mensaje la situación.

Solución:


Ahora debemos diseñar la interfaz de usuario de nuestra aplicación. Para ello simplemente
colocamos un control numérico digital que reciba por parte del usuario el valor al cual se le
calculará la raíz cuadrada. Además, debemos colocar un indicador (también digital en este
caso) para visualizar el resultado de la operación.

Esto queda de la siguiente manera:



Ya estamos listos para programar en “Código G” la lógica de nuestra aplicación. Por lo tanto
utilizando (Ctrl+E) vamos a la pantalla del diagrama en bloques, que luce de la siguiente forma:

La operación de cálculo de la raíz cuadrada implica realizar una operación de comprobación
antes de efectuarla, y esto depende del valor del número. Si este es positivo se puede hacer,
sino debe indicarse un mensaje. Véase que existe una condición mediante la cual se bifurca el
flujo de programa. Para ello es necesario utilizar una estructura clásica del tipo IF-THEN-ELSE,
que el caso de labVIEW se denomina “Case Structure” y se puede obtener según se indica en
las figuras siguientes:



Esta estructura está representada por un marco y un titular que representa el
área donde se programa el código asociado a la condición de

true: y el código asociado a la condición de false: . Note que usted
puede conmutar entre uno y otro según desee utilizando las flechas, y que los elementos de
código para uno u otro son diferentes.

Según nuestra lógica, si el valor numérico es positivo, se realiza la operación de raíz, esto se
consigue utilizando las funciones numéricas como se muestra a continuación:



El código complementario, cuando no se puede efectuar la operación debido a que el número
es falso, se reduce a colocar un cuadro de mensajes que alerte al usuario. Para ello se utiliza
en la paleta de funciones un “One Button Dialog” y un “String Constant” según se observa a
continuación:

Ahora solo nos resta realizar la comparación y conectarla a la estructura “case” para determinar
cual de las dos acciones posibles se realizará en tiempo de ejecución. Para ello necesitamos
comparar la variable correspondiente al control numérico relacionado con el valor a calcular.
Sin embargo ya hemos utilizado el terminal asociado al mismo, por lo que debemos crear una

variable local de ese control. Esto se hace dando clic derecho sobre la variable ,
seleccionando la opción “Create” y a su vez “Local Variable”. Usted debe recordar que las
variables en LabVIEW pueden ser de escritura o lectura. Al crear una variable local estas son
de escritura por defecto, aquí se utilizara para compararla y saber si es mayor que cero, por lo
que no la modificaremos. En este caso hay que cambiarla para su tipo de lectura, esto se hace
dando clic derecho sobre ella y seleccionando la opción “Change To Read”:



Para comparar el valor de la variable, se debe utilizar la función de comparación “Grater Or
Equal To 0?” que se encuentra en la paleta de funciones. El resultado de esta comparación es
“True” o “False” y sirve de condición a la estructura “Case” por medio del selector que
decidirá según su estado “booleano” cual código realizar.

Ya se está en condiciones de correr la aplicación, sin embargo usted se dará cuenta de que la
ejecución de la aplicación no es “buena”. Cuando se introduce un valor negativo se ejecuta
indefinidamente la opción de mostrar el cuadro de diálogo por lo que se bloquea la aplicación.
Este problema se soluciona muy fácilmente introduciendo un botón de cálculo, según el cual se
realizan las operaciones. Para ello se debe utilizar una estructura “case” más externa
gobernada por el botón de cálculo.



Para obtener los resultados esperados la acción mecánica (Mechanical Action) debe colocarse
en uno de los siguientes estados:
• Latch when Pressed
• Latch when Released
• Latch until Released



Si no se utiliza este modo persisten los errores planteados al principio.
¡Compruébelo y obtenga conclusiones!

Estudio Individual

Realice una calculadora capaz de hacer las operaciones básicas de suma, resta, multiplicación
y división entre dos números reales. Utilice un control de tipo “Menu Ring” para indicar la
operación a realizar. Note que este elemento gráfico está representado por una variable de tipo

y que según su valor debe realizarse una operación de las cuatro mencionadas. Además,
debe utilizar dos controles para los operandos y un indicador para el resultado.

Ejercicio 2:

Elabore un programa en LabView que permita animar un control de labVIEW. El control debe
describir la figura geométrica de un cuadrado con aristas de 100 pixels.

Solución:



LabVIEW Instrumentación Virtual

LabVIEW Instrumentación Virtual

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (20)

Similar a LabVIEW Instrumentación Virtual

Similar a LabVIEW Instrumentación Virtual (20)

LabVIEW Instrumentación Virtual