ESP-NOW-tutorial: draadloze communicatie met de ESP32 zonder router
ESP-NOW met de ESP32: zoek het MAC-adres, verstuur een struct van maximaal 250 bytes in één of twee richtingen, gebruik tot 20 peers, bereik, wijzigingen in core 3.x en Wi-Fi-kanalen.
ESP-NOW is een draadloos protocol van Espressif waarmee ESP32- en ESP8266-boards data rechtstreeks naar elkaar sturen, zonder router, accesspoint of internetverbinding. De boards gebruiken hun Wi-Fi-radio, maar maken nooit verbinding met een netwerk; elk apparaat vindt het andere via het MAC-adres en levert kleine pakketten van maximaal 250 bytes af in een paar milliseconden. Omdat er geen verbinding hoeft te worden opgezet, geen IP-adres nodig is en geen wachtwoord moet worden ingevoerd, kan een druk op een knop van het ene board meteen een relais op een ander board schakelen. Een sensor op batterijen kan wakker worden, zijn meting versturen en direct weer gaan slapen.
In deze gids zet je ESP-NOW stap voor stap op: eerst lees je de MAC-adressen van je boards uit, daarna verstuur je met voorbeelden in één en twee richtingen verschillende waarden, zoals temperatuur, een teller en tekst, in één pakket met een struct. Vervolgens leer je over de limiet van 20 peers, broadcastberichten, bereik en snelheid, de functies die veranderd zijn met ESP32 Arduino core 3.x en het afstemmen van kanalen, de enige regel voor het tegelijk gebruiken van ESP-NOW en Wi-Fi. In het laatste deel stuur je de metingen van een draadloze sensor op batterijen in deep sleep naar een gateway die met Wi-Fi is verbonden, en bekijk je ze op je telefoon. Is dit je eerste ESP32-project? Rond dan eerst de installatie van Arduino IDE af in Wat is de ESP32?.

Wat is ESP-NOW en hoe werkt het?
Bij gewone Wi-Fi maakt de ESP32 eerst verbinding met de router, controleert het wachtwoord, krijgt via DHCP een IP-adres en kan pas daarna data versturen; dat duurt meestal 1–3 seconden. ESP-NOW slaat al deze stappen over. Je data gaat in een kort Wi-Fi-pakket, een vendor-specific action frame uit de IEEE 802.11-standaard, en wordt rechtstreeks naar het MAC-adres van het andere board gestuurd. Het ontvangende board antwoordt met een hardware-bevestiging (ACK-frame), en een callback-functie aan de kant van de zender vertelt je of het pakket is afgeleverd. Komt er geen ACK, dan probeert de Wi-Fi-laag het pakket automatisch een paar keer opnieuw. Kortom: ESP-NOW werkt als een onzichtbare brievenbus tussen twee boards: je schrijft het adres, gooit het pakket erin en hoort terug wanneer de andere kant het heeft ontvangen.
| Kenmerk | Waarde |
|---|---|
| Ontwikkeld door | Espressif Systems |
| Frequentie | 2,4 GHz (Wi-Fi-radio, kanalen 1–13) |
| Data per pakket | 250 bytes (ESP-NOW v1); 1470 bytes met v2 op ESP-IDF 5.4 en later |
| Geregistreerde peers | Tot 20; standaard maximaal 7 versleutelde peers |
| Standaard datasnelheid | 1 Mbps |
| Ontvangstbevestiging | Ja bij unicast (ACK), geen bij broadcast |
| Versleuteling | Optioneel, CCMP (AES-128); PMK- en LMK-sleutels van elk 16 bytes |
| Router / accesspoint | Niet nodig |
| Ondersteunde chips | ESP32-chips met Wi-Fi (ESP32, S2, S3, C2, C3, C6…) en ESP8266 |
De echte voordelen van ESP-NOW zijn de snelle reactie en het lage energieverbruik. Druk je op een knop, dan gaat de led aan de andere kant binnen een paar milliseconden branden; hetzelfde via Wi-Fi betekent eerst verbinden en dan een verzoek naar een server sturen. Bij een sensor op batterijen is het verschil nog groter: tijdens het verbinden met Wi-Fi trekt de radio seconden lang meer dan 100 mA, terwijl het board bij ESP-NOW wakker wordt, zijn meting verstuurt en binnen een paar honderd milliseconden in totaal weer gaat slapen. Aan de andere kant bereikt ESP-NOW het internet niet; wil je je data naar het internet of je telefoon brengen, dan moet er ergens in het netwerk een gateway-ESP32 zijn die met Wi-Fi is verbonden. Die opstelling bouwen we verderop in deze gids.
ESP-NOW vs Wi-Fi vs Bluetooth vs nRF24L01
| Methode | Extra module | Router | Pakketgrootte | Typisch bereik (open ruimte) | Het meest geschikt voor |
|---|---|---|---|---|---|
| ESP-NOW | Niet nodig | Niet nodig | 250 bytes | 100–200 m, meer in LR-modus | Commando's en sensordata tussen boards |
| Wi-Fi (HTTP, MQTT) | Niet nodig | Vereist | Praktisch onbeperkt | Het bereik van de router | Internet, webpagina's, cloud |
| Bluetooth (BLE) | Niet nodig | Niet nodig | Standaard 20 bytes | 10–20 m binnenshuis | Verbinden met een telefoon |
| nRF24L01 | Vereist (SPI) | Niet nodig | 32 bytes | Tientallen meters, veel meer met de PA+LNA-versie | Boards zonder draadloze verbinding, zoals de Arduino Uno en Nano |
| LoRa (SX1278) | Vereist (SPI) | Niet nodig | Tot 255 bytes | Enkele kilometers | Zeer grote afstanden, weinig data |
Moet je met een telefoon praten, dan is Bluetooth de juiste keuze; heb je internet nodig, gebruik dan Wi-Fi. Heb je echter meerdere ESP32-boards die alleen met elkaar hoeven te praten, dan is ESP-NOW meestal de eenvoudigste manier: geen extra module, kabel of router en slechts een paar regels code. Voor boards zonder draadloze verbinding, zoals de Arduino Uno, past de nRF24L01 beter, en voor kilometers bereik LoRa-modules. Wil je alle opties naast elkaar vergelijken, zie dan draadloze communicatie met Arduino, en voor een verbinding met een telefoon onze gids over ESP32 Bluetooth.
Welke boards ondersteunen ESP-NOW?
| Board / chip | ESP-NOW | Opmerking |
|---|---|---|
| ESP32 (WROOM-32, DevKit) | Ja | Ondersteunt ook de Long Range (LR)-modus |
| ESP32-S2, S3, C3, C6 | Ja | Dezelfde Arduino-code, alleen de boardkeuze verandert |
| ESP32-C2 (ESP8684) | Ja | Geen LR-modus |
| ESP32-H2 | Nee | Geen Wi-Fi-radio, dus geen ESP-NOW |
| ESP8266 (NodeMCU, Wemos D1 Mini) | Ja | Andere bibliotheek (espnow.h), alleen v1 en 250 bytes |
| Raspberry Pi Pico W / Pico 2 W | Nee | De Wi-Fi-chip (CYW43439) kan geen ESP-NOW draaien |
| Arduino Uno, Nano, Mega | Nee | Kan via een seriële poort (UART) met een ESP32 worden verbonden |
ESP-NOW werkt ook tussen verschillende ESP-chips: een ESP32-C3-sensor kan pakketten sturen naar een klassieke ESP32-gateway of naar een ESP8266-board. De enige voorwaarden zijn dat beide kanten op hetzelfde Wi-Fi-kanaal zitten en dat de datastructuur aan beide kanten precies hetzelfde is gedefinieerd. De voorbeelden hieronder gebruiken twee ESP32 DevKit-boards; welke pins van jouw board veilig te gebruiken zijn, zie je in de tool Pinout.
Stap 1: zoek het MAC-adres van de ESP32
Bij ESP-NOW vindt elk board het andere via zijn 6 bytes lange MAC-adres; dit adres wordt in de fabriek in elke ESP32 geschreven en verandert nooit. Upload de onderstaande sketch naar het board dat je als ontvanger gebruikt en open de Serial Monitor op 115200 baud. Het adres wordt zowel leesbaar als als arrayregel afgedrukt, die je direct in de code van het andere board kunt plakken. Doe dit bij de voorbeelden met twee boards voor beide boards en noteer de adressen.
1#include <WiFi.h>
2#include <esp_wifi.h>
3
4void setup() {
5 Serial.begin(115200);
6 delay(1000);
7 WiFi.mode(WIFI_STA); // ESP-NOW istasyon arayüzünü kullanır / ESP-NOW uses the station interface
8
9 uint8_t mac[6];
10 if (esp_wifi_get_mac(WIFI_IF_STA, mac) == ESP_OK) {
11 Serial.printf("STA MAC: %02X:%02X:%02X:%02X:%02X:%02X\n",
12 mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
13 // Diğer karta kopyalanacak satır / line to paste into the other board's code
14 Serial.printf("uint8_t karsiMac[] = {0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X};\n",
15 mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
16 } else {
17 Serial.println("MAC okunamadi / could not read MAC");
18 }
19}
20
21void loop() {
22}Data versturen met een struct en de limiet van 250 bytes
ESP-NOW verstuurt alleen een array van bytes en weet niet wat erin zit. De nette manier om meerdere verschillende waarden tegelijk te sturen is ze te groeperen in een struct en de bytes van de struct precies zoals ze in het geheugen staan te versturen. De ontvanger definieert dezelfde struct en kopieert de binnenkomende bytes er met memcpy op. Hiervoor moet de struct aan beide kanten dezelfde volgorde, dezelfde typen en dezelfde grootte hebben. De compiler kan onzichtbare opvulbytes tussen velden invoegen voor snellere toegang: de Paket-struct in de voorbeelden hieronder neemt normaal 36 bytes in, maar komt op precies 30 bytes uit zodra je __attribute__((packed)) toevoegt. Met packed weet je zeker dat elke byte op dezelfde plek staat, tussen een ESP32 en een ESP8266 of tussen Arduino en MicroPython.
| Type | Grootte | Opmerking |
|---|---|---|
| bool, uint8_t, int8_t, char | 1 byte | Vlag, klein getal, enkel teken |
| int16_t, uint16_t | 2 bytes | −32768…32767 of 0…65535 |
| int, int32_t, uint32_t | 4 bytes | int is 4 bytes op de ESP32 en ESP8266, maar 2 bytes op de Arduino Uno |
| float | 4 bytes | Ongeveer 7 cijfers nauwkeurigheid |
| double | 8 bytes | Gebruik float tenzij je dit echt nodig hebt |
| char mesaj[16] | 16 bytes | Tekst met vaste lengte; moet eindigen op '\0' |
| String, char*, pointer | Kan niet worden verstuurd | Er gaat alleen een geheugenadres de lucht in, en dat betekent niets aan de andere kant |
Een pakket bevat maximaal 250 bytes. Deze limiet komt uit de eerste versie van ESP-NOW (v1) en geldt voor elk board, ook de ESP8266. Arduino core 3.2 en later, gebaseerd op ESP-IDF 5.4, kan met ESP-NOW v2 pakketten tot 1470 bytes versturen; een board met v1 (een ESP8266 of een ESP32 met een oudere core) kapt pakketten langer dan 250 bytes echter af of gooit ze helemaal weg. In een gemengd netwerk is binnen 250 bytes blijven dus de veiligste keuze. De regel static_assert in de zendersketch stopt het compileren met een duidelijke melding als de struct groter wordt dan 250 bytes. Moet je grotere data versturen, knip die dan in genummerde stukken en zet ze in volgorde weer in elkaar op de ontvanger; voor sensorwaarden, knopstanden of commando's zijn enkele tientallen bytes ruim voldoende.
ESP-NOW in één richting: de zendersketch
- Controleer of beide ESP32-boards in Arduino IDE zijn geselecteerd als ESP32 Dev Module. De ESP-NOW-bibliotheek maakt deel uit van het boardpakket, dus je hoeft verder niets te installeren.
- Vul het MAC-adres dat je van het ontvangende board hebt uitgelezen in bij de array aliciMac in de onderstaande code.
- Sluit op de zender een drukknop aan tussen GPIO 4 en GND; omdat we INPUT_PULLUP gebruiken, is geen extra weerstand nodig. Voor details zie Een knop aansluiten op een Arduino.
- Upload de sketch naar de zender en open de Serial Monitor op 115200 baud. Zolang de ontvanger nog niet draait, is het normaal dat je elke twee seconden "Teslim edilemedi / failed" ziet.
1#include <WiFi.h>
2#include <esp_now.h>
3#include <esp_idf_version.h>
4
5// Alıcının STA MAC adresi (mac_oku çıktısı) / receiver's STA MAC address (from the MAC sketch)
6uint8_t aliciMac[] = {0x24, 0x6F, 0x28, 0xAA, 0xBB, 0xCC};
7
8const int BUTON_PIN = 4; // buton GPIO 4 ile GND arasında / button between GPIO 4 and GND
9
10// İki kartta da birebir aynı olmalı / must be identical on both boards
11typedef struct __attribute__((packed)) {
12 uint8_t id; // gönderen kart numarası / sender board number
13 uint32_t sayac; // paket sayacı / packet counter
14 float sicaklik; // °C
15 float nem; // % bağıl nem / % relative humidity
16 bool buton; // buton basılı mı / is the button pressed
17 char mesaj[16]; // kısa metin, String değil / short text, not String
18} Paket;
19static_assert(sizeof(Paket) <= 250, "Paket 250 bayti asamaz / packet must not exceed 250 bytes");
20
21Paket paket;
22
23// Teslim sonucu: alıcı paketi aldıysa SUCCESS / delivery result: SUCCESS if the receiver got it
24#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 0)
25void gonderimSonucu(const esp_now_send_info_t *bilgi, esp_now_send_status_t durum) { // çekirdek 3.3+ / core 3.3+
26#else
27void gonderimSonucu(const uint8_t *mac, esp_now_send_status_t durum) { // çekirdek 2.x-3.2 / core 2.x-3.2
28#endif
29 Serial.println(durum == ESP_NOW_SEND_SUCCESS ? "Teslim edildi / delivered" : "Teslim edilemedi / failed");
30}
31
32void setup() {
33 Serial.begin(115200);
34 pinMode(BUTON_PIN, INPUT_PULLUP);
35 WiFi.mode(WIFI_STA); // önce Wi-Fi, sonra ESP-NOW / Wi-Fi first, then ESP-NOW
36
37 if (esp_now_init() != ESP_OK) {
38 Serial.println("ESP-NOW baslatilamadi / ESP-NOW init failed");
39 return;
40 }
41 esp_now_register_send_cb(gonderimSonucu);
42
43 esp_now_peer_info_t es = {}; // tüm alanları sıfırla / zero every field
44 memcpy(es.peer_addr, aliciMac, 6);
45 es.channel = 0; // 0 = şu anki kanal / 0 = current channel
46 es.ifidx = WIFI_IF_STA;
47 es.encrypt = false;
48 if (esp_now_add_peer(&es) != ESP_OK) {
49 Serial.println("Es eklenemedi / failed to add peer");
50 return;
51 }
52 paket.id = 1;
53}
54
55void loop() {
56 paket.sayac++;
57 paket.sicaklik = 20.0 + random(0, 100) / 10.0; // deneme değeri / test value
58 paket.nem = 40.0 + random(0, 200) / 10.0;
59 paket.buton = (digitalRead(BUTON_PIN) == LOW);
60 snprintf(paket.mesaj, sizeof(paket.mesaj), "Selam %lu", (unsigned long)paket.sayac);
61
62 esp_err_t sonuc = esp_now_send(aliciMac, (uint8_t *)&paket, sizeof(paket));
63 if (sonuc != ESP_OK) {
64 Serial.printf("Gonderme hatasi / send error: %s\n", esp_err_to_name(sonuc));
65 }
66 delay(2000);
67}De sketch start eerst Wi-Fi in WIFI_STA-modus; ESP-NOW kan niet werken zonder de Wi-Fi-radio, dus esp_now_init() moet altijd na de regel WiFi.mode() komen. Daarna wordt de ontvanger als peer aan de lijst toegevoegd. Het leegmaken van de struct esp_now_peer_info_t met = {} is belangrijk; willekeurige restwaarden in niet-geleegde velden veroorzaken de fout "Peer interface is invalid". channel = 0 betekent "gebruik het huidige kanaal van het board". esp_now_send() zet het pakket in een wachtrij en keert direct terug; ESP_OK betekent alleen dat het pakket is geaccepteerd om te verzenden. Het echte resultaat komt een paar milliseconden later binnen in de functie gonderimSonucu(): ESP_NOW_SEND_SUCCESS betekent dat de ontvanger het pakket op hardwareniveau heeft bevestigd. Het #if-blok bovenaan kiest de juiste vorm van de send-callback, die afhangt van de coreversie; dat leggen we uit in de sectie over core 3.x.
ESP-NOW-ontvangersketch
1#include <WiFi.h>
2#include <esp_now.h>
3#include <esp_idf_version.h>
4
5// Vericidekiyle birebir aynı yapı / exactly the same struct as the sender
6typedef struct __attribute__((packed)) {
7 uint8_t id;
8 uint32_t sayac;
9 float sicaklik;
10 float nem;
11 bool buton;
12 char mesaj[16];
13} Paket;
14
15Paket gelen;
16volatile bool yeniPaket = false;
17
18// Wi-Fi görevinde çalışır: kısa tut / runs in the Wi-Fi task: keep it short
19#if ESP_IDF_VERSION_MAJOR >= 5
20void veriGeldi(const esp_now_recv_info_t *bilgi, const uint8_t *veri, int uzunluk) { // çekirdek 3.x / core 3.x
21#else
22void veriGeldi(const uint8_t *mac, const uint8_t *veri, int uzunluk) { // çekirdek 2.x / core 2.x
23#endif
24 if (uzunluk != sizeof(Paket)) return; // farklı boyut: başka bir paket / wrong size: some other packet
25 memcpy(&gelen, veri, sizeof(Paket)); // veriyi hemen kopyala / copy the data right away
26 yeniPaket = true;
27}
28
29void setup() {
30 Serial.begin(115200);
31 WiFi.mode(WIFI_STA);
32
33 if (esp_now_init() != ESP_OK) {
34 Serial.println("ESP-NOW baslatilamadi / ESP-NOW init failed");
35 return;
36 }
37 esp_now_register_recv_cb(veriGeldi);
38 Serial.println("Alici hazir / receiver ready");
39}
40
41void loop() {
42 if (yeniPaket) {
43 yeniPaket = false;
44 Paket p = gelen; // kopya üzerinde çalış / work on a copy
45 p.mesaj[sizeof(p.mesaj) - 1] = '\0'; // metin her zaman sonlansın / always terminate the text
46 Serial.printf("id=%u sayac=%lu sicaklik=%.1f nem=%.1f buton=%d mesaj=%s\n",
47 (unsigned)p.id, (unsigned long)p.sayac, p.sicaklik, p.nem, (int)p.buton, p.mesaj);
48 }
49}Op de ontvanger komen pakketten binnen in de functie veriGeldi(). Deze functie draait niet in je loop(), maar in de taak met hoge prioriteit van Wi-Fi, dus je moet er geen Serial.print, delay of lange berekeningen in gebruiken. De juiste aanpak is controleren of de pakketgrootte overeenkomt met de verwachte struct, de data met memcpy naar je eigen variabele kopiëren en loop() via een volatile-vlag op de hoogte brengen. Op core 3.x vertelt de parameter bilgi je ook wie het pakket heeft gestuurd (bilgi->src_addr) en de signaalsterkte (bilgi->rx_ctrl->rssi, in dBm); deze informatie is alleen binnen de functie geldig, dus kopieer haar als je haar later nodig hebt. De ontvanger hoeft de zender niet als peer toe te voegen: onversleutelde unicastpakketten en broadcasts worden geaccepteerd van boards die niet in de lijst staan.
Communicatie in twee richtingen: twee ESP32-boards die elkaar bedienen
Bij communicatie in twee richtingen is elk board zowel zender als ontvanger. Je uploadt de onderstaande sketch naar beide boards; het enige verschil is dat je op elk board het adres van het andere board invult in de array karsiMac. Als je op de knop van het ene board drukt, gaat de led op het andere board aan of uit, en het board dat zijn led heeft gewijzigd meldt dit terug met een bevestigingsbericht. De bedrading is op beide boards hetzelfde:
| Onderdeel | ESP32-pin | Opmerking |
|---|---|---|
| Knop | GPIO 4 en GND | Gebruikt de interne pull-up, geen extra weerstand nodig |
| LED | GPIO 2 | Ingebouwde blauwe led op de meeste DevKits; gebruik een weerstand van 220 Ω voor een externe led |
| Voeding | USB | De boards kunnen worden gevoed via aparte USB-poorten of adapters |
1#include <WiFi.h>
2#include <esp_now.h>
3#include <esp_idf_version.h>
4
5// Bu kodu iki karta da yükle; yalnız karşı kartın MAC adresini değiştir
6// Upload to both boards; change only the other board's MAC address
7uint8_t karsiMac[] = {0x24, 0x6F, 0x28, 0xAA, 0xBB, 0xCC};
8
9const int BUTON_PIN = 4; // buton GPIO 4 ile GND arasında / button between GPIO 4 and GND
10const int LED_PIN = 2; // dahili LED / onboard LED
11
12typedef struct __attribute__((packed)) {
13 uint8_t tur; // 1 = komut, 2 = onay / 1 = command, 2 = acknowledgement
14 bool ledAcik; // istenen ya da uygulanan durum / requested or applied state
15} Mesaj;
16
17volatile bool komutGeldi = false;
18volatile bool onayGeldi = false;
19volatile bool gelenLed = false;
20bool karsiLed = false; // karşı karttaki LED için son isteğimiz / our last request for the other LED
21int sonButon = HIGH;
22
23#if ESP_IDF_VERSION_MAJOR >= 5
24void veriGeldi(const esp_now_recv_info_t *bilgi, const uint8_t *veri, int uzunluk) { // çekirdek 3.x / core 3.x
25#else
26void veriGeldi(const uint8_t *mac, const uint8_t *veri, int uzunluk) { // çekirdek 2.x / core 2.x
27#endif
28 if (uzunluk != sizeof(Mesaj)) return;
29 Mesaj m;
30 memcpy(&m, veri, sizeof(m));
31 if (m.tur == 1) {
32 gelenLed = m.ledAcik;
33 komutGeldi = true;
34 } else if (m.tur == 2) {
35 onayGeldi = true;
36 }
37}
38
39void gonder(uint8_t tur, bool ledAcik) {
40 Mesaj m = {tur, ledAcik};
41 esp_now_send(karsiMac, (uint8_t *)&m, sizeof(m));
42}
43
44void setup() {
45 Serial.begin(115200);
46 pinMode(BUTON_PIN, INPUT_PULLUP);
47 pinMode(LED_PIN, OUTPUT);
48 WiFi.mode(WIFI_STA);
49
50 if (esp_now_init() != ESP_OK) {
51 Serial.println("ESP-NOW baslatilamadi / ESP-NOW init failed");
52 return;
53 }
54 esp_now_register_recv_cb(veriGeldi);
55
56 esp_now_peer_info_t es = {};
57 memcpy(es.peer_addr, karsiMac, 6);
58 es.ifidx = WIFI_IF_STA; // kanal 0, şifresiz / channel 0, unencrypted
59 esp_now_add_peer(&es);
60}
61
62void loop() {
63 // 1) Butona basılınca karşı kartın LED'ini değiştir / on press, toggle the other board's LED
64 int buton = digitalRead(BUTON_PIN);
65 if (buton != sonButon) {
66 delay(30); // kontak sıçramasını bekle / wait out contact bounce
67 buton = digitalRead(BUTON_PIN);
68 if (sonButon == HIGH && buton == LOW) {
69 karsiLed = !karsiLed;
70 gonder(1, karsiLed);
71 Serial.println(karsiLed ? "Komut: AC / command: ON" : "Komut: KAPAT / command: OFF");
72 }
73 sonButon = buton;
74 }
75
76 // 2) Gelen komutu uygula ve onay gönder / apply an incoming command and reply
77 if (komutGeldi) {
78 komutGeldi = false;
79 digitalWrite(LED_PIN, gelenLed ? HIGH : LOW);
80 gonder(2, gelenLed);
81 }
82
83 // 3) Karşı karttan gelen onay / acknowledgement from the other board
84 if (onayGeldi) {
85 onayGeldi = false;
86 Serial.println("Karsi kart uyguladi / the other board applied it");
87 }
88}Het veld tur in de berichtstruct geeft aan wat voor pakket het is: 1 is een commando, 2 is een bevestiging. Het board waarvan de knop wordt ingedrukt, verstuurt de gewenste status voor de led van het andere board; het board dat het commando ontvangt, zet zijn led en stuurt dezelfde status terug met type 2. Zo krijgt de zender zowel de hardware-ACK als de bevestiging dat "de led echt is veranderd". Het binnengekomen commando wordt weer met volatile-vlaggen doorgegeven aan loop(), en daar worden digitalWrite en het antwoord uitgevoerd. Dit is veiliger dan esp_now_send() aanroepen vanuit de callback. De wachttijd van 30 ms bij de knop filtert contactdender weg. Sluit een relais aan in plaats van de led en dezelfde code wordt een draadloze lichtschakelaar; voor de bedrading van een relais zie Wat is een relaismodule?.
Meerdere apparaten: de limiet van 20 peers en broadcast
ESP-NOW ondersteunt alle drie de opstellingen: één zender naar veel ontvangers (een afstandsbediening naar vijf relaisboards), veel zenders naar één ontvanger (vijf sensoren naar één gateway) en netwerken waarin iedereen met iedereen praat. De peerlijst van een board kan maximaal 20 items bevatten, en standaard kunnen er maar 7 versleuteld zijn. Deze limiet geldt alleen voor de boards waar je naar verstuurt. Een gateway hoeft sensoren die hem onversleutelde pakketten sturen niet toe te voegen, dus hij kan naar meer dan 20 sensoren luisteren. Is de lijst vol, dan geeft esp_now_add_peer() ESP_ERR_ESPNOW_FULL terug; dan kun je peers die je niet meer nodig hebt verwijderen met esp_now_del_peer() en nieuwe toevoegen. De onderstaande sketch voegt drie ontvangers en het broadcastadres toe aan de lijst en verstuurt daarna zowel één voor één als via broadcast:
1#include <WiFi.h>
2#include <esp_now.h>
3
4// Üç alıcının STA MAC adresleri / STA MAC addresses of three receivers
5uint8_t alicilar[3][6] = {
6 {0x24, 0x6F, 0x28, 0x11, 0x11, 0x11},
7 {0x24, 0x6F, 0x28, 0x22, 0x22, 0x22},
8 {0x24, 0x6F, 0x28, 0x33, 0x33, 0x33}
9};
10uint8_t yayinMac[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; // yayın adresi / broadcast address
11
12typedef struct __attribute__((packed)) {
13 uint8_t hedef; // 0 = herkes, 1-3 = tek alıcı / 0 = everyone, 1-3 = one receiver
14 uint32_t sayac;
15} Komut;
16
17Komut komut;
18
19bool esEkle(const uint8_t *mac) {
20 esp_now_peer_info_t es = {};
21 memcpy(es.peer_addr, mac, 6);
22 es.ifidx = WIFI_IF_STA;
23 return esp_now_add_peer(&es) == ESP_OK;
24}
25
26void setup() {
27 Serial.begin(115200);
28 WiFi.mode(WIFI_STA);
29 if (esp_now_init() != ESP_OK) {
30 Serial.println("ESP-NOW baslatilamadi / ESP-NOW init failed");
31 return;
32 }
33 for (int i = 0; i < 3; i++) esEkle(alicilar[i]);
34 esEkle(yayinMac); // yayın da eş olarak eklenmeli / broadcast must be added as a peer too
35
36 esp_now_peer_num_t sayi;
37 esp_now_get_peer_num(&sayi);
38 Serial.printf("Kayitli es / registered peers: %d / 20\n", sayi.total_num);
39}
40
41void loop() {
42 komut.sayac++;
43
44 // 1) Tek tek: her alıcıya ayrı paket ve ayrı teslim onayı / one by one: separate packet and ACK each
45 for (int i = 0; i < 3; i++) {
46 komut.hedef = i + 1;
47 esp_now_send(alicilar[i], (uint8_t *)&komut, sizeof(komut));
48 delay(10);
49 }
50 delay(2000);
51
52 // 2) Yayın: tek paket, aynı kanaldaki herkes alır, onay yok / broadcast: one packet, everyone on the channel, no ACK
53 komut.hedef = 0;
54 esp_now_send(yayinMac, (uint8_t *)&komut, sizeof(komut));
55 delay(2000);
56}Het broadcastadres FF:FF:FF:FF:FF:FF moet ook als peer worden toegevoegd voordat je ernaar verstuurt. Eén broadcastpakket bereikt elke ESP-NOW-ontvanger op hetzelfde kanaal; je hoeft de MAC-adressen van de ontvangers niet te kennen, waardoor dit de makkelijkste methode is om in te stellen. De prijs is dat broadcasts geen ontvangstbevestiging hebben, het verzendresultaat er altijd geslaagd uitziet en broadcastpakketten niet kunnen worden versleuteld. Bij één voor één versturen krijgt elk pakket zijn eigen ACK. Geef je NULL als adres mee aan esp_now_send(), dan wordt het pakket apart naar elke peer in de lijst gestuurd; staat het broadcastadres ook in de lijst, dan gaat het pakket ook één keer als broadcast de lucht in. Een praktische aanpak voor veel projecten is de boards elkaar bij de eerste start via een broadcast te laten vinden, daarna hun MAC-adressen te leren en over te stappen op unicast met bevestiging.
Bereik en snelheid van ESP-NOW
| Maat | Typische waarde | Opmerking |
|---|---|---|
| Bereik binnenshuis | 20–40 m (1–3 muren) | Muren van gewapend beton en metalen voorwerpen verzwakken het signaal het meest |
| Bereik in open ruimte | 100–200 m | Met de ingebouwde printantenne; neemt toe als de boards hoger boven de grond staan |
| LR-modus (Long Range) | Tot 1 km | Waarde van Espressif bij zichtlijn; de snelheid zakt naar 0,5 of 0,25 Mbps |
| Standaard datasnelheid | 1 Mbps | Een hogere snelheid betekent een korter bereik |
| Zendtijd van een pakket van 250 bytes | Ongeveer 2,5 ms | Ongeveer 3 ms per pakket inclusief ACK en wachttijden |
| Theoretische pakketsnelheid | ~300 pakketten per seconde (~70 kB/s) | Met pakketten van 250 bytes; in de praktijk lager |
| Vertraging van een commando | Een paar milliseconden | Geen verbinding opzetten of server nodig |
Deze waarden variëren sterk met de omgeving, maar de berekening is eenvoudig. Bij de standaard 1 Mbps blijft elke byte 8 microseconden in de lucht; 250 bytes data met headers en de sync-preamble duren ongeveer 2,5 ms. Met de ACK van de ontvanger en de tijd die je wacht op een vrij kanaal heb je ongeveer 3 ms per pakket nodig, dus er kunnen hooguit zo'n 300 pakketten per seconde worden verstuurd. Dat is ruim voldoende voor sensordata en commando's, maar ESP-NOW is niet geschikt voor het streamen van audio of video. Om het bereik te vergroten, plaats je de boards hoog boven de grond, bedek je de antenne niet met een metalen doos, batterijen of kabels, gebruik je modules met een externe antenne (zoals de ESP32-WROOM-32U) en schakel je de Long Range (LR)-modus van Espressif aan beide kanten in met esp_wifi_set_protocol(WIFI_IF_STA, WIFI_PROTOCOL_LR). LR werkt alleen tussen twee ESP32-boards; een interface die alleen op LR staat kan geen verbinding maken met gewone routers, en de ESP8266 en ESP32-C2 ondersteunen deze modus niet. Print bij het testen van het bereik op core 3.x bilgi->rx_ctrl->rssi op de ontvanger: −50 dBm is een heel sterk signaal, −80 dBm zit dicht bij de grens en rond −90 dBm begint pakketverlies.
Wijzigingen in ESP32 Arduino core 3.x
De meeste ESP-NOW-voorbeelden op internet zijn geschreven voor ESP32 Arduino core 2.x. Als je versie 3.x via de Boards Manager hebt geïnstalleerd, compileert die code niet, omdat Espressif met ESP-IDF 5 de vorm van de callback-functies heeft veranderd. De wijzigingen kwamen in twee stappen: core 3.0 veranderde de receive-callback en core 3.3, gebaseerd op ESP-IDF 5.5, veranderde de send-callback. Welke versie je hebt, zie je naast het esp32-pakket onder Tools > Board > Boards Manager.
| Onderwerp | Core 2.x | Core 3.0–3.2 | Core 3.3 en later |
|---|---|---|---|
| Receive-callback | (const uint8_t *mac, const uint8_t *veri, int uzunluk) | (const esp_now_recv_info_t *bilgi, const uint8_t *veri, int uzunluk) | Hetzelfde als 3.0 |
| Adres van de zender | mac | bilgi->src_addr | bilgi->src_addr |
| Send-callback | (const uint8_t *mac, esp_now_send_status_t durum) | Hetzelfde als 2.x | (const esp_now_send_info_t *bilgi, esp_now_send_status_t durum) |
| Grootste pakket | 250 bytes | 250 bytes; 1470 bytes met v2 op 3.2 | 1470 bytes met v2 |
| Het kanaal instellen | esp_wifi_set_channel() | Ook WiFi.setChannel() | Hetzelfde als 3.0 |
| Kant-en-klare klassenbibliotheek | Geen | ESP32_NOW.h (ESP_NOW_Peer, ESP_NOW_Serial) | ESP32_NOW.h met v2-ondersteuning |
Als je oude code op 3.x compileert, zie je voor de receive-callback de fout invalid conversion from 'void (*)(const uint8_t*, const uint8_t*, int)' ... to 'esp_now_recv_cb_t'. De oplossing is de eerste parameter van de functie const esp_now_recv_info_t * te maken en het adres van de zender uit bilgi->src_addr te lezen. Ga je over naar core 3.3, dan verschijnt een vergelijkbare fout, nu voor esp_now_send_cb_t; de eerste parameter van de send-callback moet const esp_now_send_info_t * zijn en het adres van de ontvanger staat in bilgi->des_addr. De sketches in deze gids gebruiken de macro ESP_IDF_VERSION om zelf de juiste vorm te kiezen, dus ze compileren ongewijzigd op 2.x, 3.0–3.2 en 3.3+. Core 3.x introduceerde ook een op klassen gebaseerde bibliotheek, ESP32_NOW.h: je schrijft onReceive() en onSent() in een klasse die is afgeleid van ESP_NOW_Peer, en met de klasse ESP_NOW_Serial gebruik je een ESP-NOW-verbinding net als Serial. De voorbeelden vind je onder ESP_NOW in het menu File > Examples. Wij gebruiken de functies van esp_now.h rechtstreeks, omdat die compatibel blijven met de ESP8266 en met oudere code.
ESP-NOW en Wi-Fi tegelijk: het kanaal afstemmen
De ESP32 heeft één 2,4 GHz-radio, en die kan maar op één kanaal tegelijk werken. Zodra het board verbinding maakt met een router, bepaalt de router, niet jij, het kanaal; zit de router op kanaal 6, dan draait ESP-NOW ook op kanaal 6. Elke sensor die pakketten naar een gateway met Wi-Fi-verbinding stuurt, moet dus ook overschakelen naar het kanaal van de router. Komen de kanalen niet overeen, dan print de zender "failed"; als je de peer met een kanaal ongelijk aan nul hebt toegevoegd, toont de Serial Monitor ook de fout "ESPNOW: Peer channel is not equal to the home channel, send fail!". Volg deze regels voor een probleemloze opstelling:
- De gateway maakt eerst verbinding met Wi-Fi, start daarna ESP-NOW en print het kanaal van de router met WiFi.channel() naar de Serial Monitor.
- De sensoren maken geen verbinding met de router; ze vinden het kanaal door te scannen op de netwerknaam (WiFi.scanNetworks() en WiFi.channel(i)) of gebruiken een vast kanaal in de code. Het Wi-Fi-wachtwoord hebben ze hiervoor niet nodig.
- Zet het kanaal van je router van "Auto" op een vast kanaal (1, 6 of 11). In automatische modus raken de sensoren de gateway kwijt als de router van kanaal wisselt.
- Schakel energiebesparing op de gateway uit met WiFi.setSleep(false). Standaard laat een ESP32 die met een router is verbonden zijn radio met tussenpozen slapen en kan hij ESP-NOW-pakketten missen die in die tijd binnenkomen.
- Vul op de sensoren het STA-MAC-adres van de gateway in; de onderstaande gatewaysketch print dit adres bij het opstarten naar de Serial Monitor.
De onderstaande gatewaysketch maakt verbinding met je thuisnetwerk, bewaart de metingen van maximaal vijf sensoren en toont ze op een eenvoudige webpagina die je kunt openen vanaf een telefoon op hetzelfde netwerk. Vervang de netwerknaam en het wachtwoord door je eigen gegevens en open na het uploaden het IP-adres dat in de Serial Monitor staat in de browser van je telefoon:
1#include <WiFi.h>
2#include <WebServer.h>
3#include <esp_now.h>
4#include <esp_idf_version.h>
5
6const char *ssid = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
7const char *sifre = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
8
9// Sensör kodundakiyle birebir aynı / identical to the sensor sketch
10typedef struct __attribute__((packed)) {
11 uint8_t id; // sensör numarası 1-5 / sensor number 1-5
12 uint32_t sayac;
13 float sicaklik;
14 float nem;
15 float pil; // pil gerilimi (V) / battery voltage (V)
16} SensorPaketi;
17
18const int SENSOR_SAYISI = 5;
19SensorPaketi sonVeri[SENSOR_SAYISI + 1]; // 1..5 kullanılır / indexes 1..5 are used
20unsigned long sonZaman[SENSOR_SAYISI + 1]; // son paketin zamanı / time of the last packet
21QueueHandle_t kuyruk;
22WebServer server(80);
23
24#if ESP_IDF_VERSION_MAJOR >= 5
25void veriGeldi(const esp_now_recv_info_t *bilgi, const uint8_t *veri, int uzunluk) { // çekirdek 3.x / core 3.x
26#else
27void veriGeldi(const uint8_t *mac, const uint8_t *veri, int uzunluk) { // çekirdek 2.x / core 2.x
28#endif
29 if (uzunluk != sizeof(SensorPaketi)) return;
30 SensorPaketi p;
31 memcpy(&p, veri, sizeof(p));
32 xQueueSend(kuyruk, &p, 0); // kuyruğa at, Wi-Fi görevini bekletme / queue it, never block the Wi-Fi task
33}
34
35void anaSayfa() {
36 String html = "<meta name='viewport' content='width=device-width'>"
37 "<meta http-equiv='refresh' content='10'>"
38 "<h2>ESP-NOW sensorleri</h2><table border=1 cellpadding=6>"
39 "<tr><th>ID</th><th>Sicaklik</th><th>Nem</th><th>Pil</th><th>Son paket</th></tr>";
40 for (int i = 1; i <= SENSOR_SAYISI; i++) {
41 if (sonZaman[i] == 0) continue; // bu sensörden veri yok / no data from this sensor yet
42 html += "<tr><td>" + String(i) + "</td><td>" + String(sonVeri[i].sicaklik, 1) +
43 " °C</td><td>%" + String(sonVeri[i].nem, 0) + "</td><td>" + String(sonVeri[i].pil, 2) +
44 " V</td><td>" + String((millis() - sonZaman[i]) / 1000) + " sn once</td></tr>";
45 }
46 html += "</table>";
47 server.send(200, "text/html", html);
48}
49
50void setup() {
51 Serial.begin(115200);
52 kuyruk = xQueueCreate(10, sizeof(SensorPaketi));
53
54 WiFi.mode(WIFI_STA);
55 WiFi.begin(ssid, sifre);
56 while (WiFi.status() != WL_CONNECTED) delay(500);
57 WiFi.setSleep(false); // güç tasarrufu kapalı: paket kaçmaz / power save off: no missed packets
58
59 Serial.print("IP: ");
60 Serial.println(WiFi.localIP());
61 Serial.printf("Kanal / channel: %d\n", (int)WiFi.channel());
62 Serial.print("Gecit MAC / gateway MAC: ");
63 Serial.println(WiFi.macAddress()); // sensörlere bu adresi yaz / put this address in the sensors
64
65 if (esp_now_init() != ESP_OK) {
66 Serial.println("ESP-NOW baslatilamadi / ESP-NOW init failed");
67 return;
68 }
69 esp_now_register_recv_cb(veriGeldi);
70
71 server.on("/", anaSayfa);
72 server.begin();
73}
74
75void loop() {
76 SensorPaketi p;
77 while (xQueueReceive(kuyruk, &p, 0) == pdTRUE) {
78 if (p.id >= 1 && p.id <= SENSOR_SAYISI) {
79 sonVeri[p.id] = p;
80 sonZaman[p.id] = millis();
81 Serial.printf("Sensor %u: %.1f C %%%.0f %.2f V\n", (unsigned)p.id, p.sicaklik, p.nem, p.pil);
82 }
83 }
84 server.handleClient();
85}In de receive-callback zet de gateway het pakket alleen in een FreeRTOS-wachtrij en keert direct terug. loop() leegt de wachtrij en bewaart per sensor de laatste meting en het aankomsttijdstip, en de webserver toont die tabel. De wachtrij zorgt ervoor dat geen pakket verloren gaat als meerdere sensoren op hetzelfde moment sturen; het is ook de praktische manier om het advies van Espressif te volgen om geen lange taken in callbacks uit te voeren. De pagina ververst zichzelf elke 10 seconden, en de kolom "Son paket" (laatste pakket) laat meteen zien of een sensor stil is geworden (lege batterij of buiten bereik?). Kan de gateway helemaal geen verbinding maken met Wi-Fi, dan ligt het probleem niet bij ESP-NOW; loop dan de controles door in ESP32 maakt geen verbinding met Wi-Fi. Wil je de data in een domoticasysteem gebruiken, dan kun je in plaats van de webpagina MQTT en Home Assistant gebruiken.
Voorbeeld van een draadloze sensor: DHT22, deep sleep en ESP-NOW
Nu bouwen we de sensor op batterijen die data naar de gateway stuurt. Elke keer als hij wakker wordt, meet de sensor temperatuur, luchtvochtigheid en batterijspanning, verstuurt hij één ESP-NOW-pakket, wacht hij op de ACK en gaat hij 60 seconden in deep sleep. We gebruiken een DHT22 voor temperatuur en luchtvochtigheid; je moet de DHT sensor library van Adafruit installeren via de Library Manager. Hoe de sensor werkt, lees je in onze gids over de DHT11-sensor voor temperatuur en luchtvochtigheid; de bedrading is bij de DHT22 hetzelfde en in de code stel je alleen het sensortype in op DHT22.




| Verbinding | ESP32-pin | Opmerking |
|---|---|---|
| DHT22 VCC (+) | 3V3 | Werkt op 3,3–5 V |
| DHT22 DATA | GPIO 4 | Voeg bij een kale sensor een weerstand van 10 kΩ toe tussen DATA en 3V3 |
| DHT22 GND (−) | GND | Gemeenschappelijke massa |
| Batterij + | GPIO 34 (via de spanningsdeler) | Twee weerstanden van 100 kΩ; een batterij van 4,2 V komt als 2,1 V op de pin |
| Batterij − | GND | De onderste weerstand van de deler gaat ook naar GND |
1#include <WiFi.h>
2#include <esp_now.h>
3#include <esp_wifi.h>
4#include <esp_idf_version.h>
5#include <DHT.h>
6
7const char *AG_ADI = "AgAdi"; // ağ geçidinin bağlandığı Wi-Fi (şifre gerekmez) / Wi-Fi the gateway uses (no password needed)
8uint8_t gecitMac[] = {0x24, 0x6F, 0x28, 0xAA, 0xBB, 0xCC}; // ağ geçidinin STA MAC adresi / gateway STA MAC
9const uint8_t SENSOR_ID = 1; // her sensöre farklı numara / a different number for each sensor
10const uint64_t UYKU_US = 60ULL * 1000000ULL; // 60 saniye uyku / sleep for 60 seconds
11
12#define DHT_PIN 4
13#define PIL_PIN 34 // ADC1 pini, 100k + 100k bölücü / ADC1 pin, 100k + 100k divider
14DHT dht(DHT_PIN, DHT22);
15
16typedef struct __attribute__((packed)) {
17 uint8_t id;
18 uint32_t sayac;
19 float sicaklik;
20 float nem;
21 float pil;
22} SensorPaketi;
23
24RTC_DATA_ATTR uint8_t kanal = 0; // derin uykuda silinmez / kept during deep sleep
25RTC_DATA_ATTR uint32_t paketSayaci = 0;
26volatile bool sonucGeldi = false;
27volatile bool teslimEdildi = false;
28
29#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 0)
30void gonderimSonucu(const esp_now_send_info_t *bilgi, esp_now_send_status_t durum) { // çekirdek 3.3+ / core 3.3+
31#else
32void gonderimSonucu(const uint8_t *mac, esp_now_send_status_t durum) { // çekirdek 2.x-3.2 / core 2.x-3.2
33#endif
34 teslimEdildi = (durum == ESP_NOW_SEND_SUCCESS);
35 sonucGeldi = true;
36}
37
38uint8_t kanalBul(const char *ag) { // ağın kanalını tarayarak bul / find the network's channel by scanning
39 int n = WiFi.scanNetworks();
40 for (int i = 0; i < n; i++) {
41 if (WiFi.SSID(i) == ag) return WiFi.channel(i);
42 }
43 return 1; // bulunamazsa kanal 1 / channel 1 if not found
44}
45
46void uyu() {
47 esp_sleep_enable_timer_wakeup(UYKU_US);
48 esp_deep_sleep_start();
49}
50
51void setup() {
52 Serial.begin(115200);
53 dht.begin();
54 WiFi.mode(WIFI_STA);
55
56 if (kanal == 0) kanal = kanalBul(AG_ADI); // yalnız ilk açılışta ya da hatadan sonra tara / scan only at first boot or after a failure
57 esp_wifi_set_promiscuous(true);
58 esp_wifi_set_channel(kanal, WIFI_SECOND_CHAN_NONE);
59 esp_wifi_set_promiscuous(false);
60
61 if (esp_now_init() != ESP_OK) uyu();
62 esp_now_register_send_cb(gonderimSonucu);
63
64 esp_now_peer_info_t es = {};
65 memcpy(es.peer_addr, gecitMac, 6);
66 es.channel = kanal;
67 es.ifidx = WIFI_IF_STA;
68 esp_now_add_peer(&es);
69
70 SensorPaketi p;
71 p.id = SENSOR_ID;
72 p.sayac = ++paketSayaci;
73 p.sicaklik = dht.readTemperature();
74 p.nem = dht.readHumidity();
75 p.pil = analogReadMilliVolts(PIL_PIN) * 2 / 1000.0; // bölücü yarıya indirir / the divider halves it
76
77 esp_now_send(gecitMac, (uint8_t *)&p, sizeof(p));
78 unsigned long baslangic = millis();
79 while (!sonucGeldi && millis() - baslangic < 200) delay(1); // en fazla 200 ms bekle / wait up to 200 ms
80
81 Serial.printf("Kanal %u, %.1f C, %%%.0f, %.2f V, %s\n", (unsigned)kanal, p.sicaklik, p.nem, p.pil,
82 teslimEdildi ? "teslim edildi / delivered" : "teslim edilemedi / failed");
83 if (!teslimEdildi) kanal = 0; // teslim edilemedi: sonraki uyanışta yeniden tara / not delivered: rescan next wake
84 Serial.flush();
85 uyu();
86}
87
88void loop() {
89}De sleutel van deze sketch zijn de variabelen met RTC_DATA_ATTR. In deep sleep wordt het hoofdgeheugen van de ESP32 gewist, maar deze variabelen in het RTC-geheugen blijven bewaard. De sensor zoekt het kanaal alleen bij de eerste start door te scannen (dat duurt ongeveer 2 seconden) en gebruikt dat kanaal bij latere keren direct; kan een pakket niet worden afgeleverd, dan reset hij de kanaalvariabele en scant hij bij het volgende ontwaken opnieuw. Zelfs als de router van kanaal wisselt, herstelt de sensor zich dus na één cyclus. De batterijspanning wordt al gekalibreerd uitgelezen met analogReadMilliVolts() en met 2 vermenigvuldigd omdat de deler haar halveert; de weerstandswaarden kun je controleren in de tool Spanningsdeler. GPIO 34 is een ADC1-pin; dat is belangrijk, want ADC2-pins kunnen geen analoge metingen doen zolang de Wi-Fi-radio aan staat. Voor de details over slaapmodi zie onze gids ESP32 Deep Sleep.
Laten we de levensduur van de batterij grof schatten. Een start zonder scan (opstarten, meten en versturen) duurt ongeveer 0,3 seconden en verbruikt gemiddeld ongeveer 100 mA, wat neerkomt op ruwweg 0,008 mAh per keer. Eén keer per minuut wakker worden geeft 1440 keer per dag, samen ongeveer 12 mAh. Een kale ESP32-module verbruikt in deep sleep rond 10 µA; samen met de standby-stroom van de DHT22 en de deelweerstanden blijft het slaapverbruik onder 2 mAh per dag. De sensor gebruikt dus ongeveer 14 mAh per dag, en een 18650-cel van 2000 mAh gaat 4–5 maanden mee. Om met je eigen waarden te rekenen, gebruik je de Batterijduurcalculator.
ESP-NOW met de ESP8266

ESP8266-boards kunnen ESP-NOW gebruiken in hetzelfde netwerk als ESP32-boards, maar hun Arduino-bibliotheek is anders: je neemt espnow.h op in plaats van esp_now.h en ESP8266WiFi.h in plaats van WiFi.h, en de functies komen uit de ESP8266 SDK in plaats van uit ESP-IDF. De belangrijkste verschillen zijn:
| Taak | ESP32 (esp_now.h) | ESP8266 (espnow.h) |
|---|---|---|
| Initialiseren | esp_now_init() == ESP_OK | esp_now_init() == 0 |
| Rol | Niet nodig | esp_now_set_self_role(ESP_NOW_ROLE_COMBO) |
| Een peer toevoegen | esp_now_add_peer(&es) met een struct | esp_now_add_peer(mac, ESP_NOW_ROLE_COMBO, channel, NULL, 0) |
| Receive-callback | (const esp_now_recv_info_t *bilgi, const uint8_t *veri, int uzunluk) | (uint8_t *mac, uint8_t *data, uint8_t len) |
| Send-callback | (..., esp_now_send_status_t durum) | (uint8_t *mac, uint8_t status); 0 betekent gelukt |
| Grootste pakket | 250 bytes (1470 met v2) | 250 bytes |
Vergeet op de ESP8266 niet WiFi.disconnect() toe te voegen na WiFi.mode(WIFI_STA); bij het opstarten probeert de ESP8266 uit zichzelf opnieuw verbinding te maken met de laatst gebruikte router, wat het kanaal verandert en tot verloren pakketten kan leiden. Als je de datastruct aan beide kanten als packed definieert, lezen de ESP32 en ESP8266 dezelfde bytes op dezelfde manier, omdat beide 32-bits little-endian-processors zijn. Voor de pins en de installatie van de ESP8266 zie onze gids ESP8266 NodeMCU.
ESP-NOW met MicroPython en de Raspberry Pi Pico
Programmeer je de ESP32 in MicroPython, dan is er een kant-en-klare module espnow voor ESP-NOW; die zit in de MicroPython-builds voor de ESP32 en ESP8266. De onderstaande code ontvangt de Paket-struct van 30 bytes die het Arduino-zendervoorbeeld verstuurt en decodeert hem met struct.unpack(). In de formatstring betekent < little-endian zonder opvulling; B is een getal van 1 byte, I een 4 bytes unsigned getal, f een float en 16s 16 bytes tekst. Het bool-veld van Arduino wordt met B gelezen als 0 of 1. Upload de code met Thonny naar het board en vul het MAC-adres dat het print in bij de array aliciMac van de Arduino-zender:
1import network
2import espnow
3import struct
4import binascii
5
6sta = network.WLAN(network.STA_IF) # ESP-NOW istasyon arayüzünü kullanır / ESP-NOW uses the station interface
7sta.active(True)
8print("MAC:", binascii.hexlify(sta.config("mac"), ":").decode()) # bu adresi vericiye yaz / put it in the sender
9
10e = espnow.ESPNow()
11e.active(True)
12
13BICIM = "<BIffB16s" # Arduino'daki Paket yapısı / the Paket struct from Arduino
14BOYUT = struct.calcsize(BICIM) # 30 bayt / 30 bytes
15
16while True:
17 mac, msg = e.recv() # paket gelene kadar bekle / wait for a packet
18 if msg and len(msg) == BOYUT:
19 kimlik, sayac, sicaklik, nem, buton, mesaj = struct.unpack(BICIM, msg)
20 metin = mesaj.split(b"\x00")[0].decode()
21 print(binascii.hexlify(mac, ":").decode(), kimlik, sayac,
22 round(sicaklik, 1), round(nem, 1), bool(buton), metin)Een pakket versturen vanuit MicroPython kost ook twee regels: voeg de ontvanger toe met e.add_peer(mac) en verstuur dezelfde struct met e.send(mac, struct.pack(BICIM, 2, 1, 23.5, 45.0, 0, b"Selam")), zodat Arduino- en MicroPython-boards in hetzelfde netwerk kunnen samenwerken. Schakel op een MicroPython-board dat met Wi-Fi is verbonden de energiebesparing uit met sta.config(pm=sta.PM_NONE), zodat je geen pakketten mist. Ben je nieuw met MicroPython, begin dan met onze gids MicroPython-basis. De Raspberry Pi Pico-familie heeft echter geen ESP-NOW: de standaard Pico heeft helemaal geen draadloze verbinding, en de CYW43439-chip op de Pico W en Pico 2 W draait alleen standaard Wi-Fi en Bluetooth. Om een Pico in een ESP-NOW-netwerk te krijgen, sluit je er via seriële UART-communicatie een kleine ESP32-C3 op aan als brug, of laat je de Pico W via Wi-Fi met de gateway praten; Wi-Fi op de Pico W komt aan bod in Wi-Fi en webserver op de Pico W. Dezelfde brugaanpak werkt voor de Arduino Uno.
ESP-NOW-pakketten versleutelen
Standaard zijn ESP-NOW-pakketten onversleuteld; iedereen op hetzelfde kanaal kan ze in de lucht onderscheppen en valse pakketten sturen die jouw struct nabootsen. Gebruik versleuteling voor projecten zoals deursloten of garagedeuren. ESP-NOW gebruikt CCMP, zoals WPA2, en werkt met twee sleutels: een PMK van 16 bytes die op alle apparaten hetzelfde is (ingesteld met esp_now_set_pmk()) en een aparte LMK van 16 bytes voor elke peer. Bij het toevoegen van de peer zet je es.encrypt = true en kopieer je de sleutel naar es.lmk; de andere kant moet jou ook als versleutelde peer toevoegen met dezelfde LMK. Om versleutelde pakketten te ontvangen, moet de ontvanger de zender aan zijn lijst toevoegen. Broadcastpakketten kunnen niet worden versleuteld, en standaard heb je maximaal 7 versleutelde peers. Versleuteling alleen voorkomt niet dat een onderschept pakket later opnieuw wordt afgespeeld; een oplopende teller aan kritieke commando's toevoegen en oude nummers op de ontvanger afwijzen is een goede extra beveiliging.
Projectideeën met ESP-NOW
- Draadloze deurbel: Als de knop op de ESP32 bij de deur wordt ingedrukt, klinkt er een buzzer op het board binnen; gebruik voor de batterijduur de knop als pin die het board uit deep sleep wekt.
- Temperatuurbewaking in meerdere kamers: Plaats in elke kamer een DHT22- of BME280-sensor, verzamel de metingen op één gateway en vergelijk ze op een webpagina.
- Tuinbewatering: Een bodemvochtsensor stuurt een "nu water geven"-commando naar het board naast de pomp; voor de bedrading zie Bodemvochtsensor.
- Draadloze robotafstandsbediening: Stuur joystick-waarden 20 keer per seconde; voor de mechanische kant van de robot zie Een robotauto bouwen met Arduino.
- Tuinalarm: Als een PIR-sensor in de tuin beweging detecteert, stuurt de gateway een melding via Telegram.
- Gesynchroniseerde lichtshow: Schakel de WS2812B-strips op meerdere boards met één broadcastpakket tegelijk naar dezelfde kleur.
Veelvoorkomende ESP-NOW-fouten en oplossingen
| Symptoom / fout | Oorzaak | Oplossing |
|---|---|---|
| "ESPNOW: Peer interface is invalid", peer kan niet worden toegevoegd | esp_now_peer_info_t gebruikt zonder hem leeg te maken | Maak de struct leeg met = {} of memset en stel ifidx = WIFI_IF_STA in |
| Voortdurend "failed"-meldingen | Verkeerd MAC-adres (AP-adres of typefout), ontvanger uit of op een ander kanaal | Lees het STA-MAC-adres van de ontvanger opnieuw uit en controleer de kanalen van beide boards |
| Pakketten komen aan maar de waarden zijn onzin | De struct verschilt aan beide kanten of bevat een String | Definieer de struct aan beide kanten als packed in dezelfde volgorde en gebruik een char-array voor tekst |
| "invalid conversion ... to 'esp_now_recv_cb_t'" | Code voor core 2.x wordt op 3.x gecompileerd | Schrijf de receive-callback met const esp_now_recv_info_t * |
| "invalid conversion ... to 'esp_now_send_cb_t'" | Code voor core 3.0–3.2 wordt op 3.3+ gecompileerd | Schrijf de send-callback met const esp_now_send_info_t * of gebruik de macro ESP_IDF_VERSION |
| "Peer channel is not equal to the home channel, send fail!" | Het kanaal van het board dat met Wi-Fi is verbonden verschilt van het kanaal van de peer | Voeg de peer toe met channel = 0 en zet de sensoren op het kanaal van de router |
| De gateway die met Wi-Fi is verbonden mist sommige pakketten | Wi-Fi-energiebesparing (modem sleep) | Gebruik WiFi.setSleep(false) |
| ESP_ERR_ESPNOW_NOT_INIT | esp_now_init() is niet aangeroepen, of aangeroepen voordat Wi-Fi was gestart | Eerst WiFi.mode(WIFI_STA), daarna esp_now_init() |
| ESP_ERR_ESPNOW_FULL | De peerlijst heeft 20 items bereikt | Verwijder oude peers met esp_now_del_peer() of gebruik broadcast |
| ESP_ERR_ESPNOW_NO_MEM | Pakketten worden direct na elkaar verstuurd voordat de zendwachtrij leeg is | Wacht op het verzendresultaat voordat je het volgende pakket verstuurt |
| Het MAC-adres toont 00:00:00:00:00:00 | Op core 3.x is WiFi.macAddress() aangeroepen voordat Wi-Fi volledig was gestart | Gebruik esp_wifi_get_mac() na WiFi.mode(WIFI_STA) |
ESP-NOW is de snelste manier om meerdere ESP32-boards te laten praten zonder router, kabels of extra modules: lees het MAC-adres uit, definieer je datastruct aan beide kanten hetzelfde, voeg de peer toe en verstuur. Gebruik je het naast Wi-Fi, onthoud dan de ene regel: iedereen moet op hetzelfde kanaal zitten. In de BlueGrays-app kun je elk bouwblok uit deze gids uitproberen, waaronder led- en knopbediening met de ESP32, temperatuurmeting met de DHT22, Wi-Fi-verbinding, een webserver en deep sleep, stap voor stap met schakelschema's en kant-en-klare code.
Veelgestelde vragen
Heeft ESP-NOW een router of internet nodig?
Nee. ESP-NOW gebruikt de Wi-Fi-radio van de boards maar maakt geen verbinding met een netwerk; de boards sturen pakketten rechtstreeks naar elkaars MAC-adressen. Wil je data naar het internet brengen, dan heb je één ESP32 nodig die als gateway fungeert en zowel met Wi-Fi als met ESP-NOW is verbonden.
Wat is het bereik van ESP-NOW?
Met ESP32-boards met een ingebouwde antenne haal je binnenshuis meestal 20–40 meter, afhankelijk van de muren, en in open ruimte rond 100–200 meter. Met modules met externe antenne en de LR-modus (Long Range) aan beide kanten ingeschakeld is volgens Espressif tot 1 kilometer mogelijk bij zichtlijn.
Hoeveel apparaten kunnen met ESP-NOW verbinden?
De peerlijst van een board kan tot 20 apparaten bevatten, en standaard kunnen er maximaal 7 versleuteld zijn. Deze limiet geldt voor de apparaten waar je naar verstuurt: een gateway kan luisteren naar meer dan 20 sensoren die onversleutelde pakketten sturen, en een broadcast bereikt met één pakket elk apparaat op hetzelfde kanaal.
Kunnen ESP-NOW en Wi-Fi tegelijk worden gebruikt?
Ja, maar omdat de enige radio van de ESP32 op één kanaal tegelijk werkt, moet elk ESP-NOW-apparaat het kanaal van de router gebruiken. Schakel energiebesparing op de gateway uit met WiFi.setSleep(false), en laat de sensoren het kanaal vinden door op de netwerknaam te scannen, of zet de router op een vast kanaal.
Kunnen een ESP32 en een ESP8266 communiceren met ESP-NOW?
Ja. Beide chips ondersteunen ESP-NOW en kunnen pakketten naar elkaar sturen; alleen de bibliotheek (espnow.h) en de functiehandtekeningen zijn anders op de ESP8266. Definieer de datastruct aan beide kanten als packed en identiek, en houd pakketten onder 250 bytes.
Wat is de maximale datagrootte van ESP-NOW?
Met ESP-NOW v1 bevat een pakket maximaal 250 bytes, en deze limiet geldt voor elk board, ook de ESP8266. Boards met ESP-IDF 5.4 of later (Arduino core 3.2+) kunnen met ESP-NOW v2 tot 1470 bytes versturen, maar boards die v1 gebruiken kunnen geen pakketten ontvangen die langer zijn dan 250 bytes.
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-ledbesturing met drukknop (Toggle)
Elke keer dat je op de knop drukt, verandert de led van stand: is hij aan, dan gaat hij uit; is hij uit, dan gaat hij aan. Het klassieke togglepatroon. Met debounce filteren we de mechanische ruis van de drukknop weg, zodat één druk precies één wisseling geeft.

Tweerichtingscommunicatie tussen 2 Arduino's
Twee Arduino's zijn met draden aan elkaar gekoppeld en praten met elkaar: druk op de knop van de ene en het lampje van de andere gaat aan, druk nog eens en het gaat uit.

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 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 asynchrone webserver (met IP-weergave op lcd)
In dit project maken we van de ESP32 een asynchrone webserver die je met je telefoon of computer op hetzelfde wifinetwerk kunt bedienen. Dankzij de ESPAsyncWebServer-bibliotheek kan de server meerdere verzoeken tegelijk verwerken (anders dan de klassieke WebServer.h, die bij één verzoek blokkeert). Je opent het IP-adres van de ESP32 in een browser en klikt op de knoppen ON/OFF (de routes /on en /off) om de led op GPIO 5 aan en uit te zetten.

ESP32 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)
De Deep Sleep-modus van de ESP32 schakelt de CPU en de meeste randapparatuur uit, waardoor het stroomverbruik daalt tot ongeveer 10µA; dat is cruciaal voor IoT-apparaten op batterijen. Dit project gebruikt drie wekbronnen: een timer (15 s), een externe pin (EXT0, de knop op GPIO 33) en een touchpin (T0/GPIO 4). Tellers met RTC_DATA_ATTR blijven behouden tijdens deep sleep.

ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bouw met de ESP32 een temperatuur- en vochtigheidslogger met tijdstempel! Een DHT22-sensor meet elke minuut temperatuur en luchtvochtigheid en elke meting wordt als CSV op een microSD-kaart opgeslagen, met de actuele tijd van de DS1307 RTC-module. Het OLED-display toont in grote letters live de laatste temperatuur, vochtigheid, tijdstempel en het totale aantal records.
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

