Módulo GSM con mqtt

Bueno, hoy (en continuación al post del módulo GSM) les traigo cómo utilizar mqtt con un módulo gsm, hay una librería que se encarga de hacer todo el manejo de gprs y las conexiones y nos da un sistema simplificado. El código es el siguiente:

/**************************************************************
 *
 * For this example, you need to install PubSubClient library:
 *   https://github.com/knolleary/pubsubclient/releases/latest
 *   or from http://librarymanager/all#PubSubClient
 *
 * TinyGSM Getting Started guide:
 *   http://tiny.cc/tiny-gsm-readme
 *
 **************************************************************
 * Use Mosquitto client tools to work with MQTT
 *   Ubuntu/Linux: sudo apt-get install mosquitto-clients
 *   Windows:      https://mosquitto.org/download/
 *
 * Subscribe for messages:
 *   mosquitto_sub -h test.mosquitto.org -t GsmClientTest/init -t 

 *   GsmClientTest/ledStatus -q 1
 * Toggle led:
 *   mosquitto_pub -h test.mosquitto.org -t GsmClientTest/led -q 1 -m 

 *   "toggle"
 *
 * You can use Node-RED for wiring together MQTT-enabled devices
 *   https://nodered.org/
 * Also, take a look at these additional Node-RED modules:
 *   node-red-contrib-blynk-websockets
 *   node-red-dashboard
 *
 **************************************************************/

// elegimos el modem:
#define TINY_GSM_MODEM_SIM800
// #define TINY_GSM_MODEM_SIM808
// #define TINY_GSM_MODEM_SIM900
// #define TINY_GSM_MODEM_A6
// #define TINY_GSM_MODEM_A7
// #define TINY_GSM_MODEM_M590
// #define TINY_GSM_MODEM_ESP8266
// #define TINY_GSM_MODEM_XBEE

#include <TinyGsmClient.h>
#include <PubSubClient.h>

// credenciales de gprs
// en caso de no tener usuario y contraseña no llenar
const char apn[]  = "tuapn";
const char user[] = "";
const char pass[] = "";

// para las placas Mega, Leonardo, Micro utilizar el serie por hardware
#define SerialAT Serial1

// o Software Serial para Uno y Nano
//#include <SoftwareSerial.h>
//SoftwareSerial SerialAT(2, 3); // RX, TX

TinyGsm modem(SerialAT);
TinyGsmClient client(modem);
PubSubClient mqtt(client);

const char* broker = "test.mosquitto.org";

const char* topicLed = "GsmClientTest/led";
const char* topicInit = "GsmClientTest/init";
const char* topicLedStatus = "GsmClientTest/ledStatus";

#define LED_PIN 13
int ledStatus = LOW;

long lastReconnectAttempt = 0;

void setup() {
  pinMode(LED_PIN, OUTPUT);

  // elegimos una velocidad de datos
  Serial.begin(115200);
  delay(10);

  // elegimos la velocidad para el módulo
  SerialAT.begin(115200);
  delay(3000);

  // reiniciamos el módulo, demora mucho
  Serial.println("inicializando modem...");
  modem.restart();

  String modemInfo = modem.getModemInfo();
  Serial.print("Modem: ");
  Serial.println(modemInfo);

  // si la sim tiene contraseña ponerla acá
  //modem.simUnlock("1234");

  Serial.print("esperando por red...");
  if (!modem.waitForNetwork()) {
    Serial.println(" fallo");
    while (true);
  }
  Serial.println(" OK");

  Serial.print("conectando a ");
  Serial.print(apn);
  if (!modem.gprsConnect(apn, user, pass)) {
    Serial.println(" fallo");
    while (true);
  }
  Serial.println(" OK");

  // MQTT Broker setup
  mqtt.setServer(broker, 1883);
  mqtt.setCallback(mqttCallback);
}

boolean mqttConnect() {
  Serial.print("conectando a ");
  Serial.print(broker);
  if (!mqtt.connect("GsmClientTest")) {
    Serial.println(" fallo");
    return false;
  }
  Serial.println(" OK");
  mqtt.publish(topicInit, "GsmClientTest iniciado");
  mqtt.subscribe(topicLed);
  return mqtt.connected();
}

void loop() {

  if (mqtt.connected()) {
    mqtt.loop();
  } else {
    // Reconnect every 10 seconds
    unsigned long t = millis();
    if (t - lastReconnectAttempt > 10000L) {
      lastReconnectAttempt = t;
      if (mqttConnect()) {
        lastReconnectAttempt = 0;
      }
    }
  }

}

void mqttCallback(char* topic, byte* payload, unsigned int len) {
  Serial.print("mensaje recibido [");
  Serial.print(topic);
  Serial.print("]: ");
  Serial.write(payload, len);
  Serial.println();

  // solo lo ejecutamos si coinciden los tópicos
  if (String(topic) == topicLed) {
    ledStatus = !ledStatus;
    digitalWrite(LED_PIN, ledStatus);
    mqtt.publish(topicLedStatus, ledStatus ? "1" : "0");
  }
}

En donde dice "tuapn" en la línea 43, tendremos que ingresar el APN de nuestro proveedor de telefonía, a continuación les dejo los apn de las compañías de argentina:

CLARO: igprs.claro.com.ar

MOVISTAR: wap.gprs.unifon.com.ar usuario: wap contraseña: wap

PERSONAL: datos.personal.com usuario: datos contraseña: datos

TUENTI: internet.movil usuario:internet contraseña: internet

Para otros países solamente hay que googlear: apn nombre_compañia de nombre_país (en mi caso busqué "apn de todas las compañias de argentina").

Esto código sirve para encender un led a través de mqtt por internet (las aplicaciones podrían llegar a ser increíbles, como encender algo a distancia), para hacerlo funcionar tendremos que subscribirnos a los tópicos "GsmClientTest/init" y "GsmClientTest/ledStatus", en el primer tópico el equipo va a notificar cuando se conecte y en el segundo nos va a notificar el estado del led (encendido o apagado). Si publicamos en el tópico "GsmClientTest/led" podremos cambiar el estado del led mandando un mensaje cualquiera en ese tópico.

Estación meteorológica simple

En esta ocasión les traigo una forma de hacer una estación meteorológica simple con node-red, mqtt, esp8266, un dth11 y una raspberry pi 3 haciendo las veces de servidor. La idea es dejar este equipo en el exterior y que se comunique con el servidor a través de la red wifi, y que a través de un servicio web podamos consultar los datos actuales y atrás en el tiempo.

Primero y principal deberíamos tener los componentes mínimos para montar el sistema, por lo que vamos a necesitar un par de cargadores de celular (para alimentación de las dos placas), una vez realizado esto tendríamos que establecer una conexión vnc, que lo vamos a conseguir ingresando al terminal (de la raspberry pi 3) y ponemos los siguientes comandos:

sudo apt-get update

sudo apt-get install realvnc-vnc-server realvnc-vnc-viewer

esto nos va a instalar el real vnc, una vez puesto todo eso vamos a descargar el vnc viewer y a instalarlo. una vez echo esto vamos a conectarnos (es posible que haya que configurar una contraseña además de darle permiso desde la rbpi 3, no pongo todos los pasos por acá porque se va a hacer muy largo el post y esto tampoco es tan necesario para tener andando todo, directamente se podría realizar desde la rbpi 3 y dejarlo andando sin problemas, pero me resulta más práctico tener acceso a la computadora de forma remota) a la dirección que nos indique en la rbpi3. Esto nos va a "simular" lo que aparecería por pantalla de la computadora, y debería ser algo como lo siguiente:

Luego deberíamos bajar el mqtt broker mosca en la rbpi 3, para poder crear el servicio. Para ello abriremos el terminal e ingresar el siguiente comando (quizá sea bastante molesto, pero poner la palabra "sudo" antes de cualquier comando, le da atributos root y nos evita perder el tiempo, aunque hay que tener cuidado porque justamente estamos ejecutando cosas como root):

sudo npm install mosca bunyan -g

y debería aparecer lo siguiente:

El proceso de instalación demora bastante, sobre todo si la tarjeta SD sobre la cual montamos el SO es medio lenta o si están ejecutando otras cosas como el navegador.

Una vez terminado el proceso de instalación, solo hay que iniciar el servidor mqtt con el comando:

mosca -v | bunyan

y debería iniciar de la siguiente forma:

Hay que recordar que también hay que iniciar el node-red para este proyecto. Una vez todo configurado vamos a abrir en nuestro navegador el node-red (con la ip de la rbpi 3) y vamos a colocar los siguientes nodos:

El código para estos nodos lo dejo al final del post.

Le damos "deploy" y ya deberíamos tener esa parte lista, si queremos guardar los dato o si queremos graficar más tiempo solo tenemos que cambiar las bases de las gráficas. Si nos vamos a la página del node-red (que es agregando a la dirección que termina en 1880, /ui) tendremos lo siguiente:

Ahora vamos a arrancar con la parte del sensor (dht11) y el esp8266. Los componentes que estoy usando son los de las fotos (sé que no queda bien usar el flash, pero se veía tan poco que decidí cometer el pecado):

 

Los tengo conectados con un cable que me vino con mi modelo del esp.
El cable no era el ideal, porque tenía la separación de los pines muy
corta y los cables no me coincidían con el sensor, pero lo invertí y
"forcé" los pines del dht para que todo quedase bien (creo).

Según mi placa (el modelo es "crowtail- ESP8266 NodeMCU") lo tengo conectado sobre el pin "D1" que según la web es el GPIO5, por lo que si ustedes tienen otra placa deberían corroborar cuál es el pin adecuado.

El código que le cargué es el siguiente:

/*
 * Este programa es una estación meteorológica que verifica los niveles de 
 * temperatura y humedad del ambiente con el sensor DTH11. Se alimenta con 
 * una celda fotovoltáica, y posee un cargador de baterías y alimentación 
 * para el equipo.
 */


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

//---------------------------------------------------------------------------

#include "DHT.h"

#define DHTPIN            5         // Pin de datos
#define DHTTYPE           DHT11     // DHT 11

// El tercer parámetro va en función de la velocidad
// del microprocesador, cuanto más rápido sea, más 
// grande el valor (6 es para un micro de 16Mhz).

DHT dht(DHTPIN, DHTTYPE, 11);

//---------------------------------------------------------------------------

// Las siguientes tres constantes definen, nombre
// de red wifi y su contraseña.

const char* ssid = "Fibertel WiFi999";
const char* password = "0043546735";
const char* mqtt_server = "192.168.1.23";

// Acá definimos los pines.

const int d1 = 5, d2 = 4, d3 = 0, pin_led = 2;

long tiempo = 0;

// A continuación declaramos el nombre del cliente 
// que se va a conectar.

WiFiClient espClient;
PubSubClient client(espClient);

// En esta variable se almacena el mensaje recibido
// notar que tiene un máximo de 50 (en realidad son
// 49) caracteres.

char msg[50];

void setup() {
  pinMode(pin_led, OUTPUT);   //Pin del LED 2
  digitalWrite(pin_led, LOW);
  pinMode(d1, INPUT);         //Pin D1
  pinMode(d2, INPUT);         //Pin D2
  pinMode(d3, INPUT);         //Pin D3
  
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);

  dht.begin();
}

void setup_wifi() {

    Serial.println();
    Serial.print("Conectando a: ");
    Serial.println(ssid);
  
    WiFi.begin(ssid, password);

    while (WiFi.status() != WL_CONNECTED) 
    {
      delay(500);
      Serial.print(".");
    }
  
    digitalWrite(pin_led, HIGH);
  
    Serial.println("");
    Serial.println("WiFi conectado");
    Serial.println("IP: ");
    Serial.println(WiFi.localIP());

}

// En esta función se administra la llegada de 
// mensajes, nos avisa en qué tópico llegó y 
// cuál es el mensaje.

void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Mensaje recibido [");
  Serial.print(topic);
  Serial.print("] ");

  if ((char)payload[0] == 'O') {  // si recibo como primer caracter una O
    if ((char)payload[1] == 'N'){  // si recibo como segundo caracter una N
      Serial.println("El boton esta apagado"); 
      digitalWrite(pin_led, LOW);
    } 
    else {
      Serial.println("El boton esta encendido");  
      digitalWrite(pin_led, HIGH);
    }
  }

}

// Esta función se encarga de conectar con el 
// mqtt broker, si lo consigue se subscribe a
// los tópicos que definamos (no es necesario
// subscribirnos en esta función, pero si lo
// recomiendo para organizar mejor el código.
// Prueba reconectarse cada cinco segundos si
// no lo consigue.

void reconnect() {
  // Loop hasta lograr la conexión
  while (!client.connected()) {
    Serial.print("Intentando conectar al servicio MQTT...");
    
    if (client.connect("ESP8266Client")) {
      Serial.println("Conectado!");
      client.publish("temperatura", "0");    //envío dato
      client.publish("humedad", "0");    //envío dato
    } 
    else 
    {
      Serial.print("Fallo, Resultado=");
      Serial.print(client.state());
      Serial.println("Intetando nuevamente en 5 segundos");
      delay(5000);
    }
  }
}

// En el loop principal no hacemos nada más 
// que verificar si perdimos la conexión con
// el servicio mqtt, que lleguen mensajes y
// actualizamos la temperatura y humedad. 
// El "client.loop();" se encarga de revisar 
// si llegaron mensajes, por lo que habría
// que invocar esta función regularmente.

void loop() {

  if (WiFi.status() != WL_CONNECTED)
  {
    setup_wifi();
  }
  if (!client.connected()) 
  {
    reconnect();
  }
  
  //-------------------------------------------------------
  if ((millis() - tiempo) > 2000)
  {
    tiempo = millis();
    float humedad = dht.readHumidity();
    float temperatura = dht.readTemperature();
    client.publish("temperatura", String(temperatura).c_str(),true);
    delay(250);
    client.publish("humedad", String(humedad).c_str(),true);
    delay(250);
    Serial.print(temperatura);
    Serial.print(" ");
    Serial.println(humedad);
  }

  //-------------------------------------------------------
}

Bueno, el resultado final va a ser similar al siguiente (mi sensor no anda del todo bien y me tira picos de 66º C, pero por suerte eso no pasa jaja)

Acá les dejo el código fuente del programa del node-red (recuerden modificar las direcciones ip para que se ajusten a su red, aunque si está todo montado de forma local, poniendo localhost debería bastar) para que puedan importarlo a sus servidores (con algunos extra):

https://mega.nz/#!z9pVQY5K!UbAhz9WpzZzg1AXPkpskjLP9lIkeax5fp_dCDyoldTc

ESP8266 + Node-Red + MQTT broker

Bueno, ahora que ya tenemos los conocimientos básicos sobre el MQTT, node-red, el módulo ESP8266 y ya usamos el ESP8266 más un MQTT broker podremos integrar todo para obtener un sistema bastante completo y de cierta complejidad (de forma sencilla).

Primero que nada vamos a iniciar los servicios de node-red y mosca. Una vez que se inicien, vamos a la ip local 127.0.0.1:1880 y ahí deberíamos configurar los siguientes módulos:

1. Text imput: configurado para que aparezca en el default del dashboard y con un Delay (ms) en 0 para que espere a que se presione el enter para mandar.
2. MQTT: configurado con la ip donde se aloja el mqtt broker y con el tópico mensajes.

Y debería quedar como muestra la siguiente imágen:

Y si nos vamos a la dirección 127.0.0.1:1880/ui deberíamos encontrarnos con el dashboard de esta forma.

En donde dice escribir acá podremos ingresar un mensaje que se va a mandar a través del mqtt broker, de esta forma si accedemos a la dirección ip de nuestra pc desde el celular (el navegador) podremos mandar mensajes sin necesidad de ninguna aplicación.

Ahora si vamos a arduino y cargamos el siguiente código (que es el mismo que la última vez) y lo cargamos en nuestra ESP8266 deberíamos poder recibir por el puerto serie el mensaje que mandemos desde la interfaz web:

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

// Las siguientes tres constantes definen, ip del 
//mqtt broker, nombre de red wifi y su contraseña.

const char* mqtt_server = "192.168.1.15";
const char* ssid = "id_red_wifi";
const char* password = "contraseña_red_wifi";

// A continuación declaramos el nombre del cliente 
// que se va a conectar.
WiFiClient espClient;
PubSubClient client(espClient);

// En esta variable se almacena el mensaje recibido
// notar que tiene un máximo de 50 (en realidad son
// 49) caracteres.
char msg[50];

// Iniciamos la comunicación serie, la conexión por
// wifi y definimos en donde se aloja el servidor y
// en qué puerto, y la función donde administramos
// la llegada de mensajes.
void setup() {
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
}

// En esta función se conecta con la red designada,
// mientras esté tratando de conectarse va a mandar
// un punto "." por el puerto serie y cuando lo 
// consiga nos avisará.
void setup_wifi() {

  delay(10);

  Serial.println();
  Serial.print("Conectando a: ");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi conectado");
  Serial.println("Direccion IP: ");
  Serial.println(WiFi.localIP());
}

// En esta función se administra la llegada de 
// mensajes, nos avisa en qué tópico llegó y 
// cuál es el mensaje.
void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Mensaje recibido [");
  Serial.print(topic);
  Serial.print("] ");
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println();
}

// Esta función se encarga de conectar con el 
// mqtt broker, si lo consigue se subscribe a
// los tópicos que definamos (no es necesario
// subscribirnos en esta función, pero si lo
// recomiendo para organizar mejor el código.
// Prueba reconectarse cada cinco segundos si
// no lo consigue.
void reconectar() {

  while (!client.connected()) {
    Serial.print("Intentando conectar con el mqtt broker...");

    if (client.connect("ESP8266Client")) {
      Serial.println("conectado");
      client.subscribe("mensajes");
    } else {
      Serial.print("fallo, rc=");
      Serial.print(client.state());
      Serial.println(" prueba nuevamente en 5 segundos");

      delay(5000);
    }
  }
}

// En el loop principal no hacemos nada más 
// que verificar si perdimos la conexión con
// el servicio mqtt y verificamos que lleguen
// mensajes. El "client.loop();" se encarga 
// de revisar si llegaron mensajes, por lo 
// que habría que invocar esta función regu-
// larmente.
// Esta sección se podría mejorar si ponemos
// que revise si perdió la conexión con la
// red wifi.
void loop() {

  if (!client.connected()) {
    reconectar();
  }
  client.loop();
}

Si agregamos al código algo que "analice" el mensaje entrante podremos hacer algún programa que "reaccione" ante ciertos mensajes en específico.

ESP8266 + servicio mqtt

Bueno, hoy les traigo una comunicación simple entre un ESP8266 y el celular (con la aplicación para android llamada MQTT Client, aunque cambiando un poco las cosas, se podría hacer entre dos ESP8266) y haciendo de intermediario un MQTT broker, más específicamente el broker que vamos a usar es el mosca. El broker se va a encargar de administrar la comunicación entre ambos dispositivos.

Primero que nada debemos descargar y ejecutar el mqtt broker:

Para esto vamos a abrir el git-bash (antes de continuar recomiendo leer los post del mqtt, el del esp8266 y el del node-red) y ejecutar el siguiente comando: "npm install mosca bunyan -g"

Luego de que se instale escribimos en la consola "mosca -v | bunyan" y eso va a iniciar el mqtt broker

Así nos debería quedar cuando lo ejecutamos por primera vez, esto sería el servidor por lo que hay que dejar abierta esta ventana (si la cerramos se detiene el servicio).

Ahora si bajamos la aplicación MQTT Client (presionando en el nombre los lleva a la página de descarga) (esta aplicación está para android, desconozco si se encuentra disponible para otros sistemas opera) y la abrimos nos vamos a encontrar con la siguiente pantalla

Si presionamos en donde aparece la llave (arriba a la derecha) podremos ingresar a las configuraciones para poner la ip local donde se aloja el servidor (al final del post dejo la forma de averiguarlo).

Yo puse la ip de mi pc (192.168.1.15) (esta ip varía dependiendo de como las administre el router, por lo que podría cambiar incluso si apagamos y prendemos el wifi o desconectamos el cable de ethernet o reiniciamos la pc o el router) y el puerto (1883) en el cual se encuentra nuestro mqtt broker (este puerto es por defecto), una vez finalizado esto ponemos "CONNECT" y en la consola nos va a aparecer lo siguiente:

Como aclaración, yo me conecté dos veces, por eso figura dos veces el texto "client connected".
Si ahora vamos a la aplicación a la parte donde dice "add topic" y agregamos uno debería quedarnos de la siguiente forma:

Como podemos ver, inmediatamente figura que nos subscribimos al tópico mensajes (el nombre es indistinto). Ahora vamos a mandar un mensaje al tópico mensajes presionando el ícono de subir (que se encuentra al lado del de configuración).

Y si lo enviamos deberíamos recibir el mensaje dado que estamos subscritos a ese tópico.

Bueno, esta fue la parte del celular, ahora si queremos mandar mensajes desde el esp8266, deberíamos meternos en arduino y hacer un programa que se comunique.

Primero vamos al gestor de librerías de arduino, y buscamos e instalamos la librería "PubSubClient", y cargamos el siguiente código:

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

// Las siguientes tres constantes definen, ip del 
//mqtt broker, nombre de red wifi y su contraseña.

const char* mqtt_server = "192.168.1.15";
const char* ssid = "id_red_wifi";
const char* password = "contraseña_red_wifi";

// A continuación declaramos el nombre del cliente 
// que se va a conectar.
WiFiClient espClient;
PubSubClient client(espClient);

// En esta variable se almacena el mensaje recibido
// notar que tiene un máximo de 50 (en realidad son
// 49) caracteres.
char msg[50];

// Iniciamos la comunicación serie, la conexión por
// wifi y definimos en donde se aloja el servidor y
// en qué puerto, y la función donde administramos
// la llegada de mensajes.
void setup() {
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
}

// En esta función se conecta con la red designada,
// mientras esté tratando de conectarse va a mandar
// un punto "." por el puerto serie y cuando lo 
// consiga nos avisará.
void setup_wifi() {

  delay(10);

  Serial.println();
  Serial.print("Conectando a: ");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi conectado");
  Serial.println("Direccion IP: ");
  Serial.println(WiFi.localIP());
}

// En esta función se administra la llegada de 
// mensajes, nos avisa en qué tópico llegó y 
// cuál es el mensaje.
void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Mensaje recibido [");
  Serial.print(topic);
  Serial.print("] ");
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println();
}

// Esta función se encarga de conectar con el 
// mqtt broker, si lo consigue se subscribe a
// los tópicos que definamos (no es necesario
// subscribirnos en esta función, pero si lo
// recomiendo para organizar mejor el código.
// Prueba reconectarse cada cinco segundos si
// no lo consigue.
void reconectar() {

  while (!client.connected()) {
    Serial.print("Intentando conectar con el mqtt broker...");

    if (client.connect("ESP8266Client")) {
      Serial.println("conectado");
      client.subscribe("mensajes");
    } else {
      Serial.print("fallo, rc=");
      Serial.print(client.state());
      Serial.println(" prueba nuevamente en 5 segundos");

      delay(5000);
    }
  }
}

// En el loop principal no hacemos nada más 
// que verificar si perdimos la conexión con
// el servicio mqtt y verificamos que lleguen
// mensajes. El "client.loop();" se encarga 
// de revisar si llegaron mensajes, por lo 
// que habría que invocar esta función regu-
// larmente.
// Esta sección se podría mejorar si ponemos
// que revise si perdió la conexión con la
// red wifi.
void loop() {

  if (!client.connected()) {
    reconectar();
  }
  client.loop();
}

Este código sólo sirve para recibir mensajes en el tópico de "mensajes". Y como aclaración es un código editado mínimamente del ejemplo que nos da la librería PubSubClient (más específicamente
Ahora paso a explicar qué hace cada función.
Antes que nada se define la ip donde se aloja el mqtt broker, la id (o nombre) de la red wifi y su correspondiente contraseña (estas tres cosas, en este código, son constantes, pero se podría hacer algo más interesante para que sean variables)


Si queremos averiguar cuál es la ip que asignó el router a nuestra computadora simplemente abrimos la consola de comandos de windows y tecleamos "ipconfig" y debería aparecer algo similar a lo siguiente (dentro del recuadro rojo se encuentra la ip de la pc):