UNIVERSIDAD DE SONORA

Divisin de Ingeniera
Departamento de Ingeniera Industrial

Ingeniera Mecatrnica
Instrumentacin Virtual I
Prctica 1: Contadores con LabVIEW
Martn Francisco Noriega Moreno

Hermosillo, Sonora a 1 de septiembre de 2014

Tabla de contenido

Introduccin........................................................................................................3
Marco terico......................................................................................................4
Desarrollo............................................................................................................8
Conclusiones....................................................................................................18
Fuentes de consulta.........................................................................................18

Introduccin
LabVIEW es un programa muy completo que ofrece un sin fin de posibilidades
enfocadas a la generacin de sistemas y tiene como caracterstica principal
que la programacin es grfica, permitiendo un trato ms fcil y ameno con el
programa.
Mediante esta prctica se cumplirn dos objetivos principales, el primero de
ellos es tener un primer contacto con el programa y conocer la forma en la que
opera y sus componentes. Entre otros aspectos, se busca conocer las
caractersticas y objetos que tiene presente el Diagrama de Bloques y el Panel
Frontal.
El segundo objetivo es la creacin de distintos tipos de operadores,
comenzando con unos sencillos que van incrementando sin ninguna condicin
que finalice ese conteo, para terminar con un contador que simule a un reloj,
para ello se contar con 4 contadores que representen los segundos, minutos,
horas y das. Mediante estos contadores, se tendr un mejor dominio en
componentes de LabVIEW, como lo son estructuras, ya que se utilizarn
estructuras WHILE, diversos comparadores e indicadores que plasmarn el
resultado final en el Panel Frontal.

Marco terico
Introduccin a LabVIEW
LabVIEW es una aplicacin que se basa en una programacin grfica que
ayuda a escalar desde diseos hasta pruebas y desde sistemas pequeos
hasta grandes sistemas.
Los programas desarrollados en LabVIEW se llaman Instrumentos Virtuales
(VIs), debido a que la apariencia de estos simulan a un instrumento real. Los
Vis tienen una parte que interacta con el usuario y otra parte de cdigo fuente.
La interfaz grfica del VI con el usuario se denomina Panel Frontal. En ella se
recogen las entradas procedentes del usuario y se representan las salidas
proporcionadas por el programa. El panel frontal se forma por botones,
pulsadores, potencimetros, grficos, etctera. stos pueden servir como
controles o grficos. Los controles sirven para introducir parmetros al VI,
mientras que los indicadores se emplean para mostrar los resultados
producidos.
En la ilustracin 1, se puede ver un ejemplo del panel frontal de una VI, los
controles estn definidos por la letra (a), mientras que los indicadores se
muestran con la letra (b).

Ilustracin 1

El Diagrama de Bloques representa el cdigo fuente del VI y en l se realiza la

implementacin de programa VI para procesar las entradas y salidas que se
crean en el panel frontal. Se incluyen funciones y estructuras que se
encuentran en las libreras incorporadas por LabVIEW. Los controles e
indicadores que fueron introducidos al Panel Frontal como terminales. El
diagrama de bloques est formado por diferentes objetos conectados entre s
por medio de cables, que unen a los elementos de entrada y salida.

LabVIEW tiene una innumerable biblioteca de funciones, que incluyen

operaciones aritmticas, comparaciones, conversiones, funciones de anlisis,
entre otros. Un ejemplo claro son las estructuras, que simulan a los bucles en
lenguajes convencionales como el bucle for, while, case, etctera.
En la Ilustracin 2 se puede observar un ejemplo de un diagrama de bloques,
dnde una funcin est descrita con la letra (a), las terminales (controles e
indicadores) con la letra (b) y una estructura con la letra (c).

Ilustracin 2

Los colores de los cables dependern del tipo de dato que procesan, si las
lneas son naranjas se refieren a datos numricos, si son verdes, son datos
booleanos y si las lneas son rosas, se procesan cadenas de caracteres.
Dentro de las dos ventanas principales de LabVIEW podremos encontrar dos
tipos de paletas que contienen los elementos a utilizar en los VI. La paleta de
Controles (Controls Palette) se encuentra en el Panel Frontal y desde ella
podremos introducir los controladores e indicadores a la interfaz. La paleta de
Funciones (Functions Palette) contiene los objetos que se deben de emplear en
el Diagrama de Bloquees ya sean funciones aritmticas, entrada/salida de
datos, temporizadores, adquisicin de seales, entre otros.
Elementos utilizados en esta prctica
While Loop

Numeric
constant

Wait (ms)

Select

Local
Variable

Numeric
Control

Increment

Equal

And

Push button

Ring

Multiply

While Loop:
El bucle while es equivalente al cdigo siguiente en un lenguaje convencional:
Do
//Se ejecuta lo que hay en el interior del bloque
While terminal condicional is true.
5

El programa comprueba el valor de lo que se halle conectado al terminal

condicional una vez que finaliza el bucle, por lo que se ejecuta al menos una
vez. En algunos casos, la terminal condicional puede representarse por un
botn de STOP. Si la condicin se cumple, el bucle finaliza, si no se vuelve a
repetir hasta que se cumpla la condicin.
El nmero de iteraciones completadas se representa con el cono i ubicado en
la parte inferior izquierda y puede ser de utilidad en algunos casos.

Ilustracin 3

Wait (ms) function:

Provoca que se espere un especfico nmero de milisegundos. Para ello debe
de tener conectado un valor en la entrada, que representa el valor a esperar.
Es til para diversas estructuras, ya que se debe de esperar el tiempo
mencionado para iniciar la iteracin correspondiente.
Select:
Tiene 3 valores de entrada, uno de ellos es una condicin, y dos entradas que
sern las salidas (una para cuando la condicin es verdadera y otra para
cuando es falsa). Si la condicin se cumple, se regresar como salida la
entrada T (True), y si la condicin es falsa, la salida es la entrada F (False).
Variable local:
Una variable local es de utilidad para leer o escribir en uno de los controles o
indicadores del panel frontal en el diagrama de bloques. Es de utilidad ya que
cita alguna de las entradas o salidas que tiene el VI y aadir valores finales de
una estructura, o leerlos para iniciar la estructura.
Numeric Control:
Es un indicador que se introduce desde el panel frontal, y mostrar valores
numricos. Dichos valores pueden ser una salida de algn procesamiento de
datos en el Diagrama de Bloques, aunque tambin un control numrico sirve
como entrada para algn proceso.
La modificacin del Control numrico puede ser dada por el usuario, ya que
desde el Panel Frontal se puede introducir un nuevo valor, o por medio de las
dos flechas que incluye el control, ir al valor inmediatamente superior o inferior
que se despliega en esos momentos.
Increment:
Este conector le agrega una unidad a la entrada, provocando que si la entrada
es x, la salida ser x+1.
Equal Function:

Tiene dos entradas y una salida, esta funcin se encarga de compara las dos
entradas y si son iguales, el resultado ser un valor TRUE booleano, mientras
que si no son iguales se dar como salida un FALSE booleano. Los valores de
entrada deben de ser del mismo tipo, mientras que la salida siempre ser
booleana.
And function:
Compara dos entradas booleanas o numricas y si ambas entradas son
verdaderas, la funcin regresa una salida TRUE, de lo contrario la salida ser
FALSE.
Push button:
Un Push Button es un elemento que se puede ingresar en el diagrama de
bloques y presenta dos estados, pudiendo estar presionado o liberado, al estar
presionado, est encendido (1) y al estar liberado est apagado (0). Pueden
ser presionados por el usuario o por alguna condicin propia de la VI.
Ring Constant:
Este elemento permitir crear una lista de valores que estarn relacionadas con
un valor numrico y una etiqueta de caracteres. Si el elemento se convierte en
un indicador, LabVIEW va a mostrar en el panel frontal el valor de la etiqueta en
lugar del valor numrico. En las propiedades de este indicador se pueden
aadir, remover o modificar las etiquetas asociadas a los valores numricos.
Multiply Function:
A partir de dos entradas formadas por nmeros o arreglos escalares, se realiza
la multiplicacin de ambas entradas y regresa dicho producto.

Desarrollo
El primer paso para comprender el funcionamiento del ciclo While y
componentes bsicos de LabVIEW, fue la realizacin de 3 contadores:
Contador que aumenta su valor una unidad.
El primer contador realizado va incrementando su valor en 1 por cada iteracin
realizada.
Primeramente desde el panel frontal agregamos un control numrico. Despus,
ya en el diagrama de bloques, se integr dentro de una estructura While el
control numrico, que fue conectado a un increment, y la salida del incremento
se vuelve a almacenar en la variable local que representa al Contador, por lo
que se despliega en pantalla el incremento correspondiente.
Tambin se agreg un timer que hace que cada iteracin se produzca cada
1000 milisegundos (esto por medio de una variable con valor 1000 que est
conectada a la entrada del timer). Finalmente, se cuenta con un botn que
detiene el proceso While.
En la Tabla 1, se pueden ver los elementos utilizados para este contador, y en
las ilustraciones 4 y 5 se apreciar el programa en el diagrama de bloques y
panel frontal, respectivamente.
Tabla 1. Elementos utilizados en el primer contador

While Loop

Numeric
constant

Wait (ms)

Increment

Ilustracin 4

Ilustracin 5

Local Variable

Numeric
Control

Contador que aumenta su valor 5 unidades.

Para este contador se utiliz de igual manera un ciclo While, al igual que el
contador descrito anteriormente, se utiliz un timer para que la numeracin
cambie cada segundo, sin embargo hay una diferencia en la lgica que se
utiliza para realizar el incremento de 5 unidades.
Se implement un bloque de multiplicador, en el que sus dos entradas, fueron,
en primer caso, una constante numrica con valor 5, y el valor i, que
representa las iteraciones que se van realizando dentro del ciclo While. Como
salida de esta operacin tenemos la variable local que representa el valor del
contador. Es decir, podemos considerar que la relacin de entrada salida es:
5i=Contador , dnde i se va incrementando una unidad en cada
iteracin del ciclo. Adems se incluy un botn para detener las iteraciones.
En la tabla 2 se pueden apreciar los elementos incluidos
Tabla 2. Elementos utilizados en el segundo contador

While Loop

Numeric
constant

Wait (ms)

Multiply

Local Variable

Numeric
Control

Ilustracin 6

Ilustracin 7

Como dato interesante, se puede observar que la variable que se est

incrementando es de diferente tipo para los dos contadores, en el primero, la
variable es el contador en s, mientras que en el segundo es la variable i ,
que est dada por el ciclo While y va incrementando su valor en 1 por cada

iteracin; por lo que en el primer caso, cuando se inicialice el programa, el

contador continuar en el valor que est establecido, mientras que en el
segundo, el contador siempre iniciar en cero, ya que la variable i se
inicializa en 0 cada vez que comienza el programa.
Contador-reloj.
Siguiendo la lgica de los contadores anteriores, en este VI se deben de tener
4 contadores diferentes: el de segundos, minutos, horas y das, con las
siguientes condiciones:

Segundos: Podr tener incrementos cuando el botn de encendido est

presionado y deber de regresar a cero una vez que ha alcanzado el
valor 59.
Minutos: No tendr un incremento hasta que el valor del contador de
segundos sea igual a 59, as mismo, tendr que regresar a cero una vez
que tanto el contador de minutos y segundos llegue a cero.
Horas: El incremento se dar cuando los minutos y segundos tengan
valor igual a 59. Deber de regresar a cero una vez que los minutos y
segundos tengan valor 59 y las horas valor 23.
Das: En este contador, se utilizan valores numricos que representan a
los das, por lo que el incremento numrico se dar en el momento en el
que los minutos y segundos sean igual a 59 y las horas a 23. Se deber
de reiniciar la cuenta en cero cuando el valor de das sea igual a 6, el de
horas 23 y el de minutos y segundos 59.

Nota importante: Puede resultar extrao que los contadores presenten un

incremento cuando el valor de los segundos es 59 (debido a que un minuto
tiene 60 segundos), sin embargo, esto se debe a que en el ciclo en el que el
segundero muestra 59, se activa la condicin verdadera en el selector,
haciendo que en el siguiente ciclo, en lugar de mostrar el 60 cambie a cero y
se incremente en 1 los minutos. (Dicha relacin se puede aplicar al incremento
de horas y das).
Para su funcionamiento, se dividi el trabajo por mdulos, iniciando con el
contador de los segundos e ir incrementndole los contadores hasta llegar al
de das.
Los elementos a usar son los siguientes:
While Loop

Increment

Tabla 3. Elementos utilizados en el contador-reloj

Numeric
Wait (ms)
Select
Local
constant
Variable

Equal

And

Push button

10

Ring

Numeric
Control

Segundos
Primeramente, se debe de agregar en el Panel Frontal 2 elementos, dos push
button y un control numrico. Uno de los push button ser el botn de
encendido, que recibe de nombre (ON) y el otro ser el indicador de que se
debe de reiniciar el contador de segundos (R. Sec); el control numrico ser el
contador para los segundos (Segundos). En la ilustracin 8 se pueden ver los 3
elementos requeridos para esta parte del reloj.

Ilustracin 8

Ahora, en el diagrama de bloques, se crea un ciclo while y dentro de l se hace

el diagrama mostrado en la ilustracin 9.

Ilustracin 9

El diagrama parte a partir del contador segundos, dicho contador tiene dos
ramificaciones, en una hay un incrementor y la otra contina con el valor
original, ambas conexiones se conectan a un selector, teniendo como resultado
verdadero el incremento y como resultado falsa el valor actual del contador
numrico. Lo que determinar al selector si la condicin es falsa o verdadera es
el botn de encendido, siendo verdadero si se encuentra encendido.
El valor que sale del selector sigue dos caminos, primeramente se dirige a un
comparador de igualdad, que comparar si el valor es igual a 59, de ser as se
activa el botn R. Sec. El segundo camino se dirige a un nuevo selector,
teniendo como respuesta falsa que contine el mismo valor de entrada a la
variable local Segundos (valor del contador), mientras que la respuesta
verdadera ser el valor 0. Lo que determinar si se cumple o no la condicin
es el valor de encendido o apagado del push button R. Sec.
Es decir, una vez que el botn se encuentre encendido, comenzar a avanzar,
siendo verdadero el primer selector (incremento +1) y falso el segundo

11

comparador (mientras no llegue al valor 59 el push button R. Sec permanece

apagado) provocando que el valor de segundos sea igual a la salida del primer
selector. Cuando el valor llega a 59, se cumple la condicin de igualdad 59=59,
activando el push button R. Sec, por lo que en la siguiente iteracin en lugar de
aumentar el valor a 60 se regresa a cero.
Adicionalmente, se integra un timer, que har que el cambio numrico de los
contadores se efecte cada segundo.
Minutos
Una vez entendida la lgica de funcionamiento de segundos, resultar fcil
comprender los otros contadores. Como se pudo observar, la base del reloj son
2 selectores y un comparador de igualdad. Sin embargo, es importante tener
listo el mdulo de los segundos, ya que para este contador, se requieren
condiciones de simultaneidad con el segundero. En la ilustracin 10 se pueden
ver los 2 elementos agregados en el Panel Frontal y en la ilustracin 11 se
aprecia el Diagrama de Bloques correspondiente.

Ilustracin 10

Ilustracin 11

12

En el minutero, tambin se cuentan con dos selectores, uno de ellos

determinar el aumento de nmero y el segundo determinar cundo debe de
reiniciar el conteo.
En el primer selector, tenemos dos entradas, si la condicin es verdadera se
incrementar en uno el contador y si la condicin es falsa seguir el valor
actual del contador. Lo que determinar el cambio es cuando el valor del
segundero sea igual a 59. Es decir, al momento de que los segundos muestran
el valor 59, en la siguiente iteracin, los minutos aumentarn en 1, y los
segundos regresarn a su valor 0 (como ya se explic anteriormente).
La salida del selector tiene dos ramificaciones, la primera de ellas es un
comparador de igualdad, que ser activado cuando el valor de los minutos sea
igual a 59, y a la salida de este comparador se tiene una compuerta AND, que
los valores de entrada son el valor de la comparacin y el valor de la
comparacin del mdulo anterior (segundos), es decir la condicin del
segundero 59=59. Cuando ambas condiciones son falsas (es decir, cuando se
tenga en los contadores 59 minutos, 59 segundos), se activar el push button
R. Min.
La otra salida del primer selector se dirige a un segundo selector, que tiene
como condicin el encendido del push button R. Min, haciendo que si la
condicin es verdadera, el valor de minutos se regresa a cero, pero si es falsa
contina con el valor asignado en la primera compuerta.
Esto da a entender que el valor de los minutos aumentar en la iteracin que
contina cuando se muestra 59 en el contador de los segundos, siempre y
cuando no haya un 59 en los minutos, ya que eso provocar que se regresen
a cero los minutos en la prxima iteracin.
Horas
El contador de horas representa una estructura muy similar al de minutos, ya
que tiene 2 selectores, en el primero se incrementa el valor una unidad si el
valor de minutos y segundos es igual a 59. El valor de salida de ese selector se
va a un comparador de igualdad, que es activado si las horas son iguales a 23
y en conjunto con una compuerta AND que proviene del mdulo anterior
(minutos=59 y segundos=59), haciendo que si se cumplen esas tres
condiciones, se active un push button llamado R. Hora.
Hay otra ramificacin de la salida del primer selector que se conecta a otro
selector, siendo esa ramificacin la respuesta si la condicin es falsa, si la
condicin es verdadera el contador de horas regresa a cero. De la condicin
que hablamos es que el botn R. Horas se encuentre encendido (es decir, que
horas=23, minutos=59 y segundos=59).
De esta manera, se aumentar el valor de horas a la iteracin siguiente cuando
los minutos y segundos se encuentren el 59:59, y el valor de horas se reiniciar

13

a cero a la iteracin siguiente cuando los minutos y segundos valgan 59 y las

horas 23 (es decir, en 23:59:59).
En la Ilustracin 12 y 13 se puede ver el diagrama de bloques y panel frontal
hasta este punto del programa.

Ilustracin 12

Ilustracin 13

Das
Como paso final para el contador-reloj, est la integracin de los das, dichos
das se integran dentro de una Ring Constant, que tiene como funcin asociar
ciertos valores numricos con textos.
Para ello, el primer paso es ingresar una Ring Constant al Diagrama de
Bloques, hacer clic derecho sobre ella y seleccionar Change to control, esto
har un contador en el Panel Frontal.

14

Acto seguido, volvemos a hacer clic derecho y seleccionamos Properties, eso

nos abre una ventana nueva, y ah elegimos la pestaa Edit Items. Como se
puede apreciar en la Ilustracin 14, ingresamos la descripcin que deseamos
que tenga cada valor, en este caso, se inici desde el valor 0, como Lunes, 1
para Martes, y as sucesivamente hasta llegar al domingo, con el valor 6.

Ilustracin 14

La parte del diagrama es idntica a los otros 3 contadores descritos

anteriormente, se cuenta con un push button de nombre R. Da, que es
activado por medio de una compuerta AND, cuando el valor del contador de da
sea igual a 6, el de hora igual a 23, minutos igual a 59 y segundos igual a 59.
Se incluyen tambin dos selectores, el primero aumentar en 1 el valor de da
si se cumple con la condicin de que la hora sea igual a 23, minutos iguala 59
y segundos igual a 59. Por otra parte hay otro selector que determinar si el
contador se debe de reiniciar, eso sucede cuando se encuentra encendido el
push button R. Da.
Es decir, el contador da aumentar a la iteracin siguiente cuando los
contadores hora-minuto-da se encuentren en los valores 23:59:59, y regresar
a 0 (es decir Lunes) a la siguiente iteracin cuando los 4 contadores tengan el
valor Domingo (6) 23:59:59.
Por ltimo, se agreg un botn de detencin, al hacer clic derecho en el cono
que se encuentra en la parte inferior derecha de la estructura While y elegir
Create Control. Ese botn fue conectado al botn de detencin de dicha
estructura.

15

En las Ilustraciones 15 y 16 se puede observar el resultado final de la

aplicacin en el Diagrama de Bloques y Panel Frontal.

Ilustracin 15

16

Ilustracin 16

17

Conclusiones
Por medio de esta prctica, se pudo conocer la facilidad con la que se elaboran
IVs en LabVIEW. Podra decirse que es muy similar a programar en algn otro
lenguaje de programacin, ya que partimos desde una estructura While y
describimos un proceso dentro de ella.
Los primeros dos contadores creados presentan una estructura muy fcil, que
se complic en el reloj-contador, debido a que el nmero de premisas y
condiciones necesarias para poder realizarlo son ms especficas.
Es curioso que la lgica interna del programa puede variar de una persona a
otra pero el resultado final es similar, algunos pueden optar por muchas
condiciones, otros por la utilizacin de pushbutton, y otros por la repeticin de
variables locales para las condiciones dadas.
A partir de esta prctica, considero que los pasos primordiales para tener un
buen VI es, primeramente, conocer las entradas y salidas, para introducir los
indicadores y controles en el Panel Frontal, despus viene la tarea difcil que es
idear la lgica para que el VI funcione correctamente. El lado bueno es que
LABView permite realizar simulaciones para verificar los lugares en los que el
programa comienza a fallar.
Por ltimo, puedo concluir que LabVIEW es un excelente programa que nos
permitir simular sistemas a fin de comprender el funcionamiento de una mejor
manera y utilizar las tcnicas aprendidas durante el transcurso de nuestra
carrera (especialmente en las clases de Programacin) para solucionar
problemas por medio de Instrumentos Virtuales.

Fuentes de consulta
Software de Desarrollo de Sistemas NI LabVIEW (s.f). Consultado el 30 de
agosto del 2014 en http://www.ni.com/labview/esa/
Tutorial de LabVIEW (s.f.). Consultado el 30 de agosto del 2014 en
http://www.esi2.us.es/~asun/LCPC06/TutorialLabview.pdf
Ring Constant (2012). Consultado el 30 de agosto del 2014
http://zone.ni.com/reference/en-XX/help/371361J-01/glang/ring_constant/

en

Local Variable (2012). Consultado el 30 de agosto del 2014

http://zone.ni.com/reference/en-XX/help/371361J-01/glang/local_variable/

en

Manual de LabVIEW 2012. National Instruments.

18