INTERNET DE LAS COSAS CON

ARDUINO Y NODEMCU
Laboratorio Nro 5.1.

Ricardo Yauri Rodriguez Rubén Acosta Jacinto

2018
Siglas del curso/B36/1
Nombre del autor
Nombre del curso. Laboratorio 5.1. (Separata)
/ INICTEL-UNI. Lima: INICTEL-UNI, Año.
Nro. de páginas.

INTERNET DE LAS COSAS CON ARDUINO Y NODEMCU/ TEMA DEL LABORATORIO

Datos del programa al que pertenece el curso

Internet de las cosas con Arduino y NodeMCU. Laboratorio Nro. 5.1 Separata
por Nombre del autor
©INICTEL-UNI, Año
Hecho en Perú

Av. San Luis 1771

15021 – Lima – PERÚ
Teléf.: 626-1400 (7256)
jvente@inictel-uni.edu.pe
www.inictel-uni.edu.pe

Derechos reservados. No está permitida la reproducción total o parcial de la obra por cualquier medio o procedimiento,
comprendidos la reprografía, el tratamiento informático y electrónico sin la autorización de INICTEL-UNI.

1
 LABORATORIO N° 5.1

1. Configuración y programación de cliente HTTP

El módulo NodeMCU tiene integrado la electrónica adecuada para realizar la conectividad Wi-Fi. Entre los
protocolos de comunicación web que tiene son los peticiones GET/POST HTTP, las cuales permiten
obtener y enviar información a servidores.

2. Objetivos
 Implementación de un cliente GET cliente para petición de datos a ThingSpeak.
 Implementación de un cliente GET para petición de datos a JsonPlaceHolder
 Configuración de servidor ThingSpeak para conexión con el NodeMCU
 Implementación de un cliente GET para envío de datos a ThingSpeak

3. Sustento teórico

El Protocolo de transferencia de hipertexto (HTTP) está diseñado para habilitar las comunicaciones entre
clientes y servidores. HTTP funciona como un protocolo de solicitud y respuesta entre un cliente y un
servidor. Un navegador web puede ser el cliente, y una aplicación en una computadora que aloja un sitio
web puede ser el servidor. Veremos que el módulo NodeMCU se puede comportar como cliente, servidor o
Modo AP (Access Point).
 GET. Solicita datos de un recurso especificado. El objetivo de GET es obtener información del
servidor, ya sea en un archivo o base de datos, hacia el cliente.
 POST. Envía datos para ser procesados a un recurso especificado. El objetivo es enviar información
desde el cliente para que sea procesada y actualice o agregue información en el servidor

4. Equipos y Materiales

 NodeMCU x1
 Sensor DHT22/DHT11
 Cables para Protoboard.
 Protoboard x1.
 Resistor de 1k Ohmios x1

5. Procedimientos

En este laboratorio se realizarán cuatro ejercicios para realizar la comunicación con servidores Web
usando cliente HTTP en el NodeMCU

5.1. Implementación de un cliente GET cliente para petición de datos a ThingSpeak.

En la siguiente sección se desarrollará un programa para implementar en el NodeMCU un cliente HTTP
GET y solicitar datos a un servicio en el servidor de aplicaciones “thingspeak”. En este caso usaremos el
servidor de Thingspeak para la demostración del cliente HTTP.

2
 Figura 1. Esquema de comunicación de clientes con servidor en la nube

Thingspeak es una plataforma para transmisión y recepción de datos de dispositivos IOT en la que
cualquiera puede visualizar y analizar datos en vivo desde sus dispositivos sensores. Además, podemos
realizar análisis de datos con la información publicada por dispositivos remotos usando Matlab.
En este ejemplo usaremos un canal de identificación ya existente el cual nos devuelve el último dato que
ha sido almacenado.
 La identificación del canal es = 309236
 La clave de escritura es = 1EYZIS5OCRJSKZHG

En este ejemplo no es necesario tener ningún otro componente más que el NodeMCU, asi que nos
conectaremos directamente a la nube de ThinSpeak para acceder a un canal de datos libre. Un esquema
de conexión se muestra en la siguiente figura.

GET Request

GET Response

Figura 2. Comunicación Request/response del NodeMCU

Para realizar este ejemplo seguimos estos pasos:

 Abrimos el IDE Arduino y seleccionamos la tarjeta NodeMCU v1.0 y el puerto Serial donde se
encuentre conectado.
 Escribimos código del siguiente cuadro que permitirá conectarnos a los servicios de ThingSpeak,
obtener el último registro del dato ingresado al canal que hemos configurado en el programa.
 Se crea el objeto “client” de la clase “WiFiClient”.
 El código muestra que se inicializa la velocidad del puerto serial a 9600 y la comunicación WiFi
con la función “WiFiBegin”.
 En el bucle principal se realiza la conexión con el servidor y si hay una conexión exitosa se realiza
la petición de datos con GET.
3
 Si hay respuesta del servidor se utiliza la función “client.available” para mostrar la respuesta por
el puerto serie.
 Se agrega un retardo de 10 segundos, el cual es el periodo en el que se harán peticiones al
servidor
 Una vez escrito el código guardamos el archivo con nombre nombre: “Ejemplo12_get”.
 Compilamos y grabamos el programa, verificando nuevamente que se ha seleccionado la tarjeta
NodeMCU 1.0 y puerto Serial correcto.
#include <ESP8266WiFi.h>
const char* ssid = "ricne"; // Enter SSID here
const char* password = "s10n1sm0"; //Enter Password here
const char* server = "api.thingspeak.com";
/* Set GET link with channel ID */
const char* _getLink =
"http://api.thingspeak.com/channels/309236/feeds/last.txt";

WiFiClient client;
void setup() {
Serial.begin(9600);
delay(1000);
Serial.println("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);

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

delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
}
void loop()
{
// "184.106.153.149" or api.thingspeak.com
if (client.connect(server,80))
{
String getStr = _getLink;
client.print("GET "+getStr+"\n");client.print("HTTP/1.1\n");
client.print("Host: api.thingspeak.com\n");
client.print("Connection: close\n\n\n");

while(client.available()){
char c = client.read();Serial.print(c);
}
Serial.println("");
}
client.stop();
Serial.println("Waiting…");
delay(10000);
}

4
Se observa en el monitor serial que se tiene la respuesta del servidor cada 10 segundos donde se tiene el
último registro de datos a ese canal en ThingSpeak. Nosotros podemos obtener esa información
accediendo directamente al enlace “http://api.thingspeak.com/channels/309236/feeds/last.txt” y observar
que tenemos la misma información.

Figura 3. Respuesta del servidor enviada por el puerto serial

Figura 4. Acceso al servidor remoto utilizando un cliente Web

También se puede usar el software “Hercules” para implementar un cliente HTTP y comprobar que el
formato de petición GET es el mismo. La petición GET puede también puede tener como url de conexión:
“/channels/309236/feeds/last.txt” y el parámetro HTTP/1.1, si está separado por espacio de la línea
anterior GET nos brindará más datos en la respuesta del servidor

NodeMCU Hercules HW
GET GET
http://api.thingspeak.com/channels/309236/fee http://api.thingspeak.com/channels/309236/fee
ds/last.txt\n ds/last.txt<LF>
HTTP/1.1\n HTTP/1.1<LF>
Host: api.thingspeak.com\n Host: api.thingspeak.com<LF>
Connection: close\n\n\n Connection: close<LF><LF><LF>
Tabla 1. Formato de petición de datos utilizando el protocolo HTTP GET

5
 Figura 5. Acceso al servidor remoto utilizando el software Hercules

5.2. Implementación de un cliente GET para petición de datos a JsonPlaceHolder

En esta caso implementaremos otro cliente GET pero esta vez usaremos agregaremos la librería
“ESP8266HTTPClient.h” para utilizar la clase “HTTPClient”. Además solicitaremos datos del servidor
“http://jsonplaceholder.typicode.com/” donde tenemos varios ejemplos para obtener información de prueba.
En este ejemplo no es necesario tener ningún otro componente más que el NodeMCU, así que nos
conectaremos directamente al servicio en “jsonplaceholder” para acceder a información de prueba. Un
esquema de conexión se muestra en la siguiente figura.

GET Request

GET Response

Figura 6. Esquema de solicitud de datos al servidor “JSONPlaceHolder”

Para realizar este ejemplo seguimos estos pasos:

 Abrimos el IDE Arduino y seleccionamos la tarjeta NodeMCU v1.0 y el puerto Serial donde se
encuentre conectado.
 Escribimos código del siguiente cuadro que permitirá conectarnos a los servicios de
JsonPlaceHolder.
 Se observa que se ha agregado la librería “ESP8266HTTPClient.h”.
 El código muestra que se inicializa la velocidad del puerto serial a 9600 y la comunicación WiFi
con la función “WiFi.begin”.
 En el bucle principal se revisa si hay conexión existosa observando el estado de la conexión. Si es
asi se crea el objeto “http” de la clase “HTTPClient”.

6
  Se especifica la dirección donde se hará la petición con la función “http.begin” y se realiza la
petición “http.GET”.
 Si hay respuesta del servidor se utiliza la función “http.getString” para obtener los datos y
enviarlos por el puerto serie.
 Se agrega un retardo de 30 segundos, el cual es el periodo en el que se harán peticiones al
servidor
 Una vez escrito el código guardamos el archivo con nombre nombre: “Ejemplo13_get”.
 Compilamos y grabamos el programa, verificando nuevamente que se ha seleccionado la tarjeta
NodeMCU 1.0 y puerto Serial correcto.

#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
const char* ssid = "ricne";
const char* password = "s10n1sm0";
void setup () {
Serial.begin(9600);
WiFi.begin(ssid, password);

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

delay(1000);
Serial.print("Connecting..");
}
}
void loop() {
if (WiFi.status() == WL_CONNECTED) { //Check WiFi
HTTPClient http; //Declare an object of class HTTPClient

http.begin("http://jsonplaceholder.typicode.com/users/1");
int httpCode = http.GET();

if (httpCode > 0) { //Check the returning code

String payload = http.getString(); //Get response payload
Serial.println(payload); //Print payload
}
http.end(); //Close connection
}
delay(30000); //Send a request every 30 seconds
}

Se observa en el monitor serial que se tiene la respuesta del servidor cada 30 segundos donde se obtiene
información en formato json desde el servidor de pruebas “JSONPlaceholder. Nosotros podemos obtener
esa información accediendo directamente al enlace “http://jsonplaceholder.typicode.com/users/1” y
observar que tenemos la misma información.

7
 Figura 7. Recepción de datos del servidor.

Figura 8. Petición de datos al servidor usando un cliente Web

5.3. Configuración de servidor ThingSpeak para conexión con el NodeMCU

ThingSpeak proporciona una herramienta muy buena para proyectos basados en IoT. Al usar el sitio
ThingSpeak, podemos monitorear nuestros datos a través de Internet desde cualquier lugar, y también
podemos controlar nuestro sistema a través de Internet, utilizando los Canales y las páginas web
proporcionadas por ThingSpeak.

Figura 9. Servicio ThingSpeak

8
Los pasos a seguir para configura el servicio son los siguientes
 Primero se crea una cuenta en ThingSpeak.com, luego iniciar sesión y hacer clic en Comenzar.
 Ahora vamos a 'Canales' y hacemos clic en la opción “Nuevo canal” en la misma página para
continuar el proceso.

Figura 10. Creación de canal en ThingSpeak.

 Se observa un formulario para crear el canal, por lo que debemos completar el Nombre y la
Descripción. Luego se completa los dos primeros campos con los nombres 'temperature' y
'humidity’ en las etiquetas Campo 1 y Campo 2, marcando las casillas de verificación para ambos
Campos. Marque también la casilla de verificación 'Hacer público' en el formulario y finalmente
Guarde el canal.

Figura 11. Creación de campos para el canal.

 Ahora se hace clic en la pestaña "API Keys" y observamos las claves de escritura, lectura y el
número de canal. Debemos guardar las claves de escritura y lectura de la API debido a que se
utilizaran en los dispositivos para leer y escribir datos.

9
 Figura 5.12. Acceso a la API KEY

5.4. Implementación de un cliente GET para envío de datos a ThingSpeak

En la siguiente sección se desarrollará un programa para implementar en el NodeMCU un cliente HTTP
GET el cual realizará lecturas del sensor de humedad y temperatura ambiental DHT22 y enviará esta
información a los servicios de visualización de datos en ThingSpeak.

temperature
GET Request
humidity

Figura 13. Esquema de publicación de datos de sensor en ThingSpeak.

Para realizar este ejemplo seguimos estos pasos:

 Abrimos el IDE Arduino y seleccionamos la tarjeta NodeMCU v1.0 y el puerto Serial donde se
encuentre conectado.
 Escribimos código del siguiente cuadro que permitirá conectarnos a los servicios de ThingSpeak.
Es en este punto donde debemos tener el API_KEY para escribir datos en el servidor de
ThingSpeak.

const char* host = "api.thingspeak.com";

const char* THINGSPEAK_API_KEY = "xxxxxxxxxxxxxxxxx";

 Se realiza la configuración de las variables de conexión a red y el host y API_KEY de ThingSpeak

y pin del sensor DHT11.
 En la sección de configuración se observa la inicialización de la velocidad del puerto serial a 9600
y la comunicación WiFi con la función “WiFiBegin”.
 En el bucle principal se realiza la conexión con el servidor.
 Si hay una conexión exitosa se hace la lectura del sensor DHT y crea la URL para realizar la
petición de datos.
 Si hay respuesta del servidor se utiliza la función “client.available” para mostrar la respuesta por
10
 el puerto serie junto con “client.readStringUntil”.
 Se agrega un retardo de 30 segundos, el cual es el periodo para enviar datos. Es importante tener
en cuenta que el mínimo valor para el envío de datos a ThingSpeak es de 20 segundos.
 Una vez escrito el código guardamos el archivo con nombre nombre: “Ejemplo14_get”.
 Compilamos y grabamos el programa, verificando nuevamente que se ha seleccionado la tarjeta
NodeMCU 1.0 y puerto Serial correcto.
#include <ESP8266WiFi.h>
#include "DHT.h"
const char* ssid = "ricne";
const char* password = "s10n1sm0";
const char* host = "api.thingspeak.com";
const char* THINGSPEAK_API_KEY = "AY5DJAKOADFCLAL5";
#define DHTPIN D7
#define DHTTYPE DHT11 // DHT 11
const boolean IS_METRIC = true;
const int UPDATE_INTERVAL_SECONDS = 30;
DHT dht(DHTPIN, DHTTYPE);

void setup() {
Serial.begin(115200);
delay(10);
Serial.println();Serial.println();
Serial.print("Connecting to ");Serial.println(ssid);

WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);Serial.print(".");
}
Serial.println("");Serial.println("WiFi connected");
Serial.println("IP address: ");Serial.println(WiFi.localIP());
}

void loop() {
Serial.print("connecting to ");Serial.println(host);
WiFiClient client;
const int httpPort = 80;
if (!client.connect(host, httpPort)) {
Serial.println("connection failed");
return;
}
float humidity = dht.readHumidity();
float temperature = dht.readTemperature(!IS_METRIC);

String url = "/update?api_key=";

url += THINGSPEAK_API_KEY;
url += "&field1=";
url += String(temperature);
url += "&field2=";
url += String(humidity);

Serial.print("Requesting URL: ");

11
 Serial.println(url);

client.print(String("GET ") + url + " HTTP/1.1\r\n" +

"Host: " + host + "\r\n" +
"Connection: close\r\n\r\n");
delay(10);
while(!client.available()){
delay(100);Serial.print(".");
}
while(client.available()){
String line = client.readStringUntil('\r');Serial.print(line);
}
Serial.println();Serial.println("closing connection");
delay(1000 * UPDATE_INTERVAL_SECONDS);
}

Se observa en el monitor serial que se tiene la respuesta del servidor cada 30 segundos lo cual indica que
tenemos una respuesta satisfactoria del servidor. Los datos se pueden observar de forma gráfica en la
sección “Channels”.

Figura 14. Visualización de la respuesta del servidor

Figura 15. Interfaz visual de monitoreo de datos

12
Utilizando el software “Hercules” podemos comprobar que también podemos enviar datos si utilizamos el
formato adecuado para el envío de datos.

NodeMCU. Envío de datos Hercules HW. Envío de datos

GET GET
http://api.thingspeak.com/update?api_key=AY5DJAK http://api.thingspeak.com/update?api_key=AY5DJA
OADFCLAL5&field1=27.2&field2=56.2\n KOADFCLAL5&field1=27.2&field2=56.2
HTTP/1.1\n HTTP/1.1<LF>Host:
Host: api.thingspeak.com\n api.thingspeak.com<LF>Connection:
Connection: close\n\n\n close<LF><LF><LF>

Tabla 2. Formato de petición HTTP GET

Figura 16. Acceso al servidor desde un cliente HTTP en Hercules

Para hacer la lectura de los datos de forma remota podemos utilizar las siguientes opciones:

a) Utilizar el navegador web. Accediendo a la sección “Data import/export” se observa el formato de

petición GET para obtener las lecturas de los “feeds” de un canal que hemos creado. EL formato es:
GET https://api.thingspeak.com/channels/<canal>/feeds.json?api_key=<KEY>&results=<num>

13
 https://thingspeak.com/channels/469510/ https://api.thingspeak.com/channels/469510/
import_export feeds.json?api_key=XX&results=1

Figura 17. Formato de solicitud de datos para ThingSpeak

b) Uso de un software cliente HTTP. Se puede utilizar el software “Hércules” con el formato mostrado en
la siguiente figura.
“GET
https://api.thingspeak.com/channels/469510/feeds.json?api_key=AY5DJAKOADFCLAL5&results=1<LF>H
TTP/1.1<LF>Host: api.thingspeak.com<LF>Connection: close<LF><LF><LF>”

Figura 18. Acceso al servidor desde un cliente HTTP en Hercules

c) Utilizar aplicaciones móviles. Otra opción para acceder a los datos remotamente desde el teléfono
móvil utilizando la aplicación donde debemos ingresar la API_KEY de lectura y número de canal.
Podemos utilizar la aplicación “ThingView” la cual requiere como datos el número de canal y el API_KEY
para lectura de datos

14
 Figura 19. Sofware ThingView para visualización de datos.

También se puede utilizar un cliente HTTP “HTTPClient” e ingresar los datos de solicitud de datos en el
formato:
“GET /channels/469510/feeds.json?api_key= AY5DJAKOADFCLAL5&results=1”

Figura 20. Software HTTP Client para conexión con servidores

15