Comunicación MQTT ESP32 a ESP32 |

ESP32 MQTT: publicar y suscribirse con Arduino IDE

¡Bienvenidos al emocionante mundo de la IoT con ESP32 y MQTT! En este artículo te enseñaremos cómo publicar y suscribirte a mensajes utilizando Arduino IDE. Aprenderás cómo utilizar estas tecnologías para crear proyectos increíbles que te ayudarán a llevar tus habilidades de programación al siguiente nivel. ¡Sigue leyendo para descubrir más sobre ESP32 MQTT y cómo puedes empezar a desarrollar tus propias aplicaciones conectadas!

Este proyecto muestra cómo utilizar el protocolo de comunicación MQTT con ESP32 para publicar mensajes y suscribirse a temas. Como ejemplo, publicamos los valores del sensor BME280 en el tablero de Node-RED y controlamos una salida ESP32. Programamos el ESP32 con Arduino IDE.

ESP32 MQTT: publicar y suscribirse con Arduino IDE

Descripción del proyecto

En este ejemplo, hay una aplicación Node-RED que controla las salidas de ESP32 y recibe valores de sensores de ESP32 a través del protocolo de comunicación MQTT. La aplicación Node-RED se ejecuta en una Raspberry Pi.

Usamos el broker Mosquitto instalado en la misma Raspberry Pi. El corredor es responsable de recibir todos los mensajes, filtrarlos, decidir quién está interesado en ellos y publicarlos para todos los clientes suscritos.

La siguiente imagen muestra una descripción general de lo que haremos en este tutorial.

ESP32 MQTT: publicar y suscribirse con Arduino IDE
  • La aplicación Node-RED publica noticias (“En» o «fuera de«) en tema esp32/problema. El ESP32 está suscrito a este tema. Entonces recibe el mensaje con “on” o “off” para encender o apagar el LED.
  • El ESP32 da la temperatura en el esp32/temperatura El tema y la humedad en el esp32/humedad Tema. La aplicación Node-RED está suscrita a estos temas. Esto le proporciona valores de temperatura y humedad que se pueden representar, por ejemplo, en un diagrama o en una pantalla.

Nota: También hay un tutorial similar sobre el uso de ESP8266 y Node-RED con MQTT.

requisitos

  • Deberías estar familiarizado con Raspberry Pi; lee Introducción a Raspberry Pi.
  • Debe tener el sistema operativo Raspbian instalado en su Raspberry Pi; lea «Instalar, activar y conectar Raspbian Lite usando SSH».
  • Debe tener Node-RED instalado en su Pi y Node-RED Dashboard.
  • Aprenda qué es MQTT y cómo funciona.

Si te gusta la domótica y quieres aprender más sobre Node-RED, Raspberry Pi, ESP8266 y Arduino, te recomendamos nuestro curso: Crear un sistema domótico con Node-RED, ESP8266 y Arduino. También tenemos un curso específico para ESP32: Regístrate en el curso Aprende ESP32 con Arduino IDE.

Piezas requeridas

Estas son las piezas necesarias para construir el circuito (haga clic en los enlaces a continuación para encontrar el mejor precio en Asesor de creadores):

ESP32 MQTT: publicar y suscribirse con Arduino IDE

Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!

ESP32 MQTT: publicar y suscribirse con Arduino IDE

Introducción del módulo de sensor BME280

El Módulo de sensores BME280 Mide temperatura, humedad y presión. Dado que la presión cambia con la altitud, también se puede estimar la altitud. Sin embargo, en este tutorial sólo mediremos la temperatura y la humedad. Existen varias versiones de este módulo de sensor, pero usaremos la que se muestra en la siguiente figura.

ESP32 MQTT: publicar y suscribirse con Arduino IDE

El sensor puede comunicarse mediante protocolos de comunicación SPI o I2C (hay módulos de este sensor que solo se comunican vía I2C, pero estos solo tienen cuatro pines).

Para utilizar el protocolo de comunicación SPI, utilice los siguientes pines:

  • SCK: este es el pin del reloj SPI
  • SDO-MISO
  • IDE – MOSI
  • CS – Selección de chips

Para utilizar el protocolo de comunicación I2C, el sensor utiliza los siguientes pines:

  • SCK – Bolígrafo SCL
  • Conector SDI-SDA

Esquema

Usaremos comunicación I2C con el módulo de sensor BME280. Para hacer esto, conecte el sensor a los pines ESP32-SDA y SCL como se muestra en el siguiente diagrama de circuito.

También controlamos una salida ESP32, un LED conectado a GPIO 4.

ESP32 MQTT: publicar y suscribirse con Arduino IDE

Así es como debería verse tu circuito:

ESP32 MQTT: publicar y suscribirse con Arduino IDE

Preparando el IDE de Arduino

Existe un complemento para Arduino IDE que le permite programar el ESP32 usando el Arduino IDE y su lenguaje de programación. Siga uno de los siguientes tutoriales para preparar su IDE de Arduino para que funcione con ESP32 si aún no lo ha hecho.

  • ventanas Instrucciones – Placa ESP32 en Arduino IDE
  • mac y linux Instrucciones – Placa ESP32 en Arduino IDE

Después de asegurarte de tener instalado el complemento ESP32, puedes continuar con este tutorial.

Instalación de la biblioteca PubSubClient

El PubSubCliente La biblioteca proporciona un cliente para mensajes simples de publicación/suscripción con un servidor que admite MQTT (básicamente permite que su ESP32 se comunique con Node-RED).

  1. Haga clic aquí para descargar la biblioteca PubSubClientdeberías tener uno .Cremallera Carpeta en su carpeta de Descargas
  2. Descomprime eso .Cremallera carpeta y deberías recibir maestro pubsubcliente Carpeta
  3. Cambie el nombre de su carpeta de maestro pubsubcliente A pubsubcliente
  4. mueve eso pubsubcliente Carpeta a la carpeta de bibliotecas de instalación de Arduino IDE
  5. Luego vuelve a abrir tu IDE de Arduino

La biblioteca contiene varios bocetos de ejemplo. Consulte archivo >Ejemplos > PubSubCliente dentro del software Arduino IDE.

Importante: PubSubClient no es totalmente compatible con ESP32, pero el ejemplo proporcionado en este tutorial funciona de manera muy confiable durante nuestras pruebas.

Instalación de la biblioteca BME280

Para medir la lectura del módulo sensor BME280, utilizamos el Biblioteca Adafruit_BME280Siga los siguientes pasos para instalar la biblioteca en su IDE de Arduino:

  1. Haga click aquí para descargar la biblioteca Adafruit BME280. Deberías tener una carpeta .zip en tu carpeta de Descargas.
  2. Descomprima la carpeta .zip y debería obtener Biblioteca maestra Adafruit BME280 Carpeta
  3. Cambie el nombre de su carpeta de Biblioteca maestra Adafruit BME280 A Adafruit_BME280_Library
  4. mueve eso Adafruit_BMPE280_Library Carpeta a la carpeta de bibliotecas de instalación de Arduino IDE
  5. Finalmente, vuelva a abrir su IDE de Arduino

Alternativamente puedes Bosquejo > incluir biblioteca > Administrar bibliotecas y escribe “Adafruit BME280”para buscar la biblioteca. Luego haga clic en Instalar.

Instalación de la biblioteca Adafruit_Sensor

Para utilizar la biblioteca BME280, también debe tener la Biblioteca Adafruit_SensorSiga los siguientes pasos para instalar la biblioteca:

  1. Haga click aquí para descargar la biblioteca Adafruit_Sensor. Deberías tener una carpeta .zip en tu carpeta de Descargas.
  2. Descomprima la carpeta .zip y debería obtener Maestro Adafruit_Sensor Carpeta
  3. Cambie el nombre de su carpeta de Maestro Adafruit_Sensor A Adafruit_Sensor
  4. mueve eso Adafruit_Sensor Carpeta a la carpeta de bibliotecas de instalación de Arduino IDE
  5. Finalmente, vuelva a abrir su IDE de Arduino

Subir código

Ahora puedes cargar el siguiente código en tu ESP32. El código contiene comentarios donde es necesario realizar cambios. Deberá editar el código con su propio SSID, contraseña y dirección IP de Raspberry Pi.

/*********
  Rui Santos
  Complete project details at https://randomnerdtutorials.com  
*********/

#include <WiFi.h>
#include <PubSubClient.h>
#include <Wire.h>
#include <Adafruit_BME280.h>
#include <Adafruit_Sensor.h>

// Replace the next variables with your SSID/Password combination
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

// Add your MQTT Broker IP address, example:
//const char* mqtt_server = "192.168.1.144";
const char* mqtt_server = "YOUR_MQTT_BROKER_IP_ADDRESS";

WiFiClient espClient;
PubSubClient client(espClient);
long lastMsg = 0;
char msg[50];
int value = 0;

//uncomment the following lines if you're using SPI
/*#include <SPI.h>
#define BME_SCK 18
#define BME_MISO 19
#define BME_MOSI 23
#define BME_CS 5*/

Adafruit_BME280 bme; // I2C
//Adafruit_BME280 bme(BME_CS); // hardware SPI
//Adafruit_BME280 bme(BME_CS, BME_MOSI, BME_MISO, BME_SCK); // software SPI
float temperature = 0;
float humidity = 0;

// LED Pin
const int ledPin = 4;

void setup() {
  Serial.begin(115200);
  // default settings
  // (you can also pass in a Wire library object like &Wire2)
  //status = bme.begin();  
  if (!bme.begin(0x76)) {
    Serial.println("Could not find a valid BME280 sensor, check wiring!");
    while (1);
  }
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);

  pinMode(ledPin, OUTPUT);
}

void setup_wifi() {
  delay(10);
  // We start by connecting to a WiFi network
  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 callback(char* topic, byte* message, unsigned int length) {
  Serial.print("Message arrived on topic: ");
  Serial.print(topic);
  Serial.print(". Message: ");
  String messageTemp;
  
  for (int i = 0; i < length; i++) {
    Serial.print((char)message[i]);
    messageTemp += (char)message[i];
  }
  Serial.println();

  // Feel free to add more if statements to control more GPIOs with MQTT

  // If a message is received on the topic esp32/output, you check if the message is either "on" or "off". 
  // Changes the output state according to the message
  if (String(topic) == "esp32/output") {
    Serial.print("Changing output to ");
    if(messageTemp == "on"){
      Serial.println("on");
      digitalWrite(ledPin, HIGH);
    }
    else if(messageTemp == "off"){
      Serial.println("off");
      digitalWrite(ledPin, LOW);
    }
  }
}

void reconnect() {
  // Loop until we're reconnected
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    // Attempt to connect
    if (client.connect("ESP8266Client")) {
      Serial.println("connected");
      // Subscribe
      client.subscribe("esp32/output");
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      // Wait 5 seconds before retrying
      delay(5000);
    }
  }
}
void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();

  long now = millis();
  if (now - lastMsg > 5000) {
    lastMsg = now;
    
    // Temperature in Celsius
    temperature = bme.readTemperature();   
    // Uncomment the next line to set temperature in Fahrenheit 
    // (and comment the previous temperature line)
    //temperature = 1.8 * bme.readTemperature() + 32; // Temperature in Fahrenheit
    
    // Convert the value to a char array
    char tempString[8];
    dtostrf(temperature, 1, 2, tempString);
    Serial.print("Temperature: ");
    Serial.println(tempString);
    client.publish("esp32/temperature", tempString);

    humidity = bme.readHumidity();
    
    // Convert the value to a char array
    char humString[8];
    dtostrf(humidity, 1, 2, humString);
    Serial.print("Humidity: ");
    Serial.println(humString);
    client.publish("esp32/humidity", humString);
  }
}

Ver código sin formato

Este código publica los valores de temperatura y humedad en el esp32/temperatura Y esp32/humedad Temas sobre el protocolo MQTT.

El ESP32 está suscrito al esp32/problema Tema para recibir los mensajes publicados por la aplicación Node-RED sobre este tema. El LED se encenderá o apagará según el mensaje recibido.

Suscríbete a temas MQTT

En el conectarse de nuevo() Esta función le permite suscribirse a temas MQTT. En este caso el ESP32 solo se suscribe al esp32/problema:

client.subscribe("esp32/output");

En el Llamar de vuelta() función, el ESP32 recibe los mensajes MQTT de los temas suscritos. Dependiendo del tema y mensaje MQTT, enciende o apaga el LED:

// If a message is received on the topic esp32/output, you check if the message is either "on" or "off". 
// Changes the output state according to the message
if (String(topic) == "esp32/output") {
  Serial.print("Changing output to ");
  if (messageTemp == "on") {
    Serial.println("on");
    digitalWrite(ledPin, HIGH);
  }
  else if (messageTemp == "off") {
    Serial.println("off");
    digitalWrite(ledPin, LOW);
  }
}

Publicar mensajes MQTT

En el Cinta(), Cada 5 segundos se publican nuevas mediciones:

if (now - lastMsg > 5000) { ... }

De forma predeterminada, el ESP32 envía la temperatura en grados Celsius, pero puedes comentar la última línea para enviar la temperatura en Fahrenheit:

// Temperature in Celsius
temperature = bme.readTemperature(); 
// Uncomment the next line to set temperature in Fahrenheit 
// (and comment the previous temperature line)
//temperature = 1.8 * bme.readTemperature() + 32; // Temperature in Fahrenheit

Debe convertir la variable flotante de temperatura en una matriz de caracteres para poder mostrar los valores de temperatura en el esp32/temperatura Tema:

// Convert the value to a char array
char tempString[8];
dtostrf(temperature, 1, 2, tempString);
Serial.print("Temperature: ");
Serial.println(tempString);
client.publish("esp32/temperature", tempString);

Se repite el mismo proceso para determinar el valor de humedad en el esp32/humedad Tema:

humidity = bme.readHumidity();
// Convert the value to a char array
char humString[8];
dtostrf(humidity, 1, 2, humString);
Serial.print("Humidity: ");
Serial.println(humString);
client.publish("esp32/humidity", humString);

Creando el flujo Node-RED

Antes de crear el flujo, debes tener instalado lo siguiente en tu Raspberry Pi:

  • Nudo-ROJO
  • Panel de control del nodo RED
  • corredor de mosquitos

Luego importe el flujo Node-RED implementado. Ir a repositorio de GitHub o haga clic en la imagen a continuación para ver el archivo sin formato y copiar el código proporcionado.

ESP32 MQTT: publicar y suscribirse con Arduino IDE

A continuación, en la ventana Node-RED, seleccione el menú en la parte superior derecha y vaya a Importar > Portapapeles.

ESP32 MQTT: publicar y suscribirse con Arduino IDE

Luego pegue el código proporcionado y haga clic Importar.

ESP32 MQTT: publicar y suscribirse con Arduino IDE

Se deben cargar los siguientes nodos:

ESP32 MQTT: publicar y suscribirse con Arduino IDE

Después de realizar cambios, haga clic en el Insertar Botón para guardar todos los cambios.

ESP32 MQTT: publicar y suscribirse con Arduino IDE

Interfaz de usuario Nodo-RED

Ahora su aplicación Node-RED está lista. Para acceder a la interfaz de Node-RED y ver cómo se ve su aplicación, abra cualquier navegador en su red local y escriba:

http://Your_RPi_IP_address:1880/ui

Su aplicación debería verse como la siguiente imagen. Puedes encender y apagar el LED con el interruptor o mostrar los valores de temperatura en un gráfico y los valores de humedad en un medidor.

ESP32 MQTT: publicar y suscribirse con Arduino IDE

demostración

Mire el siguiente vídeo para una demostración en vivo:

Abra el monitor serie Arduino IDE para ver los mensajes MQTT recibidos y publicados.

ESP32 MQTT: publicar y suscribirse con Arduino IDE

Envolver

En resumen, te hemos mostrado los conceptos básicos que te permitirán encender luces y monitorear sensores con tu ESP32 usando Node-RED y el protocolo de comunicación MQTT. Puede utilizar este ejemplo para integrarlo en su propio sistema domótico, controlar salidas adicionales o monitorear otros sensores.

Usted también puede estar interesado en:

  • Curso Aprende ESP32 con Arduino IDE
  • Alexa (Echo) con ESP32 y ESP8266 – Relé controlado por voz
  • Construya un escudo de estación meteorológica ESP32 todo en uno
  • ESP32 publica valores de sensores en Google Sheets
  • ESP32 con servidor web de temperatura y humedad DHT11 DHT22
  • Servidor web ESP32 con Arduino IDE

Esperamos que este tutorial te haya resultado útil.

Gracias por leer.

Error 403 The request cannot be completed because you have exceeded your quota. : quotaExceeded

ESP32 MQTT: publicar y suscribirse con Arduino IDE

Descripción del Proyecto

Este proyecto muestra cómo usar el protocolo de comunicación MQTT con el ESP32 para publicar mensajes y suscribirse a temas. Como ejemplo, publicaremos lecturas del sensor BME280 en el Dashboard de Node-RED y controlaremos una salida del ESP32. El ESP32 será programado usando Arduino IDE.

Descripción del Proyecto

En este ejemplo, hay una aplicación Node-RED que controla las salidas del ESP32 y recibe lecturas de sensores del ESP32 utilizando el protocolo de comunicación MQTT. La aplicación Node-RED se ejecuta en una Raspberry Pi.

Usaremos el broker Mosquitto instalado en la misma Raspberry Pi. El broker es responsable de recibir todos los mensajes, filtrar los mensajes, decidir quién está interesado en ellos y publicar los mensajes a todos los clientes suscritos.

La siguiente figura muestra una descripción general de lo que vamos a hacer en este tutorial.

La aplicación Node-RED publica mensajes ("on" o "off") en el tema esp32/output. El ESP32 está suscrito a ese tema. Por lo tanto, recibe el mensaje con "on" o "off" para encender o apagar el LED. El ESP32 publica la temperatura en el tema esp32/temperatura y la humedad en el tema esp32/humedad. La aplicación Node-RED está suscrita a esos temas. Por lo tanto, recibe lecturas de temperatura y humedad que se pueden mostrar en un gráfico o un medidor, por ejemplo.

Nota: también hay un tutorial similar sobre cómo usar el ESP8266 y Node-RED con MQTT.

Requisitos

  • Debes estar familiarizado con la Raspberry Pi – leer Introducción a Raspberry Pi.
  • Debes tener instalado el sistema operativo Raspbian en tu Raspberry Pi – leer Instalación de Raspbian Lite, Habilitación y Conexión con SSH.
  • Debes tener Node-RED instalado en tu Pi y Node-RED Dashboard.
  • Aprende qué es MQTT y cómo funciona.

Si te gusta la domótica y deseas aprender más sobre Node-RED, Raspberry Pi, ESP8266 y Arduino, te recomendamos probar nuestro curso: Construye un Sistema de Automatización del Hogar con Node-RED, ESP8266 y Arduino. También tenemos un curso dedicado al ESP32: Inscríbete en el curso de Aprende ESP32 con Arduino IDE.

Partes Necesarias

Estas son las partes necesarias para construir el circuito:

  • Raspberry Pi.
  • Placa ESP32 DOIT DEVKIT V1 – lee Revisión y Comparación de Placas de Desarrollo ESP32.
  • Módulo de sensor BME280.
  • 1 LED de 5 mm.
  • 1 resistor de 220 ohmios.
  • Protoboard.
  • Cables de puente.

Puedes utilizar los enlaces anteriores o ir directamente a MakerAdvisor.com/tools para encontrar todas las partes para tus proyectos al mejor precio.

Módulo Sensor BME280

El módulo del sensor BME280 lee temperatura, humedad y presión. Debido a que la presión cambia con la altitud, también puedes estimar la altitud. Sin embargo, en este tutorial solo leeremos la temperatura y la humedad. Hay varias versiones de este módulo de sensor, pero estamos usando el que se muestra en la imagen.

El sensor puede comunicarse utilizando los protocolos de comunicación SPI o I2C (hay módulos de este sensor que solo se comunican con I2C, estos vienen con solo cuatro pines).

Para usar el protocolo de comunicación SPI, usa los siguientes pines:

  • SCK – este es el pin de Clock de SPI.
  • SDO – MISO.
  • SDI – MOSI.
  • CS – Chip Select

Para usar el protocolo de comunicación I2C, el sensor utiliza los siguientes pines:

  • SCK – pin de SCL.
  • SDI – pin de SDA

Esquemático

Vamos a usar la comunicación I2C con el módulo del sensor BME280. Para ello, conecta el sensor a los pines SDA y SCL del ESP32, como se muestra en el siguiente diagrama esquemático. También controlaremos una salida del ESP32, un LED conectado al GPIO 4.

¡Aquí tienes cómo debería verse tu circuito!

Preparando el Arduino IDE

Hay un complemento para el Arduino IDE que te permite programar el ESP32 utilizando el Arduino IDE y su lenguaje de programación. Sigue uno de los siguientes tutoriales para preparar tu Arduino IDE para trabajar con el ESP32, si aún no lo has hecho:

  • Instrucciones para Windows – Placa ESP32 en Arduino IDE
  • Instrucciones para Mac y Linux – Placa ESP32 en Arduino IDE

Después de asegurarte de tener instalado el complemento ESP32, puedes continuar con este tutorial.

Instalando la Biblioteca PubSubClient

La biblioteca PubSubClient proporciona un cliente para realizar mensajes simples de publicación/suscripción con un servidor que admite MQTT (básicamente permite que tu ESP32 hable con Node-RED).

Haz clic aquí para descargar la biblioteca PubSubClient. Deberías tener una carpeta .zip en tu carpeta de Descargas.

Descomprime la carpeta .zip y deberías obtener la carpeta pubsubclient-master.

Renombra tu carpeta de pubsubclient-master a pubsubclient.

Mueve la carpeta pubsubclient a la carpeta de bibliotecas de instalación de tu Arduino IDE.

Luego, vuelve a abrir tu Arduino IDE.

La biblioteca viene con varios ejemplos. Ve a Archivo > Ejemplos > PubSubClient dentro del software Arduino IDE.

Importante: PubSubClient no es completamente compatible con el ESP32, pero el ejemplo proporcionado en este tutorial funciona de manera muy confiable durante nuestras pruebas.

Instalación de la Biblioteca BME280

Para tomar lecturas del módulo del sensor BME280, utilizaremos la biblioteca Adafruit_BME280. Sigue los siguientes pasos para instalar la biblioteca en tu Arduino IDE:

Haz clic aquí para descargar la biblioteca Adafruit-BME280. Deberías tener una carpeta .zip en tu carpeta de Descargas.

Descomprime la carpeta .zip y deberías obtener la carpeta Adafruit-BME280-Library-master.

Renombra tu carpeta de Adafruit-BME280-Library-master a Adafruit_BME280_Library.

Mueve la carpeta Adafruit_BMPE280_Library a la carpeta de bibliotecas de instalación de tu Arduino IDE.

Finalmente, vuelve a abrir tu Arduino IDE.

Alternativamente, puedes ir a Sketch > Incluir Biblioteca > Administrar Bibliotecas y buscar "adafruit bme280" para buscar la biblioteca. Luego, haz clic en instalar.

Instalación de la Biblioteca Adafruit_Sensor

Para usar la biblioteca BME280, también necesitas instalar la biblioteca Adafruit_Sensor. Sigue los siguientes pasos para instalar la biblioteca:

Haz clic aquí para descargar la biblioteca Adafruit_Sensor. Deberías tener una carpeta .zip en tu carpeta de Descargas.

Descomprime la carpeta .zip y deberías obtener la carpeta Adafruit_Sensor-master.

Renombra tu carpeta de Adafruit_Sensor-master a Adafruit_Sensor.

Mueve la carpeta Adafruit_Sensor a la carpeta de bibliotecas de instalación de tu Arduino IDE.

Finalmente, vuelve a abrir tu Arduino IDE.

Subir el Código

Ahora, puedes subir el siguiente código a tu ESP32. El código está comentado en donde necesitas hacer cambios. Debes editar el código con tu propio SSID, contraseña y dirección IP de la Raspberry Pi.

/******
  Rui Santos
  Detalles completos del proyecto en https://randomnerdtutorials.com  
******/

#include <WiFi.h>
#include <PubSubClient.h>
#include <Wire.h>
#include <Adafruit_BME280.h>
#include <Adafruit_Sensor.h>

// Reemplaza las siguientes variables con tu combinación de SSID/Contraseña
const char* ssid = "REEMPLAZAR_CON_TU_SSID";
const char* password = "REEMPLAZAR_CON_TU_CONTRASEÑA";

// Agrega la dirección IP de tu Broker MQTT, ejemplo:
//const char* mqtt_server = "192.168.1.144";
const char* mqtt_server = "LA_DIRECCIÓN_IP_DE_TU_BROKER_MQTT";

WiFiClient espClient;
PubSubClient client(espClient);
long lastMsg = 0;
char msg[50];
int value = 0;

//descomenta las siguientes líneas si estás usando SPI
/*#include <SPI.h>
#define BME_SCK 18
#define BME_MISO 19
#define BME_MOSI 23
#define BME_CS 5*/

Adafruit_BME280 bme; // I2C
//Adafruit_BME280 bme(BME_CS); // hardware SPI
//Adafruit_BME280 bme(BME_CS, BME_MOSI, BME_MISO, BME_SCK); // software SPI
float temperature = 0;
float humidity = 0;

// Pin del LED
const int ledPin = 4;

void setup() {
  Serial.begin(115200);
  // configuraciones por defecto
  // (también puedes pasar un objeto de biblioteca Wire1)
  //status = bme.begin();  
  if (!bme.begin(0x76)) {
    Serial.println("¡No se pudo encontrar un sensor BME280 válido, revisa la conexión!");
    while (1);
  }
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);

  pinMode(ledPin, OUTPUT);
}

void setup_wifi() {
  delay(10);
  // Comenzamos conectándonos a una red WiFi
  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("Dirección IP: ");
  Serial.println(WiFi.localIP());
}

void callback(char* topic, byte* message, unsigned int length) {
  Serial.print("Mensaje recibido en el tema: ");
  Serial.print(topic);
  Serial.print(". Mensaje: ");
  String messageTemp;

  for (int i = 0; i < length; i++) {
    Serial.print((char)message[i]);
    messageTemp += (char)message[i];
  }
  Serial.println();

  // Si se recibe un mensaje en el tema esp32/output, compruebas si el mensaje es "on" o "off". 
  // Cambia el estado de la salida según el mensaje
  if (String(topic) == "esp32/output") {
    Serial.print("Cambiando salida a ");
    if(messageTemp == "on"){
      Serial.println("encendido");
      digitalWrite(ledPin, HIGH);
    }
    else if(messageTemp == "off"){
      Serial.println("apagado");
      digitalWrite(ledPin, LOW);
    }
  }
}

void reconnect() {
  // Vuelve a intentar la conexión hasta que estemos conectados
  while (!client.connected()) {
    Serial.print("Intentando conexión MQTT...");
    // Intenta conectar
    if (client.connect("ESP8266Client")) {
      Serial.println("conectado");
      // Suscribirse
      client.subscribe("esp32/output");
    } else {
      Serial.print("falló, rc=");
      Serial.print(client.state());
      Serial.println(" intentar de nuevo en 5 segundos");
      // Esperar 5 segundos antes de volver a intentar
      delay(5000);
    }
  }
}
void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();

  long now = millis();
  if (now - lastMsg > 5000) {
    lastMsg = now;

    // Temperatura en Celsius
    temperature = bme.readTemperature();   
    // Descomenta la siguiente línea para establecer la temperatura en Fahrenheit 
    // (y comenta la línea de temperatura anterior)
    //temperature = 1.8 * bme.readTemperature() + 32; // Temperatura en Fahrenheit

    // Convertir el valor a un array de caracteres
    char tempString[8];
    dtostrf(temperature, 1, 2, tempString);
    Serial.print("Temperatura: ");
    Serial.println(tempString);
    client.publish("esp32/temperature", tempString);

    humidity = bme.readHumidity();

    // Convertir el valor a un array de caracteres
    char humString[8];
    dtostrf(humidity, 1, 2, humString);
    Serial.print("Humedad: ");
    Serial.println(humString);
    client.publish("esp32/humidity", humString);
  }
}

Este código publica lecturas de temperatura y humedad en los temas esp32/temperatura y esp32/humedad a través del protocolo MQTT.

El ESP32 está suscrito al tema esp32/output para recibir los mensajes publicados en ese tema por la aplicación Node-RED. Luego, de acuerdo con el mensaje recibido, enciende o apaga el LED.

Suscribirse a Temas MQTT

En la función reconnect(), puedes suscribirte a temas MQTT. En este caso, el ESP32 solo está suscrito a esp32/output:

client.subscribe("esp32/output");

En la función callback(), el ESP32 recibe los mensajes MQTT de los temas suscritos. De acuerdo con el tema MQTT y el mensaje, enciende o apaga el LED:

// Si se recibe un mensaje en el tema esp32/output, compruebas si el mensaje es "on" o "off". 
// Cambia el estado de la salida según el mensaje
if (String(topic) == "esp32/output") {
  Serial.print("Cambiando salida a ");
  if (messageTemp == "on") {
    Serial.println("encendido");
    digitalWrite(ledPin, HIGH);
  }
  else if (messageTemp == "off") {
    Serial.println("apagado");
    digitalWrite(ledPin, LOW);
  }
}

Publicar Mensajes MQTT

En el loop(), se publican nuevas lecturas cada 5 segundos:

if (now - lastMsg > 5000) {...}

Por defecto, el ESP32 envía la temperatura en Celsius, pero puedes descomentar la última línea para enviar la temperatura en Fahrenheit:

// Temperatura en Celsius
temperature = bme.readTemperature(); 
// Descomenta la siguiente línea para establecer la temperatura en Fahrenheit 
// (y comenta la línea de temperatura anterior)
//temperature = 1.8 * bme.readTemperature() + 32; // Temperatura en Fahrenheit

Debes convertir la variable flotante de temperatura en un array de caracteres, para que puedas publicar la lectura de temperatura en el tema esp32/temperatura:

// Convertir el valor a un array de caracteres
char tempString[8];
dtostrf(temperature, 1, 2, tempString);
Serial.print("Temperatura: ");
Serial.println(tempString);
client.publish("esp32/temperature", tempString);

El mismo proceso se repite para publicar la lectura de humedad en el tema esp32/humedad:

humidity = bme.readHumidity();
// Convertir el valor a un array de caracteres
char humString[8];
dtostrf(humidity, 1, 2, humString);
Serial.print("Humedad: ");
Serial.println(humString);
client.publish("esp32/humidity", humString);

Creación del Flujo de Node-RED

Antes de crear el flujo, debes haber instalado en tu Raspberry Pi:

  • Node-RED
  • Node-RED Dashboard
  • Broker Mosquitto

Después de eso, importa el flujo de Node-RED proporcionado. Ve al repositorio de GitHub o haz clic en la figura a continuación para ver el archivo en bruto, y copia el código proporcionado.

A continuación, en la ventana de Node-RED, en la esquina superior derecha, selecciona el menú, y ve a Importar > Portapapeles.

Luego, pega el código proporcionado y haz clic en Importar.

Deberían cargar los siguientes nodos:

Después de hacer cualquier cambio, haz clic en el botón Desplegar para guardar todos los cambios.

Interfaz de Usuario de Node-RED

Ahora, tu aplicación de Node-RED está lista. Para acceder a la interfaz de usuario de Node-RED y ver cómo se ve tu aplicación, accede a cualquier navegador en tu red local y escribe:

http://Dirección_IP_de_tu_RPi:1880/ui

Tu aplicación debería verse como se muestra en la siguiente figura. Puedes controlar el LED encendido y apagado con el interruptor o ver lecturas de temperatura en un gráfico y los valores de humedad en un medidor.

Demostración

Mira el siguiente video para una demostración en vivo:

Abre el monitor serial del Arduino IDE para ver los mensajes MQTT recibidos y publicados.

Conclusión

En resumen, te hemos mostrado los conceptos básicos que te permiten encender luces y monitorear sensores con tu ESP32 utilizando Node-RED y el protocolo de comunicación MQTT. Puedes utilizar este ejemplo para integrarlo en tu propio sistema de domótica, controlar más salidas o monitorear otros sensores.

Esperamos que hayas encontrado útil este tutorial.

Gracias por leer.

Related Posts:

5 comentarios en «ESP32 MQTT: publicar y suscribirse con Arduino IDE»

Deja un comentario