You are on page 1of 82

LabView + Arduino

Gua de Iniciacin

Por:CarlosA.GuzmnHdez.

IngenieroElectrnico

Julio del 2012


LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

PREFACIO

Hoy en da estamos rodeado de tecnologa, pero desconocemos como lograr interactuar


con ella, la idea que me llev a realizar este material fue la preocupacin de que los
estudiantes requieren de una herramienta de bajo costo para realizar la lectura y control
de los equipos electrnicos que les rodea, y en vista que da a da va creciendo el auge
de los dispositivos de adquisicin de datos, me resulta grato el poder mostrar como
utilizar la herramienta de Arduino como elemento de Adquisicin de datos, un DAQ,
como se le conoce por sus siglas del ingls (Data Adquisition), que no es mas que
interactuar con el entorno fsico tomando muestras y convirtiendo stas en valores digital
para su posterior proceso dentro del computar.

Adems, con la utilizacin del Arduino, podemos obtener resultados sorprendentes a


bajo costo y, la comunicacin con el entorno grfico de LabView es muy simple gracias a
las labores de diseo de Sam Kristoff de National Instruments, quien escribi el Sketch
bsico para el Arduino, el cual permite la interaccin con LabView, el archivo se conoce
como LVFA_Firmware el cual puede ser modificado y redistribuido gratuitamente, el
archivo original puede ser descarga de la pgina de National Instruments en
http://www.ni.com/arduino.

2
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

ndice de contenido
PREFACIO.........................................................................................................................................2
Qu es el Arduino?...........................................................................................................................4
1- Conociendo el mdulo que ser en lo adelante nuestra herramienta de interaccin con el
entorno fsico.................................................................................................................................4
Hardware.......................................................................................................................................4
Resumen........................................................................................................................................6
Esquema de diseo de referencia y esquemtico...........................................................................6
Fuente de alimentacin..................................................................................................................7
Memoria.........................................................................................................................................8
Entradas y Salidas..........................................................................................................................8
Comunicacin................................................................................................................................9
Programacin...............................................................................................................................10
Automtica (Software) Restablecer (automatic software reset)..................................................11
Proteccin USB contra sobrecorriente........................................................................................12
Caractersticas fsicas..................................................................................................................12
Shields.........................................................................................................................................14
Hardware de terceros recomendado............................................................................................14
2- LabView.......................................................................................................................................15
2.1 Conociendo el entorno grfico para el Arduino.....................................................................16
2.2 Empezando con el Arduino....................................................................................................21
3- Ejercicios propuestos...................................................................................................................29
3.1 Encendiendo y apagando un led desde el LabView..............................................................29
Pasos para Instalar el Arduino en LabView.................................................................................32
3.2- Encendiendo y apagando multiples led desde el LabView..................................................34
3.3 Control de encendido y apagado de los LED con matrix constante......................................37
3.4 Interactuando con las Entradas Digitales...............................................................................40
3.5 Control del encendido y apagado local remoto..................................................................43
3.6 Control de Entrada Analgica................................................................................................46
3.7 Control de Entradas Analgicas multiples.............................................................................48
3.8 Control de LED RGB segn paleta de colores......................................................................50
3.9 Control del LED RGB con los potenciometros del mdulo..................................................52
3.10 Generando Tonos con el Arduino-LabView........................................................................55
3.11 Steper Motor y Servo Motor................................................................................................56

3
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Qu es el Arduino?
1- Conociendo el mdulo que ser en lo adelante nuestra herramienta de
interaccin con el entorno fsico.

Segn la descripcin de la pgina oficial de Arduino http://www.arduino.cc/es/, Arduino


es una plataforma de electrnica abierta para la creacin de prototipos basada en
software y hardware flexibles y fciles de usar. Se cre para artistas, diseadores,
aficionados y cualquiera interesado en crear entornos u objetos interactivos.

Arduino puede tomar informacin del entorno a travs de sus pines de entrada de toda
una gama de sensores y puede afectar aquello que le rodea controlando luces, motores
y otros actuadores. El microcontrolador en la placa Arduino se programa mediante el
lenguaje de programacin Arduino (basado en Wiring) y el entorno de desarrollo Arduino
(basado en Processing). Los proyectos hechos con Arduino pueden ejecutarse sin
necesidad de conectar a un ordenador, si bien tienen la posibilidad de hacerlo y
comunicar con diferentes tipos de software (p.ej. Flash, Processing, MaxMSP).

Las placas pueden ser hechas a mano o compradas montadas de fbrica; el software
puede ser descargado de forma gratuita. Los ficheros de diseo de referencia (CAD)
estn disponibles bajo una licencia abierta, as pues eres libre de adaptarlos a tus
necesidades.

Arduino recibi una Mencin Honorfica en la seccin Digital Communities de la edicin


del 2006 del Ars Electrnica Prix. El equipo Arduino (Arduino team) es: Massimo Banzi,
David Cuartielles, Tom Igoe, Gianluca Martino, and David Mellis. Credits

Hardware

La placa actual utilizada es la Arduino UNO, Arduino es una placa electrnica basada en

4
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

el ATmega328. Cuenta con 14 entradas / salidas digitales pines (de los cuales 6 pueden
ser utilizados como salidas PWM), 6 entradas analgicas, un oscilador de cristal de 16
MHz, una conexin USB, un conector de alimentacin, una cabecera de ICSP, y un
botn de reinicio. Contiene todo lo necesario para apoyar a la micro, slo tiene que
conectarlo a un ordenador con un cable USB o el poder con un adaptador AC-DC o la
batera para empezar.

El UNO difiere de todas las placas anteriores en que no utilizan el chip controlador USB
FTDI a serie. Por el contrario, cuenta con la Atmega16U2 (Atmega8U2 hasta la versin
R2) programado como un convertidor de USB a serie.

Revisin 2 de la placa Uno tiene una resistencia tirando de la lnea HWB 8U2 a tierra,
por lo que es ms fcil de poner en modo DFU .

Revisin 3 de la placa tiene las siguientes nuevas caractersticas:


1,0 pinout: aade pines SDA y SCL que se encuentran cerca al pin AREF y dos
pasadores de otros nuevos que se pongan cerca del pin de RESET, el IOREF que
permiten a los escudos de adaptarse a la tensin proporcionada por la junta. En el
futuro, escudos sern compatibles tanto con la tarjeta que utiliza el regulador, que
operan con 5V y con el Arduino Debido que funcionan con 3.3V. El segundo es un
pin no est conectado, que se reserva para usos futuros.
REINICIAR (RESET) ms fuerte en el circuito.
Atmega 16U2 reemplaza el 8U2.

"Uno" significa uno en italiano y se nombra para celebrar el prximo lanzamiento de


Arduino 1.0. El Uno y la versin 1.0 ser la versin de referencia de Arduino, de seguir
adelante. El Uno es el ltimo de una serie de placas Arduino USB, y el modelo de
referencia para la plataforma Arduino, una comparacin con las versiones anteriores,
consulte el ndice de la placa Arduino .

5
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Resumen

Microcontroladores ATmega328
Voltaje de funcionamiento 5V
Voltaje de Entrada (recomendado) 7-12V
Voltaje de entrada (los lmites) 6-20V
Digital pines I / O 14 (6 de las cuales proporcionan una salida PWM)
Pines de entrada analgica 6
Corriente de I / S de CC Pin 40 mA
De corriente continua de 3,3 V Pin 50 mA
32 KB (ATmega328) de los cuales 0,5 KB utilizado
Memoria Flash
por gestor de arranque
SRAM 2 KB (ATmega328)
EEPROM 1 KB (ATmega328)
Velocidad de reloj 16 MHz

Esquema de diseo de referencia y esquemtico

EAGLE archivos: arduino-uno-Rev3-reference-design.zip (NOTA: trabaja con Eagle 6.0 y


posteriores) http://arduino.cc/en/uploads/Main/arduino_Uno_Rev3-02-TH.zip

Esquema: arduino-uno-Rev3-schematic.pdf
http://translate.googleusercontent.com/translate_c?
act=url&hl=es&ie=UTF8&prev=_t&rurl=translate.google.com&sl=en&tl=es&twu=1&u=http
://arduino.cc/en/uploads/Main/Arduino_Uno_Rev3-
schematic.pdf&usg=ALkJrhjXgObtG1BCwprXE96AwQc5nlEsnA

Nota: El diseo de referencia Arduino puede utilizar un Atmega8, 168, o 328, los
modelos actuales utilizan una ATmega328, pero una Atmega8 se muestra en el esquema
de referencia. La configuracin de pines es idntico en los tres procesadores.

6
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Fuente de alimentacin

El Arduino UNO puede ser alimentado a travs de la conexin USB o con una fuente de
alimentacin externa. La fuente de alimentacin se selecciona automticamente.

Externo (no USB), el poder puede venir de un adaptador de CA a CC (en la pared) o de


una batera. El adaptador se puede conectar al conector con centro positivo de enchufe
de 2.1 mm en la placa. Cables de la batera se puede insertar en los encabezados de pin
GND y Vin del conector de alimentacin.

La placa puede operar en un suministro externo de 6 a 20 voltios. Sin embargo, si se


suministran con menos de 7V, el regulador de 5V puede suministrar menos de cinco
voltios y la placa puede ser inestable. Si utiliza ms de 12V, el regulador de voltaje se
puede sobrecalentar y daar la placa. El rango recomendado es de 7 a 12 voltios.

Los pines de alimentacin son los siguientes:


VIN. El voltaje de entrada a la placa Arduino cuando se utiliza una fuente de
alimentacin externa (a diferencia de 5 voltios de la conexin USB o de otra
fuente de alimentacin regulada). Usted puede suministrar tensin a travs de
este pin, o, si el suministro de tensin a travs de la toma de poder, acceder a ella
a travs de este pin.
5V. Este pin genera unos 5V regulados por el regulador en el tablero. El tablero
puede ser alimentado ya sea desde la entrada de alimentacin (7 - 12 V), el
conector USB (5V), o el conector de VIN de la placa (7-12V). El suministro de
tensin a travs de los terminales de 5V o 3.3V no pasa por el regulador, y puede
daar la placa. No es aconsejable.
3V3. Un suministro voltios 3,3 generada por el regulador de a bordo. Consumo de
corriente mxima es de 50 mA.
GND. Estacas.

7
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Memoria

El ATmega328 tiene 32 MB (con 0,5 KB utilizados para el gestor de arranque). Tambin


dispone de 2 KB de SRAM y 1 KB de memoria EEPROM (que se puede leer y escribir
con la librera EEPROM ).

Entradas y Salidas

Cada uno de los 14 pines digitales en el Uno se puede utilizar como entrada o de salida,
usando las funciones pinMode(), digitalWrite(), y digitalRead(). Ellos
operan a 5 voltios. Cada pin puede proporcionar o recibir un mximo de 40 mA y tiene
una resistencia interna de pull-up (desconectado por defecto) de 20 a 50 kOhm. Adems,
algunos pines tienen funciones especializadas:
Serie:. 0 (RX) y 1 (TX) Se utiliza para recibir (RX) y transmitir (TX) datos serie
TTL. Estos se encuentran conectadas a los pines correspondientes de la
ATmega8U2 USB-a-chip de serie TTL.
Interrupciones externas: 2 y 3 Estos pines pueden ser configurados para activar
una interrupcin en un valor bajo, un flanco ascendente o descendente, o un
cambio en el valor. Ver la funcin attachInterrupt () para ms detalles.
PWM:. 3, 5, 6, 9, 10 y 11 Proporcionar 8-bits de salida PWM con la funcin
analogWrite ().
SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK) Se trata de los pines de apoyo con
la comunicacin SPI. biblioteca de SPI .
LED: 13 Hay un built-in LED conectado al pin digital 13.. Cuando el pin es de alto
valor, el LED est encendido, cuando el pin es bajo, es apagado.

El Uno tiene 6 entradas analgicas, etiquetados A0 a A5, cada una de las cuales
proporcionan 10 bits de resolucin (es decir 1024 valores diferentes). Por defecto miden
desde el GND a 5 voltios, aunque es posible cambiar el extremo superior de su rango

8
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

con el pin AREF y la funcin analogReference (). Adems, algunos pines tienen
funciones especializadas:
IST: A4 o A5 y pin SDA o SCL pin de soporte de comunicacin con el IST. librera
Wire .
Hay un par de pines adicionales en el tablero:
AREF. Voltaje de referencia para las entradas analgicas. Se utiliza con
analogReference ().
Reset. Lleve esta lnea a LOW para reiniciar el microcontrolador. Normalmente se
utiliza para aadir un botn de reinicio para los SHIELD que bloquean el tablero
UNO.
Vase tambin el mapeo entre los pines de Arduino y puertos ATmega328 . La
asignacin para el Atmega8, 168, y 328 es idntico.

Comunicacin

El Arduino UNO tiene una serie de facilidades para comunicarse con un ordenador, otro
Arduino, u otros microcontroladores. El ATmega328 ofrece comunicacin en serie UART
TTL (5V) de que est disponible en los pines digitales 0 (RX) y 1 (TX). Un ATmega16U2
en los canales de comunicacin a bordo esta serie a travs de USB y aparece como un
puerto COM virtual con el software en el ordenador. El firmware '16U2 utiliza el estndar
de los controladores USB, COM, y no es necesario ningn controlador externo. Sin
embargo, en Windows, un archivo .inf se requiere. El software de Arduino incluye un
monitor serial que permite a los simples datos de texto, ser enviados desde y hacia la
placa Arduino. Los LEDs RX y TX en el tablero parpadea cuando se estn transmitiendo
datos a travs del chip de USB a serie y la conexin USB a la computadora (pero no
para la comunicacin serial en los pines 0 y 1).

Una biblioteca de Software Serial permite la comunicacin serial en cualquiera de los


pines digitales de la UNO.

9
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

El ATmega328 tambin soporta comunicacin I2C (TWI) y SPI. El software de Arduino


incluye una librera Wire para simplificar el uso del bus I2C, consulte la documentacin
para ms detalles. Para la comunicacin SPI, utilice la biblioteca de SPI .

Programacin

El Arduino UNO puede ser programado con el software de Arduino. Seleccione "Arduino
Uno en el men Herramientas> Tablero (de acuerdo con el microcontrolador en el
tablero). Para obtener ms informacin, consulte la referencia y tutoriales .

El ATmega328 en la Arduino UNO viene pre-programado con un gestor de arranque


(bootloader) que le permite cargar nuevos cdigos a la misma sin el uso de un
programador de hardware externo. Se comunica utilizando el protocolo original STK500
(de referencia, los archivos de cabecera C).

Tambin puede pasar por alto el gestor de arranque y el programa del microcontrolador a
travs de la cabecera ICSP (programacin In-Circuit Serial), ver las instrucciones para
los detalles.

El ATmega16U2 (o 8U2 en los REV1 y REV2 tablas) el cdigo fuente est disponible y el
firmware. El ATmega16U2 / 8U2 est cargado con un cargador de arranque DFU, que
puede ser activado por:
En placa Rev1: conectar el puente de soldadura en la parte posterior de la placa
(cerca del mapa de Italia) y luego reiniciar el 8U2.
En Rev2 o placas posteriores: hay una resistencia que tirando de la lnea de
8U2/16U2 HWB a tierra, por lo que es ms fcil poner en modo DFU.

10
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Automtica (Software) Restablecer (automatic software reset)

En lugar de exigir una presin fsica del botn de reinicio antes de realizar una carga, el
Arduino UNO est diseado de una manera que le permite ser restaurada mediante el
software que se ejecuta en un ordenador conectado. Una de las lneas de control de flujo
de hardware (DTR) de la ATmega8U2/16U2 est conectado a la lnea de reposicin del
ATmega328 travs de un condensador 100 nanofaradios. Cuando esta lnea aterriza
(llevada a cero), la lnea de reset cae lo suficiente como para restablecer el chip. El
software de Arduino utiliza esta capacidad que le permite cargar el cdigo con slo
pulsar el botn de subida en el entorno Arduino. Esto significa que el gestor de arranque
puede tener un tiempo de espera ms corto, como la reduccin puede ser bien
coordinada con el DTR al inicio de la carga.

Esta configuracin tiene otras implicaciones. Cuando el UNO se conecta a un ordenador


con Mac OS X o Linux, se pone a cero cada vez que se realiza una conexin a ella
desde el software (a travs de USB). Para el siguiente medio segundo ms o menos, el
gestor de arranque se est ejecutando en la ONU. Mientras que est programado para
ignorar los datos con formato incorrecto (es decir, nada, adems de un proceso de carga
del nuevo cdigo), que interceptar los primeros bytes de datos enviados a la placa
despus de abrir una conexin. Si un esquema que se ejecuta en la placa recibe una
configuracin en tiempo u otros datos cuando se inicia por primera vez, asegrese de
que el software con el que se comunica espera un segundo despus de abrir la conexin
y antes de enviar estos datos.

El UNO contiene una pista que se puede cortar para deshabilitar la auto-reset. Las
almohadillas en cada lado de la huella puede ser soldadas entre s para volver a habilitar
la misma. Ha marcado "RESET-ES". Tambin puede ser capaz de desactivar el reinicio
automtico mediante la conexin de una resistencia de 110 ohmios de 5V a la lnea de
reset, ver este vnculo del foro para ms detalles.

11
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Proteccin USB contra sobrecorriente

El Arduino UNO tiene un polifusible reajustable que protege a los puertos USB de tu
ordenador de cortos circuitos y de sobrecorriente. Aunque la mayora de las
computadoras ofrecen su proteccin interna, el fusible proporciona una capa adicional de
proteccin. Si hay ms de 500 mA aplicados al puerto USB, el fusible automticamente
corta la conexin hasta que el cortocircuito o una sobrecarga se haya eliminado.

Caractersticas fsicas

La longitud mxima y la anchura de la placa UNO son 2,7 y 2,1 pulgadas


respectivamente, con el conector USB y conector de alimentacin se extiende ms all
de la dimensin anterior. Cuatro orificios para tornillos permite que la tarjeta sea sujetada
a una superficie o caja. Obsrvese que la distancia entre los pines digitales 7 y 8 es de
160 milsimas de pulgada (0,16 "), no un mltiplo par de la separacin 100 milsimas de
los otros pines.

Hay multitud de diferentes versiones de placas Arduino. La predecesora placa bsica, el


Duemilanove, usa Atmel ATmega328. La anterior Diecimila, y las primeras unidades de
Duemilanove usaban el Atmel ATmega168, mientras que las placas mas antiguas usan
el ATmega8. El Arduino Mega esta basado en el ATmega1280.

Nota: Los diseos y esquemas de Arduino se distribuyen bajo licencia Creative


Commons Attribution-ShareAlike 2.5. Mira Quieres hacer un Arduino? para indicaciones
sobre como producir tu propio hardware.
Placas de E/S
Duemilanove - Esta es la penltima revisin de la placa Arduino USB bsica. Se
conecta al ordenador con un cable USB estndar y contiene todo lo necesario
para programar la placa. Se puede ampliar con gran variedad de shields: placas
de extensin con funcionalidades especificas.

12
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Diecimila - Esta es la revisin anterior de la placa USB bsica.


Nano - Una placa compacta diseada para usarse directamente en placas de
desarrollo, el Nano se conecta al ordenador con un cable Mini-B USB.
Mega - Mas grande y potente placa Arduino, compatible con los shields de
Duemilanove y Diecimila.
Bluetooth - El Arduino BT contiene un modulo bluetooth que permite comunicarse
y programarse sin cables. Es compatible con los shields de Arduino.
LilyPad - Diseado para aplicaciones sobre prendas, esta placa puede ser cosida
a la ropa y es de color purpura y con un diseo con estilo.
Fio - Diseada para aplicaciones inalmbricas. Incluye un zcalo para XBee, un
conector para bateras LiPo y electrnica para cargar bateras.
Mini - La placa Arduino mas pequea. Funciona perfectamente en una placa de
desarrollo o en aplicaciones donde el espacio es primordial. Se conecta al
ordenador usando el adaptador Mini USB.
Adaptador Mini USB - Esta placa convierte una conexin USB en 5 voltios , toma
tierra, lineas TX y RX que puedes conectar al Arduino Mini o a otro micro
controlador.
Pro - Esta placa esta diseada para aquellos que quien dejar la placa incrustada
en el proyecto: es mas barata que la Diecimila y se puede alimentar fcilmente
con bateras. Pero requiere de componentes extra y montaje.
Pro Mini - Como la Pro, la Pro Mini esta diseada para usuarios avanzados que
requieren de bajo coste, menor tamao y dispuestos a un poco de trabajo extra.
Serial - Placa bsica que utiliza una interfaz RS232 como comunicacin con el
ordenador para programar o intercambiar datos. Esta placa es fcil de montar
incluso como ejercicio didctico.
Serial a una cara (Single Sided) - Esta placa esta diseada para ser trazada y
montada a mano. Es un poco mas grande que la Diecimila, pero compatible con
los shields.

13
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Shields

Los Shields son placas que se colocan encima de la placa Arduino y para ampliar una
nueva funcin para que sea controlada desde Arduino, para controlar diferentes
aparatos, adquirir datos, etc.
Shield Xbee - Este shield permite conectar inalmbricamente varios Arduino a
distancias de 100 pies en edificios y 300 pies en el exterior usando el mdulo
Maxstream Xbee Zigbee.
Shield Motores- Este shield permite a Arduino controlar motores elctricos de
corriente continua, servos y motores paso a paso y leer encoders.
Shield Ethernet - Este shield permite a una placa Arduino conectarse a una red
Ethernet y tener acceso a y desde Internet.

Hardware de terceros recomendado

Productos de otros que hemos probado y nos gustan, compatibles con el software de
Arduino.
Boarduino de Adafruit Industries. Para usar en placas de desarrollo junto a un
cable FTDI USB-to-TTL-Serie o otro adaptador de USB a serie. Disponible solo el
PCB o en formato de kit.

14
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

2- LabView
LabView no es mas que un entorno grfico que permite adquirir, procesar y controlar
cualquier entorno que haya sido digitalizado por medio de un mdulo de adquisicin de
datos, dichos mdulos pueden ser adquiridos en la National Instruments o de otros
proveedores los cuales brindar hardware y drivers para la interaccin con LabView.

LabView utiliza un lengua de programacin grfico, o sea, que la realizacin del


programa se realiza interconectando iconos que estn previamente configurados y la
personalizacin en funcin de los que se requiere ejecutar es mnimo, no obstante
existen una gran variedad de estos iconos, comnmente llamado en el entorno grfico
como vi estndar, otros por ser mas complejos vi express y segn la jerarqua de la
configuracin vi para manejos de DLL.

Adems, LabView posee una vasta librera de herramientas que permite la programacin
gil y detallada que van desde funciones muy bsicas como las aritmticas y lgicas
hasta manipulacin de funciones de libreras dinmicas (DLL) y especiales (FURIER,
MATLAB, VISION, MOTION, SOUND, VIBRATION, ETC.),

Aqu nos enfocaremos al uso de la librera especializada para Arduino, la cual puede ser
descargada de la pgina de National Instruments, detallaremos de forma clara y sencilla
las funciones que estn disponibles para la adquisicin, proceso y control de los pines
que posee el Arduino, cabe destacar que el uso de las funciones de la librera pueden
trabajar en tres mdulos de Arduino (UNO, Dimuelanove w/Atmega 328 y Mega 2560),
aqu nos enfocaremos en el Arduino UNO, por su alto desempeo y que adems es mas
moderno que los anteriores.

La forma de comunicacin con el mdulo Arduino, LabView lo puede realizar de tres


maneras que pueden ser USB/Serial, XBEE y BlueSmirf (Bluetooth). Nosotros
utilizaremos el USB/Serial.

15
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

2.1 Conociendo el entorno grfico para el Arduino


Lo primero que debemos hacer antes de empezar a disear nuestro programa en
LabView es grabarle el Sketch1 correspondiente al Arduino que permita que el
computador lo reconozca como un dispositivo de adquisicin de datos.

Para esto, solo tenemos que grabarle el Sketch cuyo nombre es LVIFA_Base.pde, el
cual se encuentra en la ruta de la carpeta de National Instruments, se compila y se graba
utilizando el IDE de Arduino que se puede descargar de la pgina oficial de Arduino
http://www.arduino.cc, luego debemos tener el paquete de drivers de LabView llamado
VISA completamente instalado y como es lgico el LabView a partir de la versin 9.0 en
adelante con su licencia.

Una vez realizado el proceso de grabado del Sketch podemos empezar a conocer los
diferentes iconos para realizar los ejemplos y practicas que se plantearan a los largo de
este material.

Vamos a ver las diferentes pantallas que estn bajo la librera de Arduino, empezando
por la pantalla principal donde se pueden apreciar las funciones de inicio (Int), cerrado
(Close), seales (Low Level), sensores (Sensors), utileras (Utility) y ejemplos
(Examples)

1 El Sketch a grabar se encuentra en la pgina de www.ni.com y tambin en la seccon de anexos

16
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

En la seccin de seales cabe destacar que las funciones all expuestas son para el
control de las diferentes entradas y salidas que posee el Arduino, en la parte digital
contiene 14 pines de entradas y salidas digitales, de los cuales 6 pueden ser
configurados para salidas analgicas (PWM), pines 3, 5, 6, 9, 10 y 11 con seales que
se controlan con valores de 0 a 255, tambin tiene 6 entradas analgicas, adems, de
las seales de VCC y GND, as como de AREF (Valor de referencia analgicas para
ajuste externo, y RESET para el provocar el reinicio del mdulo.

Las funciones son: Analog Read Pin, Analog Read Port, Set Digital Pin Mode, Digital
Read Pin, Digital Read Port, Digital Write Pin, Digital Write Port, PWM Write Pin, PWM
Configure Port, PWM Write Port, Tone, Bus Specific (I2C, SPI), Analog Sampling
(Continuous Aquisition On, Continuous Aquisition Off, Continuous Aquisition Sample, Get
Finite Analog Sample.

17
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

En la seccin de los sensores podemos hallar algunos vi express, los mas tpicos de
estos:

Entre los vi de la seccin de sensores tenemos: Thermistor Read, Photocell Read, IR


Sensor Read, RGB LED Configure, RGB LED Write, Seven Segment Configure, Seven
Segment Write Char, Seven Segment Write String, Thumbstick Config, Thumbstick Read,
BlinkM, Servo Stepper Motor y LCD.

18
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

En la pantalla de funciones de utileras encontramos Packetize, Send Receive, Calculate


Update Rates, Get Timing Data, y Helpers.

En la de ayudas tenemos algunas herramienta que nos facilita la interaccin con el


Arduino, Auto Detect Arduino, Check For Pin Out Of Range, Wait For Bytes Angle Mag To
RGB, Thumbstick Value To Angle, Cycle RGB Colors.

19
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

En la seccin de ejemplos encontramos una variedad de ejercicios resueltos que nos


muestras como debemos interactuar con el Arduino mediante LabView.

Entre los ejemplos aqu mostrados estn: Analog Read Pin Example, Thermistor Read
Example, Photocell Example, Tone Example, RGB LED Example, Seven Segment
Display Example, Thumb Stick RGB LED Example, BlinkM Example, Servo Example,
Light Show Example, IR Sensor Example, Stepper Motor Example, LCD Event Based
Example, LCD Hello World 4-bits Example, Continuous Sampling Example, Finite Analog
Sampling Example.

20
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

2.2 Empezando con el Arduino

Ahora empezaremos a conocer las herramientas principales para poder inicializar al


Arduino dentro del entorno de LabView, para esto se dispone de dos vi que son de
carcter obligatorio, uno es el de inicio y el otro es el de cierre.

Estos vi, estn diseados para que el LabView pueda activar e iniciar al Arduino antes de
poder configurarle cualquier pin, ya sea ste de entrada o de salida segn el caso, y el
otro vi es el de cierre, que garantiza que el Arduino haya cerrado debidamente antes de
que el LabView finalice el programa que se esta ejecutando.

Para familiarizarnos mejor con estos vi, los veremos con mayor detalle:

21
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

El mdulo de inicializacin tiene una series de entradas que vienen pre-configuradas


para poder activar al Arduino, empezando por la de VISA resource, sta entrada no
permite identificar el puerto Serial donde se encuentra el Arduino, recordando que el
protocolo de comunicacin del Arduino es Serial y que posee una interfaz USB para
poder comunicarse con los Pcs modernos que carecen del puerto serial, esto nos ayuda
a poder conectarnos con el Arduino sin necesidad de poseer un puert Serial fsico
instalado en la PC.

La siguiente es la de Baud Rate que como dijimos es Serial hay que configurarla a
115200 bps para que el LabView pueda negociar la comunicacin con l.

Tenemos tambin, el Board Type, este me permite seleccionar el mdulo de Arduino


que usaremos con el LabView, al momento la herramienta de comunicacin nos permite
seleccionar al Arduino UNO, el Dimuelanove w/Atmega328 y al MEGA 2560.

El Bytes Per Packet controla la cantidad mxima de bytes que pueden ser enviados en
un paquete hacia el Arduino.

Connection Type seala la forma como nos comunicaremos con el entorno del Arduino,
entre las conecciones tenemos la USB/Serial, XBEE y BlueSmirf (Bluetooth), para los
fines prcticos la comunicacin USB/Serial es la que viene por defecto con el Arduino, no
obstante este puede ser accesado utilizando accesorios (Shields), que permiten que
adopte el medio mas propicio para la comunicacin con el Arduino.

Error in es una entrada para sincronizar seales de errores desde otras secciones.

Arduino Resource nos habilita la comunicacin de datos entre Arduino-LabView.

Error out es una salida para sincronizar seales de errores hacia otras secciones.

22
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Para el mdulo de cierre, este nos permite cerrar el Arduino y posterior cerrar el
programa que se ha ejecutado en LabView.

Arduino Resource entrega las caractersticas para garantiza el cierre del puerto donde
se encuentra conectado el Arduino antes de finalizar el programa.

Error in es una entrada para sincronizar seales de errores desde otras secciones.

Error out es una salida para sincronizar seales de errores hacia otras secciones.

Ahora veremos los mdulos bsicos de control de puertas tanto analgicas como de las
digitales, para conocimiento, las entradas analgicas como son entradas, siempre estn
configuradas como tal, por esa razn no hay que configurarla para dichos fines, sin
embargo, las digitales como son bidireccionales hay que previamente configurarle la
condicin que tendr en el sistema, no obstante, stas vienen pre-configuradas como
salidas, pero an as es recomendable la configuracin de la misma.

Empezaremos con la parte Digital donde tendremos un vi para la configuracin del modo
(Entrada o Salida), y los vi de lectura digital.

23
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

El primero en el de ajuste de los pines digitales Set Digital Pin Mode, este se utiliza
para especificar a cual pin se le asignar la condicin de Input o Output, en el segundo
lectura de pin digital Digital Read Pin, este nos permite conocer el estado del pin de
entrada seleccionado y entregarnos su valor (0 1). y el tercero lectura de puerto digital
Digital Read Port, este se utiliza para poder leer todos los pines de salidas digital que
posee el Arduino, si todos los pines estn habilitados como salidas estos se leern
desde el Pin 2 hasta el Pin 13, recordando que los Pines 0 y 1 estn reservados para
la comunicacin Serial entre el Arduino y LabView.

24
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

En los vi de escritura digital tenemos los siguientes:

Aqu podemos observar, que tenemos dos vi que controlan la escritura digital, el primero
es el escritura digital a un pin Digital Write Pin, este seleccionando el pin correspondiente
desde el 2 hasta el 13, nos permite colocarle un 0 1, dependiendo si la condicin es
LOW o HIGH. En el segundo se controla todo el puerto de los pines de salidas digitales
si todos estn configurados as, recordando que ser desde el pin 2 hasta el pin 13,
reservando los pin 0 y 1 para la comunicacin Serial.

Para el caso de las entradas Analgicas, recordaremos que estas estn por defecto
configuradas como entradas, por tal razn no es necesario la configuracin de los pines
para tales fines.

De acuerdo a la arquitectura del Arduino los pines de entrada analgicos estn


identificados desde el A0 hasta el A5, en Arduino se representan desde 0 hasta 5, puesto
que el reconoce internamente por el interprete que se trata de las seales analgicas al
momento de colocarle la instruccin correspondiente para esos fines, sin embargo, en la

25
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

programacin del programa o Sketch del Arduino los pines analgicos se encuentran
desde el 14 al 19, pero esto es transparente para el usuario final.

Mdulos de lecturas analgicas:

En la lectura analgicas, tenemos dos maneras una es seleccionando el pin de entrada


analgico que deseamos leer Analog Read Pin, o leyendo todos los puertos analgicos
existentes en el mdulo Analog Read Port.

Una observacin importante que se debe conocer, la salida que nos da este mdulo es
una seal expresada en rango de tensin, o sea, esta seal es flotante de doble
precisin por tanto se expresa en funcin de los 5 voltios aplicados comnmente al
sistema en la forma 0.000E0.

Si se requiere que se exprese de otra forma habr que darle el tratamiento de


conversin adecuado para tales fines.

26
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Para lo que representara lo que seria la escritura analgica, el Arduino posee dentro de
sus pines digitales algunos que pueden ser utilizados para salidas analgicas, estos
pines estn representados con el smbolo (~), el cual nos muestra que este pin digital
puede ser por configuracin como salida analgica entregando una seal que se
encuentra dentro del rango de 0 a 255 bits, cuya interpretacin es una seal en forma de
PWM a la salida del pin.

27
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

El primero permite configurar los pines que sern utilizados como salidas analgicas
para poder ser controlados desde el LabView PWM Configure Port, recordando que
estos no conservan un orden dentro del sistema, an as, nos permite configurar 3 pines
a la ves. Los dems son para colocarle el valor en PWM de 0 a 255 bits para la
interpretacin segn el nivel en el pin de salida correspondiente. El segundo lo hace por
pin PWM Write Pin y el tercero por todo los pines seleccionados PWM Write Port.

Nota: esta seal es de 0 a 255, se debe tener cuidado de no conectar directamente las
entradas analgicas del mdulo de entrada a las de salidas analgicas, puesto que no
son del mismo tipo ni rango.

Hasta ahora ya conocemos los vi y mdulos bsicos que se necesitan para controlar el
Arduino desde LabView.

En el siguiente captulo trataremos en detalle una serie de problemas paso a paso, los
cuales nos dar una idea acabada, de lo que podemos hacer con el LabView utilizando
al Arduino como un DAQ.

En cada problema se detallar en lo posible, los pasos a seguir dentro del entorno del
LabView para realizar cada ejercicio sin que haya trabas o dudas para su realizacin.

28
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

3- Ejercicios propuestos2
3.1 Encendiendo y apagando un led desde el LabView
El primer ejercicio que veremos lo bsico para encender un led en un pin cualquiera de
salida digital del Arduino.

Esta es la apariencia que tendr nuestro programa en LabView, como se observa esto
es el panel frontal donde se ha colocado un interruptor para el encendido y apagado del
pin digital, el control numrico Arduino Port es el mismo Visa Resource con el nombre
cambiado para poder hallar el puerto donde se encuentra el Arduino conectado.

Esta parte es la que haremos en la seccin del diagrama en bloque, y lo realizaremos


siguiendo los pasos que a continuacin detallaremos para la fcil ubicaciones de los
mdulos y comandos que se requieren para realizar el ejercicio.

2 Los ejercicios propuestos aqu estn realizados en funcin del mdulo shield diseado para acompaar este
material, el cual est detallado su esquemtico en la seccin de anexos

29
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Pasos para realizar el ejercicio propuesto como ejercicio 1:


1- Creamos un nuevo vi en LabView
2- Cambiamos a pantalla y nos vamos a la ventana del diagrama en bloques (Block
Diagram), con el cursor del mouse o presionando la combinacin de teclas Ctrl + e.
3- Dando clic derecho abrimos la seccin Funtions del LabView y entramos en la
seccin de Arduino y le damos clic al icono Init y lo colocamos en el diagrama en
bloques.
4- Hacemos los mismo otra vez y sacamos el icono Close.
5- Nuevamente hacemos lo mismo otra vez y entramos a la sub-seccin Low Level y
sacamos los iconos Set Digital Pin mode y Digital Write Pin y lo colocamos en el
diagrama en bloques como se muestra en la figura.
6- Ahora nos vamos a la seccin Express>Exec Control> y sacamos el mdulo While
Loop, y cuando le demos clic arrastramos el mouse para expandir el while loop como
se muestra en la figura.
7- Procederemos a realizar las interconexiones correspondientes en el diagrama.
8- El icono de Arduino Port es el mismo de Visa Resource con el nombre de la etiqueta
cambiado, para sacarlo colocamos el cursor de mouse sobre el pin del mdulo de Init
donde dice VISA Resource y dando un clic derecho seleccionamos Create a Control.
9- Lo mismo para el Pin Mode del mdulo Set Digital Pin Mode.
10- Para la constante 13 se realiza los mismo pasos pero se selecciona Constant en la
seccin de Create.
11- En icono Estado de Salida debe ser colocado en la pantalla de Panel Frontal
(Frontal Panel), dando clic derecho nos aparece la seccin de Control y seleccionando
Express>Buttons seleccionamos el Toggle Switch.
12- Volvemos al diagrama en bloques y sacamos ahora el conversor booleano a 0 y 1
que se encuentra en Funtion>Programmings>Boolean y damos clic sobre el icono
Bool to (0, 1) y lo colocamos y cableamos segn se muestra en la figura.
13- El Simple Error Handler esta en Funtion>Programmings>Dialog & User
Interface.
14- Al While Loop hay que colocar un control booleano dando clic derecho sobre la

30
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

entrada del control del loop esquina inferior derecha y crendole un control, este es el
mismo que veremos en el panel frontal como STOP. Importante cuando se ejecuta
cualquier programa que interacta con el Arduino es Obligatorio que el mismo sea
apagado utilizando la tecla de control STOP que fue colocado para esos fines y no
utilizar el stop que trae el sistema en el men arriba, puesto que esto realiza al
programa una parada brusca (Abort Execution), o sea, una parada de emergencia
forzada, impidiendo que se cierre correctamente el Arduino y esto puede causar
posteriormente fallas en la comunicacin entre el LabView y Arduino, forzando a
tener que reiniciar tanto al Arduino como al LabView.

Ahora solo nos queda configurar que el puerto donde se encuentra el Arduino este
debidamente colocado donde dice Arduino Port y procederemos a realizar la ejecucin
del programa, si todo est correcto se debe esperar que el Arduino inicialice y empiece a
interactuar con el LabView, luego con el switch procederemos a encender y apagar el pin
previamente configurado en nuestro sistema, para este ejercicio estar en el pin 13.

31
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Pasos para Instalar el Arduino en LabView.


1- Colocamos el Arduino en el Puerto USB.
2- Cuando nos pida el Driver lo enviamos a la carpeta drivers que esta dentro de la
carpeta del Arduino y procedemos a verificar que se instale correctamente.
3- Luego ejecutamos el IDE del Arduino (versin 1.0.1), abrimos el Sketch del Programa
de interfaz para la comunicacin entre LabView y Arduino, y buscamos la carpeta
LVIFA_Base y seleccionamos el archivo con el mismo nombre LVIFA_Base.
4- Lo verificamos presionando sobre el icono de verificar.
5- En la pestaa de Herramientas> Puerto Serial verificamos que este el COM donde
el Arduino esta conectado, luego el la seccin Tarjetas se verifica que este marcado el
Arduino Uno; luego se carga el programa al Arduino presionando el icono

Una vez realizado todo esto procederemos a configurarlo dentro del entorno del
LabView.
Para esto haremos lo siguiente:
1- Ejecutaremos el Measurement & Automation Explorer,

una vez abierto nos vamos a la seccin My System>Serial & Parallel y seleccionamos
el Puerto COM donde se instal el Arduino bajo Windows,

32
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

lo abrimos y en la seccin VISA Alias on My System le ponemos el nombre Arduino,


luego cambiamos la ventana a la de Port Settings y configuramos el Baud Rate a
115200 lo dems se mantiene igual, Validamos y salvamos y cerramos.

Hasta aqu, se ha instalado y configurado nuestro Arduino y solo debemos en LabView


seleccionarlo en el Visa Resource y ejecutar nuestro programa.

33
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

3.2- Encendiendo y apagando multiples led desde el LabView


En este ejercicio veremos como configurar varios pines como salida y controlaremos los
LED conectados en los pines 10, 11, 12 y 13 del mdulo conectado al Arduino.

La imagen muestra el entorno del rea del Panel Frontal en LabView, ntese que esto es
un arreglo con Switch de control duplicado 4 veces.

El icono de STOP, es el correspondiente al de control del While Loop del programa con
una variacin del color de fondo en modo OFF, para realizarlo le dan clic derecho sobre
el icono y selecciona Properties, y en la casilla Off le damos click y le colocamos el color
de nuestra preferencia y adems, le ponemos en Off text el nombre que deseemos.

Lo mismo con los Switch, podemos personalizarlos a nuestro gusto, algo importante
cuanto se agrupan elementos de igual tipo dentro de un arreglo el label es nico, si
cambian uno los dems asumen el mismo, para que salga el texto deseado deben abrir
la herramienta de paleta y colocar etiquetas individuales en cada interruptor para poder
identificarlos.

Arduino Port viene del icono de Init cuando se crea. Refierace a la gua del eje.1.

34
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Diagrama en bloques del ejercicio 2

35
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

En este ejercicio el Case Structure esta configurado igual como se muestra para el caso
True solo que en el False el valor de entrada sera 0, de este modo la sentencia
cuando sea verdadera escribir un 1 al pin en cuestin o un 0 si la conticin es falsa.

Ntese que en este ejercicio se ha utilizado un For Loop para poder configurar los pines
que se utilizarn, y adems, otro dentro del While Loop para ir seleccionando a cual de
los pines se le escribir el 1 si se da el caso o de lo contrario sera un 0.

El ejercicio cuando se ejecuta, va monitoreando el estado del interruptor seleccionado y


dependiendo si la condicin es verdadera o falsa, procede a realizar la activacin o no
del LED asisgnado al mismo.

Las funciones se encuentran en la seccin Programming y Arduino. Entre las funciones


que utilizamos para este ejercicio estn:
Init Funtions>Arduino
Close Funtions>Arduino
Set Digital Pin Mode Funtions>Arduino>Low Level
Digital Write Pin Funtions>Arduino>Low Level
Simple Error Handler Funtions>Programming>Dialog & User Interface
For Loop Funtions>Programming>Structures
While Loop Funtions>Programming>Structures
Add Funtions>Programming>Numeric
Subtract Funtions>Programming>Numeric
Index Array Funtions>Programming>Array
Case Structure Funtions>Programming>Strutures
Wait until Next ms Multiple Funtions>Programming>Timing
Unbundle By Name Funtions>Programming>Cluster, Class, & Variant
To Unsigned Byte Interger Funtions>Programming>Numeric>Conversion
Or Funtions>Programming>Boolean
Numeric Constant Funtions>Programming>Numeric

36
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

3.3 Control de encendido y apagado de los LED con matrix constante


En este ejercicio vamos a encender y apagar los LEDs con una matrix en forma de
patrones para que se vea de forma secuencial. Recordemos que el control de los LEDs
se realizar por medio de patrones siguiendo la caracteristica de los pines digitales del
Arduino, para esto realizaremos una matrix constante de cuatro bloques con una
constante numrica interna y le activamos el Radix a binario para poder colocarle los bits
que iremos encendiendo recordando que el bit menos significativo se encuentra a la
derecha.

Esta pantalla es solo una interpretacin para poder seleccionar el Puerto donde esta el
Arduino y poder apagar el mismo.

Recuerden que se debe finalizar el programa presionando la barra de STOP en el


sistema y no realizandole un Break Force por arriba.

37
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Diagrama en bloques del ejercicio 3

38
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Este programa cuando se ejecuta, realiza una secuencia de ir y venir de los LEDs
conectados entre los pines 10, 11, 12 y 13 del mdulo conectado al Arduino, algo
parecido a las luces clsicas del Knight Rider.

Las funciones se encuentran en la seccin Programming y Arduino. Entre las funciones


que utilizamos para este ejercicio estn:
Init Funtions>Arduino
Close Funtions>Arduino
Set Digital Pin Mode Funtions>Arduino>Low Level
Digital Write Port Funtions>Arduino>Low Level
Simple Error Handler Funtions>Programming>Dialog & User Interface
For Loop Funtions>Programming>Structures
While Loop Funtions>Programming>Structures
Add Funtions>Programming>Numeric
Index Array Funtions>Programming>Array
Wait until Next ms Multiple Funtions>Programming>Timing
Unbundle By Name Funtions>Programming>Cluster, Class, & Variant
To Unsigned Byte Interger Funtions>Programming>Numeric>Conversion
Or Funtions>Programming>Boolean
Numeric Constant Funtions>Programming>Numeric
Quotient & Remainder Funtions>Programming>Numeric
Number to Boolean Array Funtions>Programming>Numeric>Conversion

39
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

3.4 Interactuando con las Entradas Digitales


Ahora trataremos las Entradas Digitales, el concepto es el mismo que hemos estado
realizando en ejercicios anteriores, salvo que aqu debemos hacer un bucle de
configuracin para colocarle INPUT a las correspondientes y OUTPUT a las dems.

La pantalla es simblica para el control del Arduino y poder detener el programa cuando
querramos, los pines de entradas que utilizaremos sern el 2, 4, 7 y 8, y los de salidas
sern 10, 11, 12 y 13.

El Case Structure utilizado aqu tiene una modificacin para que permita mas casos, de
tal forma la condiciones no sern verdadero falso sino que a medida que se adicionan
nuevos casos aumentara la lgica y ser del tamao que se le asigne en funcin de de
las condiciones que necesitemos.

Para el caso de la configuracin de inicio, los pines habr que configurarlos uno a uno en
funcin de su condicin en el ejercicio.

40
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Diagrama en bloques del ejercicio 4

41
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Ahora en este ejercicio incorporamos una nueva funcin de entrada digital, esta nos da
una salida de datos de valor entero de 0 1 y debe ser convertido a byte entero para
que el sistema pueda interpretarlo dentro del arreglo.

Cuando ejecutamos el ejercicio a medida que presionamos un switch en el mdulo


observaremos el LED que se le asign encendiendo.

Las funciones se encuentran en la seccin Programming y Arduino. Entre las funciones


que utilizamos para este ejercicio estn:
Init Funtions>Arduino
Close Funtions>Arduino
Set Digital Pin Mode Funtions>Arduino>Low Level
Digital Write Pin Funtions>Arduino>Low Level
Digital Read Pin Funtions>Arduino>Low Level
Simple Error Handler Funtions>Programming>Dialog & User Interface
For Loop Funtions>Programming>Structures
While Loop Funtions>Programming>Structures
Add Funtions>Programming>Numeric
Subtract Funtions>Programming>Numeric
Index Array Funtions>Programming>Array
Build Array Funtions>Programming>Array
Case Structure Funtions>Programming>Strutures
Wait until Next ms Multiple Funtions>Programming>Timing
Unbundle By Name Funtions>Programming>Cluster, Class, & Variant
To Unsigned Byte Interger Funtions>Programming>Numeric>Conversion
Or Funtions>Programming>Boolean
Numeric Constant Funtions>Programming>Numeric

42
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

3.5 Control del encendido y apagado local remoto

El control del encendido y apagado local remoto se realiza mediante el selector de


condicin dentro del programa. Ente mantiene la misma programacin que el ejercicio 4,
agregando la seleccin local remoto.

Como se observa en el panel frontal, aqu tenemos los interruptores remotos y el


selector Local/Remoto para transferir el mando al mdulo o va software del control de
los LEDs en el mdulo.

Recordando que, cuando est remoto solo se podr encender los LEDs del mdulo
mediante los interruptores en el programa y los interruptores en el mdulo quedarn
desactivados y viceversa cuando este local.

43
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Diagrama en bloques del ejercicio 5

44
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Cuando ejecutamos debemos seleccionar el switch en local o remoto, si esta off se


encuentra local y si activamos el interruptor cambia la lgica a remoto permitiendose
controlar desde el programa, el ejercicio a medida que presionamos un switch en el
mdulo observaremos el LED que se le asign encendiendo.

Las funciones se encuentran en la seccin Programming y Arduino. Entre las funciones


que utilizamos para este ejercicio estn:
Init Funtions>Arduino
Close Funtions>Arduino
Set Digital Pin Mode Funtions>Arduino>Low Level
Digital Write Pin Funtions>Arduino>Low Level
Digital Read Pin Funtions>Arduino>Low Level
Simple Error Handler Funtions>Programming>Dialog & User Interface
For Loop Funtions>Programming>Structures
While Loop Funtions>Programming>Structures
Add Funtions>Programming>Numeric
Subtract Funtions>Programming>Numeric
Index Array Funtions>Programming>Array
Build Array Funtions>Programming>Array
Case Structure Funtions>Programming>Strutures
Wait until Next ms Multiple Funtions>Programming>Timing
Unbundle By Name Funtions>Programming>Cluster, Class, & Variant
To Unsigned Byte Interger Funtions>Programming>Numeric>Conversion
Or Funtions>Programming>Boolean
Numeric Constant Funtions>Programming>Numeric
Select Funtions>Programming>Comparison

45
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

3.6 Control de Entrada Analgica

Cuando se manejan las entradas analgicas debemos recordar que las mismas por ser
solo entradas no hay que darles configuracin inicial. Los pines que se pueden utilizar
para tales fines estn reservados en el Arduino y se enumeran desde el A0 al A5.

La salida de datos se expresa en formato entero de 0.000E0 hasta 5.000E0 con sus
margenes de error, dependiendo de la regulacin de la fuente interna del Arduino. No
obstante, podemos manejarla as o convertirla para propositos posteriores.

Vista del panel frontal del programa para visualizar las entradas analgicas.

El escalar bsico es de 0 a 5, pero en funcin del sistema o circuito que se este


controlando, podemos hacerle la conversin necesaria para obtener el resultado
equerido.

Para voltajes majores de 5V, debemos tener cuidado, puesto que podemos daar el
Arduino.

46
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Al ejecutar el ejercicio, solo debemos seleccionar la entrada analgica que deseamos


visualizar y esperamos hasta que refresque la visualizacin.

Las funciones se encuentran en la seccin Programming y Arduino. Entre las funciones


que utilizamos para este ejercicio estn:
Init Funtions>Arduino
Close Funtions>Arduino
Analog Read Pin Funtions>Arduino>Low Level
Simple Error Handler Funtions>Programming>Dialog & User Interface
While Loop Funtions>Programming>Structures
Wait (ms) Funtions>Programming>Timing
Unbundle By Name Funtions>Programming>Cluster, Class, & Variant
Or Funtions>Programming>Boolean
Numeric Constant Funtions>Programming>Numeric

47
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

3.7 Control de Entradas Analgicas multiples

Este es igual que el ejercicio anterior, lo nico que le agregamos es la opcin de poder
visualizar las diferentes entradas de forma individual.

Notese que aqu, se puede personalizar cada visualizador en funcin de la seal que se
requiere capturar, por ejemplo para el voltaje la escala sera en voltios, para temperatura
sera en Celcios, y as dependiendo de la entrada y el circuito que tenga acoplado.

Recordando que los niveles sern siempre de 0 a 5V en formato Interger (enteros), y que
el tratamiento o conversin sera en funcin con el circuito acoplado a la entrada,
valiendonos a veces, de funciones matemticas o leyes conocidas de circuito.

48
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Para identificar las entradas analgicas, en LabView se hace referencia a los pines
desde A0 hasta A5, con los terminos de 0 a 5, puesto que la funcin para lectura
analgicas es nica, no interfiere con las de los pines digitales.

Las funciones se encuentran en la seccin Programming y Arduino. Entre las funciones


que utilizamos para este ejercicio estn:
Init Funtions>Arduino
Close Funtions>Arduino
Analog Read Pin Funtions>Arduino>Low Level
Simple Error Handler Funtions>Programming>Dialog & User Interface
For Loop Funtions>Programming>Structures
While Loop Funtions>Programming>Structures
Case Structure Funtions>Programming>Strutures
Wait (ms) Funtions>Programming>Timing
Unbundle By Name Funtions>Programming>Cluster, Class, & Variant
Or Funtions>Programming>Boolean
Numeric Constant Funtions>Programming>Numeric

49
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

3.8 Control de LED RGB segn paleta de colores

Todos conocemos la paleta de colores, esta nos da una representacin grfica del color
que queremos interpretar en el LED RGB, el cual esta conectado a las salidas digitales
con control de PWM, los pines 5, 6 y 9.

Recordando que el color mostrado y el color en el LED es un aproximado, hay muchas


variantes que hay que tomar en cuenta para lograr el color del pixel que visualimos en la
paleta de colores.

En el mdulo, los pines estan representados en funcin de los colores que posee el LED
y estan conectados para el Rojo = pin 5; Verde = pin 6 y para el Azul = 9. Estos pines
son digitales pero como salida pueden controlarse por medio de ancho de pulso PWM, el
cual varia los rangos desde el 0 a 255.

Para este ejercicio utilizamos una funcin (SubVI) dentro del LabView que procesa la
informacin entregada a los pines configurados y los interpreta en la lgica del PWM de
0 a 255.

50
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Al ejecutar este ejercicio, solo debemos darle un clic al icono de los colores y abrir una
paleta de colores, seleccionamos el color y el programa enviar la interpretacin
correcpondiente para el color visualizarse en el LED.

Las funciones se encuentran en la seccin Programming y Arduino. Entre las funciones


que utilizamos para este ejercicio estn:
Init Funtions>Arduino
Close Funtions>Arduino
RGB LED Configure Funtions>Arduino>Sensors
RGB LED Write Funtions>Arduino>Sensors
Simple Error Handler Funtions>Programming>Dialog & User Interface
While Loop Funtions>Programming>Structures
Numeric Constant Funtions>Programming>Numeric

51
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

3.9 Control del LED RGB con los potenciometros del mdulo

En este ejercicio controlaremos el LED RGB mediante la utilizacin de los


potenciometros instalados en el mdulo, cada potenciometro controlar un color del
LED, mediante el nivel ajustado como referencia al voltaje y convertido este a la escala
de escritura de 0 a 255, podremos aproximarnos a la paleta del ejercicio anterior.

En el panel frontal disponemos de visualizadores numricos para apreciar el valor


asignado de acuerdo a la posicin que tenga el potenciometro.

Recordando que el valor ledo en los potenciometros es del orden de 0 a 5 Voltios,


debemos de convertirlo a un rango compatible con el de la funcin de escritura PWM
que debe estar dentro del rango de 0 a 255.

Para esto, tomamos el valor de entrada y lo dividimos entre el valor de referencia que en
nuestro caso es 5 voltios, luego lo multiplicamos por la constante mxima que tendremos
que ser de 255 y por ltimo lo sometemos a un filtro para que se conserve el rengo de
trabajo de 0 a 255, luego lo convertimos a un rango que el sistema pueda interpretar de
byte.

52
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Diagrama en bloques del ejercicio 9

53
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

al ejecutar el programa luego que inicialice, solo debemos mover los potenciometros y
ajustar al valor que se desee.

Las funciones se encuentran en la seccin Programming y Arduino. Entre las funciones


que utilizamos para este ejercicio estn:
Init Funtions>Arduino
Close Funtions>Arduino
Analog Read Pin Funtions>Arduino>Low Level
PWM Configure Port Funtions>Arduino>Low Level
PWM Write Pin Funtions>Arduino>Low Level
Simple Error Handler Funtions>Programming>Dialog & User Interface
While Loop Funtions>Programming>Structures
For Loop Funtions>Programming>Structures
Case Structure Funtions>Programming>Structures
Numeric Constant Funtions>Programming>Numeric
Divide Funtions>Programming>Numeric
Multiply Funtions>Programming>Numeric
IWait until Next ms Multiple Funtions>Programming>Timing
Unbundle By Name Funtions>Programming>Cluster, Class, & Variant
To Unsigned Byte Interger Funtions>Programming>Numeric>Conversion
Or Funtions>Programming>Boolean
In Range and Coerce Funtions>Programming>Comparison

54
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

3.10 Generando Tonos con el Arduino-LabView

En LabView se dispone de un SubVI para generar tonos, a este


solo hay que configurarle el pin de salida digital con PWM al cual
se conectar el Buzzer. En nuestro caso estar conectado en el
pin 3.

Al ejecutarce el programa, solo debemos ajustar frecuencia y duracin.

Las funciones se encuentran en la seccin Programming y Arduino. Entre las funciones


que utilizamos para este ejercicio estn:
Init Funtions>Arduino
Close Funtions>Arduino
Tone Funtions>Arduino>Low Level
Simple Error Handler Funtions>Programming>Dialog & User Interface
While Loop Funtions>Programming>Structures
Numeric Constant Funtions>Programming>Numeric
Unbundle By Name Funtions>Programming>Cluster, Class, & Variant
Or Funtions>Programming>Boolean

55
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

3.11 Steper Motor y Servo Motor

Los ejercicios de control de Servo motores y motore Paso a Paso son los que estn
propuesto en LabView como ejemplos, recuerden que las funciones estn dentro de la
librera de Arduino como SubVI.

56
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Estos ejemplos se encuentran en NI Example Finder del men principal de LabView y


Escribiendo en Search Arduino, o pueden accesarlos en la ruta
NationalInstrument>examples>LabVIEW Interface for Arduino>*.vi.

57
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

ANEXOS

58
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

LVIFA_Base.ino
/*********************************************************************************
**
** LVFA_Firmware - Provides Basic Arduino Sketch For Interfacing With LabVIEW.
**
** Written By: Sam Kristoff - National Instruments
** Written On: November 2010
** Last Updated: Dec 2011 - Kevin Fort - National Instruments
** Last Modification: Jul 2012 - Carlos Guzman - UNAPEC
**
** This File May Be Modified And Re-Distributed Freely. Original File Content
** Written By Sam Kristoff And Available At www.ni.com/arduino.
**
*********************************************************************************/

/*********************************************************************************
**
** Includes.
**
********************************************************************************/
// Standard includes. These should always be included.
#include <Wire.h>
#include <SPI.h>
#include <Servo.h>
#include "LabVIEWInterface.h"

/*********************************************************************************
** setup()
**
** Initialize the Arduino and setup serial communication.
**
** Input: None
** Output: None
*********************************************************************************/
void setup()
{
// Initialize Serial Port With The Default Baud Rate
syncLV();

// Place your custom setup code here

59
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

/*********************************************************************************
** loop()
**
** The main loop. This loop runs continuously on the Arduino. It
** receives and processes serial commands from LabVIEW.
**
** Input: None
** Output: None
*********************************************************************************/
void loop()
{
// Check for commands from LabVIEW and process them.

checkForCommand();
// Place your custom loop code here (this may slow down communication with
LabVIEW)

if(acqMode==1)
{
sampleContinously();
}

60
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

LabVIEWInterface.h
/*********************************************************************************
**
**
** LVFA_Firmware - Provides Functions For Interfacing With The Arduino Uno
**
** Written By: Sam Kristoff - National Instruments
** Written On: November 2010
** Last Updated: Dec 2011 - Kevin Fort - National Instruments
** Last modification: Jul 2012 - Carlos Guzman - UNAPEC
**
** This File May Be Modified And Re-Distributed Freely. Original File Content
** Written By Sam Kristoff And Available At www.ni.com/arduino.
**
*********************************************************************************/

/*********************************************************************************
** Define Constants
**
** Define directives providing meaningful names for constant values.
*********************************************************************************/

#define FIRMWARE_MAJOR 02
#define FIRMWARE_MINOR 00
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#define DEFAULTBAUDRATE 9600 // Defines The Default Serial Baud Rate (This must
match the baud rate specifid in LabVIEW)
#else
#define DEFAULTBAUDRATE 115200
#endif
#define MODE_DEFAULT 0 // Defines Arduino Modes (Currently Not Used)
#define COMMANDLENGTH 15 // Defines The Number Of Bytes In A Single
LabVIEW Command (This must match the packet size specifid in LabVIEW)
#define STEPPER_SUPPORT 1 // Defines Whether The Stepper Library Is Included
- Comment This Line To Exclude Stepper Support

// Declare Variables
unsigned char currentCommand[COMMANDLENGTH]; // The Current Command For
The Arduino To Process
//Globals for continuous aquisition
unsigned char acqMode;
unsigned char contAcqPin;
float contAcqSpeed;

61
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

float acquisitionPeriod;
float iterationsFlt;
int iterations;
float delayTime;

/*********************************************************************************
** syncLV
**
** Synchronizes with LabVIEW and sends info about the board and firmware
(Unimplemented)
**
** Input: None
** Output: None
*********************************************************************************/
void syncLV();

/*********************************************************************************
** setMode
**
** Sets the mode of the Arduino (Reserved For Future Use)
**
** Input: Int - Mode
** Output: None
*********************************************************************************/
void setMode(int mode);

/*********************************************************************************
** checkForCommand
**
** Checks for new commands from LabVIEW and processes them if any exists.
**
** Input: None
** Output: 1 - Command received and processed
** 0 - No new command
*********************************************************************************/
int checkForCommand(void);

/*********************************************************************************
** processCommand
**
** Processes a given command
**
** Input: command of COMMANDLENGTH bytes
** Output: 1 - Command received and processed

62
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

** 0 - No new command
*********************************************************************************/
void processCommand(unsigned char command[]);

/*********************************************************************************
** writeDigitalPort
**
** Write values to DIO pins 0 - 13. Pins must first be configured as outputs.
**
** Input: Command containing digital port data
** Output: None
*********************************************************************************/
void writeDigitalPort(unsigned char command[]);

/*********************************************************************************
** analogReadPort
**
** Reads all 6 analog input ports, builds 8 byte packet, send via RS232.
**
** Input: None
** Output: None
*********************************************************************************/
void analogReadPort();

/*********************************************************************************
** sevenSegment_Config
**
** Configure digital I/O pins to use for seven segment display. Pins are stored in
sevenSegmentPins array.
**
** Input: Pins to use for seven segment LED [A, B, C, D, E, F, G, DP]
** Output: None
*********************************************************************************/
void sevenSegment_Config(unsigned char command[]);

/*********************************************************************************
** sevenSegment_Write
**
** Write values to sevenSegment display. Must first use sevenSegment_Configure
**
** Input: Eight values to write to seven segment display
** Output: None
*********************************************************************************/
void sevenSegment_Write(unsigned char command[]);

63
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

/*********************************************************************************
** spi_setClockDivider
**
** Set the SPI Clock Divisor
**
** Input: SPI Clock Divider 2, 4, 8, 16, 32, 64, 128
** Output: None
*********************************************************************************/
void spi_setClockDivider(unsigned char divider);

/*********************************************************************************
** spi_sendReceive
**
** Sens / Receive SPI Data
**
** Input: Command Packet
** Output: None (This command sends one serail byte back to LV for each data byte.
*********************************************************************************/
void spi_sendReceive(unsigned char command[]);

/*********************************************************************************
** checksum_Compute
**
** Compute Packet Checksum
**
** Input: Command Packet
** Output: Char Checksum Value
*********************************************************************************/
unsigned char checksum_Compute(unsigned char command[]);

/*********************************************************************************
** checksum_Test
**
** Compute Packet Checksum And Test Against Included Checksum
**
** Input: Command Packet
** Output: 0 If Checksums Are Equal, Else 1
*********************************************************************************/
int checksum_Test(unsigned char command[]);

/*********************************************************************************
** SampleContinuosly
**

64
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

** Returns several analog input points at once.


**
** Input: void
** Output: void
*********************************************************************************/
void sampleContinously(void);

/*********************************************************************************
** finiteAcquisition
**
** Returns the number of samples specified at the rate specified.
**
** Input: pin to sampe on, speed to sample at, number of samples
** Output: void
*********************************************************************************/
void finiteAcquisition(int analogPin, float acquisitionSpeed, int numberOfSamples );
/*********************************************************************************
** lcd_print
**
** Prints Data to the LCD With The Given Base
**
** Input: Command Packet
** Output: None
*********************************************************************************/
void lcd_print(unsigned char command[]);

65
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

LabVIEWInterface.ino
/*********************************************************************************
**
** LVIFA_Firmware - Provides Functions For Interfacing With The Arduino Uno
**
** Written By: Sam Kristoff - National Instruments
** Written On: November 2010
** Last Updated: Dec 2011 - Kevin Fort - National Instruments
** Last modification: Jul 2012 - Carlos Guzman - UNAPEC
**
** This File May Be Modified And Re-Distributed Freely. Original File Content
** Written By Sam Kristoff And Available At www.ni.com/arduino.
**
*********************************************************************************/

#include <Wire.h>
#include <SPI.h>
#include <LiquidCrystal.h>

// Variables

unsigned int retVal;


int sevenSegmentPins[8];
int currentMode;
unsigned int freq;
unsigned long duration;
int i2cReadTimeouts = 0;
char spiBytesToSend = 0;
char spiBytesSent = 0;
char spiCSPin = 0;
char spiWordSize = 0;
Servo *servos;
byte customChar[8];
LiquidCrystal lcd(0,0,0,0,0,0,0);
// Sets the mode of the Arduino (Reserved For Future Use)
void setMode(int mode)
{
currentMode = mode;
}

// Checks for new commands from LabVIEW and processes them if any exists.
int checkForCommand(void)
{
int bufferBytes = Serial.available();

66
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

if(bufferBytes >= COMMANDLENGTH)


{
// New Command Ready, Process It
// Build Command From Serial Buffer
for(int i=0; i<COMMANDLENGTH; i++)
{
currentCommand[i] = Serial.read();
}
processCommand(currentCommand);
return 1;
}
else
{
return 0;
}
}

// Processes a given command


void processCommand(unsigned char command[])
{
// Determine Command
if(command[0] == 0xFF && checksum_Test(command) == 0)
{
switch(command[1])
{
/*********************************************************************************
** LIFA Maintenance Commands
*********************************************************************************/
case 0x00: // Sync Packet
Serial.print("sync");
Serial.flush();
break;
case 0x01: // Flush Serial Buffer
Serial.flush();
break;

/*********************************************************************************
** Low Level - Digital I/O Commands
*********************************************************************************/
case 0x02: // Set Pin As Input Or Output
pinMode(command[2], command[3]);
Serial.write('0');
break;

67
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

case 0x03: // Write Digital Pin


digitalWrite(command[2], command[3]);
Serial.write('0');
break;
case 0x04: // Write Digital Port 0
writeDigitalPort(command);
Serial.write('0');
break;
case 0x05: //Tone
freq = ( (command[3]<<8) + command[4]);
duration=(command[8]+ (command[7]<<8)+ (command[6]<<16)+
(command[5]<<24));

if(freq > 0)
{
tone(command[2], freq, duration);
}
else
{
noTone(command[2]);
}
Serial.write('0');
break;
case 0x06: // Read Digital Pin
retVal = digitalRead(command[2]);
Serial.write(retVal);
break;
case 0x07: // Digital Read Port
retVal = 0x0000;
for(int i=0; i <=13; i++)
{
if(digitalRead(i))
{
retVal += (1<<i);
}
}
Serial.write( (retVal & 0xFF));
Serial.write( (retVal >> 8));
break;

/*********************************************************************************
** Low Level - Analog Commands
*********************************************************************************/
case 0x08: // Read Analog Pin

68
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

retVal = analogRead(command[2]);
Serial.write( (retVal >> 8));
Serial.write( (retVal & 0xFF));
break;
case 0x09: // Analog Read Port
analogReadPort();
break;

/*********************************************************************************
** Low Level - PWM Commands
*********************************************************************************/
case 0x0A: // PWM Write Pin
analogWrite(command[2], command[3]);
Serial.write('0');
break;
case 0x0B: // PWM Write 3 Pins
analogWrite(command[2], command[5]);
analogWrite(command[3], command[6]);
analogWrite(command[4], command[7]);
Serial.write('0');
break;

/*********************************************************************************
** Sensor Specific Commands
*********************************************************************************/
case 0x0C: // Configure Seven Segment Display
sevenSegment_Config(command);
Serial.write('0');
break;
case 0x0D: // Write To Seven Segment Display
sevenSegment_Write(command);
Serial.write('0');
break;

/*********************************************************************************
** I2C
*********************************************************************************/
case 0x0E: // Initialize I2C
Wire.begin();
Serial.write('0');
break;
case 0x0F: // Send I2C Data
Wire.beginTransmission(command[3]);
for(int i=0; i<command[2]; i++)

69
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

{
#if defined(ARDUINO) && ARDUINO >= 100
Wire.write(command[i+4]);
#else
Wire.send(command[i+4]);
#endif

}
Wire.endTransmission();
Serial.write('0');
break;
case 0x10: // I2C Read
i2cReadTimeouts = 0;
Wire.requestFrom(command[3], command[2]);
while(Wire.available() < command[2])
{
i2cReadTimeouts++;
if(i2cReadTimeouts > 100)
{
return;
}
else
{
delay(1);
}
}

for(int i=0; i<command[2]; i++)


{
#if defined(ARDUINO) && ARDUINO >= 100
Serial.write(Wire.read());
#else
Serial.write(Wire.receive());
#endif

}
break;

/*********************************************************************************
** SPI
*********************************************************************************/
case 0x11: // SPI Init
SPI.begin();
Serial.write('0');

70
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

break;
case 0x12: // SPI Set Bit Order (MSB LSB)
if(command[2] == 0)
{
SPI.setBitOrder(LSBFIRST);
}
else
{
SPI.setBitOrder(MSBFIRST);
}
Serial.write('0');
break;
case 0x13: // SPI Set Clock Divider
spi_setClockDivider(command[2]);
Serial.write('0');
break;
case 0x14: // SPI Set Data Mode
switch(command[2])
{
case 0:
SPI.setDataMode(SPI_MODE0);
break;
case 1:
SPI.setDataMode(SPI_MODE1);
break;
case 2:
SPI.setDataMode(SPI_MODE2);
break;
case 3:
SPI.setDataMode(SPI_MODE3);
break;
default:
break;
}
Serial.write('0');
break;
case 0x15: // SPI Send / Receive
spi_sendReceive(command);
break;
case 0x16: // SPI Close
SPI.end();
Serial.write('0');
break;

71
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

/*********************************************************************************
** Servos
*********************************************************************************/
case 0x17: // Set Num Servos
free(servos);
servos = (Servo*) malloc(command[2]*sizeof(Servo));
for(int i=0; i<command[2]; i++)
{
servos[i] = Servo();
}
if(servos == 0)
{
Serial.write('1');
}
else
{
Serial.write('0');
}
break;
case 0x18: // Configure Servo
servos[command[2]].attach(command[3]);
Serial.write('0');
break;
case 0x19: // Servo Write
servos[command[2]].write(command[3]);
Serial.write('0');
break;
case 0x1A: // Servo Read Angle
Serial.write(servos[command[2]].read());
break;
case 0x1B: // Servo Write uS Pulse
servos[command[2]].writeMicroseconds( (command[3] + (command[4]<<8)) );
Serial.write('0');
break;
case 0x1C: // Servo Read uS Pulse
retVal = servos[command[2]].readMicroseconds();
Serial.write ((retVal & 0xFF));
Serial.write( (retVal >> 8));
break;
case 0x1D: // Servo Detach
servos[command[2]].detach();
Serial.write('0');
break;
/*********************************************************************************

72
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

** LCD
*********************************************************************************/
case 0x1E: // LCD Init
lcd.init(command[2], command[3], command[4], command[5], command[6],
command[7], command[8], command[9], command[10], command[11], command[12],
command[13]);

Serial.write('0');
break;
case 0x1F: // LCD Set Size
lcd.begin(command[2], command[3]);
Serial.write('0');
break;
case 0x20: // LCD Set Cursor Mode
if(command[2] == 0)
{
lcd.noCursor();
}
else
{
lcd.cursor();
}
if(command[3] == 0)
{
lcd.noBlink();
}
else
{
lcd.blink();
}
Serial.write('0');
break;
case 0x21: // LCD Clear
lcd.clear();
Serial.write('0');
break;
case 0x22: // LCD Set Cursor Position
lcd.setCursor(command[2], command[3]);
Serial.write('0');
break;
case 0x23: // LCD Print
lcd_print(command);
break;
case 0x24: // LCD Display Power

73
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

if(command[2] == 0)
{
lcd.noDisplay();
}
else
{
lcd.display();
}
Serial.write('0');
break;
case 0x25: // LCD Scroll
if(command[2] == 0)
{
lcd.scrollDisplayLeft();
}
else
{
lcd.scrollDisplayRight();
}
Serial.write('0');
break;
case 0x26: // LCD Autoscroll
if(command[2] == 0)
{
lcd.noAutoscroll();
}
else
{
lcd.autoscroll();
}
Serial.write('0');
break;
case 0x27: // LCD Print Direction
if(command[2] == 0)
{
lcd.rightToLeft();
}
else
{
lcd.leftToRight();
}
Serial.write('0');
break;
case 0x28: // LCD Create Custom Char

74
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

for(int i=0; i<8; i++)


{
customChar[i] = command[i+3];
}
lcd.createChar(command[2], customChar);

Serial.write('0');
break;
case 0x29: // LCD Print Custom Char
lcd.write(command[2]);
Serial.write('0');
break;

/*********************************************************************************
** Continuous Aquisition
*********************************************************************************/
case 0x2A: // Continuous Aquisition Mode On
acqMode=1;
contAcqPin=command[2];
contAcqSpeed=(command[3])+(command[4]<<8);
acquisitionPeriod=1/contAcqSpeed;
iterationsFlt =.08/acquisitionPeriod;
iterations=(int)iterationsFlt;
if(iterations<1)
{
iterations=1;
}
delayTime= acquisitionPeriod;
if(delayTime<0)
{
delayTime=0;
}
break;
case 0x2B: // Continuous Aquisition Mode Off
acqMode=0;
break;
case 0x2C: // Return Firmware Revision
Serial.write(byte(FIRMWARE_MAJOR));
Serial.write(byte(FIRMWARE_MINOR));
break;
case 0x2D: // Perform Finite Aquisition
Serial.write('0');
finiteAcquisition(command[2],(command[3])+(command[4]<<8),command[5]+

75
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

(command[6]<<8));
break;

/*********************************************************************************
** Unknown Packet
*********************************************************************************/
default: // Default Case
Serial.flush();
break;
}
}
else{
// Checksum Failed, Flush Serial Buffer
Serial.flush();
}
}

/*********************************************************************************
** Functions
*********************************************************************************/

// Writes Values To Digital Port (DIO 0-13). Pins Must Be Configured As Outputs Before
Being Written To
void writeDigitalPort(unsigned char command[])
{
digitalWrite(13, (( command[2] >> 5) & 0x01) );
digitalWrite(12, (( command[2] >> 4) & 0x01) );
digitalWrite(11, (( command[2] >> 3) & 0x01) );
digitalWrite(10, (( command[2] >> 2) & 0x01) );
digitalWrite(9, (( command[2] >> 1) & 0x01) );
digitalWrite(8, (command[2] & 0x01) );
digitalWrite(7, (( command[3] >> 7) & 0x01) );
digitalWrite(6, (( command[3] >> 6) & 0x01) );
digitalWrite(5, (( command[3] >> 5) & 0x01) );
digitalWrite(4, (( command[3] >> 4) & 0x01) );
digitalWrite(3, (( command[3] >> 3) & 0x01) );
digitalWrite(2, (( command[3] >> 2) & 0x01) );
digitalWrite(1, (( command[3] >> 1) & 0x01) );
digitalWrite(0, (command[3] & 0x01) );
}

// Reads all 6 analog input ports, builds 8 byte packet, send via RS232.
void analogReadPort()
{

76
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

// Read Each Analog Pin


int pin0 = analogRead(0);
int pin1 = analogRead(1);
int pin2 = analogRead(2);
int pin3 = analogRead(3);
int pin4 = analogRead(4);
int pin5 = analogRead(5);

//Build 8-Byte Packet From 60 Bits of Data Read


char output0 = (pin0 & 0xFF);
char output1 = ( ((pin1 << 2) & 0xFC) | ( (pin0 >> 8) & 0x03) );
char output2 = ( ((pin2 << 4) & 0xF0) | ( (pin1 >> 6) & 0x0F) );
char output3 = ( ((pin3 << 6) & 0xC0) | ( (pin2 >> 4) & 0x3F) );
char output4 = ( (pin3 >> 2) & 0xFF);
char output5 = (pin4 & 0xFF);
char output6 = ( ((pin5 << 2) & 0xFC) | ( (pin4 >> 8) & 0x03) );
char output7 = ( (pin5 >> 6) & 0x0F );

// Write Bytes To Serial Port


Serial.print(output0);
Serial.print(output1);
Serial.print(output2);
Serial.print(output3);
Serial.print(output4);
Serial.print(output5);
Serial.print(output6);
Serial.print(output7);
}

// Configure digital I/O pins to use for seven segment display


void sevenSegment_Config(unsigned char command[])
{
// Configure pins as outputs and store in sevenSegmentPins array for use in
sevenSegment_Write
for(int i=2; i<10; i++)
{
pinMode(command[i], OUTPUT);
sevenSegmentPins[(i-1)] = command[i];
}
}

// Write values to sevenSegment display. Must first use sevenSegment_Configure


void sevenSegment_Write(unsigned char command[])
{

77
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

for(int i=1; i<9; i++)


{
digitalWrite(sevenSegmentPins[(i-1)], command[i]);
}
}

// Set the SPI Clock Divisor


void spi_setClockDivider(unsigned char divider)
{
switch(divider)
{
case 0:
SPI.setClockDivider(SPI_CLOCK_DIV2);
break;
case 1:
SPI.setClockDivider(SPI_CLOCK_DIV4);
break;
case 2:
SPI.setClockDivider(SPI_CLOCK_DIV8);
break;
case 3:
SPI.setClockDivider(SPI_CLOCK_DIV16);
break;
case 4:
SPI.setClockDivider(SPI_CLOCK_DIV32);
break;
case 5:
SPI.setClockDivider(SPI_CLOCK_DIV64);
break;
case 6:
SPI.setClockDivider(SPI_CLOCK_DIV128);
break;
default:
SPI.setClockDivider(SPI_CLOCK_DIV4);
break;
}
}

void spi_sendReceive(unsigned char command[])


{
if(command[2] == 1) //Check to see if this is the first of a series of SPI packets
{
spiBytesSent = 0;
spiCSPin = command[3];

78
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

spiWordSize = command[4];

// Send First Packet's 8 Data Bytes


for(int i=0; i<command[5]; i++)
{
// If this is the start of a new word toggle CS LOW
if( (spiBytesSent == 0) || (spiBytesSent % spiWordSize == 0) )
{
digitalWrite(spiCSPin, LOW);
}
// Send SPI Byte
Serial.print(SPI.transfer(command[i+6]));
spiBytesSent++;

// If word is complete set CS High


if(spiBytesSent % spiWordSize == 0)
{
digitalWrite(spiCSPin, HIGH);
}
}
}
else
{
// SPI Data Packet - Send SPI Bytes
for(int i=0; i<command[3]; i++)
{
// If this is the start of a new word toggle CS LOW
if( (spiBytesSent == 0) || (spiBytesSent % spiWordSize == 0) )
{
digitalWrite(spiCSPin, LOW);
}
// Send SPI Byte
Serial.write(SPI.transfer(command[i+4]));
spiBytesSent++;

// If word is complete set CS High


if(spiBytesSent % spiWordSize == 0)
{
digitalWrite(spiCSPin, HIGH);
}
}
}
}

79
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

// Synchronizes with LabVIEW and sends info about the board and firmware
(Unimplemented)
void syncLV()
{
Serial.begin(DEFAULTBAUDRATE);
i2cReadTimeouts = 0;
spiBytesSent = 0;
spiBytesToSend = 0;
Serial.flush();
}

// Compute Packet Checksum


unsigned char checksum_Compute(unsigned char command[])
{
unsigned char checksum;
for (int i=0; i<(COMMANDLENGTH-1); i++)
{
checksum += command[i];
}
return checksum;
}

// Compute Packet Checksum And Test Against Included Checksum


int checksum_Test(unsigned char command[])
{
unsigned char checksum = checksum_Compute(command);
if(checksum == command[COMMANDLENGTH-1])
{
return 0;
}
else
{
return 1;
}
}
void sampleContinously()
{

for(int i=0; i<iterations; i++)


{
retVal = analogRead(contAcqPin);
if(contAcqSpeed>1000) //delay Microseconds is only accurate for values less that
16383
{

80
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

Serial.write( (retVal >> 2));


delayMicroseconds(delayTime*1000000); //Delay for neccesary amount of time to
achieve desired sample rate
}
else
{
Serial.write( (retVal & 0xFF) );
Serial.write( (retVal >> 8));
delay(delayTime*1000);
}
}
}
void finiteAcquisition(int analogPin, float acquisitionSpeed, int numberOfSamples)
{
//want to exit this loop every 8ms
acquisitionPeriod=1/acquisitionSpeed;

for(int i=0; i<numberOfSamples; i++)


{
retVal = analogRead(analogPin);

if(acquisitionSpeed>1000)
{
Serial.write( (retVal >> 2));
delayMicroseconds(acquisitionPeriod*1000000);
}
else
{
Serial.write( (retVal & 0xFF) );
Serial.write( (retVal >> 8));
delay(acquisitionPeriod*1000);
}
}
}

void lcd_print(unsigned char command[])


{
if(command[2] != 0)
{
// Base Specified By User
int base = 0;
switch(command[2])
{
case 0x01: // BIN

81
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.

base = BIN;
break;
case 0x02: // DEC
base = DEC;
break;
case 0x03: // OCT
base = OCT;
break;
case 0x04: // HEX
base = HEX;
break;
default:
break;
}
for(int i=0; i<command[3]; i++)
{
lcd.print(command[i+4], base);
}
}
else
{

for(int i=0; i<command[3]; i++)


{
lcd.print((char)command[i+4]);

}
}
Serial.write('0');
}

82

You might also like