ESP32 - MQTT
In diesem Tutorial werden wir untersuchen, wie man den ESP32 verwendet, um Daten an einen MQTT-Broker zu senden und von diesem zu empfangen, wobei das MQTT-Protokoll verwendet wird. Genauer gesagt werden wir Folgendes behandeln:
- Herstellung einer Verbindung zwischen dem ESP32 und einem MQTT-Broker.
- Programmieren des ESP32, Daten an einen MQTT-Broker zu senden, indem Daten auf einem MQTT-Thema veröffentlicht werden.
- Programmieren des ESP32, Daten zu empfangen, indem es sich auf ein MQTT-Thema abonniert.
Wir werden uns mit zwei unterschiedlichen Szenarien befassen:
- ESP32 mit einem Online-MQTT-Broker.
- ESP32 mit einem MQTT-Broker, der auf deinem PC installiert ist.
Erforderliche Hardware
Oder Sie können die folgenden Kits kaufen:
| 1 | × | DIYables ESP32 Starter-Kit (ESP32 enthalten) | |
| 1 | × | DIYables Sensor-Kit (30 Sensoren/Displays) | |
| 1 | × | DIYables Sensor-Kit (18 Sensoren/Displays) |
Offenlegung: Einige der in diesem Abschnitt bereitgestellten Links sind Amazon-Affiliate-Links. Wir können eine Provision für Käufe erhalten, die über diese Links getätigt werden, ohne zusätzliche Kosten für Sie. Wir schätzen Ihre Unterstützung.
Über ESP32 und MQTT
Wenn Sie bereits mit dem MQTT-Protokoll vertraut sind, großartig! Wenn nicht, können Sie online nachschlagen. Dieses Tutorial dreht sich ganz darum, den ESP32 zu verwenden, um Daten mit MQTT zu senden und zu empfangen.
Hier sind einige Möglichkeiten, wie der ESP32 mit MQTT arbeiten kann:
- Verbinde den ESP32 mit einem Online-MQTT-Broker wie Mosquitto oder AWS IoT.
- Verbinde den ESP32 mit einem MQTT-Broker, der auf deinem Computer installiert ist, z. B. Mosquitto oder HiveMQ.
- Verbinde den ESP32 mit einem MQTT-Broker, der auf deinem Raspberry Pi läuft, zum Beispiel Mosquitto.
- Verbinde den ESP32 mit einem cloud-basierten MQTT-Broker, wie Mosquitto oder HiveMQ auf AWS EC2.
In diesem Tutorial beginnen wir damit zu prüfen, ob der ESP32 eine Verbindung zu einem Online-Mosquitto-Broker herstellen kann. Wir ermöglichen dem ESP32, Daten über diesen Broker über das Internet zu senden und zu empfangen.
Danach richten wir den Mosquitto-Broker auf unserem Computer ein. Wir verbinden den ESP32 mit diesem lokalen Broker und setzen das Senden und Empfangen von Daten fort.
Sobald du dieses Tutorial abgeschlossen hast, kannst du mehr entdecken, indem du dir diese anderen Tutorials anschaust:
Diese Links geben Ihnen weitere Hinweise zu verwandten Themen.
Verbinde den ESP32 mit einem Online-MQTT-Broker
In diesem Teil lernen wir, wie man den ESP32 mit test.mosquitto.org verbindet, einem Online-MQTT-Broker, der von Mosquitto betrieben wird. Bitte beachten Sie, dass dieser Broker nur zu Testzwecken verwendet werden sollte.
ESP32-Code
Der untenstehende ESP32-Code führt Folgendes aus:
- Mit dem MQTT-Broker verbinden
- Ein Thema abonnieren
- Periodisch Nachrichten auf demselben Thema veröffentlichen, das es abonniert
/*
* Dieser ESP32 Code wurde von newbiely.de entwickelt
* Dieser ESP32 Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/esp32/esp32-mqtt
*/
#include <WiFi.h>
#include <MQTTClient.h>
#include <ArduinoJson.h>
const char WIFI_SSID[] = "YOUR_WIFI_SSID"; // CHANGE TO YOUR WIFI SSID
const char WIFI_PASSWORD[] = "YOUR_WIFI_PASSWORD"; // CHANGE TO YOUR WIFI PASSWORD
const char MQTT_BROKER_ADRRESS[] = "test.mosquitto.org"; // CHANGE TO MQTT BROKER'S ADDRESS
const int MQTT_PORT = 1883;
const char MQTT_CLIENT_ID[] = "YOUR-NAME-esp32-001"; // CHANGE IT AS YOU DESIRE
const char MQTT_USERNAME[] = ""; // CHANGE IT IF REQUIRED, empty if not required
const char MQTT_PASSWORD[] = ""; // CHANGE IT IF REQUIRED, empty if not required
// The MQTT topics that ESP32 should publish/subscribe
const char PUBLISH_TOPIC[] = "YOUR-NAME-esp32-001/loopback"; // CHANGE IT AS YOU DESIRE
const char SUBSCRIBE_TOPIC[] = "YOUR-NAME-esp32-001/loopback"; // CHANGE IT AS YOU DESIRE
const int PUBLISH_INTERVAL = 5000; // 5 seconds
WiFiClient network;
MQTTClient mqtt = MQTTClient(256);
unsigned long lastPublishTime = 0;
void setup() {
Serial.begin(9600);
// set the ADC attenuation to 11 dB (up to ~3.3V input)
analogSetAttenuation(ADC_11db);
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
Serial.println("ESP32 - Connecting to Wi-Fi");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println();
connectToMQTT();
}
void loop() {
mqtt.loop();
if (millis() - lastPublishTime > PUBLISH_INTERVAL) {
sendToMQTT();
lastPublishTime = millis();
}
}
void connectToMQTT() {
// Connect to the MQTT broker
mqtt.begin(MQTT_BROKER_ADRRESS, MQTT_PORT, network);
// Create a handler for incoming messages
mqtt.onMessage(messageHandler);
Serial.print("ESP32 - Connecting to MQTT broker");
while (!mqtt.connect(MQTT_CLIENT_ID, MQTT_USERNAME, MQTT_PASSWORD)) {
Serial.print(".");
delay(100);
}
Serial.println();
if (!mqtt.connected()) {
Serial.println("ESP32 - MQTT broker Timeout!");
return;
}
// Subscribe to a topic, the incoming messages are processed by messageHandler() function
if (mqtt.subscribe(SUBSCRIBE_TOPIC))
Serial.print("ESP32 - Subscribed to the topic: ");
else
Serial.print("ESP32 - Failed to subscribe to the topic: ");
Serial.println(SUBSCRIBE_TOPIC);
Serial.println("ESP32 - MQTT broker Connected!");
}
void sendToMQTT() {
StaticJsonDocument<200> message;
message["timestamp"] = millis();
message["data"] = analogRead(0); // Or you can read data from other sensors
char messageBuffer[512];
serializeJson(message, messageBuffer);
mqtt.publish(PUBLISH_TOPIC, messageBuffer);
Serial.println("ESP32 - sent to MQTT:");
Serial.print("- topic: ");
Serial.println(PUBLISH_TOPIC);
Serial.print("- payload:");
Serial.println(messageBuffer);
}
void messageHandler(String &topic, String &payload) {
Serial.println("ESP32 - received from MQTT:");
Serial.println("- topic: " + topic);
Serial.println("- payload:");
Serial.println(payload);
}
Schnelle Schritte
- Falls du ESP32 zum ersten Mal verwendest, siehe wie man die Umgebung für ESP32 in der Arduino-IDE einrichtet.
- Schließe die Verkabelung wie im obigen Bild an.
- Schließe das ESP32-Board über ein USB-Kabel an deinen PC an.
- Öffne die Arduino-IDE auf deinem PC.
- Wähle das richtige ESP32-Board (z. B. ESP32 Dev Module) und den COM-Port aus.
- Öffne die Arduino-IDE auf deinem PC.
- Öffne den Library Manager, indem du auf das Library Manager-Symbol in der linken Navigationsleiste der Arduino-IDE klickst.
- Gib MQTT in das Suchfeld ein, und suche dann nach der MQTT-Bibliothek von Joel Gaehwiler.
- Klicke auf den Install-Button, um die MQTT-Bibliothek zu installieren.
- Geben Sie ArduinoJson in das Suchfeld ein, und suchen Sie danach nach der ArduinoJson-Bibliothek von Benoit Blanchon.
- Klicken Sie auf die Schaltfläche Installieren, um die ArduinoJson-Bibliothek zu installieren.
- Kopieren Sie den obigen Code und öffnen Sie ihn in der Arduino IDE
- Ersetzen Sie die WLAN-Informationen (SSID und Passwort) im Code durch Ihre eigenen.
- Im Code sehen Sie dreimal das Wort 'YOUR-NAME'. Ersetzen Sie dieses Wort durch Ihren Namen oder zufällige Zeichen (nur Buchstaben, keine Leerzeichen). Dies ist notwendig, denn wenn Sie die Änderung nicht vornehmen, kann es mehrere Personen geben, die denselben Code gleichzeitig ausführen, was zu Konflikten führen könnte, da die MQTT-Client-IDs und -Themen für alle gleich sind.
- Klicken Sie auf den Upload-Button in der Arduino IDE, um den Code auf den ESP32 hochzuladen.
- Öffnen Sie den seriellen Monitor.
- Sehen Sie das Ergebnis im seriellen Monitor.
COM6
ESP32 - Connecting to MQTT broker
ESP32 - Subscribed to the topic: YOUR-NAME-esp32-001/loopback
ESP32 - MQTT broker Connected!
ESP32 - sent to MQTT:
- topic: YOUR-NAME-esp32-001/loopback
- payload:{"timestamp":11757,"data":255}
ESP32 - received from MQTT:
- topic: YOUR-NAME-esp32-001/loopback
- payload:
{"timestamp":11757,"data":255}
ESP32 - sent to MQTT:
- topic: YOUR-NAME-esp32-001/loopback
- payload:{"timestamp":16896,"data":259}
ESP32 - received from MQTT:
- topic: YOUR-NAME-esp32-001/loopback
- payload:
{"timestamp":16896,"data":259}
Autoscroll
Clear output
9600 baud
Newline
Wie Sie beobachten können, veröffentlicht der ESP32 Nachrichten an den MQTT-Broker und erhält anschließend dieselbe Nachricht zurück. Dies geschieht, weil der bereitgestellte Code dasselbe Thema abonniert, auf das er Daten veröffentlicht. Wenn Sie nicht möchten, dass der ESP32 die von ihm veröffentlichten Nachrichten empfängt, können Sie dies einfach erreichen, indem Sie das Abonnement-Thema vom Veröffentlichungs-Thema unterscheiden.
Verbinde den ESP32 mit dem MQTT-Broker, der auf deinem PC installiert ist
Mosquitto MQTT-Broker installieren
- Lade den Mosquitto MQTT-Broker herunter (https://mosquitto.org/download/)
- Installiere ihn auf dem Laufwerk D: statt auf dem Laufwerk C:. Vermeide es, den Mosquitto-Broker auf dem Laufwerk C: zu installieren, um potenzielle Probleme zu vermeiden.
Mosquitto MQTT-Broker starten
Nun prüfen wir, ob der MQTT-Broker ordnungsgemäß funktioniert, indem wir diese Schritte befolgen:
- Gehe in das Verzeichnis, in dem Mosquitto installiert wurde. Zum Beispiel: D:\Draft\mosquitto>
- Erstelle eine neue Datei mit dem Namen test.conf, kopiere den untenstehenden Inhalt hinein und speichere sie in diesem Verzeichnis:
listener 1883
allow_anonymous true
- Öffnen Sie die Eingabeaufforderung als Administrator auf Ihrem PC. Nennen wir es Broker Window. Schließen Sie es nicht bis zum Ende des Tutorials.
- Führe die untenstehenden Befehle nacheinander aus:
cd /d D:\Draft\mosquitto
mosquitto -v -c test.conf
- Sie werden sehen:
Command Prompt
Microsoft Windows [Version 10.0.19045.3930]
(c) Microsoft Corporation. All rights reserved.
C:\WINDOWS\system32>cd /d D:\Draft\mosquitto
D:\Draft\mosquitto>mosquitto -v -c test.conf
1710918939: mosquitto version 2.0.18 starting
1710918939: Config loaded from test.conf.
1710918939: Opening ipv6 listen socket on port 1883.
1710918939: Opening ipv4 listen socket on port 1883.
1710918939: mosquitto version 2.0.18 running
- Öffnen Sie eine weitere Eingabeaufforderung als Administrator auf Ihrem PC.
- Finden Sie die IP-Adresse Ihres PCs, indem Sie den untenstehenden Befehl ausführen:
ipconfig
Command Prompt
C:\WINDOWS\system32>ipconfig
Windows IP Configuration
Ethernet adapter:
Subnet Mask . . . . . . . . . . . : 255.0.0.0
IPv4 Address. . . . . . . . . . . : 192.168.0.26
Subnet Mask . . . . . . . . . . . : 255.255.255.0
Default Gateway . . . . . . . . . :
- Schreibe die IP-Adresse für späteren Gebrauch auf. Im obigen Beispiel: 192.168.0.26
Prüfe, ob der Mosquitto-Broker funktioniert
- Öffnen Sie eine weitere Eingabeaufforderung als Administrator auf Ihrem PC. Nennen wir es Abonnentenfenster
- Abonnieren Sie ein Thema, indem Sie die untenstehenden Befehle nacheinander ausführen (ersetzen Sie sie durch Ihre IP-Adresse):
cd /d D:\Draft\mosquitto
mosquitto_sub -h 192.168.0.26 -p 1883 -t esp32-001/send
- Öffnen Sie eine weitere Eingabeaufforderung als Administrator auf Ihrem PC. Nennen wir sie Publisher Window
- Veröffentlichen Sie eine Nachricht auf demselben Thema, indem Sie die untenstehenden Befehle der Reihe nach ausführen (ersetzen Sie es durch Ihre IP-Adresse):
cd /d D:\Draft\mosquitto
mosquitto_pub -h 192.168.0.26 -p 1883 -t esp32-001/send -m "Hello, MQTT!"
- Sie werden sehen:
Command Prompt
Microsoft Windows [Version 10.0.19045.3930]
(c) Microsoft Corporation. All rights reserved.
C:\WINDOWS\system32>cd /d D:\Draft\mosquitto
D:\Draft\mosquitto>mosquitto_pub -h 192.168.0.26 -p 1883 -t esp32-001/send -m "Hello, MQTT!"
D:\Draft\mosquitto>
Sie werden sehen, dass diese Nachricht an das Abonnentenfenster wie folgt weitergeleitet wird:
Command Prompt
Microsoft Windows [Version 10.0.19045.3930]
(c) Microsoft Corporation. All rights reserved.
C:\WINDOWS\system32>cd /d D:\Draft\mosquitto
D:\Draft\mosquitto>mosquitto_sub -h 192.168.0.26 -p 1883 -t esp32-001/send
Hello, MQTT!
Jetzt haben Sie den Mosquitto MQTT-Broker erfolgreich auf Ihrem PC installiert. Bitte schließen Sie NICHT drei Fenster: Broker-Fenster, Abonnent-Fenster und Publisher-Fenster. Wir werden sie als Nächstes verwenden.
ESP32-Quellcode
Der untenstehende ESP32-Code macht Folgendes:
- Verbinde dich mit dem MQTT-Broker
- Abonniere ein Topic
- Veröffentliche periodisch Nachrichten an ein anderes Topic
/*
* Dieser ESP32 Code wurde von newbiely.de entwickelt
* Dieser ESP32 Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/esp32/esp32-mqtt
*/
#include <WiFi.h>
#include <MQTTClient.h>
#include <ArduinoJson.h>
#define CLIENT_ID "ESP32-001" // CHANGE IT AS YOU DESIRE
const char WIFI_SSID[] = "YOUR_WIFI_SSID"; // CHANGE TO YOUR WIFI SSID
const char WIFI_PASSWORD[] = "YOUR_WIFI_PASSWORD"; // CHANGE TO YOUR WIFI PASSWORD
const char MQTT_BROKER_ADRRESS[] = "192.168.0.26"; // CHANGE TO MQTT BROKER'S IP ADDRESS
const int MQTT_PORT = 1883;
const char MQTT_USERNAME[] = ""; // CHANGE IT IF REQUIRED
const char MQTT_PASSWORD[] = ""; // CHANGE IT IF REQUIRED
// The MQTT topics that this device should publish/subscribe
#define PUBLISH_TOPIC "esp32-001/send"
#define SUBSCRIBE_TOPIC "esp32-001/receive"
#define PUBLISH_INTERVAL 5000 // 4 seconds
WiFiClient network;
MQTTClient mqtt = MQTTClient(256);
unsigned long lastPublishTime = 0;
void setup() {
Serial.begin(9600);
// set the ADC attenuation to 11 dB (up to ~3.3V input)
analogSetAttenuation(ADC_11db);
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
Serial.println("ESP32 - Connecting to Wi-Fi");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println();
connectToMQTT();
}
void loop() {
mqtt.loop();
if (millis() - lastPublishTime > PUBLISH_INTERVAL) {
sendToMQTT();
lastPublishTime = millis();
}
}
void connectToMQTT() {
// Connect to the MQTT broker
mqtt.begin(MQTT_BROKER_ADRRESS, MQTT_PORT, network);
// Create a handler for incoming messages
mqtt.onMessage(messageHandler);
Serial.print("ESP32 - Connecting to MQTT broker");
while (!mqtt.connect(CLIENT_ID, MQTT_USERNAME, MQTT_PASSWORD)) {
Serial.print(".");
delay(100);
}
Serial.println();
if (!mqtt.connected()) {
Serial.println("ESP32 - MQTT broker Timeout!");
return;
}
// Subscribe to a topic, the incoming messages are processed by messageHandler() function
if (mqtt.subscribe(SUBSCRIBE_TOPIC))
Serial.print("ESP32 - Subscribed to the topic: ");
else
Serial.print("ESP32 - Failed to subscribe to the topic: ");
Serial.println(SUBSCRIBE_TOPIC);
Serial.println("ESP32 - MQTT broker Connected!");
}
void sendToMQTT() {
StaticJsonDocument<200> message;
message["timestamp"] = millis();
message["data"] = analogRead(0); // Or you can read data from other sensors
char messageBuffer[512];
serializeJson(message, messageBuffer);
mqtt.publish(PUBLISH_TOPIC, messageBuffer);
Serial.println("ESP32 - sent to MQTT:");
Serial.print("- topic: ");
Serial.println(PUBLISH_TOPIC);
Serial.print("- payload:");
Serial.println(messageBuffer);
}
void messageHandler(String &topic, String &payload) {
Serial.println("ESP32 - received from MQTT:");
Serial.println("- topic: " + topic);
Serial.println("- payload:");
Serial.println(payload);
// You can process the incoming data as json object, then control something
/*
StaticJsonDocument<200> doc;
deserializeJson(doc, payload);
const char* message = doc["message"];
*/
}
Schnelle Schritte
- Kopiere den obigen Code und öffne ihn mit der Arduino-IDE
- Ersetze die WiFi-Informationen (SSID und Passwort) im Code durch deine eigenen.
- Ersetze die MQTT-Broker-Adresse im Code (Domänenname oder IP-Adresse).
- Klicke auf die Schaltfläche Hochladen in der Arduino-IDE, um den Code auf den ESP32 hochzuladen
Nachricht vom ESP32 zum PC über MQTT senden
Der ESP32-Code veröffentlicht Daten auf dem MQTT-Thema esp32-001/send, Abonnentenfenster auf dem PC abonniert dieses Thema, um die Daten zu empfangen.
- Öffnen Sie den seriellen Monitor. Sie werden sehen, dass der ESP32 periodisch eine Nachricht an ein Topic veröffentlicht.
COM6
ESP32 - Connecting to MQTT broker
ESP32 - Subscribed to the topic: esp32-001/receive
ESP32 - MQTT broker Connected!
ESP32 - sent to MQTT:
- topic: esp32-001/send
- payload:{"timestamp":10708,"data":311}
ESP32 - sent to MQTT:
- topic: esp32-001/send
- payload:{"timestamp":15837,"data":298}
ESP32 - sent to MQTT:
- topic: esp32-001/send
- payload:{"timestamp":20965,"data":291}
ESP32 - sent to MQTT:
- topic: esp32-001/send
- payload:{"timestamp":26094,"data":286}
Autoscroll
Clear output
9600 baud
Newline
- Überprüfen Sie das Abonnentenfenster, dort sehen Sie, dass es die vom ESP32 veröffentlichte Nachricht wie unten zu sehen empfängt:
Command Prompt
Microsoft Windows [Version 10.0.19045.3930]
(c) Microsoft Corporation. All rights reserved.
C:\WINDOWS\system32>cd /d D:\Draft\mosquitto
D:\Draft\mosquitto>mosquitto_sub -h 192.168.0.26 -p 1883 -t esp32-001/send
Hello, MQTT!
{"timestamp":10708,"data":311}
{"timestamp":15837,"data":298}
{"timestamp":20965,"data":291}
{"timestamp":26094,"data":286}
Nachricht vom PC zum ESP32 über MQTT senden
Der ESP32 abonniert das Thema esp32-001/receive, Publisher Window auf dem PC veröffentlicht eine Nachricht an dieses Thema, um sie an den ESP32 zu senden.
- Veröffentlichen Sie eine Nachricht an das Thema, das der ESP32 abonniert hat, indem Sie den folgenden Befehl im Publisher Window ausführen:
mosquitto_pub -h 192.168.0.26 -p 1883 -t esp32-001/receive -m "Hello, ESP32!"
- Sie werden sehen, dass diese Nachricht vom ESP32 im Serial Monitor wie unten gezeigt empfangen wird:
COM6
ESP32 - received from MQTT:
- topic: esp32-001/receive
- payload:
Hello, ESP32!
Autoscroll
Clear output
9600 baud
Newline
Video Tutorial
Wir erwägen die Erstellung von Video-Tutorials. Wenn Sie Video-Tutorials für wichtig halten, abonnieren Sie bitte unseren YouTube-Kanal , um uns zu motivieren, die Videos zu erstellen.