TECNOLÓGICO NACIONAL DE MÉXICO

Instituto Tecnológico de Celaya

Ingeniería Mecatrónica

Instrumentación
Manual LabVIEW

Docente: Jimena Yumiko Oshin Rosales Isabel

Integrantes:
Palomino Malagón Manuel Alejandro
Blanco Serrano Evellyn Margarita
Davalos Hernández Marco Antonio
Guzmán Araujo Bryan André

Cuarto Parcial

FECHA DE ENTREGA: viernes 20 de mayo del 2022

Índice.

1. Introducción. ............................................................................................................................ 1
2. Programación. .......................................................................................................................... 2
2.1 Crear un nuevo proyecto ....................................................................................................... 2
2.2 Crear un nuevo programa...................................................................................................... 5
2.3 Diferencia entre proyecto y programa .................................................................................. 7
3. Vinculación con Arduino......................................................................................................... 7
3.1. LabVIEW y Arduino (I) ................................................................................................. 16
3.2. LabVIEW y Arduino (O) ............................................................................................... 22
3.3. LabVIEW y Arduino (I/O)................................................................................................. 25
4. Panel del operador..................................................................................................................... 25
4.1. Panel frontal ....................................................................................................................... 25
4.2. Diagrama de bloques ...................................................................................................... 26
4.3Instrucciones ........................................................................................................................ 27
4.3.1Booleano ........................................................................................................................... 27
4.3.2 Numeric............................................................................................................................ 31
4.3.3 String ................................................................................................................................ 37
4.3.4 Timing .............................................................................................................................. 38
5. Estructuras................................................................................................................................. 40
5.1 While Loop..................................................................................................................... 40
5.2. Case .................................................................................................................................... 42
6. Funciones. ................................................................................................................................. 44
6.1 Shift Register. ................................................................................................................. 44
7.Estetica ....................................................................................................................................... 46
7.1. Decoraciones ...................................................................................................................... 46
7.2 Tool Palete .......................................................................................................................... 48
7.3Alinear Elementos ................................................................................................................ 51
7.4. Cambiar tamaño de los elementos ..................................................................................... 52
8. Sensor de fotorresistencia ......................................................................................................... 55
9. Referencias. ............................................................................................................................... 66
 1. Introducción.
Los procesos industriales, en especial los dirigidos a la automatización, necesitan de la
instrumentación industrial. Se trata de un conjunto de factores que ayudan a asegurar y mejorar los
procesos industriales y cómo manejan sus recursos. La instrumentación industrial considera
variables, y mide, convierte y registra las mismas para asegurar procesos. Podemos definir de una
manera más formal a la instrumentación industrial, como aquella disciplina que estudia las técnicas
de diseñar, construir y utilizar correctamente los sistemas de medida mediante un conjunto de
instrumentos que hacen posible la medición de una variable particular, para censar y transmitir lo
que sucede en el objeto evaluado. Dentro de esta definición se encuentran los sistemas de
medición, los cuales son aquel conjunto de elementos que forman un instrumento, capaz de
convertir una variable física en una señal o indicación interpretada por el hombre con mayor
facilidad. [1]
Una de las ramas de la instrumentación industrial, es la instrumentación industrial digital, la cual,
es una de las formas de medición de variables de origen físico más revolucionarias de toda la
historia de la humanidad. Podríamos decir que, en general, desde la aparición de lo digital la
importancia de este tipo de dispositivos ha marcado en gran medida el devenir de toda nuestra
existencia. Con instrumentación digital nos referimos a todos los instrumentos que sirven para
medir diferentes señales y variables de origen físico que, de un impulso con dicho origen pueden
transformarse en uno binario. De ahí precisamente es de donde viene el término digital:
normalmente se transforma primero una señal física en una analógica y posteriormente una
analógica en una digital. Es así como podemos llevar a cabo mediciones sobre lo físico con la
precisión, estandarización y garantías superiores que puede ofrecernos lo digital frente a lo
analógico. [3]
En el presente documento se pretende mostrar el desarrollo de una serie de prácticas que involucran
el uso y aplicación de la instrumentación industrial, prácticas sencillas que muestran una pequeña
parte de las bastas aplicaciones que la instrumentación industrial digital posee. Para el desarrollo
de dichas prácticas se hace uso del software LabVIEW, un entorno de programación gráfica de
uso ingenieril, para desarrollo de sistemas, pruebas automatizadas de investigación, validación y
producción. [2] El presente documento pretende servir como un manual para el uso del software
mencionado, mostrando desde pasos básicos, el uso de algunas herramientas en la interfaz del
mismo y una serie de prácticas sencillas que involucren su uso exclusivamente digital como
también, en complemento con el uso de comunicación serial con Arduino.

1
 2. Programación.
2.1 Crear un nuevo proyecto
La creación es una de las cosas más fundamentales y básicas que es necesario conocer al momento
de ingresar por primera vez al software. Los proyectos son una herramienta que nos permite
generar una especie de “carpeta de trabajo”, ya que dentro de un proyecto tenemos la posibilidad
de crear uno o varios programas, de tal manera que se puedan tener todos los programas destinados
a usarse en conjunto o que estén relacionados entre si en un mismo lugar.
El primer paso para la creación de un nuevo proyecto es abrir el software como tal, una vez hecho
eso nos aparecerá una ventana como la siguiente:

Posteriormente, vemos que se tienen ya opciones directas en la pantalla para poder crear un
proyecto, o en su defecto para abrir un documento que ya este creado, pero, desde la perspectiva
de alguien que esta comenzando recientemente con la utilización del software, los pasos para la
creación de un proyecto nuevo serían los siguientes.
1. Vamos a la esquina superior izquierda y damos click en la opción de “File” y
posteriormente en la opción de New.

2
2. Se generará una nueva ventana con tres carpetas, VI, Project y Other Files, damos click en
el icono + en la carpeta de Proyect. Dentro, se desplegará una opción con el nombre de

3
3. Seleccionamos la opción y damos click en OK. Posteriormente se abrirá una ventana nueva,
ya tendremos creado nuestro proyecto, ahora simplemente es cuestión de guardarlo en la
ubicación que deseemos al igual que nombrarla a nuestro gusto.

4. Para guardarla bastará con dar click en la opción de File-Save y finalmente seleccionar la
ubicación que deseamos y nombrar nuestro archivo de proyecto a nuestro gusto.

4
2.2 Crear un nuevo programa
Para la creación de un nuevo programa se tienen dos opciones, ya sea que se quiera trabajar un
programa individual o que se vayan a realizar una serie de programas. Para la creación de un
programa individual, basta con irnos a la pantalla de inicio de LabVIEW, poner el cursor sobre la
opción de “file” y posteriormente seleccionar la opción de “New VI”

5
Al hacer esto, automáticamente nos generará un Blank VI para poder comenzar a trabajar, tanto
en el diagrama de bloques como en el Front Panel.

La otra opción es crear un nuevo programa dentro de un proyecto, para ello basta con abrir el
archivo de nuestro proyecto, dar click en la opción “File”, y posteriormente en “New VI” y
automáticamente se generará un área de trabajo, además de que el programa recién creado se
quedará guardado dentro el proyecto, por lo que se podrá acceder directamente a el desde el
proyecto mismo.

6
2.3 Diferencia entre proyecto y programa
Tal como se pudo observar, desde ambas opciones se tiene la posibilidad de acceder a la creación
de programas en sí, más, sin embargo, aunque ambas de estas opciones sean similares no son del
todo iguales. La principal diferencia entre un proyecto y un programa, radica en que, el programa
es un área de trabajo individual, es decir, que será un solo archivo de trabajo y ya está. Sin embargo,
en el proyecto se tiene la posibilidad de poder crear internamente uno, dos o muchos mas
programas anidados dentro de él.
A manera de resumen, un programa es un área de trabajo única, y un proyecto es un área de trabajo
que puede contener múltiples programas dentro de el para trabajarlos de una manera más eficiente.

3. Vinculación con Arduino

Además de la realización de programas completamente digitales, se tiene la opción de realizar
complementos a los códigos de LabVIEW para poder trabajarlos de manera física mediante el uso
de Arduino. Para poder realizar esta complementación es necesario primero la vinculación entre
la placa y el software de Arduino en conjunto con el propio LabVIEW, para ello es necesario que
se realicen los siguientes pasos:
o Instalar el ide de Arduino. En esta ocasión la recomendación es trabajar con
la versión 1.6.13, ya que es la que no generará errores o inconvenientes con
LabVIEW. Para realizar este paso, basta con acceder a la página oficial de

7
 Arduino, entrar a la pestaña de “Software”, posteriormente en “Old Software
Releases”, y dentro de esta página buscar entonces la versión correspondiente
y descargarla en el ordenador. Para acceder a esta página de manera directa,
puedes acceder desde el siguiente link [4].

o Acceder al código LIFA_Base. Una vez que se tiene descargado el IDE de

Arduino, procedemos a buscar el archivo de LIFA_Base, para ello es necesario
realizar los pasos siguientes:

Cuando se realizó la instalación de LabVIEW se instalan en total los tres

softwares, “VPM Browser”, “N1 Labview” y “V1 Package Manager”, este
último es el que se va a requerir, por lo cual es necesario buscar dicho programa
y acceder a él. Una vez abierto, accedemos al buscador e insertamos el nombre
de “Arduino” para que asi nos muestre los complementos correspondientes.

8
Una vez hecho ese paso será necesario buscar en las opciones que aparecen aquella
con el nombre “LabVIEW Interface for Arduino” y dar doble click sobre ella para
abrirla. (En caso de que al escribir “Arduino” en el buscador y no se nos muestre la
opción que requerimos, bastará con cambiar el filtro a “ALL”) Al abrir la opción
mencionada se nos abrirá una ventana nueva, dentro deberás seleccionar la opción
de “Install”. (En este caso, como ya se tiene instalada nos aparece la opción de
Uninstall).

Para verificar la correcta instalación de este complemento bastará con ir a

LabVIEW y crear un Blank VI, dentro del panel frontal dar click derecho y en la
parte inferior de la ventana habrá que verificar que aparezca la opción de
“Arduino”, tal como se muestra en la imagen siguiente:

9
o Cargar el archivo de LIFA_Base al Arduino. Una vez instalada la librería
mencionada procedemos a cargar ahora si el archivo de LIFA_Base, para ello
deberemos de seguir la siguiente ruta en nuestro explorador de archivos:

• Acceder al disco local (Windows (c:))

• Archivos de programa (x86)
• National Instruments
• LabVIEW 2020 (O a la versión que se tenga instalada)
• VI libraries
• Vi.lib
• Labview interface for Arduino
• Firmware
• LIFA_Base

10
11
12
13
14
Una vez localizado el archivo mencionado procedemos a abrirlo con el IDE de Arduino
dando doble click sobre el mismo, al abrirse se debe de cargar el programa del LIFA_Base
al Arduino y ya estará lista la comunicación entre la placa de Arduino y el LabVIEW.

15
3.1. LabVIEW y Arduino (I)
Después de haber realizado los pasos necesarios para poder realizar la comunicación con
Arduino, procedemos con la realización del primer código que involucre tanto a Arduino como
a LabVIEW. En este primer ejemplo se realizará un programa de entrada sumamente sencillo
en el cual se le configura una entrada desde el Arduino hasta el software, de tal manera que
dicha entrada sea la señal enviada por un pulsador, y que asi, esta sea interpretada por el
software para encender un LED digital colocado en el panel frontal.
Primeramente, comenzamos con el desarrollo del código en el diagrama de bloques, lo
principal para el uso de Arduino en LabVIEW es hacer uso de una estructura While Loop,
estructura que será explicada a detalle más adelante, además de esto se coloca un botón de paro
que controle esta estructura y asi poder finalizar el programa.

Después de tener lista esta estructura base, procedemos a hacer uso de las herramientas de la
librería instalada previamente “Labview interface for Arduino”, por tanto, desde el diagrama
de bloques entramos al apartado de Arduino, y en el sub menú que se muestra, seleccionamos
tanto la apertura como el cierre de la comunicación serial.

16
El elemento de apertura se coloca a la izquierda de la estructura, y el de cierre se coloca a la derecha
de la misma. En el elemento de apertura se tienen las siguientes entradas (Viendo de arriba hacia
abajo) “VISA Resource” en color rosa, “Baud Rate”, “Board Type (Uno)”, “Bytes per packed
(15)”, “Conection Type (USB/Serial)” y finalmente “Error in” en color amarillo. En nuestro caso
únicamente requerimos de dos de estas entradas al elemento, estas serán el VISA Resource y el
Board Type.
En primera instancia, para la entrada en color rosa de “VISA Resource” tendremos que crearle un
control para poder mediante este, seleccionar el puerto de comunicación serial mediante el cual
estará trabajando el Arduino en conjunto con LabVIEW, para crear el control, basta con posicionar
el cursor sobre dicha entrada, dar click derecho, ir a la opción de “create control”. Por otro lado,
la segunda entrada que se utilizará es la de “Board Type (Uno)”, esta nos servirá para seleccionar
el tipo de tarjeta de Arduino con la que se trabajará, por defecto viene seleccionada la tarjeta
Arduino UNO tal y como se puede observar en el propio nombre. Al hacer los pasos mencionados,
deberíamos tener lo siguiente:

Para mayor practicidad, cambiaremos el nombre de cada uno de los elementos a “Puerto” y
“Modelo” respectivamente. Teniendo esto listo, procedemos a conectar las únicas dos salidas
presentes en este elemento a la estructura While Loop, la señal en color rosa será pues la que
transporte la comunicación principal, y la de color amarillo la que transporte la salida del error.

17
Ahora, ya que nuestro código es de entrada, requerimos de un pin digital de Arduino para poder
conectar el botón, por lo que hay que declarar que se hará uso de uno de estos pines digitales, para
ello nos dirigimos nuevamente a la librería de Arduino y en la sub ventana posicionamos el cursor
sobre la opción de “Low Level”.

Se abrirá una sub ventana más con una serie de distintos elementos más, seleccionamos el que
lleva el nombre de “Set Digital Pin Mode” y la colocamos dentro de la estructura While.

18
Este elemento cuenta con cuatro entradas, dos de ellas son la rosa y la amarilla que simplemente
se deben de conectar a la comunicación de Arduino que sale desde el elemento de apertura, las
otras dos entradas llevan el nombre de “Digital I/O Pin” y “Pin Mode (Input)”, la primera de ellas
nos servirá para seleccionar el número de pin digital que se utilizará en la placa de Arduino, y el
segundo servirá para seleccionar la configuración que tendrá dicho pin, ya sea que se requiera
como una entrada o como una salida.
Por lo tanto, procedemos a crearles un control a ambas entradas tal como se hizo anteriormente
con el elemento anterior.

Una vez hecho ese paso, conectamos la entrada de comunicación de datos y de error
correspondientes, y para mayor practicidad, cambiamos la entrada de “Digital I/O Pin” a
simplemente Pin.

19
Habiendo realizado este ultimo paso de declaración de un pin, requerimos de hacer la lectura de la
señal que entrara a él, para lo cual, es necesario hacer uso de un elemento más de la librería de
Arduino, dentro de la misma ventana de donde se obtuvo el “Set Digital Pin Mode”, vamos a tomar
un elemento con el nombre de “Digital Read Pin”, que tal y como su nombre lo indica, nos hará la
lectura de señal digital proveniente de un pin en específico. Este elemento posee tres entradas, dos
de ellas son las de comunicación (Rosa y Amarilla), y la tercera entrada que lleva el nombre de
“Digital I/O Pin (0)”, sirve para colocar el pin del cual se recibirá la señal, por lo tanto, conectamos
las dos entradas de comunicación provenientes del elemento anterior, y a la tercer entrada
simplemente la puenteamos con el control de Pin anterior, ya que es el pin digital del cual se hizo
la declaración de que sería nuestro pin de entrada.

Ahora bien, este último elemento posee tres salidas, dos de ellas son las de comunicación, pero la
tercera salida, la cual lleva por nombre “Value”, servirá para enviar el valor de la señal que esta
siendo leída, al ser digital, estará enviando un “0” o un “1”, dicha señal será la que utilizaremos
para poder encender el LED digital que estará en nuestro panel frontal.
Para ello, utilizaremos un elemento de comparación, para poder verificar en que momento el botón
se encuentra presionado (1) o en que momento no lo está (0). Este elemento de comparación será
el de “Equal?”, que se puede encontrar dando click derecho en el diagrama de bloques y yendo a
la carpeta de “Comparison”.

20
 Este elemento tiene dos entradas numéricas y una salida Booleana (True/False), en la entrada “X”,
se coloca la variable a comparar, y en la entrada “Y” se coloca la constante con la cual será
comparada dicha variable.

Entonces, procederemos a colocar la tercera salida del “Digital Read Pin” a la entrada X del
comparador, y para la entrada Y crearemos una constante de 1, de tal manera que, cuando ambas
entradas sean 1, a la salida se estará obteniendo un “True”, de lo contrario un “False”, ahora bien,
simplemente restaría colocar en esta salida el LED digital que se encenderá o se apagará de acuerdo
a la señal enviada por el pulsador. Para colocar un LED, nos vamos al panel frontal, daremos click
derecho y en la ventana que se muestra nos dirigiremos a la carpeta “Boolean” y seleccionaremos
ya sea un “Round LED” o un “Square LED” y lo colocaremos en el panel frontal a nuestro gusto.

21
 Ya tendríamos listo el código, simplemente restaría conectas las entradas de comunicación del
elemento de cierre con las salidas del elemento anterior que a si vez se encuentran conectadas al
otro costado de la estructura While Loop. Solo restaría reacomodar los elementos generados en el
panel frontal para darles una mejor presentación, quedando el programa final tal como se muestra
en las siguientes figuras.

3.2.LabVIEW y Arduino (O)

Para el segundo código de comunicación serial, se pretende realizar un código de salida en el
cual, se hará uso de un botón digital para posteriormente encender o apagar un LED físico
conectado en la protoboard. Para comenzar crearemos la estructura base del programa
(Estructura While, apertura y cierre de la comunicación serial, todos con sus respectivos
controles), después de eso, ya que vamos a utilizar un pin de Arduino como salida para poder
encender el LED, declaramos el pin de la misma manera, con excepción de que esta vez, su
configuración será de salida en lugar de ser de entrada, y en el caso del elemento de lectura,
esta vez se utilizará un elemento de escritura, que se encuentra en la misma ventana que el de
lectura y que lleva por nombre “Digital Write Pin”.

22
Para este elemento de escritura tenemos la pequeña excepción de posee cuatro entradas, dos
de comunicación, la tercera “Digital I/O Pin” y la cuarta “Value (0)”. En este caso, en la entrada
de “Digital I/O Pin” se puenteará con el control de selección de pin creado en el elemento
anterior, y para la entrada de “Value”, recordando que será una escritura, será dónde deberemos
colocar el pulsador digital que nos encenderá o apagará el LED físico, por lo cual, desde el
panel frontal vamos a la sección de Boolean y seleccionaremos uno de los botones, en este
caso seleccionamos el “Push Button”.

23
Sin embargo, no podemos conectar directamente el botón a la entrada de Value del elemento
de escritura, ya que estos reciben entradas de 1 y 0 que es con las que trabaja Arduino, en
cambio LabVIEW trabaja con True o False, por lo que también necesitamos un elemento que
nos transforme la señal enviada por el botón a una apta para Arduino, dicho elemento lleva el
nombre de “Bool to (0,1)”, se puede encontrar dando click derecho en el diagrama de bloques,
y en la carpeta de Boolean.

Una vez realizadas las conexiones correspondientes, el código final y el panel frontal nos
quedan de la siguiente manera.

24
3.3. LabVIEW y Arduino (I/O)

4. Panel del operador

4.1. Panel frontal
Una vez creado un nuevo proyecto en LabVIEW, crearemos un nuevo archivo VI, Se habilitarán
dos ventanas en nuestra pantalla.

25
La pantalla que se encuentra en blanco será nuestro panel frontal, donde se llevará a cabo la
elaboración de nuestro código.
4.2. Diagrama de bloques
Un diagrama de bloques contiene un código de manera gráfica, su función es separar el código de
la interfaz de usuario de una manera lógica y sencilla, los objetos del panel frontal aparecen como
terminales.

De esta manera se puede ejecutar operaciones con un orden lógico que el operador necesita.

26
4.3Instrucciones
Nos ubicamos en el panel frontal y damos clic derecho, haciendo eso se abre un recuadro con
diferentes herramientas para utilizar.

4.3.1Booleano
Acercamos el cursor a la carpeta de Boolean y encontramos diferentes herramientas a usar

La herramienta And es una compuerta que sirve para realizar operaciones con valores verdadero y
falso, este posee dos entradas, guiándonos de su tabla de verdad podemos conocer el valor de salida
que podemos obtener.
Usando la herramienta and, colocaremos dos constantes como entradas, y a la salida colocaremos
un led, una vez ejecutemos el programa dependiendo del valor de las entradas, el led se encenderá
cuando sea verdadero como se muestra en la sig. figura.

27
Daremos clic derecho en panel frontal, en la sección de boolean seleccionamos la herramienta de
Or.

Esta herramienta trabaja con dos entradas de verdadero y falso, usando también su tabla de verdad,
dependiendo las entradas obtendremos un valor a la salida; Usaremos un led conectado a la salida
para conocer su valor, este encenderá cuando el valor sea verdadero.

28
Damos clic derecho en el panel, seleccionamos la carpeta boolean y seleccionamos la herramienta
exclusive or, funciona con dos entradas de valores verdadero y falso con una salida, para conocer
su salida usaremos su tabla de verdad para conocer el valor de sus entradas; para esto conectaremos
un led a la salida.

Damos clic derecho en el panel, seleccionamos la carpeta boolean y seleccionamos la herramienta

exclusive not, esta herramienta tiene una entrada y una salida; su función es invertir el valor de la
entrada y mandarla a la salida, colocaremos un led a la salida para verificar su valor.

29
Para la siguiente herramienta, daremos clic derecho en el panel, seleccionamos la carpeta boolean
y seleccionaremos la herramienta Bool to; esta herramienta funciona para convertir una constante
de entrada (verdadero a falso) y la convierte en un numero (1 o 0) dependiendo de la entrada.
En esta ocasión, a la salida daremos clic derecho y colocaremos un indicador.

La siguiente herramienta puede tener dos valores constantes (verdadero y falso), damos clic
derecho en el panel, seleccionamos la herramienta Boolean y seleccionamos true constan o false
constan, suelen usarse para mandar un valor a un operador booleano o herramientas que acepten
dichos valores.

30
Para ello colocaremos un led y lo conectaremos a la constante.

4.3.2 Numeric
Daremos clic derecho en el panel frontal y seleccionaremos la carpeta de numeric, al hacer esto
aparecerán varias herramientas que podremos usar.

31
Numeric Constant
Damos clic derecho, seleccionamos la carpeta de numeric y seleccionamos la herramienta Numeric
constant.
Esta herramienta es una constante la cual podemos introducir a un operador numérico para realizar
operaciones.

De este modo logramos introducir valores numéricos modificando su valor.

Add
Seleccionamos la herramienta add, esta herramienta realiza la operación de suma con dos valores
de entrada y el resultado es mandado a la salida.
Para verificar su funcionamiento, colocaremos dos constantes a la entrada y un indicador numérico
a la salida.

32
De este modo observamos que al colocar un 5 y un 7 a la entrada, a la salida obtenemos 12.
Subtract
Damos clic derecho, seleccionamos la carpeta de numeric y seleccionamos la herramienta Subtract

Esta herramienta realiza la operación de restar con dos valores de entrada y el resultado es mandado
a la salida.
Para verificar su funcionamiento, colocaremos dos constantes a la entrada y un indicador numérico
a la salida.
De este modo observamos que al colocar un 5 y un 7 a la entrada, a la salida obtenemos -2.

33
Multiply
Damos clic derecho, seleccionamos la carpeta de numeric y seleccionamos la herramienta
Multiply.
Esta herramienta realiza la operación de multiplicar con dos valores de entrada y el resultado es
mandado a la salida.
Para verificar su funcionamiento, colocaremos dos constantes a la entrada y un indicador numérico
a la salida.

De este modo observamos que al colocar un 5 y un 7 a la entrada, a la salida obtenemos 35.

Divide
Damos clic derecho, seleccionamos la carpeta de numeric y seleccionamos la herramienta Divide.
Esta herramienta realiza la operación de dividir con dos valores de entrada y el resultado es
mandado a la salida.
Para verificar su funcionamiento, colocaremos dos constantes a la entrada y un indicador numérico
a la salida.

34
De este modo observamos que al colocar un 21 y un 7 a la entrada, a la salida obtenemos 3.
Increment y Decrement
Damos clic derecho, seleccionamos la carpeta de numeric y seleccionamos la herramienta
Increment y Decrement.
Estas dos herramientas tienen una función muy parecida, la herramienta Increment suma una
unidad a un valor de entrada, mientras que el decrement resta una unidad al valor de entrada.

35
De este modo observamos que en increment como tiene una entrada de 5, agrega una unidad
mostrando un 6 de salida.
En el segundo caso, al agregar un 5 como entrada a decrement, resta una unidad y muestra un 4 a
la salida.
Square
Damos clic derecho, seleccionamos la carpeta de numeric y seleccionamos la herramienta Square.
Esta herramienta realiza la operación de elevar al cuadrado un valor de entrada y el resultado es
mandado a la salida.

36
De este modo observamos que en square como tiene una entrada de 5, eleva al cuadrado la entrada
y arroja un 25 de salida.
4.3.3 String
Damos clic derecho en el panel frontal, seleccionamos la carpeta de String y se nos muestra todas
las herramientas que tenemos disponibles.

37
String Constant
Seleccionamos la carpeta de String y damos clic en la herramienta String Constant.

Esta herramienta como su nombre indica es una constante de letras, estas son usadas para mostrar
un mensaje en alguna operación que estemos realizando.
Para ello en la constante String colocaremos el mensaje que deseamos mostrar, de lado derecho
daremos clic derecho y colocaremos un indicador, con esto lograremos mostrar el mensaje que
colocamos en la variable String.

4.3.4 Timing
Damos clic derecho en el panel frontal, seleccionamos la carpeta de Timing y se nos muestra todas
las herramientas que tenemos disponibles.

38
Wait
Seleccionamos la carpeta de Timing y damos clic en la herramienta Wait.
Esta herramienta es un reloj que se encuentra en microsegundos y es utilizado cuando es necesario
dar un tiempo especifico para que se ejecute una acción en un diagrama de bloques.
Para demostrar su funcionamiento usaremos 4 leds, les asignaremos constantes y colocaremos una
constante de 2000 ms a él timing, de este modo al ejecutar el programa, los leds mostraran el estado
en que se les indico con las constantes.
Una vez transcurrido el tiempo, los leds se apagarán, y volverán a mostrar el estado inicial.

39
5. Estructuras.
En LABVIEW las estructuras son elementos de control del programa. Una estructura controla el
flujo de datos en un VI, entre las cuales se encuentran: bucles While, For, Estructura Case, Bloque
Secuencia, entre muchas otras. Las estructuras son representaciones graficas de los casos que se
presentan en lenguajes de programación de texto. Se utiliza una estructura en el diagrama a bloques
para repetir segmentos de código o para ejecutar código bajo alguna condición o en un orden
especifico.

5.1 While Loop.

Un bucle WHILE ejecuta un subdiagrama repetidamente hasta que una condición se cumpla.
Cuando se ejecuta el VI, se ejecuta el código dentro del bucle WHILE y luego se evalúa la
condición de la terminal.
Dando clic derecho en el diagrama de bloques podemos observar las carpetas disponibles que
a su vez engloban varias herramientas de código de bloques para utilizar, entre ellas, la carpeta
structures. En dicha carpeta encontramos el elemento While Loop, que es el mas utilizado
debido a que nos permite ciclar los programas hasta que una condición ya no se cumpla.

Al seleccionar el elemento While Loop y sosteniendo clic izquierdo, puedes ajustar el tamaño del
bucle que englobara el algoritmo que deseas se cicle.

40
Para controlar el bucle, damos clic derecho en el loop condition rojo de la parte inferior derecha
del bucle y seleccionamos la opción crear control. Se creará un botón de stop que podremos
visualizar en el panel frontal de labview. Dicho botón, detiene el bucle While cuando se
encuentra en ejecución el programa.

41
 5.2. Case
Una estructura de Casos tiene dos o más subdiagramas o casos. Solamente un subdiagrama
es visible a la vez y la estructura ejecuta solamente un caso a la vez. Un valor de entrada determina
cual subdiagrama se ejecuta.
Con clic derecho en el panel de diagramas de bloques del LabVIEW, seleccionando la carpeta de
estructuras, encontramos la estructura de casos como se muestra en la imagen de abajo.

42
La etiqueta del selector de caso en la parte superior de la estructura de Caso contiene el nombre
del valor del selector que corresponde al caso en el centro y a las flechas de incremento y reducción
a cada lado.

Haga clic en las flechas de incremento y reducción para desplazarse en los casos disponibles.
También puede hacer clic en la flecha hacia abajo a lado del nombre del caso y seleccionar un caso
en el menú desplegable.

Cablee un valor de entrada o selector a la terminal del selector para determinar qué caso se ejecuta.

43
Debe cablear un entero, valor Booleano, secuencia o valor de tipo enumerado a la terminal del
selector. Puede colocar la terminal del selector en cualquier parte del borde izquierdo de la
estructura de Casos. Si el tipo de datos de la terminal del selector es Booleano, la estructura tiene
un caso True o un caso False. Si la terminal del selector es un entero, secuencia o valor de tipo
enumerado, la estructura tiene cualquier número de casos.

6. Funciones.
Las funciones son elementos de operación particularmente fundamentales en LabVIEW.
Las funciones no tienen ventanas en el panel frontal o ventanas de diagrama de bloques, pero
tienen terminales de entrada y salida para pasar datos dentro y fuera de manera similar a los
controles e indicadores.
6.1 Shift Register.
El shift register es utilizado en LabVIEW para almacenar datos durante el ciclo (para ciclos while
y for). Esta función permite acceder a los datos y devolver el valor de iteración anterior. Actúa
como variable local dentro de un bucle en lenguaje basado en texto. Es posible utilizar shift register
dentro de un bucle para:
1. Almacenar/actualizar datos
2. Realizar cálculos a partir de los datos del registro de desplazamiento
3. Realizar acciones en función de los datos del registro de turnos.
Dando clic derecho sobre tu ciclo (while o for) y seleccionando la opción Add Shift Register.

44
En seguida se harán presentes dos flechas al costado del recuadro del ciclo, tal como se muestra
en la imagen siguiente.

Podemos pasar valores de iteraciones anteriores a través del ciclo a la siguiente iteración.
LabVIEW transfiere los datos conectados en la parte derecha del registro a la próxima iteración.
Después que el ciclo se ejecuta, la terminal en la parte derecha del ciclo regresa al último valor
almacenado en el registro de desplazamiento.

45
7.Estetica
7.1. Decoraciones
Abrimos un nuevo archivo (New VI), nos ubicamos en el panel físico, damos clic derecho y nos
ubicamos en la carpeta de decoraciones, una vez hecho esto se abrirá una nueva carpeta con
diferentes herramientas que el software posee.

46
En este apartado se encuentran diferentes figuras y líneas que puedes utilizar para crear tu panel
físico.
Vertical Smooth Box
Seleccionamos la carpeta de Decorations y seleccionamos la herramienta Vertical Smooth Box,
posteriormente en el panel físico, tendremos la opción de colocar la figura, permitiéndonos colocar
la figura con el tamaño que deseemos.

De este modo podemos colocar y ordenar las herramientas que deseemos dentro de la figura, solo
es necesario colocar la herramienta en el lugar de la figura, otro método es usar ctrl + j para que se
coloque encima.

47
7.2 Tool Palete
Para acceder a esta herramienta, nos colocamos sobre las pestañas en el panel frontal, en la pestaña
de view y seleccionamos la opción tool Palete.
Una vez hecho eso aparecerá un recuadro con nuevas herramientas para personalizar.

48
Si damos clic en el recuadro con la A, se nos permite colocar etiquetas que podemos colocar para
indicar algo si así lo deseamos.

Si damos clic en el pincel, podemos escoger el color que deseemos y podremos dar ese color a la
figura que tenemos o deseamos cambiar el color.

49
Si damos clic en el recuadro con la mano cerrada, podremos desplazarnos para a través del panel.

50
7.3Alinear Elementos
Para acceder a esta herramienta nos posicionamos debajo de la pestaña de window y damos clic
en el recuadro que posee figuras de colores.

Aquí podemos ordenar elementos dependiendo de la referencia que necesitamos.

Para esto seleccionamos los objetos que vamos a alinear y seleccionamos la opción que deseamos.
Como ejemplo, colocaremos 3 leds en diferentes posiciones.

Después seleccionamos los leds y vamos a la herramienta, seleccionaremos la opción para top
Edges para alinearlos con el elemento que se encuentre mas alta, damos clic y se alinearan los leds,
en este caso con Boolean 2.

51
7.4. Cambiar tamaño de los elementos
Para esta opción, nos colocaremos debajo de las pestañas principales y daremos clic en la opción
donde se encuentra una barra con dos flechas.

Se despliega una carpeta donde posee ciertas herramientas para cambiar el tamaño de las figuras
o componentes.
Para dar un ejemplo de esto usaremos 3 leds y cambiaremos el tamaño de uno de estos.

52
Seleccionamos los leds y vamos a la herramienta para modificar su tamaño, daremos clic en la
opción máximum Width ang Height para que el tamaño de los leds se ajusten al de mayor tamaño.

53
De este modo podemos ajustar el tamaño de varios objetos usando como referencia una figura.

54
8. Sensor de fotorresistencia

¿Cómo funciona una fotorresistencia?

Una fotorresistencia o LDR (por sus siglas en inglés “light-dependent resistor”) es un componente
electrónico cuya resistencia varía en función de la luz.
Se trata de un sensor que actúa como una resistencia variable en función de la luz que capta. A
mayor intensidad de luz, menor resistencia.
Para ello utilizaremos Arduino y LabVIEW como se vio en paginas anteriores.
Lo primero será crear un archivo VI.
Posteriormente colocamos un ciclo while y agregamos un flat secuencie donde se llevará acabo el
código que crearemos.
En este caso usaremos el código creado para el proyecto asignado a nuestro equipo.

En este caso, nuestro programa se divide en varios pasos, en el paso numero 2, usamos una
fotorresistencia.
En el primer flat secuencie se usan variables locales para indicar cada indicador del panel.

55
En la parte 2 del flat secuencie, usaremos la herramienta para leer una señal analógica, y en ella
indicaremos el pin que fue conectado a la fotorresistencia, también a la salida de la señal
colocaremos un indicador para conocer el voltaje que entrega la fotorresistencia.

Debido a que la fotorresistencia manda un cierto voltaje dependiendo de la luz del ambiente y la
que refleja un objeto, podemos hacer una comparación con un valor que deseamos que sea
correcto, para ello la salida de la señal la conectamos a un comparador, en la otra entrada
colocamos el valor el cual queremos comparar.

56
Posteriormente colocamos la señal de salida a una estructura cases para indicar al programa que
opciones tiene dependiendo de si la comparación es verdad o falsa.
En nuestro caso, teníamos que diferenciar entre dos colores, el azul nos daba un aproximado de
0.18, y el rojo nos daba valores superiores a 0.34.
En el caso de ser verdadera, significa que el colore de la pieza era roja, por lo tanto, usábamos una
variable local y con un string le dábamos un valor de defectuosa.
Después de eso, realizábamos una comparación entre el valor de la pieza, y si era igual a
defectuosa, se regresaba al primer paso y regresa al paso 1, y se cicla hasta que el valor sea menor
a 0.34
En caso de que no se cumpla y sea menor a 0.34, la variable local adquiere el valor de correcta y
se pasara al caso 3, continuando el proceso.

Además, se colocará un buffer para que emita un sonido en este caso para dar a entender al
operador que la pieza es correcta.

57
Se indica el pin al que ira conectado, en este caso el número 12, la frecuencia que emitirá y la
duración del sonido.
De ahí pasa al siguiente cuadro del flat secuencie, donde se apaga el indicador del paso 2, con
ayuda de un wait pasaban 2 segundos y sale de la secuencia.
Para la conexión en físico de la fotorresistencia usamos un soporte donde no recibiera mucha luz
y variara los valores.

Se coloco su resistencia para evitar que se quemara y el voltaje que enviaba fue conectado al pin
del Arduino que hacia la lectura.
La pieza pasa por debajo con ayuda de la banda y el sensor toma la medida.

58
9. Sensor de presencia

¿Qué es un sensor de presencia?

el sensor de presencia es un tipo de sensor que activa o desactiva automáticamente el mecanismo
eléctrico al que está conectado, cuando detecta o no, la presencia de un objeto dentro de un radio
de acción determinado.
Esta detección puede hacerse con o sin contacto con el objeto. En el primer caso, se trata siempre
de un interruptor, abierto o cerrado, dependiendo de la aplicación que se quiera hacer, y segundo
caso se utilizan diferentes principios físicos para detectar la presencia, dando lugar a los diferentes
tipos de sensores.
Para ello utilizaremos Arduino y LabVIEW como se vio en páginas anteriores.
Lo primero será crear un archivo VI.
Posteriormente colocamos un ciclo while y agregamos un flat secuencie donde se llevará acabo el
código que crearemos.
En este caso usaremos el código creado para el proyecto asignado a nuestro equipo.
Para detectar el tamaño de las cajas, creamos dos pasos, uno para las piezas chicas y otro para las
piezas grandes.

59
En este caso usamos dos sensores de presencia, uno colocado 1 cm arriba de la banda y el otro
sensor fue colocado mas alto, esto para identificar el tamaño de las piezas.
En el paso 4 (Piezas chicas), el proceso se hace con un flat secuencie, en el primer recuadro de la
secuencia las variables locales serán declaradas apagadas y la variable local del led que indica el
paso 3 se encenderá.
Con un wait permitiremos que este proceso dure 2 segundos.

Pasamos al siguiente cuadro de la secuencia utilizaremos las entradas de lectura una señal de
Arduino, uno para cada sensor, para el sensor de la parte de abajo le daremos el pin 7 de la placa
Arduino además crearemos un indicador para saber cuándo el sensor detecte algo.
Para el otro sensor, también le daremos un pin de entrada, en este caso el número 11 y también
crearemos un indicador.
Colocaremos un wait con valor de 1 segundo para hacer la lectura.

60
Y tenemos un led con valor de true para mostrar que el paso 4 se está llevando a cabo.
Pasamos al siguiente cuadro de la secuencia.
En este crearemos condiciones usando los valores que arrojan los sensores de presencia, como es
una pieza chica el sensor de abajo debe mandar la señal y el de arriba debe de estar apagado; si
ambas condiciones se cumplen pasamos a un case, de no ser así se pasara al paso 5 (piezas
grandes).
Dentro de la estructura case del paso 4, en la variable local de tamaño le asignaremos el valor de
pequeña, de ahí, usando los shift register de piezas pequeñas completadas se le sumara 1, y al shift
register de piezas pequeñas faltantes le restaremos 1.
Le dejaremos un wait para que haga el proceso por cierto tiempo.
Después de eso sale de la secuencia y pasa al paso 6.

61
Dentro de la estructura de paso 5 (piezas grandes) en el flat secuencie declaramos las variables
locales apagas, excepto por la que indica que el paso 5 se está llevando a cabo.

62
De ese paso pasamos a el siguiente cuadro.
En este cuadro, igual que el paso 4, usamos las entradas de lectura de Arduino con el mimo orden
y encendemos el led que indica que el paso 5 esta activo.

63
En este cuadro, usaremos las señales que mandan los sensores y con ello crearemos las condiciones
necesarias para indicar que es una pieza grande.
Si los dos sensores mandan una señal falsa, pasaremos al case, donde a la variable local de tamaño
le daremos el valor de grande.
De este modo al shift register de piezas grandes completadas aumentaremos su valor en 1, y al
shift register de piezas grandes restantes le restaremos 1.
Una vez hecho eso, en la parte de falso del case, no colocaremos nada pues no es necesario.
Una vez sale de la secuencia, este pasa al siguiente paso, concluyendo el paso 5.

64
Como se observa en la imagen anterior, los sensores son colocados dentro de una caja que donde
tengan el menor ruido posible, una vez la pieza se detiene ahí, los sensores mandan la señal a los
pines del Arduino que fueron indicados en LabVIEW.

65
9. Referencias.
[1] GENERA CREATIVE GROUP. (2019, June 7). ¿Qué es la instrumentación industrial? AUTYCOM. Retrieved May 8,
2022, from https://www.autycom.com/que-es-la-instrumentacion-industrial/

[2] ¿Qué es LabVIEW? (n.d.). NI. Retrieved May 8, 2022, from https://www.ni.com/es-mx/shop/labview.html#

[3] Rubio, A. (2019, May 14). ¿Qué es la instrumentación digital y para qué sirve? Paneles digitales y analizadores de red.
Retrieved May 8, 2022, from https://www.instrumentaciondigital.es/que-es-la-instrumentacion-digital-y-para-que-sirve/

[4] https://www.arduino.cc/en/software/OldSoftwareReleases

66