Hur man gör flera ESP-samtal via ESP-NOW med ESP32 och ESP8266: 8 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:40

I mitt pågående projekt behöver jag flera ESP för att prata med varandra utan en router. För att göra detta använder jag ESP-NU för att få trådlös kommunikation med varandra utan en router på ESP.

Tillbehör

Saker jag använde:

ESP32 DEV -modul

NODEMCU 1.0 (ESP12E -modul)

Steg 1: Skaffa Board Mac -adressen

Via ESP-nu pratar ESP-enheter med varandra genom att skicka data till sin unika adress medan de är anslutna till ett internt åtkomstpunktsnätverk som skapats vid intilaisering av esp nu.. Bestäm alltså MAC -adressen för varje enhet. Bifogade är mina ESP32- och ESP8266 -kortinställningar

FÖR ESP32

#inkludera "WiFi.h" // För att komma åt ESP32 WIFI -funktioner

void setup () {Serial.begin (115200); Serial.print ("ESP32 Board MAC Address:"); Serial.println (WiFi.macAddress ()); // skriver ut sin MAC -adress} void loop () {}

FÖR ESP8266

#include // Bibliotek som används för att komma åt ESP8266 WIFI -funktioner

void setup () {Serial.begin (115200); Serial.println (); Serial.print ("ESP8266 Board MAC Address:"); Serial.println (WiFi.macAddress ()); // skriver ut sin MAC -adress} void loop () {}

Mina MAC -ADRESS är:

• ESP32 - 30: AE: A4: F5: 03: A4
• ESP8266: A4: CF: 12: C7: 9C: 77

Steg 2: Så här får du ESP-NU att fungera

Här är en översikt över hur man får det att fungera:

1. Inkludera esp nu och wifi -bibliotek
2. Spara mac -adressen till mottagarens ESP
3. Definiera datastrukturen för meddelandet skicka/ta emot
4. Ställ in wifi på stationsläge vid installationen
5. Initiera esp_now
6. ring och registrera återuppringningsfunktionen som kallas efter att du har skickat och mottagit data
7. Definiera dess roll för Esp8266
8. registrera kamrat eller mottagare esp
9. Skicka data

Steg 3: ESP-NU-FUNKTIONER (ESP32)

esp_now_init (ogiltigt)

Lämna tillbaka:

• ESP_OK: lyckas
• ESP_ERR_ESPNOW_INTERNAL: Internt fel

Beskrivning:

Initiera ESPNOW -funktionen

esp_now_register_send_cb (cb)

Returer:

• ESP_OK: lyckas
• ESP_ERR_ESPNOW_NOT_INIT: ESPNOW initieras inte
• ESP_ERR_ESPNOW_INTERNAL: internt fel

Parametrar:

• cb: namn för återuppringningsfunktion efter att ha skickat ESPNOW -data med dessa parametrar:

  • void cb (const uint8_t *mac_addr, esp_now_send_status_t status)

    • mac_addr: mottagarens mac -adress

    • status:

      • 1 = framgång
      • 0 = misslyckas

Beskrivning:

Anropa funktionen OnDataSent efter att du har skickat ESPNOW -data

esp_now_add_peerconst esp_now_peer_info_t *peer)

Returer:

• ESP_OK: lyckas
• ESP_ERR_ESPNOW_NOT_INIT: ESPNOW initieras inte
• ESP_ERR_ESPNOW_ARG: ogiltigt argument
• ESP_ERR_ESPNOW_FULL: kamratlistan är full
• ESP_ERR_ESPNOW_NO_MEM: slut på minne
• ESP_ERR_ESPNOW_EXIST: peer har funnits

Parametrar:

• peer: peer -information med följande data:

  • uint8_t

    peer_addr [ESP_NOW_ETH_ALEN]; ESPNOW -peer -MAC -adress som också är MAC -adressen för stationen eller softap

  • uint8_t lmk [ESP_NOW_KEY_LEN]

    ESPNOW peer lokal huvudnyckel som används för att kryptera data

  • uint8_t kanal

    Wi-Fi-kanal som peer använder för att skicka/ta emot ESPNOW-data. Om värdet är 0, använd den aktuella kanalen som station eller program är på. Annars måste den ställas in som den kanal som stationen eller programmen är på

  • wifi_interface_t ifidx

    Wi-Fi-gränssnitt som peer använder för att skicka/ta emot ESPNOW-data

  • bool kryptera

    ESPNOW -data som denna peer skickar/tar emot är krypterade eller inte

  • void *priv

    ESPNOW privata data

Beskrivning:

Lägg till en peer -to -peer -lista

esp_now_send (const uint8_t *peer_addr, const uint8_t *data, size_t len)

Returer:

• ESP_OK: lyckas
• ESP_ERR_ESPNOW_NOT_INIT: ESPNOW initieras inte
• ESP_ERR_ESPNOW_ARG: ogiltigt argument
• ESP_ERR_ESPNOW_INTERNAL: internt fel
• ESP_ERR_ESPNOW_NO_MEM: slut på minne
• ESP_ERR_ESPNOW_NOT_FOUND: peer hittades inte
• ESP_ERR_ESPNOW_IF: nuvarande WiFi -gränssnitt matchar inte peer

Parametrar:

• peer_addr: peer MAC -adress
• data: data att skicka
• len: längd på data

Beskrivning:

Skicka ESPNOW -data. I vissa fall händer detta:

• Om peer_addr inte är NULL, skicka data till peer vars MAC -adress matchar peer_addr
• Om peer_addr är NULL, skicka data till alla kamrater som läggs till i peerlistan
• Den maximala längden på data måste vara mindre än ESP_NOW_MAX_DATA_LEN
• Bufferten som dataargumentet pekar på behöver inte vara giltig efter esp_now_send returnerar

esp_now_register_recv_cb (cb)

Returer:

• ESP_OK: lyckas
• ESP_ERR_ESPNOW_NOT_INIT: ESPNOW initieras inte
• ESP_ERR_ESPNOW_INTERNAL: internt fel

Parametrar:

• cb: återuppringningsfunktion för mottagning av ESPNOW -data

  • void cb (const uint8_t *mac_addr, const uint8_t *data, int data_len)

    • mac_addr:

      mottagarens mac -adress

    • *data:

      data tar emot

    • data_len

      databyte längd

Beskrivning:

Ring funktionen cb efter att ha fått ESPNOW -data

Steg 4: ESP-NU-FUNKTIONER (ESP8266)

FUNKTIONER BESKRIVNING ESP32 ESP8266

int esp_now_init (ogiltigt)

Returer:

• 1 = framgång
• 0 = misslyckas

Beskrivning

Initiera ESPNOW -funktionen

int esp_now_set_self_role (rollen u8)

Parametrar:

• ESP_NOW_ROLE_IDLE: dataöverföring är inte tillåten.
• ESP_NOW_ROLE_CONTROLLER: prioritet ges till Sation -gränssnitt
• ESP_NOW_ROLE_SLAVE: prioritet ges till SoftAP -gränssnitt
• ESP_NOW_ROLE_COMBO: prioritet ges till SoftAP -gränssnitt

Beskrivning

Ställer in enhetens roll

int esp_now_register_send_cb (cb)

Returer:

• 1 = framgång
• 0 = misslyckas

Parametrar:

• cb: namn för återuppringningsfunktion efter att ha skickat ESPNOW -data med dessa parametrar:

  • void cb (const uint8_t *mac_addr, esp_now_send_status_t status)

    • mac_addr: mottagarens mac -adress

    • status:

      • 1 = framgång
      • 0 = misslyckas

Beskrivning

Anropa funktionen OnDataSent efter att du har skickat ESPNOW -data

int esp_now_add_peer (u8 *mac_addr, u8 roll, u8 kanal, u8 *key, u8 key_len)

Returer:

• 1 = framgång
• 0 = misslyckas

Parametrar:

• mac_addr

  mac -adress för kamrat

• roll

• kanal

  Om värdet är 0, använd den aktuella kanalen som station eller program är på. Annars måste den ställas in som den kanal som stationen eller programmen är på

• *nyckel

  nyckel för kryptering

• key_len

  nyckelns längd

Beskrivning:

Lägg till en peer -to -peer -lista

int esp_now_send (const uint8_t *peer_addr, const uint8_t *data, size_t len)

Returer:

• 1 = Framgång
• 0 = Misslyckad

Parametrar:

• peer_addr: peer MAC -adress
• data: data att skicka
• len: datalängd

Beskrivning:

Skicka ESPNOW -data. I vissa fall händer detta:

• Om peer_addr inte är NULL, skicka data till peer vars MAC -adress matchar peer_addr
• Om peer_addr är NULL, skicka data till alla kamrater som läggs till i peerlistan
• Den maximala längden på data måste vara mindre än ESP_NOW_MAX_DATA_LEN
• Bufferten som dataargumentet pekar på behöver inte vara giltig efter esp_now_send returnerar

int esp_now_register_recv_cb (cb)

Returer:

• 1 = Framgång
• 0 = Misslyckad

Parametrar:

• cb: återuppringningsfunktion för mottagning av ESPNOW -data

  • void cb (const uint8_t *mac_addr, const uint8_t *data, int data_len)

    • mac_addr:

      mottagarens mac -adress

    • *data:

      data tar emot

    • data_len

      databyte längd

Beskrivning:

Ring funktionen cb efter att ha fått ESPNOW -data

Steg 5: Envägskommunikation (ESP32 som avsändare)

ESP32 skickar data till en ESP8266. med denna kod. Ändra broadcastAddress till din korrigerande mottagares mac -adress. Min var A4: CF: 12: C7: 9C: 77

// Lägg till nödvändiga bibliotek

#include // För att komma åt esp nu -funktionerna #include // To Add Wifi Capabilities on ESP32 // save the MAC Address in a array named broadcastAddress; uint8_t broadcastAddress = {0xA4, 0xCF, 0x12, 0xC7, 0x9C, 0x77}; // MAC -adress för min mottagare/*definiera datatyperna för de flera variabler som är strukturerade och byter namn på det hela till struct_message*/typedef struct struct_message {char a [32]; int b; flyta c; Sträng d; bool e; } struct_message; // Skapa en struct_message som heter myData struct_message myData; // funktion anropas när data skickas för att skriva ut dess status void OnDataSent (const uint8_t *mac_addr, esp_now_send_status_t status) {Serial.print ("\ r / nLast paketsändningsstatus: / t"); Serial.println (status == ESP_NOW_SEND_SUCCESS? "Leveransframgång": "Leverans misslyckas"); } void setup () {// Ställ in överföringshastigheten för seriell kommunikation med ESP Serial.begin (115200); // Ställ in enheten som en Wi-Fi-station WiFi.mode (WIFI_STA); // Startar wifi // Init ESP-NOW och returnerar sin status om (esp_now_init ()! = ESP_OK) {Serial.println ("Fel vid initialisering av ESP -NU"); lämna tillbaka; } // ringa funktionen OnDataSent efter att ha skickat ESPNOW -data esp_now_register_send_cb (OnDataSent); // Registrera peer esp_now_peer_info_t peerInfo; // initiera och tilldela peer -informationen som en pekare till en addres memcpy (peerInfo.peer_addr, broadcastAddress, 6); // kopiera värdet på broadcastAddress med 6 byte till peerInfo.peer_addr peerInfo.channel = 0; // kanal där esp pratar. 0 betyder odefinierad och data kommer att skickas till den aktuella kanalen. 1-14 är giltiga kanaler som är samma sak med den lokala enheten peerInfo.encrypt = false; // inte krypterad // Lägg till enheten i listan över parade enheter om (esp_now_add_peer (& peerInfo)! = ESP_OK) {Serial.println ("Det gick inte att lägga till peer"); lämna tillbaka; }} void loop () {// Ange värden för att skicka strcpy (myData.a, "DETTA ÄR EN CHAR"); // spara "DETTA ÄR EN CHAR" till variabel a av mina "data" definierade tidigare myData.b = random (1, 20); // spara ett slumpmässigt värde myData.c = 1.2; // save a float myData.d = "Hej"; // spara en sträng myData.e = false; // spara en bool // Skicka data mindre än eller lika med 250 byte via ESP-NOW och returnerar dess status esp_err_t result = esp_now_send (broadcastAddress, (uint8_t *) & myData, sizeof (myData)); if (result == ESP_OK) {Serial.println ("Skickat med framgång"); } else {Serial.println ("Fel vid överföring av data"); } fördröjning (2000); }

ESP8266 tar emot data från ESP32 med denna kod.

// Lägg till nödvändiga bibliotek

#include // För att lägga till Wifi -funktioner på ESP32 #include // För att få åtkomst till esp nu -funktionerna /*definiera datatyperna för de flera variabler som är strukturerade och byter namn på allt till struct_message* /typedef struct struct_message {char a [32]; int b; flyta c; Sträng d; bool e; } struct_message; // Skapa en variabel struct_message som heter myData struct_message myData; // funktion kallas när data tas emot och skriver ut den ogiltiga OnDataRecv (uint8_t * mac, uint8_t * incomingData, uint8_t len) {memcpy (& myData, incomingData, sizeof (myData)); Serial.print ("Byte mottagna:"); Serial.println (len); Serial.print ("Char:"); Serial.println (myData.a); Serial.print ("Int:"); Serial.println (myData.b); Serial.print ("Float:"); Serial.println (myData.c); Serial.print ("String:"); Serial.println (myData.d); Serial.print ("Bool:"); Serial.println (myData.e); Serial.println (); } void setup () {// Ställ in överföringshastigheten för seriell kommunikation med ESP Serial.begin (115200); // Ställ in enheten som Wi-Fi Station WiFi.mode (WIFI_STA); // Startar wifi // Init ESP-NOW och returnerar status om (esp_now_init ()! = 0) {Serial.println ("Fel vid initiering av ESP-NOW"); lämna tillbaka; } esp_now_set_self_role (ESP_NOW_ROLE_SLAVE); // Definierar rollen för denna esp esp_now_register_recv_cb (OnDataRecv); // ring funktionen OnDataRecv efter att ha mottagit ESPNOW -data} void loop () {}

Steg 6: Envägskommunikation (ESP8266 som avsändare)

ESP8266 skickar data till en ESP32. med denna kod. Ändra broadcastAddress till din korrigerande mottagares mac -adress. Min esp32 -adress är 30: AE: A4: F5: 03: A4. För andra funktioner för esp8266 gå här

// Lägg till nödvändiga bibliotek

#include // För att lägga till Wifi -funktioner på ESP32 #include // För att komma åt esp nu -funktionerna // spara MAC -adressen i en array som heter broadcastAddress; uint8_t broadcastAddress = {0x30, 0xAE, 0xA4, 0xF5, 0x03, 0xA4}; /*definiera datatyperna för de flera variabler som är strukturerade och byter namn på det hela till struct_message*/ typedef struct struct_message {char a [32]; int b; flyta c; Sträng d; bool e; } struct_message; // Skapa en strukturerad variabel som heter myData struct_message myData; // funktion kallas när data skickas och skriver ut dess status tom OnDataSent (uint8_t *mac_addr, uint8_t sendStatus) {Serial.print ("\ r / nLast paket skickas status: / t"); Serial.println (sendStatus == 1? "Leveransframgång": "Leverans misslyckas"); } void setup () {// Ställ in överföringshastigheten för seriell kommunikation med ESP Serial.begin (115200); // Ställ in enheten som en Wi-Fi-station WiFi.mode (WIFI_STA); // Startar wifi // Init ESP-NOW och returnerar sin status om (esp_now_init ()) {Serial.println ("Fel vid initiering av ESP-NOW"); lämna tillbaka; } esp_now_register_send_cb (OnDataSent); // ringa funktionen OnDataSent efter att ha skickat ESPNOW -data // Lägg till enheten i listan över parade enheter om (esp_now_add_peer (broadcastAddress, ESP_NOW_ROLE_CONTROLLER, 1, NULL, 0)) {Serial.println ("Det gick inte att lägga till peer"); lämna tillbaka; }} void loop () {// Ange värden för att skicka strcpy (myData.a, "DETTA ÄR EN CHAR"); // spara "DETTA ÄR EN CHAR" till variabel a av mina "data" definierade tidigare myData.b = random (1, 20); // spara ett slumpmässigt värde myData.c = 1.2; // spara en float myData.d = "SP8266"; // spara en sträng myData.e = false; // spara en bool // Skicka data mindre än eller lika med 250 byte via ESP-NOW och returnerar dess status int resultat = esp_now_send (broadcastAddress, (uint8_t *) & myData, sizeof (myData)); if (esp_now_init ()! = 0) {Serial.println ("Skickat med framgång"); } else {Serial.println ("Fel vid överföring av data"); } fördröjning (2000); }

ESP32 tar emot data från en ESP8266. med denna kod. För andra funktioner referera här

// Lägg till nödvändiga bibliotek

#include // För att få åtkomst till esp nu -funktionerna #include // To Add Wifi Capabilities on ESP32 /*definiera datatyperna för de flera variabler som är strukturerade och byter namn på allt till struct_message* /typedef struct struct_message {char a [32]; int b; flyta c; Sträng d; bool e; } struct_message; // Skapa en variabel struct_message som heter myData struct_message myData; // funktion kallas när data tas emot och skriver ut den ogiltiga OnDataRecv (const uint8_t * mac, const uint8_t * incomingData, int len) {memcpy (& myData, incomingData, sizeof (myData)); Serial.print ("Byte mottagna:"); Serial.println (len); Serial.print ("Char:"); Serial.println (myData.a); Serial.print ("Int:"); Serial.println (myData.b); Serial.print ("Float:"); Serial.println (myData.c); Serial.print ("String:"); Serial.println (myData.d); Serial.print ("Bool:"); Serial.println (myData.e); Serial.println (); } void setup () {// Ställ in överföringshastigheten för seriell kommunikation med ESP Serial.begin (115200); // Ställ in enheten som Wi-Fi Station WiFi.mode (WIFI_STA); // Startar wifi // Init ESP-NOW och returnerar status om (esp_now_init ()! = 0) {Serial.println ("Fel vid initiering av ESP-NOW"); lämna tillbaka; } esp_now_register_recv_cb (OnDataRecv); // anropa funktionen OnDataRecv efter att ha fått ESPNOW -data} void loop () {}

Steg 7: Tvåvägskommunikation

ESP32 skickar data vid start till ESP8266. ESP8266 skriver ut det mottagna meddelandet och svarar sedan på vilket ESP32 skriver ut på sin seriella bildskärm.

ESP32 -KOD

// Lägg till nödvändiga bibliotek

#include // För att komma åt esp nu -funktionerna #include // To Add Wifi Capabilities on ESP32 // save the MAC Address in a array named broadcastAddress; uint8_t broadcastAddress = {0xA4, 0xCF, 0x12, 0xC7, 0x9C, 0x77}; // MAC -adress för min mottagare/*definiera datatyperna för de flera variabler som är strukturerade och byter namn på det hela till struct_message*/typedef struct struct_message {char a [32]; int b; flyta c; Sträng d; bool e; } struct_message; // Skapa en struct_message som heter myData struct_message myData; // funktion anropas när data skickas för att skriva ut dess status void OnDataSent (const uint8_t *mac_addr, esp_now_send_status_t status) {Serial.print ("\ r / nLast paketsändningsstatus: / t"); Serial.println (status == ESP_NOW_SEND_SUCCESS? "Leveransframgång": "Leverans misslyckas"); if (status! = ESP_NOW_SEND_SUCCESS) {send_data ();}} void OnDataRecv (const uint8_t * mac, const uint8_t * incomingData, int len) {memcpy (& myData, incomingData, sizeof (myData)); Serial.print ("Byte mottagna:"); Serial.println (len); Serial.print ("Char:"); Serial.println (myData.a); Serial.print ("Int:"); Serial.println (myData.b); Serial.print ("Float:"); Serial.println (myData.c); Serial.print ("String:"); Serial.println (myData.d); Serial.print ("Bool:"); Serial.println (myData.e); Serial.println (); } void setup () {// Ställ in överföringshastigheten för seriell kommunikation med ESP Serial.begin (115200); // Ställ in enheten som en Wi-Fi-station WiFi.mode (WIFI_STA); // Startar wifi // Init ESP-NOW och returnerar sin status om (esp_now_init ()! = ESP_OK) {Serial.println ("Fel vid initialisering av ESP -NU"); lämna tillbaka; } // ringa funktionen OnDataSent efter att ha skickat ESPNOW -data esp_now_register_send_cb (OnDataSent); // Registrera peer esp_now_peer_info_t peerInfo; // initiera och tilldela peer -informationen som en pekare till en addres memcpy (peerInfo.peer_addr, broadcastAddress, 6); // kopiera värdet på broadcastAddress med 6 byte till peerInfo.peer_addr peerInfo.channel = 0; // kanal där esp pratar. 0 betyder odefinierad och data kommer att skickas till den aktuella kanalen.1-14 är giltiga kanaler som är samma sak med den lokala enheten peerInfo.encrypt = false; // inte krypterad // Lägg till enheten i listan över parade enheter om (esp_now_add_peer (& peerInfo)! = ESP_OK) {Serial.println ("Det gick inte att lägga till peer"); lämna tillbaka; } esp_now_register_recv_cb (OnDataRecv); // anropa funktionen OnDataRecv efter mottagande av ESPNOW -data send_data (); } void loop () {} void send_data () {Serial.println ("Skickar"); // Ställ in värden för att skicka strcpy (myData.a, "THIS IS A CHAR"); // spara "DETTA ÄR EN CHAR" till variabel a av mina "data" definierade tidigare myData.b = random (1, 20); // spara ett slumpmässigt värde myData.c = 1.2; // spara en float myData.d = "ESP32"; // spara en sträng myData.e = false; // spara en bool // Skicka data mindre än eller lika med 250 byte via ESP-NOW och returnerar dess status esp_err_t result = esp_now_send (broadcastAddress, (uint8_t *) & myData, sizeof (myData)); if (result == ESP_OK) {Serial.println ("skickat med framgång");} else {Serial.println ("Fel vid överföring av data"); }}

ESP8266 KOD

// Lägg till nödvändiga bibliotek

#include // För att lägga till Wifi -funktioner på ESP32 #include // För att komma åt esp nu -funktionerna // spara MAC -adressen i en array som heter broadcastAddress; uint8_t broadcastAddress = {0x30, 0xAE, 0xA4, 0xF5, 0x03, 0xA4}; /*definiera datatyperna för de flera variabler som är strukturerade och byter namn på det hela till struct_message*/ typedef struct struct_message {char a [32]; int b; flyta c; Sträng d; bool e; } struct_message; // Skapa en variabel struct_message som heter myData struct_message myData; // funktion kallas när data tas emot och skriver ut den ogiltiga OnDataRecv (uint8_t * mac, uint8_t * incomingData, uint8_t len) {memcpy (& myData, incomingData, sizeof (myData)); Serial.print ("Byte mottagna:"); Serial.println (len); Serial.print ("Char:"); Serial.println (myData.a); Serial.print ("Int:"); Serial.println (myData.b); Serial.print ("Float:"); Serial.println (myData.c); Serial.print ("String:"); Serial.println (myData.d); Serial.print ("Bool:"); Serial.println (myData.e); Serial.println (); skicka data(); } void OnDataSent (uint8_t *mac_addr, uint8_t sendStatus) {Serial.print ("\ r / nLast Packet Send Status: / t"); Serial.println (sendStatus == 1? "Leveransframgång": "Leverans misslyckas"); if (sendStatus! = 1) {send_data (); }} void send_data () {// Ange värden för att skicka strcpy (myData.a, "DETTA ÄR EN CHAR"); // spara "DETTA ÄR EN CHAR" till variabel a av mina "data" definierade tidigare myData.b = random (1, 20); // spara ett slumpmässigt värde myData.c = 1.2; // spara en float myData.d = "ESP8266"; // spara en sträng myData.e = false; // spara en bool esp_now_send (broadcastAddress, (uint8_t *) & myData, sizeof (myData)); } void setup () {// Ställ in överföringshastigheten för seriell kommunikation med ESP Serial.begin (115200); // Ställ in enheten som Wi-Fi Station WiFi.mode (WIFI_STA); // Startar wifi // Init ESP-NOW och returnerar status om (esp_now_init ()! = 0) {Serial.println ("Fel vid initiering av ESP-NOW"); lämna tillbaka; } if (esp_now_add_peer (broadcastAddress, ESP_NOW_ROLE_SLAVE, 1, NULL, 0)) {Serial.println ("Det gick inte att lägga till peer"); lämna tillbaka; } esp_now_set_self_role (ESP_NOW_ROLE_COMBO); esp_now_register_send_cb (OnDataSent); esp_now_set_self_role (ESP_NOW_ROLE_COMBO); // Definierar rollen för denna esp esp_now_register_recv_cb (OnDataRecv); // anropa funktionen OnDataRecv efter att ha fått ESPNOW -data} void loop () {}

Steg 8: REFERENSER

ESPNOW_32_Exempel

ESPNOW_8266 Exempel

WIFI.h

ESP8266WiFi.h

esp_now.h för ESP8266

esp_now.h för ESP32

esp_now officiellt dokument (bättre förklaring av funktioner)

ESP-NU Officiell guide