01/01/2020

INSTRUMENTACIÓ
N
PROF. M. EN C. MIGUEL ÁNGEL GONZÁLEZ ORTIZ | MANUAL DE PRÁCTICAS | ENERO-JUNIO
2020

NOMBRE
DEL
ALUMNO:

PRÁCTICA
N:1

DISEÑO Y CONTRUCCIÓN DE UNA TARJETA DE ADQUISICIÓN DE DATOS PARA MEDICIONES DE

SENSORES NUMERO DE ESTUDIANTES POR EQUPO: 4 DURACIÓN: 2 HORAS

COMPETENCIAS: EL ESTUDIANTE PROGRAMARÁ Y CONFIGURARÁ MEDIANTE EL SOFTWARE DE

INSTRUMENTACIÓN LA PUESTA EN MARCHA DE UNA TARJETA DE ADQUISICIÓN DE DATOS DE FORMA
EXPERIMENTAL.

El objetivo programar la placa ARDUINO para que se comporte como una DAQ (Data AcQuisition) de bajo costo. Es decir, que
permita escribir salidas digitales (leds), leer entradas digitales (botones) y leer una entrada analógica (potenciómetro) a través
de comandos enviados desde la PC

SEGURIDAD DE
ELABORACIÓN:

Se trabajar con tarjetas sensibles a la estática y a la alimentación externa, asegurarse que las conexiones a la AL
ARDUINO sean correctas.

Las fuentes de alimentación externa deben ser puenteadas al común de la tarjeta para la correcta referencia de los voltajes a
ser medidos.

Lo anterior para tu seguridad y evitar daños irreversibles al equipo.

DESCRIPCIÓN DE LA
PRÁCTICA:

Haciendo uso de una tarjeta Arduino versión uno o Mega se diseñará una interfaz mediante el software de LabVIEW para que
funca como tarjeta de adquisición de datos, ésta realizará la medición de señales analógicas y digitales mediante el uso de sus
convertidores analógico digital y los enviará a la PC mediante su conexión USB. Los datos serán enviados haciendo uso de su
protocolo USB-HID donde la PC reconoce a la placa como un puerto serie, y el software de LabVIEW realiza la captura de los
datos serie que posteriormente pueden ser tratados y visualizados mediante un programa gráfico diseñado a medida de
acuerdo a las necesidades de medición.

El objetivo programar la placa ARDUINO para que se comporte como una DAQ (Data AcQuisition) de bajo costo. Es decir, que
permita escribir salidas digitales (leds), leer entradas digitales (botones) y leer una entrada analógica (potenciómetro) a través
de comandos enviados desde la PC.

MATERIA
L
• ARduio Uno o MEGa.
• Botones y LED
• Resistencias distintos valores.
• Multímetro.
• Conectores (varios).
• Pusch Botton
• Headers
• Tarjetas PCB perforada.

Procedimiento:

1. Instalar labivew y el driver correspondiente para que la placa ARDUINO didáctica suministrada por la cátedra sea reconocida
por la PC como un dispositivo conectado a un puerto COM virtual. 2. Instalar las librerías NI-VISA (si aún no lo han hecho), para
poder realizar luego la comunicación con el dispositivo conectado al puerto COM virtual. Las herramientas que usaremos están en
la pestaña “Data Comunication” del diagrama de bloques de LabVIEW. 2. Instalar las librerías ​NI-VISA ​(si aún no lo han hecho)​,
para poder realizar luego la comunicación con el dispositivo conectado al puerto COM virtual. Las herramientas que usaremos
están en la pestaña “Data Comunication” del diagrama de bloques de LabVIEW.
 3. Generar un programa en ARDUINO y en LabVIEW para establecer la comunicación entre la PC y la DAQ de bajo
costo. El programa en ARDUINO se puede generar en el propio Entorno de Desarrollo Integrado (IDE).

(Escritura de salidas
digitales)

Programar el comando A de la placa Arduino que permitirá escribir 4 salidas digitales nombradas D0, D1, D2 y D3 correspondientes a
los pines físicos 4, 5, 7 y 9 respectivamente.

2
Código del Arduino:

//DECLARACIONES///////////////////////////////////////////////////////////// ​const int

D0​=​4​, ​D1​=​5​, ​D2​=​7​, ​D3​=​9; ​// SALIDAS DIGITALES ​char ​caracteres[4]​,
caracterEntrada; ​//SETUP//////////////////////////////////////////////////////////////////////////
void ​setup​() { ​pinMode​(D0​, ​OUTPUT​); ​// DECLARACIÓN DE SALIDAS
DIGITALES ​pinMode​(D1​, ​OUTPUT​); ​pinMode​(D2​, ​OUTPUT​);
pinMode​(D3​, ​OUTPUT​); ​Serial​.​begin​(9600); ​// CONFIGURACIÓN DEL
PUERTO SERIE ​digitalWrite​(D0​,​0); ​// INICIALIZACIÓN DE SALIDAS (se
ponen en 0) ​digitalWrite​(D1​,​0); ​digitalWrite​(D2​,​0); ​digitalWrite​(D3​,​0); }​//
FIN DEL SETUP //CICLO
PRINCIPAL///////////////////////////////////////////////////////////// ​void ​loop​() { ​if
(​Serial​.​available​()) { ​// si llegó uno o más caracteres desde la PC
caracterEntrada ​= ​Serial​.​read​(); ​// toma un nuevo byte // ATENCIÓN AL
COMANDO 'A' (ESCRITURA DE SALIDAS DIGITALES) ​if
(caracterEntrada ​== ​'A'​) { ​Serial​.​readBytes​(caracteres​,​4); ​// lee 4
caracteres y los guarda en un buffer ​digitalWrite​(D0​,c​ aracteres[0]); ​//
escribe la salida digital D0 ​digitalWrite​(D1​,​caracteres[1]); ​// escribe la
salida digital D1 ​digitalWrite​(D2​,​caracteres[2]); ​// escribe la salida digital
D2 ​digitalWrite​(D3​,​caracteres[3]); ​// escribe la salida digital D3 ​}​// FIN DE
ATENCIÓN AL COMANDO 'A' ​}​// fin del if principal ​}​// fin del loop

4. Una vez escrito el programa anterior, se selecciona el modelo de la placa (UNO, MEGA 2560, Intel Galileo Gen 1 o DUE) y el
puerto COM en la pestaña ​Herramientas.​ Luego, se debe compilar presionando ​Ctrl R o ​ a través de la pestaña ​Programa​. Si la
compilación resulta exitosa (no aparecen errores en el código) se carga el mismo al ARDUINO presionando ​Ctrl U

3
Antes de programar en LabVIEW se enviarán comandos al puerto serie de la placa a
través del software Docklight a fin de testear el funcionamiento del código recién
cargado. Para ello, se abre el programa de hiperterminal o el receptor serial del
software de programación del Arduino para verificar que se están enviando datos
seriales.

5.- Se realiza el código de labview para recibir los datos

 4

6.- se diseña el programa para la lectura de entradas digitales:

Programar el comando B de la placa Arduino que permitirá leer 4 entradas digitales

nombradas D4, D5, D6 y D7 correspondientes a los pines físicos 2, 3, 6 y 8
respectivamente
 5

//DECLARACIONES///////////////////////////////////////////////////////////// ​const int ​D0​=​4​, ​D1​=​5​, ​D2​=​7​, ​D3​=​9; ​// SALIDAS

DIGITALES ​const int ​D4​=​2​, ​D5​=​3​, ​D6​=​6​, ​D7​=​8; ​// ENTRADAS DIGITALES ​int ​entradaDigital​, ​b0​, ​b1​, ​b2​, ​b3;
// VARIABLES ​char ​caracteres[4]​, ​caracterEntrada; ​//SETUP//////////////////////////////////////////////////////////////////////////
void ​setup​() { ​pinMode​(D0​, ​OUTPUT​); ​// DECLARACIÓN DE SALIDAS DIGITALES ​pinMode​(D1​, ​OUTPUT​);
pinMode​(D2​, ​OUTPUT​); ​pinMode​(D3​, O ​ UTPUT​); ​pinMode​(D4​, ​INPUT​); ​// DECLARACIÓN DE ENTRADAS
DIGITALES ​pinMode​(D5​, ​INPUT​); ​pinMode​(D6​, I​ NPUT​); ​pinMode​(D7​, ​INPUT​); ​Serial​.​begin​(9600); ​//
CONFIGURACIÓN DEL PUERTO SERIE ​digitalWrite​(D0​,​0); ​// INICIALIZACIÓN DE SALIDAS (se ponen en
0) ​digitalWrite​(D1​,​0); ​digitalWrite​(D2​,​0); ​digitalWrite​(D3​,​0); }​// FIN DEL SETUP //CICLO
PRINCIPAL///////////////////////////////////////////////////////////// ​void ​loop​() { ​if ​(​Serial​.​available​()) { ​// si llegó uno o más
caracteres desde la PC ​caracterEntrada ​= ​Serial​.​read​(); ​// toma un nuevo byte // ATENCIÓN AL
COMANDO 'A' (ESCRITURA DE SALIDAS DIGITALES) ​if ​(caracterEntrada ​== ​'A'​) {
Serial​.​readBytes​(caracteres​,​4); ​// lee 4 caracteres y los guarda en un buffer ​digitalWrite​(D0​,​caracteres[0]); ​//
escribe la salida digital D0 ​digitalWrite​(D1​,​caracteres[1]); ​// escribe la salida digital D1
digitalWrite​(D2​,​caracteres[2]); ​// escribe la salida digital D2 ​digitalWrite​(D3​,​caracteres[3]); ​// escribe la salida
digital D3 ​}​// FIN DE ATENCIÓN AL COMANDO 'A' // ATENCIÓN AL COMANDO 'B' (LECTURA DE
ENTRADAS DIGITALES) ​if ​(caracterEntrada ​== '​ B'​) { b0 ​= ​digitalRead​(D4); ​// lee la entrada D4 ​b1 ​=
digitalRead​(D5); ​// lee la entrada D5 ​b2 ​= ​digitalRead​(D6); ​// lee la entrada D6 ​b3 ​= ​digitalRead​(D7); ​// lee la
entrada D7 ​entradaDigital ​= ​1 ​* ​b0 ​+ ​2 ​* ​b1 ​+ ​4 ​* b ​ 2 ​+ ​8 ​* ​b3; ​Serial​.​write​(​lowByte​(​byte​(entradaDigital))); ​//
envía el estado de las entradas en los 4 bits menos significativos ​}​// FIN DE ATENCIÓN AL COMANDO 'B'
}​// fin del if principal ​}​// fin del loop

7.- Se rediseña la aplicación de labview para leer las entradas digitales

6
8.- Lectura de entradas analógicas:

Programar el comando C de la placa Arduino que permitirá leer 1 entrada analógica

del canal solicitado desde la PC.
 7

//DECLARACIONES///////////////////////////////////////////////////////////// ​const int ​D0​=​4​, ​D1​=​5​, ​D2​=​7​, ​D3​=​9; ​// SALIDAS

DIGITALES ​const int ​D4​=​2​, ​D5​=​3​, ​D6​=​6​, ​D7​=​8; ​// ENTRADAS DIGITALES ​int ​entradaDigital​, ​b0​, ​b1​, ​b2​, ​b3​,
dato; ​// VARIABLES ​char ​caracteres[4]​, ​caracterEntrada; ​byte ​vector1[2]; ​String ​canal;
//SETUP////////////////////////////////////////////////////////////////////////// ​void ​setup​() { ​pinMode​(D0​, ​OUTPUT​); ​//
DECLARACIÓN DE SALIDAS DIGITALES ​pinMode​(D1​, ​OUTPUT​); ​pinMode​(D2​, ​OUTPUT​); ​pinMode​(D3​,
OUTPUT​); ​pinMode​(D4​, ​INPUT​); ​// DECLARACIÓN DE ENTRADAS DIGITALES ​pinMode​(D5​, ​INPUT​);
pinMode​(D6​, ​INPUT​); ​pinMode​(D7​, ​INPUT​); ​Serial​.​begin​(9600); ​// CONFIGURACIÓN DEL PUERTO SERIE
digitalWrite​(D0​,​0); ​// INICIALIZACIÓN DE SALIDAS (se ponen en 0) ​digitalWrite​(D1​,​0); ​digitalWrite​(D2​,​0);
digitalWrite​(D3​,​0); }​// FIN DEL SETUP //CICLO PRINCIPAL///////////////////////////////////////////////////////////// ​void
loop​() { ​if ​(​Serial​.​available​()) { ​// si llegó uno o más caracteres desde la PC ​caracterEntrada ​= ​Serial​.​read​();
// toma un nuevo byte // ATENCIÓN AL COMANDO 'A' (ESCRITURA DE SALIDAS DIGITALES) ​if
(caracterEntrada ​== ​'A'​) { ​Serial​.​readBytes​(caracteres​,​4); ​// lee 4 caracteres y los guarda en un buffer
digitalWrite​(D0​,​caracteres[0]); ​// escribe la salida digital D0 ​digitalWrite​(D1​,​caracteres[1]); ​// escribe la salida
digital D1 ​digitalWrite​(D2​,​caracteres[2]); ​// escribe la salida digital D2 ​digitalWrite​(D3​,​caracteres[3]); ​//
escribe la salida digital D3 ​}​// FIN DE ATENCIÓN AL COMANDO 'A' // ATENCIÓN AL COMANDO 'B'
(LECTURA DE ENTRADAS DIGITALES) ​if ​(caracterEntrada ​== ​'B'​) { b0 ​= ​digitalRead​(D4); ​// lee la entrada
D4 ​b1 ​= ​digitalRead​(D5); ​// lee la entrada D5 ​b2 ​= ​digitalRead​(D6); ​// lee la entrada D6 ​b3 ​= ​digitalRead​(D7);
// lee la entrada D7 ​entradaDigital ​= ​1 ​* b ​ 0 ​+ ​2 ​* ​b1 ​+ ​4 ​* ​b2 ​+ ​8 ​* ​b3;
Serial​.​write​(​lowByte​(​byte​(entradaDigital))); ​// envía el estado de las entradas en los 4 bits menos
significativos ​}​// FIN DE ATENCIÓN AL COMANDO 'B' // ATENCIÓN AL COMANDO 'C' (LECTURA DE
UNA ENTRADA ANALÓGICA) ​if ​(caracterEntrada ​== ​'C'​) { caracterEntrada ​= ​Serial​.​read​(); ​// toma un
nuevo byte ​canal ​= ​caracterEntrada ​+ ​""​; ​// convierte el caracter en string

8
dato ​= ​analogRead​(canal​.​toInt​()); ​// lee el canal analógico
solicitado ​vector1[0] ​= ​lowByte​(​word​(dato)); ​// genera el primer
byte ​vector1[1] ​= ​highByte​(​word​(dato)); ​// genera el segundo byte
Serial​.​write​(vector1​,​2); ​// envía los dos bytes en binario ​}​// FIN DE
ATENCIÓN AL COMANDO 'C' ​}​// fin del if principal ​}​// fin del loop
Diseñamos también el código para labview

EVALUACIÓ
N

CUESTINARIO: ACIERTO PUNTAJE

30%
Circuito de Entradas Digitales ​☐ ​

30%
Circuito de entradas analógicas ​☐ ​

Programas de labview ​☐ ​60%

Final
9