MQTT

UNIVERSIDAD TÉCNICA DE AMBATO
FACULTAD DE INGENIERÍA EN SISTEMAS, ELECTRÓNICA E INDUSTRIAL

Carrera: Telecomunicaciones - Modulo: Comunicaciones Avanzadas
Docente: Ing. Santiago Manzano
PRACTICA MQTT
MQTT
Es un protocolo de comunicación que nos permite enviar mensajes entre un publicador,

que es quien envía el mensaje y uno o varios suscriptores que son quienes recibirán los
mensajes siempre y cuando estén suscritos al tópico del publicador, el encargado d
establecer esta conexión es un bróker como se puede apreciar en la siguiente imagen:
Descripción
Desarrollo de Practica
La siguiente practica tiene como fin usar la tarjeta ESP8266 como publicador y nuestro
ordenador como subscriptor, así como también de bróker, para esta práctica usaremos
el sensor DHT11 de humedad y temperatura y HCSR04 de distancia para poder enviar
los datos, los cuales serán almacenados en una base datos de forma local como en un
servicio en la nube, para este caso utilizaremos nuestra máquina virtual de RedHat como
servidor local y una instancia de AWS como servidor en la nube.
Materiales:
• ESP8266
• Arduino IDE
• Maquina virtual con SO de RedHat o Centos

• Suscripción en AWS
Desarrollo de la práctica
Instalación de MQTT
1. Arrancamos nuestra máquina virtual y procedemos a ingresar los siguientes
comandos:
Para actualizar los repositorios
sudo yum -y install nano
Instalamos epl-release
sudo yum install epel-release-latest-7.noarch.rpm
Instalamos mosquito
sudo yum -y install mosquitto
Una vez instalado procedmos a modificar el archivo de configuración
vi /etc/mosquitto/mosquitto.conf
Aplastamos la tecla Shift + g para dirigirnos al final del archivo
Una vez estando al final del archivo vamos a agregar las siguientes líneas que
están en el recuadro rojo de la imagen superior
listener 1883
allow_anonymous true
listener 9001
protocol websockets
Guardamos la configuración y ahora procedemos a correr nuestro bróker con el

siguiente comando:
mosquitto_-c /etc/mosquitto/mosquito.conf
Si hemos realizado todos los pasos de forma correcta, veremos lo siguiente:
Estos mensajes indican que nuestro bróker esta funcionando, ahora

procedermos a abrir dos terminales mas mediante SSH para comprobar el
funcionamiento de MQTT.
En el primer terminal vamos a escribir el siguiente comando y daremos enter
mosquitto_sub -h –ip del servidor-- -t casa/luz -v
La estructura de este comando como podemos ver es que primero especificamos

si seremos suscriptor o publicador, en este caso usando “_sub” aludimos a que
seremos suscirptores, luego con el atributo -h especificamos la dirección del
servidor donde esta corriendo el bróker, por ultimo usamos -t que nos dira al
topico que nos vamos a suscrbir.
Ahora en la segunda terminal abierta vamos a iniciar el publicador con el

siguiente comando:
mosquitto_pub -h –ip del servidor-- -t casa/luz -m “hola mundo”
Observamos que la estructura es casi idéntica a la del susribtor, solo que usamos
el subfijo “_sub” así como añadimos el atributo de -m para añadir el mensaje a
enviar, pulsamos enter y tendremos el siguiente resultado:
Esto indica que nuestro bróker esta funcionando de forma correcta.

Una vez instalado el bróker ahora procederemos a programar nuestra ESP8266
para que pueda enviar los datos a nuestro servidor.
Programación de ESP8266
Antes de comenzar a escribir nuestro script vamos a instalar las siguientes
librerías las cuales se pueden instalar mediante el gestor de librerías propio del
IDE de Arduino
• ESP8266WiFi
• Ticker
• AsyncMqttClient
• DHT
A continuación, se explicará las partes del código que se deben de modificar, el código
se encontrar al final de la explicación.
Solo se debe cambiar las líneas señaladas teniendo en cuenta los parámetros de
nuestra práctica, las demás líneas ya vienen por defecto.
NOTA: No se muestra el proceso para la adquisición de datos con los sensores
ya que es básico.
#include "DHT.h"
#include <ESP8266WiFi.h>
#include <Ticker.h>
#include <AsyncMqttClient.h>
#define WIFI_SSID "ANKADA"

#define WIFI_PASSWORD "1804628616i"
// Dirección del servidor donde esta nuestro broker

#define MQTT_HOST IPAddress(3,17,76,160)
//puerto de MQTT
#define MQTT_PORT 1883
// TOPICOS MQTT
#define MQTT_PUB_TEMP "casa/temperatura"
#define MQTT_PUB_HUM "casa/humedad"
#define MQTT_PUB_DIS "casa/distancia"
// sensor DHT
#define DHTPIN 5
#define DHTTYPE DHT11 // DHT 11
// Variables para sensores

const int trigPin = 14; //D5
const int echoPin = 12; //D6
float duration;
float dis;
DHT dht(DHTPIN, DHTTYPE);
// Variables para sensores

float temp;
float hum;
AsyncMqttClient mqttClient;
Ticker mqttReconnectTimer;
WiFiEventHandler wifiConnectHandler;
WiFiEventHandler wifiDisconnectHandler;
Ticker wifiReconnectTimer;
unsigned long previousMillis = 0; // Stores last time

temperature was published
const long interval = 10000; // Interval at which to
publish sensor readings
void connectToWifi() {
Serial.println("Connecting to Wi-Fi...");
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
}
void onWifiConnect(const WiFiEventStationModeGotIP& event) {

Serial.println("Connected to Wi-Fi.");
connectToMqtt();
}
void onWifiDisconnect(const WiFiEventStationModeDisconnected&

event) {
Serial.println("Disconnected from Wi-Fi.");
mqttReconnectTimer.detach();
wifiReconnectTimer.once(2, connectToWifi);
}
void connectToMqtt() {
Serial.println("Connecting to MQTT...");
mqttClient.connect();
}
void onMqttConnect(bool sessionPresent) {

Serial.println("Connected to MQTT.");
Serial.print("Session present: ");
Serial.println(sessionPresent);
}
void onMqttDisconnect(AsyncMqttClientDisconnectReason reason)

{
Serial.println("Disconnected from MQTT.");
if (WiFi.isConnected()) {
mqttReconnectTimer.once(2, connectToMqtt);
}
}
void onMqttPublish(uint16_t packetId) {

Serial.print("Publish acknowledged.");
Serial.print(" packetId: ");
Serial.println(packetId);
}
void setup() {
pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
pinMode(echoPin, INPUT); // Sets the echoPin as an Input
Serial.begin(115200);
Serial.println();
dht.begin();
wifiConnectHandler = WiFi.onStationModeGotIP(onWifiConnect);
wifiDisconnectHandler =
WiFi.onStationModeDisconnected(onWifiDisconnect);
mqttClient.onConnect(onMqttConnect);
mqttClient.onDisconnect(onMqttDisconnect);
mqttClient.onPublish(onMqttPublish);
mqttClient.setServer(MQTT_HOST, MQTT_PORT);
connectToWifi();
}
void loop() {
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= interval) {
previousMillis = currentMillis;
hum = dht.readHumidity();
temp = dht.readTemperature();
/////////
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH);
dis = duration*0.034/2.0;
//Publicación de mensaje MQTT con el topico temp
uint16_t packetIdPub1 = mqttClient.publish(MQTT_PUB_TEMP,
1, true, String(temp).c_str());
Serial.printf("Publishing on topic %s at QoS 1, packetId:
%i ", MQTT_PUB_TEMP, packetIdPub1);
Serial.printf("Message: %.2f \n", temp);
//Publicación de mensaje MQTT con el topico hum

uint16_t packetIdPub2 = mqttClient.publish(MQTT_PUB_HUM,
1, true, String(hum).c_str());
Serial.printf("Publishing on topic %s at QoS 1, packetId
%i: ", MQTT_PUB_HUM, packetIdPub2);
Serial.printf("Message: %.2f \n", hum);
//Publicación de mensaje MQTT con el topico dist
uint16_t packetIdPub3 = mqttClient.publish(MQTT_PUB_DIS,
1, true, String(dis).c_str());
Serial.printf("Publishing on topic %s at QoS 1, packetId
%i: ", MQTT_PUB_DIS, packetIdPub3);
Serial.printf("Message: %.2f \n", dis);
}
}
Una vez modificado el script procedemos a cargarlo para poder comprobar su

funcionamiento, procedemos a abrir nuestra máquina virtual y nos suscribiremos
a a los tópicos con el siguiente comando:
mosquitto_sub -h --ip de Arduino -- -t casa/# -v
Vemos que en el topico se ha utilizado “casa/#” con el carácter de numeral vamos

a recibir cualquier topico que empiece con “casa/”, también podemos usar otros
caracteres como “+”, para saber más sobre su uso se puede referir a la
documentación haciendo clic aquí.
Si no podemos ver que los mensajes del publicador llegan, se recomienda

deshabilitar el firewall de nuestro servidor con el siguiente comando:
systemctl stop firewalld.service
Deberemos tener una salida así:
Instalación de Mosquitto en una instancia de AWS
Para la instalación de Mosquitto en AWS seguimos los mismos pasos que usamos
para instalarlo en nuestro servidor de RedHat es por eso por lo que se omitirá
esa parte y se mostrara las configuraciones adicionales que se deben de hacer
son la habilitación de puertos:
1. En el panel de control de EC2 nos dirigimos a la opción de Security Groups

En el siguiente apartado daremos clic en el ID
Luego vamos a añadir las reglas de entrada para que nuestra tarjeta ESP8266
pueda conectarse a nuestro servidor a AWS
Una ves en el apartado de reglas de entrada vamos a añadir dos reglas con
los parámetros de la siguiente imagen, una para MQTT y otra websockets.
Una vez realizado este paso ya podremos usar nuestro servidor en AWS como
bróker, usaremos el mismo script para nuestra tarjeta ESP8266 que usamos
para el servidor local, solo debemos cambiar la IP de nuestro servidor, la cual
podemos encontrarla en el apartado de instancias, debemos de usar la IP
publica.
Una vez cambiado la IP subimos el script a nuestra tarjeta y vamos a proceder

a probar nuestro servidor, nos conectamos mediante PUTTY e iniciamos
nuestro bróker, luego procedemos a suscribirnos al tópico que está
publicando nuestra tarjeta como vemos en el siguiente ejemplo:
mosquitto_-c /etc/mosquitto/mosquitto.conf
mosquitto_sub -h --ip de Arduino -- -t casa/# -v
Ahora nos dirigimos a nuestro IDE de Arduino y procedemos a cargar

nuestro script apuntando a nuestro servidor en AWS
Vamos a ver como en nuestra consola de Putty donde nos suscribimos, vamos
a empezar a recibir los datos como se ve en la siguiente imagen:
Podemos también comprobar el funcionamiento mediante el websocket

para mqtt, podrán descargar la carpeta haciendo clic aquí. Ahí deberán
configurar en el archivo de ‘config.js’ el host, puerto y tópico. Una vez hecho
esto lo moveremos bajo ‘/var/www/html/’ ahí podremos acceder a nuestro
websocket, teniendo el siguiente resultado:

MQTT

Cargado por

Información del documento

Derechos de autor

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

MQTT

Cargado por

Copyright:

UNIVERSIDAD TÉCNICA DE AMBATO

FACULTAD DE INGENIERÍA EN SISTEMAS, ELECTRÓNICA E INDUSTRIAL

Es un protocolo de comunicación que nos permite enviar mensajes entre un publicador,

• Maquina virtual con SO de RedHat o Centos

Guardamos la configuración y ahora procedemos a correr nuestro bróker con el

Estos mensajes indican que nuestro bróker esta funcionando, ahora

La estructura de este comando como podemos ver es que primero especificamos

Ahora en la segunda terminal abierta vamos a iniciar el publicador con el

mosquitto_pub -h –ip del servidor-- -t casa/luz -m “hola mundo”

Esto indica que nuestro bróker esta funcionando de forma correcta.

#define WIFI_SSID "ANKADA"

// Dirección del servidor donde esta nuestro broker

#define DHTTYPE DHT11 // DHT 11

// Variables para sensores

// Variables para sensores

unsigned long previousMillis = 0; // Stores last time

void onWifiConnect(const WiFiEventStationModeGotIP& event) {

void onWifiDisconnect(const WiFiEventStationModeDisconnected&

void onMqttConnect(bool sessionPresent) {

void onMqttDisconnect(AsyncMqttClientDisconnectReason reason)

void onMqttPublish(uint16_t packetId) {

//Publicación de mensaje MQTT con el topico hum

Una vez modificado el script procedemos a cargarlo para poder comprobar su

mosquitto_sub -h --ip de Arduino -- -t casa/# -v

Vemos que en el topico se ha utilizado “casa/#” con el carácter de numeral vamos

Si no podemos ver que los mensajes del publicador llegan, se recomienda

systemctl stop firewalld.service

Deberemos tener una salida así:

Instalación de Mosquitto en una instancia de AWS

1. En el panel de control de EC2 nos dirigimos a la opción de Security Groups

En el siguiente apartado daremos clic en el ID

Una vez cambiado la IP subimos el script a nuestra tarjeta y vamos a proceder

mosquitto_sub -h --ip de Arduino -- -t casa/# -v

Ahora nos dirigimos a nuestro IDE de Arduino y procedemos a cargar

Podemos también comprobar el funcionamiento mediante el websocket

También podría gustarte