Cum să faci mai multe conversații ESP prin ESP-NOW folosind ESP32 și ESP8266: 8 pași

2025 Autor: John Day | [email protected]. Modificat ultima dată: 2025-01-23 15:04

În proiectul meu în desfășurare, am nevoie de mai multe ESP pentru a vorbi între ei fără un router. Pentru a face acest lucru, voi folosi ESP-ACUM pentru a comunica fără fir unul cu celălalt fără un router pe ESP.

Provizii

Lucruri pe care le-am folosit:

Modulul ESP32 DEV

NODEMCU 1.0 (modul ESP12E)

Pasul 1: Obțineți adresa Mac Board

Prin intermediul ESP-now, dispozitivele ESP vorbesc între ele prin trimiterea de date la adresa lor unică, în timp ce sunt conectate la o rețea de puncte de acces interne realizate la introducerea sp-ului acum.. Astfel, determinați adresa MAC a fiecărui dispozitiv. Atașat este ESP32 și ESP8266 Board Settings

PENTRU ESP32

#include "WiFi.h" // Pentru a accesa capabilitățile ESP32 WIFI

void setup () {Serial.begin (115200); Serial.print ("Adresa MAC a plăcii ESP32:"); Serial.println (WiFi.macAddress ()); // își imprimă adresa MAC} bucla nulă () {}

PENTRU ESP8266

#include // Biblioteca utilizată pentru a accesa capabilitățile ESP8266 WIFI

void setup () {Serial.begin (115200); Serial.println (); Serial.print ("Adresa MAC a plăcii ESP8266:"); Serial.println (WiFi.macAddress ()); // își imprimă adresa MAC} bucla nulă () {}

ADRESA MAC este:

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

Pasul 2: Cum să faci să funcționeze ESP-ACUM

Iată o prezentare generală a modului de funcționare:

1. Includeți acum bibliotecile esp și wifi
2. Salvați adresa Mac a destinatarului ESP
3. Definiți structura de date a mesajului trimis / primit
4. La configurare, setați wifi la modul stație
5. Inițializați esp_now
6. efectuați și înregistrați funcția de apelare apelată după trimiterea și primirea datelor
7. Pentru Esp8266, definiți-i rolul
8. înregistrați peer sau destinatarul esp
9. Trimite date

Pasul 3: FUNCȚII ESP-ACUM (ESP32)

esp_now_init (nul)

Întoarcere:

• ESP_OK: reușește
• ESP_ERR_ESPNOW_INTERNAL: Eroare internă

Descriere:

Inițializați funcția ESPNOW

esp_now_register_send_cb (cb)

Se intoarce:

• ESP_OK: reușește
• ESP_ERR_ESPNOW_NOT_INIT: ESPNOW nu este inițializat
• ESP_ERR_ESPNOW_INTERNAL: eroare internă

Parametri:

• cb: numele funcției de apel invers după trimiterea datelor ESPNOW cu acești parametri:

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

    • mac_addr: adresa mac a receptorului

    • stare:

      • 1 = succes
      • 0 = eșuează

Descriere:

Apelați funcția OnDataSent după trimiterea datelor ESPNOW

esp_now_add_peerconst esp_now_peer_info_t * peer)

Se intoarce:

• ESP_OK: reușește
• ESP_ERR_ESPNOW_NOT_INIT: ESPNOW nu este inițializat
• ESP_ERR_ESPNOW_ARG: argument nevalid
• ESP_ERR_ESPNOW_FULL: lista de peer este plină
• ESP_ERR_ESPNOW_NO_MEM: fără memorie
• ESP_ERR_ESPNOW_EXIST: peer a existat

Parametri:

• peer: informații peer cu următoarele date:

  • uint8_t

    peer_addr [ESP_NOW_ETH_ALEN]; Adresa MAC peer ESPNOW care este, de asemenea, adresa MAC a stației sau softap-ului

  • uint8_t lmk [ESP_NOW_KEY_LEN]

    ESPNOW cheie master locală peer care este utilizată pentru a cripta date

  • canal uint8_t

    Canal Wi-Fi pe care colegul îl folosește pentru a trimite / primi date ESPNOW. Dacă valoarea este 0, utilizați canalul curent pe care stație sau softap este activat. În caz contrar, trebuie setat ca canal pe care este activat postul sau softap-ul

  • wifi_interface_t ifidx

    Interfață Wi-Fi pe care o folosește colegul pentru a trimite / primi date ESPNOW

  • criptare bool

    Datele ESPNOW pe care acest peer le trimite / le primește sunt criptate sau nu

  • nul * priv

    ESPNOW date private peer

Descriere:

Adăugați un peer la lista de peer

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

Se intoarce:

• ESP_OK: reușește
• ESP_ERR_ESPNOW_NOT_INIT: ESPNOW nu este inițializat
• ESP_ERR_ESPNOW_ARG: argument nevalid
• ESP_ERR_ESPNOW_INTERNAL: eroare internă
• ESP_ERR_ESPNOW_NO_MEM: fără memorie
• ESP_ERR_ESPNOW_NOT_FOUND: egalul nu este găsit
• ESP_ERR_ESPNOW_IF: interfața WiFi curentă nu se potrivește cu cea a colegului

Parametri:

• peer_addr: adresa MAC peer
• date: date de trimis
• len: lungimea datelor

Descriere:

Trimiteți date ESPNOW. În unele cazuri, acest lucru se întâmplă:

• Dacă peer_addr nu este NULL, trimiteți datele peerului a cărui adresă MAC se potrivește peer_addr
• Dacă peer_addr este NULL, trimiteți date tuturor colegilor care sunt adăugați la lista de egali
• Lungimea maximă a datelor trebuie să fie mai mică decât ESP_NOW_MAX_DATA_LEN
• Tamponul indicat de argumentul de date nu trebuie să fie valid după revenirea esp_now_send

esp_now_register_recv_cb (cb)

Se intoarce:

• ESP_OK: reușește
• ESP_ERR_ESPNOW_NOT_INIT: ESPNOW nu este inițializat
• ESP_ERR_ESPNOW_INTERNAL: eroare internă

Parametri:

• cb: funcție de apel invers pentru primirea datelor ESPNOW

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

    • mac_addr:

      adresa Mac a receptorului

    • *date:

      primirea datelor

    • data_len

      lungimea octetului de date

Descriere:

Apelați funcția cb după ce primiți date ESPNOW

Pasul 4: FUNCȚII ESP-ACUM (ESP8266)

FUNCȚII DESCRIERE ESP32 ESP8266

int esp_now_init (nul)

Se intoarce:

• 1 = succes
• 0 = eșuează

Descriere

Inițializați funcția ESPNOW

int esp_now_set_self_role (rol u8)

Parametri:

• ESP_NOW_ROLE_IDLE: transmisia datelor nu este permisă.
• ESP_NOW_ROLE_CONTROLLER: se acordă prioritate interfeței Sation
• ESP_NOW_ROLE_SLAVE: se acordă prioritate interfeței SoftAP
• ESP_NOW_ROLE_COMBO: se acordă prioritate interfeței SoftAP

Descriere

Setează rolul dispozitivului

int esp_now_register_send_cb (cb)

Se intoarce:

• 1 = succes
• 0 = eșuează

Parametri:

• cb: numele funcției de apel invers după trimiterea datelor ESPNOW cu acești parametri:

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

    • mac_addr: adresa mac a receptorului

    • stare:

      • 1 = succes
      • 0 = eșuează

Descriere

Apelați funcția OnDataSent după trimiterea datelor ESPNOW

int esp_now_add_peer (u8 * mac_addr, rol u8, canal u8, cheie u8 *, cheie u8_len)

Se intoarce:

• 1 = succes
• 0 = eșuează

Parametri:

• mac_addr

  adresa mac a colegului

• rol

• canal

  Dacă valoarea este 0, utilizați canalul curent pe care stație sau softap este activat. În caz contrar, trebuie setat ca canal pe care este activat postul sau softap-ul

• *cheie

  cheie pentru criptare

• key_len

  lungimea cheii

Descriere:

Adăugați un peer la lista de peer

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

Se intoarce:

• 1 = Succes
• 0 = Fail

Parametri:

• peer_addr: adresa MAC peer
• date: date de trimis
• len: lungimea datelor

Descriere:

Trimiteți date ESPNOW. În unele cazuri, acest lucru se întâmplă:

• Dacă peer_addr nu este NULL, trimiteți date peerului a cărui adresă MAC se potrivește peer_addr
• Dacă peer_addr este NULL, trimiteți date tuturor colegilor care sunt adăugați la lista de egali
• Lungimea maximă a datelor trebuie să fie mai mică decât ESP_NOW_MAX_DATA_LEN
• Tamponul indicat de argumentul de date nu trebuie să fie valid după revenirea esp_now_send

int esp_now_register_recv_cb (cb)

Se intoarce:

• 1 = Succes
• 0 = Fail

Parametri:

• cb: funcție de apel invers pentru primirea datelor ESPNOW

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

    • mac_addr:

      adresa Mac a receptorului

    • *date:

      primirea datelor

    • data_len

      lungimea octetului de date

Descriere:

Apelați funcția cb după ce primiți date ESPNOW

Pasul 5: comunicare unidirecțională (ESP32 ca expeditor)

ESP32 trimite date către un ESP8266. cu acest cod. Schimbați broadcastAddress la adresa Mac a receptorului corespunzător. Al meu era A4: CF: 12: C7: 9C: 77

// Adăugați bibliotecile necesare

#include // Pentru a accesa funcțiile esp acum #include // Pentru a adăuga capacități Wifi pe ESP32 // salvați adresa MAC într-o matrice numită broadcastAddress; uint8_t broadcastAddress = {0xA4, 0xCF, 0x12, 0xC7, 0x9C, 0x77}; // Adresa MAC a receptorului meu / * definește tipurile de date ale multiplelor variabile structurate și redenumite toate ca struct_message * / typedef struct struct_message {char a [32]; int b; plutitor c; Șirul d; bool e; } struct_message; // Creați un struct_message numit myData struct_message myData; // funcție apelată când datele sunt trimise pentru a-și imprima starea void OnDataSent (const uint8_t * mac_addr, starea sp_now_send_status_t) {Serial.print ("\ r / nStarea ultimului pachet de trimitere: / t"); Serial.println (status == ESP_NOW_SEND_SUCCESS? "Delivery Success": "Livrare nereușită"); } void setup () {// Setați viteza de transmisie pentru comunicațiile seriale cu ESP Serial.begin (115200); // Setați dispozitivul ca stație Wi-Fi WiFi.mode (WIFI_STA); // Pornește wifi // Init ESP-ACUM și își returnează starea dacă (esp_now_init ()! = ESP_OK) {Serial.println ("Eroare la inițializarea ESP -ACUM"); întoarcere; } // apelați funcția OnDataSent după trimiterea datelor ESPNOW esp_now_register_send_cb (OnDataSent); // Înregistrează peer esp_now_peer_info_t peerInfo; // inițializați și atribuiți informațiile peer ca un pointer către un memcpy de adresă (peerInfo.peer_addr, broadcastAddress, 6); // copiați valoarea broadcastAddress cu 6 octeți peerInfo.peer_addr peerInfo.channel = 0; // canal la care vorbesc sp. 0 înseamnă nedefinit, iar datele vor fi trimise pe canalul curent. 1-14 sunt canale valabile, ceea ce este același cu dispozitivul local peerInfo.encrypt = false; // nu este criptat // Adăugați dispozitivul la lista de dispozitive asociate dacă (esp_now_add_peer (& peerInfo)! = ESP_OK) {Serial.println ("Nu s-a putut adăuga peer"); întoarcere; }} void loop () {// Setați valori pentru a trimite strcpy (myData.a, „ACEST ESTE UN CHAR”); // salvați „THIS IS A CHAR” în variabila a din „datele” mele definite mai devreme myData.b = random (1, 20); // salvați o valoare aleatorie myData.c = 1.2; // save a float myData.d = "Bună ziua"; // salvați un șir MyData.e = false; // salvați un bool // Trimiteți date mai mici sau egale cu 250 de octeți prin ESP-ACUM și returnează starea sa esp_err_t result = esp_now_send (broadcastAddress, (uint8_t *) & myData, sizeof (myData)); if (result == ESP_OK) {Serial.println ("Trimis cu succes"); } else {Serial.println ("Eroare la trimiterea datelor"); } întârziere (2000); }

ESP8266 primește date de la ESP32 folosind acest cod.

// Adăugați bibliotecile necesare

. int b; plutitor c; Șirul d; bool e; } struct_message; // Creați o variabilă struct_message numită myData struct_message myData; // funcție numită atunci când datele sunt primite și le imprimă nul OnDataRecv (uint8_t * mac, uint8_t * incomingData, uint8_t len) {memcpy (& myData, incomingData, sizeof (myData)); Serial.print ("Octeți primiți:"); 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 ("Șir:"); Serial.println (MyData.d); Serial.print ("Bool:"); Serial.println (MyData.e); Serial.println (); } void setup () {// Setați viteza de transmisie pentru comunicațiile seriale cu ESP Serial.begin (115200); // Setați dispozitivul ca stație Wi-Fi WiFi.mode (WIFI_STA); // Pornește wifi // Inițiază ESP-ACUM și își returnează starea dacă (esp_now_init ()! = 0) {Serial.println ("Eroare la inițializarea ESP-ACUM"); întoarcere; } esp_now_set_self_role (ESP_NOW_ROLE_SLAVE); // Definește rolul acestui esp esp_now_register_recv_cb (OnDataRecv); // apelează funcția OnDataRecv după primirea datelor ESPNOW} void loop () {}

Pasul 6: Comunicare unidirecțională (ESP8266 ca expeditor)

ESP8266 trimite date către un ESP32. cu acest cod. Schimbați broadcastAddress la adresa Mac a receptorului corespunzător. Adresa mea esp32 este 30: AE: A4: F5: 03: A4. Pentru alte funcții pentru esp8266 accesați aici

// Adăugați bibliotecile necesare

#include // Pentru a adăuga capacități Wifi pe ESP32 #include // Pentru a accesa funcțiile esp acum // salvați adresa MAC într-o matrice numită broadcastAddress; uint8_t broadcastAddress = {0x30, 0xAE, 0xA4, 0xF5, 0x03, 0xA4}; / * definește tipurile de date ale mai multor variabile structurate și redenumite toate ca struct_message * / typedef struct struct_message {char a [32]; int b; plutitor c; Șirul d; bool e; } struct_message; // Creați o variabilă structurată numită myData struct_message myData; // funcția apelată atunci când datele sunt trimise și tipăresc starea sa nulă OnDataSent (uint8_t * mac_addr, uint8_t sendStatus) {Serial.print ("\ r / nStarea ultimului pachet de trimitere: / t"); Serial.println (sendStatus == 1? "Delivery Success": "Delivery Fail"); } void setup () {// Setați viteza de transmisie pentru comunicațiile seriale cu ESP Serial.begin (115200); // Setați dispozitivul ca stație Wi-Fi WiFi.mode (WIFI_STA); // Pornește wifi // Init ESP-NOW și își returnează starea dacă (esp_now_init ()) {Serial.println ("Eroare la inițializarea ESP-NOW"); întoarcere; } esp_now_register_send_cb (OnDataSent); // apelați funcția OnDataSent după trimiterea datelor ESPNOW // Adăugați dispozitivul în lista de dispozitive asociate dacă (esp_now_add_peer (broadcastAddress, ESP_NOW_ROLE_CONTROLLER, 1, NULL, 0)) {Serial.println ("Nu s-a adăugat peer"); întoarcere; }} void loop () {// Setați valori pentru a trimite strcpy (myData.a, „ACEST ESTE UN CHAR”); // salvați „THIS IS A CHAR” în variabila a din „datele” mele definite mai devreme myData.b = random (1, 20); // salvați o valoare aleatorie myData.c = 1.2; // salvați un float myData.d = "SP8266"; // salvați un șir MyData.e = false; // salvați un bool // Trimiteți date mai mici sau egale de 250 de octeți prin ESP-ACUM și returnează starea sa int result = esp_now_send (broadcastAddress, (uint8_t *) & myData, sizeof (myData)); if (esp_now_init ()! = 0) {Serial.println ("Trimis cu succes"); } else {Serial.println ("Eroare la trimiterea datelor"); } întârziere (2000); }

ESP32 primește date de la un ESP8266. cu acest cod. Pentru alte funcții arbitre aici

// Adăugați bibliotecile necesare

. int b; plutitor c; Șirul d; bool e; } struct_message; // Creați o variabilă struct_message numită myData struct_message myData; // funcție numită atunci când datele sunt primite și le imprimă nul OnDataRecv (const uint8_t * mac, const uint8_t * incomingData, int len) {memcpy (& myData, incomingData, sizeof (myData)); Serial.print ("Octeți primiți:"); 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 ("Șir:"); Serial.println (myData.d); Serial.print ("Bool:"); Serial.println (myData.e); Serial.println (); } void setup () {// Setați viteza de transmisie pentru comunicațiile seriale cu ESP Serial.begin (115200); // Setați dispozitivul ca stație Wi-Fi WiFi.mode (WIFI_STA); // Pornește wifi // Inițiază ESP-ACUM și își returnează starea dacă (esp_now_init ()! = 0) {Serial.println ("Eroare la inițializarea ESP-ACUM"); întoarcere; } esp_now_register_recv_cb (OnDataRecv); // apelează funcția OnDataRecv după primirea datelor ESPNOW} void loop () {}

Pasul 7: COMUNICARE DOUĂ CĂI

ESP32 trimite date la pornire către ESP8266. ESP8266 tipărește mesajul primit și apoi răspunsurile la care ESP32 tipărește pe monitorul său serial.

COD ESP32

// Adăugați bibliotecile necesare

#include // Pentru a accesa funcțiile esp acum #include // Pentru a adăuga capacități Wifi pe ESP32 // salvați adresa MAC într-o matrice numită broadcastAddress; uint8_t broadcastAddress = {0xA4, 0xCF, 0x12, 0xC7, 0x9C, 0x77}; // Adresa MAC a receptorului meu / * definește tipurile de date ale multiplelor variabile structurate și redenumite toate ca struct_message * / typedef struct struct_message {char a [32]; int b; plutitor c; Șirul d; bool e; } struct_message; // Creați un struct_message numit myData struct_message myData; // funcție numită atunci când datele sunt trimise pentru a-și imprima starea void OnDataSent (const uint8_t * mac_addr, esp_now_send_status_t status) {Serial.print ("\ r / nStarea ultimului pachet de trimitere: / t"); Serial.println (status == ESP_NOW_SEND_SUCCESS? "Delivery Success": "Livrare nereușită"); 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 ("Octeți primiți:"); 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 ("Șir:"); Serial.println (myData.d); Serial.print ("Bool:"); Serial.println (myData.e); Serial.println (); } void setup () {// Setați viteza de transmisie pentru comunicațiile seriale cu ESP Serial.begin (115200); // Setați dispozitivul ca stație Wi-Fi WiFi.mode (WIFI_STA); // Pornește wifi // Init ESP-ACUM și își returnează starea dacă (esp_now_init ()! = ESP_OK) {Serial.println ("Eroare la inițializarea ESP -ACUM"); întoarcere; } // apelați funcția OnDataSent după trimiterea datelor ESPNOW esp_now_register_send_cb (OnDataSent); // Înregistrează peer esp_now_peer_info_t peerInfo; // inițializați și atribuiți informațiile peer ca un pointer către un memcpy de adresă (peerInfo.peer_addr, broadcastAddress, 6); // copiați valoarea broadcastAddress cu 6 octeți peerInfo.peer_addr peerInfo.channel = 0; // canal la care vorbesc sp. 0 înseamnă nedefinit, iar datele vor fi trimise pe canalul curent.1-14 sunt canale valabile, ceea ce este același cu dispozitivul local peerInfo.encrypt = false; // nu este criptat // Adăugați dispozitivul la lista de dispozitive asociate dacă (esp_now_add_peer (& peerInfo)! = ESP_OK) {Serial.println ("Nu s-a putut adăuga peer"); întoarcere; } esp_now_register_recv_cb (OnDataRecv); // apelează funcția OnDataRecv după primirea datelor ESPNOW send_data (); } void loop () {} void send_data () {Serial.println ("Trimiterea"); // Setați valorile pentru a trimite strcpy (myData.a, „THIS IS A CHAR”); // salvați „THIS IS A CHAR” în variabila a din „datele” mele definite mai devreme myData.b = random (1, 20); // salvați o valoare aleatorie myData.c = 1.2; // salvați un float myData.d = "ESP32"; // salvați un șir MyData.e = false; // salvați un bool // Trimiteți date mai mici sau egale cu 250 de octeți prin ESP-ACUM și returnează starea sa esp_err_t result = esp_now_send (broadcastAddress, (uint8_t *) & myData, sizeof (myData)); if (result == ESP_OK) {Serial.println ("Trimis cu succes");} else {Serial.println ("Eroare la trimiterea datelor"); }}

COD ESP8266

// Adăugați bibliotecile necesare

#include // Pentru a adăuga capacități Wifi pe ESP32 #include // Pentru a accesa funcțiile esp acum // salvați adresa MAC într-o matrice numită broadcastAddress; uint8_t broadcastAddress = {0x30, 0xAE, 0xA4, 0xF5, 0x03, 0xA4}; / * definește tipurile de date ale mai multor variabile structurate și redenumite toate ca struct_message * / typedef struct struct_message {char a [32]; int b; plutitor c; Șirul d; bool e; } struct_message; // Creați o variabilă struct_message numită myData struct_message myData; // funcție numită atunci când datele sunt primite și le imprimă nul OnDataRecv (uint8_t * mac, uint8_t * incomingData, uint8_t len) {memcpy (& myData, incomingData, sizeof (myData)); Serial.print ("Octeți primiți:"); 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 ("Șir:"); Serial.println (myData.d); Serial.print ("Bool:"); Serial.println (myData.e); Serial.println (); send_data (); } void OnDataSent (uint8_t * mac_addr, uint8_t sendStatus) {Serial.print ("\ r / nStarea ultimului pachet de trimitere: / t"); Serial.println (sendStatus == 1? "Delivery Success": "Delivery Fail"); if (sendStatus! = 1) {send_data (); }} void send_data () {// Setați valori pentru a trimite strcpy (myData.a, „ACEST ESTE UN CHAR”); // salvați „THIS IS A CHAR” în variabila a din „datele” mele definite mai devreme myData.b = random (1, 20); // salvați o valoare aleatorie myData.c = 1.2; // salvați un float myData.d = "ESP8266"; // salvați un șir MyData.e = false; // salvați un bool esp_now_send (broadcastAddress, (uint8_t *) & myData, sizeof (myData)); } void setup () {// Setați viteza de transmisie pentru comunicațiile seriale cu ESP Serial.begin (115200); // Setați dispozitivul ca stație Wi-Fi WiFi.mode (WIFI_STA); // Pornește wifi // Inițiază ESP-ACUM și își returnează starea dacă (esp_now_init ()! = 0) {Serial.println ("Eroare la inițializarea ESP-ACUM"); întoarcere; } if (esp_now_add_peer (broadcastAddress, ESP_NOW_ROLE_SLAVE, 1, NULL, 0)) {Serial.println ("Nu s-a adăugat peer"); întoarcere; } esp_now_set_self_role (ESP_NOW_ROLE_COMBO); esp_now_register_send_cb (OnDataSent); esp_now_set_self_role (ESP_NOW_ROLE_COMBO); // Definește rolul acestui esp esp_now_register_recv_cb (OnDataRecv); // apelează funcția OnDataRecv după primirea datelor ESPNOW} void loop () {}

Pasul 8: REFERINȚE

ESPNOW_32_Example

ESPNOW_8266 Exemplu

WIFI.h

ESP8266WiFi.h

esp_now.h pentru ESP8266

esp_now.h pentru ESP32

document oficial esp_now (O mai bună explicație a funcțiilor)

Ghid oficial ESP-ACUM