Instrumentación Avanzada. G. Murcia – J.

Strack

GUIA DE EJERCICIOS
Nº 13
INSTRUMENTACIÓN AVANZADA

Comunicación Ethernet con

Arduino y LabVIEW

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

13.-Ejemplo de servidor Ethernet con Arduino y LabVIEW

Ejercicio 13.1

Formar 2 grupos con los elementos provistos por la cátedra.

Luego de reconocer los elementos realizar el cableado del conjunto variador de velocidad –
motor basado en la siguiente figura:

Esquema de conexiones de Fuerza Motriz y Maniobra:

Una vez realizadas todas las conexiones, procederemos a configurar el variador de velocidad
ATV 11 siguiendo las instrucciones del Anexo I y probaremos su correcto funcionamiento.

Para comandar y monitorear el ATV 11 desde Arduino realizaremos tres circuitos:

1. Un circuito de relés para accionar las entradas digitales del variador.

2. Un circuito optoacoplado para accionar la entrada analógica Al1 del variador
desde una salida PWM del Arduino.
3. Un circuito optoacoplado para leer desde una entrada analógica de Arduino la
salida D0 (PWM) del variador.

2
 Instrumentación Avanzada. G. Murcia – J. Strack
Circuito 1: Mando para los relés de Arduino (marcha / parada)

Circuito 2: Mando de velocidadoptoacoplado (Al1)

Circuito 3: Medición de velocidad (D0)

Luego de realizar los circuitos acondicionadores anteriores cargaremos el siguiente código en la

placa Arduino UNO ó MEGA. El mismo consiste en el driver de comandos que veníamos
utilizando, pero ahora en lugar de comunicarnos con la placa a través del puerto serie (COM
virtual desde USB), nos comunicaremos a través de Ethernet utilizando el protocolo TCP/IP.

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

///////////////////////////////////////////////////////////////////
// Cátedra Instrumentación Avanzada //
// Driver de comunicación TCP/IP para Arduino UNO y MEGA 2560 //
// Versión: 1.0.10 //
// Fecha: 26/11/2015 //
///////////////////////////////////////////////////////////////////

//DECLARACIONES_________________________________

// LIBRERÍAS
#include<SPI.h>//comunicación SPI (ethernetshield, pines 10,11,12,13)
#include<Ethernet.h>//funciones para comunicación ethernet

// CONFIGURACION DE LA PLACA ETHERNET

bytemac[] = {0x00, 0x22, 0x68, 0x2F, 0xA0, 0x9C }; // Direccion MAC
IPAddressip(10,2,0,100); // Direccion IP
EthernetServer server(80); // puerto de comunicacion HTTP

// SALIDAS DIGITALES:
constint D0=4;
constint D1=5;
constint D2=7;
constint D3=9;

// ENTRADAS DIGITALES:
constint D4=2;
constint D5=3;
constint D6=6;
constint D7=8;

// VARIABLES
Char caracterEntrada;
Int entradaDigital, b0, b1, b2, b3, dato;
byte vector1[2], vector2[10];
char canal;
int valor_analog;

//SETUP_________________________________________
Void setup() {

// DECLARACIÓN DE SALIDAS DIGITALES:

pinMode(D0,OUTPUT);
pinMode(D1,OUTPUT);
pinMode(D2,OUTPUT);
pinMode(D3,OUTPUT);

// DECLARACIÓN DE ENTRADAS DIGITALES:

pinMode(D4,INPUT);
pinMode(D5,INPUT);
pinMode(D6,INPUT);
pinMode(D7,INPUT);

// CONFIGURACIÓN DE LA COMUNICACION TCP/IP

Ethernet.begin(mac,ip); // Inicialización de la pila TCP/IP
server.begin(); // Inicialización del servidor

// INICIALIZACIÓN DE SALIDAS (se ponen en 0)

digitalWrite(D0,0);
digitalWrite(D1,0);
digitalWrite(D2,0);
digitalWrite(D3,0);

}// FIN DEL SETUP

4
 Instrumentación Avanzada. G. Murcia – J. Strack
//CICLO PRINCIPAL________________________________
Void loop() {
EthernetClient client=server.available(); // Se crea el objeto cliente
if (client) { // Si se recibe una petición de un cliente
while (client.connected()) { // Mientras el cliente esté conectado
if (client.available()) { // Si el cliente está disponible
caracterEntrada=client.read(); // toma un nuevo byte

// ATENCIÓN AL COMANDO 'A' (ESCRITURA DE SALIDAS DIGITALES)

if (caracterEntrada=='A') {
caracterEntrada=client.read(); // toma un nuevo byte
digitalWrite(D0,caracterEntrada); // escribe la salida digital D0
caracterEntrada=client.read();
digitalWrite(D1,caracterEntrada);
caracterEntrada=client.read();
digitalWrite(D2,caracterEntrada);
// caracterEntrada = client.read();
// digitalWrite(D3,caracterEntrada);
}// 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);
b2 =digitalRead(D6);
b3 =digitalRead(D7);
entradaDigital= 1 * b0 + 2 * b1 + 4 * b2 + 8 * b3;
client.write(lowByte(byte(entradaDigital)));
// envía el estado de las entradasen 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') {
canal =client.read(); // toma un nuevo byte
dato =analogRead(canal); // lee el canal analógico solicitado
vector1[0] =lowByte(word(dato)); // genera el primer byte
vector1[1] =highByte(word(dato)); // genera el segundo byte
client.write(vector1,2); // envía los dos bytes en binario
}// FIN DE ATENCIÓN AL COMANDO 'C'___________

// ATENCIÓN AL COMANDO 'E' (ESCRITURA DE SALIDA PWM)

if (caracterEntrada=='E') {
caracterEntrada=client.read();
valor_analog=caracterEntrada;
analogWrite(D3,valor_analog);
}// FIN DE ATENCIÓN AL COMANDO 'E'___________

}// fin del if(client.available())

}// fin del while (client.connected())
}// fin del if principal (if(client))
}// fin del loop

El driver anterior nos servirá para este y otros proyectos, ya que podremos crear cualquier
programa en LabVIEW que envíe comandos a través de TCP/IP a nuestra placa, de forma tal de
escribir o leer pines digitales, leer entradas analógicas o escribir una salida pseudoanalógica
(PWM).

5
 Instrumentación Avanzada. G. Murcia – J. Strack
Finalmente desarrollaremos un programa en LabVIEW que nos permita comandar el variador de
velocidad ATV11 a través de TCP/IP.

Panel Frontal sugerido:

Diagrama de Bloques:

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

Conectar el shield Ethernet a la placa Arduino UNO o MEGA y realizar un programa en el IDE
de ARDUINO que permita generar una página web en formato HTML. En dicha página se debe
poder ver una entrada analógica y una entrada digital, a la vez que se debe poder accionar una
salida digital de la placa.

Pagina web sugerida:

Algunos comandos y funciones específicas disponibles útiles para resolver este ejercicio:

// LIBRERIAS
#include <Ethernet.h> // Librería para la comunicación Ethernet

// VARIABLES ESPECIALES
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; // Escribe una dirección
MAC para el controlador.
IPAddress ip(10,2,0,100); // Escribe una IP para el controlador.
EthernetServer server(80); // Puerto 80 es el valor predeterminado para HTTP

// FUNCIONES
Ethernet.begin(mac, ip); // Inicialización del servidor
server.begin();// comienza a recibir conexiones
EthernetClient client = server.available(); // Obtiene un cliente que esté
conectado al servidor y posea datos disponibles para lectura.
client.connected(); //Vale 1 si el cliente está conectado
client.available(); //Vale 1 si el cliente está disponible
client.read(); // Lee un caracter del cliente
client.println(); // Envía una línea al cliente
client.println("<meta http-equiv=\"refresh\" content=\"5\">"); // Añade una
etiqueta para conseguir que el navegador se actualice cada 5 segundos por
ejemplo.
client.println("<input type=submit value=ON style=width:200px;height:75px
onClick=location.href='./?LED=T\'>"); // arma un botón y retorna lo escrito
detras del signo ? (LED=T en este caso)
client.stop(); // cierra la conexión:

7
 Instrumentación Avanzada. G. Murcia – J. Strack
Ejercicio 13.3

Formar 2 grupos con los elementos provistos por la cátedra.

Crear una página web en Arduino para comandar y monitorear un conjunto variador de
velocidad ATV-11 y motor asincrónico trifásico. El objetivo es controlar el variador de
velocidad desde LabVIEW utilizando Ethernet, pero a su vez queremos que también se pueda
controlar desde una página web HTML, de forma tal que se pueda acceder a ella desde cualquier
dispositivo (smartphone, tablet) conectado a internet simplemente utilizando un navegador web.

Luego de realizar los circuitos acondicionadores anteriores cargaremos el siguiente código en la

placa Arduino UNO ó MEGA

///////////////////////////////////////////////////////////////////
// Cátedra Instrumentación Avanzada //
// Ejercicio 13.2 //
// Fecha: 26/11/2015 //
///////////////////////////////////////////////////////////////////

//DECLARACIONES_________________________________
// LIBRERÍAS
#include<SPI.h>//comunicación SPI utilizada por Ethernet shield (pines
10,11,12,13)
#include<Ethernet.h>//funciones para comunicación ethernet

// CONFIGURACIÓN DE LA PLACA ETHERNET

byte mac[] = {0x98, 0x4F, 0xEE, 0x01, 0x10, 0x77}; // Direccion MAC
IPAddress ip(10,2,0,100); // Direccion IP
EthernetServer server(80); // puerto de comunicacion HTTP

// CONSTANTES Y VARIABLES
const int marcha=5; // pin de salida marcha
const int parada=4; // pin de salida parada
const int vel=9;
String estado="PARADA"; // estado del motor inicialmente "PARADA"
String velocidad="0000";
int v=0;

//SETUP_________________________________________
void setup(){

// DECLARACIÓN DE SALIDAS DIGITALES:

pinMode(marcha,OUTPUT);
pinMode(parada,OUTPUT);
pinMode(vel,OUTPUT);

// CONFIGURACIÓN DE LA COMUNICACION TCP/IP

Ethernet.begin(mac,ip); // se inicializa la comunicación Ethernet
server.begin(); // se inicializa el servidor

// CONFIGURACIÓN DEL PUERTO SERIE (visualización)

Serial.begin(115200);

// INICIALIZACIÓN DE SALIDAS
digitalWrite(marcha,0);
digitalWrite(parada,1);
analogWrite(vel,v);

} // fin del setup

Void loop(){

8
 Instrumentación Avanzada. G. Murcia – J. Strack
EthernetClient client=server.available(); // se crea el objeto cliente
if (client) { // si se detecta un cliente a través de una petición HTTP
boolean linea_blanca= true; //Una petición HTTP acaba con una línea en
blanco
String cadena=""; // se crea una cadena de caracteres vacía
while (client.connected()) { // mientras el cliente esté conectado
analogWrite(vel,v);
if (client.available()) { // si el cliente está disponible
char c =client.read();// se lee la petición HTTP carácter por
carácter
cadena.concat(c);// se convierte la petición HTTP en un String
int posicion=cadena.indexOf("M="); // se guarda la posición de la
cadena "M="
if(cadena.substring(posicion)=="M=1") { // si en esa posición dice
"M=1"
digitalWrite(marcha,1);
digitalWrite(parada,0);
client.write('1');
estado="MARCHA"; // se guarda el estado MARCHA
} // fin del if
if(cadena.substring(posicion)=="M=0") { // si en esa posición dice
"M=0"
digitalWrite(marcha,0);
digitalWrite(parada,1);
client.write('0');
estado="PARADA"; // se guarda el estado PARADA
} // fin del if
int pos=cadena.indexOf("V="); // se guarda la posición de la cadena
"V="
if(cadena.substring(pos,pos+2)=="V="){
velocidad =cadena.substring(pos+2,pos+6);
v =floor(velocidad.toInt()*255/1350);
}
if (v>0){
analogWrite(vel,v);
}
Serial.write(c);// se visualiza la petición por el monitor serie
// Cuando reciba una línea en blanco, la petición HTTP habrá acabado
// y el servidor web estará listo para enviar una respuesta
if (c =='\n'&&linea_blanca) {
// Se envía al cliente una respuesta HTTP
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println();
//Página web en formato HTML
client.println("<html>");
client.println("<head>");
client.println("</head>");
client.println("<body>");
client.println("<h1 align='center'>INSTRUMENTACION
AVANZADA</h1><h3 align='center'>MOTOR controlado por Servidor Web con
Arduino</h3>");
//Se crean los botones. Para enviar parametros a través de HTML
se utiliza el metodo URL encode. Los parámetros se envian a través del
símbolo '?'
client.println("<div style='text-align:center;'>");
client.println("<button onClick=location.href='./?M=1\'
style='margin:auto;background-color: #3ADF00;color: snow;padding:
10px;border: 1px solid #3ADF00;width:100px;'>");
client.println("MARCHA");
client.println("</button>");
client.println("<button onClick=location.href='./?M=0\'
style='margin:auto;background-color: #FF0000;color: snow;padding:
10px;border: 1px solid #FF0000;width:100px;'>");
client.println("PARADA");

9
 Instrumentación Avanzada. G. Murcia – J. Strack
client.println("</button>");
client.println("<br /><br />");
client.println("<b>ESTADO DEL ACCIONAMIENTO = ");
client.print(estado);
client.println("<br /><br />");
client.println("<button onClick=location.href='./?V=0000\'
style='margin:auto;background-color: #81BEF7;color: snow;padding:
10px;border: 1px solid #81BEF7;width:100px;'>");
client.println("0 RPM");
client.println("</button>");
client.println("<button onClick=location.href='./?V=0500\'
style='margin:auto;background-color: #2E9AFE;color: snow;padding:
10px;border: 1px solid #2E9AFE;width:100px;'>");
client.println("500 RPM");
client.println("</button>");
client.println("<button onClick=location.href='./?V=1000\'
style='margin:auto;background-color: #0174DF;color: snow;padding:
10px;border: 1px solid #0174DF;width:100px;'>");
client.println("1000 RPM");
client.println("</button>");
client.println("<button onClick=location.href='./?V=1350\'
style='margin:auto;background-color: #084B8A;color: snow;padding:
10px;border: 1px solid #084B8A;width:100px;'>");
client.println("1350 RPM");
client.println("</button>");
client.println("<br /><br />");
client.println("<b>VELOCIDAD DEL MOTOR: ");
client.print(velocidad);
client.println(" RPM");
client.println("</b><br />");
client.println("</b></body>");
client.println("</html>");
break;
} // fin del if
if (c =='\n') { // si hay nueva linea
linea_blanca= true;
} // fin del if
else if (c !='\r') {
linea_blanca= false; // si hay retorno de carro
} // fin del if
} // fin del if (client.available)
} // fin del while
delay(1); // se le da tiempo al navegador para recibir los datos
client.stop();// se cierra la conexión
} // fin del if (client)
} // fin del loop

Ya estamos en condiciones de visualizar la página web creada en Arduino. Sólo debemos abrir el
navegador y acceder a la IP 10.2.0.100 que configuramos en el código anterior.

10
 Instrumentación Avanzada. G. Murcia – J. Strack
Si también queremos realizar el control desdeLabVIEW, ya que disponemos de más
herramientas gráficas, construimos el siguiente programa:
Panel Frontal

Diagrama de Bloques

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

12