Manual Basico de Programacion en LabVIEW

2014
Curso básico de
programación en
LabVIEW
www.masterhacks.net – Grupo STRIMH
Aspectos básicos sobre la programación en el lenguaje gráfico LabVIEW. Este libro
incluye también algunos ejemplos explicados de programas desarrollados en este
excelente software.
www.masterhacks.net
Segunda edición
01/01/2014
www.masterhacks.net
CONTENIDO
Introducción --------------------------------------------------------------------- 02
¿Qué es LabVIEW? ------------------------------------------------------------- 03
Conociendo LabVIEW ---------------------------------------------------------- 05
Context Help ---------- ---------------------------------------------------------- 06
El primer programa en LabVIEW -------------------------------------------- 12
Controles e indicadores -------------------------------------------------------- 15
Elementos booleanos --------------------------------------------------------- 16
Uso de Select ------------------------------------------------------------------- 21
Uso de cadenas de texto ----------------------------------------------------- 23
Uso de la estructura Case ------------------------------------------------------ 25
Uso de Array --------------------------------------------------------------------- 30
Uso de arrays con strings ----------------------------------------------------- 33
El ciclo For ------------------------------------------------------------------------ 36
For condicional ------------------------------------------------------------------ 39
Shift Register --------------------------------------------------------------------- 40
El ciclo While ------------------------------------------------------------------- 42
Variables locales ---------------------------------------------------------------- 47
Uso de Cluster ------------------------------------------------------------------- 48
Aplicando los conocimientos ------------------------------------------------- 52
Inserción de imágenes y decoraciones ------------------------------------- 57
Máquinas de estados ---------------------------------------------------------- 60
Ejercicios para practicar ------------------------------------------------------- 68
Tamaño de un botón con nodos de propiedad --------------------------- 70
Ejercicio con array de leds ---------------------------------------------------- 72
Máquina tragamonedas ------------------------------------------------------- 77
Edición del ícono de un programa ------------------------------------------ 88
Operaciones con matrices ----------------------------------------------------- 90
Uso de fórmulas matemáticas en LabVIEW --------------------------------- 93
Uso de Web Publishing ---------------------------------------------------------- 96
Programa para administrar venta de pinturas ------------------------------ 98
Seguridad en el desarrollo de un programa ------------------------------- 101
La importancia del diseño ----------------------------------------------------- 102
Notas del autor ------------------------------------------------------------------ 104
Programación básica en LabVIEW – Grupo STRIMH 1

www.masterhacks.net
INTRODUCCIÓN
Este libro está pensado para estudiantes y personas que se inician en el

mundo de la programación en LabVIEW, por lo que su contenido empieza
desde lo más básico, hasta un nivel intermedio, en dónde se verán los
conceptos y aplicaciones básicos que incluye todo el software.
Es importante saber que para poder aprender a programar en LabVIEW se

requieren conocimientos básicos de álgebra booleana y programación en
cualquier lenguaje de código escrito, ya que el entorno de programación en
LabVIEW está diseñado preferentemente para adquisición de datos, diseño
de sistemas, instrumentación y control automático. Al hablar de álgebra
booleana, se hace referencia a compuertas lógicas, pues el software LabVIEW
incluye un panel de lógica en el que se pueden usar las compuertas lógicas a
la hora de programar.
Los conocimientos en otro lenguaje son importantes, ya que el lenguaje

gráfico parte del lenguaje convencional, por ejemplo, lenguaje C o Visual
Basic, con los que se aprende a utilizar las estructuras de control, matrices,
entre otros, que son indispensables para poder programar en LabVIEW.
Para poder crear y ejecutar los programas en LabVIEW es necesario descargar

el software desde la página oficial de National Instruments;
http://www.ni.com/trylabview/esa/ . Aclarando que en esta página se ofrece
la versión de prueba por 30 días para el uso del software, pasado ese tiempo,
es necesario comprar la licencia directamente con National Instruments.
Grupo STRIMH y Masterhacks ofrecen este libro de manera gratuita, dejando

que el lector pueda descargar, imprimir o reproducir libremente siempre y
cuando no altere su contenido y respete los créditos de los autores.
En caso de tener alguna duda o comentario, favor de hacerlo llegar al correo

contacto@masterhacks.net

www.masterhacks.net
¿QUÉ ES LABVIEW?
LabVIEW (Laboratory Virtual Instrumentation Engineering Workbench) es un

entorno de desarrollo y diseño de sistemas con un lenguaje visual gráfico.
LabVIEW utiliza el lenguaje G (lenguaje gráfico) que acelera la productividad
o desarrollo de programas para una mejor eficiencia en el desarrollo de
sistemas.
Es un software creado por la empresa National Instruments en 1976 y

lanzado al mercado en 1986.
Al desarrollar un programa en LabVIEW, se crea un Instrumento Virtual o VI

que contiene la interfaz gráfica del programa y el diagrama de bloques
(código).
Cuando un programa está terminado, el usuario final hace uso del panel
frontal, donde se encuentra todo lo necesario para controlar un sistema. El
diagrama de bloques es donde se encuentra el código del programa, es
donde el programador accede para modificar o mantener el programa.
Actualmente, el software de programación LabVIEW se puede utilizar en los

sistemas operativos Microsoft Windows, Mac OS X, GNU/Linux.
Una de las principales características de LabVIEW es que es relativamente

fácil de usar, no se requiere ser un experto en el área de programación para
poder hacer un programa que se pudiera considerar como complejo o incluso
imposible de hacer para algunas personas en otros lenguajes.
Aunque es necesario aclarar que para desarrollar programas que se apliquen

a la automatización, control, adquisición y manejo de datos, especialmente
en las áreas de ingeniería, como lo son Electrónica, Mecatrónica, Telemática,
etc. sí es necesario tener conocimientos más avanzados no solo de
programación, sino de otras áreas específicas para cada aplicación del
programa que se tenga planeado.

www.masterhacks.net
LabVIEW es principalmente utilizado por los ingenieros para el manejo de

datos, la comunicación entre una computadora y un aparato o circuito
externo es imprescindible para las aplicaciones que se le pueden dar al
software, por lo que LabVIEW puede comunicarse con interfaces como:
 Puerto serial
 Puerto paralelo
 GPIB
 PXI
 VXI
 TCP/IP
 Irda
 Bluetooth
 USB
 OPC
Entre otros.
Esto es lo que hace del Laboratorio Virtual de Instrumentación una excelente

opción para proyectos grandes donde se requieran conocimientos de
programación, electrónica, mecánica, robótica, etc.
Este software es utilizado en empresas y agencias importantes como la NASA,
por lo que NI destaca entre las empresas tecnológicas más innovadoras a
nivel internacional.
La programación representa un factor muy importante al hablar de proyectos

de automatización y control, donde se especializan ingenieros mecatrónicos,
robóticos y más. LabVIEW ofrece la herramienta para crear el software, el
programa depende del programador y su funcionamiento, la eficacia y
utilidad dependerán de las habilidades de éste mismo.
“La potencia está en el software” Una frase muy célebre de LabVIEW, que
hace referencia a la capacidad e importancia que puede tener un programa
en un proyecto.

www.masterhacks.net
Conociendo LabVIEW
Una vez instalado el software LabVIEW (link de descarga del instalador en la

introducción del libro), se creará un acceso directo en el escritorio de la
computadora, al ejecutarlo, aparecerá una ventana como la siguiente:
Imagen #1: Pantalla de bienvenida de LabVIEW
Aquí se puede elegir del menú la opción de abrir un nuevo VI, un proyecto en
blanco o un VI desde una plantilla. Para empezar se elegirá abrir un VI en
blanco. Esto para conocer todos los íconos que ofrece el software.

www.masterhacks.net
Aparecen dos ventanas, el Front Panel (Panel frontal) y Block Diagram

(Diagrama de bloques). En el panel frontal, es donde se pueden elegir los
elementos que conformarán nuestro programa, estos elementos son los que
el usuario final podrá visualizar o manipular.
Imagen #2: Panel frontal del programa en LabVIEW
Estas dos ventanas, se conocen como VI, que significa Virtual Instrument, o
Instrumento Virtual en español, este nombre es debido a su parecido con un
instrumento virtual físico, pues muestra las secuencias y todos los procesos
de una simulación virtual.
En la parte superior izquierda, se encuentra el panel de ejecución, con los

íconos correspondientes a las acciones de ejecutar, ejecutar continuamente,
abortar y pausar, respectivamente, como se observa en la imagen #3:

www.masterhacks.net
Imagen #3: Menú de ejecución del panel frontal.
El primer botón (Run) sirve para ejecutar el programa, en este caso, si el

software está diseñado para ejecutarse una vez y realizar la acción
correspondiente, se intuye que no utilizará ningún ciclo o bucle, entonces, al
presionar el botón ejecutar, el programa correrá y realizará la acción
programada una vez y se detendrá.
Cabe mencionar que si el código del programa tiene algún error, el ícono de
ejecutar se mostrará con una fractura que indicará que el programa no se
puede correr hasta que se depure el código, normalmente, LabVIEW abre
una ventana que muestra los errores que impiden la ejecución del programa.
Si se requiere que el programa esté en ejecución constante, es necesario

hacer clic en el segundo botón (run continuously), que significa correr
continuamente, de esta manera, el programa se ejecutará hasta que el
usuario vuelva a dar clic en ese botón o realice alguna acción en el programa
que haga que éste se detenga, por ejemplo, presionar un botón de stop.
El tercer botón sirve para abortar la ejecución. Este ícono se utiliza solamente
cuando el programa se cicla, es decir, que no se puede detener ya sea por
algún error en la programación o por un consumo excesivo de los recursos de
la computadora. Generalmente, esto sucede cuando se trabaja con ciclos y es
recomendable no usarlo si no es absolutamente necesario, ya que el usarlo
podría causar pérdida de datos.
El cuarto botón sirve para pausar la ejecución del programa, en caso de

querer verificar algún movimiento durante la ejecución.

www.masterhacks.net
Imagen #4: Menú de estilos, alineación y tamaño de elementos.
El menú de la imagen 4 sirve para modificar el tamaño, fuente y color de las

letras que se utilicen en la interfaz del programa. Los otros cuatro botones
sirven para alinear y mover los elementos que se estén utilizando para dar un
aspecto más estético.
Imagen #5: Barra de búsqueda y propiedades del VI
En la esquina superior derecha se encuentra la barra de búsqueda y el botón

de ayuda. También están dos íconos, el primero sirve para incluir sub VI´s en
el programa, aquí se construye el panel conector para poder utilizar sub VI´s.
El otro ícono sirve para ver y modificar las propiedades del VI (clic derecho>VI
properties).
Desde ahí se puede editar el tamaño de la ventana del programa, proteger el

código con contraseña, el uso de CPU, etc.
También se puede editar el ícono dando clic derecho> Edit icon.

www.masterhacks.net
Imagen #6: Diagrama de bloques del programa.
En el diagrama de bloques los menús son muy parecidos, solo que aquí se
agrega un botón al menú de ejecución que sirve para ver paso a paso lo que
el diagrama de bloques está ejecutando, muy útil cuando se quiere ver el
orden de ejecución de todo el código y ver su comportamiento, este botón es
el que tiene una imagen de un foco.
Otro botón que se agrega es el que limpia todo el código, este se utiliza para
ordenar el código, de manera que su lectura sea más clara y ocupe menos
espacio.
Para empezar a colocar elementos en el panel frontal, podemos dar clic

derecho en cualquier parte del panel y aparece el menú con todos los
elementos, o se puede dar clic en View>Controls palette.

www.masterhacks.net
Imagen #7: Menú de elementos.
En ese menú podemos elegir cualquier control numérico, booleano, de texto,

etc. Ofrece una gran cantidad de elementos que se pueden usar en una
infinidad de programas.
Para ver más elementos, solo se necesita dar clic en la flechita de abajo del
menú para desplegar el menú completo.

www.masterhacks.net
CONTEXT HELP
LabVIEW cuenta con una herramienta de ayuda bastante práctica, el Context

Help, que básicamente es una pequeña ayuda que muestra una breve
descripción de cada elemento de LabVIEW en caso de que se requiera saber
cómo funciona el elemento que se va a utilizar.
Esta herramienta se puede abrir dando clic en el menú superior, donde dice
Help > Show Context Help, y se abrirá una ventana como la siguiente:
Imagen #8: Ayuda contextual de LabVIEW.
Esta ventana se mantiene abierta mientras se esté ejecutando LabVIEW o

hasta que el usuario decida cerrarla, se puede arrastrar al lugar donde se
requiera.
El contenido de la ventana cambiará cada vez que el usuario ponga el cursor

en cualquier elemento de LabVIEW, por ejemplo, al colocar el puntero sobre
el elemento de suma (add), se muestra la figura y su descripción en la
ventana de ayuda.

www.masterhacks.net
EL PRIMER PROGRAMA EN LABVIEW
Como primer programa, se puede crear una sumadora sencilla de dos

números. Para esto, se necesita en el panel frontal dos controles numéricos y
un indicador numérico.
Imagen# 9: Panel frontal de la sumadora.
Al crear los elementos en el panel frontal, estos aparecen automáticamente

en el diagrama de bloques:
Imagen #10: Diagrama de bloques de la sumadora.

www.masterhacks.net
Aquí ya empieza el trabajo del programador, realizar las operaciones

necesarias para que el programa funcione como se desea. Para seleccionar
las funciones que se utilizarán, solo se tiene que dar clic derecho sobre el
diagrama de bloques para que aparezca el menú, igual que en el panel
frontal.
En este caso solo usaremos una simple suma:
Imagen #11: Conexión de los elementos del diagrama de bloques.
Para comenzar a conectar los elementos, se sitúa el puntero del ratón en

cualquiera de los elementos, exactamente en la flechita que indica si el
elemento es control o indicador, aquí aparecerá un pequeño carrete, aquí se
da clic y sin soltar el botón del ratón, se arrastra hasta el elemento que se
desea, en este caso, a la operación de suma.
De acuerdo a la imagen #11, se puede deducir que el número 1 se sumará al

número 2, y el resultado de lo anterior se mostrará en el indicador
“resultado”.

www.masterhacks.net
Hasta aquí ya se puede ejecutar el programa, como no se está utilizando

ciclo, se puede seleccionar la opción de correr continuamente, para que el
programa no se detenga antes de que el usuario haya colocado los números
que se deseen sumar.
Imagen #12: Programa en funcionamiento.
NOTA: En la imagen #12 no aparece ningún botón de stop, por lo que el

programa no se podrá detener hasta que el usuario haga clic en correr
continuamente o en abortar, en este caso el botón de stop se coloca por
estética, sin embargo, en otros programas resulta necesario.
En este programa se pueden modificar los valores y el resultado se actualiza

automáticamente mientras el programa se esté ejecutando continuamente.
Si se requiere cambiar la función de suma por otra como resta o

multiplicación, solo se da clic derecho sobre el ícono y en replace se elige la
función que se requiera.

www.masterhacks.net
CONTROLES E INDICADORES
Los elementos de cada programa de LabVIEW se pueden definir como

controles o indicadores. Como se observó en el programa anterior, se usaron
dos controles para ingresar los números que se van a sumar. Con esto se
deduce que un control es un elemento que puede ser controlado o
modificado por el usuario, normalmente con perillas o flechas de
incremento.
Por otro lado, los indicadores son los elementos que no pueden ser
modificados por el usuario, y que solamente muestran datos o resultados
que el programa arroja, por ejemplo en el programa anterior, el indicador
muestra el resultado de la suma.
Imagen #13: Diferencias entre indicador y control.
En el diagrama de bloques es fácil distinguir un control de un indicador, el

control tiene el color del borde más grueso y la flechita de lado derecho,
indicando que el cable o datos van a salir del elemento, mientras que el
indicador tiene el borde más delgado y la flechita del lado izquierdo,
indicando que va a recibir un cable o datos.
Para cambiar un control a indicador o viceversa, solo se le da clic derecho al

ícono y otro clic en change to control o change to indicator, según se
requiera.

www.masterhacks.net
ELEMENTOS BOOLEANOS
Como se debe saber, los elementos booleanos funcionan con un cero o un

uno, siendo falso o verdadero respectivamente, no tienen otro valor más que
esos.
En LabVIEW los elementos booleanos se representan con el color verde y con

las letras t o f. Estos son botones, leds, comparadores, entre otros.
Un ejemplo muy sencillo del uso de estos, es para encender un led con un
switch, solo se necesita un switch y un led, conectados entre sí, para poder
encender el led con los valores verdadero o falso.
Imagen #14: Conexión de un switch y un led.
De esta forma al accionar el switch se enciende el led, puesto que como se

observa en la imagen #14, el Switch tiene una letra F (false) cuando el
interruptor se encuentra de lado izquierdo, y una T (true), cuando el
interruptor se encuentra de lado derecho.

www.masterhacks.net
Imagen #15: Ejemplo del uso de elementos booleanos.
En el panel frontal, en el menú booleano, se tienen elementos como el push

button, leds, Slide switch, buttons, radio buttons, entre otros. Todos son
elementos booleanos pues funcionan mediante dos valores, falso o
verdadero.
El uso de cada uno depende de la necesidad del programador y del usuario

final.
En el menú booleano del diagrama de bloques se pueden encontrar las

compuertas lógicas AND, OR, NOT, NAND, NOR, entre otras.
Para poder usar las compuertas lógicas, es necesario conocer sus tablas de
verdad, dichas tablas son:
Imagen #16: Tabla de verdad de la compuerta AND.

www.masterhacks.net
Imagen #17: Tabla de verdad de la compuerta OR.
Imagen #18: Tabla de verdad de la compuerta XOR.
Imagen #19: Tabla de verdad de la compuerta XOR de tres entradas.

www.masterhacks.net
Imagen #20: Tabla de verdad de la compuerta NOT.
Imagen #21: Tabla de verdad de la compuerta NOR.
Imagen #22: Tabla de verdad de la compuerta XNOR.

www.masterhacks.net
Un ejemplo del uso de la compuerta AND es el siguiente:
Imagen #23: Ejemplo del uso de la compuerta AND en un programa.
Se tiene un led y dos botones, el objetivo del programa es que al tener

presionados los dos botones, es decir, tener en estado True los dos botones,
el led se encienda, si cualquiera de los dos botones está apagado, el led no se
enciende.
Imagen #24: Diagrama de bloques del ejemplo del uso de la compuerta AND.
En el diagrama de bloques, se observa que los dos botones están conectados

a la compuerta AND, entonces, se puede decir que Boolean 2 Y (AND)
Boolean 3, activan a Boolean.
Es decir, el botón 1 y el botón 2 activan al led.
Es por esto que si un botón está apagado, no se enciende el led, pues no se

cumple la condición de la compuerta AND que dice que un elemento y otro
elemento deben estar encendidos.

www.masterhacks.net
USO DE SELECT
En LabVIEW se puede encontrar dentro del menú comparisson

(comparación), un ícono llamado select. Este funciona como la estructura
condicional if.
Si la condición es verdadera, se devuelve determinado valor o función, si es
falsa realiza la acción correspondiente.
Se puede apreciar un ejemplo muy sencillo del uso de select en el siguiente

programa:
Imagen #25: Panel frontal para ejemplo del uso de select.
El objetivo del control numérico es que si es menor de 5, el led de abajo

enciende, si es mayor de 5, se apaga el led de abajo y prende el de arriba.
Para esto se utilizan dos select, uno para cada led.

www.masterhacks.net
Imagen 26: Diagrama de bloques del ejemplo del uso de select.
Se utiliza un comparativo para el control numérico, en este caso mayor que.

Si el dato ingresado por el usuario en el tanque es mayor a 5, prende el led
de arriba, si es menor, prende el de abajo y se apaga el de arriba.
Nótese que se utilizaron constantes booleanas para los select, de esta
manera se hace más efectivo su uso cuando no se utilizan ciclos.

www.masterhacks.net
USO DE CADENAS DE TEXTO
Si se requiere trabajar con texto en LabVIEW se pueden utilizar los controles

e indicadores de texto. En el diagrama de bloques éstos tienen un color rosa,
al igual que los elementos booleanos y numéricos, los strings tienen control,
indicador y constante.
Para mostrar un texto determinado se utiliza una constante de texto, y para

que ésta sea visible en el panel frontal, se utiliza un indicador de texto.
Usando el ejemplo anterior, podemos agregar un indicador de texto para

visualizar los estados del programa:
Imagen #27: Ejemplo del uso de cadenas de texto.

www.masterhacks.net
El objetivo del indicador textual es que si el nivel es mayor o menor de 5, se

indique con un mensaje. Para esto se utiliza otro select conectado a
cualquiera de los dos leds, para evaluar si este está encendido o prendido, las
constantes de texto estarán conectadas al select y la salida al indicador.
Imagen #28: Diagrama de bloques del ejemplo de uso de strings.
Imagen #29: Programa funcionando

www.masterhacks.net
USO DE LA ESTRUCTURA CASE
Asumiendo que ya se sabe que la estructura case sirve para ejecutar o

albergar los posibles casos o acciones en función de una expresión.
En el lenguaje de programación C, la sintaxis es:
switch (funcion)
{
case1:
Sentencias;
break;
case 2:
Sentencias;
break;
}
Aquí, se ejecuta la estructura case al evaluar la función, en este caso tiene

dos casos con diferentes sentencias cada uno.
En el lenguaje gráfico, las estructuras de control se representan mediante

rectángulos. El case se conecta al elemento que requiera tener varias
opciones y todas las operaciones se van guardando en cada caso.
Se puede ver el funcionamiento de la estructura case en el siguiente ejemplo:
Imagen #30: Ejemplo del uso de la estructura case.

www.masterhacks.net
El programa es una calculadora de dos funciones, suma y resta, se piden dos

números al usuario y con un botón elige si quiere que esos números se resten
o se sumen.
Imagen #31: Diagrama de bloques del ejemplo de uso de case.
Como se mencionó anteriormente, el botón se conecta al case, dando como

resultado dos únicos casos, falso o verdadero. Al tratarse de un botón slide,
el falso es cuando el botón está del lado izquierdo y el verdadero del lado
derecho.
Al analizar la imagen #31 se puede notar que lo único que hay dentro del
case es la operación que se va a realizar. Esto es porque si metemos
cualquiera de los controles o indicadores, éstos solo servirán para un solo
caso, y para que el programa funcione correctamente se tendrían que crear
variables locales de cada elemento para colocarlos en el otro caso, pero eso
es innecesario y haría que el código quede más grande.
En cambio, dejando los elementos afuera, al conectarlos al case, se crea un

túnel en donde se pueden usar para los demás casos sin tener que crear
variables.

www.masterhacks.net
En el case también se puede conectar un tab control, útil para dar un mejor
aspecto al programa, almacenando cada operación o acción en un
contenedor individual. El tab control se encuentra en el menú Containers
(Contenedores).
Podemos ver un ejemplo con un programa para hacer los cálculos de la ley de
Ohm:
Imagen #32: Ejemplo del uso de tab control y case.
Aquí se usan tres pestañas para el tab control, (para añadir más pestañas se
da clic derecho sobre cualquier pestaña y luego en add page after ó add page
before). Cada pestaña representa el valor que se quiere obtener, ya sea
voltaje, resistencia o intensidad.
En cada pestaña hay dos controles numéricos y un indicador numérico, el

usuario ingresa los dos valores y el programa hace los cálculos pertinentes.

www.masterhacks.net
Imagen #33: Código del programa de ejemplo de uso de tab control.
Como se puede apreciar en la imagen #33, aquí si se meten todos los

elementos a cada caso, esto porque se está utilizando un tab control y resulta
mejor crear controles e indicadores para cada caso. Siguiendo la ley de Ohm,
solo se hacen operaciones sencillas de división y multiplicación.
Nota: Al conectar el tab control al case, automáticamente aparecen los dos

primeros casos, para agregar más casos a esta estructura, se da clic derecho
al nombre del caso en la parte de arriba y luego en add case before o after
según se requiera.
Si queremos utilizar cadenas de texto en un case que esté conectado a un

botón, es muy simple. El case solo tendrá dos casos, y por ello solo
utilizaremos dos mensajes.

www.masterhacks.net
Imagen #34: Ejemplo del uso de strings con case.
El diagrama de bloques queda como se muestra:
Imagen #35: Código del ejemplo de string en case.
En este caso, cuando el programa se corra continuamente, saldrá el mensaje

del caso false ya que seguramente el botón estará en false cuando se corra el
programa, al accionar el botón, se mostrará el mensaje del caso true.

www.masterhacks.net
USO DE ARRAY
El array (matriz o vector en español), se utiliza para almacenar varios

elementos, siempre del mismo tipo. En un array no se pueden meter objetos
que sean de distintos tipos, es decir; si se mete un led a un array, ese array
sólo será de leds.
En LabVIEW, si se requiere usar cada elemento de un array por separado, se

utilizan las herramientas del diagrama de bloques para poder hacerlo, tales
como index array, initialize array, etc.
Al colocar un array en el diagrama de bloques, solo se le arrastra un objeto

hacia dentro y el array toma automáticamente el tamaño del objeto. Para
hacer más grande el array (que tenga más elementos del mismo tipo) solo se
da clic en la flechita de tamaño ya sea abajo o arriba del array y se desplaza
hacia el mismo lado.
Si se requiere que el array sea de dos dimensiones, se le da clic derecho y se

da clic en add dimension.
Un ejemplo del uso de arrays puede ser el siguiente:
Imagen #36: Uso de Array en LabVIEW

www.masterhacks.net
En el panel frontal se tienen dos arrays, uno de leds y otro de switch.

En el diagrama de bloques sólo saldrán dos elementos, que son los arrays, si
se conectan, el programa funcionará perfectamente.
Imagen #37: Diagrama de bloques del ejemplo de Arrays.
Esto reduce de manera notable el código del programa, ya que si no se

utilizan arrays en este programa, en el diagrama de bloques habría cuatro
leds y cuatro switches, lo que haría muy grande el código.
Algo que se debe aclarar es que si se quiere controlar el array de cuatro leds
con un solo switch fuera de un array, no se puede, ya que son elementos de
distintos tipos.
Al conectar los dos arrays de esta forma, se respeta el orden de encendido,

es decir; al activar el switch 1, se enciende el switch 1, y así sucesivamente. Si
se requiere cambiar el orden de encendido, por ejemplo, que al activar el
switch 1 se encienda el led 4, al activar el switch 2 se encienda el led 3, y así
sucesivamente, se puede utilizar la herramienta Index array, para inicializar
los elementos del array en el orden que se requiera.
Después, las salidas del array indexado se van conectan a la herramienta

Build array, que construye un array para conectarlo al siguiente array.

www.masterhacks.net
Imagen #38: Uso de Index array y Build array.
Como se ve en la figura #38, se le dio un orden ascendente a los elementos

del array de switches, esas salidas se conectaron a un build array que a su vez
se conectó al array de leds.
Al correr el programa debe funcionar correctamente.
Imagen #39: Funcionamiento del programa con Index array.

www.masterhacks.net
USO DE ARRAYS CON STRINGS
Si queremos utilizar cadenas de texto para mostrar mensajes, en elementos

que están los arrays es sencillo, podemos utilizar el ejemplo anterior para
mostrar esto:
Imagen #40: Uso de string y array.
Como se puede apreciar en la imagen #40, el array de switches se indexa,

para sacar los elementos y ordenarlos, esto con el fin de poder conectar cada
elemento a un select que evalúa si el switch está activado o no.
Si es falso, con una constante de texto se dice que el led está apagado, si es
verdadero, dice que está encendido.
Lo interesante aquí es cómo mandar las tres salidas de texto al indicador.

Simple, usamos la herramienta Concatenate string, que agrupa todas
constantes de texto y saca una sola salida, como si se estuviera construyendo
un array de texto y éste se conecta al indicador.

www.masterhacks.net
El resultado al correr el programa es el siguiente:
Imagen #41: Programa funcionando con Concatenate string.
Los textos mostrados en el indicador se ven muy amontonados y da un mal

aspecto, esto se puede corregir utilizando un Carriage return constant, que
da un salto de línea. Aplicándolo al diagrama de bloques, queda de la
siguiente manera:
Imagen #42: Uso de Carriage return constant.

www.masterhacks.net
Esta constante de retorno se conecta cada vez que finaliza la frase (para este
caso), no es necesario usar tres constantes de estas ya que una sola puede
funcionar para todo el programa.
El resultado queda así:
Imagen #43: Programa funcionando con Carriage return constant.

www.masterhacks.net
EL CICLO FOR
El ciclo for es una estructura de control utilizada en la gran mayoría de los

lenguajes de programación, que permite establecer el número mínimo de
iteraciones.
Sus elementos son la variable de control, inicialización de la variable de

control, condición de control, incremento, y cuerpo.
La variable de control es la variable con la que el bucle va a trabajar, esta

misma es la que se inicializa para establecer un valor predeterminado con el
que va a iniciar la iteración.
Su uso se orienta a vectores, permite agregar, modificar o eliminar datos

según el índice.
En LabVIEW, este ciclo también se representa con un rectángulo:
Imagen #44: Representación gráfica del ciclo for.

www.masterhacks.net
La terminal N representa el número de veces que se va a repetir el ciclo, la

terminal i representa la iteración, que va desde 0 a n-1 .
Es importante aclarar que cuando se va a utilizar un ciclo, se debe agregar un

Timing (Wait), que sirve para que LabVIEW no consuma toda la memoria de
la PC y esto haga que se sature. El mínimo valor del Timing puede ser de 5
milisegudos.
Se puede tomar el siguiente programa como ejemplo del uso del ciclo for:
Imagen #45: Ejemplo del uso del ciclo for.
En el panel frontal solo se tiene un indicador numérico.
Imagen #46: Diagrama de bloques del ejemplo del ciclo for.

www.masterhacks.net
Se puede observar que el número de repeticiones del ciclo for será de 5, y la

operación será la suma de un número aleatorio y cinco. Esta operación se
hará cinco veces y esos cinco resultados se imprimirán en el indicador
numérico.
Aquí el Timing cumple una función interesante, ya que si le ponemos un valor

bajo como 5 o 10, no se aprecia el cambio en el indicador numérico y
parecerá que sólo se hizo una operación, en cambio, si se le pone 100 o más,
ya se puede ver cómo aparecen los 5 números, lógicamente, en el indicador
sólo quedará el último resultado.
Si queremos que el número de repeticiones del ciclo quede al azar, entonces

sólo ponemos el Random conectado a la terminal N. Con algunas operaciones
básicas, se pueden establecer límites para el número aleatorio.
IMPORTANTE: Al utilizar ciclos, ya sea for o while, no se debe utilizar el botón

correr continuamente, aquí sólo se usar el botón correr, para respetar las
acciones del ciclo y evitar que éste se cicle.
Asimismo, el botón abortar sólo se puede usar cuando el programa esté
ciclado.

www.masterhacks.net
FOR CONDICIONAL
Se dice que un ciclo for es condicional cuando éste tiene una terminal de
paro, se trata de una terminal a donde se puede conectar un botón de stop o
una condición para que el programa se detenga en determinado momento
sin importar que no se hayan ejecutado el número de repeticiones
establecidas.
Esta terminal de paro se puede agregar dando clic derecho sobre el ciclo for y
posteriormente clic en conditional terminal.
Imagen #47: Representación del ciclo for condicional.
Nótese que en la terminal N aparece un circulito rojo, éste representa que el

ciclo for tiene una terminal de paro.

www.masterhacks.net
SHIFT REGISTER
Los shift registers son elementos que guardan valores y mediante

operaciones son modificados, éstos son muy útiles para muchos programas,
en especial aquellos que utilicen contadores.
Estos elementos se usan en ciclos, para agregar uno, se le da clic derecho al

ciclo y luego se da clic en add shift register.
Imagen #48: Representación gráfica del shift register en ciclo for.
La terminal de la izquierda es el valor inicial que se guardará en el shift

register, mientras que la terminal de la derecha, es donde se guardará el
nuevo valor.

www.masterhacks.net
Un ejemplo del uso de shift register con array es el siguiente:
Imagen #49: ejemplo del uso de shift register y array.
Aquí, se tiene un array de 4 leds, se usa un shift register que está aumentado
a 4 elementos que representan a cada led, esto se hace poniendo el cursor
del mouse debajo del shift register y arrastrándolo hacia abajo.
Se inicializa con una constante true, esto indica que el primer led estará
encendido al correr el programa. En un lapso de 100 milisegundos pasa a
false y el siguiente a true, así hasta llegar al último, y esto se repite 50 veces o
hasta que el usuario presione el botón stop.
Imagen #50: Panel frontal del programa de ejemplo de shift register y array.

www.masterhacks.net
EL CICLO WHILE
A diferencia del For, el ciclo While ejecuta determinada acción hasta que el
programa termine su función o hasta que el usuario decida detener el
programa. Si el programa no tiene un fin determinado, el programa se
ejecutará infinitamente o hasta que el usuario lo detenga.
El ciclo While no funciona si no se conecta un botón de stop o una condición

de paro a la terminal de stop, si no ocurre esto, será imposible ejecutar el
programa.
Imagen #51: Representación gráfica del ciclo while.
Aquí también es posible utilizar shift register.

www.masterhacks.net
Se puede observar un ejemplo muy sencillo de un programa para encontrar

la hipotenusa de un triángulo usando el Teorema de Pitágoras, con el ciclo
while.
Imagen #52: Ejemplo del uso del ciclo while.
En el panel frontal se tienen dos controles numéricos y un indicador

numérico, cada uno representa un lado del triángulo.
Imagen #53: Diagrama de bloques del ejemplo con while.
En el diagrama de bloques, se tiene un ciclo while, que contiene toda la

operación. Según el Teorema de Pitágoras, se sabe que el cuadrado de la
hipotenusa es igual a la suma de los catetos.

www.masterhacks.net
Entonces una forma simple de resolverlo, es usando la función square, que

eleva al cuadrado cualquier número que se le conecte, entonces, se usan dos,
uno para cada lado del triángulo. Éstos se suman y se le saca raíz cuadrada al
resultado, usando la función square root. Ambas funciones se encuentran en
el menú Numeric.
El resultado se imprime en el indicador numérico.
Nótese que el ciclo while tiene un botón de stop conectado a la terminal de

paro, sin esto, el programa no se ejecuta.
Hasta aquí todo va bien, pero hay un pequeño error, que en este programa
puede no causar problemas, pero al trabajar con programas grandes, puede
ocasionar muchos problemas. Es necesario colocar un Timing.
Imagen #54: Uso del ciclo while con Timing.

www.masterhacks.net
Un ejemplo para el uso de shift register con un ciclo while, podría ser un
contador, para llenar un tanque.
Imagen #55: Panel frontal para el programa con while y shift register.
Aquí, el propósito del programa podría ser que el tanque se vaya llenando,
como si se tratara de una máquina automática de llenado de algún líquido,
como un despachador de café o algo así.
Imagen #56: Diagrama de bloques del ejemplo de un contador.

www.masterhacks.net
El shift register se inicializa en cero y se le suma uno, esto hace que en cada
repetición se sume uno al valor final. Esto hace que el tanque se vaya
llenando lentamente, dando un efecto como de máquina automatizada.
Aquí, el timing juega un papel muy importante, ya que si se deja en el valor

que muestra la imagen #56, el llenado va a ser muy rápido y no se va a poder
apreciar, entonces se tiene que cambiar el 5 por un 200 o más para que se
pueda ver mejor cómo se va llenando el tanque.
También se puede cambiar el uno de la suma por otro número menor o

mayor, para dar más precisión a la cantidad de líquido que se vierte en el
tanque, si se utilizan decimales, es necesario cambiar la representación para
poder usarlo, ya que en el ejemplo se están usando enteros.
Otra cosa muy útil sería que el programa se detuviera cuando el tanque
llegue a 10. Para esto, usamos una función de comparación Equal (igual),
conectada a una compuerta OR, esto para que el programa se detenga si el
tanque llega a 10 o si el usuario presiona el botón de stop.
Imagen #57: Diagrama de bloques del ejemplo terminado.
Se puede ver un video del funcionamiento de este programa aquí:

http://www.youtube.com/watch?v=4-ONceG9hWQ

www.masterhacks.net
VARIABLES LOCALES
En lenguajes de programación como C se usan variables para todo, por

ejemplo, se declara una variable llamada edad, esta variable se puede usar
muchas veces en todo el código del programa, respetando su tipo de dato.
En LabVIEW se puede hacer lo mismo, se pueden crear variables locales de

elementos para poder usarlos varias veces, aunque no es recomendable
abusar de las variables locales, algunas veces resulta muy útil. De hecho, se
deben usar solamente cuando es necesario.
Para crear una variable local, solo se da clic derecho sobre el elemento, luego
en create>Local variable.
Imagen #58: Control numérico slide y su variable local.
La variable local parece una constante, si se le da un clic, se puede cambiar

por otro elemento que se encuentre en el diagrama de bloques.

www.masterhacks.net
USO DE CLUSTER
En LabVIEW un cluster es una colección de elementos de diferentes tipos. Es

parecido al array, la diferencia es que en el array sólo se pueden introducir
un solo tipo de elementos, es decir; un led o un botón. En cambio, en el
cluster se puede introducir cualquier elemento, ya sean leds, botones,
medidores, controles numéricos y de texto, etc.
El uso del cluster puede reducir el tamaño del código y dependiendo del
programa que se esté desarrollando, su uso puede ser imprescindible.
Podemos ver un panel frontal con un cluster que alberga algunos elementos:
Imagen #59: Cluster con un led, un push button y un indicador de texto.
Como se puede ver, se tienen tres elementos diferentes. El tamaño del

cluster, a diferencia del array, se puede modificar al tamaño que más le
agrade al programador.

www.masterhacks.net
En el diagrama de bloques, lo anterior aparece con un solo elemento, al igual

que el array. Para trabajar con cluster, se usan las funciones del menú
cluster, class & variant.
Para sacar los elementos del cluster, podemos usar Unbundle y Unbundle by
name. La diferencia entre estos es que el unbundle saca los elementos de
forma individual, en orden ascendente. Y el unbundle by name saca los
elementos mostrando sus nombres, en algunas ocasiones es más fácil utilizar
esta función para saber con qué elementos se está trabajando.
Imagen #60: Uso de unbundle by name.
Al conectar el cluster al unbundle by name, este sólo muestra un elemento,

para visualizar los demás se tiene que colocar el cursor en la parte de debajo
de la función, dar clic y arrastrar hacia abajo sin soltar para que vayan
mostrándose los siguientes elementos.

www.masterhacks.net
Se puede observar el siguiente ejemplo donde se usa un cluster y variables

locales:
Imagen #61: Ejemplo del uso de cluster.
En el panel frontal se tiene un cluster con un medidor y un indicador

numérico. El objetivo es que el usuario mueva la aguja del medidor y lo que
marque se pueda observar en el indicador numérico.

www.masterhacks.net
El primer paso sería sacar los elementos del clúster, utilizando un unbundle
by name, y se selecciona solo el medidor que es el que se va a utilizar como
control. Luego utilizamos bundle by name para conectar el medidor al
indicador numérico, aquí prácticamente se estaría creando un cluster. Para
finalizar, se crea una variable local del cluster y se conecta el bundle by name
a éste.
Imagen #62: Uso de cluster con variable local.
De esta manera, al correr el programa y mover la aguja del medidor, el

indicador numérico mostrará el número real que la aguja está marcando.

www.masterhacks.net
APLICANDO LOS CONOCIMIENTOS
Máquina despachadora de refrescos.
Aplicando todo lo que se ha visto hasta ahorita, podemos crear un programa

que simule una máquina expendedora de algún líquido, en este caso,
refrescos.
El funcionamiento es simple, el programa muestra tres botones, éstos

representan sabores, cola, manzana y limón.
El programa muestra un mensaje de bienvenida mientras no se presione
algún botón.
Se muestra un control numérico que representa la ranura donde se introduce

el dinero, y un indicador que imprime el cambio.
También hay un indicador numérico tipo tanque, que se irá llenando al

presionar un sabor, siempre y cuando se haya introducido una cantidad de
dinero suficiente.
Imagen #63: Panel frontal del surtidor de refrescos.

www.masterhacks.net
Los botones que indican los sabores están dentro de un cluster, lo demás son
controles e indicadores.
Entonces, al correr el programa, se mostrará un mensaje de bienvenida y el

usuario podrá ingresar dinero y presionar el botón que elija.
Imagen #64: Diagrama de bloques de la máquina de refrescos.

www.masterhacks.net
Como se puede ver en la imagen #64, se usa un ciclo while que anida 3
estructuras case, que a su vez, anidan otro case cada una, y éste, un ciclo for.
Se analizará cada parte del código.
Imagen #65: Se sacaron los elementos del cluster con Unbundle by name.
Dentro del while, se utilizó unbundle by name para poder usar los botones
del cluster individualmente. Estos tres botones se conectaron a una
estructura case cada uno.
Imagen #66: Mensaje de bienvenida del programa.
El mensaje de bienvenida no debe estar dentro de ningún case, ya que este

se debe mostrar al momento de ejecutar el programa. Se usa un Select
conectado a cualquiera de los tres botones, en este caso, el primero, si el
botón se activa, no se muestra el mensaje, si no se activa, se muestra el
mensaje de bienvenida. Esto es algo lógico, ya que se sabe que no se puede
presionar ningún botón antes de correr el programa, entonces, obviamente
se mostrará el mensaje antes que nada.

www.masterhacks.net
Imagen #67: Estructura Case del primer botón.
Todos los Case de los tres botones tienen lo mismo, solo cambia el costo de
la bebida. En el primer case, estando en true, se evalúa si el dinero ingresado
es igual o mayor que 15 (costo de la bebida). Si esto es verdadero, en un case
anidado se hace la operación para mostrar el cambio.
También se muestra un mensaje que dice que ya se está preparando su

bebida y se usa una variable local del indicador de texto.
Con un ciclo for se hace la simulación del llenado del vaso. Como se vio
anteriormente, se usa un shift register como contador para ir llenando el
vaso, empezando de cero y llenándose de 5 en 5 cada 200 milisegundos.
Después, si el valor del tanque es igual a 100, se manda la instrucción de
detener el programa.

www.masterhacks.net
Imagen #68: Valor false del segundo case.
Si el valor del dinero ingresado es menor que 15, entonces el programa

muestra un mensaje emergente que le indica al usuario que no le alcanza
para esa compra.
Los siguientes dos case indican lo mismo, sólo cambia el valor del dinero y
que se usan variable locales de los controles e indicadores.
Imagen #69: Uso de compuerta OR para detener el programa.
Se utiliza un compound OR de tres casillas para detener el programa cuando

el tanque de cualquiera de los tres botones llegue a 100.
Se puede ver un video del programa funcionando aquí:
http://www.youtube.com/watch?v=3q3HnQQ6Ix0

www.masterhacks.net
INSERCIÓN DE IMÁGENES Y DECORACIONES
Pueden surgir algunas dudas con el programa anterior, como por ejemplo,
cómo insertar la imagen del vaso en el panel frontal.
Insertar imágenes es muy sencillo. Basta con tener una imagen guardada en
el disco duro y arrastrarla desde su ubicación hasta el panel frontal, de esta
manera se hace una copia y no importará si se borra la imagen del disco
duro, ésta se quedará en el panel frontal, donde se podrá modificar su
tamaño.
Para encontrar las decoraciones, se debe ir al menú Modern > Decorations.

Ahí estará el siguiente menú:
Imagen #70: Menú de decoraciones de LabVIEW.

www.masterhacks.net
Ahí se puede elegir cualquier tipo de decoración para que el programa que se
esté desarrollando se vea más presentable.
Para que la decoración que se haya elegido no tape todo, nos vamos al menú
y se da clic en el ícono que tiene dos flechas como las siguientes:
Imagen #71: Menú para mover elementos.
Aquí se puede elegir Move to back para que la decoración se vaya hasta atrás
de todo lo que se tenga en el panel.
Para insertar imágenes al panel frontal es muy sencillo, solo basta con dar clic
en Edit o Editar, y en Import picture to clipboard.
De esta manera se puede elegir la imagen que se requiera.
Otra forma es arrastrar la imagen desde su ubicación al panel frontal.

Cualquiera de estas dos opciones es buena, y luego se puede modificar el
tamaño de la imagen en el panel frontal.

www.masterhacks.net
Imagen #72: Insertar imágenes en el panel frontal.

www.masterhacks.net
MÁQUINAS DE ESTADOS
Una máquina de estados se usa para el desarrollo de algoritmos, siendo una

forma muy eficaz de implementación.
Se sigue una serie de pasos para lograr que la máquina funcione, esto se
puede observar en el siguiente diagrama:
Entrada 1
ESTADO 2
Entrada 2
Entrada 1 Entrada 2 Entrada 2 Entrada 2

Entrada 3
Entrada 3
ESTADO 1 Entrada 1 ESTADO 3
Entrada 3
Imagen #73: Diagrama de estados.
En LabVIEW, se utilizan máquinas de estados para resolver problemas en

determinadas condiciones.
Los elementos básicos de una máquina de estados en LabVIEW son: Un ciclo
while, una estructura case, un enum y los elementos básicos de las
estructuras como lo son el timing y el botón de paro del ciclo while.

www.masterhacks.net
Para abrir una plantilla de máquina es estados en LabVIEW, sólo se da clic en

File>new>For template>Frameworks>Design Patterns>Standard state
machine.
Imagen #74: Proceso de apertura de plantilla de máquina de estados.
Al dar clic en OK, se abre en el diagrama de bloques una plantilla de máquina

de estados, en la estructura case se añaden los estados y se controlan con un
Enum conectado a un shift register.

www.masterhacks.net
Imagen #75: Plantilla de máquina de estados en LabVIEW.
Ahora se verá un ejemplo del uso de la máquina de estados para crear un

programa de llenado de un tanque de Diesel. El panel frontal mostrará un
tanque con capacidad de 1000 litros, 3 botones y un indicador numérico.
Para empezar, se establecen los estados, salidas, entradas, acciones para

poder realizar el diagrama de estados.

www.masterhacks.net
Para este programa, se tiene lo siguiente:
Estados:
 Stand by: El programa en estado normal

 Inicio: Se comienza a llenar el tanque
 Detener: Se detiene el proceso de llenado
Entradas:
 Botón de inicio
 Botón de detener
Salidas:
 Llenado del tanque

 Paro del programa
Acciones:
 Si se está Stand by se espera una acción.

 Si se está en inicio se llena el tanque hasta llegar a 1000.
 Si se está en detener, se detiene el proceso de llenado pero no la
ejecución del programa.
Con estos datos ya se puede crear el diagrama de estados que servirá para
poder desarrollar el código del programa en LabVIEW.

www.masterhacks.net
Inicio
Stand
Detener
by
Ahora, ya se puede empezar con el código. Se coloca lo básico, un ciclo while,

un case y un Enum.
En el panel frontal se tendrá un tanque, dos botones que se usarán para

Inicio y Detener, un indicador numérico para visualizar los litros y un botón
de paro para el ciclo While.
Imagen #76: Panel frontal del ejemplo de máquina de estados.

www.masterhacks.net
El diagrama de bloques terminado queda de la siguiente manera:
Imagen #77: Diagrama de bloques del ejemplo de máquina de estados.
Como se observa en la imagen #77, al estar en el caso Inicio, el proceso de

llenado funciona con un ciclo for, parecido al de programas anteriores para
llenar tanques. Se usan 1000 repeticiones del for, que representan el número
de litros. Con el Timing elegimos el tiempo que tarda en llenarse.
Con un incremento los indicadores (tanque e indicador numérico) aumentan

de uno en uno cada 5 milisegundos, al ser el valor de los indicadores igual a
1000, se detiene el proceso de llenado.

www.masterhacks.net
Imagen #78: Caso Stand by.
Al estar en Stand by, el programa solo espera que el usuario presione el

botón Inicio para pasar al estado de llenado, de lo contrario se queda en el
mismo estado.
Imagen #79: Funcionamiento del botón detener.
Para que el proceso de llenado del tanque se detenga sin que el programa
completo se detenga, hay que ponerle una terminal de paro al ciclo for (for

www.masterhacks.net
condicional), de esta manera, al presionar el botón sólo se detendrá el ciclo

for y no todo el programa, haciendo más eficaz el uso del mismo.
Imagen #80: Paro total del programa.
Si se quiere que el programa se detenga por completo, entonces se tiene que

usar la terminal del ciclo while. Nada más que aquí es necesario utilizar una
compuerta lógica OR para que el programa se detenga si el usuario presiona
el botón Stop o si el tanque llega a los 1000 litros.
Con esto se concluye el programa y sólo queda agregar algunos detalles

visuales o en el código, dependiendo de las necesidades del programador y
del usuario final.

www.masterhacks.net
EJERCICIOS PARA PRACTICAR
Hasta aquí ya se ha visto lo más básico para aprender a programar en

LabVIEW, por lo que el estudiante ya debe comprender el funcionamiento de
cada elemento que ofrece este Software, así como saber resolver problemas
relacionados.
Ahora se verán algunos ejemplos para reforzar lo aprendido, en éstos se

trabajará con todo lo que se ha visto hasta el momento.
Podemos empezar con un ejercicio aplicado al área del álgebra lineal.

Suponiendo que necesitamos resolver una multiplicación de matrices A X B,
que mejor forma que hacerlo con algún software como Matlab o Excel, pero
al tratarse de ser programadores, podemos crear uno en LabVIEW.
Se puede crear un programa que haga multiplicación de matrices usando

arrays y todas las operaciones que esto requiere, pero sería una pérdida de
tiempo hacer el programa que realice la operación si LabVIEW ya incluye un
menú para trabajar con álgebra lineal. Sólo basta con usar los elementos de
este menú.
Imagen #81: Menú de elementos para álgebra lineal.

www.masterhacks.net
Para acceder a este menú desde el diagrama de bloques se selecciona

Mathematics>Linear Algebra.
Ahora, en el panel frontal, se usarán tres matrices; A, B y C, siendo A y B las

matrices que se van a multiplicar y C el resultado. Con esto ya se puede saber
de antemano que A y B serán controles y C indicador.
Se pueden encontrar las matrices en el menú donde se encuentran los arrays,

ahí se usa Real Matrix para matrices con números reales, ó Complex Matrix
para matrices con números complejos.
Imagen #82: Matrices para el ejemplo de multiplicación de A X B.
Ahora, en el menú de álgebra lineal, se utiliza el elemento AXB y se conectan

las matrices.
Imagen #83: Diagrama de bloques del programa A X B.

www.masterhacks.net
A y B se conectan de lado izquierdo y C del lado derecho. El ciclo while es

opcional, pero si se requiere que el programa se mantenga en ejecución es
conveniente utilizar un ciclo.
Hay que tener presente el orden de conexión de las matrices, ya que si se

coloca A en el lugar de B y B en el de A el resultado será diferente.
En este programa se está trabajando con matrices de 3 X 3, pero hay opción

de hacerlas más grandes o más pequeñas.
TAMAÑO DE UN BOTÓN CON NODOS DE PROPIEDAD
En este programa usaremos nodos de propiedad para ajustar el tamaño de

un botón. Usaremos el nodo Size con los parámetros Width y Height.
Imagen #84: Ubicación del nodo de propiedad Size.
Con este nodo de propiedad podemos ajustar el ancho y largo del botón.
Para esto usaremos dos controles tipo Slide que se conectarán al cluster del
nodo de propiedad mediante un bundle by name.

www.masterhacks.net
Imagen #85: Código del programa con nodo de propiedad Size.
Imagen #86: Panel frontal del programa.
Para ver el programa funcionando entra a este link:

http://www.youtube.com/watch?v=D4oLOfPpWRc

www.masterhacks.net
EJERCICIO CON ARRAY DE LEDS
El objetivo de este ejercicio es explotar los conocimientos que se tienen en el

uso de arrays, se tiene un array de 11 X 11 de leds en donde el objetivo es
que se encienda un led del centro, y vaya haciendo una especie de espiral
hasta dejar prendidos todos los leds.
Aparte, el programa tendrá la opción de que el usuario elija hacia qué

dirección se encenderá el segundo led: arriba, abajo, izquierda o derecha.
También tendrá un indicador de texto que mostrará un mensaje cuando el

programa esté en ejecución o se detenga. Un botón de stop y un botón de
salida que hará que se cierre LabVIEW al presionarlo.
El panel frontal terminado queda de la siguiente manera:
Imagen #87: Panel frontal del programa.

www.masterhacks.net
El diagrama de bloques completo es el siguiente:
Imagen #88: Diagrama de bloques del programa.
El programa consta de un ciclo For y dos estructuras case, el mayor grado de

complejidad está en la parte de la dirección de encendido. Se explicará por
partes para una mejor comprensión.
Imagen #89: Uso de shift register con enum.

www.masterhacks.net
Se utiliza un Enum con 4 valores; arriba, abajo, izquierda y derecha, éste es el

que se encarga de asignar la dirección hacia donde se encenderán los leds. Se
conecta a un shift register que a su vez se conecta a una estructura case. Esta
estructura tendrá una configuración para cada uno de los cuatro casos en
donde prácticamente sólo varía el orden de los incrementos y decrementos.
Imagen #90: Configuración del ciclo for y del array de leds.
Se utiliza un initialize array que no servirá para establecer un cómo empezará

a trabajar el array. La constante False indica que al ejecutar el programa, los
leds estarán apagados, de ahí, las dos terminales de abajo hacen referencia a
la dimensión del array, en este caso de 11 X 11, así que se usaron dos
constantes, 5 y 1, donde x vale 5 y n vale 1. Usando el elemento que
multiplica a X por 2 elevado a la n potencia, tenemos que 5 X 1 = 101 lo que
nos deja un valor de 10, a esto le sigue un incremento que nos deja un valor
de 11, con esto ya tenemos que nuestro array es de 11 X 11.
Todo lo anterior se puede sustituir por un simple 11 en cada terminal, para

hacer las cosas más sencillas.
Luego podemos observar que el valor 11 se conecta a un elemento que eleva

a la segunda potencia, lo que hace que nuestra X tenga un nuevo valor de
121, luego se conecta a un decremento dando como resultado 120.

www.masterhacks.net
Este número 120 representa el número total de leds en el array, y a su vez, la

cantidad de repeticiones que el ciclo for ejecutará.
El resultado del Initialize array se conecta a un Replace array subset, que va a

reemplazar los leds apagados por leds encendidos con ayuda de los shift
register. Nótese que se siguen usando los valores de 11 X 11.
Este último elemento se conecta a un shift register que pasa por la estructura
case, luego se conecta a otro Replace array subset que seguirá el orden de
encendido de los casos y dejará en valor verdadero los leds que se vayan
encendiendo, luego se conecta al array de leds para mostrar el resultado.
Imagen #91: Estructura case para el orden de encendido.
Para establecer hacia donde se van a encender los leds, sólo se usan dos
elementos, incremento y decremento. Por ejemplo, para “Abajo”, al estar
encendido el led del centro se enciende el de abajo con un decremento,
luego, con un incremento se enciende el de su derecha y así funcionan los
demás casos, sólo se juega con los incrementos.

www.masterhacks.net
Imagen #92: Textos para el estado del programa.
En la parte de estado, el programa muestra en un indicador de texto si el

programa está ejecutándose o si se detuvo. Para esto usamos dos constantes
de texto conectadas a un select y éste conectado al botón de stop. Si el botón
no se presiona, por default al ejecutar el programa saldrá el mensaje de que
se está corriendo ya que los leds empiezan a encenderse. Al presionar el
botón, se muestra el mensaje de que el programa se detuvo y luego se
detiene el programa.
Cabe mencionar que el Timing que se ve en la figura 80 nos sirve también

para la velocidad de encendido de los leds.
Imagen #93: Mensaje de despedida y salida de LabVIEW.

www.masterhacks.net
Para salir de LabVIEW usamos otro botón, éste se conecta a un case, si el

botón está en false no se hace nada, si se presiona, cambia a true y el
programa mostrará un mensaje emergente con la frase “Hasta luego” y con
el elemento Exit, saldrá de LabVIEW.
Para ver el programa funcionando, puedes ver el siguiente video:
http://www.youtube.com/watch?v=jLspyWmOTFM
MÁQUINA TRAGAMONEDAS
El siguiente programa es muy extenso, se utilizan muchos elementos, en

especial leds, y varias estructuras case. Se trata de una máquina
tragamonedas como las que se suelen ver en las tienditas.
El funcionamiento es simple, se inserta el dinero y se escoge una fruta, cada

fruta tiene un valor, este valor es el que el usuario puede ganar si el led se
enciende en su casilla. Al insertar el dinero y presionar el botón de la fruta, se
enciende un led que va recorriendo todas las casillas, empezando con una
velocidad alta que va disminuyendo aleatoriamente hasta detenerse.
Si al terminar, el led se enciende en la fruta seleccionada, se gana el valor

indicado, si no, se descuenta un peso del dinero ingresado.
Si se presiona el botón de jugar sin haber ingresado dinero, se muestra un

mensaje de alerta advirtiendo que no hay dinero suficiente. Si el usuario gana
el premio seleccionado, se muestra otro mensaje de felicitaciones.
Si el usuario quiere sacar su dinero sobrante o ganado, se presiona el botón

cobrar y la cantidad va disminuyendo simulando que fueran cayendo las
monedas.
www.masterhacks.net
El panel frontal es un poco grande, debido a que se utilizan las imágenes de

una máquina real, sólo insertando los elementos con los que se trabaja en
LabVIEW.
Imagen #94: Panel frontal del programa “Máquina tragamonedas”.
En el panel frontal, los elementos que se usarán son los leds que hay en cada
fruta, los botones de la parte derecha, también el control numérico y el
indicador de texto y el botón de stop.
Debido a que el código es demasiado grande, no se mostrará completo como

imagen, pero se puede ver en el video de muestra o descargando el VI desde
nuestra página web.
Para el manual, se explicará el código por partes.

www.masterhacks.net
Para empezar, utilizamos un ciclo while para mantener corriendo el

programa, hasta que se presione el botón de stop. Esto podría considerarse
como la simulación de encendido y apagado de la máquina.
Dentro del while, se colocó el botón de jugar, éste se conectó a un case, en el

caso falso no se hace nada, en el caso verdadero, se evalúa si el control
numérico “dinero” es mayor o igual a uno y eso se conecta a otro case
anidado. En caso de ser falso, se muestra un mensaje emergente advirtiendo
que falta dinero. Si es verdadero, se ejecuta la mayor parte del programa.
Imagen #95: Se evalúa si dinero es mayor o igual a 1.
Aquí es donde viene la parte más interesante, hacer que el led recorra todas
las frutas, encendiéndose uno y apagando los que ya recorrió, empezando
rápido hasta terminar lento.
Lo más viable para esto sería un ciclo for. El número de repeticiones del ciclo
será la cantidad de vueltas que dará el led encendido en el tablero, ésta
cantidad debe variar, ya que se trata de un juego de azar.

www.masterhacks.net
Entonces, se puede utilizar un número aleatorio (random), éste se encuentra

en el menú numérico. Ahora, como se trata de un número aleatorio, podría
variar entre 0 e infinito, entonces se tiene que poner un rango. En este caso
fue de 0 a 150.
Imagen #96: Configuración del número de repeticiones.
Ahora, para que el led camine con una velocidad descendente, podemos usar
un contador con un shift register. Se inicializa el shift register en cero, se
conecta a un incremento y éste a un timing.
Esto ocasionará que el timing empiece en cero y vaya avanzando en uno

conforme avanzan las repeticiones del ciclo.
Imagen #97: Configuración de la velocidad de avance del led.
Para que al ejecutarse el ciclo for no se queden encendidos los leds, se

inicializa el shift register en true y los demás, que corresponden a cada led, se
quedan en false. Esto hará que no se queden encendidos, únicamente lo
estará uno.

www.masterhacks.net
Imagen #98: Inicialización de shift registers.

www.masterhacks.net
Al correr el programa, el indicador de texto nos muestra un mensaje, éste se

encuentra dentro del while, y se mostrará durante toda la ejecución del
programa.
Imagen #99: Mensaje de texto del programa.
Aquí se usan dos frases para el usuario, entre ellas usamos un Carriage
Return Constant que nos servirá para colocar una oración debajo de la otra,
es decir; deja un espacio como si se hubiera presionado un enter al escribir o
parecido al uso de \n en el lenguaje C.
Para que se haga la resta del dinero del usuario cada vez que presiona el
botón jugar, utilizamos una variable local del control numérico.
Imagen #100: Resta del dinero al presionar el botón “jugar”.
Entonces, se conecta el control numérico “dinero” a una operación de resta,

y el resultado se conecta a una variable local del mismo control numérico.

www.masterhacks.net
Imagen #101: Conexión de los botones a estructuras case.
Cada botón que representa las frutas del tablero se conecta a una estructura
case, en esta, se usa una compuerta lógica OR para advertir que si X led se
queda encendido se cumpla el caso verdadero. Si el case debe responder a
más de dos leds, se utiliza un Compound Arithmetic para poder conectar más
elementos a la compuerta.

www.masterhacks.net
Imagen #102: Uso de compuerta AND en estructura case.
Esa compuerta se conecta a otro case anidado, en donde el caso falso no

contiene nada, pero el verdadero alberga la operación que se realiza si el led
cae en la fruta que el usuario eligió.

www.masterhacks.net
Por ejemplo, en el caso de la naranja, la estructura case es la siguiente:
Imagen #103: Casos para leds representativos de la naranja.
La naranja se repite tres veces en el tablero, por lo tanto son 3 leds los que se
usan para esa fruta, si uno de esos tres queda encendido al terminar el ciclo
for, se utiliza una operación de suma para añadirle el valor de la fruta, 10 en
este caso, al dinero del usuario, para esto se utiliza una variable local del
control “dinero”.
También se utiliza el elemento One Button Dialog para mostrar un mensaje

emergente al usuario felicitándolo.
Lo mismo se usa para cada botón, entonces se utilizan nueve estructuras

case que a su vez anidan otra.
Imagen #104: Casos para salto de turno.
Si el led se detiene en la figura del muñequito que hay a los lados del tablero,
sólo se regresa la cantidad que el usuario gastó.

www.masterhacks.net
Para terminar nos queda la parte donde el usuario decide cobrar el dinero
que ganó o el dinero que ingresó.
Para esto se utilizará otro contador, pero esta vez descendente.
Imagen #105: Contador descendente para botón de cobro.
Se conecta el botón de “cobrar” a una estructura case, en el caso falso no se

hace nada, en el verdadero, se utiliza un ciclo for.
El número de repeticiones del ciclo for será la cantidad que haya en el control
numérico “dinero”. Se utiliza un shift register, que se inicializa también con el
control numérico “dinero”, se conecta a un decremento y luego a una
variable local del mismo control numérico.
Con un timing de 5 mili segundos determinamos la velocidad del contador,

entonces, al presionar el botón, los números en el control irán corriendo
descendentemente, simulando la caída de dinero de la máquina.
Es importante aclarar que la configuración del botón cobrar quedará en la

acción mecánica Switch when pressed. El objetivo de esto es que mientras se
tenga presionado el botón, se ejecute la acción. Si se presiona y se suelta,
sólo se ejecutará el for una o dos veces, pero si se deja presionado, se
ejecutará hasta que se quede en ceros. Esto le agrega más realismo al juego.
Esto también se aplica para los botones de las frutas.

www.masterhacks.net
Imagen #106: Código completo de la máquina tragamonedas.

www.masterhacks.net
Puedes ver un video del programa funcionando aquí:

http://www.youtube.com/watch?v=b_wL9Ncb_nA
EDICIÓN DEL ÍCONO DE UN PROGRAMA
Como ya se ha mencionado anteriormente, para editar el ícono del programa

que se esté creando, Se da un clic derecho sobre el ícono situado en la parte
superior derecha, luego clic en edit icon.
Imagen #107: Cómo entrar al editor de íconos.
También se puede acceder dando doble clic al ícono.
Al hacer eso, nos aparecerá una ventana como la siguiente:
Imagen #108: Editor del ícono del programa.

www.masterhacks.net
Ahí se puede editar el ícono como se requiera, se pueden utilizar las

imágenes de la pestaña Glyphs.
Y desde ahí se puede editar el ícono de la forma que se requiera, usando

imágenes, las herramientas del editor, entre otros.
Imagen #109: Ejemplo de ícono.

www.masterhacks.net
OPERACIONES CON MATRICES
Hacer operaciones con matrices en LabVIEW es algo muy sencillo, la

programación se hace rápidamente y no se necesita un diagrama de bloques
muy grande. Para poder utilizar matrices, se debe ir al menú de Array, Cluster
& Matrix.
Imagen #110: Menú de matrices.
Aquí se pueden utilizar matrices reales o matrices complejas. Es necesario

tener conocimientos en álgebra lineal para comprender estos términos y
para realizar algunas de las operaciones, que aunque el programa hace todo,
se necesitan los conocimientos para poder desarrollar el programa.

www.masterhacks.net
Un programa sencillo puede ser el siguiente:
Imagen #111: Programa de multiplicación de matrices.
En la imagen #111 se muestra el panel de control, donde se encuentran tres

matrices reales, dos de ellas son controles, mismas que serán las que se
multiplicarán de la manera A X B, dando como resultado C, siendo C la
tercera matriz que en este caso será indicador.
Imagen #112: Diagrama de bloques del programa de multiplicación de

matrices.
El diagrama de bloques de este programa resulta muy pequeño, basta con

una multiplicación de las matrices A y B.

www.masterhacks.net
Otra manera de realizar esta operación, es utilizando el Sub VI de

multiplicación de matrices que ofrece el toolkit matemático de LabVIEW.
Este se puede encontrar en el menú de objetos, dando clic en Mathematics,

Linear algebra:
Imagen #113: Menú de álgebra lineal de LabVIEW.
Aquí se selecciona el VI de multiplicación A X B y se coloca como se muestra

en la siguiente imagen:
Imagen #114: Uso del VI de multiplicación de matrices.

www.masterhacks.net
Basta con conectar las matrices que se van a multiplicar al sub VI para que
éste haga la operación. Como se puede ver en la figura #114 se puede
agregar un ciclo while para que el programa pueda detenerse con un botón
cuando sea necesario.
Existen muchos más elementos para poder hacer operaciones con matrices,
su uso ya depende de la aplicación que se le quiera dar al programa que se va
a desarrollar.
USO DE FÓRMULAS MATEMÁTICAS CON LABVIEW
LabVIEW también cuenta con una herramienta que nos permite proporcionar
fórmulas en un nodo matemático utilizando el lenguaje C. Esta herramienta
se llama Formula node y se encuentra en el menú de matemáticas:
Imagen #115: Ubicación del nodo de fórmulas.
En este nodo se puede crear el programa en lenguaje C que se vaya a utilizar,

generalmente es más usado para escribir fórmulas matemáticas que no se
pudieran plantear con el lenguaje gráfico.

www.masterhacks.net
Un ejemplo muy simple es un comparador como el siguiente:
Imagen #116: Diagrama de bloques del comparador utilizando Formula Node.
En este programa se creó un programa que comparara un número, en este

caso el de la variable A. Si A es igual a 10, la variable B toma el valor de 1, de
lo contrario, toma el valor de 0.
Algo importante es que en este caso se están utilizando variables externas al

nodo de fórmula, siendo el control A y el indicador B dichas variables, por
esta razón no es necesario declararlas en el nodo de fórmula, claro está que
si no se utilizaran variables externas, es necesario declarar las variables como
se hace comúnmente en cualquier lenguaje no gráfico.
Para el nodo de fórmula, la variable A se toma como input variable (Variable

de entrada) y B como output variable (Variable de salida). Para colocar estas
variables, se da clic derecho sobre el borde del nodo y se selecciona la
variable que se desea agregar.
Entonces, en el programa se pide que el usuario ingrese el resultado de una

suma sencilla (5 + 5), si el usuario teclea 10, el valor en la variable B cambia a
1, de lo contrario se le asigna 0.

www.masterhacks.net
Entonces, al finalizar el proceso del nodo de fórmula, la variable de salida, en

este caso B ya tiene un valor, por lo que podemos utilizarlo en el lenguaje
gráfico nuevamente, en este programa se crea una variable local de B y se
utiliza como lectura, y con un comparador, se evalúa si B es igual a 1, con un
Select se evalúa si dicha condición es verdadera o falsa y envía el resultado al
led.
Imagen #117: Programa del comparador funcionando.
Finalmente, si el usuario ingresa la respuesta correcta, el led se enciende, de

lo contrario se mantiene apagado.

www.masterhacks.net
USO DE WEB PUBLISHING
Si se requiere que el programa que se haya desarrollado en LabVIEW sea

controlado desde otra ubicación, se puede utilizar la herramienta de
publicación web de LabVIEW, que permite crear un archivo HTML con el VI
insertado en el archivo para poder visualizarlo como página web.
Esta herramienta está en el menú principal, en la pestaña Opciones:
Imagen #118: Ubicación de la herramienta de publicación web.

www.masterhacks.net
Para empezar, se crea el VI que desee publicar y se guarda en cualquier parte

del disco duro, luego accedemos a Web Publishing Tool y en VI Name se
selecciona el VI que vamos a utilizar, este debe estar abierto para que
aparezca en la lista.
Se da clic en next y aparece una ventana de configuración del HTML en

donde se colocan los datos del título, cabecera y pie de página del
documento web. Aquí se ponen los datos necesarios, mismos que son
opcionales.
Se da clic en next y se selecciona donde se guardará el HTML y con qué

nombre, LabVIEW proporcionará una URL que nos servirá para acceder al
HTML desde el navegador de Internet, normalmente esa dirección es
Localhost.
Al dar clic en preview in browser o pegar el link que LabVIEW proporcionó en

el navegador de internet, se abrirá el HTML con el VI que se insertó. Para
abrirlo desde otra computadora, es necesario que esa computadora esté en
red con la que tiene ejecutando el VI, de lo contrario no podrá visualizar el
programa en el navegador.
Por otro lado, si se requiere acceder a ese HTML desde una ubicación más
lejana, es necesario adquirir un hosting (almacenamiento en Internet), o en
su caso, un servidor que se conecte a Internet, y un dominio, para poder
acceder al HTML como si fuera una página de Internet.
Se pueden hacer modificaciones al archivo HTML para que tenga un mejor

aspecto pero para ello se necesitan conocimientos en ese lenguaje de
programación.

www.masterhacks.net
EJERCICIO: PROGRAMA PARA ADMINISTRAR VENTA DE PINTURA
Una ferretería necesita un programa para la venta de tres colores diferentes

de pintura, se debe escoger el color de la pintura que se va a vender y el
tamaño de la porción. Proporcionar el precio total de la venta, ingresar el
dinero que el cliente paga y el cambio que se tiene que dar.
Luego, Simular el proceso de llenado de acuerdo a los litros vendidos, con un

medidor numérico deslizable, y que al momento de llenar los litros vendidos,
aparezca un mensaje indicando que se ha surtido la venta.
Datos para utilizar:
 Colores: Blanco, Rojo y Verde

 Precios: $45, $35 y $30 por litro, respectivamente.

Como una de las posibles soluciones para el problema, se tiene el siguiente

panel frontal:
Imagen #119: Panel frontal del programa para pinturas (A).

www.masterhacks.net
Imagen #120: Panel frontal del programa para pinturas (B).
Se utilizó un Tab Control con dos pestañas, una para el pedido y otra para la
entrega.
En la pestaña de pedido, se tiene una caja de opciones con los colores de las
pinturas, un control numérico para indicar los litros que se venderán, un
indicador numérico para indicar el total de la venta y para cobra se tiene un
control numérico para ingresar el dinero que se recibe y un indicador que
muestra el cambio que el vendedor tiene que dar.
Después de hacer eso, al dirigirse a la pestaña de entrega, aparece un

indicador deslizable que simula el surtidor de pintura, al dar clic en el botón
para despachar pintura, la barra del slider va subiendo lentamente hasta
llegar al número de litros vendidos. Cuando termina, aparece un mensaje en
el indicador de texto que advierte que la pintura ha sido surtida.
Abajo aparece un botón de paro para detener la ejecución del programa.

www.masterhacks.net
El diagrama de bloques de este programa es el siguiente:
Imagen #121: Diagrama de bloques del programa para pinturas (A).
Imagen #122: Diagrama de bloques del programa para pinturas (B).
Como se puede apreciar en las imágenes #121 y #122, se utiliza un ciclo while
para mantener al programa ejecutándose hasta que se presione el botón de
paro. Dentro del while, hay estructuras case anidadas, entre ellas un ciclo for
que sirve para llenar el indicador deslizable de una manera lenta, con la
ayuda de un incremento, una variable local de los litros vendidos y un timer
que especifica el tiempo de llenado del slider, que en este caso son 500 mili
segundos.

www.masterhacks.net
Las operaciones para calcular el cambio que se tiene que regresar y el total
de la venta por los litros vendidos son básicas por lo que no se profundizará
mucho en ellas.
Como en todos los programas, existen muchas soluciones, quizás mejores o

quizás peores, eso depende del programador.
SEGURIDAD EN EL DESARROLLO DE UN PROGRAMA
Hoy en día la seguridad informática se ha convertido en un tema con

bastante importancia para las empresas desarrolladoras de software, debido
a las intrusiones y todo tipo de ataques de delincuentes cibernéticos a los
programas. Es por esto, que se deben tomar ciertas medidas para mejorar la
seguridad del programa que se esté desarrollando.
LabVIEW ofrece paquetes que permiten que los VI o proyectos que se estén
desarrollando tengan una mejor seguridad para evitar plagios o robo de
contenido, estos paquetes son algo caros, pero para empezar, se puede
utilizar la herramienta de protección de código que ofrece LabVIEW.
Para esto se debe dar clic derecho sobre el ícono del VI y luego irse a VI
properties (Propiedades del VI).
Imagen #123: Ubicación de las propiedades del VI.

www.masterhacks.net
En la pestaña de categoría se selecciona Protección y aparecen tres opciones,

la primera es para dejar sin protección al VI, la segunda es para proteger el
código del VI, pero esta protección la puede quitar cualquier persona
accediendo a este mismo menú.
La tercera opción es la más eficaz si se pretende asegurar bien el código. Esta

opción permite ponerle contraseña al diagrama de bloques. El VI se abre
normalmente, pero a la hora de querer ver el código del programa pedirá la
contraseña.
LA IMPORTANCIA DEL DISEÑO
Generalmente, los ingenieros que programan en LabVIEW no dan mucha

importancia al diseño, pues muchas veces el programa va a ser utilizado por
otros ingenieros o por el mismo programador cuando el objetivo del
programa es controlar un circuito electrónico, planta industrial, entre otros.
Pero el diseño es algo muy importante, ya que en muchas empresas, la

interfaz la va a manejar algún empleado que no siempre es tan intuitivo para
manejar las cosas, o no tiene los conocimientos necesarios para hacerlo. Es
por eso que en este apartado se muestran algunos ejemplos para mejorar y
optimizar la interfaz de usuario para que el usuario final pueda utilizar el
programa adecuadamente.
Algo importante que se debe tener en cuenta son los colores que se
utilizarán en el programa, saber determinar el color que se usará para los
estados en que se encuentran los elementos de un programa.

www.masterhacks.net
Por ejemplo, Para una planta purificadora de agua, se puede tomar como
ejemplo el proceso de llenado de una botella, si utilizamos leds que indiquen
si se está llenando, si se está derramando el agua, etcétera, lo más
conveniente sería utilizar un color verde para afirmar que el proceso se está
realizando, un color rojo como alarma si el líquido se está regando.
Y de esta manera poder tener una perspectiva más clara de lo que se

pretende.
De igual manera, es bueno tener indicaciones en el programa para que el

usuario pueda saber para qué sirve cada botón o cualquier otro elemento de
la interfaz, pero tampoco es bueno exagerar en la información.
Por ejemplo, un mensaje de error puede ser este: “Error X002 debido a un
paro inesperado del proceso tres antes de haberse terminado, debe parar
todos los procesos y reiniciar el sistema nuevamente para evitar futuros
errores”.
Ese mensaje en lugar de resultar útil para el operador del programa, puede
ser poco claro o confuso, debido al exceso de información. Bastaría con un
mensaje como este: “Error debido al paro inesperado del proceso 3, reinicie
el sistema para continuar”.
De esta manera se está aclarando lo que sucedió y se está dando una posible
solución al problema sin envolver al usuario en tanto texto que al final resulta
inútil.
Entonces, sabiendo colocar los elementos en el orden adecuado, con sus

respectivas instrucciones claras y cortas y utilizando los colores que más se
adapten a la tarea que se esté realizando, la capacitación para la persona que
va a utilizar el programa resultará más simple y será más fácil para el usuario
utilizar el programa sin perder tanto tiempo en estar investigando para que
sirve cada botón, o a qué se refiere un mensaje con lenguaje muy técnico.

www.masterhacks.net
NOTAS DEL AUTOR
Esta edición del curso básico de programación en LabVIEW se terminó de

escribir el 25 de abril del 2014.
Si deseas descargar más manuales, libros y tutoriales referentes a

programación, informática, hacking, mecánica, robótica, electrónica, entre
otros, ingresa a nuestra página web www.masterhacks.net y podrás
descargar el contenido de manera gratuita, o ver nuestras publicaciones en
línea en cada sección del sitio.
Páginas donde podrás ver información y tutoriales interesantes, así como

noticias sobre seguridad informática, tecnología, ciencia, etcétera:
www.masterhacks.net
www.facebook.com/mast3rhacks
www.facebook.com/grupostrimh
www.youtube.com/masterhacksnet
Si deseas contactarnos, ya sea para enviar algún aporte, sugerencia o queja,

puedes hacerlo por correo electrónico a la dirección:
contacto@masterhacks.net
Recuerda que puedes mandarnos programas o información para añadir a las

futuras ediciones de nuestros manuales, libros o tutoriales, naturalmente
respetando los créditos de tu autoría.

Manual Basico de Programacion en LabVIEW

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Manual Basico de Programacion en LabVIEW

Cargado por

Copyright:

Formatos disponibles

2014

Programación básica en LabVIEW – Grupo STRIMH 1

Este libro está pensado para estudiantes y personas que se inician en el

Es importante saber que para poder aprender a programar en LabVIEW se

Los conocimientos en otro lenguaje son importantes, ya que el lenguaje

Para poder crear y ejecutar los programas en LabVIEW es necesario descargar

Grupo STRIMH y Masterhacks ofrecen este libro de manera gratuita, dejando

En caso de tener alguna duda o comentario, favor de hacerlo llegar al correo

Programación básica en LabVIEW – Grupo STRIMH 2

LabVIEW (Laboratory Virtual Instrumentation Engineering Workbench) es un

Es un software creado por la empresa National Instruments en 1976 y

Al desarrollar un programa en LabVIEW, se crea un Instrumento Virtual o VI

Actualmente, el software de programación LabVIEW se puede utilizar en los

Una de las principales características de LabVIEW es que es relativamente

Aunque es necesario aclarar que para desarrollar programas que se apliquen

Programación básica en LabVIEW – Grupo STRIMH 3

LabVIEW es principalmente utilizado por los ingenieros para el manejo de

Esto es lo que hace del Laboratorio Virtual de Instrumentación una excelente

La programación representa un factor muy importante al hablar de proyectos

Programación básica en LabVIEW – Grupo STRIMH 4

Una vez instalado el software LabVIEW (link de descarga del instalador en la

Imagen #1: Pantalla de bienvenida de LabVIEW

Programación básica en LabVIEW – Grupo STRIMH 5

Aparecen dos ventanas, el Front Panel (Panel frontal) y Block Diagram

Imagen #2: Panel frontal del programa en LabVIEW

En la parte superior izquierda, se encuentra el panel de ejecución, con los

Programación básica en LabVIEW – Grupo STRIMH 6

Imagen #3: Menú de ejecución del panel frontal.

El primer botón (Run) sirve para ejecutar el programa, en este caso, si el

Si se requiere que el programa esté en ejecución constante, es necesario

El cuarto botón sirve para pausar la ejecución del programa, en caso de

Programación básica en LabVIEW – Grupo STRIMH 7

Imagen #4: Menú de estilos, alineación y tamaño de elementos.

El menú de la imagen 4 sirve para modificar el tamaño, fuente y color de las

Imagen #5: Barra de búsqueda y propiedades del VI

En la esquina superior derecha se encuentra la barra de búsqueda y el botón

Desde ahí se puede editar el tamaño de la ventana del programa, proteger el

También se puede editar el ícono dando clic derecho> Edit icon.

Programación básica en LabVIEW – Grupo STRIMH 8

Imagen #6: Diagrama de bloques del programa.

Para empezar a colocar elementos en el panel frontal, podemos dar clic

Programación básica en LabVIEW – Grupo STRIMH 9

Imagen #7: Menú de elementos.

En ese menú podemos elegir cualquier control numérico, booleano, de texto,

Programación básica en LabVIEW – Grupo STRIMH 10

LabVIEW cuenta con una herramienta de ayuda bastante práctica, el Context

Imagen #8: Ayuda contextual de LabVIEW.

Esta ventana se mantiene abierta mientras se esté ejecutando LabVIEW o

El contenido de la ventana cambiará cada vez que el usuario ponga el cursor

Programación básica en LabVIEW – Grupo STRIMH 11

EL PRIMER PROGRAMA EN LABVIEW

Como primer programa, se puede crear una sumadora sencilla de dos

Imagen# 9: Panel frontal de la sumadora.

Al crear los elementos en el panel frontal, estos aparecen automáticamente

Imagen #10: Diagrama de bloques de la sumadora.

Programación básica en LabVIEW – Grupo STRIMH 12

Aquí ya empieza el trabajo del programador, realizar las operaciones

En este caso solo usaremos una simple suma:

Imagen #11: Conexión de los elementos del diagrama de bloques.

Para comenzar a conectar los elementos, se sitúa el puntero del ratón en

De acuerdo a la imagen #11, se puede deducir que el número 1 se sumará al

Programación básica en LabVIEW – Grupo STRIMH 13

Hasta aquí ya se puede ejecutar el programa, como no se está utilizando

Imagen #12: Programa en funcionamiento.