UNaM - Tecnicatura Universitaria en Tecnologías de la Información 2022

Robótica Educativa

Guía IoT Primeros pasos

Configuración del entorno

Partiendo de la base que ya tenemos instalado el IDE de Arduino, será necesario agregar las librerías
correspondientes al nuevo microcontrolador para poder utilizarlo.
Es posible encontrar mayor documentación en el siguiente link: https://arduino-
esp8266.readthedocs.io/en/latest/installing.html
Existen dos formas de hacerlo, una por medio del propio IDE de Arduino y otra por fuera.

No conecte la placa a la computadora hasta haber completado la configuración del entorno.

Configurando el entorno por medio del IDE de Arduino

1. En el IDE de Arduino, se debe ir al menú Archivo – Preferencias:

2. Cuando se presente en pantalla la ventana de Preferencias, será como la siguiente:

Lic.
Mariela V. Burghardt 1
UNaM - Tecnicatura Universitaria en Tecnologías de la Información 2022
Robótica Educativa

3. En el ítem “Gestor de URLs Adicionales de Tarjetas”, debemos copiar la siguiente URL:

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

Con esto le indicamos al IDE de Arduino que busque los datos de la tarjeta en esa url y agregue las
tarjetas dentro de la lista del Gestor de Tarjetas.

Presionamos el botón Ok y aguardamos que se actualice. En ocasiones se recomienda cerrar y volver

a abrir el IDE para que tome los cambios.
4. Nuevamente con el IDE iniciado, debemos ir al menú Herramientas – Placa – Gestor de
tarjetas:

Lic.
Mariela V. Burghardt 2
UNaM - Tecnicatura Universitaria en Tecnologías de la Información 2022
Robótica Educativa

Una vez iniciado el Gestor de tarjetas demora un instante en actualizar el listado.

5. En el Gestor de tarjeta debemos buscar “esp8266”:

Seleccionamos el mismo, y presionamos el botón Instalar, esta operación puede demorar algunos
minutos.
6. Por último, solo nos queda verificar que se haya instalado adecuadamente, para ello
ingresamos al menú Herramientas – Placa y buscamos “NodeMCU 1.0” en la lista:

Lic.
Mariela V. Burghardt 3
UNaM - Tecnicatura Universitaria en Tecnologías de la Información 2022
Robótica Educativa

Luego solo es cuestión de seleccionar el Puerto por el cual el equipo reconoció a la placa.

Configurando el entorno por fuera del Arduino IDE

No es raro que, en ciertas ocasiones, puede ocurrir que el enlace desde donde el IDE detecta que
archivos debe descargar no esté funcionando, o los vínculos no estén activos; de manera que para
poder configurar el entorno en estas circunstancias se debe realizar por fuera del Arduino IDE.
Será necesario contar con algunas herramientas antes de comenzar:

● Git, se puede descargar desde https://git-scm.com/download/win Solo será necesario si

deseamos descargar el ultimo repositorio. Si se va a utilizar la copia provista no es necesario.
● Python 2.7.15 https://www.python.org/downloads/release/python-2715/ se utiliza para
ejecutar algunas herramientas.
Luego que se hayan instalado las herramientas procedemos con los siguientes pasos:

1. Debemos asegurarnos que el IDE de Arduino este cerrado.

2. Abrimos el explorador de archivos, y navegamos hasta la carpeta Arduino ubicada dentro de
Documentos, también podemos pegar en la barra de direcciones:
%USERPROFILE%\Documents\Arduino

Lic.
Mariela V. Burghardt 4
UNaM - Tecnicatura Universitaria en Tecnologías de la Información 2022
Robótica Educativa

3. Buscamos una carpeta llamada hardware, si no existe la creamos. Dentro de la carpeta

hardware creamos otra carpeta llamada esp8266com.
4. Dentro de la carpeta esp8266com, se descomprime el archivo esp8266.zip.
Luego de completar estos pasos tendremos la siguiente estructura

5. Iniciamos el Símbolo de Sistema, podemos encontrar en Inicio – Accesorios de Windows –

Símbolo de Sistema; sino, otra forma más ágil es presionar la combinación de teclas Win +
R, y en la ventana escribir cmd y se presentará la ventana de fondo negro del Símbolo de
Sistema.
6. Desde el símbolo de sistema ejecutamos las siguientes instrucciones:

cd %USERPROFILE%\Documents\Arduino\hardware\esp8266com\esp8266\tools python
get.py
Esto va a demorar algunos minutos, concluido el proceso podemos iniciar el IDE de Arduino y
corroborar dentro del menú Herramientas – Placas si “NodeMCU 1.0” está en la lista.

Ejercicio 1: Blink
El objetivo de este ejercicio es corroborar el funcionamiento de la placa y del entorno de trabajo
que se instaló.

Lic.
Mariela V. Burghardt 5
UNaM - Tecnicatura Universitaria en Tecnologías de la Información 2022
Robótica Educativa

Construiremos el siguiente circuito:

El voltaje de operación del NodeMCU es de 3.3V, utilice la Ley de Ohm para calcular el
valor de la resistencia

𝑉=𝐼*𝑅
Una pequeña ayuda:

1. Conecte la placa por medio del cable USB a la computadora.

2. Inicie el Arduino IDE, y corrobore que está marcada la opción adecuada en el menú
Herramientas – Placas, así como también seleccionado el puerto adecuado.
3. Utilizaremos el siguiente código de ejemplo:

Lic.
Mariela V. Burghardt 6
UNaM - Tecnicatura Universitaria en Tecnologías de la Información 2022
Robótica Educativa

1 int pinLed = XXX;

2
3 void setup() {
4 pinMode(pinLed,OUTPUT);
5 }
6
7 void loop() {
8 digitalWrite(pinLed,HIGH);
9 delay(500);
10 digitalWrite(pinLed,LOW);
11 delay(500);
}
12
Una vez escrito el ejemplo no va a compilar, si lo intentamos nos dará un error puesto que la variable
pinLed tiene asignado XXX. Debemos reemplazar por el número de GPIO adecuado.

GPIO es la abreviación de Puerto General de Entrada/Salida; en el caso del NodeMCU/Lolin, el

número de puerto impreso en la placa no se corresponde de manera exacta con el GPIO; para ello
nos ayudamos con los números esquemas que existen de la placa en internet:

Si seguimos el diagrama de cómo conectamos los componentes, vemos conectamos el led al puerto
D6 que se corresponde con el GPIO12, por lo tanto, en el código debemos indicar que pinLed = 12.
También es posible utilizar la sigla D6.
Una vez que se reemplaza este valor, podemos compilar y el led comenzará el ciclo de prenderse y
apagarse.

Lic.
Mariela V. Burghardt 7
UNaM - Tecnicatura Universitaria en Tecnologías de la Información 2022
Robótica Educativa

Ejercicio 2: Conectarnos a una red inalámbrica

El dispositivo debe conectarse a una red inalámbrica para poder compartir datos con el exterior o
interactuar con otros servicios.

Será necesario utilizar una biblioteca llamada ESP8266WiFi, que se encarga de gestionar la conexión
a la red inalámbrica. Por medio del método begin(), que recibe como argumentos el nombre de la
red y la contraseña, el dispositivo se conecta a la red inalámbrica.

Es importante destacar que el dispositivo primero corrobora que no se encuentre conectado a la

red inalámbrica y queda en el bloque de loop() hasta que se conecte.

Para ello realizamos el siguiente ejemplo:

1
2 #include <ESP8266WiFi.h>
3
4 const char* ssid = "Nombre_Red";
5 const char* password = "Clave_Red";
6
7 void setup() {
8
9 Serial.begin(9600);
10 WiFi.begin(ssid, password);
11 Serial.println("Conectando");
12
13 while (WiFi.status() != WL_CONNECTED) {
14 Serial.print(".");
15 delay(500);
16 }
17
18 Serial.println("Conectado");
19 Serial.print("Direccion: ");
Serial.println(WiFi.localIP());
20 }
21
22 void loop() {
23 }
24

Luego de compilar y subir el programa a la placa, en el monitor serie se puede ver cual es la dirección
IP que toma la placa.

Lic.
Mariela V. Burghardt 8
UNaM - Tecnicatura Universitaria en Tecnologías de la Información 2022
Robótica Educativa

Conocer la dirección IP de la placa dentro de la red, nos permitirá conectarnos a la misma para
solicitar información.

Ejercicio 3: Una página web

El objetivo de este ejercicio es generar una página web en el dispositivo que muestre un mensaje.

Al igual que en el ejercicio 2, utilizaremos la librería ESP8266WiFi para que el dispositivo pueda
conectarse a la red inalámbrica.

Adicionalmente utilizaremos una instancia de WiFiServer, la misma permite que el dispositivo

atienda las solicitudes externas (de otro dispositivo o de un navegador) y responda a ellas según el
requerimiento. WiFiServer lleva como argumento el nro. del puerto que se va a utilizar, en nuestro
caso utilizamos el puerto 80, que es el estándar para las conexiones http.

Se pueden utilizar otros puertos que son estándares de otros servicios: FTP, SSH, HTTPS, NTP; puede
leer más aquí: https://es.wikipedia.org/wiki/Anexo:N%C3%BAmeros_de_puertos_de_red

Se puede resumir en el diagrama anterior:

1. Desde un navegador ingresamos la dirección IP del dispositivo:

http://192.168.1.100 por ejemplo.
2. El dispositivo detecta que existe un cliente conectado al recibir el requerimiento.
3. Elabora una respuesta.
4. Envía la respuesta al cliente (navegador). El navegador al recibir la respuesta la
muestra en la pantalla.
Entonces para lograr esto realizamos:

Lic.
Mariela V. Burghardt 9
UNaM - Tecnicatura Universitaria en Tecnologías de la Información 2022
Robótica Educativa

1 #include <ESP8266WiFi.h>
2
3 const char* ssid = "Nombre_red";
4 const char* password = "clave";
5
6 WiFiServer server(80);
7
8 void setup() {
9
10 Serial.begin(115200);
11 WiFi.begin(ssid, password);
12 Serial.println("Conectando");
13
14 while (WiFi.status() != WL_CONNECTED) {
15 Serial.print(".");
16 delay(500);
17 }
18
19 Serial.println("Conectado");
20 Serial.print("Direccion: ");
21 Serial.println(WiFi.localIP());
22
23 //Se inicia el servidor
24 server.begin();
25
26 }
27
28 void loop() {
29
30 WiFiClient client = server.available();
31 if(!client) { //No se detecto ningun cliente
32 return;
}
33

Lic.
Mariela V. Burghardt 10
UNaM - Tecnicatura Universitaria en Tecnologías de la Información 2022
Robótica Educativa

34
35 Serial.println("Ingreso un nuevo cliente/requerimiento");
36 //Se espera hasta que el cliente haya enviado todos los
37 requerimientos
38 while(!client.available()) {
39 delay(1);
40 }
41
42 String req = client.readStringUntil('\r');
43 Serial.print("Requerimiento: ");
44 Serial.println(req);
45
46 client.flush();
47
String respuesta = "HTTP/1.1 200 OK\r\nContent-Type:
text/html\r\n\r\n<!DOCTYPE
HTML>\r\n<html>\r\n<h1>Hola Mundo</h1></html> ";
48
client.print(respuesta);
49 delay(1);
50 Serial.println("Cliente desconectado");
51 }

Ejercicio 4: Controlar un led por WiFi

El objetivo de este ejercicio es poder controlar el encendido de un led desde una página
web, para ello construimos el siguiente circuito:

Lic. Mariela V. Burghardt 11

UNaM - Tecnicatura Universitaria en Tecnologías de la Información 2022
Robótica Educativa

Calcule los valores de las resistencias utilizando la Ley de Ohm, como se realizo en el
ejercicio 1.

Extendemos el ejercicio numero 3:

1. Según el requerimiento desde el navegador se va a encender/apagar un led.
2. Modificamos la respuesta para mostrar en el navegador si está
encendido/apagado el led y un link para cambiar el estado.

Realizamos los siguientes cambios:

1 #include <ESP8266WiFi.h>
2
3 const char* ssid = "nombre_red"; const
4 char* password = "clave_red";
5
6 WiFiServer server(80);
7
8 int pinLed1 = 12;
9
10 void setup() {
11
12 Serial.begin(115200);
13 WiFi.begin(ssid, password);
14 Serial.println("Conectando");
15
16 while (WiFi.status() != WL_CONNECTED) {
17 Serial.print(".");
18 delay(500);
19 }
20
21 Serial.println("Conectado");
22 Serial.print("Direccion: ");
23 Serial.println(WiFi.localIP());
24
25 //Se inicia el servidor
26 server.begin();
27
28 //Se configura el pin como salida
29 pinMode(pinLed1,OUTPUT); digitalWrite(pinLed1,LOW);

Lic. Mariela V. Burghardt 12

UNaM - Tecnicatura Universitaria en Tecnologías de la Información 2022
Robótica Educativa

30 }
31 void loop() {
32
33 WiFiClient client = server.available();
34 if(!client) { //No se detecto ningun cliente
35 return;
36 }
37 Serial.println("Ingreso un nuevo cliente/requerimiento");
//Se espera hasta que el cliente haya enviado todos los
38
requerimientos
39 while(!client.available()) {
40 delay(1);
41 }
42 String requerimiento = client.readStringUntil('\r');
43 Serial.print("Requerimiento: ");
44 Serial.println(requerimiento);
45 client.flush();
46
47 //Se evalúa el requerimiento
48 int nroPin;
49 if(requerimiento.indexOf("/D6/0") != -1) {
50 digitalWrite(pinLed1,LOW);
51 } else if(requerimiento.indexOf("/D6/1") != -1) {
52 digitalWrite(pinLed1,HIGH);
}
53
54
String respuesta = "HTTP/1.1 200 OK\r\nContent-Type:
55
text/html\r\n\r\n<!DOCTYPE HTML>\r\n<html>\r\n<h1>LED</h1>";
56
respuesta+= "<p>LED 1 esta ";
57 int estado = digitalRead(pinLed1);
58 respuesta+= (estado) ? "Encendido <a
59 href=\"/D6/0\">Apagar</a>" : "Apagado <a
60 href=\"/D6/1\">Encender</a></p>";
61 respuesta+="</html>\n";
62 client.print(respuesta);
delay(1);
63
Serial.println("Cliente desconectado");
64
}
65

Lic. Mariela V. Burghardt 13

UNaM - Tecnicatura Universitaria en Tecnologías de la Información 2022
Robótica Educativa

Ejercicio 6: Consulta a sensor remoto

Conecte un sensor a la placa, puede ser cualquier tipo de sensor que disponga y muestre
los datos por medio de una pagina web. Extendiendo el desarrollo del modelo de programa:
https://gist.github.com/gsampallo/9cf807bc4b14fdf2e8b46b60cebce68c

Ejercicio 7: Consulta a servicios web

Extienda el desarrollo del programa del ejercicio 5 para poder encender los tres leds.
Tip:
La respuesta del dispositivo al navegador es una página web, la misma está
construida con lenguaje HTML, HTML utiliza una serie de etiquetas para indicar el
tipo de contenido.
<p></p> establece que el contenido es un párrafo; utilice las mismas para indicar el bloque
de cada led.
Para saber más: https://es.wikipedia.org/wiki/HTML

Ejercicio 8: Consulta a servicios web

El objetivo de este ejercicio será utilizar servicios provistos por la nube para obtener datos
dinámicos y mostrarlos en una página web dentro de nuestro dispositivo.
Para ello realizamos:

Lic. Mariela V. Burghardt 14

UNaM - Tecnicatura Universitaria en Tecnologías de la Información 2022
Robótica Educativa

#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
const char* ssid = "Nombre_Red";
const char* password = "Clave_red";

WiFiServer server(80);

void setup() {
Serial.begin(115200);
WiFi.begin(ssid, password);
Serial.println("Conectando");

while (WiFi.status() != WL_CONNECTED) {

Serial.print(".");
delay(500);
}

Serial.println("Conectado");
Serial.print("Direccion: ");
Serial.println(WiFi.localIP());
obtenerDatos();
server.begin();
}
const char *host =
"https://www.gsampallo.com/wp-content/uploads/2022/12/dog.txt";
String pagina;
void obtenerDatos() {
HTTPClient http;
http.begin(host);

int httpCode = http.GET(); //Send the request

String payload = http.getString(); //Get the response
Serial.print("Response Code:"); //200 is OK
Serial.println(httpCode); //Print HTTP return code
if(httpCode == 200) {
pagina = payload;
}
}
void loop() {

WiFiClient client = server.available();

if(!client) { //No se detecto ningun cliente

Lic. Mariela V. Burghardt 15

UNaM - Tecnicatura Universitaria en Tecnologías de la Información 2022
Robótica Educativa

return;
}
Serial.println("Ingreso un nuevo cliente/requerimiento");

while(!client.available()){
delay(1);
}

String requerimiento = client.readStringUntil('\r');

Serial.print("Requerimiento: ");
Serial.println(requerimiento);
client.flush();

client.print(pagina);
delay(1);
Serial.println("Cliente desconectado");

Luego de compilar el programa, debemos abrir el Monitor Serie para saber cual es la IP del
dispositivo y utilizar el navegador para conectarnos a dicha IP, será similar a
http://192.168.1.XXX
Existen otro tipo de webservice que utilizan el formato JSON para devolver los datos; JSON
facilita poder manipular los datos, para ello es necesario utilizar la librería ArduinoJSON en
conjunto con el código indicado.
Un webservice muy popular es OpenWeatherMap https://openweathermap.org/ que
ofrece datos del clima y pronostico del tiempo de manera gratuita, solo es necesario
registrarse para obtener acceso a la misma.

Ejercicio 9: Sensores

En este ejercicio veremos cómo mostrar información de sensores en la web.

Se toma como base para el ejercicio un sensor de temperatura analógico; pero con
algunos cambios sencillos en el código es posible mostrar información de cualquier sensor
deseado.

Utilizaremos el siguiente circuito:

Lic. Mariela V. Burghardt 16

UNaM - Tecnicatura Universitaria en Tecnologías de la Información 2022
Robótica Educativa

Comenzamos importando las librerías que vamos a utilizar y definiendo los parámetros
globales:

1 #include <ESP8266WiFi.h>
2 #include <WiFiClient.h>
3 #include <ESP8266WebServer.h>
4
5 const char *ssid = "Nombre_Red"; //Nombre de la red inalámbrica
6 const char *password = "Clave"; //Clave de la red
7 //Creamos un servicio que atiende las solicitudes de los clientes.
8 ESP8266WebServer server(80);
9

En la función setup() , especificamos el modo de operación del NodeMCU para la red

WiFi, cuál será la función que atenderá los requisitos de los clientes:

Lic. Mariela V. Burghardt 17

UNaM - Tecnicatura Universitaria en Tecnologías de la Información 2022
Robótica Educativa

10 void setup() {
11 Serial.begin(115200);
12
13 WiFi.softAP(ssid,password);
14
15 IPAddress ip = WiFi.softAPIP();
16 Serial.print("Direccion IP: ");
17 Serial.println(ip);
18
19 server.on("/",handleTemp);
20
21 server.begin();
22 Serial.println("Servidor iniciado");
23 }
24

En la función loop()invocamos a una función de server para que se ocupe de los requisitos

de los clientes:

25
26 void loop() {
27 server.handleClient();
28 }
29

Por último nos queda definir la función handleTemp() , la cual se hará cargo de obtener
el valor del sensor, convertirlo a grados celsius y devolvernos una página web para que
sea leído desde nuestro navegador:

Lic. Mariela V. Burghardt 18

UNaM - Tecnicatura Universitaria en Tecnologías de la Información 2022
Robótica Educativa

30
31 void handleTemp() {
32 //Se debe tener en cuenta que el voltaje de operacion es de 3.3V.
33 float resolution=3.3/1023;
34
35 float temp = ((analogRead(A0) * resolution) * 100)+23.89;
36
37 String respuesta = "<h1>"+String(temp)+"°C<h1>";
38
39 server.send(200, "text/html", respuesta);
40 }
41

Compilamos y, si no existe ningún error, se sube el programa al NodeMCU. Luego, al

ingresar en la página: http://192.168.4.1 podremos ver la temperatura del sensor.

Lic. Mariela V. Burghardt 19

UNaM - Tecnicatura Universitaria en Tecnologías de la Información 2022
Robótica Educativa

Bibliografía y links de referencia:

- Installing. Boards Manager. https://arduino-
esp8266.readthedocs.io/en/latest/installing.html
- Sampallo, Guillermo. Internet de las Cosas con ESP8266. Una guía sencilla y
completa para la experimentación con IOT. Marcombo. 2019.
- Comparación de placas NodeMCU. ESPloradores.
https://www.esploradores.com/comparacion-de-placas-nodemcu_/

Lic. Mariela V. Burghardt 20