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.

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.
| Begrip | Wat het doet | Voorbeeld |
|---|---|---|
| Broker | De server die berichten ontvangt en aan abonnees verdeelt | Mosquitto, de Mosquitto-broker in Home Assistant |
| Client | Elk apparaat of programma dat verbinding maakt met de broker; elk heeft een unieke client-ID | ESP32, Home Assistant, MQTT Explorer |
| Topic | Het adres van een bericht, opgebouwd uit niveaus gescheiden door schuine strepen | ev/salon/sicaklik |
| Publish | Een bericht naar een topic sturen | De waarde "23.4" naar ev/salon/sicaklik sturen |
| Subscribe | Je aanmelden om de berichten op een topic te ontvangen | De ESP32 die luistert naar ev/salon/role/komut |
| Payload | De inhoud van een bericht; tekst, een getal of JSON | ON, 23.4, {"sicaklik":23.4} |
| Retain | De broker bewaart het laatste bericht op een topic en geeft het meteen aan nieuwe abonnees | Relaisstatus: ON |
| LWT (last will) | Een bericht dat de broker namens een client publiceert als die onverwacht wegvalt | ev/salon/baglanti: offline |
| QoS | Het 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
| Methode | Voordelen | Nadelen | Het best voor |
|---|---|---|---|
| MQTT + Home Assistant | Lokaal en snel, tweerichtingsverkeer; honderden apparaten op één dashboard, automatiseringen | Je moet zelf een broker draaien | Het hele huis vanaf één plek beheren |
| ESP32-webserver | Geen extra server, opent in een browser | Elk apparaat heeft een eigen pagina, geen automatiseringen tussen apparaten | Een bedieningspaneel voor één apparaat |
| Blynk IoT | Kant-en-klaar dashboard op je telefoon, toegang via internet | Afhankelijk van de cloud, beperkingen in het gratis abonnement | Snelle mobiele prototypes |
| Telegram-bot | Gratis directe meldingen, geen port forwarding | Geen grafieken of dashboard | Alarmen en eenvoudige commando's |
| ESP-NOW | ESP-boards praten met elkaar zonder router of broker | Alleen tussen ESP-boards, bereikt Home Assistant niet rechtstreeks | Data 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:
| Topic | Gepubliceerd door | Beluisterd door | Retain |
|---|---|---|---|
| ev/salon/sicaklik | ESP32 (elke 30 seconden) | Home Assistant | Ja |
| ev/salon/nem | ESP32 (elke 30 seconden) | Home Assistant | Ja |
| ev/salon/role/komut | Home Assistant, telefoon, automatiseringen | ESP32 | Nee |
| ev/salon/role/durum | ESP32 (bij elke wijziging) | Home Assistant | Ja |
| ev/salon/baglanti | ESP32 (online), broker (offline) | Home Assistant | Ja |
| homeassistant/status | Home Assistant (online bij het opstarten) | ESP32 | Nee |
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:
- Open in Home Assistant Settings > Apps (in oudere versies Add-ons genoemd), klik op Install app en kies Mosquitto broker uit de lijst.
- Klik op Install; klik als het klaar is op Start en laat de optie om bij het opstarten te starten ingeschakeld.
- 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.
- 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.
- 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.
| Regel | Betekenis |
|---|---|
| listener 1883 | Luistert op poort 1883 op alle netwerkinterfaces; zonder deze regel accepteert Mosquitto 2.x alleen verbindingen vanaf dezelfde computer |
| allow_anonymous false | Weigert 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/passwd | Gebruikt het wachtwoordbestand dat je met mosquitto_passwd hebt gemaakt; wachtwoorden staan daarin als hashes |
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.
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.



| Aansluiting | ESP32 | ESP8266 (NodeMCU) | Raspberry Pi Pico W |
|---|---|---|---|
| DHT22 VCC | 3V3 | 3V3 | 3V3(OUT) |
| DHT22 DATA | GPIO 4 | D2 (GPIO 4) | GP15 |
| DHT22 GND | GND | GND | GND |
| Relais VCC | VIN (5V) | VIN (5V) | VBUS (5V) |
| Relais IN | GPIO 26 | D1 (GPIO 5) | GP14 |
| Relais GND | GND | GND | GND |
PubSubClient installeren in de Arduino IDE
- 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?.
- 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.
- 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.
- 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:
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:
| rc | PubSubClient-naam | Betekenis en oplossing |
|---|---|---|
| -4 | MQTT_CONNECTION_TIMEOUT | De broker antwoordde niet op tijd; zwak netwerk of een overbelaste broker |
| -3 | MQTT_CONNECTION_LOST | Een bestaande verbinding viel weg; meestal omdat loop() lang niet is aangeroepen of de wifi wegviel |
| -2 | MQTT_CONNECT_FAILED | De 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 |
| -1 | MQTT_DISCONNECTED | De verbinding is netjes gesloten (disconnect is aangeroepen) of er was nooit verbinding |
| 2 | MQTT_CONNECT_BAD_CLIENT_ID | De client-ID is geweigerd; er is een lege of ongeldige client-ID gebruikt |
| 4 | MQTT_CONNECT_BAD_CREDENTIALS | Verkeerde gebruikersnaam of verkeerd wachtwoord (sommige brokers geven deze code) |
| 5 | MQTT_CONNECT_UNAUTHORIZED | Niet 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.
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}| Regel | Wat 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_LOW | De meeste relaismodules schakelen op een LOW-signaal; zet dit op false als die van jou op HIGH schakelt |
| OLCUM_ARALIGI | Hoe 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().
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-veld | Betekenis | Onze waarde |
|---|---|---|
| name | De weergavenaam van de entiteit; de apparaatnaam wordt ervoor gezet | Sıcaklık (getoond als Salon ESP32 Sıcaklık) |
| unique_id | De vaste ID van de entiteit; zonder deze kunnen naam en gebied van de entiteit niet in de interface worden aangepast | esp32-salon_sicaklik |
| state_topic | Het topic waaruit de waarde wordt gelezen | ev/salon/sicaklik |
| command_topic | Het topic waarnaar schakelcommando's worden gestuurd | ev/salon/role/komut |
| device_class | Bepaalt het pictogram, de eenheidsopties en het grafiektype | temperature, humidity |
| unit_of_measurement | Meeteenheid | °C en % |
| state_class | De waardemeting maakt langetermijnstatistieken en grafieken mogelijk | measurement |
| availability_topic | Het topic waaruit de online/offline-status wordt gelezen; de standaardpayloads zijn online en offline | ev/salon/baglanti |
| device | Groepeert de entiteiten op één apparaatkaart | identifiers, 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:.
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.
| QoS | Garantie | Hoe het werkt | Wanneer gebruik je het |
|---|---|---|---|
| 0 | Hooguit één keer | Het bericht wordt één keer verstuurd zonder bevestiging; het kan verloren gaan als de verbinding op dat moment wegvalt | Frequente sensormetingen |
| 1 | Minstens één keer | De ontvanger bevestigt met PUBACK en het bericht wordt opnieuw verstuurd als er geen bevestiging komt; het kan twee keer aankomen | Relaiscommando's, alarmen |
| 2 | Precies één keer | Een handshake in vier stappen met PUBREC, PUBREL en PUBCOMP; het langzaamste niveau | Zaken 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:
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_sifresiEr 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.
| Kenmerk | PubSubClient (Arduino-code) | ESPHome (YAML) |
|---|---|---|
| Code schrijven | Je schrijft alles in C++ | Alleen YAML; de firmware wordt automatisch gecompileerd |
| Toevoegen aan Home Assistant | Je stuurt zelf de discovery-JSON | Automatisch gevonden |
| Flexibiliteit | Onbeperkt; elke bibliotheek en logica is bruikbaar | Beperkt tot kant-en-klare componenten, maar honderden sensoren worden ondersteund; C++ kan worden toegevoegd met lambda's |
| Updates via de lucht | Je voegt ArduinoOTA zelf aan de code toe | Ingebouwd |
| Broker nodig | Ja | Niet met de native API |
| Leerwaarde | Leert je het MQTT-protocol en programmeren | Snel 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:
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 melding | Oorzaak | Oplossing |
|---|---|---|
| Steeds rc=-2 | Verkeerd broker-IP of verkeerde poort, broker draait niet, of Mosquitto in local-only-modus | Controleer het IP, voeg listener 1883 toe aan de configuratie, sta poort 1883 toe in de firewall |
| rc=5 | Verkeerde gebruikersnaam of verkeerd wachtwoord, of een poging om zonder inloggegevens te verbinden | Test het wachtwoord vanaf je computer met mosquitto_sub; maak de gebruiker zo nodig opnieuw aan |
| Verbindt, valt na een paar seconden weg, blijft herhalen | Twee 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 terug | De PubSubClient-buffer is standaard 256 bytes en de JSON past er niet in | Roep mqtt.setBufferSize(1024) aan in setup() |
| Vaak rc=-3 | Een lange delay() in loop() stopt de keep-alive-pakketten, of het wifisignaal is zwak | Regel de timing met millis() en zet het board dichter bij de router |
| Commando's bereiken de ESP32 nooit | De topicnaam verschilt in hoofdletters of spelling, of subscribe() wordt na het opnieuw verbinden niet herhaald | Controleer het topic met mosquitto_sub; zet de subscribe()-regels in de verbindingsfunctie |
| Het relais gaat bij het opstarten uit zichzelf aan | Er staat een oud retained bericht op het commandotopic | Wis het met mosquitto_pub -r -n -t ev/salon/role/komut |
| Entiteiten tonen "Unavailable" in Home Assistant | Het availability-topic zegt offline of online is anders gespeld | Houd ev/salon/baglanti in de gaten en zorg dat de code na het verbinden online publiceert |
| Rare tekens in plaats van een waarde | De payload is niet met \0 afgesloten en is gelezen zonder length te gebruiken | Kopieer de payload in een lus tot length |
| Het ESPHome-apparaat herstart elke 15 minuten | In MQTT-modus staat het blok api: er nog steeds, maar Home Assistant verbindt nooit | Verwijder het blok api: of voeg reboot_timeout: 0s toe |
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.
Projecten om hierna te bouwen
Alle projecten bekijken
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.

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.

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.

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.

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.

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/.

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.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

