loT con Arduino NodeMcu ESP8266 + Potenciometro en internet 2019

Usaremos una plataforma IoT (gratis) para ver desde cualquier parte del mundo el valor que un potenciómetro tiene al variarlo, esto con la tarjeta NodeMcu basada en el ESP8266 conectada a internet.


Y todo este proceso tendrá su explicación paso a paso porque aquí nadie nace aprendido y los detalles más pequeños pueden ser de mucha ayuda para aquellos que recién empiezan con el tema de IoT y similares.

Haciendo IoT con NodeMcu + Potenciómetro

Como ya había hecho mención párrafos arriba el objetivo variar un potenciómetro que estará conectado a nuestra tarjeta NodeMcu, dicho dato será visualizado en una plataforma de IoT tal que desde cualquier parte del mundo alguien pueda ver como se comporta en vivo, sin más que decir empecemos:

1. ¿Qué usaremos?

- x1 Tarjeta NodeMcu v3.0 de LoLin (si tienes otra versión no hay lío)
- x1 Potenciómetro de 5K
- Cables de conexión (Hembra-Hembra ó Hembra-macho)
- x1 Cable micro USB (Con el que cargamos el celular servirá)
- Plataforma IoT Asksensors 
- IDE Arduino

¡Listo! Con lo anterior podemos hacer el tutorial rápidamente.


2. Crear y configurar cuenta IoT en Asksensors 

En internet  hay cientos de plataformas para IoT sin embargo he decidido tomar esta por su extrema facilidad pues es casi un "Plug & Play" y es lo que buscamos en SkullTrap al compartir un tutorial o proyecto, que sea claro, preciso  y lo más fácil posible, aunque otras plataformas IoT tienen mejores funciones y son más avanzadas, usar Asksensors será suficiente para ver una o más variables graficarlas, exportar dichos datos y tratarlos así que veamos:

2.1. Nos registraremos en asksensors seleccionando la cuenta gratis (Click para ir), una vez nos registramos vamos al dashboard de asksensors:


2.2. Ya en el dashboard vamos a crear un nuevo sensor dando click en "+New sensor" asignamos un nombre, ahora creamos un módulo dando en "+Add module" deberá quedarnos un módulo agregado así:

Module1 creado

2.3. Hecho lo anterior bajamos un poco y guardamos cambios en "Save", luego nos cargará los detalles de nuestro sensor "Sensors details" de estos datos por ahora sólo necesitaremos la API key in, así que la copiaremos para usarla más adelante:


2.4. Agregaremos el sistema de gráficos que nos mostrará el comportamiento del potenciómetro al variarlo, como se ve en la imagen anterior vamos a la pestaña (2) Modules luego a "+Add graph" y dejaremos en Type "Line" para registrar todo el comportamiento del potenciómetro, finalmente damos click en "Save": 


Y nos saldrá un cuadro de gráfico vacío pero con el espacio listo para tratar los datos (Cosa que haremos cuando programemos nuestra nodeMcu):



3. Cómo conectar potenciómetro 5k a NodeMcu

Sabemos que lo que proporcionará el potenciómetro será un dato análogo entonces requerimos un pin análogo de la NodeMcu (Que sólo trae uno) para ello la identificación de todos los pines está en esta imagen:
Clic en imagen para ampliar
El pin conversor Análogo-Digital será el A0 en la tarjeta ¡Fácil! además hay que recordar que la resolución de dicho conversor es de 10 bits lo que se traduce en que podremos manejar y ver valores entre 0 a 1023.

3.1. Sabido lo anterior la conexión a realizar será simple y estará lista así:

Clic en imagen para ampliar

4. Programar NodeMcu para IoT usando API

Nota: Si compraste tu NodeMcu pero es la primera vez que la conectas a tu pc debes instalar el driver de la tarjeta y configurarla con el IDE de Arduino para programarla, da click aquí para ir al tutorial que tenemos para ello.

4.1. Ya con la tarjeta NodeMcu configurada podemos ir al siguiente paso, abrimos el IDE de Arduino y como he mencionado al principio usaré la tarjeta NodeMcu v3.0 si tienes esta entonces vamos a Herramientas > Placa > NodeMcu 1.0(ESP-12E Module) luego seleccionamos Upload Speed > 115200 conectamos la tarjeta y escogemos el puerto COM correspondiente que nos salga:


4.2. ¡Importante! Lo siguiente será instalar la librería ESP8266WiFi, entonces vamos a Programa > Incluir Librería > Administrar Bibliotecas escribimos ESP8266WiFi e instalamos la que dice IoTtweet by Isaranu Janthong:



4.3. Con la librería lista finalmente programaremos nuestra NodeMcu con el siguiente código:
/*API DESARROLLADA POR AskSensors código traducido 
y modificado al español por Andrés Lozano 
de SkullTrap Electronics - www.skulltrap.co */

#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <ESP8266WiFiMulti.h>
#include <ESP8266HTTPClient.h>

// Configuración Inicial
const char* wifi_ssid = "NOMBRE RED WIFI";     // SSID - Nombre red Wifi
const char* wifi_password = "CLAVE RED WIFI";  // Clave Wifi
const char* apiKeyIn = "AQUI VA LA API KEY";   // API KEY IN
const unsigned int writeInterval = 300;   // Tiempo de actualización (en ms)

// Configuración API asksensors
String host = "http://api.asksensors.com";  // Host de API
    
ESP8266WiFiMulti WiFiMulti;

void setup() {

  Serial.begin(115200);
  Serial.println("*****************************************************");
  Serial.println("********** Programa Inicial :  ESP8266 a AskSensors sobre HTTP");
  Serial.println("Esperando WiFi... ");
  Serial.print("********** Conectando al WiFi : ");
  Serial.println(wifi_ssid);
  WiFi.begin(wifi_ssid, wifi_password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  
  Serial.println("");
  Serial.println("-> Conectado al WiFi");
  Serial.println("-> Direccion IP: ");
  Serial.println(WiFi.localIP());

//Lectura Inicial de Potenciómetro  
pinMode(A0, INPUT); 
}

void loop() {

int POT = analogRead(A0);
Serial.print("Pot-5K = ");
  Serial.println(POT); //Imprimo valor de Potenciómetro

    // Espera para la conexión WiFi
  if (WiFi.status() == WL_CONNECTED){

        HTTPClient http;

        Serial.print("[HTTP] Iniciando...n");
        
        // Creo la URL para enviar la petición concatenando los datos
        String url = "";
        url += host;
        url += "/write/";
        url += apiKeyIn;
        url += "?module1=";
        url += POT;        // Variable del potenciometro concatenada en la URL
        
        Serial.print("********** solicitando URL: ");
        Serial.println(url);
        http.begin(url); //HTTP
        
        Serial.println("> Solicitud enviada a ASKSENSORS");

        Serial.print("[HTTP] GET...n");
        // Inicio la conexión y envío peticion GET
        int httpCode = http.GET();

        if(httpCode > 0) {
           Serial.printf("[HTTP] GET... codigo: %dn", httpCode);
            if(httpCode == HTTP_CODE_OK) {
                String payload = http.getString();
                Serial.println(payload);
            }
        } else {
            Serial.printf("[HTTP] GET... fallido, error: %sn", http.errorToString(httpCode).c_str());
        }

        http.end();

        Serial.println("********** Fin ");
        Serial.println("*****************************************************");
    }

    delay(writeInterval);   // Espera el tiempo de actualización
}

Sobre el código

- ¡Importante! En las líneas 11, 12 y 13 se debe reemplazar respectivamente el texto entre las comillas dobles por el nombre exacto de nuestra red WiFi, la clave WiFi y la Api Key In que obtuvimos en el paso 2.3.

- Línea 14 se establece el intervalo de actualización en milisegundos esto irá directamente ligado a cada cuánto se enviará el dato del potenciómetro a la plataforma IoT.

- Línea 17 contiene la URL a la que se conecta en este caso allí se validará la API Key ingresada en la línea 13, no se debe modificar.

- Línea 46 a 48  a cargo de leer el valor del potenciómetro y mostrarlo en monitor serial.

- Línea 58 a la 63 he creado un STRING para concatenar porciones que crearán mi URL final que se conectará por peticiones HTTP, en la línea 63 se almacena el valor en la variable POT que se graficará finalmente en el module1 indicado en la línea 62 en el paso 2.2 agregamos dicho módulo con ese nombre "Module1" por defecto.

4.4. Hechas las modificaciones ahora hay que cargar el código en la tarjeta, mientras lo hace el led del ESP8266 de la NodeMcu titilará y en el IDE de Arduino una vez carga por completo el código, saldrá algo así:


Vamos a la tarjeta para presionar el botón de reset (rst) y verificamos en el monitor serial (La comunicación debe estar en 115200 baudios) como se está comportando el programa, allí podremos ver si la conexión se ha logrado o no, entonces:


Hemos comprobado que nuestra tarjeta se conecta a internet y establece un vínculo con la API de la plataforma IoT enviando el valor actual que tenga el potenciómetro, recordemos que para este código el tiempo se actualizará cada 300ms pero este puede ser cambiado a gusto del programador.

5. Ver valor potenciómetro en gráfica IoT AskSensors

Para ver en vivo como se comporta nuestro potenciómetro en la plataforma IoT vamos de nuevo a Asksensors y damos en "visualize":


Nos cargará el mismo cuadro de gráfica que sacamos en el paso 2.4 para finalmente ver el comportamiento de nuestro potenciómetro ¡La magia ocurre cuando lo variamos! y vemos como actualiza cada cierto tiempo en vivo:


5.1. Hasta lo anterior ya logramos conectar un potenciómetro al mundo de Internet lo cual está bien: IoT que le llaman, aunque es algo muy básico son buenas bases para ir adquiriendo nivel y hacer cosas más complejas, pero por ahora el paso final será tener la opción de que cualquier persona pueda ver el comportamiento de nuestro componente:
Como decirle a un amigo "Abre este link y mira como varío un potenciómetro en vivo desde mi casa" y tu amigo está a 100 kilómetros de ti
Entonces, en la misma gráfica de asksensor le damos click al cuarto ícono que dice "open chart" y listo ese link en una nueva ventana se lo podremos enviar a alguien más para que observe todo:

 

Si abro el link en modo incógnito/privado o lo envío a alguien más para que observe no requerirá ingresar a mi cuenta de asksensors lo cuál es bueno ya que sólo podrán ver más no modificar o alterar mi gráfica:

Cualquier persona con el link verá algo así esté donde esté

¡Felicidades 😼 hiciste IoT con Arduino NodeMcu y un Potenciómetro!



🔔 Aclaraciones y dudas:

🔰 ¿Puedo mostrar el estado de otro elemento o componente?

Sí, desde un sensor hasta un pulsador todo depende de nuestra creatividad programando,este código es una base para establecer conexión a internet y hacer IoT.

 🔰 ¿Se puede cambiar el estilo de gráfica usada, no usar línea?

Sí, sólo usamos línea para el ejemplo pero como expliqué en el paso 2.4 en Type tenemos múltiples opciones (Sólo las resaltadas en amarillo):


 🔰 ¿Es del todo gratis AskSensors?

No, como cualquier servicio en la red poseen planes de pago y el gratis que hemos creado al inicio tiene validez de 1 año pero, no pasa nada si el año se cumple creamos otra cuenta y se repite el proceso sin problema. 


Es todo en este 1er post sobre IoT muy completo y dinámico, ¿Alguna duda? Comentar es gratis 😉.

Compartir:

Configurar - Descargar Driver NodeMcu V3.0 en IDE Arduino 2019

En estos días se me ha dado por trabajar con la tarjeta NodeMcu en su versión V3.0 de Lolin que como todas las anteriores ya traen el ESP8266 y para empezar con una serie de tutoriales es importante instalar y configurar la tarjeta con el IDE de Arduino para dejarla lista y que sólo sea escribir código, cargar y probar, así que ese será el objetivo de este post.



CONFIGURAR - PROGRAMAR NODEMCU EN IDE ARDUINO

¿Qué usaremos?

Para este paso a paso lo que se requiere es fácil de encontrar, considerando que ya tienes la NodeMcu, entonces es:

- x1 Tarjeta NodeMcu preferiblemente la V3.0 (Si tienes otra no hay lío)
- x1 Cable MicroUSB (Con el que cargas tu celular sirve)
- IDE de Arduino (Descargar)
- Driver CH340G/CH341SER de la NodeMcu (Descargar)

Paso a paso...

1. Inicialmente vamos a instalar el ESP8266 en nuestro IDE de Arduino, para ello vamos a configurar la URL del paquete que permite la compatibilidad del IDE con las ESP8266.

Vamos al IDE de Arduino > Archivo > Preferencias y en "Gestor de URLs Adicionales de Tarjetas" hacemos clic en el pequeño botón de la derecha:

 


2. En la ventana que aparece luego de hacer clic al cuadro, pegaremos la siguiente URL:

http://arduino.esp8266.com/stable/package_esp8266com_index.json

Damos en OK y todo debe marchar tal y como se ve en la imagen:

 


3. Ahora vamos a Configuración > Placa > Gestor de Tarjetas:

 


Y buscamos el paquete de tarjeta basadas en ESP8266 para luego instalarlo:

 


4. Ahora verificamos que estén disponibles las tarjetas de desarrollo basadas en el ESP8266:


Instalación del Driver

Este proceso es importante ya que la tarjeta aún después de realizar todo lo anterior al momento de conectarla no será reconocida por nuestro PC, y lo único que nos falta es instalar el Driver, para ello lo pueden descargar aquí. y el proceso de instalación es el siguiente:

5. Se descomprime el archivo .rar y luego ejecutamos "SETUP":


No hace falta modificar nada en el proceso de instalación, sólo queda dar clic en "INSTALL" y esperar unos breves segundos, si todo sale bien deberá decirnos que el proceso ya fue realizado:


En la siguiente imagen relaciono la configuración que le dejo a la mía a la hora de programar, realmente solo hace falta cambiar la placa escogiendo "NodeMCU 1.0 (ESP - 12E Module)" y la velocidad en sus respectivos 115200 es con la que mejor me va:

Configuración establecida para mi NodeMcu

Y con esto habremos terminado la configuración e instalación de la NodeMcu para programarla desde el IDE de Arduino, en un próximo post empezaremos a trabajarla con código y un poco de IoT.


Compartir:

Configurar RIPv2 en routers - Cisco Packet Tracer 2019

Hoy veremos como configurar RIPv2 en Routers Cisco, teniendo en cuenta que RIP es mejor usarlo cuando nuestra red es pequeña y posee pocos routers todo esto ya que va ligado a una velocidad de convergencia lenta y su métrica estructurada en la cantidad máxima de saltos que serían 15.

Así pues supongo que si estás aquí es porque eres estudiante y probablemente ves alguna materia directamente relacionada con esto, así que trataré de explicar cada detalle paso a paso pues soy consciente de que no todos saben lo mismo y algo por muy obvio que parezca alguno quizá no tenga idea de como hacerlo.

Configurando RIP en redes con 3 routers

Realmente el proceso es lo mismo, ajeno al número de routers que tengas 2,3,4 o 5 sólo debes ser ordenado y estructurar muy bien lo que haces para que te quede claro todo, en mi caso usaré la topología de la siguiente imagen, pueden descargar el archivo RIP2-SkullTrap en packet Tracer (uso la versión 7.1.1 que también la puedes descargar dando click aquí):
Topología que implementaremos con RIPv2
DIRECCIONAMIENTO IP

Es importante antes de empezar todo, saber que IPs asignaremos a cada interfaz y red (conexiones), tanto en el router R1 (Conexión A) como en R3 (Conexión D) serán máscara /24 y en R2 (Conexión B - C) toda interfaz que a él se conecte será máscara /30, entonces basado en lo anterior esta es la tabla con las redes e interfaces y sus respectivas IPs a configurar:

RED A
192.168.1.0/24
RED B
192.168.3.0/30
RED C
192.168.4.0/30
RED D
192.168.2.0/24
PC0

Fa0
IP: 192.168.1.2

Máscara: 255.255.255.0
Gateway: 192.168.1.1
R1

Se0/0/0
IP: 192.168.3.1

Máscara: 255.255.255.252
R2

Se0/0/1
IP: 192.168.4.1

Máscara: 255.255.255.252
R3

Gig0/0
IP: 192.168.2.1

Máscara: 255.255.252.0
R1

Gig0/0
IP: 192.168.1.1

Máscara: 255.255.255.0
R2

Se0/0/0
IP: 192.168.3.2

Máscara: 255.255.255.252
R3

Se0/0/0
IP: 192.168.4.2

Máscara: 255.255.255.252
PC1

Fa0
IP: 192.168.2.2

Máscara: 255.255.255.0
Gateway: 192.168.2.1
¿No entiendes la tabla? No te preocupes yo te la explico, como pudimos ver la imagen de la topología cada conexión tiene una letra en mayúscula y hace referencia a la red que hay de allí despliega el nombre del equipo y la respectiva IP de interfaz y máscara que le vamos a configurar.


ESTO ES LO QUE HAREMOS...

Entendida la tabla de direccionamiento anterior, configuraremos las interfaces de los routers con sus IPs asignadas. Luego, habilitaremos RIPv2 en cada router para que publique su tabla de enrutamiento, hecho esto podemos verificar las tablas de enrutamiento y hacer ping entre ambos computadores y así corroborar el buen funcionamiento de los routers y RIPv2


- Empezaremos configurando el Router R1 con parámetros elementales:

1. Abrimos el CLI de R1.

2. Accedemos al modo privilegiado.

R1>enable

3. Vamos al modo de configuración global.

R1#config t

4. Ahora vamos a configurar la interfaz (Gigabit 0/0)

R1(config)#interface gi0/0

5. Configuraremos la dirección IP respectiva de la tabla con su máscara, la encendemos y luego salimos de ese modo. 

R1(config-if)#ip add 192.168.1.1 255.255.255.0
R1(config-if)#no shutdown
R1(config-if)#exit

6. Entramos al modo de configuración de la interfaz (serial0/0/0)

R1(config)#interface serial0/0/0

7. Configuramos la respectiva dirección IP según la tabla, si descargaste el archivo packet tracer no es necesario asignar un clock rate pues este ya está asignado de forma automática, luego encendemos la interfaz y salimos.

R1(config-if)#ip add 192.168.3.1 255.255.255.252
R1(config-if)#no shutdown
R1(config-if)#exit

8. Ahora sólo queda guardar nos devolvemos al modo privilegiado para hacerlo.

R1(config)#exit
R1#wr
Building configuration...[OK]
R1#

9. Listo, por ahora dejaremos aquí y luego configuraremos RIPv2



Ahora vamos a configurar R2, para ello.

1. Abrimos el CLI en R2.

2. Vamos al modo privilegiado y luego ingresamos al modo de configuración global.

R2>enable
R2#config t

3. Vamos a la configuración de la interfaz en este caso la (serial0/0/0) de R2 y luego asignamos su ip, máscara, la encendemos y luego salimos.

R2(config)#interface serial0/0/0
R2(config-if)#ip add 192.168.3.2 255.255.255.252
R2(config-if)#no shutdown 
R2(config-if)#exit

4. Ahora vamos a la siguiente interfaz de R2 faltante que sería la (serial0/0/1) luego asignamos su ip, máscara, la encendemos y salimos.

R2(config)#interface serial0/0/1
R2(config-if)#ip add 192.168.4.2 255.255.255.252
R2(config-if)#no shutdown
R2(config-if)#exit

5. Nos devolvemos al modo privilegiado y guardamos la configuración en R2.

R2(config)#exit
R2#wr
Building configuration...[OK]
R2#

6. De momento dejamos así R2 y luego configuraremos RIPv2.



Ahora vamos a R3 y hacemos el mismo proceso que en R1 y R2.

1. Abrimos el CLI del router R3.

2. Ingresamos al modo privilegiado y luego al modo de configuración global.

R3>enable
R3#config t

3. Luego a la configuración de la interfaz (serial0/0/0) y asignamos IP, máscara, la encendemos y salimos.

R3(config)#interface serial0/0/0
R3(config-if)#ip add 192.168.4.1 255.255.255.252
R3(config-if)#no shutdown
R3(config-if)#exit

4. Seguimos con la interfaz (Gigabit0/0) vamos a su configuración, asignamos IP, máscara, encendemos y salimos.

R3(config)#interface gi0/0
R3(config-if)#ip add 192.168.2.1 255.255.255.0
R3(config-if)#no shutdown
R3(config-if)#exit

5. Salimos del modo de configuración global y guardamos los cambios hechos en el equipo.

R3(config)#exit
R3#wr
Building configuration...[OK]
R3#

6. Listo no es más con la IP de cada interfaz en todos los routers, queda ir al siguiente paso.



CONFIGURANDO RIPv2...

Ahora sí, usaremos RIPv2 en nuestra topología. Es importante saber que cuando configuramos RIPv2 usamos el comando network a él debemos agregar la dirección IP de la red o conexión que queremos publicar si esta se encuentra directamente conectada al router. Entonces:


 - Configuramos primero R1:

1. Vamos al modo de configuración global y luego al modo de configuración del router con RIP.

R1#config t
R1(config)#router rip

2. Aplicamos al protocolo RIP la versión 2.

R1(config-router)# version 2

3. Publicamos las redes/conexiones vinculadas directamente a R1.

R1(config-router)#network 192.168.1.0
R1(config-router)#network 192.168.3.0

4. Salimos del modo de configuración del Router y luego guardamos lo cambios en el equipo.

R1(config)#exit
R1#wr
Building configuration...[OK] 
R1#

5. Ya quedó.



Bien, seguiremos con R2 configurando RIP:

1. Ingresamos al modo configuración global, habilitamos la configuración RIP en el router y luego aplicamos la versión 2.

R2#config t
R2(config)#router rip
R2(config-router)#version 2

2. Publicamos la redes conectadas directamente a R2 que serían B - C según la tabla.

R2(config-router)#network 192.168.3.0
R2(config-router)#network 192.168.4.0

3. Salimos de una vez hasta el modo de configuración y luego guardamos los cambios hechos.

R2(config)#end
R2#wr
Building configuration...[OK]
R2#

4. Listo.

Finalmente configuramos RIPv2 en el router R3.

1. vamos al modo configuración global, habilitamos la configuración RIP en el router y luego aplicamos la versión 2.

R3#config t
R3(config)#router rip
R3(config-router)#version 2

2. Publicamos la redes conectadas directamente a R2 que serían C - D según la tabla.

R3(config-router)#network 192.168.4.0
R3(config-router)#network 192.168.2.0

3. Salimos hasta el modo privilegiado y guardamos cambios hechos.

R3(config)#end
R3#wr
Building configuration...[OK]
R3#

4. Listo.
 

Hasta aquí, si hiciste los pasos uno a uno ya tienes RIPv2 configurado. Para probar si todo está correcto escribimos el comando show ip route para así ver la tabla de enrutamiento y observar las rutas aprendidas mediante RIP (Indicadas con una R) desde el router vecino. Debería salir algo así en las tablas de enrutamiento: 

R1:

192.168.1.0/24 is variably subnetted, 2 subnets, 2 masks
C 192.168.1.0/24 is directly connected, GigabitEthernet0/0
L 192.168.1.1/32 is directly connected, GigabitEthernet0/0
R 192.168.2.0/24 [120/2] via 192.168.3.2, 00:00:18, Serial0/0/0
192.168.3.0/24 is variably subnetted, 2 subnets, 2 masks
C 192.168.3.0/30 is directly connected, Serial0/0/0
L 192.168.3.1/32 is directly connected, Serial0/0/0
R 192.168.4.0/24 [120/1] via 192.168.3.2, 00:00:18, Serial0/0/0

R2:

R 192.168.1.0/24 [120/1] via 192.168.3.1, 00:00:22, Serial0/0/0
R 192.168.2.0/24 [120/1] via 192.168.4.1, 00:00:04, Serial0/0/1
192.168.3.0/24 is variably subnetted, 2 subnets, 2 masks
C 192.168.3.0/30 is directly connected, Serial0/0/0
L 192.168.3.2/32 is directly connected, Serial0/0/0
192.168.4.0/24 is variably subnetted, 2 subnets, 2 masks
C 192.168.4.0/30 is directly connected, Serial0/0/1
L 192.168.4.2/32 is directly connected, Serial0/0/1

R3:

R 192.168.1.0/24 [120/2] via 192.168.4.2, 00:00:01, Serial0/0/0
192.168.2.0/24 is variably subnetted, 2 subnets, 2 masks
C 192.168.2.0/24 is directly connected, GigabitEthernet0/0
L 192.168.2.1/32 is directly connected, GigabitEthernet0/0
R 192.168.3.0/24 [120/1] via 192.168.4.2, 00:00:01, Serial0/0/0
192.168.4.0/24 is variably subnetted, 2 subnets, 2 masks
C 192.168.4.0/30 is directly connected, Serial0/0/0
L 192.168.4.1/32 is directly connected, Serial0/0/0

Verificado lo anterior, vamos al último paso hacer un ping y así verificar que ambos computadores están OK en conexión. Para lo único que falta es asignar la IP, máscara y gateway a PC0 y PC1 quedando algó así:

Configuración para PC0:

Configuración para PC1:


Con los PC configurados haremos el ping desde el PC0 hacia el PC1 así:


PC0:\>ping 192.168.2.2

Pinging 192.168.2.2 with 32 bytes of data:

Reply from 192.168.2.2: bytes=32 time=3ms TTL=125
Reply from 192.168.2.2: bytes=32 time=4ms TTL=125
Reply from 192.168.2.2: bytes=32 time=2ms TTL=125
Reply from 192.168.2.2: bytes=32 time=5ms TTL=125

Ping statistics for 192.168.2.2:
   Packets: Sent = 4, Received = 4, Lost = 0 (0% loss),
Approximate round trip times in milli-seconds:
   Minimum = 2ms, Maximum = 5ms, Average = 3ms

Y así culminamos esto, lo mejor detallado posible ha sido escrito, sin embargo si hay dudas más abajo está la caja de comentarios.

Hasta la próxima SkullTrapers ;)
Compartir:

SkullTrapers

Posts más vistos

 

CLICK AQUI PARA IR A NUESTRA TIENDA ON LINE ARDUINO, ELECTRÓNICA, COMPONENTES