Instrumentación Avanzada. G. Murcia – J.

Strack

GUIA DE EJERCICIOS
Nº 3
INSTRUMENTACIÓN AVANZADA

Comunicando LabVIEW
a una placa ARDUINO

1
 Instrumentación Avanzada. G. Murcia – J. Strack

3.-COMUNICANDO LABVIEW A UNA PLACA ARDUINO

El objetivo de esta guía es realizar un semáforo de un tiempo (1 única calle) cuyas luces se
enciendan físicamente en la placa suministrada por la cátedra y en el panel frontal de
LabVIEW a modo de monitoreo. El semáforo tendrá 4 modos de operación que se
seleccionarán con los 4 pulsadores de la placa de expansión montada arriba del
ARDUINO:
 Modo normal: se realiza el ciclo de conmutación normal de un semáforo de un
tiempo, es decir, de una única calle o arteria).
 Modo intermitente: debe encenderse y apagarse sólo la luz amarilla en forma
cíclica.
 Modo prueba de luces: se deben encender las tres luces para verificar su buen
funcionamiento.
 Modo apagado: las tres luces deben estar apagadas y sólo se debe encender una luz
azul de stand-by.
Con el potenciómetro de la placa se debe poder regular el período de tiempo de cada ciclo
de conmutación.

Como vimos en las transparencias de la Clase 3, para resolver el problema debemos:

1. Instalar 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.

3. Generar un programa en ARDUINO y en LabVIEW para resolver este ejercicio. A

continuación se presentan las estructuras de comandos que habría que programar.

2
 Instrumentación Avanzada. G. Murcia – J. Strack

Escritura de salidas digitales:

Lectura de entradas digitales:

Lectura de entradas analógicas:

4. El programa en ARDUINO se puede generar en el propio Entorno de Desarrollo

Integrado (IDE) provisto en el DVD de la asignatura. A continuación se muestra el
código que realiza los comandos descriptos anteriormente. El mismo se debe copiar en un
archivo nuevo.

3
 Instrumentación Avanzada. G. Murcia – J. Strack

///////////////////////////////////////////////////////////////////////////////////
// Cátedra Instrumentación Avanzada
// Driver de comunicación serie para Arduino UNO, MEGA 2560 e Intel Galileo Gen1
// Compatible con libreria de LabVIEW similar a la de PIC18F2550
// Versión: 1.1.0
// Fecha: 05/09/2016
///////////////////////////////////////////////////////////////////////////////////

//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 * b0 + 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
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

4
 Instrumentación Avanzada. G. Murcia – J. Strack

5. Una vez copiado el programa anterior, se selecciona el modelo de la placa (UNO, MEGA
2560 o Intel Galileo Gen 1) 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) cargamos el mismo al ARDUINO
presionando Ctrl U.

6. Antes de programar en LabVIEW enviaremos 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, abrimos el programa, luego abrimos el archivo
ia2016_clase3_comandos.ptp y seleccionamos el puerto COM (configurar la velocidad a
9600 baudios).

7. Finalmente el programa a realizar en LabVIEW es el siguiente:

5
 Instrumentación Avanzada. G. Murcia – J. Strack

Ejercicio 3.1
El primer paso para realizar el semáforo será leer las entradas digitales (estado de los pulsadores)
a fin de seleccionar los cuatro modos de funcionamiento (normal, intermitente, prueba de luces y
apagado). Se realizará el siguiente programa en LabVIEW:

Panel Frontal:

Diagrama de Bloques:

Ejercicio 3.2
Ahora se programará los modos apagado, prueba de luces e intermitente, comandando las salidas
digitales de la placa (LEDs) y luces de monitoreo en el panel frontal:

Panel Frontal:

6
 Instrumentación Avanzada. G. Murcia – J. Strack

Diagrama de Bloques:

Ejercicio 3.3
En este ejercicio se agregará el modo normal generando la secuencia de encendido y apagado de
las tres luces del semáforo. Se propone realizar la siguiente programación:
Diagrama de Bloques:

Ejercicio 3.4
Para finalizar, se propone al alumno agregar el código gráfico necesario para poder regular la
base de tiempo de cada ciclo del semáforo desde la entrada analógica a través de un
potenciómetro.