Gidsen · 17 min leestijd

ESP32 MQTT-tutorial: Mosquitto, Home Assistant en ESPHome

ESP32 MQTT-tutorial: installeer Mosquitto, publiceer sensordata en bestuur een relais met PubSubClient, Home Assistant discovery, een ESPHome-YAML-voorbeeld en QoS.

Een ESP32 met MQTT is de meest gebruikte manier om de sensoren en relais in huis met elkaar te laten praten en met een smarthomesysteem zoals Home Assistant. MQTT is een lichtgewicht berichtenprotocol voor kleine apparaten: de ESP32 zet de gemeten temperatuur in een topic zoals "ev/salon/sicaklik" en elk programma dat naar dat topic luistert, ontvangt de waarde direct. Zo komt ook het "ON"-commando, als je in de Home Assistant-app op je telefoon op een knop tikt, in veel minder dan een seconde bij de ESP32 aan en schakelt het relais. Anders dan HTTP opent MQTT niet voor elk verzoek een nieuwe verbinding; het werkt over één open verbinding met headers van maar twee bytes, dus het is snel en zuinig voor zowel wifi als processor.

In deze gids bouw je vanaf nul een werkende smarthome-node. Eerst leer je de MQTT-begrippen broker, topic, publish en subscribe, daarna installeer je de Mosquitto-broker in Home Assistant of op een Raspberry Pi. Vervolgens gebruik je de PubSubClient-bibliotheek om DHT22-metingen van temperatuur en luchtvochtigheid vanaf een ESP32 te publiceren, naar relaiscommando's te luisteren en MQTT Discovery toe te voegen, zodat het apparaat vanzelf in Home Assistant verschijnt. We behandelen ook QoS en retain, het last-will-bericht (LWT) dat het apparaat als "niet beschikbaar" markeert als de verbinding wegvalt, het ESPHome-alternatief dat hetzelfde doet zonder één regel C++, de verschillen bij de ESP8266 en Raspberry Pi Pico W en de meest voorkomende fouten stuk voor stuk.

ESP32-ontwikkelboard dat via MQTT met Home Assistant is verbonden
Dankzij de ingebouwde wifi maakt de ESP32 rechtstreeks verbinding met de MQTT-broker op je thuisnetwerk; sensordata en relaiscommando's lopen over dezelfde verbinding.

Wat is MQTT en hoe werkt het?

MQTT (Message Queuing Telemetry Transport) werkt volgens het publish/subscribe-model. In het midden staat een server die de broker heet; de ESP32, Home Assistant, je telefoon of een programma op je computer verbinden zich daarmee als clients. Clients kennen elkaar en elkaars IP-adressen niet: de een publiceert een bericht naar een topic en de broker stuurt het door naar iedereen die op dat topic is geabonneerd. Zie het als een postkantoor: de ESP32 gooit een brief in de bus met het adres "ev/salon/sicaklik" en Home Assistant, die op die bus let, krijgt hem meteen. Omdat de client altijd de verbinding opent, heeft de ESP32 geen vast IP-adres of open poort op je router nodig; hij hoeft alleen het adres van de broker te kennen.

BegripWat het doetVoorbeeld
BrokerDe server die berichten ontvangt en aan abonnees verdeeltMosquitto, de Mosquitto-broker in Home Assistant
ClientElk apparaat of programma dat verbinding maakt met de broker; elk heeft een unieke client-IDESP32, Home Assistant, MQTT Explorer
TopicHet adres van een bericht, opgebouwd uit niveaus gescheiden door schuine strepenev/salon/sicaklik
PublishEen bericht naar een topic sturenDe waarde "23.4" naar ev/salon/sicaklik sturen
SubscribeJe aanmelden om de berichten op een topic te ontvangenDe ESP32 die luistert naar ev/salon/role/komut
PayloadDe inhoud van een bericht; tekst, een getal of JSONON, 23.4, {"sicaklik":23.4}
RetainDe broker bewaart het laatste bericht op een topic en geeft het meteen aan nieuwe abonneesRelaisstatus: ON
LWT (last will)Een bericht dat de broker namens een client publiceert als die onverwacht wegvaltev/salon/baglanti: offline
QoSHet niveau van de bezorggarantie van een bericht (0, 1 of 2)QoS 1 voor relaiscommando's

Waarom MQTT? Vergeleken met een webserver, Blynk en Telegram

MethodeVoordelenNadelenHet best voor
MQTT + Home AssistantLokaal en snel, tweerichtingsverkeer; honderden apparaten op één dashboard, automatiseringenJe moet zelf een broker draaienHet hele huis vanaf één plek beheren
ESP32-webserverGeen extra server, opent in een browserElk apparaat heeft een eigen pagina, geen automatiseringen tussen apparatenEen bedieningspaneel voor één apparaat
Blynk IoTKant-en-klaar dashboard op je telefoon, toegang via internetAfhankelijk van de cloud, beperkingen in het gratis abonnementSnelle mobiele prototypes
Telegram-botGratis directe meldingen, geen port forwardingGeen grafieken of dashboardAlarmen en eenvoudige commando's
ESP-NOWESP-boards praten met elkaar zonder router of brokerAlleen tussen ESP-boards, bereikt Home Assistant niet rechtstreeksData van een sensor op batterij naar een gateway brengen

Kortom: MQTT komt tot zijn recht naarmate het aantal apparaten groeit. Als je een nieuwe sensor toevoegt, hoef je geen bestaande code aan te passen; je begint gewoon te publiceren naar een nieuw topic. Wil je één apparaat vanuit een browser bedienen, dan ben je met de gids ESP32 Async Web Server en WebSocket sneller klaar; voor meldingen op je telefoon zie je ESP32 Telegram-bot en voor een kant-en-klaar mobiel dashboard Blynk ESP32. Voor een tuinsensor buiten het bereik van je router is ESP-NOW een goede oplossing om de data naar een gateway-ESP32 te brengen die met MQTT is verbonden.

MQTT-topicstructuur en wildcards

Topics lijken op mappaden: "ev/salon/sicaklik" (Turks voor thuis/woonkamer/temperatuur) heeft drie niveaus en is hoofdlettergevoelig, dus "Ev/Salon" en "ev/salon" zijn twee verschillende topics. Begin niet met een schuine streep ("/ev/salon" maakt een leeg eerste niveau) en vermijd spaties en letters met accenten; gewone letters, cijfers, koppeltekens en underscores volstaan. Bij het abonneren kun je twee wildcards gebruiken: + vervangt precies één niveau ("ev/+/sicaklik" geeft de temperatuur van elke kamer), terwijl # alles erna dekt en alleen aan het eind mag staan ("ev/#" geeft elk bericht in huis). Wildcards werken alleen bij het abonneren; een bericht wordt altijd naar één exact topic gepubliceerd. Topics die met $ beginnen (zoals $SYS) zijn gereserveerd voor de eigen statistieken van de broker en worden niet door een #-abonnement gevonden. Voor het project in deze gids gebruiken we deze indeling:

TopicGepubliceerd doorBeluisterd doorRetain
ev/salon/sicaklikESP32 (elke 30 seconden)Home AssistantJa
ev/salon/nemESP32 (elke 30 seconden)Home AssistantJa
ev/salon/role/komutHome Assistant, telefoon, automatiseringenESP32Nee
ev/salon/role/durumESP32 (bij elke wijziging)Home AssistantJa
ev/salon/baglantiESP32 (online), broker (offline)Home AssistantJa
homeassistant/statusHome Assistant (online bij het opstarten)ESP32Nee

Een MQTT-broker installeren: Mosquitto

De populairste gratis MQTT-broker is Eclipse Mosquitto; zelfs op een Raspberry Pi verwerkt hij gemakkelijk honderden berichten per seconde. Er zijn drie makkelijke manieren om hem te installeren: de officiële Mosquitto broker-app als je Home Assistant OS gebruikt, het apt-pakket op een aparte Raspberry Pi of Linux-computer, of het Mosquitto-installatieprogramma op Windows. Welke je ook kiest, de broker gebruikt poort 1883 voor onversleutelde MQTT zonder TLS en 8883 voor MQTT met TLS-versleuteling, en hij hoeft alleen op hetzelfde thuisnetwerk te staan als de ESP32. In Home Assistant ga je zo te werk:

  1. Open in Home Assistant Settings > Apps (in oudere versies Add-ons genoemd), klik op Install app en kies Mosquitto broker uit de lijst.
  2. Klik op Install; klik als het klaar is op Start en laat de optie om bij het opstarten te starten ingeschakeld.
  3. Maak een aparte gebruiker voor de ESP32: voeg onder Settings > People > Users een gebruiker "esp32" toe met een sterk wachtwoord. Zie je dit tabblad niet, zet dan de geavanceerde modus aan in je profiel. De namen "homeassistant" en "addons" zijn gereserveerd voor de broker, gebruik ze dus niet.
  4. Op de pagina Settings > Devices & services verschijnt de MQTT-integratie meestal als "Discovered"; klik op Configure en bevestig. Gebeurt dat niet, gebruik dan Add integration, zoek naar MQTT en kies de optie die Mosquitto automatisch configureert.
  5. In de ESP32-code vul je het IP-adres van Home Assistant in als brokeradres (bijvoorbeeld 192.168.1.10), 1883 als poort en de gebruiker die je zojuist hebt gemaakt.

Op een Linux-machine zoals een Raspberry Pi of Ubuntu kost de installatie een paar commando's. Installeer de broker en de testtools met sudo apt install mosquitto mosquitto-clients. Maak de gebruiker "esp32" aan met sudo mosquitto_passwd -c /etc/mosquitto/passwd esp32 en typ het wachtwoord twee keer; de optie -c maakt het bestand helemaal opnieuw aan, dus laat die weg als je een tweede gebruiker toevoegt, anders worden de bestaande gebruikers gewist. Maak daarna in de map /etc/mosquitto/conf.d/ een bestand local.conf, zet de drie onderstaande regels erin en herstart de service met sudo systemctl restart mosquitto. Voeg op Windows dezelfde regels toe aan het bestand mosquitto.conf in de installatiemap van Mosquitto en herstart de service Mosquitto Broker.

RegelBetekenis
listener 1883Luistert op poort 1883 op alle netwerkinterfaces; zonder deze regel accepteert Mosquitto 2.x alleen verbindingen vanaf dezelfde computer
allow_anonymous falseWeigert verbindingen zonder gebruikersnaam en wachtwoord; dit is in 2.x al de standaard, maar het is een goede gewoonte om het uit te schrijven
password_file /etc/mosquitto/passwdGebruikt het wachtwoordbestand dat je met mosquitto_passwd hebt gemaakt; wachtwoorden staan daarin als hashes
Als er in de configuratie geen listener is gedefinieerd, luistert Mosquitto 2.0 en nieuwer alleen op 127.0.0.1 en schrijft hij de waarschuwing "Starting in local only mode. Connections will only be possible from clients running on this machine." naar zijn log. In dat geval kan de ESP32 geen verbinding maken en krijg je een rc=-2-fout. Open aan de andere kant nooit poort 1883 naar het internet op je router (geen port forwarding): onversleuteld MQTT-verkeer kan onderweg worden meegelezen en de relais in je huis kunnen in verkeerde handen vallen. Heb je toegang van buitenaf nodig, gebruik dan een VPN of de opties voor toegang op afstand van Home Assistant.

Test de broker vanaf je computer voordat je verdergaat met de ESP32; broker- en codeproblemen meteen scheiden scheelt veel tijd. Begin in één terminal met luisteren naar alle topics in huis met mosquitto_sub -h 192.168.1.10 -u esp32 -P jouwwachtwoord -t "ev/#" -v. Typ in een tweede terminal mosquitto_pub -h 192.168.1.10 -u esp32 -P jouwwachtwoord -t ev/salon/test -m hallo. Verschijnt de regel "ev/salon/test hallo" in de eerste terminal, dan draait de broker en klopt het wachtwoord. De optie -v zet het topic van elk bericht ervoor en met de optie -r wordt het bericht als retained verstuurd.

Ben je geen fan van de opdrachtregel, dan toont het gratis programma MQTT Explorer elk topic op de broker als een boom, met de laatste waarden en retain-vlaggen. In Home Assistant kun je ook naar Settings > Devices & services > MQTT > Configure gaan, ev/# invullen in het veld "Listen to a topic" en gaan luisteren, en met het onderdeel "Publish a packet" met de hand commando's naar de ESP32 sturen.

Onderdelenlijst en bedradingsschema

Voor dit project heb je een ESP32-ontwikkelboard nodig, een DHT22-sensor voor temperatuur en luchtvochtigheid, een relaismodule die bij 3,3 V kan worden geschakeld, een breadboard en jumperdraden. De DHT22 is nauwkeuriger dan de DHT11: hij meet temperatuur tot op ±0,5 °C en luchtvochtigheid tot ongeveer ±2–5% en werkt van -40 tot 80 °C; de sensorfamilie behandelen we uitgebreid in DHT11 temperatuur- en vochtsensor. Heb je een DHT11, verander dan gewoon DHT22 in DHT11 in de code. Voor de eerste verbindingstest heb je alleen een ESP32 en een USB-kabel nodig; sensor en relais kun je later toevoegen.

ESP32
ESP32
DHT22
DHT22
Relaismodule
Relaismodule
AansluitingESP32ESP8266 (NodeMCU)Raspberry Pi Pico W
DHT22 VCC3V33V33V3(OUT)
DHT22 DATAGPIO 4D2 (GPIO 4)GP15
DHT22 GNDGNDGNDGND
Relais VCCVIN (5V)VIN (5V)VBUS (5V)
Relais INGPIO 26D1 (GPIO 5)GP14
Relais GNDGNDGNDGND
De pins van de ESP32, ESP8266 en Pico werken op 3,3 V en zijn niet 5 V-tolerant; daarom voeden we de DHT22 vanaf de 3V3-pin. DHT22-modules met drie pinnen hebben meestal al een pull-upweerstand aan boord; gebruik je de kale sensor met vier pinnen, plaats dan een weerstand van 4,7–10 kΩ tussen DATA en VCC. Als je met het relais een 230 V-netbelasting schakelt, doe dan alle bedrading met de stekker uit het stopcontact en vraag een volwassene om hulp; details staan in Wat is een relaismodule?. Alle pins van je board zie je in de tool Pinout.

PubSubClient installeren in de Arduino IDE

  1. Als het ESP32-boardpakket nog niet in de Arduino IDE is geïnstalleerd, installeer je dat eerst; de stappen staan in Wat is de ESP32?.
  2. Open Tools > Manage Libraries, typ PubSubClient in het zoekvak en installeer de bibliotheek van Nick O'Leary. De code in deze gids is gecompileerd met versie 2.8.
  3. Zoek in hetzelfde venster naar DHT sensor library en installeer de Adafruit-bibliotheek; kies bij de vraag over afhankelijkheden Install all, zodat ook Adafruit Unified Sensor wordt geïnstalleerd.
  4. Kom je er bij het installeren van bibliotheken niet uit, zie dan de gids Bibliotheken toevoegen in Arduino.

Eerste test: de ESP32 met de MQTT-broker verbinden

Laten we voordat we sensoren toevoegen met de eenvoudigst mogelijke code controleren of de wifigegevens, het brokeradres en het wachtwoord kloppen. De onderstaande code maakt verbinding met de broker, publiceert "merhaba" (hallo) naar het topic "test/esp32/durum" en toont elk bericht dat op "test/esp32/komut" binnenkomt in de Serial Monitor. Vervang de wifinaam, het wachtwoord, het broker-IP en de MQTT-gebruiker door je eigen gegevens, upload de code en open de Serial Monitor op 115200 baud:

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <PubSubClient.h>
3
4const char* WIFI_SSID = "AgAdi";              // Wi-Fi adın (yalnız 2,4 GHz) / your Wi-Fi name (2.4 GHz only)
5const char* WIFI_PASS = "Sifre123";           // Wi-Fi şifren / your Wi-Fi password
6const char* MQTT_SUNUCU = "192.168.1.10";     // broker'ın IP adresi / broker IP address
7const int   MQTT_PORT = 1883;                 // şifresiz MQTT portu / unencrypted MQTT port
8const char* MQTT_KULLANICI = "esp32";         // broker kullanıcı adı / broker username
9const char* MQTT_SIFRE = "mqttSifre";         // broker şifresi / broker password
10
11WiFiClient wifiIstemci;                       // TCP bağlantısı / TCP connection
12PubSubClient mqtt(wifiIstemci);               // MQTT istemcisi / MQTT client
13
14// Abone olunan konuya mesaj gelince çalışır / runs when a subscribed topic receives a message
15void mesajGeldi(char* topic, byte* payload, unsigned int length) {
16  Serial.print("Mesaj [");
17  Serial.print(topic);
18  Serial.print("] ");
19  for (unsigned int i = 0; i < length; i++) {
20    Serial.print((char)payload[i]);           // payload sonunda \0 yoktur / payload is not null-terminated
21  }
22  Serial.println();
23}
24
25void setup() {
26  Serial.begin(115200);
27  WiFi.mode(WIFI_STA);
28  WiFi.begin(WIFI_SSID, WIFI_PASS);
29  while (WiFi.status() != WL_CONNECTED) {
30    delay(500);
31    Serial.print(".");
32  }
33  Serial.print("\nIP: ");
34  Serial.println(WiFi.localIP());
35
36  mqtt.setServer(MQTT_SUNUCU, MQTT_PORT);     // broker adresi / broker address
37  mqtt.setCallback(mesajGeldi);               // gelen mesaj fonksiyonu / incoming message handler
38}
39
40void loop() {
41  if (!mqtt.connected()) {
42    Serial.print("MQTT baglaniyor... ");
43    if (mqtt.connect("esp32-test", MQTT_KULLANICI, MQTT_SIFRE)) {   // istemci kimliği benzersiz olmalı / client ID must be unique
44      Serial.println("baglandi");
45      mqtt.subscribe("test/esp32/komut");                  // bu konuyu dinle / listen to this topic
46      mqtt.publish("test/esp32/durum", "merhaba");         // ilk mesaj / first message
47    } else {
48      Serial.print("hata, rc=");
49      Serial.println(mqtt.state());                        // hata kodu / error code
50      delay(5000);
51      return;
52    }
53  }
54  mqtt.loop();                                             // mesajları işle, bağlantıyı canlı tut / process messages, keep the connection alive
55}

Zodra je "baglandi" (verbonden) in de Serial Monitor ziet, stuur je vanuit een terminal op je computer mosquitto_pub -h 192.168.1.10 -u esp32 -P jouwwachtwoord -t test/esp32/komut -m hi; binnen enkele milliseconden verschijnt de regel "Mesaj [test/esp32/komut] hi" in de Serial Monitor. Mislukt de verbinding, dan print de code met mqtt.state() een foutcode en probeert het na 5 seconden opnieuw. Deze codes vertellen precies waar het probleem zit:

rcPubSubClient-naamBetekenis en oplossing
-4MQTT_CONNECTION_TIMEOUTDe broker antwoordde niet op tijd; zwak netwerk of een overbelaste broker
-3MQTT_CONNECTION_LOSTEen bestaande verbinding viel weg; meestal omdat loop() lang niet is aangeroepen of de wifi wegviel
-2MQTT_CONNECT_FAILEDDe TCP-verbinding kwam nooit tot stand: verkeerd IP of verkeerde poort, broker draait niet, Mosquitto in local-only-modus of een firewall die 1883 blokkeert
-1MQTT_DISCONNECTEDDe verbinding is netjes gesloten (disconnect is aangeroepen) of er was nooit verbinding
2MQTT_CONNECT_BAD_CLIENT_IDDe client-ID is geweigerd; er is een lege of ongeldige client-ID gebruikt
4MQTT_CONNECT_BAD_CREDENTIALSVerkeerde gebruikersnaam of verkeerd wachtwoord (sommige brokers geven deze code)
5MQTT_CONNECT_UNAUTHORIZEDNiet geautoriseerd; Mosquitto geeft deze code zowel bij een verkeerd wachtwoord als bij een poging om zonder inloggegevens te verbinden

Sensordata publiceren en naar relaiscommando's luisteren met de ESP32

Nu bouwen we het echte project. De onderstaande code leest de DHT22 elke 30 seconden uit en publiceert temperatuur en luchtvochtigheid met de retain-vlag, bestuurt het relais met de commando's ON, OFF en TOGGLE die op "ev/salon/role/komut" binnenkomen en meldt de nieuwe relaisstatus aan "ev/salon/role/durum". Bij het verbinden laat hij een last will achter bij de broker, stelt hij zich via MQTT Discovery voor aan Home Assistant en als de verbinding wegvalt, probeert hij het elke 5 seconden opnieuw zonder loop() te blokkeren. Dankzij het blok #if defined(ESP8266) bovenaan compileert dezelfde code zonder wijzigingen ook op een NodeMCU.

C++ (Arduino IDE)
1#if defined(ESP8266)
2#include <ESP8266WiFi.h>
3#else
4#include <WiFi.h>
5#endif
6#include <PubSubClient.h>
7#include <DHT.h>
8
9// ---- Ayarlar / Settings ----
10const char* WIFI_SSID = "AgAdi";
11const char* WIFI_PASS = "Sifre123";
12const char* MQTT_SUNUCU = "192.168.1.10";        // broker IP (Home Assistant ya da Raspberry Pi) / broker IP (Home Assistant or Raspberry Pi)
13const int   MQTT_PORT = 1883;
14const char* MQTT_KULLANICI = "esp32";
15const char* MQTT_SIFRE = "mqttSifre";
16const char* ISTEMCI_ID = "esp32-salon";          // her cihazda farklı olmalı / must be different on every device
17
18#if defined(ESP8266)
19const int DHT_PIN = 4;                           // NodeMCU D2
20const int ROLE_PIN = 5;                          // NodeMCU D1
21#else
22const int DHT_PIN = 4;                           // ESP32 GPIO 4
23const int ROLE_PIN = 26;                         // ESP32 GPIO 26
24#endif
25const bool ROLE_AKTIF_LOW = true;                // çoğu röle modülü LOW ile çeker / most relay modules switch on LOW
26const unsigned long OLCUM_ARALIGI = 30000;       // 30 saniyede bir ölçüm / one reading every 30 s
27
28// ---- Konular (topic) / Topics ----
29const char* T_SICAKLIK = "ev/salon/sicaklik";
30const char* T_NEM      = "ev/salon/nem";
31const char* T_KOMUT    = "ev/salon/role/komut";  // ON, OFF ya da TOGGLE / ON, OFF or TOGGLE
32const char* T_DURUM    = "ev/salon/role/durum";
33const char* T_BAGLANTI = "ev/salon/baglanti";    // online / offline (son vasiyet / last will)
34const char* T_HA_DURUM = "homeassistant/status"; // HA açılınca "online" yayınlar / HA publishes "online" when it starts
35
36WiFiClient wifiIstemci;
37PubSubClient mqtt(wifiIstemci);
38DHT dht(DHT_PIN, DHT22);
39
40bool roleAcik = false;
41unsigned long sonOlcum = 0;
42unsigned long sonDeneme = 0;
43
44// Röleyi sür ve yeni durumu kalıcı (retain) yayınla / drive the relay and publish the new state as retained
45void roleAyarla(bool acik) {
46  roleAcik = acik;
47  bool seviye = ROLE_AKTIF_LOW ? !acik : acik;
48  digitalWrite(ROLE_PIN, seviye ? HIGH : LOW);
49  mqtt.publish(T_DURUM, acik ? "ON" : "OFF", true);
50  Serial.println(acik ? "Role: ON" : "Role: OFF");
51}
52
53// Tek bir Home Assistant keşif mesajı gönder / send one Home Assistant discovery message
54void kesifYayinla(const char* tur, const char* nesne, const char* ad, const char* ekAlanlar) {
55  char konu[96];
56  snprintf(konu, sizeof(konu), "homeassistant/%s/%s/%s/config", tur, ISTEMCI_ID, nesne);
57  char json[600];
58  snprintf(json, sizeof(json),
59           "{\"name\":\"%s\",\"unique_id\":\"%s_%s\",%s,\"availability_topic\":\"%s\","
60           "\"device\":{\"identifiers\":[\"%s\"],\"name\":\"Salon ESP32\",\"model\":\"ESP32 + DHT22\"}}",
61           ad, ISTEMCI_ID, nesne, ekAlanlar, T_BAGLANTI, ISTEMCI_ID);
62  if (!mqtt.publish(konu, json, true)) {         // false: tampon küçük ya da bağlantı yok / false: buffer too small or not connected
63    Serial.println("Kesif mesaji gonderilemedi");
64  }
65}
66
67// Sıcaklık, nem ve röleyi Home Assistant'a tanıt / announce temperature, humidity and relay to Home Assistant
68void haKesifGonder() {
69  char ek[200];
70  snprintf(ek, sizeof(ek), "\"state_topic\":\"%s\",\"device_class\":\"temperature\",\"unit_of_measurement\":\"°C\",\"state_class\":\"measurement\"", T_SICAKLIK);
71  kesifYayinla("sensor", "sicaklik", "Sıcaklık", ek);
72  snprintf(ek, sizeof(ek), "\"state_topic\":\"%s\",\"device_class\":\"humidity\",\"unit_of_measurement\":\"%%\",\"state_class\":\"measurement\"", T_NEM);
73  kesifYayinla("sensor", "nem", "Nem", ek);
74  snprintf(ek, sizeof(ek), "\"state_topic\":\"%s\",\"command_topic\":\"%s\"", T_DURUM, T_KOMUT);
75  kesifYayinla("switch", "role", "Röle", ek);
76}
77
78// DHT22'yi oku ve değerleri yayınla / read the DHT22 and publish the values
79void olcumGonder() {
80  float t = dht.readTemperature();
81  float h = dht.readHumidity();
82  if (isnan(t) || isnan(h)) {
83    Serial.println("DHT22 okunamadi");
84    return;
85  }
86  char deger[12];
87  snprintf(deger, sizeof(deger), "%.1f", t);     // 23.4 gibi / like 23.4
88  mqtt.publish(T_SICAKLIK, deger, true);
89  snprintf(deger, sizeof(deger), "%.0f", h);     // 45 gibi / like 45
90  mqtt.publish(T_NEM, deger, true);
91  Serial.printf("Sicaklik %.1f C, nem %.0f %%\n", t, h);
92}
93
94// Abone olunan konulara mesaj gelince çalışır / runs when a subscribed topic receives a message
95void mesajGeldi(char* topic, byte* payload, unsigned int length) {
96  // Önce kopyala: yayın yapınca kütüphane aynı tamponu kullanır / copy first: publishing reuses the same buffer
97  String konu = topic;
98  String mesaj;
99  for (unsigned int i = 0; i < length; i++) mesaj += (char)payload[i];
100  mesaj.trim();
101
102  if (konu == T_KOMUT) {
103    if (mesaj == "ON") roleAyarla(true);
104    else if (mesaj == "OFF") roleAyarla(false);
105    else if (mesaj == "TOGGLE") roleAyarla(!roleAcik);
106  } else if (konu == T_HA_DURUM && mesaj == "online") {
107    haKesifGonder();                             // HA yeniden başladı, tanıtımı yenile / HA restarted, announce again
108    mqtt.publish(T_DURUM, roleAcik ? "ON" : "OFF", true);
109  }
110}
111
112bool mqttBaglan() {
113  Serial.print("MQTT baglaniyor... ");
114  // Bağlantı koparsa broker T_BAGLANTI'ya "offline" yazar / if we drop, the broker publishes "offline" to T_BAGLANTI
115  if (!mqtt.connect(ISTEMCI_ID, MQTT_KULLANICI, MQTT_SIFRE, T_BAGLANTI, 1, true, "offline")) {
116    Serial.print("hata, rc=");
117    Serial.println(mqtt.state());
118    return false;
119  }
120  Serial.println("baglandi");
121  mqtt.publish(T_BAGLANTI, "online", true);
122  mqtt.subscribe(T_KOMUT, 1);                    // komutları QoS 1 ile dinle / listen to commands with QoS 1
123  mqtt.subscribe(T_HA_DURUM);
124  haKesifGonder();
125  mqtt.publish(T_DURUM, roleAcik ? "ON" : "OFF", true);
126  return true;
127}
128
129void setup() {
130  Serial.begin(115200);
131  pinMode(ROLE_PIN, OUTPUT);
132  roleAyarla(false);                             // güvenli başlangıç: röle kapalı / safe start: relay off
133  dht.begin();
134
135  WiFi.mode(WIFI_STA);
136  WiFi.begin(WIFI_SSID, WIFI_PASS);
137  Serial.print("Wi-Fi");
138  while (WiFi.status() != WL_CONNECTED) {
139    delay(500);
140    Serial.print(".");
141  }
142  Serial.print(" IP: ");
143  Serial.println(WiFi.localIP());
144
145  mqtt.setServer(MQTT_SUNUCU, MQTT_PORT);
146  mqtt.setCallback(mesajGeldi);
147  mqtt.setBufferSize(1024);                      // keşif JSON'u varsayılan 256 bayta sığmaz / discovery JSON doesn't fit the default 256 bytes
148}
149
150void loop() {
151  if (!mqtt.connected()) {
152    unsigned long simdi = millis();
153    if (sonDeneme == 0 || simdi - sonDeneme >= 5000) {   // 5 sn'de bir dene, loop'u kilitleme / retry every 5 s without blocking
154      sonDeneme = simdi;
155      if (mqttBaglan()) sonOlcum = simdi - OLCUM_ARALIGI;  // bağlanınca hemen ölç / measure right after connecting
156    }
157    return;
158  }
159  mqtt.loop();                                   // gelen komutlar ve keep-alive / incoming commands and keep-alive
160
161  if (millis() - sonOlcum >= OLCUM_ARALIGI) {
162    sonOlcum = millis();
163    olcumGonder();
164  }
165}
RegelWat het doet
mqtt.connect(ISTEMCI_ID, ..., T_BAGLANTI, 1, true, "offline")Registreert de last will tijdens het verbinden: valt de ESP32 onverwacht weg, dan schrijft de broker een retained "offline" naar ev/salon/baglanti
mqtt.publish(T_BAGLANTI, "online", true)Zet de status direct na het verbinden op "online"; Home Assistant toont het apparaat weer als beschikbaar
mqtt.subscribe(T_KOMUT, 1)Luistert met QoS 1 naar relaiscommando's; PubSubClient ondersteunt bij abonnementen alleen QoS 0 en 1
mqtt.setBufferSize(1024)Vergroot de pakketbuffer ten opzichte van de standaard 256 bytes; het grootste discovery-pakket is ongeveer 355 bytes
mqtt.loop()Leest binnenkomende berichten en stuurt keep-alive-pakketten (PINGREQ); moet bij elke ronde van loop worden aangeroepen
ROLE_AKTIF_LOWDe meeste relaismodules schakelen op een LOW-signaal; zet dit op false als die van jou op HIGH schakelt
OLCUM_ARALIGIHoe vaak er wordt gemeten; de DHT22 kan hooguit elke 2 seconden worden uitgelezen en 30–60 seconden is ideaal voor kamertemperatuur

Een paar details in de code zijn bewust gekozen. De functie mesajGeldi() kopieert het topic en de payload eerst naar Strings, omdat PubSubClient één buffer gebruikt voor zowel inkomende als uitgaande berichten: zodra je publish() binnen de callback aanroept, worden de gegevens waarnaar de topic- en payloadpointers wijzen overschreven. De payload heeft ook geen afsluitende \0 zoals een C-string, dus we lezen precies length tekens. We gebruiken retain voor de metingen en de relaisstatus, zodat Home Assistant na een herstart direct de laatste waarde ziet in plaats van 30 seconden te wachten. De timing doen we ook met millis(): een lange delay() in loop() zou de keep-alive-pakketten ophouden en de broker zou de verbinding verbreken. Deze techniek leggen we uitgebreid uit in Arduino millis() versus delay().

Stuur nooit berichten met de retain-vlag naar commandotopics. Blijft er een retained "ON" op "ev/salon/role/komut" staan, dan ontvangt de ESP32 dat oude commando elke keer als hij na een stroomonderbreking of wifi-uitval opnieuw verbindt en schakelt hij midden in de nacht uit zichzelf het relais in. Heb je per ongeluk een retained commando verstuurd, wis het dan door een leeg retained bericht te publiceren met mosquitto_pub -r -n -t ev/salon/role/komut. De MQTT-schakelaars van Home Assistant sturen commando's standaard zonder retain.

Hoe het eruitziet in Home Assistant: MQTT Discovery

Home Assistant luistert voortdurend naar topics die met het voorvoegsel homeassistant/ beginnen. Publiceert een apparaat een JSON-configuratie naar een topic in de vorm homeassistant/[component]/[node]/[object]/config, dan maakt Home Assistant die entiteit automatisch aan; dit heet MQTT Discovery. Onze code stuurt drie berichten: twee voor de sensoren (temperatuur en luchtvochtigheid) onder homeassistant/sensor/esp32-salon/... en één voor het relais op homeassistant/switch/esp32-salon/role/config. Omdat ze retained zijn, overleven ze een herstart van Home Assistant. De code is ook geabonneerd op homeassistant/status: Home Assistant schrijft daar "online" bij het opstarten en de ESP32 meldt zich dan opnieuw aan. Heb je veel apparaten, dan raadt de documentatie van Home Assistant aan om vóór deze nieuwe aanmelding een kleine willekeurige vertraging toe te voegen.

JSON-veldBetekenisOnze waarde
nameDe weergavenaam van de entiteit; de apparaatnaam wordt ervoor gezetSıcaklık (getoond als Salon ESP32 Sıcaklık)
unique_idDe vaste ID van de entiteit; zonder deze kunnen naam en gebied van de entiteit niet in de interface worden aangepastesp32-salon_sicaklik
state_topicHet topic waaruit de waarde wordt gelezenev/salon/sicaklik
command_topicHet topic waarnaar schakelcommando's worden gestuurdev/salon/role/komut
device_classBepaalt het pictogram, de eenheidsopties en het grafiektypetemperature, humidity
unit_of_measurementMeeteenheid°C en %
state_classDe waardemeting maakt langetermijnstatistieken en grafieken mogelijkmeasurement
availability_topicHet topic waaruit de online/offline-status wordt gelezen; de standaardpayloads zijn online en offlineev/salon/baglanti
deviceGroepeert de entiteiten op één apparaatkaartidentifiers, name, model

Een paar seconden na het uploaden van de code verschijnt onder Settings > Devices & services > MQTT een apparaat met de naam "Salon ESP32". Op de apparaatkaart staan de temperatuur- en vochtsensoren en een relaisschakelaar; klik op de temperatuur om de geschiedenisgrafiek te openen, zet de schakelaar om en het relais klikt. Je kunt deze entiteiten aan een dashboard toevoegen, beschikbaar maken voor spraakassistenten of gebruiken in automatiseringen: een regel als "als de woonkamer boven 27 °C komt, schakel het relais in waar de ventilator op is aangesloten, en schakel het uit onder 25 °C" is met een paar klikken gemaakt. Haal je de ESP32 uit het stopcontact, dan gaan de entiteiten na hooguit ongeveer 22 seconden naar "Unavailable", wat laat zien dat het last-will-bericht werkt. Wil je geen discovery gebruiken, dan kun je dezelfde entiteiten ook met de hand definiëren in configuration.yaml als sensor- en switch-items onder mqtt:.

Als je de naam of de topics van het apparaat hebt gewijzigd en er oude entiteiten in Home Assistant achterblijven, stuur dan een leeg retained bericht naar het bijbehorende config-topic: mosquitto_pub -r -n -t homeassistant/sensor/esp32-salon/sicaklik/config. Home Assistant verwijdert de entiteit en ook het apparaat zelf als er geen andere entiteiten meer aan hangen. Geef je elke ESP32 een andere ISTEMCI_ID, dan verschillen ook de unique_id-waarden automatisch, zodat je meerdere kamers kunt toevoegen zonder verwarring.

QoS en retain: welke gebruik je wanneer?

QoS (Quality of Service) bepaalt hoe zeker je wilt zijn dat een bericht de andere kant bereikt. Een belangrijk detail: QoS geldt afzonderlijk voor twee trajecten. Tussen de publisher en de broker geldt de QoS van de publisher en tussen de broker en een abonnee geldt de QoS van het abonnement; de garantie die de abonnee krijgt is de laagste van de twee. PubSubClient ondersteunt voor publiceren alleen QoS 0 en voor abonnementen QoS 0 en 1. Op een wifinetwerk thuis komt een verloren bericht bij QoS 0 zeer zelden voor, maar het commandoabonnement op QoS 1 zetten is nog steeds een goedkope verzekering.

QoSGarantieHoe het werktWanneer gebruik je het
0Hooguit één keerHet bericht wordt één keer verstuurd zonder bevestiging; het kan verloren gaan als de verbinding op dat moment wegvaltFrequente sensormetingen
1Minstens één keerDe ontvanger bevestigt met PUBACK en het bericht wordt opnieuw verstuurd als er geen bevestiging komt; het kan twee keer aankomenRelaiscommando's, alarmen
2Precies één keerEen handshake in vier stappen met PUBREC, PUBREL en PUBCOMP; het langzaamste niveauZaken zoals tellers waarbij dubbele berichten schade doen; niet ondersteund door PubSubClient

De retain-vlag gaat over geheugen in plaats van bezorging: de broker bewaart alleen het laatste retained bericht van elk topic en stuurt het meteen naar iedereen die zich abonneert. Dat is ideaal voor berichten over de "huidige status", zoals sensorwaarden, de relaisstatus en de onlinestatus, maar gevaarlijk voor commando's en eenmalige gebeurtenissen. De last will (LWT) vult dit aan: ontvangt de broker 1,5 keer de keep-alive-periode lang geen pakket van een client, dan besluit hij dat de verbinding verloren is en publiceert hij het will-bericht. De standaard keep-alive van PubSubClient is 15 seconden, dus een losgekoppelde ESP32 verschijnt na hooguit ongeveer 22 seconden als "offline". Je kunt dit wijzigen met een regel zoals mqtt.setKeepAlive(30), maar hoe langer het is, hoe later je een verbroken verbinding opmerkt.

Het alternatief zonder code: ESPHome

ESPHome is een gratis tool die een apparaat dat je in een YAML-bestand beschrijft omzet in kant-en-klare ESP32-firmware; je schrijft geen enkele regel C++. Installeer in Home Assistant ESPHome Device Builder via Settings > Apps, open de interface en maak met de wizard New device een configuratie. De eerste upload doe je eenmalig via USB: Chrome of Edge kan het board rechtstreeks programmeren en lukt dat niet, dan kun je het bestand dat de wizard downloadt flashen met de pagina ESPHome Web. Alle latere updates gaan via wifi (OTA). De onderstaande configuratie is gelijk aan het Arduino-project hierboven: ze leest de DHT22 op GPIO 4 elke 30 seconden uit en biedt het active-LOW-relais op GPIO 26 aan als schakelaar. De wifigegevens en wachtwoorden worden met !secret uit een apart bestand secrets.yaml gelezen:

Code
1esphome:
2  name: salon-sensor               # küçük harf, rakam ve tire / lowercase, digits and hyphens
3  friendly_name: Salon Sensör
4
5esp32:
6  board: esp32dev
7
8logger:
9
10api:                               # Home Assistant ile doğrudan bağlantı / direct link to Home Assistant
11  encryption:
12    key: !secret api_anahtari
13
14ota:
15  - platform: esphome
16    password: !secret ota_sifresi
17
18wifi:
19  ssid: !secret wifi_ssid
20  password: !secret wifi_sifresi
21  ap:                              # Wi-Fi yoksa kendi ağını açar / opens its own network if Wi-Fi fails
22    ssid: "Salon-Sensor"
23    password: "yedek1234"
24
25captive_portal:
26
27sensor:
28  - platform: dht
29    pin: GPIO4
30    model: DHT22
31    update_interval: 30s
32    temperature:
33      name: "Sıcaklık"
34    humidity:
35      name: "Nem"
36
37switch:
38  - platform: gpio
39    name: "Röle"
40    pin:
41      number: GPIO26
42      inverted: true               # aktif LOW röle / active-LOW relay
43    restore_mode: ALWAYS_OFF       # açılışta kapalı / off at boot
44
45# MQTT ile kullanmak için api: bloğunu sil, bunu aç / to use MQTT, delete api: and uncomment this
46# mqtt:
47#   broker: 192.168.1.10
48#   username: esp32
49#   password: !secret mqtt_sifresi

Er is één verschil om te onthouden: ESPHome gebruikt standaard geen MQTT, maar zijn eigen versleutelde native API. Home Assistant vindt het apparaat zelf op het netwerk en heeft helemaal geen broker nodig. Kies alleen voor MQTT als je wilt dat andere systemen zoals Node-RED dezelfde data lezen, of als je geen Home Assistant gebruikt. Haal daarvoor de commentaartekens weg bij de mqtt:-regels aan het eind van het bestand en verwijder het blok api:; doe je dat niet, dan herstart het apparaat zichzelf telkens als er 15 minuten niemand met de native API is verbonden (dat is de instelling reboot_timeout). In MQTT-modus stuurt ESPHome de discovery-berichten van Home Assistant en de online/offline-berichten op salon-sensor/status zelf, dus het doet automatisch alles wat we in de Arduino-code met de hand deden.

KenmerkPubSubClient (Arduino-code)ESPHome (YAML)
Code schrijvenJe schrijft alles in C++Alleen YAML; de firmware wordt automatisch gecompileerd
Toevoegen aan Home AssistantJe stuurt zelf de discovery-JSONAutomatisch gevonden
FlexibiliteitOnbeperkt; elke bibliotheek en logica is bruikbaarBeperkt tot kant-en-klare componenten, maar honderden sensoren worden ondersteund; C++ kan worden toegevoegd met lambda's
Updates via de luchtJe voegt ArduinoOTA zelf aan de code toeIngebouwd
Broker nodigJaNiet met de native API
LeerwaardeLeert je het MQTT-protocol en programmerenSnel resultaat, verbergt wat er eronder gebeurt

MQTT met de ESP8266 en Raspberry Pi Pico W

De volledige code hierboven draait ongewijzigd op ESP8266 NodeMCU- en Wemos D1 Mini-boards: kies je onder Tools > Board NodeMCU 1.0, dan kiest het blok #if defined(ESP8266) automatisch ESP8266WiFi.h in plaats van WiFi.h, samen met de pins D2 en D1. Op de Raspberry Pi Pico W gebruiken we de MicroPython-module umqtt.simple. Die zit niet in de MicroPython-firmware van de Pico W; installeer hem in Thonny door onder Tools > Manage packages te zoeken naar umqtt.simple, of typ import mip; mip.install("umqtt.simple") in de REPL terwijl je met wifi bent verbonden. De dht-module die je voor de DHT22 nodig hebt, zit daarentegen wel in de firmware. De onderstaande code laat een Pico W in de keuken hetzelfde meet- en relaiswerk doen. Om het kort te houden hebben we de discovery-berichten weggelaten; om de Pico W in Home Assistant te zien, publiceer je dezelfde discovery-JSON als in de ESP32-code met de ev/mutfak-topics, of definieer je de entiteiten met de hand onder mqtt: in configuration.yaml. Sla het bestand op als main.py en het draait elke keer dat het board stroom krijgt:

MicroPython
1import network, time, dht
2from machine import Pin
3from umqtt.simple import MQTTClient    # önce mip ile kur / install with mip first
4
5WIFI_SSID = "AgAdi"                    # Wi-Fi adın / your Wi-Fi name
6WIFI_PASS = "Sifre123"                 # Wi-Fi şifren / your Wi-Fi password
7MQTT_SUNUCU = "192.168.1.10"           # broker IP / broker IP
8ISTEMCI_ID = "pico-mutfak"             # benzersiz olmalı / must be unique
9
10T_SICAKLIK = b"ev/mutfak/sicaklik"
11T_NEM = b"ev/mutfak/nem"
12T_KOMUT = b"ev/mutfak/role/komut"
13T_DURUM = b"ev/mutfak/role/durum"
14T_BAGLANTI = b"ev/mutfak/baglanti"
15
16sensor = dht.DHT22(Pin(15))            # DHT22 DATA -> GP15
17role = Pin(14, Pin.OUT, value=1)       # aktif LOW röle kapalı başlar / active-LOW relay starts off
18led = Pin("LED", Pin.OUT)              # Pico W dahili LED / Pico W onboard LED
19
20wlan = network.WLAN(network.STA_IF)
21wlan.active(True)
22wlan.connect(WIFI_SSID, WIFI_PASS)
23while not wlan.isconnected():
24    time.sleep(0.5)
25print("IP:", wlan.ifconfig()[0])
26
27def mesaj_geldi(konu, mesaj):          # ikisi de bytes gelir / both arrive as bytes
28    if konu == T_KOMUT and mesaj in (b"ON", b"OFF"):
29        acik = mesaj == b"ON"
30        role.value(0 if acik else 1)
31        led.value(1 if acik else 0)
32        istemci.publish(T_DURUM, mesaj, retain=True)
33
34istemci = MQTTClient(ISTEMCI_ID, MQTT_SUNUCU, user="esp32", password="mqttSifre", keepalive=60)   # Mosquitto kullanıcısı / Mosquitto user
35istemci.set_callback(mesaj_geldi)
36istemci.set_last_will(T_BAGLANTI, b"offline", retain=True)   # son vasiyet / last will
37
38def baglan():
39    while True:
40        try:
41            if not wlan.isconnected():         # Wi-Fi koptuysa yeniden bağlan / reconnect Wi-Fi if it dropped
42                wlan.connect(WIFI_SSID, WIFI_PASS)
43                time.sleep(5)
44            istemci.connect()
45            istemci.publish(T_BAGLANTI, b"online", retain=True)
46            istemci.publish(T_DURUM, b"OFF" if role.value() else b"ON", retain=True)
47            istemci.subscribe(T_KOMUT)
48            print("MQTT baglandi")
49            return
50        except Exception as e:         # MQTTException(5): yetki yok / not authorized
51            print("MQTT hatasi:", e)
52            time.sleep(5)
53
54baglan()
55son = time.ticks_add(time.ticks_ms(), -30000)   # ilk ölçüm hemen / first reading right away
56while True:
57    try:
58        istemci.check_msg()            # bekleyen komut var mı? / any pending command?
59        if time.ticks_diff(time.ticks_ms(), son) >= 30000:
60            son = time.ticks_ms()
61            try:
62                sensor.measure()
63            except OSError:
64                print("DHT22 okunamadi")
65                istemci.ping()         # veri yoksa da bağlantıyı canlı tut / keep the link alive without data
66            else:
67                istemci.publish(T_SICAKLIK, "{:.1f}".format(sensor.temperature()).encode(), retain=True)
68                istemci.publish(T_NEM, "{:.0f}".format(sensor.humidity()).encode(), retain=True)
69    except OSError:
70        print("Baglanti koptu, yeniden baglaniliyor")
71        time.sleep(5)
72        baglan()
73    time.sleep_ms(100)

ESP32 MQTT-projectideeën

  • Temperatuurkaart per kamer: Zet in elke kamer een ESP32 met een DHT22 of BME280 en volg het hele huis op één grafiek met een ev/+/sicaklik-abonnement.
  • Slimme lamp en stopcontact: Koppel het relais aan een Home Assistant-automatisering die het bij zonsondergang inschakelt en om middernacht uitschakelt.
  • Deur- en raamsensor: Gebruik een reedschakelaar om een MQTT-bericht te sturen als een deur opengaat en krijg een melding op je telefoon terwijl er niemand thuis is.
  • Gangverlichting met bewegingsdetectie: Laat een PIR-sensor beweging publiceren en een Home Assistant-automatisering het licht inschakelen.
  • Plantenwaterstation: Publiceer de waarde van de bodemvochtsensor en laat de pomp met een MQTT-commando draaien als de grond droog wordt.
  • Energiemonitoring: Meet de stroom die een apparaat opneemt met een ACS712-stroomsensor en zet het dagverbruik in een grafiek.
  • Sensor op batterij: Bouw een node die een meting doet, die via MQTT verstuurt en weer gaat slapen; details in ESP32 Deep Sleep.

Veelvoorkomende ESP32 MQTT-fouten en oplossingen

Symptoom of meldingOorzaakOplossing
Steeds rc=-2Verkeerd broker-IP of verkeerde poort, broker draait niet, of Mosquitto in local-only-modusControleer het IP, voeg listener 1883 toe aan de configuratie, sta poort 1883 toe in de firewall
rc=5Verkeerde gebruikersnaam of verkeerd wachtwoord, of een poging om zonder inloggegevens te verbindenTest het wachtwoord vanaf je computer met mosquitto_sub; maak de gebruiker zo nodig opnieuw aan
Verbindt, valt na een paar seconden weg, blijft herhalenTwee apparaten gebruiken dezelfde client-ID; Mosquitto logt "Client esp32-salon already connected, closing old connection."Geef elk apparaat een unieke ISTEMCI_ID
Discovery-berichten komen niet aan, publish() geeft false terugDe PubSubClient-buffer is standaard 256 bytes en de JSON past er niet inRoep mqtt.setBufferSize(1024) aan in setup()
Vaak rc=-3Een lange delay() in loop() stopt de keep-alive-pakketten, of het wifisignaal is zwakRegel de timing met millis() en zet het board dichter bij de router
Commando's bereiken de ESP32 nooitDe topicnaam verschilt in hoofdletters of spelling, of subscribe() wordt na het opnieuw verbinden niet herhaaldControleer het topic met mosquitto_sub; zet de subscribe()-regels in de verbindingsfunctie
Het relais gaat bij het opstarten uit zichzelf aanEr staat een oud retained bericht op het commandotopicWis het met mosquitto_pub -r -n -t ev/salon/role/komut
Entiteiten tonen "Unavailable" in Home AssistantHet availability-topic zegt offline of online is anders gespeldHoud ev/salon/baglanti in de gaten en zorg dat de code na het verbinden online publiceert
Rare tekens in plaats van een waardeDe payload is niet met \0 afgesloten en is gelezen zonder length te gebruikenKopieer de payload in een lus tot length
Het ESPHome-apparaat herstart elke 15 minutenIn MQTT-modus staat het blok api: er nog steeds, maar Home Assistant verbindt nooitVerwijder het blok api: of voeg reboot_timeout: 0s toe
Houd bij het oplossen van problemen een vaste volgorde aan: controleer eerst de wifiverbinding en het IP-adres in de Serial Monitor, bekijk dan met mosquitto_sub -v -t "#" op je computer wat er echt bij de broker aankomt en kijk pas daarna naar Home Assistant. Verschijnt het bericht wel op de broker maar niet in Home Assistant, dan zit het probleem in de discovery-JSON; komt het nooit bij de broker aan, dan ligt het aan de ESP32-kant. Kom je er bij de wifi-fase niet uit, zie dan ESP32 maakt geen wifiverbinding, en als het board herstart wanneer het relais klikt, zie ESP32 Brownout en Guru Meditation.

Met een broker, een paar topics en PubSubClient is je ESP32 een smarthome-apparaat geworden dat dezelfde taal spreekt als de rest van het huis. Je kunt nieuwe sensoren, andere kamers en andere boards zoals de Pico W aan dezelfde opstelling toevoegen en ze allemaal vanaf één Home Assistant-dashboard beheren. In de BlueGrays-app vind je projecten als ESP32-wifiverbinding, DHT22-temperatuur- en vochtmeting, slimme verlichting met PIR en een relais, realtimebesturing met WebSocket en slim planten water geven, stap voor stap met schakelschema's en code.

Veelgestelde vragen

Waar wordt MQTT voor gebruikt?

MQTT is een lichtgewicht berichtenprotocol waarin apparaten via een broker berichten versturen en ontvangen met behulp van topicnamen. Omdat het weinig bandbreedte en stroom gebruikt, is het ideaal voor kleine apparaten zoals de ESP32 om sensordata te sturen en commando's te ontvangen. Home Assistant, Node-RED en de meeste industriële IoT-systemen spreken MQTT.

Welke poort gebruikt MQTT?

Onversleutelde MQTT gebruikt standaard poort 1883 en MQTT met TLS-versleuteling poort 8883. De WebSocket-poort voor browserverbindingen hangt van de broker af; bij de Mosquitto-broker in Home Assistant is dat 1884. Op een thuisnetwerk verbindt de ESP32 meestal met 1883.

Heeft MQTT een internetverbinding nodig?

Nee. Draait de broker thuis op een Raspberry Pi of in Home Assistant, dan blijft het verkeer tussen de ESP32 en de broker volledig op je lokale netwerk; sensoren en relais blijven werken ook als het internet uitvalt. Internet heb je alleen nodig om het systeem van buitenaf te bereiken of om een cloudbroker te gebruiken.

Waarom verschijnt mijn ESP32 niet in Home Assistant?

De meest voorkomende oorzaken zijn een discovery-bericht dat niet in de buffer van 256 bytes van PubSubClient past, een verkeerd gespeld config-topic of een aanhalingsfout in de JSON. Luister met mosquitto_sub naar homeassistant/# om te controleren of het bericht bij de broker aankomt en zorg dat de code de regel mqtt.setBufferSize(1024) bevat. De MQTT-integratie van Home Assistant moet ook met dezelfde broker zijn verbonden.

Moet ik ESPHome of MQTT met Arduino gebruiken?

Als je snel een werkend smarthome-apparaat wilt, kost ESPHome minder moeite: je schrijft YAML, het apparaat verschijnt vanzelf in Home Assistant en wordt via de lucht bijgewerkt. Wil je het MQTT-protocol leren, je eigen logica schrijven of met andere systemen dan Home Assistant werken, dan is Arduino met PubSubClient flexibeler. Beide kunnen prima naast elkaar in hetzelfde huis bestaan.

Wat is het verschil tussen MQTT QoS 0, 1 en 2?

QoS 0 verstuurt een bericht één keer zonder op bevestiging te wachten, QoS 1 verstuurt het opnieuw tot het is bevestigd maar het kan twee keer aankomen, en QoS 2 gebruikt een handshake in vier stappen om te garanderen dat het precies één keer aankomt. QoS 0 volstaat voor sensormetingen en QoS 1 voor commando's. PubSubClient kan alleen met QoS 0 publiceren en met QoS 0 of 1 abonneren.

Alle projecten bekijken
Led laten knipperen met ESP32
ES-1Beginner

Led laten knipperen met ESP32

Leert je het basisgebruik van een GPIO-uitgang met de ESP32. Door een led via een digitale pin aan en uit te zetten krijgen we een knippereffect. Dit is de ESP32-versie van het klassieke blinkproject op de Arduino UNO; de basiscommando's in de Arduino-omgeving zijn hetzelfde, maar de pinindeling en de 3,3 V-GPIO-niveaus van de ESP32 verschillen van die van de Arduino UNO.

4.7(37)
108
ESP32 Wi-Fi-verbinding in STA-modus (met lcd-scherm)
ES-25Gevorderd

ESP32 Wi-Fi-verbinding in STA-modus (met lcd-scherm)

In dit project verbinden we de ESP32 in Station-modus (STA) veilig en foutbestendig met het wifinetwerk thuis. We zetten de SSID en het wachtwoord in een apart bestand secrets.h zodat ze niet in Git lekken, bouwen een automatisch herverbindingsmechanisme en tonen het RSSI-signaalniveau en het IP-adres op een I2C-lcd-scherm. De ingebouwde led werkt als statusindicator. Het is een verbindingsmanager van productieniveau.

4.4(21)
38
ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)
ES-15Gemiddeld

ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)

Dit project meet de omgevingstemperatuur en luchtvochtigheid met een DHT22-sensor en toont de gegevens in realtime op een 16x2 I2C-LCD. De data wordt met het one-wire-protocol via de Adafruit DHT-bibliotheek uit de sensor gelezen. Dit project is de basis voor IoT-weerstations, slimme domotica of omgevingsbewaking in kassen. De communicatie met de DHT22 loopt via pin GPIO 4 van de ESP32.

4.8(38)
57
ESP32 slimme verlichting (PIR + LDR + relais + OLED)
ES-37Gevorderd
Premium

ESP32 slimme verlichting (PIR + LDR + relais + OLED)

Met een ESP32, een PIR-bewegingssensor, een LDR-lichtsensor en een relaismodule maak je van je gang, toilet of bijkeuken slimme verlichting. Is het al licht in de ruimte, dan blijft het licht uit, ook bij beweging, zodat overdag geen energie wordt verspild. Het licht blijft 30 seconden aan en de tijd verlengt automatisch zolang er beweging is.

4.3(6)
11
ESP32 WebSocket-teller (2 knoppen + lcd + realtime web)
ES-28Gevorderd
Premium

ESP32 WebSocket-teller (2 knoppen + lcd + realtime web)

In dit project verandert een teller met twee knoppen op de ESP32 (GPIO 5 telt op, GPIO 4 telt af). De waarde wordt direct bijgewerkt op een 16x2 I2C-lcd en, via de WebSocket-ondersteuning van ESPAsyncWebServer, in elke verbonden browser zonder de pagina te herladen. In plaats van HTTP-polling wordt één blijvende verbinding gebruikt en de ESP32 stuurt de nieuwe waarde met ws.textAll() naar iedereen.

4.5(14)
23
ESP32 mDNS: het apparaat bereiken via bluegrays-esp.local (met lcd-scherm)
ES-29Gevorderd
Premium

ESP32 mDNS: het apparaat bereiken via bluegrays-esp.local (met lcd-scherm)

In dit project voegen we een mDNS-service (Multicast DNS) toe aan de ESP32, zodat je het apparaat bereikt met een leesbare hostnaam zoals bluegrays-esp.local in plaats van een IP-adres. Ook als het IP-adres dat DHCP uitdeelt verandert, reageert het apparaat altijd op dezelfde naam. Met een kleine webserver op het board bedien je de LED vanuit je browser op http://bluegrays-esp.local/.

4.8(14)
23
ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)
ES-41Gevorderd
Premium

ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)

Een slim beveiligingsalarm: als de PIR-sensor beweging detecteert, gaat de buzzer af, licht de LED op en krijgt de eigenaar direct een Telegram-melding. Een afkoeltijd van 30 seconden beperkt hoe vaak het alarm zich herhaalt; valse detecties van de PIR-sensor filtert dit niet weg. Gebruik het thuis, in een garage, een berging of een studeerkamer.

9