guia de ejercicios nº 13 instrumentaciÓn … · instrumentación avanzada. g. murcia – j....

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

1

GUIA DE EJERCICIOS

Nº 13

INSTRUMENTACIÓN AVANZADA

Comunicación Ethernet con

Arduino y LabVIEW


2

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.


3

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.


4

///////////////////////////////////////////////////////////////////

// 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


5

//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);


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);



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') {


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).


6

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:


7

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:


8

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(){


9

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"



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"



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");


10


client.println("<br /><br />");

client.println("<b>ESTADO DEL ACCIONAMIENTO = ");

client.print(estado);


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");



style='margin:auto;background-color: #2E9AFE;color: snow;padding:

10px;border: 1px solid #2E9AFE;width:100px;'>");




style='margin:auto;background-color: #0174DF;color: snow;padding:

10px;border: 1px solid #0174DF;width:100px;'>");




style='margin:auto;background-color: #084B8A;color: snow;padding:

10px;border: 1px solid #084B8A;width:100px;'>");




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.


11

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


12

guia de ejercicios nº 13 instrumentaciÓn … · instrumentación avanzada. g. murcia – j....

Documents