En este tutorial pretende mostrar una de las diferentes formas de trabajar con la placa

arduino teensy 2.0 emplendola como una tarjeta de adquisicin de datos desde la
plataforma labVIEW.

Desarrollo de ADC
En este apartado se mostrar cmo adquirir diferentes seales utilizando cuatro entradas
analgicas, cada ADC es de 10 bits, por lo tanto convierte el voltaje aplicado (0-5 volts) a
datos digitales de 0 a 1023.
La funcin a usar para leer el valor del ADC es: analogRead (canal);
Donde canal es un nmero de 0 a 11 segn el canal que utilizremos que en nuestro caso
utilizaremos los siguientes:
NUMER
O
16
17
18
19

PIN
F7
F6
F5
F4
Tabla 1

CANA
L
5
4
3
2

PROGRAMACION EN ARDUINO
El siguiente programa muestra como fue la programacin de nuestra tarjeta arduino, la
cual se explicar a continuacin:
Desde labVIEW mandaremos un dato el cual nos indicar cual es el ADC que queremos
leer, teniendo la opcin de leer los cuatro canales al mismo tiempo, el primer dato indicara
que es un ADC al cual se asigno la letra A, el segundo indica el canal en nuestro caso
los asignamos de la siguiente manera:

NUMER
O
16
17
18
19

PIN
F7
F6
F5
F4

CANA
L
5
4
3
2

DAT
O
3
2
1
0

Tabla 2
int DATO1;
int DATO2;
int ADC0;
Variables de tipo entero
int ADC1;
con un rango de -32768 a 32767
int ADC2;
int ADC3;
void setup() {
Serial.begin(115200); //Abre puerto serie a 115200 bps
}
void loop()
{
if (Serial.available() > 0) //Pregunta si ya hay dato
{
DATO1=Serial.read(); //el dato lo asigna a la variable DATO1
}
if (Serial.available() > 0) //Pregunta si ya hay dato
{
DATO2=Serial.read(); //el dato lo asigna a la variable DATO2
}
if (DATO1=='A')
{
if (DATO2=='0')
{
ADC0= analogRead(2); //Lee el voltaje en el canal 2 que es el pin F4
Serial.println(ADC0);
// print as an ASCII-encoded decimal
delay(40);
//retardo de 40 milisegundos para que mande a puerto serie
datos en forma pausada
}
if (DATO2=='1')
{
ADC1= analogRead(3); //Lee el voltaje en el canal 3 que es el pin F5
Serial.println(ADC1);
// print as an ASCII-encoded decimal
delay(40);
//retardo de 40 milisegundos para que mande a puerto serie
datos en forma pausada
}
if (DATO2=='2')
{
ADC2= analogRead(4); //Lee el voltaje en el canal 4 que es el pin F6
Serial.println(ADC2); // print as an ASCII-encoded decimal
delay(40);
//retardo de 40 milisegundos para que mande a puerto serie
datos en forma pausada
}
if (DATO2=='3')

{
ADC3= analogRead(5); //Lee el voltaje en el canal 5 que es el pin F7
Serial.println(ADC3);
// print as an ASCII-encoded decimal
delay(40);
//retardo de 40 milisegundos para que mande a puerto serie
datos en forma pausada
}
}
}
Programacin De ADC En LabVIEW
La programacin en labVIEW es un poco ms sencilla ya que es una herramienta grfica
de fcil manejo, en primera instancia se implemento un programa el cual trabaja solo con
un ADC (fig. 1- ADC panel frontal) y en base a este se pueden desarrollar otros programas
para trabajar con el numero de ADC requeridos, esto a base de crear una funcin a partir
de nuestra programacin base.

Fig. 1- ADC panel frontal

La figura anterior (fig. 1- ADC) muestra el panel frontal de nuestro programa en labVIEW
en el cual se introduce el ADC que se trabajara as como el puerto serial que utilizremos

para nuestra comunicacin, muestra los datos obtenidos por el ADC de forma grafica y si
existe algn error con la comunicacin serial.

A continuacin se muestra el diagrama a bloques de nuestra programacin para un solo

ADC, como vemos se trabajo a una velocidad de 115200 bps, un VISA write para enviar el
dato del ADC con el que queremos trabajar, un VISA read para leer el dato de nuestro
ADC,

a la salida del VISA read tenemos una serie de operaciones con las cuales

convertimos el valor que oscila entre 0 y 1023 a un valor que oscile de 0 a 5 siendo este el
voltaje con el cual nuestro ADC trabaja y por ultimo un indicador tipo char para mostrar el
valor en forma de grafica.

Fig. 2- ADC diagrama a bloques

Despus de haber creado nuestra funcin a partir del programa anterior es mas sencillo
crear nuestro programa para trabajar con el numero de ADC requeridos, en este caso se
comento que utilizaremos cuatro ADC por lo tanto nuestro diagrama a bloques (fig. 3ADC diagrama a bloques para cuatro ADC) se muestra a continuacin:

Fig. 3-ADC diagrama a bloques para cuatro ADC

El control de nuestro arduino se llevara a cavo desde nuestro panel frontal (fig. 4-ADC
panel frontal) donde configuraremos el puerto serial con el que trabajaremos, inicializamos
los ADC y obtenemos los resultados de forma grafica.

Fig. 4-ADC panel frontal

En la figura anterior (fig. 4-ADC panel frontal) se muestran cuatro graficas que ser donde
visualizaremos los datos de nuestros ADC, a un costado hay cuatro apartados llamados
ADC1, ADC2, ADC3 y ADC4 hay se colocaran el comando para leer los ADC requeridos
como se muestra en la siguiente tabla:
ADC

COMAND
O
ADC 1
A0
ADC 2
A1
ADC 3
A2
ADC 4
A3
Tabla 3

Desarrollo de PWM
El PWM (Modulacin en ancho de pulso) en nuestro arduino se realiza en 8 bits que va
desde 0 hasta 255 a una frecuencia aproximada a 490 Hz, donde si tenemos un 0 sern 0
volts y si es un 255 obtendremos 5 volts aproximados, obteniendo cada valor por medio
de una regla de tres, en la siguiente figura se muestran valores que podemos obtener:
VALOR
0
DECIMAL
51
128
153
204
255

% DE MODULACIN
0
20%
50%
60%
80%
100%
Tabla 4

VOLTAJE
0V
PROMEDIO
1V
2.5 V
3V
4V
5V

La funcin que utilizamos en nuestro arduino es analogWrite (pin,valor), donde pin es

donde queremos generar un voltaje y valor el voltaje promedio entregado.
Nuestro arduino cuenta con 7 salidas analgicas (PWM) de las cuales trabajaremos con
tres de ellas mostrndose en la siguiente tabla su distribucin:
NUMER
O
15
9
10

PIN

PWM

B6
C6
C7

PWM 1
PWM 2
PWM 3

Tabla 5
Igual que con los ADC, los PWM los manejaremos desde labVIEW refirindose con estos
con una P siguindole un numero que indique el PWM con el que trabajaremos, despus
de estos dos caracteres el valor con el que trabajara nuestro PWM como a continuacin
se muestra:
COMANDO
P0000
P0051
P0128
P0153
P0204
P0255

% DE MODULACIN
0
20%
50%
60%
80%
100%
Tabla 6

VOLTAJE PROMEDIO
ENTREGADO
0V
1V
2.5 V
3V
4V
5V

Como se observa en la tabla anterior despus de los dos primeros caracteres se colocan
otros tres no importa si el valor requerido es un cero ya que nuestro arduino lee de un
carcter a la vez y si solo mandamos un valor no trabajara nuestro programa
adecuadamente, estos tres caracteres son el valor requerido en nuestra modulacin, en
seguida se muestra nuestro cdigo en arduino, siendo esta una de las diferentes maneras
de programacin.

int B6=15;
int C7=10;
int C6=9;
int PWMA;
int PWM0;
Variables de tipo entero
int PWM1;
int PWM2;
con un rango de -32768 a 32767
int PWM3;
int PWMR;
int R1;
int R2;
int R3;
void setup()
{
pinMode(B6,OUTPUT);
pinMode(C6,OUTPUT);
se activan los pines como salidas
pinMode(C7,OUTPUT);
Serial.begin(115200);
//Abre puerto serie a 115200 bps
}

void loop() {
if (Serial.available() > 0)
//Pregunta si ya hay dato
{
PWMA=Serial.read();
//el dato lo asigna a la variable PWMA
}
if (Serial.available() > 0)
//Pregunta si ya hay dato
{
PWM0=Serial.read();
//el dato lo asigna a la variable PWM0
}
if (Serial.available() > 0)
//Pregunta si ya hay dato
{
PWM1=Serial.read();
//el dato lo asigna a la variable PWM1
}
if (Serial.available() > 0)
//Pregunta si ya hay dato
{
PWM2=Serial.read();
//el dato lo asigna a la variable PWM2
}
if (Serial.available() > 0)
//Pregunta si ya hay dato
{
PWM3=Serial.read();
//el dato lo asigna a la variable PWM3
}
R1=(PWM1-48)*100;
R2=(PWM2-48)*10;
Este es un arreglo de operaciones para juntar los datos
R3=(PWM3-48);
que mandamos desde labVIEW
PWMR=R1+R2+R3;
if (PWMA=='P')
{
if (PWM0=='0')
{
analogWrite(B6,PWMR); //Si se cumplen las condiciones anteriores se manda
escribir
delay(20);
// al PWM indicado
}
if (PWM0=='1')
{
analogWrite(C6,PWMR);
delay(20);
}
if (PWM0=='2')
{
analogWrite(C7,PWMR);
delay(20);
}
}

PROGRAMACION DE PWM EN labVIEW

En nuestro ADC utilizamos las funciones VISA write y VISA read ya que mandamos y
recibamos datos, en le caso del PWM solo utilizamos la funcin VISA write para enviarle
los datos a nuestra placa arduino, la siguiente figura (fig. 5- PWM diagrama a bloques) se
muestran todas las funciones usadas para implementar solo un PWM y de aqu obtener
una nueva funcin y utilizarla para implementar un mayor numero de PWM.

Fig. 5- PWM diagrama a bloques

En el panel frontal (fig. 6- 3 PWM panel frontal) es donde activaremos nuestro puerto y
colocaremos los caracteres en el apartado PWM para trabajar con algn PWM de
nuestro arduino.

Fig. 6- PWM panel frontal

Despus de haber realizado pruebas con un PWM se realizo el programa con el cual
trabajaremos con los tres PWM a la vez esto con la ayuda de nuestra funcin realizada
anteriormente. Nuestro nuevo programa se muestra a continuacin (fig. 7- 3 PWM
diagrama a bloques).

Fig. 7- 3 PWM diagrama a bloques

La configuracin de la comunicacin serial de nuestro arduino se configura desde nuestro
panel frontal, aqu seleccionamos el puerto a usar y en los apartados PWM, PWM2 y
PWM3 se usan los comandos mencionados en la Tabla 6.

Fig.8- 3 PWM panel frontal

Implementacin DE LA Tarjeta De Adquisicin De Datos Con Arduino
Anteriormente se trabajo la tarjeta utilizando ADC y PWM, cada uno de manera separada,
a continuacin se dar una pequea demostracin de como podemos utiliza el arduino
como una Tarjeta de Adquisicin De Datos, donde implementaremos una serie de ADC,
PWM, activaremos un puerto como salida y otro como entrada.
Los ADC y PWM se utilizaran como se explico en los ejercicios anteriores, por el momento
se mostrara como trabajar con las entradas y salidas.
Las entradas de nuestro arduino se encargan de leer el estado de un determinado PIN el
cual puede ser bajo o alto (LOW- HIGH, 0-5 volts) y realizar determinada instruccin, en
este caso un puerto de entrada estar monitoreado por medio de un programa en
labVIEW.
En un puerto de salida se encuentran diferentes combinaciones las cuales ponen cada
PIN de salida en bajo o alto (LOW- HIGH, 0-5 volts) activando o desactivando un led o
algn otro dispositivo que este en uso.
A continuacin se muestra la programacin que se utilizo en arduino, no siendo la nica
manera de codificacin:
//VAR ADC

int DATO1;
int DATO2;
int ADC0;
int ADC1;
int ADC2;
int ADC3;
//VAR PWM
int B6=15;
int C7=10;
int C6=9;
int PWM1;
int PWM2;
int PWM3;
int PWMR;
int R1;
int R2;
int R3;
//VAR SALIDAS
int D0=5;
int D1=6;
int D2=7;
int D3=8;
int D4=22;
int D5=23;
int D6=11;
int D7=12;
int MT,M1,M2,M3,COM1,COM2,COM3;
//VAR ENTRADAS
int BB0=0;
int BB1=1;
int BB2=2;
int BB3=3;
int BB4=13;
int BB5=14;

int F0=21;
int F1=20;
int T=0;
int I0,I1,I2,I3,I4,I5,I6,I7;
void setup() {
pinMode(B6,OUTPUT);
pinMode(C6,OUTPUT);
pinMode(C7,OUTPUT);
DDRD=MT;
pinMode(BB0,INPUT);
pinMode(BB1,INPUT);
pinMode(BB2,INPUT);
pinMode(BB3,INPUT);
pinMode(BB4,INPUT);
pinMode(BB5,INPUT);
pinMode(F0,INPUT);
pinMode(F1,INPUT);
digitalWrite(BB0,LOW);
digitalWrite(BB1,LOW);
digitalWrite(BB2,LOW);
digitalWrite(BB3,LOW);
digitalWrite(BB4,LOW);
digitalWrite(BB5,LOW);
digitalWrite(F0,LOW);
digitalWrite(F1,LOW);
Serial.begin(115200);
}
void loop()
{
if (Serial.available() > 0) //Pregunta si ya hay dato
{
DATO1=Serial.read();
}

//PROGRAMACION DEL ADC

if (DATO1=='A')
{
if (Serial.available() > 0) //Pregunta si ya hay dato
{
DATO2=Serial.read();
}
if (DATO2=='0')
{
ADC0= analogRead(2);
Serial.println(ADC0);
delay(40);
}
if (DATO2=='1')
{
ADC1= analogRead(3);
Serial.println(ADC1);
delay(40);
}
if (DATO2=='2')
{
ADC2= analogRead(4);
Serial.println(ADC2);
delay(40);
}
if (DATO2=='3')
{
ADC3= analogRead(5);
Serial.println(ADC3);
delay(40);
}
}
//PROGRAMACION DE PWM

if (DATO1=='P')
{
if (Serial.available() > 0) //Pregunta si ya hay dato
{
DATO2=Serial.read();
}
if (Serial.available() > 0)
{
PWM1=Serial.read();
}
if (Serial.available() > 0)
{
PWM2=Serial.read();
}
if (Serial.available() > 0)
{
PWM3=Serial.read();
}
R1=(PWM1-48)*100;
R2=(PWM2-48)*10;
R3=(PWM3-48);
PWMR=R1+R2+R3;
if (DATO2=='0')
{
analogWrite(B6,PWMR);
delay(40);
}
if (DATO2=='1')
{
analogWrite(C6,PWMR);
delay(40);
}
if (DATO2=='2')
{

analogWrite(C7,PWMR);
delay(40);
}
}
//PROGRAMACION DE ENTRADAS
if (DATO1=='I')
{
if (digitalRead(BB0)==HIGH)
{
I0=1;
}
else
{
I0=0;
}
if (digitalRead(BB1)==HIGH)
{
I1=2;
}
else
{
I1=0;
}
if (digitalRead(BB2)==HIGH)
{
I2=4;
}
else
{
I2=0;
}
if (digitalRead(BB3)==HIGH)
{

I3=8;
}
else
{
I3=0;
}
if (digitalRead(BB4)==HIGH)
{
I4=16;
}
else
{
I4=0;
}
if (digitalRead(BB5)==HIGH)
{
I5=32;
}
else
{
I5=0;
}
if (digitalRead(F0)==HIGH)
{
I6=64;
}
else
{
I6=0;
}
if (digitalRead(F1)==HIGH)
{
I7=128;
}

else
{
I7=0;
}
T=I0+I1+I2+I3+I4+I5+I6+I7;
Serial.println(T);
delay(40);
}
//PROGRAMACION DE SALIDAS
if (DATO1=='O')
{
if (Serial.available() > 0) //Pregunta si ya hay dato
{
COM1=Serial.read();
}
if (Serial.available() > 0) //Pregunta si ya hay dato
{
COM2=Serial.read();
}
if (Serial.available() > 0) //Pregunta si ya hay dato
{
COM3=Serial.read();
}
M1=(COM1-48)*100;
M2=(COM2-48)*10;
M3=(COM3-48);
MT=M1+M2+M3;
PORTD=MT;
delay(40);
}
}

Como se puede observar en el programa de arduino para que las entradas trabajen a
partir de labVIEW se le mandara la instruccin I, en el caso de las salidas tendrn que
ser cuatro caracteres, el primero para decir que es salida O y los otros tres para fijar el
tipo de arreglo que se quiere en el puerto el cual puede ser un nmero que este entre 0 y
255 el cual se mostrara de forma binaria en el puerto de salida, a continuacin se muestra
en una tabla como es que se tiene que introducir la instruccin:
SALIDA
INSTRUCCIN
DDRD= B00000000
O000
DDRD= B00001111
O015
DDRD= B11110000
O240
DDRD= B11111111
O255
Tabla 7

Programacin De La Tarjeta De Adquisicin De Datos En LabVIEW

Existen diferentes maneras de implementar programas que trabajen con arduino en este
caso se mostrara como interactuar en conjunto con ARDUINO Y labVIEW, a partir de lo
que se mostro anteriormente obtuvimos el siguiente diagrama:

Fig.9- Tarjeta De Adquisicin De Datos diagrama a bloques

Fig.10- Tarjeta De Adquisicin De Datos panel frontal

En la figura anterior (Fig.10- Tarjeta De Adquisicin De Datos panel frontal) se muestra
como es que se debe configurar desde labVIEW nuestra tarjeta para que trabaje
adecuadamente de lo contrario se generaran errores, como se menciono, los ltimos tres
valores de PWM y OUT se pueden modificar dependiendo de nuestro uso.
Las funciones que se muestran en la figura 9 (Fig.9- Tarjeta De Adquisicin De Datos
diagrama a bloques) son VI creados a partir de otros programas, los cuales fueron
probados para su optimo desempeo.