Professional Documents
Culture Documents
Gua de Iniciacin
Por:CarlosA.GuzmnHdez.
IngenieroElectrnico
PREFACIO
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.
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.
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 .
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: 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.
7
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.
Memoria
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).
9
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.
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 .
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.
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.
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.
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
12
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.
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.
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.
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.
15
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.
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)
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:
18
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.
19
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
33
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.
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.
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.
36
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.
Esta pantalla es solo una interpretacin para poder seleccionar el Puerto donde esta el
Arduino y poder apagar el mismo.
37
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.
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.
39
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.
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.
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.
42
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.
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.
44
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.
45
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.
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.
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.
47
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.
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.
49
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.
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.
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.
51
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.
3.9 Control del LED RGB con los potenciometros del mdulo
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.
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.
54
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.
55
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.
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.
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();
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.
/*********************************************************************************
** 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
// 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.
/*********************************************************************************
** 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.
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);
}
}
}
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.
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.
77
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.
78
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.
spiWordSize = command[4];
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();
}
80
LabView + Arduino Gua de Iniciacin Ing. Carlos A. Guzmn Hdez.
if(acquisitionSpeed>1000)
{
Serial.write( (retVal >> 2));
delayMicroseconds(acquisitionPeriod*1000000);
}
else
{
Serial.write( (retVal & 0xFF) );
Serial.write( (retVal >> 8));
delay(acquisitionPeriod*1000);
}
}
}
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
{
}
}
Serial.write('0');
}
82