Resumen de conceptos básicos en redes Ethernet con protocolo TCP-IP Obtener una dirección IP automáticamente

Transcripción

1 Resumen de conceptos básicos en redes Ethernet con protocolo TCP-IP Cuando se realiza una conexión de dispositivos para formar una red local cada uno de los nodos (dispositivos que forman la red) que se conectan debe usar el protocolo de comunicaciones denominado TCP_IP y, por lo tanto, debe cumplir con algunas normas. La primera es que para acceder a una red local con protocolo TCP, el adaptador (tarjeta) de red tiene que tener un identificador único llamado dirección MAC, (Media Acces Control) que normalmente viene fijado en el hardware (En Arduino la pondremos a mano). La segunda para acceder a una red IP, es tener una dirección IP única de 4 cifras comprendidas entre 0 y 255, de la forma A.B.C.D y además una máscara de subred, que determina con quien se puede o no establecer comunicación. Al entrar en la configuración de la red en Windows, encontramos algo como esto: Donde la dirección IP está formada por 4 números desde 0x00 hasta 0xFF en hexadecimal o desde 0 hasta 255 en decimal, con excepción del 0 y el 255 que se usan para otras funciones. Para unirse a una red local hay que proporcionar una dirección IP válida en el rango de la subred. A grandes rasgos, si la red es parecida a la de arriba, significa que la dirección IP debe ser del tipo xx y no coincidir con otra que ya esté en uso. Es decir, la máscara de subred nos dice el rango de variación que puede tener nuestra ip. Además hay que proporcionar la ip del Router, muy frecuentemente en redes domésticas se configura como , que es el encargado de gestionar la conexión a direcciones externas a tu red (Internet) y también conviene darle un servicio de DNS para resolver los nombres de dominio externos. Cuando se configura una red local es cada vez más frecuente elegir la opción de configuración automática mediante el servicio de DHCP, a condición de que tal servicio exista en la red, eligiendo en el menú anterior la opción: Obtener una dirección IP automáticamente. DHCP significa Dynamic Host Control Protocol, o protocolo de control de nodo dinámico. Significa que cuando tú ordenador o teléfono despierta, levanta la mano pidiendo la vez y si el servicio existe, configura automáticamente la conexión a tu red de forma dinámica y sin intervención manual. Si te conectas a Internet con un ADSL o conexión por cable, es muy probable que este protocolo configure la conexión. Por último, el servicio de DNS. Hoy en día casi no se memoriza ningún número de teléfono de amigos o familiares. Cuando se eliges el nombre, el teléfono marca el número asociado y así nos evita memorizarlos. Con las direcciones de internet ocurre lo mismo. Su dirección física es una dirección IP que cuesta recordar. Por ejemplo, si cada vez que se busca algo hubiese que teclear la dirección de Google, sería problemático, porque es fácil de olvidar: Al escribir esa dirección en el navegador nos lleva a Google, porque en realidad hay servicio subterráneo llamado DNS o servidor de nombres de dominio, que traduce el texto, que nos resulta natural y fácil de memorizar, por la dirección IP, que sería difícil de recordar. De hecho, si un servidor de Internet cambia de dirección física, por traslado o por cualquier otro motivo, basta con que actualice la dirección en la tabla del DNS y conserve el nombre.

2 Los Puertos El protocolo IP se diseñó, con el concepto de cliente servidor. Esto significa que unos equipos hacen de Servidores mientras que la mayor parte de los nodos (equipos) de la red son clientes que demandan servicios. El tipo de servicios que se demandan son variados, por ejemplo, DCHP o DNS, pero también Servidores Web, para mostrar las páginas web disponibles. Habitualmente un mismo servidor físico, se destina a proporcionar varios servicios. No es raro que un mismo servidor actúe como Web Server y además proporcione servicios de DHCP y DNS, además de servidor de ficheros y otros. Por eso, se requiere que la máquina física decida con rapidez a cuál de sus servidores internos corresponde una petición determinada. Cada una de las peticiones que llegan vía Ethernet, llevan una propiedad que define exactamente esto, se llama puerto. En TCP se puede asignar un servicio a un nº de puerto comprendido entre 0 y , es decir entre 0 y De este modo, un mensaje IP tiene una dirección IP que determina el nodo o equipo de la red a quien se destina y un puerto, que determina el servicio interno de ese equipo que debe responder a la petición. Cuando se pone en marcha un servidor, se le asigna un puerto para que escuche peticiones. Es algo parecido a un buzón numerado, de forma que el servidor, pueda responder a quien se dirija a él. Este número de puerto tiende a ser estándar, de modo que, para servicios habituales ya se sabe el puerto en que el servidor va a escuchar. Por ejemplo, lo habitual es que un servidor web escuche el puerto 80, de modo que un desconocido puede acceder a la página web que alberga. Algunos puertos normalizados son: 21 FTP Servicio de transferencia de ficheros 25 SMTP Transporte de 80 HTTP Servidor Web 110 POP3 Recogida de correo Es posible cambiar el puerto de escucha de un servidor, asignándole un puerto privado, pero conviene entender que al hacerlo, solo quien conozca el puerto redirigido, podrá acceder al servidor (Lo que en ocasiones, es muy interesante por razones de seguridad). Los Shield de Arduino. El shield Ethernet Una ventaja de trabajar con un Arduino, es que la comunidad ha ido creando gran cantidad de placas electrónicas listas para añadirle. En muchos casos son placas que vienen diseñadas para encajar encima de los pines hembra de que dispone Arduino, añadiéndole funcionalidad. A este tipo de placas prediseñadas para encajar en los pines de Arduino se les llama genéricamente Shields (Escudos), y en este caso vamos a utilizar un shield Ethernet que nos da acceso a la red local de que dispongamos. Para ello lo primero es encajar el shield en Arduino: Debe hacerse con el Arduino apagado. Los pines tienen que encajar con suavidad primero, y después presionar cuidadosamente asegurando que todos los pines encajan en los conectores de abajo. Una vez que haya encajado se puede alimentar el Arduino y al conectar el cable de red, debería tener un aspecto similar a este:

3 Conexión del Shield con DHCP Primero vamos a comprobar si en nuestra red existe un servidor DHCP, que sirve para asignarnos una dirección IP al arrancar. Vamos a probar con uno de los ejemplos que se incluye con la librería Ethernet. Tenemos que importar en primer lugar un par de librerías, la SPI y la Ethernet. Puede hacerse directamente desde \\programa\importarlibreria #include <SPI.h> #include <Ethernet.h> Se define una dirección mac. Lo normal es que no de problemas la habitual, pero si se va a usar más de un Shield, hay que cambiar al menos una ya que tienen que ser diferentes para cada nodo. byte mac[] = { 0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x02 ; EthernetClient client; // Creamos una instancia de cliente Ethernet void setup() { Serial.begin(9600); // inicializamos el Puerto serie Serial.println("Buscando DHCP..."); La librería Ethernet, si no se suministra una dirección IP propia, al inicializar, intentara conseguir una dirección mediante DHCP automáticamente, y devolverá 1 si lo consigue y 0 en caso contrario: if (Ethernet.begin(mac) == 0) //Si devuelve error { Serial.println("No ha sido posible configurar la Ethernet por DHCP"); while (true; ) ; // No sigas, quédate aquí eternamente Si por el contrario devuelve un valor positivo, habrá rellenado un array Ethernet.localIP()[4],de 4 bites, con la dirección IP obtenida del DHCP Serial.print("Mi direccion IP es: "); for (byte B = 0; B < 4; B++) { Serial.print(Ethernet.localIP()[B], DEC); Serial.print("."); Serial.println(); El programa imprimirá, la dirección IP obtenida. Antes de cerrar el tema el DHCP, aquí vemos un programa completo para conectar a la red. #include <SPI.h> #include <Ethernet.h> byte mac[] = { 0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x02; EthernetClient client; void setup() { Serial.begin(9600); Serial.println("Buscando DHCP..."); if (Ethernet.begin(mac) == 0) { Serial.println("Error al configurar DHCP"); for (;;) ; //No tiene sentido seguir Serial.print("Direccion IP : "); for (byte B = 0; B < 4; B++) { Serial.print(Ethernet.localIP()[B], DEC); Serial.print("."); Serial.println();

4 Serial.print("Router por defecto : "); for (byte B = 0; B < 4; B++) { Serial.print(Ethernet.gatewayIP()[B], DEC); Serial.print("."); Serial.println(); Serial.print("Subred: "); for (byte B = 0; B < 4; B++) { Serial.print(Ethernet.subnetMask()[B], DEC); Serial.print("."); Serial.println(); Serial.print("DNS: "); for (byte B = 0; B < 4; B++) { Serial.print(Ethernet.dnsServerIP()[B], DEC); Serial.print("."); Serial.println(); void loop() { La salida será: Al recurrir al DHCP, hay que tener presente que tiene un coste en uso de memoria. Para economizarla se puede especificar solamente la IPAddress.ip y Arduino asignara por defecto al Gateway la dirección 1 dentro de la subred. Conexión del Shield sin DHCP Si en la red no hay disponible un DHCP, o se necesita la memoria que usa, tenemos que determinar nuestro rango de direcciones y asignarlas manualmente a nuestro Shield Ethernet. En Windows se puede abrir la consola del sistema para comprobar el rango que utiliza nuestra red. En Cortana se escribe CMD y pulsar intro. Saldrá la consola. En ella usamos ipconfig y pulsar intro.

5 Esos valores muestran los datos de la conexión. Como la dirección IP es la , lo lógico es probar una dirección del tipo xx, donde xx es un valor entre 0 y 255, que no coincida con otra dirección de la red. Para forzar al Shield a una dirección determinada, sin recurrir al DHCP, se puede hacer creando antes de llamar a Ethernet.begin (mac), uno o varios arrays de 4 bytes: byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED ; IPAddress ip(192,168,1, 177); IPAddress gateway(192,168,1, 1); IPAddress subnet(255, 255, 0, 0); Con definir la IPAddress.ip es suficiente. El resto de los valores se asignan por defecto. Además si no vamos a salir a Internet, ni acceder a nuestro Arduino desde internet, no será necesario definir la Gateway. Arduino como cliente Web El IDE incluye un ejemplo muy interesante de acceso a Google desde la red Ethernet. Haremos una petición de búsqueda en Google desde nuestro programa y mostraremos el resultado en el puerto serie. Es importante tener en cuenta lo siguiente: El volumen de información que genera el acceso a páginas Web es muy grande, aun en los casos más sencillos, porque hay mucha información de gestión que normalmente el usuario no ve y que ahora va a aparecer. Es recomendable poner la velocidad del puerto serie a bps, porque si no, la consola va a tardar. Una vez que haya finalizado la recepción de texto HTML en la consola, se puede seleccionar y copiar el texto en un editor externo como el notepad, y guardarlo con la extensión HTML y no txt. Haciendo doble click en el fichero así guardado abrirá el navegador con la respuesta, A continuación vemos el ejemplo Ethernet\WebClient #include <SPI.h> #include <Ethernet.h> byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED ; //IPAddress server(74,125,232,128); // IP de Google (sin DNS) char server[] = " // dirección para Google (usando DNS) IPAddress ip(192, 168, 1, 177); // Dirección IP estática para usar si el DHCP falla EthernetClient client ; void setup() { Serial.begin(115200); if (Ethernet.begin(mac) == 0) { Serial.println("Fallo buscando DHCP"); Ethernet.begin(mac, ip); delay(1000); // Esperar a que Ethernet se inicie Serial.println("conectando..."); if (client.connect(server, 80)) { Serial.println("conectado"); client.println("get /search?q=arduino HTTP/1.1"); // Creando una petición HTTP client.println("host: client.println("conexión: cerrada"); client.println(); else Serial.println("error de conexión"); void loop() { if (client.available()) { char c = client.read(); Serial.print(c); if (!client.connected()) // Si no hay conexion { Serial.println(); Serial.println("desconectando.");

6 client.stop(); while (true) ; // No hagas mas Arduino como servidor Web en la red local Vimos como conectarnos a la red local y salir a consultar una página Web externa. Es decir ser clientes de internet para conseguir recoger alguna información de la red. Pero en muchas ocasiones, es muy práctico publicar el resultado de unos sensores en la web para poder consultarlos en remoto. Para ello montaremos un pequeño circuito conectando un potenciómetro a la entrada A5 y publicaremos los valores para poderlos consultar desde la red local. Es mucho más fácil publicar una página web con los valores precisos, como servidor, de lo que es interpretar lo que se recibe de una consulta como cliente. Diagrama del circuito Simplemente se conecta el Shield Ethernet sobre Arduino y después el sensor al pin A5, junto con 5v y gnd. Hay que tener en cuenta que los Shields necesitan comunicarse con Arduino de alguna manera y por tanto utilizan pines digitales o analógicos que no pueden usarse para montajes. En el caso del Shield Ethernet, utiliza los pines SPI para comunicarse con Arduino y por ello no se pueden usar los pines D11, D12, y D13 en Arduino UNO. Además, la mayor parte de las Shields Ethernet incluyen un lector de tarjetas SD o micro SD por lo que otro pin adicional queda reservado. En el Arduino UNO suele ser el pin D10. El programa de control #include <SPI.h> #include <Ethernet.h> // El shield Etherent usa SPI byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED ; IPAddress ip(192,168,1,177); // Esta IP se puede modificar si es necesario EthernetServer server(80); // creamos el objeto del servidor en el puerto estandard 80 Se fija la dirección MAC y la IP, se inicializa el servidor Web en el puerto 80 (el habitual para servidores web). Se podría cambiar la dirección de escucha del servidor asignando un puerto diferente, pero entonces solo quien supiera el nuevo puerto podría acceder al servidor web. Si el nuevo puerto fuera el 1256, por ejemplo, para acceder, la dirección seria: : 1256 void setup() { Serial.begin(9600); Ethernet.begin(mac, ip); server.begin(); // Inicia el servidor web Serial.print("Servidor Web en la direccion: "); Serial.println(Ethernet.localIP()); Para entrar con la función loop, hay que entender que los códigos HTML, son un lenguaje de descripción de páginas que consisten en etiquetas de texto que indican a tu navegador como mostrar la información de una página concreta.

7 Todos los navegadores ofrecen la capacidad de mostrar el código de la página web visualizada. En Firefox o Chrome, apuntando a la página y dando al botón derecho sale la opción ver código fuente de la página. El objetivo no es que se entienda el código mostrado, sino que se vea que, por complicada que sea una página, se describe con texto. Así que lo que se va a hacer es construir una página Web (muy sencilla) que entrega valores a quien lo solicite. Ese texto que conforma la página Web estará formado por una cabecera HTML y unos textos y valores numéricos que representan la lectura del potenciómetro. Sin entrar en detalle en el tema del HTML digamos que lo primero que tendremos que hacer es entregar unas cabecera de texto, con las reglas de HTML, para que el navegador al otro extremo los entienda. La cabecera será: HTTP/ OK Content-Type: text/html Connection: close Refresh: 3 <!DOCTYPE HTML> <html> Y después enviar los valores leídos del sensor junto con algún texto explicativo de lo que son esos números, con formato HTML. Como ya se ha iniciado el servidor en el setup, ahora se comprueba periódicamente si hemos recibido peticiones de un cliente web, en caso afirmativo la propiedad available de server devolverá una entrada a la petición de un cliente, y en caso negativo será 0: EthernetClient client = server.available() Por eso, si se crea un client, es decir, si client es diferente de 0, significa que tiene una petición de cliente y debe procesarla. void loop() { EthernetClient client = server.available(); // Esperamos entrada de cliente if (client) { Serial.println("nuevo cliente"); boolean actuallineaenblanco = true; // Las peticiones HTTP finalizan con linea en blanco while (client.connected()) { if (client.available()) { char c = client.read(); Serial.write(c); // Esto no es necesario, pero copiamos todo a la consola // A partir de aquí mandamos nuestra respuesta if (c == '\n' && currentlineisblank) { // Enviar una respuesta tipica client.println("http/ OK"); client.println("content-type: text/html"); client.println("connection: close"); client.println("refresh: 3"); // Actualizar cada 3 segs client.println(); client.println("<!doctype HTML>"); client.println("<html>"); int valor = analogread(a5); Serial.println(valor); // Leer el potenciómetro // Desde aqui creamos nuestra pagina con el codigo HTML que pongamos client.print( <head><title>situacion del lugar</title></head> ); client.print( <body><h1> Servidor Ethernet</h1><p>Lectura del potenciometro ); client.print(valor); client.print(" unidades</p>"); client.print("<p><em> La página se actualiza cada 3 sg.</em></p></body></html>"); break; if (c == '\n')

8 actuallineaenblanco = true; // nueva linea else if (c!= '\r') actuallineaenblanco = false; delay(10); // Para asegurarnos de que los datos se envia client.stop(); // Cerramos la conexión Serial.println("cliente desconectado"); Algunos comentarios respecto del programa. Client, Serial y también Ethernet tienen propiedades y métodos comunes. Por eso, lo mismo que podemos hacer Serial.print(), podemos hacer client.print y cumple con exactamente las mismas reglas. Usamos client.print, para enviar un String de texto al navegador que hay al otro extremo de la conexión abierta. Igualmente hemos usado client.connected(), para comprobar si alguien ha conectado con el servidor y después usamos client.available(), para determinar si nos ha enviado algún mensaje. Cuando client.available() toma un valor no nulo, sabemos que hay que leer ese mensaje y usamos client.read(). Si os dais cuenta, los conceptos que usamos para leer de un cliente web, son los mismos que usamos para leer de una consola serie y se llaman igual. Controlando un LED por Ethernet (Control de pines digitales) Vamos a ver un programa tipo, que nos permita manipular un LED conectado a nuestro Arduino mediante una página Web. Para ello, vamos a presentar pequeños snippets (fragmentos) de HTML que nos permitan hacerlo, sin entrar en grandes detalles del lenguaje, pero que vamos a emplear en nuestros programas. EL primero, es un snippet que nos permite mostrar un checkbox en nuestra página y reconocer si se ha pinchado o no: <!DOCTYPE html> <html> <head> <title> Control de LEDs en Arduino</title> </head> <body> <h1>led remoto</h1> <p>haz click para conmutar el LED.</p> <form method="get"> <input type="checkbox" name="led2" value="2" onclick="submit();">led2 </form> </body> </html> Como norma general, lo que se presenta entre < > se llaman tags y describen algo en concreto, títulos, cabeceras, negritas. Por ejemplo para indicar al navegador que comienza el código HTML, debemos empezar con <html> y finalizar con </html>, lo mismo ocurre con los demás tags, como < head> cabecera, <body> cuerpo, o <p> párrafo, que cuando finalizan incorporan un tag con el símbolo / para indicar el fin del tag. En el snippet de arriba, hemos usado un método HTML para mostrar un checkbox y enviar un texto cuando se pulse. Si se copia ese código con un editor de textos y se guarda con extensión htm, al abrirlo con el navegador:

9 En la imagen de la derecha se ve que al pulsar el checkbox, el navegador añade al final de la dirección IP, el texto?led2=2. Utilizamos este texto de respuesta para controlar el encendido o apagado del LED. Para ello se usa la función indexof() que nos devuelve si un string está incluido o no en otro. Vamos a usar un LED conectado al D2 con sus resistencia. El programa de control La mayor parte del programa va a ser similar al programa de la sesión anterior, con algunas modificaciones. Principalmente, serán crear un variable para almacenar el status del LED, y un String para registrar la petición que nos hace el cliente Web: String HTTP_peticion; // String para guardar la petición HTTP del cliente boolean LED_estado = 0; // estado del LED, apagado por defecto El resto es casi igual, excepto porque cambiamos el código HTML que enviamos en la respuesta, para presentar el snippet del que hablamos más arriba, y porque hemos añadido una función ProcesarCheckbox() que hará el procesamiento del click (incluyendo enviar el HTML correspondiente a pulsado o no). Hay que fijarse en que se envian los comandos HTML, mediante client.print() a quien le pasamos los strings limitados por comillas. Pero como en este caso enviamos comandos HTML que también incluyen comillas, si se copian no funcionaría bien. La solución es preceder el carácter a imprimir por un carácter de escape para que el compilador sepa que no es el fin del string, si no parte de el. Por eso, si queremos mandar <form method= get > lo que tenemos que enviar con print es <form method=\ get\ >. #include <SPI.h> #include <Ethernet.h> byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED ; IPAddress ip(192,168,1,177); EthernetServer server(80); String HTTP_peticion; boolean LED2_estado = 0; // Para guardar la peticion del cliente void setup() { Ethernet.begin(mac, ip); server.begin(); Serial.begin(9600); pinmode(2, OUTPUT); void loop() { EthernetClient client = server.available(); // Comprobamos si hay peticiones if (client) // En caso afirmativo { boolean actuallineaenblanco = true; while (client.connected()) { if (client.available()) // Hay algo pendiente de leer { char c = client.read(); // Leemos los caracteres de uno en uno HTTP_peticion += c; // Los añadimos al String

10 if (c == '\n' && actuallienaenblanco) { client.println("http/ OK"); client.println("content-type: text/html"); client.println("connection: close"); client.println(); client.println("<!doctype html>"); // Envia la pagina Web client.println("<html>"); client.println("<head>"); client.println("<title>control de LEDs en Arduino</title>"); client.println("</head>"); client.println("<body>"); client.println("<h1>led</h1>"); client.println("<p>haz click para conmutar el LED.</p>"); client.println("<form method=\"get\">"); ProcesarCheckbox(client); client.println("</form>"); client.println("</body>"); client.println("</html>"); Serial.print(HTTP_peticion); HTTP_peticion = ""; // Una vez procesado, limpiar el string break; if (c == '\n') actuallienaenblanco = true; else if (c!= '\r') actuallineaenblanco = false; //nada pendiente de leer final de if (client.available // cliente desconectado final del While delay(10); // dar tiempo client.stop(); // Cerra conexion // fin del If client void ProcesarCheckbox(EthernetClient cl) { if (HTTP_peticion.indexOf("LED2=2") > -1) // buscamos cadena LED2=2 para saber si encender LED2_estado =!LED2_estado ; // Cada vez que se pincha el checkbox invertimos el valor digitalwrite(2, LED2_estado); // encendemos o apagamos el led if (LED2_estado) // si led encendido devolvemos checkbox marcado cl.println("<input type=\"checkbox\" name=\"led2\" value=\"2\" \\ onclick=\"submit();\" checked>led2"); else cl.println("<input type=\"checkbox\" name=\"led2\" value=\"2\" \\ onclick=\"submit();\">led2"); Acceso externo desde internet a nuestro Arduino Hemos visto como acceder al servidor Arduino, desde la red local, a través de un cable Ethernet. No es distinto acceder desde el exterior de la red. El esquema de una red local LAN, puede ser más o menos este:

11 Cada una de los equipos internos dispone de una dirección IP única, válida para la red interna. Normalmente son IPs en uno de dos rangos: xx.xx xx.xx Esta dos rangos están reservadas a direcciones IP privadas y no son enrutables, es decir el Router rechazará el acceso desde Internet a ellas. Por el contrario, las direcciones a las que accedemos desde Internet, las llamamos direcciones IP públicas y no pueden existir dos IPs públicas iguales bajo ninguna circunstancia. Cuando desde dentro de la LAN, se quiere acceder a una dirección pública, el Router utiliza el NAT, para enmascarar la dirección interna privada y utiliza su propia dirección pública para hacer la petición. Cuando recibe la respuesta, la reenvía al dispositivo que hizo la petición dentro de la LAN. Pero es importante entender aquí que: Siempre que el Router se enciende, recibe una dirección pública que le asigna la operadora telefónica, y que es la que usará para acceder a internet. Para saber con qué IP publica se está navegando (quien navega es el Router con su IP) se puede usar cualquiera de los servicios disponibles, por ejemplo y se verá que la IP privada es distinta de la pública. Para acceder al Arduino desde el exterior se puede utilizar esa IP, por lo menos hasta que se reinicie el Router (Y es algo que hacemos habitualmente con los servidores domésticos). Cuando se contrata con un proveedor una IP fija, se paga para que no cambie cuando se reinicia y por regla general también permite registrar en sus DNS públicos un nombre que apunte a la IP que se compra. Se pueden hacer pruebas a coste mínimo, usando alguna página como noip, que ofrecen soluciones gratuitas para encontrar tu dirección pública incluso cuando se reinicie el Router. Por otra parte, cuando alguien del exterior trata de entrar en la red local el router se lo va a impedir en principio, por lo tanto, tenemos que configurar el router para que no bloquee esas peticiones. Además de eso, dentro de la red local puede haber muchos dispositivos. A cuál de ellos debe enviar la petición? Para esto se inventó el Port Forwarding o redirección de puertos IP. Cómo diferenciamos una petición del exterior hacia el interior? Todas las peticiones que vengan por el puerto 80 podremos asumir, razonablemente, que son para el servidor Web interno. Así pues, bastaría con informar al Router, mediante una tabla de redirección de puertos, de que cualquier intento de llegar al interior de la red local por el puerto 80, HTTP, se desvíen, hacia la dirección interna del servidor Web. La limitación de este sistema es, que podemos poner tantos servidores como queramos detrás del Router o firewall, a condición de que solo haya uno de cada. No podemos poner dos servidores web en el puerto 80, porque todo lo que venga por el puerto 80, el Router hará un port forwarding a una única dirección. Actualmente todos los routers domésticos pueden administrarse desde una página web que sirve el propio Router en su dirección IP.

12 Si por ejemplo el Router tiene la dirección , accedemos a esa dirección con el navegador. Pedirá un nombre de usuario y clave de acceso para validar tu autorización. Hay cientos de modelos de routers, pero en todos ellos hay que buscar la definición de port forwandig. En un caso concreto, vemos las opciones que aparecen, en la columna de la izquierda, el menú del Router con la selección de Port Forwarding, y a la derecha la tabla de redirecciones, donde estas redireccionados varios puertos hacia dos IPs internas diferentes Aunque hasta ahora hemos hablado exclusivamente como si el Transporte fuera siempre TCP, lo cierto es que hay otro protocolo que se utiliza habitualmente, que es el UDP. Algunos servicios usan UDP y no TCP y cuando hacemos port Forwarding, se debe especificar (Aunque casi todos los routers modernos aceptan especificar ambos como arriba). Un último comentario, cuando accedes desde el exterior a tu servidor Arduino, vas a usar en tu navegador, la dirección pública de tu Router. Pero si intentas usar esa dirección pública exterior para entrar desde el interior de tu red local (por ejemplo cuando usas tu teléfono WIFI) algunos routers lo detectan como un intento de violar la seguridad y bloquearán. Otros routers pedirán una clave para pasar, que será la del Router, en cuyo caso accedes a la página Web de administración y no con el servidor interno en Arduino. Es decir, cuando se está conectado por Ethernet o WIFI, se tiene que utilizar la IP privada interna. Cuando se está fuera de la LAN, se utiliza la dirección pública.