Ethernet Shield R3

Este shield nos permitirá conectar una placa Arduino a un sistema TCP/IP local o incluso a internet. Esta versión del shield ethernet está ya descatalogada y ya existe la versión 2 de la misma. Podemos consultar las características oficiales en la página www.arduino.cc. Igualmente existen diferentes modelos fabricados por terceros que funcionan igual de bien, aunque no todos tienen como base el chip W5100.

Tendríamos a grandes rasgos una placa que:
- Funciona a 5V
- Chip de comunicaciones: W5100 de Wiznet
- Velocidad de conexión: 10/100Mb
- Comunicación con la placa Arduino principal mediante el puerto SPI

CARACTERISTICAS

Como se ha comentado, este modelo de shield lleva el chip W5100 de la casa Wiznet (datasheet). Este provee de todo lo necesario para llevar a cabo la comunicación TCP o UDP de hasta 4 conexiones simultáneas.
Este shield se conectará mediante sus pines, específicamente diseñados mas largos de lo normal, a la placa arduino (UNO y MEGA por ejemplo), quedando colocado encima de esta.
También tenemos en este shield un lector de tarjetas SD. Acepta tarjetas de tamaño micro-SD. Veremos este punto en otra sección.
Para programar este shield usaremos la librería Ethernet Library oficial de arduino. En el ejemplo que montaremos explicaré más detalladamente alguno de los comandos de esta librería.
Lleva un conector RJ45 standard para cables de CAT-5 o CAT-6. Tienes dos LED incluidos en el propio conector que nos indican si la conexión es de 100Mbps (color VERDE) y si hemos logrado el enlace o Link (color AMARILLO).

PINEADO

Como la mayoría de los shield, este utiliza algunos de los pines de E/S para su funcionamiento. La placa Arduino se comunica con el chip W5100 y con el lector de tarjetas SD a través del bus SPI a través del conector ICSP.
Como sabemos este puerto es del tipo serie y necesita de varios pines para realizar la comunicación entre el master o host (Arduino en este caso) y el esclavo. Dependiendo del modelo de Arduino al que conectemos el shield anularemos ciertos pines para nuestro propósito y quedaran bloqueados para el funcionamiento del shield.
Por ejemplo, en caso del Arduino UNO R3 o del Arduino Duemilanove los pines usados para el SPI son: 11, 12 y 13. El pin 10 para seleccionar el chip W5100 (Ethernet) y el pin 4 para seleccionar el lector de tarjetas SD. En el caso del Arduino MEGA 2560 los pines usados para el SPI son: 50, 51 y 52. El pin 10 para seleccionar el chip W5100 (Ethernet) y el pin 4 para seleccionar el lector de tarjetas SD.

BOTONES

El Ethernet shield solo tiene un botón en la placa. Es el botón de RESET. Cuando lo pulsemos resetearemos tanto el Arduino al que este conectada, como a ella misma.

LED's INDICADORES

Tenemos 5 led en la placa que nos dan la siguiente información:
- RX: parpadea cuando la placa recibe datos
- TX: parpadea cuando la placa transmite datos
- ON: indica que el shield tiene alimentación
- LINK: indica la presencia de un enlace de red y parpadea cuando transmite o recibe datos
- 100M: cuando esta encendido indica que la velocidad es de 100Mb/s. Si esta apagado es de 10Mb/s

JUMPER

El jumper situado en la parte trasera de la placa, al lado de la palabra SHIELD (como se ve en la imagen), es un jumper de soldadura que por defecto viene abierto. Si lo soldamos y lo unimos estaremos conectando internamente el pin de transmisión de interrupciones del W5100 al pin número 2 de la placa Arduino. Recordemos que, por ejemplo en la placa Arduino UNO, el pin 2 digital puede usarse para recibir peticiones de interrupciones (en este caso la 0). También tener en cuenta que esta función no esta soportada por la libraría Ethernet.

ESQUEMA

En este esquema que nos ofrecen los diseñadores del sistema, podemos ver toda la arquitectura electrónica del Shield en su versión 3. Muy útil para localizar posibles averías o dudas que tengamos.

PROBEMOS EL ETHERNET SHIELD

Ahora viene lo más importante. Vamos a probar nuestro Ethernet Shield conectándolo a un Arduino UNO R3 y programándolo con uno de los ejemplo que vienen en el IDE. El ejemplo será el WEB SERVER. Este se encarga de generar una simple página web en la dirección IP 192.168.1.177 con los datos leídos de las 6 entradas analógicas (que pueden ser desde 0 a 1023). Por defecto se realiza una lectura de las entradas y cada 5 segundos y se actualiza la página web. Esto nos dará una idea de si nuestro shield funciona correctamente y podremos seguir avanzando en su programación para otros proyectos.

A continuación tenemos el código fuente del ejemplo WEB SERVER para consultarlo. Este código no hace falta escribirlo, ya que esta como ejemplo en el IDE.

CÓDIGO ARDUINO

/*
  Web Server

 A simple web server that shows the value of the analog input pins.
 using an Arduino Wiznet Ethernet shield.

 Circuit:
 * Ethernet shield attached to pins 10, 11, 12, 13
 * Analog inputs attached to pins A0 through A5 (optional)

 created 18 Dec 2009
 by David A. Mellis
 modified 9 Apr 2012
 by Tom Igoe
 modified 02 Sept 2015
 by Arturo Guadalupi

 */

#include <SPI.h>
#include <Ethernet.h>

// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = {
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED
};
IPAddress ip(192, 168, 1, 177);

// Initialize the Ethernet server library
// with the IP address and port you want to use
// (port 80 is default for HTTP):
EthernetServer server(80);

void setup() {
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }


  // start the Ethernet connection and the server:
  Ethernet.begin(mac, ip);
  server.begin();
  Serial.print("server is at ");
  Serial.println(Ethernet.localIP());
}


void loop() {
  // listen for incoming clients
  EthernetClient client = server.available();
  if (client) {
    Serial.println("new client");
    // an http request ends with a blank line
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        Serial.write(c);
        // if you've gotten to the end of the line (received a newline
        // character) and the line is blank, the http request has ended,
        // so you can send a reply
        if (c == '\n' && currentLineIsBlank) {
          // send a standard http response header
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println("Connection: close");  // the connection will be closed after completion of the response
          client.println("Refresh: 5");  // refresh the page automatically every 5 sec
          client.println();
          client.println("<!DOCTYPE HTML>");
          client.println("<html>");
          // output the value of each analog input pin
          for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
            int sensorReading = analogRead(analogChannel);
            client.print("analog input ");
            client.print(analogChannel);
            client.print(" is ");
            client.print(sensorReading);
            client.println("<br />");
          }
          client.println("</html>");
          break;
        }
        if (c == '\n') {
          // you're starting a new line
          currentLineIsBlank = true;
        } else if (c != '\r') {
          // you've gotten a character on the current line
          currentLineIsBlank = false;
        }
      }
    }
    // give the web browser time to receive the data
    delay(1);
    // close the connection:
    client.stop();
    Serial.println("client disconnected");
  }
}

					
CÓDIGO ARDUINO

Una vez visto el código vamos a ver paso a paso como podemos probar el shield.
Para empezar necesitaremos el siguiente material:

Una placa Arduino UNO R3

Una placa Ethernet Shield

Una placa protoboard para realizar el pequeño montaje, con un potenciómetro de 4K7 o similar

Un Switch o un Hub de 100Mbps o más. En mi caso es un Switch de 1Gbit de 5 puertos. También necesitaremos dos cables ethernet cortos de categoría 5 o más.

Lo primero es abrir el IDE de Arduino. En este caso vamos a hacerlo desde Windows 10.

Ahora vamos a abrir el ejemplo WebServer. Para ello pulsamos en el menú la opción ARCHIVO, luego vamos a Ejemplos, luego vamos a Ethernet (donde están todos los ejemplos relacionados con el Ethernet Shield) y por último vamos a la última opción WebServer.

Aquí tenemos la ventana abierta con el código del WebServer. En principio no vamos a modificar nada del ejemplo.

Ahora, como siempre, vamos a informar al IDE de la placa Arduino que vamos a usar, así podrá compilar el código adecuadamente. Para ello pulsamos en el menú la opción Herramientas, luego vamos a Placa:"---------" (aquí estará seleccionada la última placa Arduino con la que hayamos trabajado) y por último Arduino/Genuino Uno.

Una vez configurado el IDE, ya podemos montar el pequeño circuito. Lo que nos interesa es poder modificar la tensión en la entrada analógica AD0 del Arduino Uno. Si conectamos un potenciómetro de manera que tenga sus dos extremos conectados a +5V y a Gnd (masa), en la patilla central o ajustable, al mover el potenciómetro tendremos una tensión entre 0V en un extremo hasta 5V en el opuesto. El esquema (realizado con KiCAD) como se ve es muy sencillo y se construye en muy poco tiempo, ya tendremos esquemas mas elaborados.

En estas dos imágenes podemos ver el montaje realizado en una placa protoboard pequeña y con un potenciómetro de 4K7 (4.700Ω)

El siguiente paso es conectar el puerto USB del Arduino Uno con el Ethernet Shield ya conectado encima, el montaje terminado, a un puerto USB del ordenador. Esto hará, al estar en Windows, que si no esta instalado el controlador de Arduino se instale automáticamente y si esta instalado previamente no notaremos nada al conectarlo.
Ahora informaremos al IDE en que puerto del ordenador esta conectado el Arduino UNO, para ello pulsamos en el menú la opción Herramientas, luego vamos a Puertos:"COM? (Arduino/Genuino Uno)" (aquí estará seleccionado el último puerto que hayamos usado con este modelo de Arduino) y por último COM? (Arduino/Genuino Uno)". En mi caso fue el puerto COM3, lo que significa que Windows asigno automáticamente el puerto COM3 del ordenador al puerto USB donde hemos conectado la placa Arduino para poder comunicarse con esta.

Una vez terminado de configurar el IDE, ya podemos verificar el Sketch. Evidentemente si no hemos modificado el código, no debería tener ningún error y deberá pasar el test de verificación sin problemas, como se ve en la imagen superior. Aquí vamos a hacer un inciso importante. Cuando estemos trabajando con diferente placas Arduino, al cambiar en el IDE el modelo de placa, podemos encontrarnos con un aviso de error al verificar nuestros códigos. Este aviso realmente no es un error, si no un aviso de cambio de placa. Si pulsamos de nuevo y verificamos el Sketch, estará libre de errores. Ojo, si la segunda vez el IDE sigue insistiendo en el error, entonces realmente tendremos un error de código y tendremos que revisarlo.

Ahora es el momento de encender nuestro Switch y conectarlo. Solo usaremos dos puertos: uno al ordenador y el segundo al conector del Ethernet Shield. En mi caso el ordenador se conecto a 1Gbits y el Shield a 100Mbps. Recordemos que el Ethernet Shield tiene una velocidad máxima de 100Mbps.
Una vez conectados los dos cables ethernet, ya podemos enviar el Sketch al Arduino UNO, pulsamos el botón de "subir". Veremos como el Arduino UNO recibe los datos y cuando termine el programa empezara a ejecutarse.

Ahora mismo tenemos el servidor web funcionando, pero no hay ningún navegador externo que este visualizando la pequeña página web que genera con los datos de las lecturas de las entradas analógicas. Para poder acceder a la página web alojada en el Arduino UNO tenemos que iniciar un navegador (en nuestro caso el EDGE de Windows 10), estando la tarjeta de red del ordenador conectada al Ethernet Shield (lo esta mediante el cable ethernet y el switch), y que ambos sistemas estén en el mismo rango dentro de la red local. Esto aunque parece algo lioso es muy sencillo.
En la imagen superior podemos ver parte del código que se esta ejecutando en el Arduino. la linea que nos interesa es: IPAddress ip(192, 168, 1, 177); esta linea es una llamada a la librería Ehternet.h que hemos cargado previamente en el Sketch, que se encarga de configurar la dirección IP de nuestro servidor web. En este caso el servidor esta situado en la IP 192.168.1.177. Cuando un navegador se conecte a esta dirección el servidor le lanzara la página web y este la presentará.
Antes tenemos que configurar la tarjeta de red del ordenador para que este en el mismo rango de red que nuestro sistema Arduino. Lo que vamos a hacer en los siguientes pasos es configurar la tarjeta de red en la dirección IP 192.168.1.100 y la mascara de subred en 255.255.255.0.

Pulsamos con el botón derecho del ratón en el icono que red que esta en la barra de tareas, al lado del reloj.

Al pulsar nos aparecerán dos opciones; pulsaremos la última: Abrir el Centro de redes y recursos compartidos.

Una vez abierto el Centro de redes y recursos compartidos, pulsaremos la opción Cambiar configuración del adaptador. Esta opción nos permite cambiar las configuraciones de todas las tarjetas de red que tengamos en el ordenador o cualquier sistema de comunicaciones.

Una vez pulsado nos aparecerá una ventana llamada "Conexiones de red" donde apareceran todos los adaptadores o tarjetas de red. En nuestro caso apareció una tarjeta Ethernet. Lo que queremos es modificar sus propiedades, para ello pulsamos con el botón derecho del ratón sobre la tarjeta de red y dentro del menú que aparece seleccionamos la última opción: Propiedades.

Una vez pulsado se nos abre una nueva ventana con todas las propiedades que podemos modificar de la tarjeta de red. A nosotros nos interesa modificar la dirección IP de la tarjeta y este ajuste esta dentro de la opción "Protocolo de Internet versión 4 (TCP/IPv4)". Lo seleccionamos para que se ponga azul y pulsamos el botón Propiedades.

Una vez pulsado se abre una nueva ventana con los dos ajustes básicos: cambiar la dirección IP y cambiar la dirección del servidor DNS. A nosotros solo nos interesa cambiar la dirección IP de nuestra tarjeta de red, por lo que pulsaremos, si no lo esta ya la opción Usar la siguiente dirección IP: esto nos dejara modificar manualmente la dirección de la tarjeta. Es ahora cuando podemos poder los datos que estábamos reservando: Dirección IP: 192.168.1.100 y Máscara de subred: 255.255.255.0. en la puerta de enlace predeterminada no hace falta poner nada.
Una vez introducidos podemos cerrar todas las ventanas hasta que quede solo el IDE de arduino. Ya tendremos configurada la tarjeta de red en el mismo rango que el sistema Arduino y podremos llamar a la página web que tiene en su interior.

Ahora tenemos que abrir el Monitor Serie del IDE para ver las comunicaciones con la placa Arduino UNO. Pulsamos el botón que esta en la parte superior derecha con un símbolo de una lupa y se abrirá el monitor serie.
Este es un punto importante, ya que si todo ha ido bien, tenemos que tener en el monitor serie un mensaje que nos ha mandado el Arduino UNO. Este mensaje nos indica, para nuestra información, la dirección del servidor web. Si podemos ver este mensaje seguiremos adelante.

Llegó el momento de abrir el navegador. En mi caso abro el Edge del Windows 10 y tendremos una página en blanco. Nos vamos a la barra de dirección he introducimos la dirección del servidor web 192.168.1.177, para que el navegador pueda leer la pagina que el servidor le mande y pueda mostrarla. Una vez introducida la dirección pulsamos enter.

Si podemos ver algo similar a la imagen superior es que el navegador esta leyendo correctamente la página web del servidor.
Primero podemos ver en el monitor serie como el Arduino a detectado que un navegador esta solicitando la lectura de la página web. El servidor web le pregunta al navegador que se identifique y este le responde con una serie de parámetros que le identifican así como al ordenador donde se esta ejecutando, etc... Son datos que a nosotros no nos interesan, pero podrían servir en posteriores prototipos.
En el navegador vemos que la página web solo tiene seis lineas de texto que nos informan de la lectura del valor leído en cada entrada analógica. Podemos ver que el valor de la entrada cero esta a 0. Esto es porque tenemos el potenciómetro a tope girado hacia la patilla que esta unida a masa (GND). Las demás lecturas de la otras entradas analógicas dan valores aleatorios al estar al aire sin conexión.
Recordemos que esta configurada la página para recargarse cada 5 segundos y así actualizar el valor de las lecturas.

En este estado y con todo funcionando (cada 5 segundos se actualiza en navegador), movemos el potenciómetro al otro externo, o sea haca la patilla que tiene los 5V. La próxima vez que se actualice la vista del navegador veremos como la entrada analógica 0 indica el valor máximo que puede medir de 1023.
Podemos probar a poner otros estados intermedios del potenciómetro para ver las diferentes lecturas que provoca.

Con esto tendríamos probado el Arduino UNO y la placa Ethernet Shield que le provee de conexión a redes ethernet. Tenemos otros ejemplos dentro del IDE que podemos probar y avanzar dentro de este versátil Shield.

A continuación tenemos un video con todo el proceso completo.