Arduino Ethernet Shield
La Arduino Ethernet Shield permite a una placa Arduino conectarse a internet. Está basada en el chip ethernet Wiznet W5100 (datasheet). El Wiznet W5100 provee de una pila de red IP capaz de TCP y UDP. Soporta hasta cuatro conexiones de sockets simultáneas. Usa la librería Ethernet para escribir programas que se conecten a internet usando la shield.
La ethernet shield dispone de unos conectores que permiten conectar a su vez otras placas encima y apilarlas sobre la placa Arduino.
Arduino usa los pines digitales 10, 11, 12, y 13 (SPI) para comunicarse con el W5100 en la ethernet shield. Estos pines no pueden ser usados para e/s genéricas.
La shield provee un conectore ethernet estándar RJ45
El botón de reset en la shield resetea ambos, el W5100 y la placa Arduino.
La shield contiene un número de LEDs para información:
- PWR: indica que la placa y la shield están alimentadas
- LINK: indica la presencia de un enlace de red y parpadea cuando la shield envía o recibe datos
- FULLD: indica que la conexión de red es full duplex
- 100M: indica la presencia de una conexión de red de 100 Mb/s (de forma opuesta a una de 10Mb/s)
- RX: parpadea cuando la shield recibe datos
- TX: parpadea cuando la shield envía datos
- COLL: parpadea cuando se detectan colisiones en la red
El jumper soldado marcado como “INT” puede ser conectado para permitir a la placa Arduino recibir notificaciones de eventos por interrupción desde el W5100, pero esto no está soportado por la librería Ethernet. El jumper conecta el pin INT del W5100 al pin digital 2 de Arduino.
El slot SD en la shield no está soportado por el software Arduino.
Para usar la Ethernet Shield solo hay que montarla sobre la placa Arduino. Para cargar los sketches a la placa conectarla al ordenador mediante el cable USB como se hace normalmente. Una vez que el sketch ha sido cargado se puede desconectar la placa del ordenador y alimentarla desde una fuente externa.
Conectar la Ethernet Shield a un ordenador, a un switch o a un router utilizando un cable ethernet standard (CAT5 oCAT6 con conectores RJ45). La conexión al ordenador puede requerir el uso de un cable cruzado (aunque muchos ordenadores actuales, incluyendo los últimos modelos Mac pueden hacer el cruce de forma interna).
Network Settings
Al shield se de debe asignar una dirección MAC y una IP fija utilizando la función Ethernet.begin(). Una dirección MAC es un identificador global único para cada dispositivo en particular; asignar una al azar suele funcionar, pero no utilice la misma para mas de una placa.
Conectando Arduino como un Servidor Web
El dispositivo será capaz de responder a una petición HTTP con su Ethernet Shield. Después de abrir un navegador web e ingresar la dirección IP asiganada al Arduino Ethernet Shield, su Arduino responderá mostrando los valores del estado de su entrada análoga (A0) y su entrada digital (Pin 2). 1. Conectamos Nuestra placa Arduino Uno al Ethernet Shield. 2. Conectamos el Ethernet shield al Router. 3. También conectamos nuestro ordenador al Router para que esten en la misma red. 4. En el Ordenador podemos verificar la IP que nos asigna la red de la siguiente manera: Si estamos en un Mac, entramos al Terminal y ponemos:
ifconfig
Si estamos en Windows vamos a la consola de windows: en Ejecutar ponemos cmd y ponemos:
ipconfig
Observamos que nos muestra la configuración de la red y buscamos en0:
en0: flags=8863<UP,BROADCAST,SMART,RUNNING,SIMPLEX,MULTICAST> mtu 1500 inet6 fe80::226:b0ff:feef:72a0%en0 prefixlen 64 scopeid 0x4 inet 192.168.1.155 netmask 0xffffff00 broadcast 192.168.1.255 ether 00:26:b0:ef:72:a0
En mi caso me muestra que mi ordenador tiene asignada la dirección IP : 192.168.1.155 Para que estén en la misma red, buscamos en el sketch que he puesto a continuación: byte ip[] = { 192, 168, 1, 6 }; y vemos que la dirección es similar, solo el ultimo numero cambia. Procuremos que la dirección que le asignemos al ethernet shield en el sketch sean iguales todos los números menos el ultimo. de esta forma nos cercioraremos de que estén compartiendo la misma mascara de sub red y la misma puerta de enlace pero con dos direcciones IP distintas.
Sketch Servidor Web:
#include <Ethernet.h> // Incluye la librería Ethernet #include <SPI.h> // Identificador Ethernet único byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; byte ip[] = { 192, 168, 1, 6 }; // Dirección IP asignanda al Arduino Ethernet Shield EthernetServer server(80); // Es el puerto HTML para conexión a Internet //Función principal void setup() { Ethernet.begin(mac, ip); //Inicializa librería y configuraciones de red server.begin(); //Inicia comunicación a través del puerto } //Función cíclicla void loop() { EthernetClient client = server.available(); if (client) { //Una petición http termina con una línea en blanco boolean current_line_is_blank = true; while (client.connected()) { if (client.available()) { char c = client.read(); // Si hemos llegado al final de la línea (recibió una nueva línea // Carácter) y la línea está en blanco, la petición http ha terminado, // Para que podamos enviarle una respuesta if (c == '\n' && current_line_is_blank) { } client.println("HTTP/1.1 200 OK"); // Envió encabezado estándar de respuesta HTTP client.println("Content-Type: text/html"); client.println(); client.print("Entrada digital "); //Imprimir valor entrada digital client.print("2"); client.print(" es "); client.print(digitalRead(2)); // Lectura del pin 2 (digital) client.println("<br />"); client.println("<br />"); client.print("Entrada analoga"); //Imprimir valor entrada análoga client.print("0"); client.print(" es "); client.print(analogRead(0)); // Lectura del pin 0 (analogo) client.println("<br />"); client.println("<br />"); break; if (c == '\n') { current_line_is_blank = true; // Comenzaremos una nueva línea } else if (c != '\r') { current_line_is_blank = false; // Obtenemos un caracter en la línea actual } } } } // Damos un tiempo al servidor web para recibir los datos delay(1); //Retardo de un 1 ms(milisegundo) client.stop(); }
Una vez hayamos cargado el programa ponemos en nuestro terminal:
ping -a 192.168.1.6
Con el comando “ping” vamos a enviar paquetes a la direccion IP que ponemos a continuacion. En mi caso yo he puesto la direccion IP que le he asignado a mi Arduino Ethernet. Al darle “Enter” podemos ver que los leds RX y TX de la Arduino Ethernet se encienden en sincronía con el envío de datos del Terminal.
Vemos en la consola que esta recibiendo 64 bytes desde la direccion IP.
Nota: Para parar el proceso presiona “Cntrl-C” ó “Cntrl_Z”.
En este momento ya tenemos configurado Arduino en la red!!!
Push botton y LDR enviando datos a una IP
Ahora vamos a conectar un circuito y enviar datos a través de la red.
5.
Conectamos al pin Analogico 0 un Fotoresistor (LDR) creando un divisor de tensión con una resistencia de 1kohm como hemos visto en el Tutorial de Arduino . 6. conectamos un Push botton al pin digital 2 como vimos anteriormente en el Tutorial de Arduino junto con una resistencia de 10kohm. 7. Cargamos el sketch a la placa. 8. Abrimos un Navegador de Internet (explorer, Firefox, Chrome, Safari) y ponemos en la barra de busqueda, la direccion IP de nustra Ethernet shield. En mi caso es la 192.168.1.6, que es la que le asigné en el sketch.
Poemos ver que al poner la direccion IP en el Navegador, accedemos via ethernet a los datos que nos envia Arduino. Estos datos los hemos descrito en el siguiente codigo del sketch:
client.print("Entrada digital "); //Imprimir valor entrada digital client.print("2"); client.print(" es "); client.print(digitalRead(2)); // Lectura del pin 2 (digital) client.println("<br />"); client.println("<br />"); client.print("Entrada analoga"); //Imprimir valor entrada análoga client.print("0"); client.print(" es "); client.print(analogRead(0)); // Lectura del pin 0 (analogo)
9. Si presionamos el Push botton y refrescamos el navegador, vemos que cambia el valor de la Entrada digital a 1. 10. si variamos la luz sobre nuestro LDR, y refrescamos el navegador tambien podemos ver que cambian los valores de la Entrada analoga.
Web client
Ahora vamos a cargar el Sketch WebClient que aparece en los ejemplos de Ethernet de Arduino. En este ejemplo nos vamos a conectar a google para poder recibir datos de google en Arduino.
Vemos que en el Sketch aparece una direccion IP correspondiente a google, esa direccion va cambiando, asi que debemos comprobar que corresponda. Para esto ponemos en nuestro Terminal del mac o en la consola de Windows:
ping www.google.com
y podemos ver a que dirección IP corresponde.
En este caso me da la siguiente IP GOOGLE = 173.194.45.16
Entonces remplazo la direccion IP correspondiente en mi Sketch WebClient.
Sketch Web clent
/* Web client This sketch connects to a website (http://www.google.com) using an Arduino Wiznet Ethernet shield. Circuit: * Ethernet shield attached to pins 10, 11, 12, 13 created 18 Dec 2009 modified 9 Apr 2012 by David A. Mellis */ #include <SPI.h> #include <Ethernet.h> // Enter a MAC address for your controller below. // Newer Ethernet shields have a MAC address printed on a sticker on the shield byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; IPAddress server(173,194,45,16); // Google // Initialize the Ethernet client library // with the IP address and port of the server // that you want to connect to (port 80 is default for HTTP): EthernetClient client; void setup() { // Open serial communications and wait for port to open: Serial.begin(9600); while (!Serial) { ; // wait for serial port to connect. Needed for Leonardo only } // start the Ethernet connection: if (Ethernet.begin(mac) == 0) { Serial.println("Failed to configure Ethernet using DHCP"); // no point in carrying on, so do nothing forevermore: for(;;) ; } // give the Ethernet shield a second to initialize: delay(1000); Serial.println("connecting..."); // if you get a connection, report back via serial: if (client.connect(server, 80)) { Serial.println("connected"); // Make a HTTP request: client.println("GET /search?q=arduino HTTP/1.0"); client.println(); } else { // kf you didn't get a connection to the server: Serial.println("connection failed"); } } void loop() { // if there are incoming bytes available // from the server, read them and print them: if (client.available()) { char c = client.read(); Serial.print(c); } // if the server's disconnected, stop the client: if (!client.connected()) { Serial.println(); Serial.println("disconnecting."); client.stop(); // do nothing forevermore: for(;;) ; } }
Después de cargar el sketch a la placa, abrimos el monitor serial de Arduino y podemos ver que se descargan los datos de google referentes a la palabra Arduino en html.
Controlando una Luz con Arduino Ethernet mediante una IP
En este ejemplo se trata de encender y apagar una Luz a través de Internet y, para ello, vamos a utilizar el Shield Ethernet Arduino. Serán necesarios unos conocimientos básicos de HTML, simplemente para poder hacer la página Web a nuestro gusto. A través de esta página Web, podremos encender y apagar nuestra bombilla cuando queramos. Desde el ordenador, iPad, tablet, o cualquier dispositivo con conexión WI-FI.
Lo que vamos a crear con el Ethernet Shield, es un servidor Web, el cual nos proporcionará el código HTML para poder verlo en nuestro navegador y poder, así, interactuar con él.
En Internet, un servidor es un ordenador remoto que provee los datos solicitados por parte de los navegadores de otros ordenadores. En redes locales (LAN, Local Area Network), se entiende como el software que configura un PC como servidor para facilitar el acceso a la red y sus recursos. Los servidores almacenan información en forma de páginas Web y, a través del protocolo HTTP lo entregan a petición de los clientes (navegadores Web) en formato HTML.
Un servidor sirve información a los ordenadores que se conecten a él. Cuando los usuarios se conectan a un servidor, pueden acceder a programas, archivos y otra información del servidor. En la Web, un servidor es un ordenador que usa el protocolo HTTP para enviar páginas Web al equipo de un usuario cuando éste las solicita.
En este caso no vamos a utilizar la red Internet sino que lo haremos a nivel local en lo que se denomina una red LAN (Red de Area Local). Para acceder a la página Web que creemos, deberemos acceder con una dirección IP perteneciente a nuestra red, que será la que le hayamos asignado al Ethernet Shield.
Vamos a cargar el siguiente sketch pero debermos poner la dirección IP que corresponda a la misma sub mascara y puerta de enlace de nuestra red. En mi caso es:
IPAddress ip(192,168,1,6);
Sketch Arduino Ethernet ON/OFF
#include <SPI.h> #include <Ethernet.h> //Declaración de la direcciones MAC e IP. También del puerto 80 byte mac[]={0xDE,0xAD,0xBE,0xEF,0xFE,0xED}; //MAC IPAddress ip(192,168,1,6); //IP EthernetServer servidor(80); int PIN_LED=8; String readString=String(30); String state=String(3);
void setup() { Ethernet.begin(mac, ip); //Inicializamos con las direcciones asignadas servidor.begin(); pinMode(PIN_LED,OUTPUT);
digitalWrite(PIN_LED,LOW); state="OFF"; }
void loop() { EthernetClient cliente= servidor.available(); if(cliente) { boolean lineaenblanco=true; while(cliente.connected()) { if(cliente.available()) { char c=cliente.read(); if(readString.length()<30) { readString.concat(c); //Cliente conectado //Leemos petición HTTP caracter a caracter //Almacenar los caracteres en la variable readString } if(c=='\n' && lineaenblanco) //Si la petición HTTP ha finalizado { int LED = readString.indexOf("LED="); if(readString.substring(LED,LED+5)=="LED=T") { digitalWrite(PIN_LED,HIGH); state="ON"; } else if (readString.substring(LED,LED+5)=="LED=F") { digitalWrite(PIN_LED,LOW); state="OFF"; } //Cabecera HTTP estándar cliente.println("HTTP/1.1 200 OK"); cliente.println("Content-Type: text/html"); cliente.println(); //Página Web en HTML cliente.println("<html>"); cliente.println("<head>"); cliente.println("<title>LAMPARA ON/OFF</title>"); cliente.println("</head>"); cliente.println("<body width=100% height=100%>"); cliente.println("<center>"); cliente.println("<h1>LAMPARA ON/OFF</h1>"); cliente.print("<br><br>"); cliente.print("Estado de la lampara: "); cliente.print(state); cliente.print("<br><br><br><br>"); cliente.println("<input type=submit value=ON style=width:200px;height:75px onClick=location.href='./?LED=T\'>"); cliente.println("<input type=submit value=OFF style=width:200px;height:75px onClick=location.href='./?LED=F\'>"); cliente.println("</center>"); cliente.println("</body>"); cliente.println("</html>"); cliente.stop(); //Cierro conexión con el cliente readString=""; } } } } }
Ahora cargamos el sketch al Arduino y nos sercioramos que tengamos conectada la Ethernet shield a la misma red de nuestro ordenador. Ahora vamos a un navegador y ponemos en la barra de direcciones la IP de nuestra Arduino Ethernet shield, en mi caso es
192.168.1.6
y nos debe aparecer la siguiente web con la cual podremos encender y apagar el LED:
Si tenemos conectado nuestro led al Pin 8, veremos que se encenderá y apagará cuando le hagamos click en ON y OFF. Este ejemplo también podría servir para encender y apagar la luz de la casa o la cafetera o el ventilador, lo único que necesitaríamos es un circuito de Relé, el cual fue explicado anteriormente en el Tutorial de Arduino.