Conexión de clientes MQTT a través de ESP32

Texto copiado
Introducción

Esta guía ofrece un tutorial completo sobre la conexión de un cliente MQTT ESP32 dispositivo a nuestroMQTT brokero cualquier agente de su elección. Cubre tareas esenciales, como el establecimiento conexiones, subscribiendo a temas, sin suscribir, e intercambiar mensajes. Al seguir estos pasos, usted puede efectivamente integraciónMQTTcomunicación en sus proyectos de IoT.

Prerrequisitos

Antes de comenzar, asegúrese de que tiene:

  • Una junta de desarrollo ESP32 con Arduino IDE
  • Acceso a cualquier instancia de corretaje MQTT (dirección IP o nombre de dominio)
  • credenciales de conexión WiFi para el ESP32

Instalación de dependencia

Instalar el IDE Arduino

Descargue e instale el Arduino IDE del sitio web oficial de Arduino.

Instalar el paquete ESP32 Board

  • Abrir el IDE Arduino
  • Ir al archivo Preferencias
  • En el campo URLs Administrador de Juntas adicionales, agregue la siguiente URL

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json

Si ya hay URLs en este campo, puedes separarlas con comas.

  • Haga clic en Aceptar para guardar las preferencias
  • Ir a Herramientas Consejo de Administración Boards Manager
  • In the Boards Manager, search for ESP32 and install the esp32 package by Espressif Sistemas

Seleccione la Junta ESP32

  • Ir a Herramientas - Junta
  • Desplazar hacia abajo y seleccionar la tabla ESP32 específica (por ejemplo, el módulo ESP32 Dev)

Instalar las bibliotecas necesarias

  • Ve a Sketch Incluir la Biblioteca Gestionar bibliotecas
  • En el Administrador de Bibliotecas, busque las siguientes bibliotecas e instálelas como necesario
    • WiFi (para conectividad WiFi)
    • ESPAsyncWebServer (para crear servidores web)
    • PubSubClient (para comunicación MQTT)
    • Sensor Adafruit (si utiliza controlador Adafruit)
    • Biblioteca de sensores DHT (para sensores DHT)
    • ArduinoJson (para JSON analizando y serializando)

Simplemente haga clic en la biblioteca deseada y luego haga clic en Botón.

Verificar la instalación

  • Abra un boceto de ejemplo para verificar la instalación.
  • Ir al archivo Ejemplos y busque ejemplos en ESP32 o en las bibliotecas instaladas.
  • Seleccione un ejemplo de boceto, compilar y subirlo a su tabla ESP32 para asegurarse todo está listo correctamente.

Definir Constantes

Reemplaza tu_wifi_ssid, tu_wifi_password, mqt_servidor, y mqtt_port con tu real Wi-Fi y detalles del corredor MQTT.

/ WiFi
const char *ssid = "xxxxx"; // Introduzca su ssid WiFi
const char *password = "xxxxx"; // Enter WiFi password
/ MQTT Broker
const char *mqtt_server = "public-mqtt-broker.bevywise.com";
const int mqt_port = 1883;
const char *mqt_username = "nombre de usuario"; (opcional)
const char *mqt_password = "pwd"; (opcional)

Conexión con MQTT Broker

Esta sección tiene fragmentos de código de varias maneras de conectarse a MQTT Broker. Garantizar que el MQTT Broker soporta el tipo de conexión que le gustaría utilizar. Además, obtener los parámetros de conexión correspondientes del MQTT Broker (Address, Port, Nombre de usuario/Password, certificado CA)

MQTT Over TCP

Utilice el siguiente código para conectar al cliente sobre TCP. Define el Macro ADDRESS utilizando los parámetros de conexión de MQTT Broker.

Para MQTT 3.1.1 :

WiFi.begin(ssid, password);
(WiFi.status() != WL_CONNECTED)
{}
retraso(500);
Serial.println("Connecting to WiFi..");
}
const char *client_id = “esp_client”;
client.setServer(mqt_server,mqtt_port);

Para MQTT 5 :

AsyncMqtClient mqtClient;
conexión de vacío ToWifi() {
Serial.println("Connecting to WiFi...");
WiFi.begin(ssid, password);
(WiFi.status() != WL_CONNECTED) {
retraso(500);
Serial.print(");
}
Serial.println("WiFi conectado");
}
vacio enMqtConnect(bool sessionPresent) {
Serial.println("Connected to MQTT.");
// Puede suscribirse a temas aquí
// mqttClient.subscribe("test/topic", 1);
}
configuración de vacío() {}
Serial.begin(115200);
connectToWifi();
mqttClient.onConnect(onMqtConnect);
mqttClient.setServer(mqt_server, mqtt_port);
mqttClient.setClientId(client_id);
// Establecer la versión de protocolo de MQTT 5.0
mqttClient.setProtocolVersion(5);
mqttClient.connect();
}

MQTT sobre TLS / SSL

Utilice el siguiente código para conectarse de forma segura a MQTT Broker sobre TLS. Define el Macro ADDRESS utilizando los parámetros de conexión de MQTT Broker.

#include ■WiFiClientSecure.h
// Certificado CA de arranque para el corredor MQTT
const char* root_ca = \
"------BEGIN CERTIFICATE------\n" \
"YOUR_ROOT_CA_CERTIFICATE\n"
"-----END CERTIFICATE-----\n";
/ Init wifi cliente seguro
WiFiClientSecure espClient;
PubSubClient client(espClient);
espClient.setCACert(root_ca);
espClient.setCertificate(server_cert); //for client verification
espClient.setPrivateKey(server_key); // para la verificación del cliente

Establecer parámetros TLS antes de llamar al MQTTClient_connect para conectar al cliente el MQTT Broker seguro sobre TLS.

Si el MQTT Broker es hospedado en un servidor de confianza y la verificación del servidor no es requerido, el siguiente código se puede utilizar para configurar Opciones TLS:

// MQTT Configuración de carpetas
const char* mqt_server = "your_mqtt_server";
const uint16_t mqt_port = 8883; // Típicamente, el puerto 8883 se utiliza para MQTT sobre TLS
const char* client_id = generateClientId(crystal_, length);
// Iniciación de clientes de WiFi y MQTT
WiFiClientSecure espClient;
PubSubClient mqtClient(espClient);
conexión de vacío ToWifi() {
Serial.println("Connecting to WiFi...");
WiFi.begin(ssid, password);
(WiFi.status() != WL_CONNECTED) {
retraso(500);
Serial.print(");
}
Serial.println("WiFi conectado"); }
conexión de vacíoToMqt() {
// Verificación de certificado de servidor deshabilitado
espClient.setInsecure();
mqttClient.setServer(mqt_server, mqtt_port);
mqttClient.setCallback(mqttCallback);
mientras (!mqtClient.connected())) {}
Serial.print("Connecting to MQTT... ");
si (mqttClient.connect(client_id)) {}
Serial.println("conectado");
// Suscribirse a temas o publicar mensajes aquí
// mqttClient.subscribe("su/topic");
. ♫ ... {
Serial.print("failed with state ");
Serial.print(mqtClient.state());
retraso(2000);
}
}
}
configuración de vacío() {}
Serial.begin(115200);
connectToWifi();
connectToMqtt();
}
vacío loop() {}
// Asegurar que el cliente MQTT se mantenga conectado
si (!mqtClient.connected())) {}
connectToMqtt();
}
mqttClient.loop();
}

Si el MQTT Broker tiene el certificado de servidor emitido por un CA con confianza, entonces el servidor El certificado puede verificarse utilizando:

/ Certificado CA de raíz para el corredor MQTT
const char* root_ca = \
"------BEGIN CERTIFICATE------\n" \
"YOUR_ROOT_CA_CERTIFICATE\n"
"-----END CERTIFICATE-----\n";
// Iniciación de clientes de WiFi y MQTT
WiFiClientSecure espClient;
PubSubClient mqtClient(espClient);
conexión de vacío ToWifi() {
Serial.println("Connecting to WiFi...");
WiFi.begin(ssid, password);
(WiFi.status() != WL_CONNECTED) {
retraso(500);
Serial.print(");
}
Serial.println("WiFi conectado");
}
conexión de vacíoToMqt() {
// Establecer el certificado de root CA
espClient.setCACert(root_ca);
mqttClient.setServer(mqt_server, mqtt_port);
mqttClient.setCallback(mqttCallback);
mientras (!mqtClient.connected())) {}
Serial.print("Connecting to MQTT... ");
si (mqttClient.connect(client_id)) {}
Serial.println("conectado");
// Suscribirse a temas o publicar mensajes aquí
// mqttClient.subscribe("su/topic");
. ♫ ... {
Serial.print("failed with state ");
Serial.print(mqtClient.state());
retraso(2000);
}
}
}
configuración de vacío() {}
Serial.begin(115200);
connectToWifi();
connectToMqtt();
}
vacío loop() {}
// Asegurar que el cliente MQTT se mantenga conectado
si (!mqtClient.connected())) {}
connectToMqtt();
}
mqttClient.loop();
}

Si el MQTT Broker tiene un certificado de servidor auto-firmado entonces el Certificado de Servidor se puede verificar utilizando el Certificado de Root obtenido a el MQTT Broker:

// Certificado de raíz autofirmado para el corredor de MQTT
const char* root_ca = \
"------BEGIN CERTIFICATE------\n" \
"YOUR_SELF_SIGNED_ROOT_CERTIFICATE\n"
"-----END CERTIFICATE-----\n";
// Iniciación de clientes de WiFi y MQTT
WiFiClientSecure espClient;
PubSubClient mqtClient(espClient);
conexión de vacío ToWifi() {
Serial.println("Connecting to WiFi...");
WiFi.begin(ssid, password);
(WiFi.status() != WL_CONNECTED) {
retraso(500);
Serial.print(");
}
Serial.println("WiFi conectado");
}
conexión de vacíoToMqt() {
// Establecer el certificado CA de raíz auto-firmado
espClient.setCACert(root_ca);
mqttClient.setServer(mqt_server, mqtt_port);
mqttClient.setCallback(mqttCallback);
mientras (!mqtClient.connected())) {}
Serial.print("Connecting to MQTT... ");
si (mqttClient.connect(client_id)) {}
Serial.println("conectado");
// Suscribirse a temas o publicar mensajes aquí
// mqttClient.subscribe("su/topic");
. ♫ ... {
Serial.print("failed with state ");
Serial.print(mqtClient.state());
retraso(2000);
}
}
}
configuración de vacío() {}
Serial.begin(115200);
connectToWifi();
connectToMqtt();
}
vacío loop() {}
// Asegurar que el cliente MQTT se mantenga conectado
si (!mqtClient.connected())) {}
connectToMqtt();
}
mqttClient.loop();
}

MQTT sobre WebSocket

Define la dirección MQTT Broker como esta para conectar al cliente en WebSocket.

#include ■PubSubClient.h
#include ■WebSocketsClient.h
// MQTT Configuración de carpetas
const char* mqtt_server = "public-mqtt-broker.bevywise.com";
const uint16_t mqt_port = 10443; // WebSocket sin TLS generalmente corre en el puerto 80
const char* client_id = generateClientId(crystal_, length);
// Iniciación de clientes de WiFi y MQTT
WiFiClient espClient;
PubSubClient mqtClient(espClient);
conexión de vacío ToWifi() {
Serial.println("Connecting to WiFi...");
WiFi.begin(ssid, password);
(WiFi.status() != WL_CONNECTED) {
retraso(500);
Serial.print(");
}
Serial.println("WiFi conectado");
}
conexión de vacíoToMqt() {
mqttClient.setServer(mqt_server, mqtt_port);
mqttClient.setCallback(mqttCallback);
mientras (!mqtClient.connected())) {}
Serial.print("Connecting to MQTT over WebSocket... ");
si (mqttClient.connect(client_id)) {}
Serial.println("conectado");
// Suscribirse a temas o publicar mensajes aquí
// mqttClient.subscribe("su/topic");
. ♫ ... {
Serial.print("failed with state ");
Serial.print(mqtClient.state());
retraso(2000);
}
}
}
vacío mqttCallback (tópico de caracteres*, carga útil byte*, longitud de entrada sin señal) {}
// Manejar mensajes entrantes
Serial.print("Message llegó al tema: ");
Serial.print(topic);
Serial.print(). Mensaje: ");
para (int int i = 0; i) longitud; i++) {}
Serial.print(char)payload[i]);
}
Serial.println();
}
configuración de vacío() {}
Serial.begin(115200);
connectToWifi();
connectToMqtt();
}
vacío loop() {}
// Asegurar que el cliente MQTT se mantenga conectado
si (!mqtClient.connected())) {}
connectToMqtt();
}
mqttClient.loop();
}

MQTT sobre Secure WebSocket

Utilice el siguiente código para conectar al cliente sobre Secure WebSocket. Establecer opciones TLS como se indica en la sección MQTT Más TLS. Define el Macro ADDRESS utilizando los parámetros de conexión de MQTT Broker.

// MQTT Configuración de carpetas
const char* mqtt_server = "public-mqtt-broker.bevywise.com";
const uint16_t mqt_port =11443; // WebSocket with TLS usually runs on puerto 443
const char* client_id = "esp_client";
// Certificado CA de arranque para el corredor MQTT
const char* root_ca = \
"------BEGIN CERTIFICATE------\n" \
"YOUR_ROOT_CA_CERTIFICATE\n"
"-----END CERTIFICATE-----\n";
// Iniciación de clientes de WiFi y MQTT
WiFiClientSecure espClient;
PubSubClient mqtClient(espClient);
conexión de vacío ToWifi() {
Serial.println("Connecting to WiFi...");
WiFi.begin(ssid, password);
(WiFi.status() != WL_CONNECTED) {
retraso(500);
Serial.print(");
}
Serial.println("WiFi conectado");
}
conexión de vacíoToMqt() {
// Establecer el certificado raíz CA para TLS
espClient.setCACert(root_ca);
mqttClient.setServer(mqt_server, mqtt_port);
mqttClient.setCallback(mqttCallback);
mientras (!mqtClient.connected())) {}
Serial.print("Connecting to MQTT over WebSocket with TLS... ");
si (mqttClient.connect(client_id)) {}
Serial.println("conectado");
// Suscribirse a temas o publicar mensajes aquí
// mqttClient.subscribe("su/topic");
. ♫ ... {
Serial.print("failed with state ");
Serial.print(mqtClient.state());
retraso(2000);
}
}
}
vacío mqttCallback (tópico de caracteres*, carga útil byte*, longitud de entrada sin señal) {}
// Manejar mensajes entrantes
Serial.print("Message llegó al tema: ");
Serial.print(topic);
Serial.print(). Mensaje: ");
para (int int i = 0; i) longitud; i++) {}
Serial.print(char)payload[i]);
}
Serial.println();
}
configuración de vacío() {}
Serial.begin(115200);
connectToWifi();
connectToMqtt();
}
vacío loop() {}
// Asegurar que el cliente MQTT se mantenga conectado
si (!mqtClient.connected())) {}
connectToMqtt();
}
mqttClient.loop();
}

Configuración de MQTT Autenticación

Para conectarse a MQTT Broker que requiere MQTT Usuario y MQTT Contraseña para autenticación, añadir a nombre de usuario y contraseña a las opciones de conexión como esta:

#include ■WiFi.h
#include ■WiFiClient.h
#include ■PubSubClient.h
// MQTT Configuración de carpetas
const char* mqtt_server = "public-mqtt-broker.bevywise.com";
const uint16_t mqt_port = 1883; // Use port 1883 for non-TLS
const char* mqt_user = "your_mqt_username";
const char* mqt_password = "your_mqt_password";
const char* client_id_prefix = "esp_client_";
// Iniciación de clientes de WiFi y MQTT
WiFiClient espClient;
PubSubClient mqtClient(espClient);
conexión de vacío ToWifi() {
Serial.println("Connecting to WiFi...");
WiFi.begin(ssid, password);
(WiFi.status() != WL_CONNECTED) {
retraso(500);
Serial.print(");
}
Serial.println("WiFi conectado");
}
Generación de cuerdas ClientId(String prefix, longitud int) {
const char chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
int charsLength = sizeof(chars) - 1;
cliente String Id = prefijo;
// Inicializar la semilla aleatoria
randomSeed(analogRead(0));
para (int i = 0; i) {}
clientId += chars[random(0, charsLength)];
}
cliente de devolución Id;
}
conexión de vacíoToMqt() {
mqttClient.setServer(mqt_server, mqtt_port);
mqttClient.setCallback(mqttCallback);
String client_id = generateClientId(client_id_prefix, 10);
mientras (!mqtClient.connected())) {}
Serial.print("Connecting to MQTT... ");
si (mqttClient.connect(client_id.c_str(), mqtt_user, mqt_password)) {}
Serial.println("conectado");
// Suscribirse a temas o publicar mensajes aquí
// mqttClient.subscribe("su/topic");
. ♫ ... {
Serial.print("failed with state ");
Serial.print(mqtClient.state());
retraso(2000);
}
}
}
vacío mqttCallback (tópico de caracteres*, carga útil byte*, longitud de entrada sin señal) {}
// Manejar mensajes entrantes
Serial.print("Message llegó al tema: ");
Serial.print(topic);
Serial.print(). Mensaje: ");
para (int int i = 0; i) longitud; i++) {}
Serial.print(char)payload[i]);
}
Serial.println();
}
configuración de vacío() {}
Serial.begin(115200);
connectToWifi();
connectToMqtt();
}
vacío loop() {}
// Asegurar que el cliente MQTT se mantenga conectado
si (!mqtClient.connected())) {}
connectToMqtt();
}
mqttClient.loop();
}

Características avanzadas

Configuración de la última voluntad

Configurar elÚltimo Voluntad y testamentofunción para especificar un mensaje que el corredor publicará si el cliente inesperadamente desconecta. Esto ayuda a informar a otros suscriptores del cliente desconectado estado.

Utilice el siguiente código para establecer Last Will en las opciones de conexión:

// Ajustes LWT
const char* lwt_topic = "test/lwt";
const char* lwt_message = "ESP32 desconectado";
const int lwt_qos = 1;
const bool lwt_retain = true;
//Función para reconectar MQTTBroker
vaciado ()
{}
mientras (!mqtClient.connected()))
{}
Serial.print("Intento de conexión MQTT...");
// Intente conectarse con el nombre de usuario MQTT, contraseña y LWT
si(mqttClient.connect("ESP32Client",mqtt_user,mqt_password, lwt_topic, lwt_qos, lwt_retain, lwt_message) {
Serial.println("conectado"); // Suscribirse a un tema mqttClient.subscribe("test/topic");
}
más
{}
Serial.print("failed, rc=");
Serial.print(mqtClient.state());
Serial.println(" intentar de nuevo en 5 segundos"); // Espera 5 segundos antes retórica
retraso(5000);

Ajuste Mantener Alive

MQTT mantiene conexiones cliente-broker con un mecanismo de mantenimiento. Ajuste el mantener el intervalo positivo para controlar con qué frecuencia el cliente envía mensajes PINGREQ el corredor.

Modifique el código de abajo para satisfacer sus requisitos:

// MQTT intervalo de mantenimiento (en segundos)
const int mqt_keep_alive = 60; // Ajuste según sea necesario
configuración de vacío()
{}
mqttClient.setKeepAlive(mqtt_keep_alive);
}

Configuración de la Persistencia de Sesión

Datos del período de sesiones de unMQTT Clienteincluir las Suscripciones hechas por el Cliente y los datos que el Cliente recibir con QoS confiar0.

El Cliente puede conseguir que el MQTT Broker almacene sus datos de sesión a través de las conexiones.

MQTT 3.1.1 Los clientes pueden establecer sesión limpia = 0 para solicitar el Broker MQTT para mantener su información de sesión almacenada a través de conexiones.

Para MQTT 3.1.1 :

si (mqttClient.connect("ESP32ClientClean", mqtt_user, mqt_password, nullptr, 0, false, nullptr, true)
{}
Serial.println("conectado");
}
si (mqttClient.connect("ESP32ClientPersistent", mqtt_user, mqtt_password, nullptr, 0, false, nullptr, false)
{}
Serial.println("conectado");
}

MQTT 5 Los clientes pueden establecer Clean Start = 0 y Session Expiry Interval = 'N' para solicitar el MQTT Broker para mantener su información de sesión almacenada a través de conexiones para 'N' segundos.

Para MQTT 5 :

// Ajustes del cliente MQTT
const char* client_id = "ESP32Client";
const bool clean_start = false;
const uint32_t session_expiry_interval = 3600; // Session expiry intervalo en segundos
AsyncMqtClient mqtClient;
conexión de vacío ToWifi() {
Serial.println("Connecting to WiFi...");
WiFi.begin(ssid, password);
(WiFi.status() != WL_CONNECTED) {
retraso(500);
Serial.print(");
}
Serial.println("WiFi conectado");
}
vacio enMqtConnect(bool sessionPresent) {
Serial.println("Connected to MQTT.");
Serial.print("Sesión presente: ");
Serial.println(sessionPresent);
// Suscribirse a temas o publicar mensajes aquí
// mqttClient.subscribe("su/topic", 0);
}
configuración de vacío() {}
Serial.begin(115200);
connectToWifi();
mqttClient.onConnect(onMqtConnect);
mqttClient.onDisconnect(onMqtDisconnect);
mqttClient.setServer(mqt_server, mqtt_port);
mqttClient.setCredentials(mqtt_user, mqtt_password);
// Configurar las características MQTT 5
mqttClient.setCleanSession(clean_start);
mqttClient.setSessionExpiry(session_expiry_interval);
mqttClient.connect(client_id);
}
vacío loop() {}
// Nada que hacer aquí, AsyncMqtClient maneja todo
}

Configuración Máxima Tamaño del paquete

MQTT5 Client puede solicitar el MQTT Broker para enviar sólo paquetes de datos menos que un tamaño específico por establecerlo así:

Para MQTT 5 :

const char* data = “datos más grandes para enviar”;
const int chunkSize = 1024;
int dataLength = strlen(data);
int numChunks = (dataLength + chunkSize - 1) / chunkSize;
// Calcular el número de trozos necesarios
para (int i = 0; i)
{}
char chunk[chunkSize + 1]; // Buffer para pedazos
// Copiar el trozo de datos en el amortiguador
strncpy(chunk, data + i * chunkSize, chunkSize);
[chunkSize] = '\0'; // Null-termina la cadena
// Publish chunk as MQTT message
mqttClient.publish("large_data_topic", chunk, false); // false for QoS 0 Serial.print("Published chunk ");
}

Publish

Envío de datos

Distribución eficiente de los datos a múltiples suscriptores por publicarlos a los designados temas con el siguiente fragmento de código:

Para MQTT 3.1.1

mqtcclient.publish("topic",message.c_str());

Para MQTT 5

// Publicación de ejemplos
Mensaje de cuerda = "¡Hola, MQTT!";
mqttClient.publish("topic", 0, false, message.c_str());
}

Configuración de mensajes retenidos

Permitir la bandera de retención al publicar un mensaje para asegurar que el corredor almacena la último mensaje para cada tema. Esto garantiza que los nuevos suscriptores reciban más mensaje reciente al conectarse.

Para implementar esto, utilice el siguiente fragmento de código:

// Ejemplo: Publicar un mensaje retenido cada 10 segundos
static unsigned long lastPublish = 0;
si (millis() - lastPublish > 10000)
{}
últimoPublicado = milis();
si (mqttClient.publish("topic", "Device Status = 1", true))
{}
Serial.println("Retained message published successfully");
}
más
{}
Serial.println("Retained message publish failed");
}
}

Especificación de los niveles de QoS

MQTT proporciona tres niveles de calidad de servicio (QoS) Entrega del mensaje:

  • QoS 0 (Al menos una vez)
  • QoS 1 (Al menos una vez)
  • QoS 2 (Exactamente una vez)
Especifique el requisitoNivel QoSal publicar mensajes MQTT usando este código:

si (mqttClient.publish("topic", "Device status with DoS 0", false, 0))
{}
Serial.println("Message with QoS 0 published successfully");
}
más
{}
Serial.println("Message with QoS 0 publish failed");
}
// Publicar un mensaje con QoS 1
si (mqttClient.publish("topic", "Devicce status with QoS 1", false, 1))
{}
Serial.println("Message with QoS 1 published successfully");
}
más
{}
Serial.println("Message with QoS 1 publish failed");
}
// Publicar un mensaje con QoS 2
si (mqttClient.publish("topic", "Device status with QoS 2", false, 2))
{}
Serial.println("Message with QoS 2 published successfully");
}
más
{}
Serial.println("El mensaje con QoS 2 publicar falló");
}

Intervalo de viaje

La propiedad 'intervalo de caducidad del mensaje' establece la duración de la vida del mensaje en segundos; si sin entrega dentro de este tiempo, el corredor lo descarta. MQTT5 admite esta función. MQTT5 Los clientes pueden configurar esto mientras publican datos.

Para MQTT 5

int expiryInterval = 60;
const char* message = “device status messge”;
mqttClient.beginPublish(topic, strlen(message), false, expiryInterval *1000); // Intervalo de exploración en milisegundos
mqttClient.print(carga);
mqttClient.endPublish();

Tema Alias

La propiedad 'Topic Alias' permite a los clientes utilizar un breve alias en lugar de un completo nombre de tema, reducción del tamaño del paquete de mensajes y mejora la eficiencia de la red.

Para MQTT 5

// Valor máximo de Alias Tópico (ajustado basado en capacidades de corredor MQTT)
const int MAX_TOPIC_ALIAS = 10;
const char* mensaje = “Mensaje de estado del dispositivo”;
// Publish with topic alias if supported by the broker
mqttClient.beginPublish(topic, strlen(message), false);
mqttClient.writeTopic(topic); // Publicar el nombre completo del tema
mqttClient.writeTopicAlias(1); // Establecer el tema alias, por ejemplo, 1 mqttClient.print(mensage);
mqttClient.endPublish();

Propiedades asociadas con MQTT PUBLISH mejorar el manejo de mensajes, proporcionando contexto o instrucciones para corredores y clientes. Estas propiedades, incluida la expiración del mensaje intervalos y alias tópicos, optimizar la entrega de mensajes y ancho de banda de red.

Suscríbete

Suscribirse al filtro del tema

Para recibir datos publicados por otros clientes, este cliente tiene que suscribirse a un matching Topic Filtro como este:

mqttClient.subscribe("cmq/topic");

Este filtro de tema puede coincidir con un tema exacto o tienen como # y +

Envío de datos

Para recibir los datos enviados para las suscripciones, es necesario definir una función callback así:

vacio enMqtMessage (tópico del cuadro*, char* payload, AsyncMqtClientMessagePropiedades profesionales, size_t len, size_t index, tamaño_t total) {}
Serial.println("Message received:");
Serie.print(" Tema: ");
Serial.println(topic);
Serie.print(" Carga: ");
Serial.println(payload);
// Puede agregar más procesamiento aquí basado en las necesidades de su aplicación
}
configuración de vacío() {}
Serial.begin(115200);
connectToWifi();
mqttClient.onConnect(onMqtConnect);
mqttClient.onDisconnect(onMqtDisconnect);
mqttClient.onMessage(onMqttMessage); // Establecer la función callback para mensajes entrantes
mqttClient.setServer(mqt_server, mqtt_port);
mqttClient.setCredentials(mqtt_user, mqtt_password);
mqttClient.connect(client_id);
}

Suscripción de Temas

Para dejar de recibir actualizaciones de un tema, utilice el código proporcionado para darse de baja.

// Unsubscribe del topicawait
mqttClient.unsubscribe("cmq/topic");

Desconectar al cliente

Asegurar una terminación adecuada de la conexión de su cliente con el corredor para evitar problemas y fugas de recursos en ambas partes, manteniendo así la estabilidad del sistema.

Utilice el siguiente código para desconectar al cliente del broker:

mqttClient.disconnect();

Construcción de su lógica de negocio

Usted tiene la oportunidad de desarrollar y personalizar su propia lógica de negocio intrincada dentro de este entorno, adaptándolo precisamente a sus necesidades y objetivos específicos.

Aplicación de las mejores prácticas

Gestión única de identificación del cliente

Asignar un ID de cliente específico a cada dispositivo para una identificación precisa. En privado configuración, designar identificaciones únicas para cada cliente. En entornos compartidos, anexa una cadena aleatoria a cada ID de cliente para mantener singularidad.

Diseño de datos

Planifique estratégicamente su estructura de datos de antemano. Si usted está trabajando con texto llano, Datos con formato JSON, o datos numéricos, aseguran que el diseño se ajuste a su las necesidades de la aplicación y el caso de uso.

Manejo de error robusto

Implementar una gestión de errores sólida para manejar la conexión MQTT fallas, problemas de suscripción y errores de publicación de mensajes eficazmente.

Verificación de credenciales

Guardar información confidencial como nombres de usuario, contraseñas y ID de cliente por no codificarlos duros en su código fuente. Use variables ambientales o seguras archivos de configuración en su lugar.

Pruebas periódicas " Monitoreo

Prueba continuamente la comunicación de MQTT y monitorea métricas de clientes como estado de conexión, rendimiento de mensajes y tasas de error para identificar e identificar rápidamente solucionar problemas.

Optimización de la gestión de las sesiones

Elija entre sesiones limpias y persistentes ( " limpias: verdaderas " o " limpias: falsas " ) basado en su necesidad de retener suscripciones y mensajes solicitados a través del cliente conexiones.

Reconnect on Disconnect

Agregar código para intentar la reconexión a laMQTT Brokercuando hay una desconexión inesperada. Esto asegurará que su cliente se mantiene conectado y no pierde datos.

Descargar Código

Descargar el código completo para el cliente que utiliza ESP32 MQTT Client Library para conectar con nuestraMQTT brokero cualquier agente de su elección.

Para MQTT 3.1.1

//Este código lee el estado de disponibilidad y el estado de productividad de la máquina a mqtbroker
//incluidas las bibliotecas necesarias
#include ■Arduino.h
#include ■WiFi.h
#include ■PubSubClient.h
#include ■ArduinoJson.h
#include "time.h"
// WiFiUDP ntpUDP;
const char *ntpServer = "time.google.com";
WiFiClient ProxSen;
PubSubClient client(ProxSen);
unsigned long epochTime = 0;
no firmado larga corriente Millis1 = 0;
const char* ssid = "xxxxxxxxxxxx"; // reemplazar xxx. con su WIFI SSID
const char* password = "xxxxxxxxxxxxx"; // repace con WIFI Contraseña
const char* mqt_server = "xxxxxxxxxxxxxxxxxxx"; //MQTT server name
const char* mqt_user = "xxxxxxxxxxxxxxxxxxxx"; //MQTT broker user name
const char* mqt_password = "xxxxxxxxxxxxx"; //MQTT broker password
const int ProxSenPin = 33; //availablity status read
const int productivityPin = 26; // produtivity status read
const unsigned long aggregation Interval = 60000; // 1 minuto
int availabilityValues[60]; // Disponibilidad y productividad de las tiendas valores por 1 minutos
// int changeoverValues[300];
int valueIndex = 0;
int availability = 0;
productividad de la int = 1;
bool produce Bandera = falsa;
unsigned long getTime()
{}
time_t now;
Serial.println("inside gettime");
struct tm timeinfo;
si (!getLocalTime(юtimeinfo))
{}
Serial.println("Failed to obtain time");
getTime();
}
tiempo (ahora);
Vuelva ahora;
}
// Para leer la disponibilidad de la máquina
void IRAM_ATTR availIsr()
{}
disponibilidad = digitalRead(ProxSenPin) ? 0 : 1; //dispositivo funciona en negataive lógica
}
// Para leer la productividad de la máquina
IRAM_ATTR produceIsr()
{}
produceFlag = digitalRead(productividadPin) ? falso : verdadero;
}
//Connection con mqtt broker
conexión de vacíoToMqt()
{}
(!client.connected()))
{}
Serial.println("Connecting to MQTT...");
si (client.connect("ProxSen", mqt_user, mqtt_password))
{}
Serial.println("Connected to MQTT");
}
más
{}
Serial.print("Failed to connect to MQTT, rc=");
Se!
rial.print(client.state());
Serial.println(" Regresar en 5 segundos..."
retraso(5000);
}
}
configuración de vacío()
{}
Serial.begin(115200);
//configurar conexión WIFI
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
(WiFi.status() != WL_CONNECTED)
{}
retraso(5000);
Serial.print(");
}
Serial.println("WiFi conectado");
//configurar MQTTBroker
client.setServer(mqt_server,1883);
configTime(0, 0, ntpServer);
epochTime = getTime();
connectToMqtt();
pinMode(ProxSenPin, INPUT);
adjuntaInterrupt(digitalPinToInterrupt(ProxSenPin), availIsr, CHANGE);
pinMode(productivityPin, INPUT);
adjuntaInterrupt(digitalPinToInterrupt(productividadPin), produceIsr, CHANGE);
disponibilidad = digitalRead(ProxSenPin)?0:1;
demora(25);
}
vacío loop()
{}
epochTime = epochTime + 1;
disponibilidadValores[valorIndex] = disponibilidad;
valorIndex++;
// Publicar los datos de producción en el tiempo de finalización parcial
si(produceFlag)
{}
DynamicJsonDocument jsonDocument1(1000);
String json Productividad;
produceFlag = falso;
jsonDocument1["producción_status"] = 1;
jsonDocument1["timestamp"] = epochTime;
serializeJson(jsonDocument1,jsonProductivity);
si (!client.connected())
{}
connectToMqtt();
}
cliente.publish("ProxSen/productivity",jsonProductivity.c_str());
}
/ / Publish machine status cada 5 segundos
if(millis() - currentMillis1 √= 5000)
{}
actualMillis1 = millis();
DynamicJsonDocument jsonDocument2(1000);
String json AvailStatus;
jsonDocument2["machine_status"] = disponibilidad;
jsonDocument2["timestamp"] = epochTime;
serializeJson(jsonDocument2,jsonAvailStatus);
si (!client.connected())
{}
connectToMqtt();
}
client.publish("ProxSen/machine_status", jsonAvailStatus.c_str());
}
retraso(1000);
}

Para MQTT 5

#include ■Arduino.h
#include ■WiFi.h
#include ■AsyncMqtClient.h
#include ■ArduinoJson.h
#include "time.h"
// credenciales WiFi
const char* ssid = "your_SSID"; // Reemplazar con su SSID WiFi
const char* password = "your_PASSWORD"; // Reemplazar con su WiFi contraseña
// MQTT Configuración de carpetas const char* mqtt_server = "public-mqtt-broker.bevywise.com"; // MQTT broker Nombre del servidor
const uint16_t mqt_port = 1883; // puerto de corredor MQTT (uso 1883 para no-TLS)
const char* mqt_user = "your_mqt_username"; // MQTT broker username
const char* mqt_password = "your_mqt_password"; // MQTT broker contraseña
// Ajustes del cliente MQTT
const char* client_id = "ESP32Client";
AsyncMqtClient mqtClient;
WiFiClient wifiClient;
unsigned long epochTime = 0;
no firmado larga corriente Millis1 = 0;
ntpServer = "time.google.com";
const int ProxSenPin = 33; //
const int productivity Pin = 26; // Estatus de productividad
const unsigned long aggregation Interval = 60000; // 1 minuto
int availabilityValues[60]; // Valores de disponibilidad de tiendas para 1 minuto
int valueIndex = 0;
int availability = 0;
bool produce Bandera = falsa;
total IRAM_ATTR availIsr() {
disponibilidad = digitalRead(ProxSenPin) ? 0 : 1; // Lógica Inversa (negativa) lógica)
}
IRAM_ATTR produceIsr() {
produceFlag = digitalRead(productividadPin) ? falso : verdadero;
}
conexión de vacíoToMqt() {
Serial.println("Connecting to MQTT...");
mqttClient.connect();
}
tiempo() {
time_t now;
struct tm timeinfo;
si (!getLocalTime(юtimeinfo)) {}
Serial.println("Failed to obtain time");
getTime();
}
tiempo (ahora);
Vuelva ahora;
}
vacio enMqtConnect(bool sessionPresent) {
Serial.println("Connected to MQTT.");
Serial.print("Sesión presente: ");
Serial.println(sessionPresent);
// Suscribirse a los temas necesarios si es necesario
mqttClient.subscribe("ProxSen/#");
// Publicación de ejemplo en conexión (si es necesario)
Mensaje de cuerda = "¡Hola, MQTT!";
mqttClient.publish("ProxSen/test", 0, false, message.c_str());
}
vacio enMqtDisconnect(AsyncMqtClientDisconnectReason reason) {
Serial.println("Disconnected from MQTT.");
si (WiFi.isConnected())) {}
connectToMqtt();
}
}
configuración de vacío() {}
Serial.begin(115200);
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
(WiFi.status() != WL_CONNECTED) {
retraso(500);
Serial.print(");
}
Serial.println("WiFi conectado");
mqttClient.setServer(mqt_server, mqtt_port);
mqttClient.setCredentials(mqtt_user, mqtt_password);
mqttClient.setClientId(client_id);
mqttClient.onConnect(onMqtConnect);
mqttClient.onDisconnect(onMqtDisconnect);
// Configure MQTT 5 ajustes específicos (opcional)
mqttClient.setCleanSession(true); // Establecer sesión limpia a verdadero o falso basado en su requisito
// Conectarse con el corredor MQTT
connectToMqtt();
// Interrupciones de configuración para los pines de disponibilidad y productividad
pinMode(ProxSenPin, INPUT);
adjuntaInterrupt(digitalPinToInterrupt(ProxSenPin), availIsr, CHANGE);
pinMode(productivityPin, INPUT);
adjuntaInterrupt(digitalPinToInterrupt(productividadPin), produceIsr, CHANGE);
disponibilidad = digitalRead(ProxSenPin) ? 0 : 1;
demora(25);
}
vacío loop() {}
epochTime = epochTime + 1;
disponibilidadValores[valorIndex] = disponibilidad;
valorIndex++;
// Publicar datos de productividad cuando se establece el productoFlag
si (produceFlag) {
DynamicJsonDocument jsonDocument1(1000);
String json Productividad;
produceFlag = falso;
jsonDocument1["producción_status"] = 1;
jsonDocument1["timestamp"] = epochTime;
serializeJson(jsonDocument1, jsonProductivity);
si (mqttClient.connected()) {}
mqttClient.publish("ProxSen/productivity", 0, false, jsonProductivity.c_str());
}
}
/ / Publish machine status cada 5 segundos
(millis() - currentMillis1 ±= 5000) {
actualMillis1 = millis();
DynamicJsonDocument jsonDocument2(1000);
String json AvailStatus;
jsonDocument2["machine_status"] = disponibilidad;
jsonDocument2["timestamp"] = epochTime;
serializeJson(jsonDocument2, jsonAvailStatus);
si (mqttClient.connected()) {}
mqttClient.publish("ProxSen/machine_status", 0, false, jsonAvailStatus.c_str());
}
}
// Handle MQTT cliente biblioteca mantener vivo y procesamiento de mensajes
si (mqttClient.connected()) {}
mqttClient.loop();
. ♫ ... {
connectToMqtt();
}
retraso(1000);
}

Crear un Bundle ejecutable

Pasos para Flash el Código en ESP32

Los siguientes son los pasos para subir el código en el procesador ESP32 :

  • Preparar el texto Mantenga el botón de arranque, luego presione y soltar el reset Botón.
  • Seleccione la tabla y el puerto: Vaya a Herramientas, luego Puerto, y seleccione el módulo ESP32 dev bordo y el puerto COM correcto. Si no está seguro de qué puerto utilizar, intente seleccionar uno y ver si funciona.
  • Verificar el código: Haga clic en el icono Verificar en la esquina superior izquierda para compilar el código y comprobar los errores.
  • Subir el código: Haga clic en el icono Subir para compilar el código de nuevo y empujarlo al ESP32.
  • Huelga la salida: Abra el monitor de serie para ver la salida. Si la salida es gibberish, es posible que necesite cambiar la tasa de baud para que coincida con el código y la serie monitor.

Conecta a tu cliente con nuestro estado de arteMQTT brokero cualquier agente de su elección. Esta potente combinación garantizará un rendimiento óptimo y confiabilidad para todas sus necesidades de mensajería, allanando el camino para un robusto y eficiente integración del sistema.