Manual de Prácticas Arduino LabVIEW

Manual de Prácticas
Arduino LabVIEW
Laboratorio de Instrumentación Virtual CUCEI

M. en C. Anuar B. Beltrán González

En colaboración con:

Alberto Daniel Ortega Zambrano

Itzel Niasandiu Aranguren Navarro

|
Universidad de Guadalajara CUCEI Laboratorio de Instrumentación virtual
I
 Manual de Prácticas Arduino LabVIEW

Contenido
¿Qué es LabVIEW? .............................................................................................................................. 1
Paletas de controles y funciones..................................................................................................... 2
Barra de herramientas .................................................................................................................... 3
¿Qué es Arduino? ................................................................................................................................ 3
Sistema decimal y binario ................................................................................................................... 5
Altos, Bajos y código ASCII .............................................................................................................. 5
Estructuras de control ......................................................................................................................... 8
Práctica 1: Conversión de un arreglo a código ASCII. ....................................................................... 10
Build Arrays ............................................................................................................................... 10
Byte Array to String ................................................................................................................... 10
Diagrama de Bloques ................................................................................................................ 11
Panel Frontal ............................................................................................................................. 11
Práctica 2: Mandar un carácter por un puerto serial. ....................................................................... 12
void setup(): .............................................................................................................................. 12
void loop(): ................................................................................................................................ 12
[Link](): ............................................................................................................................ 12
[Link](): ....................................................................................................................... 12
[Link](): .............................................................................................................................. 12
[Link](): .......................................................................................................................... 12
Monitor Serial............................................................................................................................ 13
Práctica 3: Escribir y leer en el puerto serie. ..................................................................................... 14
Librería VISA .................................................................................................................................. 14
Serial (VISA) ................................................................................................................................... 15
VISA Configure Serial Port ......................................................................................................... 15
VISA Read y VISA Write ............................................................................................................. 16
VISA Close .................................................................................................................................. 17
Salidas y entadas digitales del Arduino ......................................................................................... 17
pinMode():................................................................................................................................. 17
digitalWrite(): ............................................................................................................................ 17
digitalRead(): ............................................................................................................................. 17
Programa en LabVIEW................................................................................................................... 18
Diagrama de Bloques ................................................................................................................ 18

Universidad de Guadalajara CUCEI II Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Panel Frontal ............................................................................................................................. 18
Programa en Arduino .................................................................................................................... 19
Conexión del Arduino ................................................................................................................ 20
Práctica 4 Leer voltaje con Arduino y mandar los datos por el puerto serie. ................................... 21
analogRead(): ............................................................................................................................ 21
analogReference(EXTERNAL): ................................................................................................... 21
analogWrite(): ........................................................................................................................... 21
Leer y actualizar un valor de manera continua ............................................................................. 22
Estructuras .................................................................................................................................... 22
Flat Sequence ............................................................................................................................ 23
Case Structure ........................................................................................................................... 24
While Loop ................................................................................................................................ 25
For Loop..................................................................................................................................... 26
Wait ........................................................................................................................................... 28
Programa en Arduino ................................................................................................................ 29
Conexión del Arduino ................................................................................................................ 29
Programa en LabVIEW............................................................................................................... 30
Panel Frontal ............................................................................................................................. 30
Práctica 5 Mejorando la sincronización Arduino - LabVIEW ............................................................. 31
Programa en LabVIEW................................................................................................................... 31
View As Icon .............................................................................................................................. 32
Transformar carácter a número ................................................................................................ 32
Combo Box ................................................................................................................................ 33
Cálculos matemáticos con LabVIEW ............................................................................................. 35
Graficando datos con LabVIEW ..................................................................................................... 37
Programas en LabVIEW ............................................................................................................. 39
Panel Frontal ............................................................................................................................. 40
Programa en Arduino ................................................................................................................ 40
Conexión del Arduino ................................................................................................................ 41
Práctica 6 Control de leds ................................................................................................................. 42
Transmisión de datos entre Arduino y LabVIEW........................................................................... 42
Herramientas en LabVIEW ............................................................................................................ 44
Boolean Array To Number......................................................................................................... 44

Universidad de Guadalajara CUCEI III Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Boolean Control......................................................................................................................... 44
bitRead(): ................................................................................................................................... 45
Diagrama de Bloques ................................................................................................................ 46
Panel Frontal ............................................................................................................................. 46
Diagrama de bloques. ............................................................................................................... 47
Panel de Frontal ........................................................................................................................ 47
Código en Arduino..................................................................................................................... 48
Conexión del Arduino ................................................................................................................ 49
Práctica 7 Escribir un mensaje en una pantalla LCD ......................................................................... 50
Programa en LabVIEW................................................................................................................... 50
Update Value while Typing ....................................................................................................... 51
Cadenas en Arduino ...................................................................................................................... 52
Instrucciones en Arduino para el manejo de cadenas .................................................................. 52
[Link](): ....................................................................................................................... 52
[Link](): ................................................................................................................... 52
[Link](): ...................................................................................................................... 52
[Link](): ....................................................................................................................... 52
Pantallas LCD y Librería LiquidCrystal ........................................................................................... 53
Instrucciones para controlar un LCD ............................................................................................. 53
LiquidCrystal lcd:(RS, Rw, EN, d0, d1, d2, d3, d4, d5, d6, d7): .................................................. 53
[Link](): .......................................................................................................................... 54
[Link]():................................................................................................................................. 54
[Link](): .................................................................................................................................. 54
[Link](): ................................................................................................................................. 54
Programa en Arduino ................................................................................................................ 54
Conexión de Arduino ................................................................................................................. 55
Práctica 8 Control de un Servomotor ................................................................................................ 56
Programa en LabVIEW............................................................................................................... 56
Panel Frontal ............................................................................................................................. 56
Programa en Arduino .................................................................................................................... 57
Servo.h: ..................................................................................................................................... 57
Servo:......................................................................................................................................... 57
[Link](): .......................................................................................................................... 57

Universidad de Guadalajara CUCEI IV Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
[Link]():............................................................................................................................ 57
Conexión del Arduino .................................................................................................................... 58
Práctica 9 Monitoreo de varios voltajes al mismo tiempo ............................................................... 59
Scan From String ....................................................................................................................... 59
Bundle y Unbundle .................................................................................................................... 60
Diagrama de Bloques ................................................................................................................ 61
Panel Frontal ............................................................................................................................. 61
Programa en Arduino ................................................................................................................ 62
Conexión del Arduino ................................................................................................................ 63
Bibliografía ........................................................................................................................................ 65

Universidad de Guadalajara CUCEI V Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

¿Qué es LabVIEW?
LabVIEW (Laboratory Virtual Instrument Engineering Workbench) de National Instruments, es un
sistema de programación gráfico diseñado para el desarrollo de distintas aplicaciones como el
análisis de datos, la adquisición de datos y el control de instrumentos. Estas aplicaciones también
reciben el nombre de: Instrumentos virtuales.

En términos simples, un instrumento virtual es un software que simula el panel frontal de un

instrumento de medida, y apoyándose en elementos de hardware accesibles por una
computadora (tarjetas de adquisición, tarjetas DSP, instrumentos accesibles vía GPIB, VXI, RS-232,
USB Ethernet) realiza una serie de medidas como si se tratase de un instrumento real. De ahí por
qué las aplicaciones que creamos con LabVIEW se guardan con la extensión VI (Virtual
Instrument).

LabVIEW, consta de dos ventanas principales:

1. Panel Frontal: Parte que verá el usuario y como su nombre lo dice, simula el panel frontal
del instrumento real. Suele tener fondo gris.
2. Diagrama de bloques: es la parte en donde se realizará la programación, corresponde a la
circuitería interna del aparato físico. Suele tener fondo blanco.

Figura 1. Panel frontal y diagrama de bloques en LabVIEW

|
Universidad de Guadalajara CUCEI Laboratorio de Instrumentación virtual
1
 Manual de Prácticas Arduino LabVIEW

Paletas de controles y funciones

Aplicando clic derecho sobre el panel frontal, o el diagrama de bloques, podemos accesar a la
paleta de controles o de funciones respectivamente.

Figura 2. Paleta de controles y paleta de funciones

Las cuales nos permiten colocar los objetos y funciones necesarios para realizar nuestra aplicación.

Universidad de Guadalajara CUCEI 2 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Barra de herramientas
En la parte superior de estas ventanas, se sitúa una barra de herramientas. En el diagrama de
bloques esta barra tiene unas opciones más. Trataremos las más importantes.

Figura 3. Barra de herramientas LabVIEW

Las primera cuatro, sirven para controlar la ejecución de un programa en LabVIEW.

Figura [Link] de ejecución.

El primer botón indica si hay errores en el programa (flecha rota), y cuando no los hay (Flecha
completa), ejecuta el programa. El segundo ejecuta de forma continua el programa, como regla
general, este botón no debe usarse, en su lugar se empleará un bucle en el programa. El tercero
aborta la ejecución y el cuarto permite realizar una pausa o reanudar la ejecución.

Es siguiente ícono se llama Highligth Execution.

Figura 3.2. Highligth Execution

Ralentiza la ejecución del programa, permitiendo ver el camino que siguen los datos en el
programa.

Por último, la barra nos permite hacer una búsqueda, y la siguiente abre la ayuda contextual.

Figura 3.3. Barra de búsqueda y ayuda contextual

¿Qué es Arduino?
Arduino en realidad son tres cosas:

1. Una placa con varios componentes electrónicos, en especial un microcontrolador cuya

característica especial es ser programable. Este microcontrolador le da la capacidad de
ejecutar de forma automática una serie de instrucciones previamente definidas por el
usuario. Dado que la placa tiene una serie de pines hembra, en ellas se pueden conectar
una serie de sensores y actuadores, que nos permitirán realizar diferentes proyectos.

Universidad de Guadalajara CUCEI 3 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Figura 4. Arduino y sus pines.

2. Un software libre. El cual instalado en nuestro ordenador, nos permite escribir, verificar y
cargar en el microcontrolador de nuestra placa Arduino el conjunto de instrucciones que
queremos que ejecute.

Figura 5. Software libre de Arduino

3. Un lenguaje de programación libre. O sea un conjunto de instrucciones que nos permiten

decirle al microcontrolador que acciones queremos que lleva a cabo.

Figura 6. Ejemplo de lenguaje Arduino

Universidad de Guadalajara CUCEI 4 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Sistema decimal y binario

El sistema numérico decimal es el que nosotros utilizamos de manera habitual para representar
cantidades, consta de nueve símbolos y es de valor posicional. Esto quiere decir que cada dígito
tiene su propio peso expresado como potencia de su base, en nuestro caso 10.

1 × 102 + 6 × 101 + 5 × 100 = 16510

Como podemos observar el numero 165 tiene 3 dígitos, el 1 corresponde a las centenas, el 6
representa las decenas y el 5 a las unidades. En esencia, el 1 tiene el mayor peso de los 3 dígitos y
se le conoce como el dígito más significativo (MSD), mientras el 5 tiene el menor peso y se le
conoce como el dígito menos significativo (LSD).

Por otra parte, en el sistema binario sólo hay dos símbolos posibles: 0 y 1. Aun así este sistema
puede representar cualquier cantidad decimal, sólo que se requerirá una mayor cantidad de
dígitos binarios, también llamados bites. Este sistema al igual que el decimal, es de valor
posicional, sin embargo a diferencia del anterior, el peso de cada bit está expresado en potencias
de 2. Abajo un ejemplo:

101001012 = 1 × 27 + 0 × 26 + 1 × 25 + 0 × 24 + 0 × 23 + 1 × 22 + 0 × 21 + 1 × 20

= 128 +0 + 32 +0 +0 +4 +0 +1 = 16510

El número anterior posee 8 bites, donde el bite más significativo (MSB) es el 1 que está más a la
izquierda, por su parte, el bite menos significativo (LSB) es el 1 que está más a la derecha. Cabe
resaltar que un conjunto de 8 bites recibe el nombre especial de byte.

Altos, Bajos y código ASCII

En la electrónica digital sólo existen 2 estados posibles, ALTO y BAJO. Estos son representados por
2 niveles de tensión, normalmente 5 y 0 voltios, aunque algunas veces pueden ser 3.3 y 0 voltios.
Como el sistema binario tiene dos dígitos, estos valores también pueden ser expresados como
1(Alto) y 0(Bajo).

Podemos ir incluso más lejos: una combinación de 8 bites (1 byte) no sólo puede representar un
número, si no también, caracteres, símbolos e incluso acciones que una computadora debe llevar
a cabo. En tal caso, ya no estamos trabajando con un sistema numérico, sino más bien con un
código alfanumérico.

Un ejemplo de lo anterior es el código ASCII, el cual se utiliza casi de manera universal, en

nuestros equipos electrónicos para la transferencia e intercambio de información. Este toma en
cuenta el valor binario que crea la combinación específica de Altos y Bajos, y los organiza en una
tabla. Misma que veremos a continuación.

Universidad de Guadalajara CUCEI 5 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Tabla 1. Código ASCII

Vale la pena destacar que los primeros 31 bytes corresponden a instrucciones computacionales
para la transferencia de información. Por otro lado, a partir del byte 32 comienzan los caracteres
imprimibles.

Universidad de Guadalajara CUCEI 6 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Tabla 2. Código ASCII

Es curioso enterarse, que el código ASCII sólo utiliza 7 bites y no los 8 que conforman un byte. Lo
que sucede es que el último bite es utilizado comúnmente para detectar errores y es llamado bit
de paridad. Sin embargo también existe una versión extendida del código ASCII que utiliza 8 bites,
y por lo tanto posee 255 caracteres en comparación con el básico que sólo posee 128. Sin
embargo en este manual no utilizaremos dicha versión ampliada, porque no existe un estándar y
este varía dependiendo el fabricante.

Universidad de Guadalajara CUCEI 7 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Estructuras de control
Las estructuras de control son sentencias que nos permiten controlar como se ejecutará un
programa, es decir el orden de las instrucciones, ya que tienen un solo punto de entrada y uno de
salida. Estas se clasifican en:

Imagen 5. Estructuras de control

Estructuras de control Selectivas

Imagen 6. Estructuras de control selectivas

Universidad de Guadalajara CUCEI 8 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Estructuras de control Repetitivas

Imagen 7. Estructuras de control repetitivas

Imagen 8. Estructuras de control de salto

Universidad de Guadalajara CUCEI 9 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Práctica 1: Conversión de un arreglo a código ASCII.

Realizar un programa en LabVIEW que escriba y muestre la palabra “Hola” por medio de un
arreglo de números correspondientes al código ASCII de cada carácter.

Build Arrays
La primera herramienta que utilizaremos es Build Array (Construir un array), la cual se puede
encontrar en la paleta de funciones, Programming > Array .

Imagen 9. Build Array

Esta será utilizada para construir el arreglo de números cuyo código ASCII corresponde a las cuatro
letras de la palabra Hola.

Byte Array to String

La siguiente herramienta a utilizar se llama: Byte Array to String, se encuentra en Programming >
String > Patch/Array/String Conversion

Imagen 10. Byte Array to string

Universidad de Guadalajara CUCEI 10 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Su función es convertir un arreglo de números (sin signo) a su correspondiente carácter en código
ASCII.

Imagen 11. Byte Array to string

Abajo se muestra el programa propuesto para realizar la práctica, se recomienda poner una serie
de indicadores, para entender mejor el proceso de conversión.

Diagrama de Bloques

Imagen 12. Diagrama de Bloques

Panel Frontal

Imagen 13. Panel frontal

Universidad de Guadalajara CUCEI 11 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Práctica 2: Mandar un carácter por un puerto serial.

Esta práctica consiste en utilizar el monitor serial de Arduino, para mandar un carácter desde
nuestro teclado y visualizar su correspondiente valor en código ASCII.

Las funciones a utilizar son:

void setup(): Sucede al momento de encender o resetear el Arduino y su función es llevar a cabo
aquellas instrucciones que sólo necesitan ejecutarse una vez.

void loop(): Ocurre después del void setup(), y su trabajo es efectuar de manera continua e
infinitamente el código que lleva en su interior, al menos que se apague o reinicie el Arduino.

[Link](): Inicia la comunicación serial y define el número de caracteres por segundo

(baudios) con los que trabajará el puerto serial.

[Link](): Devuelve el número de bytes (caracteres) disponibles, que fueron recibidos a

través del canal serie. Estos bytes son almacenados temporalmente en un buffer.

[Link](): Lee y puede guardar en una variable el primer byte del buffer, posteriormente lo
elimina para que el siguiente byte pueda ser leído.

[Link](): Imprime uno o varios caracteres en el puerto serie.

El programa propuesto se presenta a continuación:

Imagen 14. Programa en Arduino

Universidad de Guadalajara CUCEI 12 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Cabe resaltar que dentro de void loop() se utilizó la condición if ([Link]() > 0), para
determinar si hay datos almacenados en el buffer, y si esto es cierto los bytes podrán ser leídos y
posteriormente eliminados por la instrucción [Link]() de manera continua.

Ahora hacemos clic en la palomita que está en la parte superior del compilador.

Imagen 15. Verificar

Cargamos el programa en Arduino,

Imagen 15.1 Cargar

y accedemos al monitor serial.

Imagen 15.2 Monitor serial

Una vez corriendo, podemos observar que si en el monitor serial escribimos la palabra “Hola” y
presionamos “Enter”, en este se imprimirá el valor decimal correspondiente de cada carácter en
código ASCII.

Monitor Serial

Imagen 16. Monitor serial ejemplificando la práctica

Como sólo hacemos uso del puerto serial, el Arduino solo se encontrará conectado a la
computadora por medio del cable USB, sin necesidad de utilizar ningún componente electrónico.

Universidad de Guadalajara CUCEI 13 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Práctica 3: Escribir y leer en el puerto serie.

1. Hacer un programa en LabVIEW que mande un número por el puerto serie.
2. Por su parte, hacer otro programa en Arduino que lea esa cifra y mande un uno lógico en
la salida digital que corresponda a dicho valor.
3. Este uno lógico durará un segundo y su propósito es prender un led.
4. Posteriormente el programa de Arduino, mandará un cero y el led se apagará.

Antes de realizar el programa, veamos un poco de teoría, para comprender mejor la comunicación
entre Arduino y LabVIEW.

Librería VISA
VISA (Virtual Instrument Software Architecture) es una librería desarrollada por varios fabricantes
de equipos que proporciona un software estándar para las operaciones de lectura, escritura y
manejo de eventos en instrumentación.

NI-VISA puede establecer comunicaciones a través de GPIB, serie, PXI, VXI o Ethernet. Como VISA
soporta varias interfaces de comunicación, suele ser el método elegido para crear drivers para
control de equipos.

Hay docenas de VIs dedicados a VISA, por lo que sólo estudiaremos los más típicos, VISA Open,
VISA Write, VISA Read y VISA Close.

Esta librería se encuentra en: Programming > Instruments I/O.

Imagen 17. VISA en LabVIEW

Universidad de Guadalajara CUCEI 14 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Serial (VISA)
Con el fin de tener las herramientas VISA más a la mano para realizar la comunicación serial
Arduino-LabVIEW, se recomienda accesar a estas de la siguiente manera: Instrument I/O > Serial.

Imagen 18. Serial en LabVIEW

VISA Configure Serial Port

La herramienta llamada VISA Configure Serial Port, abre una sesión VISA, escanea los puertos
disponibles en el ordenador y configura varios parámetros del puerto serie seleccionado, sin
embargo únicamente dos parámetros son de nuestro interés:

VISA Configure Serial Port

Imagen 19. VISA serial.

Haciendo clic derecho sobre la terminal VISA resource name y creando en ella un control o una
constante, esta herramienta nos permite indicarle a LabVIEW el puerto serie en el cual se
encuentra nuestro Arduino para así realizar un intercambio de datos.

Al igual que en el caso anterior, realizando clic derecho sobre la terminal baud rate y creando en
ella un control o constante podemos seleccionar la velocidad del puerto serie, misma que por
fuerza tiene que ser igual a la indicada en el código del Arduino.

Imagen 20. VISA serial.

Universidad de Guadalajara CUCEI 15 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

VISA Read y VISA Write

Por otro lado las herramientas VISA Read y VISA Write, nos permiten leer y escribir datos en el
puerto serie donde se encuentra conectado el Arduino.

Imagen 21. VISA Read y VISA Write

Tanto en VISA Read como en VISA Write, es necesario conectar las entradas VISA resource name
y error in a las salidas VISA resource name out y error out de la caja anterior.

La herramienta VISA Read, necesita conocer la cantidad de bytes del buffer que debe de leer, este
problema es resuelto conectando la herramienta VISA Bytes at Serial Port a la terminal byte
count, la cual al igual que todas las herramientas anteriores se encuentra en Instrument I/O >
Serial.

Como se puede observar en la figura de abajo, también se creó un indicador en la terminal read
buffer, con el objetivo de que LabVIEW nos muestre los datos que el Arduino nos envía.

Imagen 22. Bytes at Port

Por su parte la herramienta VISA Read escribe datos desde el buffer al Arduino, para esto hay que
crear un control o una constante en la terminal Write buffer de esta función.

Imagen 23. VISA Serial

Tenemos que tomar en cuenta que si se desea leer o escribir datos de manera continua en el
puerto serie, estas 2 funciones deben de encontrarse dentro de un ciclo while loop.

Universidad de Guadalajara CUCEI 16 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
VISA Close
Por último, la herramienta Visa Close cierra la sesión VISA y se cablea una vez que hemos
terminado de utilizar todas las herramientas anteriores.

Imagen 24. VISA Close

Ahora se ilustra cómo cablear el elemento anterior.

Imagen 25. Cableado de los elementos de VISA Serial

Salidas y entadas digitales del Arduino

Ahora bien, las instrucciones que utilizaremos para realizar el programa en Arduino son las
siguientes.

pinMode(): Configura un pin digital, el número de este pin es el primer parámetro de la función,
por su parte, el segundo puede ser una de estas dos constantes: INPUT o bien OUPUT, que
definen a este pin como o entrada o salida respectivamente, esta función normalmente se sitúa
dentro del void setup().

digitalWrite(): Envía un valor ALTO(HIGH) o BAJO(LOW), a un pin digital (Previamente

configurado como salida por medio de la función pinMode()), su primer parámetro es el número
de pin y el segundo define si el valor a enviar debe de ser alto o bajo, comúnmente va dentro del
void loop().

digitalRead(): Devuelve el valor leído por el pin digital (Configurado como entrada por medio de
pinMode()), el parámetro que va dentro de esta función es el número de pin.

Ahora ya somos capaces de conectar Arduino con LabVIEW, además de leer o mandar datos por el
puerto serial, a continuación se muestran los dos programas que pueden servir de guía para
realizar la práctica:

Universidad de Guadalajara CUCEI 17 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Programa en LabVIEW
Como ya nos hemos dado cuenta, al momento de mandar datos por el puerto serie, tenemos que
tener presente que estos se transportan como un arreglo de ocho bites (byte) y cada uno posee un
carácter ASCII correspondiente.

Por ejemplo, si nosotros quisiéramos mandarle por el puerto serie el número 97 a nuestro
Arduino. Tendríamos que seguir los siguientes pasos:

1. Convertir el 97 en su correspondiente carácter ASCII, el cual resulta ser “a”.

2. Mandar dicho carácter por el puerto serial, de manera que se almacene en el buffer.
3. Leer dicho valor como un dato tipo int, de manera que el valor leído sea el número 97, ya
que si lo leemos como tipo char, el valor será el carácter “a”.

Existen otras formas para realizar el trabajo, pero esta es una de las más sencillas y de las que
ofrecen mejores resultados.

Diagrama de Bloques

Imagen 26. Diagrama de bloques

Panel Frontal

Imagen 27. Panel Frontal

Para realizar el proceso anterior se prosiguió de la siguiente manera:

Como bien sabemos, existe la herramienta Byte Array to String, la cual convierte un arreglo de
bytes a sus correspondientes caracteres ASCII. Sin embargo los datos que arroja un control
numérico de LabVIEW, no son arreglos, si no elementos independientes.

Para resolver este inconveniente se utilizó el bloque Build Array, el cual tiene por función anexar
elementos de manera que estos formen un arreglo. Debido a que sólo tenemos un elemento, esta
herramienta se utilizará para otorgarle al número el formato necesario para ingresar a Byte Array
to String, la cual al final nos otorgará el correspondiente carácter ASCII del número; mismo que
será enviado por el puerto serie y posteriormente leído por el Arduino.

Universidad de Guadalajara CUCEI 18 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Programa en Arduino
En el programa de Arduino declaramos una variable tipo entera, la cual guardará el valor leído en
el buffer. Es necesario que esta variable sea de tipo int, ya que si es de algún otro tipo esta no
contendrá el valor deseado.

Imagen 28. Código en Arduino

Es muy importante mencionar que cada vez que corremos un

programa en LabVIEW que configure el puerto serie, el Arduino se
reiniciará y nuestro código tardará en funcionar aproximadamente
medio segundo en lo que se normalizan todos los parámetros. Por
lo tanto, si los datos llegan antes, el Arduino simplemente los
ignorará y terminará la acción sin siquiera empezarla.

Este problema se presenta normalmente en programas que

funcionan una sola vez (como el de la práctica), ya que los datos
llegan mucho antes de que el código de Arduino corra. Sin
embargo, la solución es muy sencilla: consiste en colocar un
capacitor de 10𝜇𝐹 entre los pines GND y RESET, lo cual deshabilita
la función auto-reset. Claro está que cuando carguemos un nuevo
código en el Arduino, tendremos que retirar el capacitor ya que
este se tiene que reiniciar para realizar el proceso. Imagen 29. Conexión del Arduino

Universidad de Guadalajara CUCEI 19 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Conexión del Arduino

Imagen 30.1: Conexión del Arduino

Universidad de Guadalajara CUCEI 20 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Práctica 4 Leer voltaje con Arduino y mandar los datos por el

puerto serie.
Esta práctica consiste en leer un voltaje por medio de las entradas analógicas de nuestro Arduino,
dicho valor será procesado y enviado por el puerto serie, de manera que un programa hecho en
LabVIEW sea capaz de mostrarlo en un indicador numérico.

Las funciones que se utilizarán en el programa para Arduino son:

analogRead(): Devuelve un número entre 0 y 1023 que corresponde al rango de 0 a 5 voltios,

donde 5 es el voltaje de referencia por defecto.

Esto se debe a que el conversor analógico-digital que lleva integrado nuestro Arduino tiene 10
bites de resolución (210 = 1024). Por lo tanto, la fórmula para determinar el voltaje de una
entrada analógica, será:

(𝑏𝑖𝑡𝑒𝑠)(5.00)
𝑉𝑒𝑛𝑡 =
1023

analogReference(EXTERNAL): Configura el voltaje de referencia usado para la conversión

analógico- digital, como el que entra por el pin “AREF”. Es importante tener en cuenta estas 2
consideraciones para no dañar nuestro Arduino:

1. Utilizar esta función antes del analogRead().

2. Como en cualquier otro pin, no aplicar a la entrada AREF un voltaje que esté fuera del
rango de 0 a 5 voltios.

La nueva fórmula para determinar el voltaje seria la siguiente:

(𝑏𝑖𝑡𝑒𝑠)(𝑉𝑟𝑒𝑓)
𝑉𝑒𝑛𝑡 =
1023

analogWrite(): Le ordena a un pin digital que entregue un valor de voltaje PWM entre 0 y 5
voltios. Esta función tiene dos parámetros:

1. El primero le indica cuál es el pin que aportará dicho voltaje. Es importante resaltar que
sólo los pines digitales PWM pueden hacer uso de esta función, además estos antes
debieron ser configurados como salidas por medio de la función pinMode().
2. Este otro parámetro determina cual será el valor de voltaje que el pin aportará. Dicho
valor deberá encontrarse entre el rango de 0 a 255. Esto se debe a que el conversor
digital-analógico de nuestro Arduino a diferencia de su contraparte, tiene una resolución
de 8 bites (28 = 256).

La relación que nos determinará el voltaje de salida PWM será la siguiente:

(𝑉𝑠𝑎𝑙)(255)
𝑏𝑖𝑡𝑒𝑠 =
5.00

Universidad de Guadalajara CUCEI 21 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Leer y actualizar un valor de manera continua

Hasta el momento ya somos capaces de conectar Arduino con LabVIEW. Podemos leer un dato y
transmitirlo por el puerto serie, sin embargo, el proceso anterior sólo podemos llevarlo a cabo una
vez. Si quisiéramos repetir el proceso varias veces de manera que podamos refrescar la
información, tenemos que hacer uso de unas funciones especiales llamadas estructuras:

Estructuras
Las estructuras de control son una de las herramientas básicas de todo lenguaje de programación
y permiten a un programa ejecutar un código de forma condicional o repetirlo cierto número de
veces.

En LabVIEW estas instrucciones son recuadros que encierran en su interior el código que afectan.
Se encuentran en el menú: Programming > Structures.

Imagen 30. Estructuras de control

Universidad de Guadalajara CUCEI 22 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Flat Sequence
Un flat sequence consiste en uno o más subdiagramas, también llamados frames, los cuales
contienen un programa en su interior y lo van ejecutando de forma secuencial. Se encuentra en
Programming > Structures.

Imagen 31. Flat Sequence Structure

Para agregar un nuevo subdiagrama, damos clic derecho sobre la estructura y seleccionamos la
opción Add a FrameAfter o Add a Frame Before, según sea el caso.

Imagen 32. Flat Sequence Structure

Universidad de Guadalajara CUCEI 23 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Case Structure
Su utilidad es ejecutar un código u otro dependiendo de una condición. En lenguajes de
programación basados en texto, es el equivalente al if y al switch.

Esta estructura tiene un menú en la parte superior, y en este se puede ver la condición para
ejecutar el código del subdiagrama correspondiente.

La terminal que aparece en el lado izquierdo marcado con el símbolo “?”, es llamado selector, el
valor que llegue a este selector es la condición que evaluará para seleccionar el subdiagrama a
ejecutar.

Al igual que la estructura anterior, esta herramienta se puede encontrar en: Programming >
Structures.

Imagen 33. Case Structure

Universidad de Guadalajara CUCEI 24 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
While Loop
La función de este bucle es repetir el código en su interior hasta que se cumpla una condición,
misma que es evaluada en cada iteración. Se localiza en: Programming > Structures.

Imagen 34. While Loop

El terminal de iteración es un cuadrado azul con símbolo “i”. El valor de este terminal es un
número entero que irá aumentando en una unidad por cada iteración del bucle, empezando a
contar desde cero.

La condición de stop es el cuadro verde con el punto rojo adentro que se encuentra en la esquina
inferior derecha, a esta terminal se le conecta un valor booleano. Si no se especifica esta condición
de parada, LabVIEW arrojará un error y no dejará correr el programa. Para que esto no ocurra, a
menudo se crea un botón STOP haciendo clic derecho sobre el icono rojo y se selecciona la opción
Create a Control, en consecuencia el programa correrá por tiempo indefinido, al menos que
nosotros deseemos detenerlo haciendo clic en el botón de STOP que hemos generado.

Imagen 35. Creando un control de Stop

Otras de las funciones del menú contextual es Add Shift Register, esta herramienta añade dos
terminales a cada lado de la estructura, estas terminales sirven para transferir un valor desde una
iteración del bucle a la siguiente.

Universidad de Guadalajara CUCEI 25 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Imagen 36. Agregando un Shift Register

For Loop
El bucle for, es muy parecido al while. También repite el código en su interior un número de veces
pero, a diferencia del anterior, este número es fijado a priori y no puede cambiarse una vez que
empieza a ejecutarse.

Consta de dos terminales numéricos:

El terminal de iteración se encuentra en el interior de la estructura y va incrementando en una

unidad por cada iteración empezando desde cero.

El terminal de cuenta está colocado en la esquina superior izquierda de la estructura y esta

simbolizado con una letra “N”, en el que se conecta un valor numérico que será el que fije el
número de repeticiones del bucle.

Al igual que todas las estructuras se sitúa en: Programming > Structures.

Universidad de Guadalajara CUCEI 26 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Imagen 37. For Loop

También se le puede añadir un tercer terminal a través del menú contextual. Este terminal es el de
condición que también tiene el while para detener el bucle. Su uso sería el equivalente al empleo
de un break, en un lenguaje de programación basado en texto.

Imagen 38. For Loop modificando el conditional terminal

Todo lo dicho en el bucle while respecto al uso del shift register es válido también en la estructura
for, de ahí por qué en el menú contextual del for, como del while existe la opción de sustituir uno
por otro.

Universidad de Guadalajara CUCEI 27 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Wait
Esta función ordena a una aplicación esperar un tiempo determinado antes de ejecutarse,
terminado dicho tiempo la aplicación operará de modo normal.

En nuestro caso normalmente lo usaremos dentro de un frame y su propósito será el esperar un

tiempo determinado, para asegurar que en una parte de nuestro programa ya llegaron y están
presentes todos los datos que requerimos, de manera que tengamos una buena sincronización
entre Arduino y LabVIEW. Se encuentra en: Programming > timing y es representado de la
siguiente manera:

Imagen 39. Wait (ms)

Para finalizar, abajo se muestran tanto el programa en Arduino, como el de LabVIEW, que se
sugieren para hacer la práctica:

Es muy importante recalcar que tanto el delay() del programa en Arduino como el Wait en el de
LabVIEW, tienen que tener por fuerza el mismo valor, ya que si sucede lo contrario tendremos un
problema de sincronización.

Como se puede apreciar abajo, en el programa hecho en LabVIEW hay un control numérico que
determina el tiempo de espera entre iteraciones (Muestreo); se invita al practicante a jugar con
este parámetro de manera que entienda qué es y qué sucede cuando este no concuerda con el
valor de su correspondiente delay().

Universidad de Guadalajara CUCEI 28 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Programa en Arduino

Imagen 40. Programa en Arduino

Conexión del Arduino

Imagen 41. Diagrama en Arduino

Universidad de Guadalajara CUCEI 29 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Imagen 42. Conexión del Arduino

Programa en LabVIEW

Imagen 43. Diagrama de Bloques

Panel Frontal

Imagen 44. Panel Frontal

Universidad de Guadalajara CUCEI 30 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Práctica 5 Mejorando la sincronización Arduino - LabVIEW

Realizar un programa en LabVIEW y en Arduino, que en conjunto hagan las siguientes tareas:

1. Controlar por medio de un programa en LabVIEW el número de pin analógico, con el cuál
Arduino leerá un voltaje.
2. De igual forma, controlar la velocidad con la que Arduino toma y actualiza los valores de
dicho parámetro.
3. Mostrar en un indicador gráfico la tensión obtenida.
4. Con el fin de fomentar una respuesta más rápida por parte del Arduino, se recomienda
que este transmita los datos en bruto, de manera que LabVIEW se encargue de hacer la
conversión bites-voltaje.

Esta práctica puede ser vista como una combinación de las 2 prácticas anteriores más algunos
elementos nuevos. Primero se explicará el cómo abordarla con los elementos ya aprendidos y
luego se complementaran los programas con nuevas herramientas.

Programa en LabVIEW
Este programa configura el puerto COM3 a una velocidad de 9600 caracteres por segundo
(baudios), posteriormente escribe en dicho puerto el carácter “1”, en seguida espera 25ms de
forma que el Arduino pueda realizar todos sus procesos internos y nos envíe el resultado; este
método es muy simple y habitual para comunicarse con microcontroladores. Después del retardo
se utiliza la propiedad Bytes at Port para indicarle a VISA read el número de bytes que tiene que
leer, la información mandada por el Arduino es leída y esta se muestra en un indicador.

Imagen 45. Diagrama de Bloques

Universidad de Guadalajara CUCEI 31 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
View As Icon
Algunas veces, es mucho más conveniente ver las
constantes, controles e indicadores de una forma
reducida, para ahorrar espacio. LabVIEW ofrece una
opción que hace posible esta labor.

Para reducir el tamaño de alguno de estos elementos,

simplemente tenemos que hacer clic derecho sobre
su ícono y seleccionar la opción View As Icon. Tal
como se ve en la imagen.

Desde ahora en adelante, trabajaremos de esta

manera, al menos que expliquemos alguna nueva
herramienta.

Imagen 46. Hacer un icono

Transformar carácter a número
Ahora bien, el nuevo bloque a aprender se llama: Fract/Exp String To Number, se encuentra en:
Programming > String > Number/String Conversion.

Imagen 47. Fract/Exp String to Number

Universidad de Guadalajara CUCEI 32 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Imagen 48. Fract/Exp String to Number

Sirve para transformar un dato tipo string cuyo símbolo sea una cifra a un dato numérico (puede
ser entero o racional la cifra de entrada, pero siempre es racional la salida). Si el String es un
carácter de otro tipo la salida dará siempre cero.

El siguiente elemento a conocer se denomina combo box, a diferencia de los anteriores, este se
encuentra en el menú de controles, su localización es: Modern > String & Path.

Combo Box
El control Combo Box es una herramienta que se utiliza para mostrar datos en un cuadro
desplegable. Esta herramienta se divide en dos partes: la parte superior es un cuadro de texto que
nos permite escribir un elemento de la lista. La segunda parte es una lista que muestra varios
elementos, de los cuales nosotros podemos seleccionar uno.

Imagen 49. Combo Box

Se localiza en la paleta de controles, yendo a: Modern > String & Patch.

Imagen 50. Combo Box

Universidad de Guadalajara CUCEI 33 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Para configurarlo, tenemos que seguir los siguientes pasos:

1. Hacer clic derecho sobre él y seleccionar la opción

propiedades, nos aparecerá la ventana que se
muestra a la derecha.

2. Posteriormente elegimos la pestaña Edit Items.

3. Deseleccionamos la opción Values math Items

4. Damos clic en el botón Insert.

5. Editamos los ítems que aparecerán en la lista del

Combo Box, así como los correspondientes valores
Imagen 51. Propiedades del Combo Box
que cada uno arrojará una vez seleccionado.

Imagen 52. Editando los ítems de un Combo Box

6. Por último aplicamos clic sobre el botón OK.

No está de más mencionar que el botón Delate elimina el ítem seleccionado. Por su parte, las
opciones Move UP y Move Down, mueven dicho ítem hacia arriba o hacia abajo, respectivamente.

Universidad de Guadalajara CUCEI 34 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Cálculos matemáticos con LabVIEW

Ahora bien, una vez que nuestro dato tipo carácter fue convertido a uno tipo numérico, podemos
hacer uso de la librería Numeric. Esta librería tiene como función principal, brindarnos
herramientas para realizar cálculos matemáticos con datos que el sistema o nosotros le
aportamos. Se encuentra desde la paleta de funciones en: Programming > Numeric.

Imagen 53. Numeric en LabVIEW

Otra opción para realizar cálculos con datos es utilizar el bloque fórmula, este elemento se parece
a una calculadora, en el pueden entrar hasta 8 diferentes variables, pero sólo arrojará un
resultado.

Imagen 54. Formula en LabVIEW

Universidad de Guadalajara CUCEI 35 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Para editar una fórmula, puedes hacer doble clic sobre su respectivo ícono o aplicar clic derecho
sobre el bloque y seleccionar la opción propiedades, de manera que aparezca la ventana de arriba.
Cabe resaltar que en un primer momento, cuando se coloca esta herramienta dentro del diagrama
de bloques, en automático aparece la ventana correspondiente, para empezar la edición.

Imagen 55. Configuración de la Fórmula

Se puede encontrar en la paleta de funciones, siguiendo la siguiente ruta: Mathematics > Scripts &
Formulas.

Imagen 56. Scripts & Formulas

Universidad de Guadalajara CUCEI 36 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Graficando datos con

LabVIEW
Algunas veces no es suficiente
observar los datos en un indicador
numérico, sino también en una
gráfica. Para realizar este trabajo,
LabVIEW ofrece una herramienta
llamada Waveform Chart.

Imagen 57. Waveform Chart

Al igual que el combo box, esta se encuentra desde la paleta de controles, en Modern > Graph.

Imagen 58. Waveform Chart

Universidad de Guadalajara CUCEI 37 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Esta herramienta en un principio

se encuentra configurada, para
buscar automáticamente la mejor
escala para graficar un dato dado.

Esto muchas veces resulta ser un

inconveniente, dado que la escala
de la gráfica cambia
continuamente y a gran
velocidad, de manera que muchas
veces no somos capaces de
percibir la magnitud de un dato,
porque la escala se vio afectada.

La solución de este problema es

muy sencilla, a continuación se
muestran los pasos a seguir:

1. Damos clic derecho sobre

la gráfica y luego nos dirigimos a
la opción: Y Scale.

2. Una vez ahí, nos

aparecerán otra serie de
opciones, y en la que dice
AutoScale Y aplicamos clic. Ahora
la autoescala ha sido suspendida.

3. El último paso es editar

los valores superiores e inferiores
de la escala.

De ahora en adelante la escala no

será afectada.

Imagen 59. Modificando un gráfico en LabVIEW

Universidad de Guadalajara CUCEI 38 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Programas en LabVIEW
A continuación se muestran tanto el programa original que se sugirió para la práctica, así como el
mismo modificado, con los elementos aprendidos anteriormente. Se sugiere al practicante realizar
ambos programas, de manera que pueda comparar la forma en que ambos trabajan.

Imagen 60. Diagramas a bloques

El funcionamiento del programa modificado es muy similar al de su contraparte básica, en un

principio se inicializa el puerto serie a una velocidad de 9600 baudios por segundo, luego el Combo
Box envía un dato tipo carácter a la herramienta siguiente de manera que este dato se convierta
en tipo numérico. Los siguientes 3 bloques transforman este número a su correspondiente valor
ASCII y lo envían por el puerto serial.

Posteriormente hay un retraso de algunos milisegundos (controlados por el usuario), con el

propósito de darle al Arduino tiempo suficiente para realizar sus procesos internos. Una vez
finalizado dicho tiempo, se lee el dato que mandó el Arduino por el puerto serial. Como este dato
de nuevo es un carácter, se convierte a número y se realizan los cálculos pertinentes para
transformar este valor a voltaje. Ahora el dato está listo para verse en una gráfica como en un
indicador numérico.

Universidad de Guadalajara CUCEI 39 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Panel Frontal

Imagen 61. Panel frontal

Programa en Arduino

Imagen 62. Código en Arduino

Universidad de Guadalajara CUCEI 40 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Conexión del Arduino

Imagen 63. Diagrama y Conexiones del Arduino

Universidad de Guadalajara CUCEI 41 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Práctica 6 Control de leds

Hacer un programa en LabVIEW que muestre 8 leds, cada uno tendrá un pin correspondiente que
estará conectado a las entradas digitales del Arduino. El objetivo será prender y apagar los leds en
el programa en LabVIEW, lo cual hará que se prenda o se apague su correspondiente en Arduino.

Ya dominamos la transmisión de datos entre al Arduino y LabVIEW, sin embargo no conocemos lo

suficiente para llevar a cabo esta práctica. A continuación se explica este proceso de una manera
más detallada.

Transmisión de datos entre Arduino y LabVIEW

La forma en la que se transmite la información entre LabVIEW y Arduino se denomina:
Transmisión en serie asíncrona. Esta consiste en enviar desde un transmisor hacia un receptor
una serie de Altos y Bajos cuya combinación específica corresponde a un símbolo ASCII. Para que
esta se lleve a cabo de manera correcta, tanto el receptor como el transmisor deben de ponerse
de acuerdo en los siguientes puntos:

1. Velocidad de transmisión. Normalmente de 9600 baudios por segundo.

2. Numero de bites a leer. Arduino trabaja con 8.
3. Bit que se transmitirá primero. El más significativo.
4. Bit de paridad para detección de errores. No lo utilizaremos.
5. Numero de bites de parada. Arduino maneja por defecto 1 bit.

Otras consideraciones que deben de tomarse en cuenta son:

1. Tanto el receptor como el transmisor, tienen que estar conectados a una misma tierra.
2. Las entradas de datos (Rx) del emisor como del transmisor, tienen que estar conectadas a
la salida de datos (Tx) del otro dispositivo, tal como se muestra a continuación.

Imagen 64. Transmisión de datos en Arduino

Universidad de Guadalajara CUCEI 42 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Ahora se explicará un ejemplo sobre este tipo de transmisión.

Entrada de Salida de
Datos RX Datos TX

Imagen 65. Transmisión de datos en Arduino por medio del código ASCII

Como podemos analizar:

1. En un principio la línea se encuentra en alto, luego repentinamente cambia a bajo (bit de

inicio), indicando así que la transmisión de datos comienza.

2. Posteriormente se envía una secuencia de 8 bites que corresponden a un valor binario.

Estos se envían empezando por el bit más significativo MSB (27 = 128).

3. Una vez terminado esto, la línea vuelve a su estado alto indicando así que la transmisión
ha terminado (bit de Parada).

Esta secuencia específica de Altos y Bajos, no sólo corresponde al número 66 en decimal, sino
también a la letra B, tal y como se puede observar en la tabla ASCII.

Otra observación importante es: que tanto el bit de inicio (Start) como el de parada (Stop) siempre
estarán entre dos caracteres, por lo tanto, el número de bites que utilizaremos para transmitir la
palabra “Hola” serán 40 y no 34 como podría llegarse a pensar.

Universidad de Guadalajara CUCEI 43 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Herramientas en LabVIEW
Las dos nuevas funciones que aprenderemos se centran en el control de bites, estas no serán
muchas y se complementarán con las ya aprendidas.

Boolean Array To Number

La función de esta herramienta es transformar un arreglo
booleano a su correspondiente número decimal. Se localiza
en: Programming > Boolean

Imagen 66. Boolean Array to Number

Boolean Control
Su ícono correspondiente
es un led, y sirve para que
el usuario determine a
voluntad si una condición
es verdadera o falsa. Se
puede encontrar desde el
panel de control en:
Modern > Boolean.

Imagen 67. Boolean control

Universidad de Guadalajara CUCEI 44 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Una vez seleccionada, esta herramienta en un principio aparece como un indicador en el diagrama
de bloques. Para cambiarlo a un control se da clic derecho sobre su ícono y seleccionamos la
opción Change To Control.

Si en el panel de control, el usuario hace clic sobre

su ícono, este cambiará de un verde obscuro a
uno más claro, indicando así que la condición ha
cambiado de bajo a alto, respectivamente.

Imagen 68. Modificación de un indicador a control y

panel frontal de LabVIEW mostrando la condición.

Por su parte, las nuevas instrucciones que se aprenderán para el código en Arduino serán:

bitRead(): Esta función trasforma un número decimal a binario y nos dice si hay un cero o un uno
en la posición que nosotros le indiquemos. Tiene dos parámetros:

1. Es el número decimal que se transformará a binario.

2. Posición del digito binario que queremos conocer. Donde 0 es el bit menos significativo.

La forma en que abordaremos la práctica es sencilla. Tenemos 8 leds conectados a las entradas
digitales 2 a 9 de nuestro Arduino. Cada led tiene 2 posibles estados (ALTO o BAJO). Por lo tanto,
podemos hacer un arreglo binario de 8 bites (un byte), en donde el bit 0 corresponderá al led de la
salida digital 2, mientas el bit 7 a la 9. Esto se hará sumando 2 unidades al lugar del bit.
Dependiendo el estado del bit, Arduino determinará si su respectivo led esta prendido o apagado.

Imagen 69. Lectura de bit

Universidad de Guadalajara CUCEI 45 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Antes de realizar la práctica, explicaremos como vamos a transmitir los estados de los leds en base
a un arreglo de 7 bites y su correspondiente carácter ASCII. A continuación se muestra dicho
programa:

Diagrama de Bloques

Imagen 70. Diagrama de bloques

Panel Frontal

Imagen 71. Panel frontal

Como podemos observar, en el Panel de control se le otorga un valor ya sea verdadero o falso a
los Controles Booleanos (prendiendo o apagando los leds). Estos valores entran al bloque Build
Array cuya función es convertirlos en un número binario que a continuación ingresan a un
Boolean Array To Number, mismo que lo transforma en un número decimal. A partir de este
punto, los dos programas son iguales: el número decimal entra a un Build Array de manera que
obtiene el formato necesario para ingresar a Byte Array To String que lo transforma en su
correspondiente valor ASCII y así pueda ser leído por el Arduino.

Universidad de Guadalajara CUCEI 46 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Se propone al practicante, recrear el diagrama anterior, de manera que entienda mejor este
proceso. A continuación se muestra el programa y conexión sugeridos para efectuar esta práctica:

Diagrama de bloques.
Al igual que en los programas anteriores, este inicializa el puerto serial, manda información por el
mismo, espera un tiempo a que Arduino termine todos sus procesos, lee el número de bytes
recibidos, e imprime la información en un indicador.

Imagen 72. Diagrama de Bloques

Sin embargo, sus dos principales diferencias son: la serie de controles booleanos y el uso de la
herramienta Boolean Array To Number, que aprendimos con anterioridad.

Panel de Frontal

Imagen 73. Panel Frontal

Universidad de Guadalajara CUCEI 47 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Código en Arduino

Imagen 74. Programa en Arduino

Vale la pena hacer tres observaciones importantes:

1. El primer ciclo for, configura del pin 2 al pin 9 como salidas digitales.
2. El segundo ciclo for, comprueba si hay un cero o un uno en una determinada posición del
valor del buffer (en binario). Esta posición varía del 7 al 0. Donde 7 es el bit más
significativo y 0 es el menos significativo.
3. Si le sumamos 2 unidades al lugar a analizar, se obtendrá el número de pin que mandará
un alto o bajo dependiendo si se leyó 0 o 1.

Universidad de Guadalajara CUCEI 48 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Conexión del Arduino

Imagen 75. Diagrama de conexión del Arduino

Universidad de Guadalajara CUCEI 49 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Práctica 7 Escribir un mensaje en una pantalla LCD

Realizar un programa en LabVIEW que permita al usuario escribir un mensaje dentro de un string
control. Este mensaje se mandará por el puerto serie, Arduino lo captará y escribirá dicho mensaje
en una pantalla LCD.

Programa en LabVIEW
El programa que proponemos no es muy diferente a los vistos previamente:

Imagen 76. Diagrama de Bloques

Lo que lo diferencia es la utilización del bloque

Concatene Strings, que como su nombre lo dice,
tiene por función concatenar (unir) cadenas.

Imagen 77. Concatenate Strings

Se puede encontrar yendo desde la paleta de funciones a: Programming > String.

En nuestro caso, únicamente lo utilizaremos para anexarle al mensaje una barra diagonal al final.
Esta nos servirá para indicarle al Arduino que el mensaje ya acabó.

Imagen 78. Concatenate Strings

Universidad de Guadalajara CUCEI 50 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Update Value while Typing

Como el objetivo de esta práctica es escribir un mensaje en un string control, de manera que
aparezca lo mismo en una pantalla LCD, necesitamos entonces actualizar continuamente nuestro
control; ya que si no lo hacemos la LCD sólo mostrará el primer mensaje que le enviamos sin
importar cuantas veces lo cambiemos.

El procedimiento que seguiremos para otorgarle esta cualidad a nuestro string control es el
siguiente:

Nos dirigimos al panel frontal, damos clic derecho sobre el control y luego seleccionamos la
opción: Update Value while Typing.

La imagen muestra el proceso a seguir:

Imagen 79. Update Value while Typing

Universidad de Guadalajara CUCEI 51 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Cadenas en Arduino
Hablando de forma simple, una cadena es un conjunto de caracteres (arreglo de variables tipo
carácter) y estas a menudo se utilizan para representar palabras. Uno de los principales
inconvenientes que nos encontramos cuando mandamos frases desde LabVIEW hacia Arduino, es
que Arduino no recibe la frase como tal, sino como una secuencia de varios caracteres. Esto es un
impedimento, ya que al momento de tratar de imprimir la frase sólo se mostrará el último
carácter.

Afortunadamente Arduino incluye un completo conjunto de instrucciones de manipulación y

tratamiento de cadenas, las cuales nos permitirán concatenar estos elementos individuales y
formar una cadena de manera que podamos imprimir el mensaje deseado. Únicamente se
explicarán las más relevantes.

Es muy importante resaltar, que estas instrucciones son un poco diferentes a las vistas hasta el
momento, ya que a diferencia de las anteriores comienzan con el nombre específico que el
usuario le dio a la cadena y posteriormente terminan con el nombre de la función a utilizar. Sin
embargo, para hacer más sencilla la sintaxis, se supondrá que el nombre de la cadena es:
“palabra”.

Imagen 80. Cadena de texto en Arduino

Instrucciones en Arduino para el manejo de cadenas

[Link](): Compara si una cadena es igual a otra. Su valor de retorno es “true” si las
cadenas son iguales o “false” en caso contrario.

[Link](): Devuelve una subcadena a partir de otra más grande. Esta se forma
especificando el lugar inicial y el final (primer y segundo parámetro) de los caracteres que se
tomarán para formar esa nueva cadena.

[Link](): Sustituye una subcadena existente dentro de otra (especificada como primer
parámetro), por otra (especificada como segundo).

[Link](): Añade (“concatena”) al final de la cadena otra cadena o un carácter.

Universidad de Guadalajara CUCEI 52 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Pantallas LCD y Librería LiquidCrystal

Las pantallas de cristal líquido sirven para mostrar texto ASCII y se comercializan en diferentes
tamaños (16X2, 20X4…etc.) donde el primer número indica la cantidad de caracteres que caben en
una fila y el segundo el número de filas que tiene la pantalla. Las LCD más habituales son las de 4 y
8 bites, dependiendo del número de cables (bites) que necesitan tener conectados al circuito para
poder recibir o enviar datos.

Aunque cada LCD varía dependiendo el fabricante, normalmente poseen los siguientes pines:

1) Un pin para recibir alimentación.

2) Otro para conectarse a tierra.
3) Un pin que regula el contraste de la pantalla.
4) Tres pines de control, generalmente marcados como: RS, EN y RW.
a) RS hace que el microcontrolador de la LCD, le diga a la pantalla si debe escribir caracteres
o enviar algún comando de control (como cambiar el cursor).
b) EN advierte a la LDC que el microcontrolador le va a enviar datos (ya sea de control o para
imprimir).
c) RW Define si se enviarán datos a la LCD o si se recibirán de ella. Sin embargo,
normalmente no la utilizamos, por lo que conectamos este pin a tierra.
5) 4 u 8 pines, que se conectan a las salidas digitales de la placa Arduino. Estos se utilizan para
transmitir datos y comandos de control, de forma paralela.
6) Dos pines para controlar la luz de fondo. Uno se conecta a alimentación y otro a tierra.
Instrucciones para controlar un LCD

Antes de utilizar estas funciones se debe indicar al Arduino que se utilizará la librería
LiquidCrystal, ya que si no se hace, Arduino no reconocerá dichas funciones.

Posteriormente tenemos que declarar una variable de tipo LiquidCrystal, misma que
representará la LCD que queremos controlar. Cabe resaltar que el nombre de la variable la decide
el programador, sin embargo supondremos que se llama “lcd”. Ahora bien, Para declarar la
variable utilizaremos la siguiente sintaxis:

LiquidCrystal lcd:(RS, Rw, EN, d0, d1, d2, d3, d4, d5, d6, d7): En donde todos estos
parámetros representan el número de pin en el cual se encuentran conectados. No está de más
resaltar que las variables d0 a d7 representan los 4 u 8 pines que posee la LCD para enviar o recibir
datos. Para una pantalla de 8 bites, se pueden omitir las variables d0 a d3, de manera que sea
controlada por 4 bites recibidos por los pines d4 a d7 sin embargo su respuesta será un poco más
lenta.

Un ejemplo para una LCD de 8 líneas controlado por 4 bites, con RW conectado a tierra sería:
LiquidCrystal lcd:(2, 3, 4, 5, 6, 7)

Universidad de Guadalajara CUCEI 53 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
[Link](): Posiciona el cursor en la columna y fila especificadas (primer y segundo
parámetro respectivamente), a partir de allí escribirá el próximo texto.

[Link](): Especifica las dimensiones de la pantalla. Donde el primer parámetro es el número

de columnas y el segundo el de filas.

[Link](): Escribe un dato en la pantalla.

[Link](): Borra el contenido de la pantalla y posiciona el cursor en la esquina superior

izquierda.
Programa en Arduino

Imagen 81. Programa en Arduino

Universidad de Guadalajara CUCEI 54 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Conexión de Arduino

Imagen 82. Diagrama y conexión del Arduino

Universidad de Guadalajara CUCEI 55 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Práctica 8 Control de un Servomotor

Realizar una interfaz gráfica en LabVIEW que nos permita controlar los grados de un servomotor
por medio de Arduino.

Programa en LabVIEW

Imagen 83. Diagrama a Bloques

Este programa configura el puerto COM14 a una velocidad de 9600 (baudios), posteriormente
escribe en dicho puerto el carácter dado por la perilla que selecciona los grados deseados, en
seguida espera 15ms de manera que la sincronización Arduino-LabVIEW sea la adecuada.
Posteriormente se lee la información mandada por el Arduino, con la cual podemos comprobar
que existe una conexión satisfactoria entre ambos, dicha información se transforma de carácter a
número y se muestra en un indicador.

Panel Frontal

Imagen 84. Panel frontal

Universidad de Guadalajara CUCEI 56 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
En esta imagen se observa el panel frontal de LabVIEW para el control del servomotor, en nuestro
caso se encuentra en funcionamiento, el cual nos marca que los 90° seleccionados son los mismos
que nos está recibiendo, por lo que podemos comprobar que hay una conexión satisfactoria entre
Arduino-LabVIEW.

Programa en Arduino
A continuación se explican las nuevas instrucciones a utilizar en este programa de Arduino:

Servo.h: Librería oficial para el uso del servomotor.

Servo: Esta es la primera instrucción que necesitamos para el control de un servomotor, su

función es declarar un objeto de tipo Servo. Si suponemos que el nombre que le damos a nuestro
objeto es “motor”, la instrucción estaría dada de la siguiente forma: Servo motor; en la zona de
declaraciones globales.

[Link](): Vincula el objeto “motor” con el pin digital de la placa Arduino, en el cual se
encuentra físicamente conectado el cable de control del servomotor.

[Link](): Controla el eje del servomotor. Su único parámetro utilizado es el ángulo en

grados donde se quiere situar el eje.

A continuación se muestra el programa propuesto:

Imagen 85. Código en Arduino

Universidad de Guadalajara CUCEI 57 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Conexión del Arduino

A continuación se muestra el diagrama de conexión del Arduino Uno con el servomotor T Pro SG90
Microservo 9g:

Imagen 86. Diagrama y Conexión del Arduino

Universidad de Guadalajara CUCEI 58 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Práctica 9 Monitoreo de varios voltajes al mismo tiempo

Diseñar un programa en LabVIEW y otro en Arduino que en conjunto sean capaces de leer seis
diferentes voltajes, de manera que se visualicen en un indicador gráfico de LabVIEW.
Scan From String

Conforme a LabVIEW, sólo aprenderemos tres nuevas funciones, la primera se llama: Scan From
String. Se localiza en: Programming > String.

Imagen 87. Scan From String

Su función es recibir una cadena de caracteres con cierto formato, la cual los separará en
componentes individuales.

Universidad de Guadalajara CUCEI 59 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Un ejemplo de la forma en que trabaja este bloque, se
muestra a continuación:

Imagen 88. Ejemplo de trabajo del bloque

Como podemos ver en el diagrama de bloques del lado derecho, se creó una constante sobre la
terminal format string, en ella se indicó que la cadena de entrada (input string) tiene tres
caracteres, cada uno separado por una diagonal. Además, se le ordeno que los valores de salida
fueran números flotantes con dos decimales.

Por otra parte, en el lado izquierdo se pueden ver los resultados que obtuvimos en el panel de
control, al momento de correr el programa. Sugerimos al practicante recrear este diagrama.

Bundle y Unbundle
En términos simples, este bloque nos permite
transportar varios datos a través de un mismo
cable (Cluster). Si el cable que contiene estos
datos (numéricos) se conecta a un indicador
gráfico, nos permitirá visualizar la señal que
genera cada uno de ellos.

En cambio Unbundle hace lo contrario. Ósea, si este

recibe un cluster, nos dará a su salida cada dato que
este contenía por separado.

Ambos se pueden
encontrar en:
Programming >
Cluster, Class, &
Variant.

Imagen 89. Visualización del Bundle y Unbundle

Universidad de Guadalajara CUCEI 60 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Diagrama de Bloques

Imagen 90. Diagrama de Bloques

Panel Frontal

Imagen 91. Panel Frontal

Universidad de Guadalajara CUCEI 61 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Programa en Arduino

Imagen 92. Código en Arduino

Universidad de Guadalajara CUCEI 62 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW
Conexión del Arduino

Imagen 93. Diagrama de conexión del Arduino

Universidad de Guadalajara CUCEI 63 Laboratorio de Instrumentación virtual
 Manual de Prácticas Arduino LabVIEW

Imagen 94. Conexión de los elementos al Arduino

Universidad de Guadalajara CUCEI 64 Laboratorio de Instrumentación virtual

 Manual de Prácticas Arduino LabVIEW

Bibliografía
Libro: Arduino, Curso práctico de formación.
Numero de edición: 1ra edición.
Editorial: Alfaomega.
Autor: Óscar Torrente Artero.

Libro: Diseño de algoritmos y su codificación en C.

Numero de edición: 2da edición.
Editorial: Ediciones de Noche.
Autores: María Adriana Corona Nakamura y María de los Ángeles Ancona Valdez.

Libro: Fundamentos de Programación, Algoritmos, Estructuras de Datos y Objetos.

Numero de edición: 4ta edición.
Editorial: Mc Graw Hill.
Autor: Luis Joyanes Aguilar.

Libro: Fundamentos de Sistemas Digitales.

Numero de edición: 9na edición.
Editorial: Pearson.
Autor: Thomas L. Floyd.

Libro: LabVIEW, Entorno grafico de programación.

Numero de edición: 2da edición.
Editorial: Marcombo.
Autores: José Rafael Lajara Vizcaíno y José Pelegrí Sebartia.

Libro: Sistemas digitales: Principios y Aplicaciones.

Numero de edición: 10ma edición.
Editorial: Pearson
Autores: Ronal J. Tocci, Neal S. Widmer y Gregory L. Moss.

Otras Referencias:
[Link]

[Link]

Universidad de Guadalajara CUCEI 65 Laboratorio de Instrumentación virtual