PRACTICA Nº 3

LABORATORIO AUTOMÁTICA INDUSTRIAL

PRACTICA Nº 3A
IoT con ThingSpeak

OBJETIVO:
Configurar y programar un entorno IoT mediante Arduino UNO, modulo Wifi ESP8266, y plataforma ThingSpeak.

Paso 1:

Instalar IDE Arduino.

https://www.arduino.cc/en/software

Si el driver no es reconocido automáticamente al conectar el Arduino UNO, actualizar manualmente en vuestro PC a

través de: Panel de control -> Administrador de dispositivos.

Paso 2:

El módulo Wifi ESP8266-ESP01 presenta las siguientes características hardware:

 32 Bits CPU @ 80 MHz processor
 64KB command RAM, 96KB data RAM; Flash Memory: 512KB (up to 4MBit).
 2 GPIO, SPI, I2C, and UART
 Wifi: 802.11 b/g/n; IPv4, TCP/IP
 Baund rate: 9.600 to 115.200
 Power consumption 200mA when transmitting

Via Augusta 390 – 08017 Barcelona – Tel.: +34 932 672 000 – Fax: +34 932 056 266 – www.iqs.edu Pág 1.
 PRACTICA Nº 3

El módulo ESP8266 es un microprocesador de altas prestaciones y bajo coste con Wifi integrado, que permite crear
conectividad Wifi en plataformas Arduino UNO. Existe un gran número de placas que integran el ESP8266, entre ellos:

El módulo ESP8266-ESP01 puede ser configurado mediante comandos AT, a través de la conexión con un Arduino
UNO mediante el puerto serie (asegurar RX y TX con nivel de tensión de 3.3V). Recomendable NO utilizar el puerto
serie del Arduino UNO, ya que esto implica que tendremos que desconectar el ESP01 cuando queramos programar el
Arduino, ya que cuando este puerto serie está ocupado con el ESP01, no permite comunicación con el PC. Por este
motivo, se emplea un puerto serie por software, a pesar de que esta solución supone una carga de procesado
importante en el Arduino UNO.

La velocidad de transmisión en el módulo ESP01 es configurable mediante los comandos AT, y por defecto suele estar
definida en 115.200 baudios, por lo que deberíamos cambiar a una velocidad de transmisión serie más lenta (9.600
baudios) utilizando el código fuente 1. Cablear la salida digital 13 para verificar que ha terminado con la configuración
del módulo, y seguir la configuración establecida de red a través de la consola de IDE.

Una forma más sencilla de utilizar el módulo ESP8266, es evitando los comandos AT y utilizando la librería asociada:
#include <ESP8266WiFi.h>; sin embargo, el ESP01 no lo permite sin una actualización de firmware previa. El
dispositivo NodeMCU integra el módulo ESP12F, el cual permite utilizar la librería #include <ESP8266WiFi.h>
directamente.

Via Augusta 390 – 08017 Barcelona – Tel.: +34 932 672 000 – Fax: +34 932 056 266 – www.iqs.edu Pág 2.
 PRACTICA Nº 3

Los pines y cableado del ESP01:

VCC = 3.3V; proporcionar esta tensión a través del Arduino UNO y añadir un estabilizador de tensión de 3.3V (78XX).
TX; RX = only 3.3V;
Programar puerto serie por software en Arduino UNO:
 RX en Arduino (Salida 2), cableado a TX en ESP01.
 TX en Arduino (Salida 3), cableado a RX en ESP01.
CH_PD = HIGH
GPIO_0 = LOW and GPIO_1 = HIGH -> Flash mode (firmware upgrade) EVITAR!!!
GPIO_0 = HIGH -> Normal mode
For reset -> RESET to GND

Paso 3:

ThingSpeak es una plataforma abierta de IoT desarrollada por Matlab.

https://thingspeak.com/

Permite subir canales a la plataforma ThingSpeak, con un máximo de 8.200 mensajes/día=56 mensajes/10 minutos
(en la versión no comercial). Cada canal permite 8 campos, y los datos pueden ser enviados cada minuto (20 segundos
mínimo).

Instalar ThingSpeak Communication Library mediante el IDE de Arduino:

Sketch->library manager->look for ThingSpeak

Una vez dado de alta en la plataforma https://thingspeak.com/; crear un nuevo canal y anotar el “Write API Key” y el
“Channel ID”.

Revisar y cargar el código fuente 2 para enviar datos a la plataforma IoT Thingspeak.

Instalar ThingViewer – ThingSpeak viewer en vuestra terminal Android, y podréis monitorizar las variables publicadas
en la nube:
https://play.google.com/store/apps/details?id=dev.stol.thingviewer&hl=es&gl=US

Via Augusta 390 – 08017 Barcelona – Tel.: +34 932 672 000 – Fax: +34 932 056 266 – www.iqs.edu Pág 3.
 PRACTICA Nº 3

Notas sobre carga de firmware en ESP01 (flash the firmare):

Se puede realizar de dos maneras, o bien a través del puerto serie creado por software en el Arduino UNO, o bien
mediante un adaptador serie CP2102 (USB a TTL) conectado directamente al ESP8266-ESP01.

Serial adaptor USB to TTL

(CP2102 on board)

La actualización del firmware sobre el ESP8266-ESP01 que permita utilizar la librería #include <ESP8266WiFi.h>, no
es tarea fácil, por lo que en su lugar utilizaremos en la siguiente práctica el NodeMCU-ESP8266-ESP12, con las
siguientes características hardware:
 ESP8266-ESP12, ideal for prototyping.
 The microprocessor is a NodeMCU, which can be programmed using IDE Arduino.
 The device holds a ESP8266, a PCB antenna, a led at GPIO2, and a flash memory (4MB).
 Power source: 3,3V
 Current consuption: 8mA
 11 terminals: digital inputs/outputs, and analog inputs.
 Do not use terminals GPIO 6-11 (for flash).
 Serial port GPIO1 (TXD0) and GPIO3 (RXD0) are protected with 470Ω resistance, and are connected to the
ESP8266 module.

Via Augusta 390 – 08017 Barcelona – Tel.: +34 932 672 000 – Fax: +34 932 056 266 – www.iqs.edu Pág 4.
 PRACTICA Nº 3

Código Fuente 1:

#include <SoftwareSerial.h>
SoftwareSerial SerialESP8266(2, 3); // 2:RX, 3:TX

unsigned long timeStored_1=0;

unsigned long timeStored_2=0;
boolean debug=true;

//SETUP==============================================================
//==============================================================
// place your setup code here for INITIALIZATION (it will execute only once):
void setup() {
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
pinMode(11, OUTPUT);
pinMode(8, INPUT);
Serial.begin(9600); // baud rate with Arduino PC console
SerialESP8266.begin(115200); // baud rate between Arduino and ESP8266
// SerialESP8266.begin(9600); // baud rate between Arduino and ESP8266

// INI ESP8266 MODULE

int delay_1=2000;
int delay_2=5000;
sendData("AT\r\n",delay_1); // check
sendData("AT+GMR\r\n",delay_1); // check version
sendData("AT\r\n",delay_1); // check

//Reconfigurar el modulo ESP8266 de 115200 a 9600 baudios; con SerialESP8266.begin(115200) y luego modificar a 9600;====
sendData("AT+RST\r\n",delay_1);
sendData("AT+UART_CUR=9600,8,1,0,0\r\n",delay_1);
//

sendData("AT+CWMODE=3\r\n",delay_1); // configure as station and access point

// sendData("AT+CIPSTA=172.16.40.100,172.16.40.1,255.255.255.0\r\n",delay_1); // SET IP, GATEAWAY, AND MASK; CAN NOT DO IT FROM HERE!!! DO
IT AT TEST_3
sendData("AT\r\n",delay_1); // check
sendData("AT+CWMODE?\r\n",delay_1); // mode request
sendData("AT\r\n",delay_1); // check
sendData("AT+CWLAP\r\n",delay_2); // show wifi available
delay(2000);
sendData("AT+CIPMUX=1\r\n",delay_2); // configure for multiple connexions
delay(2000);
sendData("AT+CIPSERVER=1,8000\r\n",delay_2); //
delay(2000);

sendData("AT+CWJAP=\"iqs_iot\",\"IqsIot2020\"\r\n",10000); //SSID and password of the network at home

delay(2000);

sendData("AT+CWJAP?\r\n",delay_2); // query network connected

delay(2000);

sendData("AT+CIFSR\r\n",delay_2); // request IP address

delay(2000);

// sendData("AT+CIPSTA?\r\n",delay_2); // request IP address

// delay(4000);
// sendData("AT+CIPSTA=172.16.40.5\r\n",delay_2); // define IP address GIVES ERROR!!!

Via Augusta 390 – 08017 Barcelona – Tel.: +34 932 672 000 – Fax: +34 932 056 266 – www.iqs.edu Pág 5.
 PRACTICA Nº 3

// delay(2000);
// sendData("AT+CIPSTA?\r\n",delay_2); // request IP address
}

//sendData======================================================
//==============================================================
// subroutine sendData: TO SEND DATA TO ESP01
void sendData(String comando, const int timeout)
{
long int time = millis(); // read actual time
SerialESP8266.print(comando); // send command to ESP8266
while( (time+timeout) > millis()) //while no timeout
{
while(SerialESP8266.available()) //reading data when available
{
char c = SerialESP8266.read();
Serial.print(c);
}
}
return;
}

//loop==========================================================
//==============================================================
void loop() {
digitalWrite(13, HIGH);
}

Via Augusta 390 – 08017 Barcelona – Tel.: +34 932 672 000 – Fax: +34 932 056 266 – www.iqs.edu Pág 6.
 PRACTICA Nº 3

Código Fuente 2:
#include <SoftwareSerial.h>
SoftwareSerial ESP8266(2, 3); // Rx, Tx

String API = " Write API Key"; // CHANGE FOR THE "Write API Key" DEFINED AT THINGSPEAK
String HOST = "api.thingspeak.com";
String PORT = "80";
String field = "field1";

int countTrueCommand;
int countTimeCommand;
boolean found = false;

int V20_temperature = 0;
long startTime = 0;

unsigned char check_connection=0;

unsigned char times_check=0;

//INI=======
void setup()
{
Serial.begin(9600);
ESP8266.begin(9600);
startTime = millis();
// ESP8266.println("AT+RST");
delay(2000);
Serial.println("Connecting to Wifi");
while(check_connection==0)
{
Serial.print(".");
ESP8266.print("AT+CWJAP=\" WIFI_NAME\",\" WIFI_PASSWORD\"\r\n");
ESP8266.setTimeout(5000);
if(ESP8266.find("WIFI CONNECTED\r\n")==1)
{
Serial.println("WIFI CONNECTED");
break;
}
times_check++;
if(times_check>3)
{
times_check=0;
Serial.println("Trying to Reconnect..");
}
}
}

//MAIN=======
void loop() {
V20_temperature = random(100);
String getData = "GET /update?api_key="+ API +"&"+ field +"="+String(V20_temperature);
sendCommand("AT+CIPMUX=1",5,"OK");
sendCommand("AT+CIPSTART=0,\"TCP\",\""+ HOST +"\","+ PORT,15,"OK");
sendCommand("AT+CIPSEND=0," +String(getData.length()+4),4,">");
ESP8266.println(getData);
delay(1500);

Via Augusta 390 – 08017 Barcelona – Tel.: +34 932 672 000 – Fax: +34 932 056 266 – www.iqs.edu Pág 7.
 PRACTICA Nº 3

countTrueCommand++;
sendCommand("AT+CIPCLOSE=0",20,"OK");
}

//SUB=======
void sendCommand(String command, int maxTime, char readReplay[]) {
Serial.print(countTrueCommand);
Serial.print(". at command => ");
Serial.print(command);
Serial.print(" ");
while(countTimeCommand < (maxTime*1))
{
ESP8266.println(command);//at+cipsend
if(ESP8266.find(readReplay))//ok
{
found = true;
break;
}

countTimeCommand++;
}

if(found == true)
{
Serial.println("OYI");
countTrueCommand++;
countTimeCommand = 0;
}

if(found == false)
{
Serial.println("Fail");
countTrueCommand = 0;
countTimeCommand = 0;
}

found = false;
}

Via Augusta 390 – 08017 Barcelona – Tel.: +34 932 672 000 – Fax: +34 932 056 266 – www.iqs.edu Pág 8.
 PRACTICA Nº 3

PRACTICA Nº 3B
IoT con MQTT

OBJETIVO:
Configurar y programar un entorno IoT mediante Arduino UNO y modulo Wifi ESP8266, que permita enviar mensajes
al servidor local mosquito MQTT (en Windows) o bien un servidor MQTT público (Google Cloud), utilizando el protocolo
MQTT.

MQTT (Message Quering Telemetry Transport) es un protocolo que permite el envío de mensajería para aplicaciones
IoT bajo protocolo TCP/IP. Desarrollado inicialmente por IBM en 1999, presenta una transmisión de mensajería más
rápido que HTTP, debido a que los telegramas pueden llegar a ser de tan solo 2 bytes, mientras que los telegramas
bajo HTTP son más extensos, al requerir de encabezamientos que contienen mucha más información, que podrían
llegar a ser de poca utilidad para los equipos que conforman la red IoT de interés.

Requiere la presencia de un Servidor MQTT (Broker), que se encarga de centralizar los mensajes enviados/recibidos
encriptados por diferentes usuarios o Clientes MQTT, y de gestionar los accesos.

Los Clientes MQTT dados de alta por el Servidor MQTT, enviarán mensajes al Servidor MQTT (Publish), o bien
recibirán mensajes del Servidor MQTT (Subscribe). Los mensajes consistirán en topics (subjects), que contendrán los
datos de interés a transmitir.

Client-1 Client-2
PUBLISH: PUBLISH:
/mensaje1A /mensaje2A

SUBSCRIBE:
/mensaje1B
MQTT Broker

Client-3 Client-4
SUBSCRIBE: PUBLISH:
/mensaje3B /mensaje4A

En esta práctica utilizaremos un servidor (Broker) público MQTT (Google Cloud), la aplicación móvil para Android
MQTT cliente de RadioShuttle (MQTT Push Client), y el NodeMCU-ESP8266-ESP12.

Una aplicación de gran utilidad en aplicaciones IoT es Node-RED, desarrollada inicialmente por IBM, permite
programar en un editor gráfico basado en flujos, la interconexión de mensajería entre diferentes sistemas:
entradas/salidas digitales, base de datos, APIs… etc. Cuenta con una librería con más de 2.800 nodos (funciones).
https://nodered.org/

Via Augusta 390 – 08017 Barcelona – Tel.: +34 932 672 000 – Fax: +34 932 056 266 – www.iqs.edu Pág 9.
 PRACTICA Nº 3

Paso 1:
A fin de evitar una actualización de firmware sobre el ESP8266-ESP01, utilizaremos el NodeMCU-ESP8266-ESP12.

Cargar código fuente 3 para realizar una prueba de conexión a la red con activación de led de la placa.

Paso 2:
Cargar código fuente 4 para realizar una prueba de conexión a la red a la plataforma ThingSpeak.

Comprobar la subida de datos en ThingViewer – ThingSpeak viewer en vuestra terminal Android:

https://play.google.com/store/apps/details?id=dev.stol.thingviewer&hl=es&gl=US

Paso 3:
El objetivo es desarrollar un código fuente que permita enviar un dato desde el cliente NodeMCU al cliente Android
MQTT Push, a través del a través del cliente MQTT Dashboard, gestionado por el Servidor público HiveMQ MQTT
(Broker).
http://www.mqtt-dashboard.com/

Utilizar la librería “PubSubClient by Nick O’Leary” en el IDE de Arduino, la cual permite publicar/subscribir mensajes
con servidores MQTT, desde el cliente Arduino (#include <PubSubClient.h>).

Instalar la aplicación Android MQTT Push de RadioShuttle, que hará de cliente MQTT en vuestro terminal Android:
https://www.radioshuttle.de/es/mqtt-es/mqtt-push-client-app/

MQTT-Broker

Android MQTT Push

(de RadioShuttle)
Cargar y depurar código fuente 5.

Paso 4 (no necesario):

Si la intención es crear un servidor HIveMQ MQTT (Broker), necesitáis instalar en vuestro PLC el HiveMQ Control
Center (ayuda de instalación en Moodle). NOTA: el fichero de instalación zip ocupa 155MB, y no cabe en Moodle; por
lo que os entregará en un USB. Instalar y leer README.txt.

Instalar Java Runtime Environment para vuestra máquina de 64 bits (si requerido) desde:
https://adoptopenjdk.net/?variant=openjdk11

Via Augusta 390 – 08017 Barcelona – Tel.: +34 932 672 000 – Fax: +34 932 056 266 – www.iqs.edu Pág 10.
 PRACTICA Nº 3

Código Fuente 3:
#define LED_BUILTIN 2
#include <ESP8266WiFi.h>
#include <SoftwareSerial.h>

const char* ssid = " WIFI_NAME "; // WiFi SSID

const char* password = " WIFI_PASSWORD "; // PASSWORD

void setup() {
// put your setup code here, to run once:
// SERIAL COM
Serial.begin(115200); //baund rate between PC and NodeMCU
delay(1000);

// CONNECT TO WIFI
Serial.println();
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);

// CONFIGURE AS WIFI CLIENT

WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);

// CHECK DEVICE CONNECTED TO WIFI

while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP()); // SHOWING IP ADDRESS

// LED at pin 2.
pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {

Via Augusta 390 – 08017 Barcelona – Tel.: +34 932 672 000 – Fax: +34 932 056 266 – www.iqs.edu Pág 11.
 PRACTICA Nº 3

Código Fuente 4:
// NodeMCU

#include "ThingSpeak.h"
#include <ESP8266WiFi.h>

const char* ssid = "WIFI_NAME"; // WiFi SSID

const char* password = "WIFI_PASS"; // PASSWORD
//const char* ssid = "sauro"; // WiFi SSID
//const char* password = "12345678"; // PASSWORD

// Example variables
unsigned long timeStored_2=0;
int V20_temperature = 0;

// ThingSpeak
unsigned long myChannelNumber = 802725;
const char * myWriteAPIKey = "YZ94RMMYS9A2PQSD";

void setup() {

Serial.begin(9600); // Enable this line only if DEBUG=true

delay(500);

// CONNECT TO WIFI
Serial.println();
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);

// CONFIGURE AS WIFI CLIENT

WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);

// CHECK DEVICE CONNECTED TO WIFI

while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP()); // SHOWING IP ADDRESS
}

void loop() {

if (millis()-timeStored_2>20000) { // write sensor value every 20 seconds.

WiFiClient client;
// Initialize ThingSpeak
ThingSpeak.begin(client);
V20_temperature = random(100);
ThingSpeak.writeField(myChannelNumber, 1, V20_temperature, myWriteAPIKey);
timeStored_2=millis();
}
}

Via Augusta 390 – 08017 Barcelona – Tel.: +34 932 672 000 – Fax: +34 932 056 266 – www.iqs.edu Pág 12.
 PRACTICA Nº 3

Código Fuente 5:
// NodeMCU with MQTT
// http://broker.mqtt-dashboard.com/
//broker.hivemq.com
//broker.mqttdashboard.com

#include <ESP8266WiFi.h>
#include <PubSubClient.h>

const char* ssid = " WIFI_NAME "; // WiFi SSID

const char* password = " WIFI_PASS "; // PASSWORD
const char *mqtt_broker = "broker.mqttdashboard.com";
const int mqtt_port = 1883;

char pub_str[100];

WiFiClient espClient;
PubSubClient client(espClient);

// Example variables
unsigned long timeStored_2=0;
float V20_temperature = 0;

void setup() {

Serial.begin(9600);
delay(500);

// CONNECT TO WIFI
Serial.println();
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);

// CONFIGURE AS WIFI CLIENT

WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);

// CHECK DEVICE CONNECTED TO WIFI

while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP()); // SHOWING IP ADDRESS
delay(2000);

// CONECTING TO MQTT BROKER

client.setServer(mqtt_broker, mqtt_port);
client.setCallback(callback);
while (!client.connected()) {
Serial.println("Connecting to public emqx mqtt broker.....");
if (client.connect("esp8266-client")) {
Serial.println("Public emqx mqtt broker connected");
} else {

Via Augusta 390 – 08017 Barcelona – Tel.: +34 932 672 000 – Fax: +34 932 056 266 – www.iqs.edu Pág 13.
 PRACTICA Nº 3

Serial.print("failed with state ");

Serial.print(client.state());
delay(2000);
}
}
// publish and subscribe ("topic","payload")
client.publish("sauro/test", "hello emqx");
client.subscribe("sauro/test");
}

void callback(char *topic, byte *payload, unsigned int length) {

Serial.print("Message arrived in topic: ");
Serial.println(topic);
Serial.print("Message:");
for (int i = 0; i < length; i++) {
Serial.print((char) payload[i]);
}
Serial.println();
Serial.println("-----------------------");
}

void loop() {

V20_temperature = random(100);
//sprintf(pub_str,"%f", tmp);
dtostrf(V20_temperature,2,3,pub_str); //dtostrf: convierte una variable float en string; 2: enteros, 3: decimales
Serial.print("valor en formato float: ");
Serial.println(V20_temperature);
Serial.print("valor en formato string: ");
Serial.println(pub_str);

client.publish("sauro/V20_temperature",pub_str); //send as string

delay(10000);

client.loop();

Via Augusta 390 – 08017 Barcelona – Tel.: +34 932 672 000 – Fax: +34 932 056 266 – www.iqs.edu Pág 14.