ARDUINO ETHERNET SHIELD

Arduino Ethernet Shield

INROUDUCCIÓN.

El Shield Arduino Ethernet se conecta a Internet en cuestión de minutos. Sólo tiene que conectar este módulo en la placa Arduino, conectarlo a la red con un cable RJ45 y seguir algunas instrucciones sencillas para empezar a controlar el mundo a través de Internet. Como siempre con Arduino, todos los elementos de la plataforma - hardware, software y documentación - son de libre acceso y de código abierto.

Arduino Ethernet Shield permite a una placa Arduino conectarse a internet. Se basa en el chip Wiznet W5100 ethernet (hoja de datos). El W5100 Wiznet proporciona una red (IP) capaz de soportar conexión TCP y UDP. Soporta hasta cuatro conexiones de socket simultáneas. Utilice la biblioteca de Ethernet a escribir sketches que se conectan a Internet a través de la pantalla. El shield de Ethernet se conecta a una placa Arduino con largas Wire Wrap-headers que se extienden a través del shield. Esto mantiene la disposición de las clavijas intacta y permite que otro shield para ser apilados en la parte superior.

The Shield Ethernet tiene un estándar de conexión RJ-45, con un transformador de línea integrada y Power over Ethernet habilitado (PoE).

Hay una ranura para insertar una tarjeta micro-SD, que puede ser usado para almacenar archivos para servir a través de la red. Es compatible con el Arduino Uno y Mega (usando la biblioteca de Ethernet). El CODEC de lector de tarjetas microSD se puede acceder a través de la Biblioteca SD. Cuando se trabaja con esta biblioteca, SS es el pin 4.

El shield actual tiene una alimentación a través de Ethernet (PoE), módulo diseñado para extraer energía de una convencional de par trenzado Categoría 5 cable Ethernet:IEEE802.3af compliant. El Shield dispone de un conector RJ45 para conectarse a una red Ethernet. El botón de reinicio sirve para reiniciar el Shield y la propia tarjeta Arduino. El shield contiene un número de LEDs informativos:

• PWR: indica que Arduino y el shield están alimentados

• LINK: indica la conexión a una red y parpadea cuando el shield transmite o recibe datos

• FULLD: indica que la conexión de red es full duplex

• 100M: indica la presencia de una conexión de red 100 Mb / s (en lugar de 10 Mb / s)

• RX: parpadea cuando el shield recibe datos • TX: parpadea cuando el shield envía datos .

• L_COL: parpadea cuando se detectan colisiones de red.

El puente de soldadura de la marca "INT" puede conectarse para permitir que la placa Arduino reciba interrupciones y sean notificadas desde W5100, pero esta opción no está en la librería estándar de Ethernet. El puente conecta el pin INT del W5100 para pin digital 2 de la Arduino.

PRINCIPALES CARACTERÍSTICAS DEL MÓDULO ETHERNET SHIELD.

• Tensión de alimentación 5V (se alimenta directamente desde la tarjeta Arduino)
• Controlador Ethernet: W5100 con una memoria interna de 16K
• Velocidad de conexión: 10/100Mb
• Conexión con Arduino a través del Puerto SPI

CONECTANDO EL SHIELD.

El Shield Arduino Ethernet permite la inserción sobre una tarjeta convencional Arduino utilizando para su gobierno la librería Ethernet.

Para la puesta en marcha hay dos pasos fundamentales:

PRIMERO:

Para usar la Ethernet Shield solo hay que montarla sobre la placa Arduino (p. e. una Diecimila). Para cargar los sketches a la placa Arduino se conecta esta 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.

SEGUNDO:

Conectar la Ethernet Shield a un ordenador, a un switch o a un enrutador utilizando un cable ethernet standard (CAT5 o CAT6 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).

CONFIGURACIÓN DE LA RED.

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 más de una placa.

Una dirección IP válida depende de la configuración de su red. Es posible usar DHCP para asignar una IP dinámica a la placa, pero esto aún no está implementado como función. Opcionalmente se pueden especificar la dirección de difusión y la máscara de subred.

CONEXIÓN A UNA PÁGINA WEB (ARDUINO ACTÚA COMO CLIENTE).

para que arduino pueda conectarse a una página web, se necesita que tenga conectado el módulo ethernet shield en primera instancia. una vez montado en módulo, conectamos el módulo de arduino mediante usb al ordenador como se hace normalmente para poder descargarle el programa. una vez descargado el programa a la placa, se procede a conectar el cable de red (UTP cable directo) al ethernet shield.

para este primer programa, hay dos forma de decirle a arduino que se conecte a una pagina web x. en el entorno de desarrollo (ide de arduino) donde realizamos la programación, es donde se le indica al servidor que se va a conectar.

Formas.

1)sabiendo la direccion ip de la pagina que deseamos que se conecte arduino.

para esto se usa la siguiente línea de instrucción:

• byte serve[] = { x, ,y , z, w}; // a,y,z,w:direccion de la pagina servidor.

2)usando el siguiente comando:

• char server[] = "www.google.com"; // se usa DNS

COMO SABER LA DIRECCIÓN IP DE UNA PÁGINA WEB?

1. presionamos las siguientes teclas:  inicio + r

2. en la ventana que aparece escribimos: cmd

3. escribimos ping  www.google.com // encontramos la ip del servidor google.

4. anotar esta direccion ip que es la que ocuparemos en el programa, para indicarle a arduino que se desea conectarse a esa página web.

    en este ejemplo es: 74.125.227.51

PROGRAMA 1:

#include<SPI.h>

#include<Ethernet.h>

/* Pone la direccion mac en el controlador. los shields Ethernet mas actuales tienen una MAC impresa en una etiqueta pegada en ellos*/

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};

//IPAddress server(74, 125, 227, 51); //ip de Google
char server[] = "www.google.com";

/* Inicializar la biblioteca de cliente Ethernet Con la dirección IP y el puerto del servidor que desea conectarse (por defecto es el puerto 80 para HTTP):*/

EthernetClient client;

void setup() {

 // Abre el puerto serie para la comunicación:

 Serial.begin(9600); while (!Serial) {

    ; // esperar para para conectar. Necesario para Leonardo sólo

 }

 // inicia la conexión con Ethernet:

 if (Ethernet.begin(mac) == 0) {

    Serial.println("Falla la conexión configurada usando DHCP");

    // No tiene sentido seguir adelante, así que no hace nada:

    for (;;)

     ;

 }

 // intenta una segunda inicialización:

 delay(1000);

 Serial.println("conectando...");

 // si tienes una conexión, informar a través del puerto serie:

 if (client.connect(server, 80)) {

    Serial.println("conectado");

    // Make a HTTP request:

    client.println("GET /search?q=arduino HTTP/1.0");

    client.println();

 }

 else {

    // kf no recibió una conexión con el servidor:

    Serial.println("conexion fallida");

 }

}

void loop() {

 // Si hay bytes disponibles entrantes

 // Del servidor los lee e imprime:

 if (client.available()) {

    char c = client.read();

    Serial.print(c);

 }

 // Si el servidor está desconectado, se detiene el cliente:

 if (!client.connected()) {

    Serial.println();

    Serial.println("desconectar.");

    client.stop();

    // no hace nada:

    for (;;)

     ;

 }

}

PRUEBA1:

1. No se pudo conectar con el servidor.
   
   
    

2. Conexión exitosa con el servidor.
   
   
   
   

ARDUINO COMO SERVIDOR EN UNA RED ETHERNET: LECTURA DE 6 CANALES ANALÓGICOS DE LA TARJETA ARDUINO 1.

Arduino con la ayuda del módulo de ethernet, tiene la capacidad de funcionar como servidor. como el modulo ethernet se le asigna una direccion ip al momento de conectarlo al router o al modem, esa dirección es solamente para poder alcanzalo (debemos estar en el mismo segmento de red, para poder comunicarnos con arduino), podemos nuevamente hacer uso de la aplicacion ping y la dirección que se le asignó al arduino al momento de conectarlo al puerto.

En el entorno de programación, con la siguiente línea de instrucción le indicamos al arduino cual va a ser la direccion de la pagina servidora.

IPAddress ip(192, 168, 1, 177);// Por ejemplo puede ser esta direccion.

Con esta instrucción le indicamos que se desea servir una página web. HTTP corre sobre el puerto 80.

EthernetServer server(80);

pasos a seguir para indicarle a arduino que trabaje como servidor en una página web.

PROGRAMA 2:

1. copiamos el siguiente código:

#include <SPI.h>

#include <Ethernet.h>

// Escriba una dirección MAC y la dirección IP para el controlador.

// La dirección IP será dependiente de la red local:

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

IPAddress ip(192, 168, 1, 200); // ip de la página a servir

// Inicializar la librería de servidor Ethernet

// Con la dirección IP y el puerto que desee utilizar

// (Puerto 80 es el valor predeterminado para HTTP):

EthernetServer server(80); void setup() {

// Abre el puerto serie de comunicacion y espera:

 Serial.begin(9600);

 while (!Serial) {

    ; // poner aquí un delay de espera para que se conecte el puerto. Solo necesario para

    // Arduino Leonardo

 }

 // inicia la conexión y el servidor:

 Ethernet.begin(mac, ip);

 server.begin();

 Serial.print("server is at ");

 Serial.println(Ethernet.localIP());

}

void loop() {

 // Detectar los clientes entrantes

 EthernetClient client = server.available();

 if (client) {

    Serial.println("Nuevo cliente");

    // Una petición http termina con una línea en blanco

    boolean currentLineIsBlank = true;

    while (client.connected()) {

     if (client.available()) {

       char c = client.read();

       Serial.write(c);

       // Si se ha llegado al final de la línea recibirá una nueva línea

       // con un carácter en blanco, la petición http ha terminado,

       // Para que pueda enviar una respuesta

       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("Conexion Cerrada: cerrada");

         client.println("Refresh: 2");  // refresca cada 2 seg los valores

         client.println();

         client.println("<!DOCTYPE HTML>");

         client.println("<html>");

         client.print("VALORES DE ENTRADAS ANALOGICAS ");

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

// Añadir una etiqueta para conseguir que el navegador se actualice cada              //5 segundos: client.println("<meta http-equiv=\"refresh\" //content=\"5\">");

         // salida del valor de cada entrada analogica

         for (int analogChannel = 0; analogChannel < 6; analogChannel++) {

           int sensorReading = analogRead(analogChannel);

           client.print("Entrada analogica: ");

           client.print(analogChannel); client.print(" es ");

           client.print(sensorReading);

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

         }

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

         break;

       }

       if (c == '\n') {

         // se inicia una nueva línea

         currentLineIsBlank = true;

       }

       else if (c != '\r') {

         // ha llegado a un carácter en la línea actual

         currentLineIsBlank = false;

               }

         }

    }

    // facilita al navegador web un tiempo para recibir los datos

    delay(1);

    // cierra la conexión:

    client.stop();

    Serial.println("Cliente desconectado");

 }

}

2) compilar y cargar el programa a la placa arduino.

3) para corroborar de que todo va bien; hacemos lo siguiente:

1. presionamos: inicio + r (para windows)
2. escribimos cmd en la venta que aparece.
3. hacemos  ping a la ip de la página servidora. (ping 192.168.1.200)
   
   
   
   

  

   d. si les aparece la ventana anterior, “felicidades”, todo fue un éxito.

PRUEBA 2:

por último, nos vamos a nuestro navegador (chrome, mozilla, etc) y escribimos en la barra de direccion (URL) la ip de nuestro servidor web (192.168.1.200)

PROYECTO FINAL.

CONTROL DE ILUMINACION RESIDENCIAL.

CODIGO

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

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFF, 0xEE}; // direccion MAC de tu Ethernet
byte ip[] = {192, 168, 1, 177};  // ip que le pones dentro de tu red
EthernetServer server(80);  //   Normalmente seria la 80

int dig[] =  {2,3,4,5,6,7,8,9}; // pines digitales a usar. No uso 0 y 1 que son de transmisin serie
                                // Tampoco uso el 10,11,12 y 13 ya que los uso para la ethernet
int digTotal = 8;  // Numero de pines a usar
int vdig[] = {0,0,0,0,0,0,0,0}; // valores iniciales (Tantos como pines usemos)
int pin;
int nivel;
String cad = String(100);

void setup()
{
  Ethernet.begin(mac, ip); // inicio la Ethernet
  server.begin();          // inicio el servidor
  Serial.begin(9600);      // inicio el serial monitor
  Serial.print("server is at: ");
  Serial.println(Ethernet.localIP());
 
  for (int i=0; i < digTotal; i++)
  {
    pinMode(dig[i], OUTPUT);   // inicializo los pines digitales como salida
    digitalWrite(dig[i],vdig[i]);  // los pongo a nivel bajo LOW=0
  }
}

void loop()
{
  cad = ""; // inicializo la cad donde almaceno los datos recibidos
  EthernetClient cliente = server.available();
  if (cliente)
  {
    while(cliente.connected())
    {
      if(cliente.available())
      {
        char c = cliente.read();
        cad = cad + c;
        Serial.print(c);

        if(c == '\n')
        {
          if (cad.lastIndexOf("dig") > -1) // si la variable cad contiene 'dig' hacer ...
          {
            pin = pinElegido(cad);
            int posicionPin;
            for (int i=0; i <digTotal; i++)
            {
              if (dig[i] == pin)
              {
                posicionPin = i;
                break;
              }
            }
            nivel = nivelElegido(cad);
            vdig[posicionPin] = nivel;

            Serial.print(pin);  // comprobamos que el pin elegido es el correcto
            Serial.println(" pin.   --  ");
            Serial.print(nivel); // comprobamos su nivel 0=LOW y 1=HIGH
            Serial.println(" nivel ");
           
            digitalWrite(pin, nivel);  // activamos o desactivamos el pin elegido
           
          }  // ... hasta aqui 'dig'
         
          if (cad.lastIndexOf("apaga") > -1)  // si la variable cad contiene 'apaga' ejecuta
          {                                    // la funcion apagaTodos()
            apagaTodos();
          }
         
          if (cad.lastIndexOf("encender") > -1) // si cad contiene 'encender' ejecuta
          {                                     // la funcion enciendeTodos()
            enciendeTodos();
          }
          // Comienza la transmision de datos desde el servidor al cliente
          cliente.println("HTTP/1.1 200 OK");
          cliente.println("Content-Type: text/html");
          cliente.println();
         
          cliente.println("<HTML>");
          cliente.println("<HEAD>");
          cliente.println("<meta name='apple-mobile-web-app-capable' content='yes' />");
          cliente.println("<meta name='apple-mobile-web-app-status-bar-style' content='black-translucent' />");
          cliente.println("<link rel='stylesheet' type='text/css' href='http://randomnerdtutorials.com/ethernetcss.css' />");//da el formato centrado
          cliente.println("<TITLE>Arduino Server</TITLE>");

          cliente.println("</HEAD>");
          cliente.println("<BODY>");
          cliente.print("<marquee id='ejemplo' direction='right'>Ing. Electrica-Electronica</marquee>");

          cliente.print("<h1><center>Control de iluminacion</center></h1>");
          cliente.print("<hr>");
                  
          //cliente.println("<marquee id='ejemplo' direction='left'>Fes Aragon</marquee>");
         
          cliente.println("<img border='0' src='http://r23.imgfast.net/users/2314/14/04/12/album/bloodm10.gif' _fcksavedurl='http://r23.imgfast.net/users/2314/14/04/12/album/bloodm10.gif' style='position:fixed; top:0; left:0; width:100%; height:150px;'/>");
         
    
          cliente.println("<br>");
          cliente.println("<br>");
          //cliente.println("<br>");

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

          for (int i=0; i < digTotal; i++)
          {
              cliente.print("Digital ");
              cliente.print(dig[i]);
              cliente.print(" ");
   
              if (vdig[i]==1)
              {
                cliente.println("<font color='green'>ON</font>");
                cliente.print("<form method=get><input type=hidden name=dig");
                cliente.print(dig[i]);
                cliente.print(" value=0><input type=submit value=OFF></form>");
              }
              if (vdig[i]==0)
              {
                cliente.println("<font color='grey'>OFF</font>");
               // cliente.println("<td>");
                cliente.print("<form method=get>");
                cliente.print("<input type=hidden name=dig");
                cliente.print(dig[i]);
                cliente.print(" value=1>");
                cliente.print("<input type=submit value=ON>");
                cliente.print("</form>");          
              }
          }         
          cliente.print("<form method=get><input type=hidden name=apaga");
          cliente.println(" value=1><input type=submit value=APAGA_TODOS></form>");
               
          cliente.println("<form method=get><input type=hidden name=encender");
          cliente.println(" value=1><input type=submit value=ENCENDER_TODOS></form>");
                
          cliente.stop();
        }
      }
    }
  }
}



//////////////  FUNCIONES /////////////////7
// Funcion: Extrae el pin del array cad (contiene la lectura de lo que el cliente devuelve)
int pinElegido(String cad)
{

    int pos_dig = cad.lastIndexOf("dig");
    int pos_igual = cad.lastIndexOf("=");
    char vpin1 = cad.charAt(pos_dig+3);
    char vpin2 = cad.charAt(pos_dig+4);
    if (vpin2 != '=')
    {
      vpin1 += vpin2;
    }
   
    int pinElegido = vpin1 - 48; //.toInt();
    return pinElegido;
}
// Funcion: Extrae en nivel de la cadena cad
int nivelElegido(String cad)
{
  int pos_igual =  cad.lastIndexOf("=");
  char v = cad.charAt(pos_igual+1) - 48;
  if (v == 0) return 0;
  if (v == 1) return 1;
}
// Funcion para apagar todos los leds al tiempo
void apagaTodos()
{
  for (int i=0; i < digTotal; i ++)
  {
    vdig[i] = 0;
    digitalWrite(dig[i], vdig[i]);
  }
}
// Funcion para encender todos los leds al tiempo
void enciendeTodos()
{
  for (int i=0; i < digTotal; i ++)
  {
    vdig[i] = 1;
    digitalWrite(dig[i], vdig[i]);
  }
}

FUENTES:

http://www.wiznet.co.kr/UpLoad_Files/ReferenceFiles/W5100_Datasheet_v1.2.2.pdf

http://www.arduino.cc/en/Main/ArduinoEthernetShield

http://www.arduino.cc/en/Tutorial/WebClient

http://www.arduino.cc/en/Tutorial/WebServer