Anschluss von MQTT Clients über ESP 32

Einleitung

Dieser Leitfaden bietet ein umfassendes Tutorial zum Anschluss eines MQTT-Clients, der auf einem ESP32 Gerät zu unseremMQTT Brokeroder einen Broker Ihrer Wahl. Es umfasst wesentliche Aufgaben wie die Einrichtung Verbindungen, Anmeldung zu Themen, Abschreiben und Austausch von Nachrichten. Durch diese Schritte können Sie effektiv IntegrationMQTKommunikation in Ihre IoT-Projekte.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie:

ESP32 Entwicklungsboard mit Arduino IDE Setup
Zugriff auf jede MQTT-Broker-Instanz (IP-Adresse oder Domainname)
WiFi-Verbindung Anmeldeinformationen für den ESP32

Dependance Installation

Arduino IDE installieren

Downloaden und installieren Sie die Arduino IDE von der offiziellen Arduino Website.

Installieren Sie das ESP32 Board Package

Öffne die Arduino IDE
Gehe zu einer Datei Vorlieben
In den Warenkorb Boards Manager URLs fügen Sie sind die folgenden URLs

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

Wenn es bereits URLs in diesem Bereich gibt, können Sie haben es geschafft Mit Kommas.

Sie auf OK, um die Einstellungen zu speichern
Gehen Sie zu Tools > !
Im Boards Manager Sie nach ESP32 und installieren Sie das esp32 Paket von Espressif Systeme

Wählen Sie das ESP32 Board

Gehen Sie zu Tools > Vorstand
Wie man sieht Sie nach unten und wählen Sie Ihr spezifisches ESP32 Board (z.B. ESP32 Dev Module)

Benötigte Bibliotheken installieren

Gehe zu Sketch > Bibliothek > Bibliotheken
Im Library Manager Sie nach folgenden Bibliotheken und Installationen suchen Sie sind die ANHANG

WiFi (für WiFi-Konnektivität)
ESPAsyncWebServer (für die Erstellung von Webservern)
PubSubClient (für MQTT-Kommunikation)
Adafruit Sensor (bei Verwendung von Adafruit-Sensoren)
DHT-Sensorbibliothek (für DHT-Sensoren)
ArduinoJson (für JSON Parsing und Serialisierung)

ANHANG Sie einfach auf die gestellte Bibliothek und klicken Sie dann auf Installieren Knopf.

Installation überprüfen

Sie eine Beispielskizze, um die Installation zu überprüfen.
Gehe zu einer Datei Beispiele und nach Durchführung unter ESP32 oder den bestehenden Bibliotheken suchen.
Wählen Sie eine Beispielskizze, ein Kompilieren und geladen Sie es auf Ihrem ESP32 Board, um verdient Alles ist korrekt eingerichtet.

Feste Konstanten

Ersetzen Sie Ihr_wifi_ssid, Ihr_wifi_password, mqt_server und mqt_port mit Ihrem aktuellen WiFi und MQTT Broker Details.

/ WiFi
const char *ssid = "xxxxx"; // Geben Sie Ihr WLAN-Ssid
const char *password = "xxxxx"; // Geben Sie WiFi-Passwort ein
// MQTT Broker
const char *mqt_server = "public-mqtt-broker.bevywise.com";
const int mqt_port = 1883;
const char *mqtt_username = "username"; (optional)
const char *mqt_password = "pwd"; (optional)

Anschluss an MQTT Broker

Dieser Abschnitt hat Code-Snippets von verschiedenen Möglichkeiten, um mit MQTT Broker zu verbinden. Stellen Sie sicher, dass der MQTT Broker unterstützt den Verbindungstyp, den Sie verwenden möchten. Auch erhalten die entsprechenden Verbindungsparameter des MQTT Broker (Adresse, Port, Benutzername/Passwort, CA Certificate)

MQT Über TCP

Verwenden Sie den folgenden Code, um den Client über TCP zu verbinden. Definieren Sie die Macro ADDRESS mit den Verbindungsparametern von MQTT Broker.

Für MQTT 3.1.1:

WiFi.begin(ssid, passwort);
während (WiFi.status() != WL_CONNECTED)
{\cHFFFF}
Verzögerung(500)
Serial.println("Connecting to WiFi..");
}
const char *client_id = “esp_client”;
client.setServer(mqt_server,mqtt_port);

Für MQTT 5:

AsyncMqtClient mqtClient;
Leere Verbindung ToWifi() {
Serial.println("Connecting to WiFi...");
WiFi.begin(ssid, passwort);
während (WiFi.status() != WL_CONNECTED {
Verzögerung(500)
Serial.print(");
}
Serial.println("WiFi verbunden");
}
ungültig aufMqtConnect(bool sessionPresent) {
Serial.println("Connected to MQTT.");
// Sie können Themen hier abonnieren
// mqtClient.subscribe("test/topic", 1);
}
Nichtigkeitseinstellung() {\cHFFFF}
Serial.begin(115200);
ConnectToWifi();
mqtClient.onConnect(onMqtConnect);
mqttClient.setServer (mqtt_server, mqt_port);
mqtClient.setClientId(client_id);
// Legen Sie die Protokollversion auf MQTT 5.0
mqtClient.setProtocolVersion(5);
mqtClient.connect();
}

MQTT über TLS / SSL

Verwenden Sie den folgenden Code, um sicher mit MQTT Broker über TLS zu verbinden. Definieren Sie die Macro ADDRESS mit den Verbindungsparametern von MQTT Broker.

#include <WiFiClientSecure.h>
// Root CA Zertifikat für den MQTT Broker
* root_ca = \
"-----------------
"YOUR_ROOT_CA_CERTIFICATE\n" \
"------END KERTIFIKATE-----------\n";
// init wifi sicher Client
WiFiClientSecure espClient;
PubSubClient Client(espClient);
espClient.setCACert(root_ca);
espClient.setCertificate(server_cert); //für Client-Verifikation
espClient.setPrivateKey(server_key); // für Client-Verifikation

Setzen Sie TLS-Parameter vor dem Aufruf der MQTTClient_connect, um den Client zu verbinden der mQTT Broker sicher über TLS.

Wenn der MQTT Broker in einem vertrauenswürdigen Server gehostet wird und die Serververifikation nicht erforderlich, der folgende Code kann verwendet werden, um TLS-Optionen einzustellen:

// MQTT Broker Einstellungen
const char* mqt_server = "your_mqt_server";
const uint16_t mqt_port = 8883; // Typischerweise wird Port 8883 für MQTT über TLS
const char* client_id = createClientId(kristall_, Länge);
// Initialisieren Sie WiFi und MQTT-Kunden
WiFiClientSecure espClient;
PubSubClient mqtClient(espClient);
Leere Verbindung ToWifi() {
Serial.println("Connecting to WiFi...");
WiFi.begin(ssid, passwort);
während (WiFi.status() != WL_CONNECTED {
Verzögerung(500)
Serial.print(");
}
Serial.println("WiFi verbunden"); }
Leere VerbindungToMqt() {
// Server-Zertifizierung deaktivieren
espClient.setInsecure();
mqttClient.setServer (mqtt_server, mqt_port);
mqtClient.setCallback (mqttCallback)
während (!mqtClient.connected()) {\cHFFFF}
Serial.print("Connecting to MQTT... ");
wenn (mqtClient.connect(client_id)) {\cHFFFF}
Serial.println("verbunden");
// Abonnieren Sie Themen oder veröffentlichen Sie Nachrichten hier
// mqtClient.subscribe("your/topic");
} auch
Serial.print("veröffentlicht mit Zustand ");
Serial.print(mqtClient.state());
Verzögerung(2000)
}
}
}
Nichtigkeitseinstellung() {\cHFFFF}
Serial.begin(115200);
ConnectToWifi();
verbindenToMqt();
}
Leerschleife() {\cHFFFF}
// Stellen Sie sicher, dass der MQTT-Client angeschlossen bleibt
wenn (!mqtClient.connected()) {\cHFFFF}
verbindenToMqt();
}
mqttClient.loop();
}

Wenn das MQTT Broker Serverzertifikat von einer Trusted CA ausgestellt hat, dann der Server Zertifikat kann mit:

/ Root CA Zertifikat für den MQTT Broker
* root_ca = \
"-----------------
"YOUR_ROOT_CA_CERTIFICATE\n" \
"------END KERTIFIKATE-----------\n";
// Initialisieren Sie WiFi und MQTT-Kunden
WiFiClientSecure espClient;
PubSubClient mqtClient(espClient);
Leere Verbindung ToWifi() {
Serial.println("Connecting to WiFi...");
WiFi.begin(ssid, passwort);
während (WiFi.status() != WL_CONNECTED {
Verzögerung(500)
Serial.print(");
}
Serial.println("WiFi verbunden");
}
Leere VerbindungToMqt() {
// Legen Sie das root CA-Zertifikat fest
espClient.setCACert(root_ca);
mqttClient.setServer (mqtt_server, mqt_port);
mqtClient.setCallback (mqttCallback)
während (!mqtClient.connected()) {\cHFFFF}
Serial.print("Connecting to MQTT... ");
wenn (mqtClient.connect(client_id)) {\cHFFFF}
Serial.println("verbunden");
// Abonnieren Sie Themen oder veröffentlichen Sie Nachrichten hier
// mqtClient.subscribe("your/topic");
} auch
Serial.print("veröffentlicht mit Zustand ");
Serial.print(mqtClient.state());
Verzögerung(2000)
}
}
}
Nichtigkeitseinstellung() {\cHFFFF}
Serial.begin(115200);
ConnectToWifi();
verbindenToMqt();
}
Leerschleife() {\cHFFFF}
// Stellen Sie sicher, dass der MQTT-Client angeschlossen bleibt
wenn (!mqtClient.connected()) {\cHFFFF}
verbindenToMqt();
}
mqttClient.loop();
}

Wenn der MQTT Broker ein selbstsigniertes Serverzertifikat besitzt dann kann das Server-Zertifikat mit dem Root-Zertifikat aus MQTT Broker:

// Selbstsignierte Root-Zertifikat für den MQTT Broker
* root_ca = \
"-----------------
"YOUR_SELF_SIGNED_ROOT_CERTIFICATE\n" \
"------END KERTIFIKATE-----------\n";
// Initialisieren Sie WiFi und MQTT-Kunden
WiFiClientSecure espClient;
PubSubClient mqtClient(espClient);
Leere Verbindung ToWifi() {
Serial.println("Connecting to WiFi...");
WiFi.begin(ssid, passwort);
während (WiFi.status() != WL_CONNECTED {
Verzögerung(500)
Serial.print(");
}
Serial.println("WiFi verbunden");
}
Leere VerbindungToMqt() {
// Setzen Sie das selbstsignierte Wurzelzertifikat CA
espClient.setCACert(root_ca);
mqttClient.setServer (mqtt_server, mqt_port);
mqtClient.setCallback (mqttCallback)
während (!mqtClient.connected()) {\cHFFFF}
Serial.print("Connecting to MQTT... ");
wenn (mqtClient.connect(client_id)) {\cHFFFF}
Serial.println("verbunden");
// Abonnieren Sie Themen oder veröffentlichen Sie Nachrichten hier
// mqtClient.subscribe("your/topic");
} auch
Serial.print("veröffentlicht mit Zustand ");
Serial.print(mqtClient.state());
Verzögerung(2000)
}
}
}
Nichtigkeitseinstellung() {\cHFFFF}
Serial.begin(115200);
ConnectToWifi();
verbindenToMqt();
}
Leerschleife() {\cHFFFF}
// Stellen Sie sicher, dass der MQTT-Client angeschlossen bleibt
wenn (!mqtClient.connected()) {\cHFFFF}
verbindenToMqt();
}
mqttClient.loop();
}

MQTT über WebSocket

Definieren Sie die MQTT Broker Adresse wie diese, um den Client über WebSocket zu verbinden.

#include <PubSubClient.h>
#include <WebSocketsClient.h>
// MQTT Broker Einstellungen
const char* mqt_server = "public-mqtt-broker.bevywise.com";
const uint16_t mqt_port = 10443; // WebSocket ohne TLS läuft in der Regel auf dem Hafen 80
const char* client_id = createClientId(kristall_, Länge);
// Initialisieren Sie WiFi und MQTT-Kunden
WiFiClient espClient;
PubSubClient mqtClient(espClient);
Leere Verbindung ToWifi() {
Serial.println("Connecting to WiFi...");
WiFi.begin(ssid, passwort);
während (WiFi.status() != WL_CONNECTED {
Verzögerung(500)
Serial.print(");
}
Serial.println("WiFi verbunden");
}
Leere VerbindungToMqt() {
mqttClient.setServer (mqtt_server, mqt_port);
mqtClient.setCallback (mqttCallback)
während (!mqtClient.connected()) {\cHFFFF}
Serial.print("Connecting to MQTT over WebSocket... ");
wenn (mqtClient.connect(client_id)) {\cHFFFF}
Serial.println("verbunden");
// Abonnieren Sie Themen oder veröffentlichen Sie Nachrichten hier
// mqtClient.subscribe("your/topic");
} auch
Serial.print("veröffentlicht mit Zustand ");
Serial.print(mqtClient.state());
Verzögerung(2000)
}
}
}
mqttCallback(char*-Thema, byte* Nutzlast, unbezeichnet int Länge) {\cHFFFF}
// eingehende Nachrichten ausschalten
Serial.print("Message kam zum Thema: ");
Serial.print(topisch);
Serial.print(". Nachricht: ");
für (unsigniert int i = 0; i < Länge; i++) {\cHFFFF}
Serial.print((char)payload[i];
}
Serial.println();
}
Nichtigkeitseinstellung() {\cHFFFF}
Serial.begin(115200);
ConnectToWifi();
verbindenToMqt();
}
Leerschleife() {\cHFFFF}
// Stellen Sie sicher, dass der MQTT-Client angeschlossen bleibt
wenn (!mqtClient.connected()) {\cHFFFF}
verbindenToMqt();
}
mqttClient.loop();
}

MQTT über Secure WebSocket

Verwenden Sie den folgenden Code, um den Client über Secure WebSocket zu verbinden. Setzen Sie TLS-Optionen wie in MQTT über TLS Abschnitt angegeben. Definieren Sie die Macro ADDRESS mit den Verbindungsparametern von MQTT Broker.

// MQTT Broker Einstellungen
const char* mqt_server = "public-mqtt-broker.bevywise.com";
const uint16_t mqt_port =11443; // WebSocket mit TLS läuft normalerweise auf Hafen 443
const char* client_id = "esp_client";
// Root CA Zertifikat für den MQTT Broker
* root_ca = \
"-----------------
"YOUR_ROOT_CA_CERTIFICATE\n" \
"------END KERTIFIKATE-----------\n";
// Initialisieren Sie WiFi und MQTT-Kunden
WiFiClientSecure espClient;
PubSubClient mqtClient(espClient);
Leere Verbindung ToWifi() {
Serial.println("Connecting to WiFi...");
WiFi.begin(ssid, passwort);
während (WiFi.status() != WL_CONNECTED {
Verzögerung(500)
Serial.print(");
}
Serial.println("WiFi verbunden");
}
Leere VerbindungToMqt() {
// Setzen Sie das Root CA-Zertifikat für TLS
espClient.setCACert(root_ca);
mqttClient.setServer (mqtt_server, mqt_port);
mqtClient.setCallback (mqttCallback)
während (!mqtClient.connected()) {\cHFFFF}
Serial.print("Connecting to MQTT über WebSocket mit TLS... ");
wenn (mqtClient.connect(client_id)) {\cHFFFF}
Serial.println("verbunden");
// Abonnieren Sie Themen oder veröffentlichen Sie Nachrichten hier
// mqtClient.subscribe("your/topic");
} auch
Serial.print("veröffentlicht mit Zustand ");
Serial.print(mqtClient.state());
Verzögerung(2000)
}
}
}
mqttCallback(char*-Thema, byte* Nutzlast, unbezeichnet int Länge) {\cHFFFF}
// eingehende Nachrichten ausschalten
Serial.print("Message kam zum Thema: ");
Serial.print(topisch);
Serial.print(". Nachricht: ");
für (unsigniert int i = 0; i < Länge; i++) {\cHFFFF}
Serial.print((char)payload[i];
}
Serial.println();
}
Nichtigkeitseinstellung() {\cHFFFF}
Serial.begin(115200);
ConnectToWifi();
verbindenToMqt();
}
Leerschleife() {\cHFFFF}
// Stellen Sie sicher, dass der MQTT-Client angeschlossen bleibt
wenn (!mqtClient.connected()) {\cHFFFF}
verbindenToMqt();
}
mqttClient.loop();
}

MQTT konfigurieren Authentifizierung

Um mit MQTT Broker zu verbinden, die MQTT Username und MQTT Password benötigt Authentifizierung, Benutzername und Passwort zu den folgenden Verbindungsoptionen hinzufügen:

#include <WiFi.h>
#include <WiFiClient.h>
#include <PubSubClient.h>
// MQTT Broker Einstellungen
const char* mqt_server = "public-mqtt-broker.bevywise.com";
const uint16_t mqt_port = 1883; // Port 1883 für nicht-TLS verwenden
const char* mqt_user = "your_mqtt_username";
const char* mqt_password = "your_mqtt_password";
const char* client_id_prefix = "esp_client_";
// Initialisieren Sie WiFi und MQTT-Kunden
WiFiClient espClient;
PubSubClient mqtClient(espClient);
Leere Verbindung ToWifi() {
Serial.println("Connecting to WiFi...");
WiFi.begin(ssid, passwort);
während (WiFi.status() != WL_CONNECTED {
Verzögerung(500)
Serial.print(");
}
Serial.println("WiFi verbunden");
}
String erzeugen ClientId(String prefix, int Länge) {
Das sind die folgenden: = „ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789“;
int charsLength = Größe(chars) - 1;
String Client Id = Präfix;
// Initialisieren Sie zufälligen Samen
randomSeed(analogRead(0));
für (in i = 0; i < Länge; i++) {\cHFFFF}
clientId += chars[random(0, charsLength)];
}
zurück zum Kunden Id.
}
Leere VerbindungToMqt() {
mqttClient.setServer (mqtt_server, mqt_port);
mqtClient.setCallback (mqttCallback)
String client_id = generierenClientId(client_id_prefix, 10);
während (!mqtClient.connected()) {\cHFFFF}
Serial.print("Connecting to MQTT... ");
wenn (mqttClient.connect(client_id.c_str(), mqtt_user, mqtt_password)) {\cHFFFF}
Serial.println("verbunden");
// Abonnieren Sie Themen oder veröffentlichen Sie Nachrichten hier
// mqtClient.subscribe("your/topic");
} auch
Serial.print("veröffentlicht mit Zustand ");
Serial.print(mqtClient.state());
Verzögerung(2000)
}
}
}
mqttCallback(char*-Thema, byte* Nutzlast, unbezeichnet int Länge) {\cHFFFF}
// eingehende Nachrichten ausschalten
Serial.print("Message kam zum Thema: ");
Serial.print(topisch);
Serial.print(". Nachricht: ");
für (unsigniert int i = 0; i < Länge; i++) {\cHFFFF}
Serial.print((char)payload[i];
}
Serial.println();
}
Nichtigkeitseinstellung() {\cHFFFF}
Serial.begin(115200);
ConnectToWifi();
verbindenToMqt();
}
Leerschleife() {\cHFFFF}
// Stellen Sie sicher, dass der MQTT-Client angeschlossen bleibt
wenn (!mqtClient.connected()) {\cHFFFF}
verbindenToMqt();
}
mqttClient.loop();
}

Erweiterte Funktionen

Das letzte Testament einrichten

Konfigurieren derLetzter Beitrag Will und Testamenteine Nachricht anzugeben, die der Broker veröffentlichen wird, wenn der Client unerwartet trennt. Dies hilft, andere Abonnenten des abgeschalteten Clients zu informieren Status.

Verwenden Sie den folgenden Code, um Last Will in den Verbindungsoptionen festzulegen:

// LWT Einstellungen
const char* lwt_topic = "test/lwt";
const char* lwt_message = "ESP32 getrennt";
const int lwt_qos = 1;
const bool lwt_retain = true;
//Anschließen von MQTTBroker
Leere Wiederverbindung()
{\cHFFFF}
während (!mqtClient.connected())
{\cHFFFF}
Serial.print("Versuche MQTT-Verbindung...");
// Versuchen Sie, mit dem MQTT Benutzernamen, Passwort und LWT zu verbinden
wenn(mqtClient.connect("ESP32Client",mqt_user,mqtt_password, lwt_topic,lwt_qos, lwt_retain, lwt_message)
Serial.println("verbunden"); // Ein Thema eintragen mqtClient.subscribe("test/topic");
}
andere
{\cHFFFF}
Serial.print("failed, rc=");
Serial.print(mqtClient.state());
Serial.println(" versuchen Sie wieder in 5 Sekunden"); // 5 Sekunden vor Wiederaufnahme
Verzögerung(5000);

Adjusting Keep Alive

MQTT unterhält Client-Broker-Verbindungen mit einem Haltemechanismus. Einstellen der halten-alive Intervall, um zu kontrollieren, wie häufig der Client PINGREQ-Nachrichten an der Broker.

Ändern Sie den untenstehenden Code entsprechend Ihren Anforderungen:

// MQTT-Halteintervall (in Sekunden)
const int mqtt_keep_alive = 60; // Nach Bedarf anpassen
Nichtigkeitseinstellung()
{\cHFFFF}
mqtClient.setKeepAlive(mqtt_keep_alive);
}

Sitzungspersistenz konfigurieren

Sitzungsdaten einerMQT !beinhalten die Abschriften des Clients und alle Daten, die der Client mit QoS>0 empfangen.

Der Client kann den MQTT Broker dazu bringen, seine Sitzungsdaten über Verbindungen zu speichern.

MQTT 3.1.1 Clients können Clean Session = 0 festlegen, um den MQTT Broker zu bitten, seine Sitzungsinformationen über Verbindungen gespeichert.

Für MQTT 3.1.1:

wenn (mqtClient.connect("ESP32ClientClean", mqtt_user, mqtt_password, nullptr, 0, false, nullptr, true))
{\cHFFFF}
Serial.println("verbunden");
}
wenn (mqtClient.connect("ESP32ClientPersistent", mqt_user, mqtt_password, nullptr, 0, false, nullptr, false))
{\cHFFFF}
Serial.println("verbunden");
}

MQT 5 Clients können Clean Start = 0 und Session Expiry Interval = 'N' auf Anfrage einstellen der MQTT Broker, um seine Sitzungsinformationen über Verbindungen für 'N' zu speichern Sekunden.

Für MQTT 5:

// MQTT Client Einstellungen
const char* client_id = "ESP32Client";
const bool clean_start = falsch;
const uint32_t session_expiry_interval = 3600; // Sitzungsablauf Intervall in Sekunden
AsyncMqtClient mqtClient;
Leere Verbindung ToWifi() {
Serial.println("Connecting to WiFi...");
WiFi.begin(ssid, passwort);
während (WiFi.status() != WL_CONNECTED {
Verzögerung(500)
Serial.print(");
}
Serial.println("WiFi verbunden");
}
ungültig aufMqtConnect(bool sessionPresent) {
Serial.println("Connected to MQTT.");
Serial.print("Session vorhanden: ");
Serial.println(sessionPresent);
// Abonnieren Sie Themen oder veröffentlichen Sie Nachrichten hier
// mqtClient.subscribe("your/topic", 0);
}
Nichtigkeitseinstellung() {\cHFFFF}
Serial.begin(115200);
ConnectToWifi();
mqtClient.onConnect(onMqtConnect);
mqtClient.onDisconnect(onMqtDisconnect);
mqttClient.setServer (mqtt_server, mqt_port);
mqttClient.setCredentials(mqtt_user, mqt_password);
// MQTT 5 Funktionen konfigurieren
mqtClient.setCleanSession(clean_start);
mqtClient.setSessionExpiry(session_expiry_interval);
mqtClient.connect(client_id);
}
Leerschleife() {\cHFFFF}
// Nichts zu tun, AsyncMqtClient behandelt alles
}

Maximal Packungsgröße

MQTT5 Client kann den MQTT Broker anfordern, nur Datenpakete weniger als ein spezifische Größe, indem Sie es so einstellen:

Für MQTT 5:

const char* data = „größte Daten zum Senden“;
const int chunkSize = 1024;
int dataLength = strlen(data);
int numChunks = (dataLength + chunkSize - 1) / chunkSize;
// Berechnen Sie die Anzahl der benötigten Stücke
für (in i = 0; i < numChunks; i++)
{\cHFFFF}
char chunk[chunkSize + 1]; // Buffer für chunk
// Kopieren von Daten in Puffer
strncpy(chunk, data + i * chunkSize, chunkSize);
chunk[chunkSize] = '\0'; // Null-terminieren Sie den String
// chunk als MQTT-Nachricht veröffentlichen
mqtClient.publish("large_data_topic", chunk, false); // falsch für QoS 0 Serial.print("Published chunk ");
}

Publizieren

Daten senden

Effizient Daten an mehrere Abonnenten verteilen, indem sie an benannte Abonnenten publiziert werden Themen mit dem folgenden Code-Snippet:

Für MQTT 3.1.1

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

Für MQTT 5

// Beispielverlag
String message = "Hallo, MQTT!";
mqtClient.publish("topic", 0, false, message.c_str());
}

Festhaltene Nachrichten einstellen

Aktivieren Sie die Rückhalte-Flag bei der Veröffentlichung einer Nachricht, um sicherzustellen, dass der Broker speichert die letzte Nachricht für jedes Thema. Dies garantiert, dass neue Abonnenten am meisten erhalten neue Nachricht beim Verbinden.

Um dies zu implementieren, verwenden Sie den folgenden Code snippet:

// Beispiel: Eine gespeicherte Nachricht alle 10 Sekunden veröffentlichen
statisch unbezeichnet lange lastPublish = 0;
wenn (millis() - lastPublish > 10000)
{\cHFFFF}
lastPublish = Mills();
wenn (mqttClient.publish("topic", "Device Status = 1", true))
{\cHFFFF}
Serial.println("Erhaltene Meldung erfolgreich veröffentlicht");
}
andere
{\cHFFFF}
Serial.println("Retained message pub fail");
}
}

QoS Levels angeben

MQTT bietet drei Ebenen der Qualität des Dienstes (QoS) für Nachrichtenaussendung:

QoS 0 (am meisten einmal)
QoS 1 (zumindest einmal)
QoS 2 (genau einmal)

Angabe der erforderlichenQoS-Ebenewenn MQTT-Nachrichten mit diesem Code veröffentlicht werden:

wenn (mqtClient.publish("topic", "Device status with DoS 0", false, 0))
{\cHFFFF}
Serial.println("Message mit QoS 0 erfolgreich veröffentlicht");
}
andere
{\cHFFFF}
Serial.println("Message mit QoS 0 veröffentlichen fehlgeschlagen");
}
// Eine Nachricht mit QoS 1 veröffentlichen
wenn (mqtClient.publish("topic", "Devicce status with QoS 1", false, 1))
{\cHFFFF}
Serial.println("Message mit QoS 1 erfolgreich veröffentlicht");
}
andere
{\cHFFFF}
Serial.println("Message mit QoS 1 veröffentlicht fehlgeschlagen");
}
// Eine Nachricht mit QoS 2 veröffentlichen
wenn (mqtClient.publish("topic", "Gerätestatus mit QoS 2", false, 2))
{\cHFFFF}
Serial.println("Message mit QoS 2 erfolgreich veröffentlicht");
}
andere
{\cHFFFF}
Serial.println("Message mit QoS 2 veröffentlichen fehlgeschlagen");
}

Nachricht abbrechen Intervall

Die Eigenschaft 'Message Ablaufintervall' setzt die Lebensdauer einer Nachricht in Sekunden; wenn undelivered innerhalb dieser Zeit, der Broker verworfen es. MQTT5 unterstützt diese Funktion. MQTT5 Clients können dies während der Veröffentlichung von Daten festlegen.

Für MQTT 5

int AuslaufInterval = 60;
const char* message = „device status messge“;
mqtClient.beginPublish(topic, strlen(message), falsch, AuslaufInterval *1000); // Ablaufintervall in Millisekunden
mqtClient.print(payload);
mqtClient.endPublish();

Thema Alias

Die Eigenschaft 'Topic Alias' ermöglicht es Kunden, einen kurzen Alias anstelle eines vollen den Namen des Themas, die Größe des Nachrichtenpakets und die Verbesserung der Netzeffizienz.

Für MQTT 5

// Thema Alias Maximalwert (bereinigt basierend auf MQTT-Brokerfunktionen)
In den Warenkorb MAX_TOPIC_ALIAS = 10;
const char* message = „Gerätestatusnachricht“;
// Veröffentlichen Sie mit dem Thema Alias, wenn der Broker unterstützt wird
mqtClient.beginPublish(topic, strlen(message), false);
mqtClient.writeTopic(topic); // Vollständige Themenbezeichnung veröffentlichen
mqtClient.writeTopicAlias(1); // Thema Alias einstellen, z.B. 1 mqtClient.print(message);
mqtClient.endPublish();

Eigenschaften, die mit MQTT PUBLISH verbunden sind, verbessern das Nachrichtenhandling, Bereitstellung von Kontext oder Anweisungen für Broker und Kunden. Diese Eigenschaften, einschließlich Meldung Ablauf Intervalle und Themen-Aliase, optimieren Nachrichtenversand und Netzwerkbandbreite.

Den Client deaktivieren

Stellen Sie sicher, dass die Verbindung Ihres Kunden mit dem Broker ordnungsgemäß beendet wird, um Probleme zu vermeiden und Ressourcenlecks auf beiden Seiten, wodurch die Systemstabilität erhalten bleibt.

Verwenden Sie den folgenden Code, um den Client vom Broker zu trennen:

mqtClient.disconnect();

Bauen Sie Ihre Business Logic

Sie haben die Möglichkeit, Ihre eigene komplizierte Geschäftslogik zu entwickeln und anzupassen in dieser Umgebung, genau auf Ihre spezifischen Bedürfnisse und Ziele zugeschnitten.

Implementierung von Best Practices

Einzigartiges Kunden-ID-Management

Jedem Gerät eine bestimmte Client-ID zur genauen Identifizierung zuweisen. Privat Einstellungen, bezeichnen einzigartige IDs für jeden Client. In geteilten Umgebungen fügen Sie jedem Client-ID einen zufälligen String an, um zu erhalten Einzigartigkeit.

Datendesign

Planen Sie Ihre Datenstruktur vorab strategisch. Ob Sie mit Klartext, JSON-formatierte Daten oder numerische Daten, stellen Sie sicher, dass das Design mit Ihrem Anwendungsbedarf und Anwendungsfall.

Robuste Fehlerbehandlung

Implementieren Sie eine starke Fehlerverwaltung mit MQTT-Verbindung Fehler, Abonnementprobleme und Nachrichtenveröffentlichungsfehler effektiv.

Sicherung von Anmeldeinformationen

Schutz sensibler Informationen wie Benutzernamen, Passwörter und Client-IDs durch nicht Sie in Ihrem Quellcode festcodieren. Verwenden Sie Umgebungsvariablen oder sicher Konfigurationsdateien statt.

Regelmäßige Prüfung und Überwachung

Kontinuierlich testen Sie MQTT-Kommunikation und überwachen Sie Client Metriken wie Verbindungsstatus, Nachrichtendurchsatz und Fehlerraten, um schnell zu identifizieren und Probleme beheben.

Optimierung des Sitzungsmanagements

Wählen Sie zwischen sauberen und persistenten Sessions (`clean: true` oder `clean: false`) basierend auf Ihrer Notwendigkeit, Abonnements und gelöschte Nachrichten über Client zu behalten Verbindungen.

Reconnect auf Disconnect

Code hinzufügen, um zu versuchen, die Verbindung zumMQTT Brokerwenn es eine unerwartete Trennung gibt. Dies wird sicherstellen, dass Ihr Kunde bleibt verbunden und verliert keine Daten.

Code herunterladen

Laden Sie den vollständigen Code für den Client herunter, der die ESP32 MQTT Client Library verwendet, um die Verbindung zu verbinden mit unsererMQTT Brokeroder einen Broker Ihrer Wahl.

Für MQTT 3.1.1

//Dieser Code liest den Verfügbarkeitsstatus und den Produktivitätsstatus der Maschine zu mqtbroker
//notwendige Bibliotheken enthalten
#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);
unbezeichnete lange EpocheZeit = 0;
unsigned long current Millis1 = 0;
const char* ssid = "xxxxxxxx"; // ersetzen xxx.. mit Ihrem WIFI SSID
const char* passwort = "xxxxxxxxxx"; // abheben mit WIFI Passwort
const char* mqt_server = "xxxxxxxxxxxxx"; //MQTT Servername
const char* mqt_user = "xxxxxxxxxxxxx"; //MQTT Broker Benutzername
const char* mqtt_password = "xxxxxxxxxx"; //MQTT Broker-Passwort
const int ProxSenPin = 33; // Verfügbarkeitsstatus gelesen
const int ProduktivitätPin = 26; // Leistungsstatus gelesen
unbezeichnete lange Aggregation Intervall = 60000; // 1 Minute
unsigned int availabilityValues[60]; // Verfügbarkeit und Produktivität speichern Werte für 1 Minuten
// unsigned int changeoverWerte[300];
nicht zugewiesener IntwertIndex = 0;
int availability = 0;
Int Produktivität = 1;
Bohnen Flagge = falsch;
nicht zugewiesen lange getTime()
{\cHFFFF}
time_t jetzt;
Serial.println("inside gettime");
struct tm timeinfo;
wenn (!getLocalTime(&timeinfo))
{\cHFFFF}
Serial.println("Failed to get time");
getTime();
}
Zeit(&now);
zurück;
}
// Um die Verfügbarkeit der Maschine zu lesen
IRAM_ATTR availIsr()
{\cHFFFF}
Verfügbarkeit = digitalRead(ProxSenPin) ? 0 : 1; //Gerätearbeiten bei negataive Logik
}
// Die Produktivität der Maschine lesen
Leere IRAM_ATTR produzierenIsr()
{\cHFFFF}
produzierenFlag = digitalRead(productivityPin) ? falsch : wahr;
}
//Verbindung mit mqtt Broker
Leere VerbindungToMqt()
{\cHFFFF}
während (!client.connected()
{\cHFFFF}
Serial.println("Connecting to MQTT...");
wenn (client.connect("ProxSen", mqtt_user, mqt_password))
{\cHFFFF}
Serial.println("Connected to MQTT");
}
andere
{\cHFFFF}
Serial.print("Failed to connect to MQTT, rc=");
Seufzer
rial.print(client.state());
Serial.println(" Wiederaufnahme in 5 Sekunden...");
Verzögerung(5000);
}
}
Nichtigkeitseinstellung()
{\cHFFFF}
Serial.begin(115200);
//Konfigurieren WIFI-Verbindung
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, passwort);
während (WiFi.status() != WL_CONNECTED)
{\cHFFFF}
Verzögerung(5000);
Serial.print(");
}
Serial.println("WiFi verbunden");
//Konfigurieren Sie MQTTBroker
client.setServer(mqt_server,1883);
configTime(0, 0, ntpServer);
epochTime = getTime();
verbindenToMqt();
pinMode(ProxSenPin, INPUT);
AttachInterrupt(digitalPinToInterrupt(ProxSenPin), availIsr, CHANGE);
pinMode (ProduktivitätPin, INPUT);
AttachInterrupt(digitalPinToInterrupt(ProduktivitätPin), productionIsr, ÄNDERUNG;
Verfügbarkeit = digitalRead(ProxSenPin)?0:1;
Verzögerung(25)
}
Leerschleife()
{\cHFFFF}
epochTime = epochTime + 1;
availabilityValues[valueIndex] = Verfügbarkeit;
WertIndex++;
//Veröffentlichen Sie die Produktionsdaten zum Teil
wenn(produzierenFlag)
{\cHFFFF}
DynamischeJsonDocument jsonDocument1(1000)
String json Produktivität;
produzierenFlag = falsch;
jsonDocument1["production_status"] = 1;
jsonDocument1["timestamp"] = epochTime;
serializeJson(jsonDocument1,jsonProduktivität);
wenn (!client.connected())
{\cHFFFF}
verbindenToMqt();
}
client.publish("ProxSen/Produktivität",jsonProductivity.c_str());
}
// Maschinenstatus alle 5 Sekunden
wenn(millis() - currentMillis1 >= 5000)
{\cHFFFF}
aktuelleMillis1 = Mills();
DynamischeJsonDocument jsonDocument2(1000)
String json AvailStatus;
jsonDocument2["machine_status"] = Verfügbarkeit;
jsonDocument2["timestamp"] = epochTime;
serializeJson(jsonDocument2,jsonAvailStatus);
wenn (!client.connected())
{\cHFFFF}
verbindenToMqt();
}
client.publish("ProxSen/machine_status", jsonAvailStatus.c_str());
}
Verzögerung(1000)
}

Für MQTT 5

#include <Arduino.h>
#include <WiFi.h>
#include <AsyncMqtClient.h>
#include <ArduinoJson.h>
#include "time.h"
// WiFi Anmeldeinformationen
const char* ssid = "your_SSID"; // Ersetzen Sie mit Ihrem WLAN SSID
const char* Passwort = "your_PASSWORD"; // Ersetzen Sie mit Ihrem WLAN Passwort vergessen?
// MQTT Broker Einstellungen const char* mqt_server = "public-mqtt-broker.bevywise.com"; // MQTT Broker Servername
const uint16_t mqt_port = 1883; // MQTT-Brokerport (verwenden 1883 für Nicht-TLS)
const char* mqt_user = "your_mqtt_username"; // MQTT Broker Benutzername
const char* mqt_password = "your_mqtt_password"; // MQTT Broker Passwort vergessen?
// MQTT Client Einstellungen
const char* client_id = "ESP32Client";
AsyncMqtClient mqtClient;
WiFiClient wifiClient;
unbezeichnete lange EpocheZeit = 0;
unsigned long current Millis1 = 0;
const char* ntpServer = "time.google.com"
const int ProxSenPin = 33; // Statuspin Verfügbarkeit
int Produktivität Pin = 26; // Produktivität Status Pin
unbezeichnete lange Aggregation Intervall = 60000; // 1 Minute
unsigned int availabilityValues[60]; // Verfügbarkeitswerte für 1 speichern Minute
nicht zugewiesener IntwertIndex = 0;
int availability = 0;
Bohnen Flagge = falsch;
IRAM_ATTR availIsr() {
Verfügbarkeit = digitalRead(ProxSenPin) ? 0 : 1; // Inverse Logik (negativ) Logik
}
Leere IRAM_ATTR produzierenIsr() {
produzierenFlag = digitalRead(productivityPin) ? falsch : wahr;
}
Leere VerbindungToMqt() {
Serial.println("Connecting to MQTT...");
mqtClient.connect();
}
unsigned long getTime() {
time_t jetzt;
struct tm timeinfo;
wenn (!getLocalTime(&timeinfo)) {\cHFFFF}
Serial.println("Failed to get time");
getTime();
}
Zeit(&now);
zurück;
}
ungültig aufMqtConnect(bool sessionPresent) {
Serial.println("Connected to MQTT.");
Serial.print("Session vorhanden: ");
Serial.println(sessionPresent);
// Abonnieren Sie notwendige Themen bei Bedarf
mqtClient.subscribe("ProxSen/#");
// Beispielveröffentlichung auf Connect (falls erforderlich)
String message = "Hallo, MQTT!";
mqtClient.publish("ProxSen/test", 0, false, message.c_str());
}
nichtig aufMqtDisconnect(AsyncMqttClientDisconnectReason Grund) {
Serial.println("Disconnected from MQTT.");
wenn (WiFi.isConnected()) {\cHFFFF}
verbindenToMqt();
}
}
Nichtigkeitseinstellung() {\cHFFFF}
Serial.begin(115200);
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, passwort);
während (WiFi.status() != WL_CONNECTED {
Verzögerung(500)
Serial.print(");
}
Serial.println("WiFi verbunden");
mqttClient.setServer (mqtt_server, mqt_port);
mqttClient.setCredentials(mqtt_user, mqt_password);
mqtClient.setClientId(client_id);
mqtClient.onConnect(onMqtConnect);
mqtClient.onDisconnect(onMqtDisconnect);
// Konfigurieren MQTT 5 spezifische Einstellungen (optional)
mqtClient.setCleanSession(true); // Stellen Sie saubere Sitzung zu wahr oder falsch basierend auf Ihrer Anforderung
// MQTT-Broker verbinden
verbindenToMqt();
// Setup-Interrupts für Verfügbarkeit und Produktivität
pinMode(ProxSenPin, INPUT);
AttachInterrupt(digitalPinToInterrupt(ProxSenPin), availIsr, CHANGE);
pinMode (ProduktivitätPin, INPUT);
AttachInterrupt(digitalPinToInterrupt(ProduktivitätPin), productionIsr, ÄNDERUNG;
Verfügbarkeit = digitalRead(ProxSenPin) ? 0 : 1;
Verzögerung(25)
}
Leerschleife() {\cHFFFF}
epochTime = epochTime + 1;
availabilityValues[valueIndex] = Verfügbarkeit;
WertIndex++;
// Produktivitätsdaten veröffentlichen, wenn die ProduktionFlag eingestellt ist
wenn (produceFlag) {
DynamischeJsonDocument jsonDocument1(1000)
String json Produktivität;
produzierenFlag = falsch;
jsonDocument1["production_status"] = 1;
jsonDocument1["timestamp"] = epochTime;
serializeJson(jsonDocument1, jsonProductivity);
wenn (mqtClient.connected()) {\cHFFFF}
mqtClient.publish("ProxSen/Produktivität", 0, falsch, jsonProductivity.c_str()
}
}
// Maschinenstatus alle 5 Sekunden veröffentlichen
wenn (millis() - currentMillis1 >= 5000) {
aktuelleMillis1 = Mills();
DynamischeJsonDocument jsonDocument2(1000)
String json AvailStatus;
jsonDocument2["machine_status"] = Verfügbarkeit;
jsonDocument2["timestamp"] = epochTime;
serializeJson(jsonDocument2, jsonAvailStatus);
wenn (mqtClient.connected()) {\cHFFFF}
mqtClient.publish("ProxSen/machine_status", 0, false, jsonAvailStatus.c_str()
}
}
// Handle MQTT-Client-Bibliothek lebendig und Nachrichtenverarbeitung
wenn (mqtClient.connected()) {\cHFFFF}
mqttClient.loop();
} auch
verbindenToMqt();
}
Verzögerung(1000)
}

Ausführender Bundle erstellen

Schritte zum Flashen des Codes in ESP32

Im Folgenden sind die Schritte, um den Code in den ESP32 Prozessor hochzuladen :

Bereiten Sie das Brett vor: Halten Sie die Boot-Taste festgestellt, drücken Sie dann und lösen Sie sind hier: Knopf.
Wählen Sie das Board und den Port: Gehen Sie zu Tools, dann Port und wählen Sie das ESP32 dev Modul und den richtigen COM-Port. Wenn Sie sich nicht sicher sind, genießen Sie die Auswahl eins und sehen, ob es funktioniert.
ANHANG Sie den Code: Sie auf das Symbol Verify in der oberen linken Ecke, um den Code zu kompilieren und auf Fehler behoben.
Den Code hochladen: Sie auf das Upload-Symbol, um den Code erneut zu kompilieren und ihn auf das ESP32.
ANHANG Sie die Ausgabe: Sie den seriellen Monitor, um die Ausgabe zu sehen. Wenn Sie das tun Gibberish, Sie müssen möglicherweise die Baudrate ändern, um den Code und die serielle Monitor.

Verbinden Sie Ihren Kunden mit unserem hochmodernenMQTT Brokeroder einen Broker Ihrer Wahl. Diese leistungsstarke Kombination sorgt für optimale Leistung und Zuverlässigkeit für alle Ihre Messaging-Anforderungen, den Weg für eine robuste und effiziente Systemintegration.

MQTT Connectors

Industrielösungen

MQT Integration

Anschluss von MQTT-Clients über ESP32

Einleitung

Voraussetzungen

Dependance Installation

Anschluss an MQTT Broker

Erweiterte Funktionen

Publizieren

Anmeldung

Den Client deaktivieren

Bauen Sie Ihre Business Logic

Implementierung von Best Practices

Code herunterladen

Ausführender Bundle erstellen

Bitte beachten Sie: