Cómo hacer una conversación ESP múltiple a través de ESP-NOW usando ESP32 y ESP8266: 8 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:41

En mi proyecto en curso, necesito varios ESP para hablar entre ellos sin un enrutador. Para hacer esto, usaré el ESP-NOW para hacer una comunicación inalámbrica entre ellos sin un enrutador en el ESP.

Suministros

Cosas que usé:

Módulo DEV ESP32

NODEMCU 1.0 (módulo ESP12E)

Paso 1: Obtenga la dirección Mac de la placa

A través de ESP-now, los dispositivos ESP se comunican entre sí enviando datos a su dirección única mientras están conectados a una red de puntos de acceso interna creada al intilar el esp now.. Por lo tanto, determine la dirección MAC de cada dispositivo. Se adjunta la configuración de mi placa ESP32 y ESP8266

PARA ESP32

#include "WiFi.h" // Para acceder a las capacidades WIFI ESP32

configuración vacía () {Serial.begin (115200); Serial.print ("Dirección MAC de la placa ESP32:"); Serial.println (WiFi.macAddress ()); // imprime su dirección MAC} void loop () {}

PARA ESP8266

#include // Biblioteca utilizada para acceder a las capacidades WIFI de ESP8266

configuración vacía () {Serial.begin (115200); Serial.println (); Serial.print ("Dirección MAC de la placa ESP8266:"); Serial.println (WiFi.macAddress ()); // imprime su dirección MAC} void loop () {}

Mi DIRECCIÓN MAC es:

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

Paso 2: Cómo hacer que ESP-NOW funcione

Aquí hay una descripción general sobre cómo hacer que funcione:

1. Incluir esp now y bibliotecas wifi
2. Guarde la dirección mac del ESP del destinatario
3. Definir la estructura de datos del mensaje enviado / recibido.
4. En la configuración, configure el wifi en modo de estación
5. Inicializar esp_now
6. hacer y registrar la función de devolución de llamada llamada después de enviar y recibir datos
7. Para Esp8266, defina su rol
8. registrar al par o destinatario esp
9. Enviar datos

Paso 3: FUNCIONES ESP-NOW (ESP32)

esp_now_init (vacío)

Regreso:

• ESP_OK: tener éxito
• ESP_ERR_ESPNOW_INTERNAL: Error interno

Descripción:

Inicializar la función ESPNOW

esp_now_register_send_cb (cb)

Devoluciones:

• ESP_OK: tener éxito
• ESP_ERR_ESPNOW_NOT_INIT: ESPNOW no está inicializado
• ESP_ERR_ESPNOW_INTERNAL: error interno

Parámetros:

• cb: nombre de la función de devolución de llamada después de enviar datos ESPNOW con estos parámetros:

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

    • mac_addr: dirección mac del receptor

    • estado:

      • 1 = éxito
      • 0 = falla

Descripción:

Llame a la función OnDataSent después de enviar datos ESPNOW

esp_now_add_peerconst esp_now_peer_info_t * par)

Devoluciones:

• ESP_OK: tener éxito
• ESP_ERR_ESPNOW_NOT_INIT: ESPNOW no está inicializado
• ESP_ERR_ESPNOW_ARG: argumento no válido
• ESP_ERR_ESPNOW_FULL: la lista de pares está llena
• ESP_ERR_ESPNOW_NO_MEM: memoria insuficiente
• ESP_ERR_ESPNOW_EXIST: el par ha existido

Parámetros:

• par: información de pares con los siguientes datos:

  • uint8_t

    peer_addr [ESP_NOW_ETH_ALEN]; Dirección MAC del par de ESPNOW que también es la dirección MAC de la estación o software

  • uint8_t lmk [ESP_NOW_KEY_LEN]

    Llave maestra local de pares de ESPNOW que se utiliza para cifrar datos

  • canal uint8_t

    Canal de Wi-Fi que usa el par para enviar / recibir datos ESPNOW. Si el valor es 0, use el canal actual en el que está la estación o el softap. De lo contrario, debe configurarse como el canal en el que se encuentra la estación o el softap

  • wifi_interface_t ifidx

    Interfaz Wi-Fi que utilizan los pares para enviar / recibir datos ESPNOW

  • bool encriptar

    Los datos de ESPNOW que este par envía / recibe están encriptados o no

  • vacío * priv

    Datos privados de pares de ESPNOW

Descripción:

Agregar un par a la lista de pares

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

Devoluciones:

• ESP_OK: tener éxito
• ESP_ERR_ESPNOW_NOT_INIT: ESPNOW no está inicializado
• ESP_ERR_ESPNOW_ARG: argumento inválido
• ESP_ERR_ESPNOW_INTERNAL: error interno
• ESP_ERR_ESPNOW_NO_MEM: memoria insuficiente
• ESP_ERR_ESPNOW_NOT_FOUND: no se encuentra el par
• ESP_ERR_ESPNOW_IF: la interfaz WiFi actual no coincide con la del par

Parámetros:

• peer_addr: dirección MAC del mismo nivel
• datos: datos para enviar
• len: longitud de los datos

Descripción:

Envía datos de ESPNOW. En algunos casos, esto sucede:

• Si peer_addr no es NULL, envíe datos al par cuya dirección MAC coincida con peer_addr
• Si peer_addr es NULL, envíe datos a todos los pares que se agregan a la lista de pares
• La longitud máxima de datos debe ser menor que ESP_NOW_MAX_DATA_LEN
• El búfer al que apunta el argumento de datos no necesita ser válido después de que esp_now_send regrese

esp_now_register_recv_cb (cb)

Devoluciones:

• ESP_OK: tener éxito
• ESP_ERR_ESPNOW_NOT_INIT: ESPNOW no está inicializado
• ESP_ERR_ESPNOW_INTERNAL: error interno

Parámetros:

• cb: función de devolución de llamada para recibir datos ESPNOW

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

    • mac_addr:

      dirección mac del receptor

    • *datos:

      recibir datos

    • data_len

      longitud del byte de datos

Descripción:

Llame a la función cb después de recibir datos de ESPNOW

Paso 4: FUNCIONES ESP-NOW (ESP8266)

DESCRIPCIÓN DE LAS FUNCIONES ESP32 ESP8266

int esp_now_init (vacío)

Devoluciones:

• 1 = éxito
• 0 = falla

Descripción

Inicializar la función ESPNOW

int esp_now_set_self_role (rol u8)

Parámetros:

• ESP_NOW_ROLE_IDLE: no se permite la transmisión de datos.
• ESP_NOW_ROLE_CONTROLLER: se da prioridad a la interfaz Sation
• ESP_NOW_ROLE_SLAVE: se da prioridad a la interfaz SoftAP
• ESP_NOW_ROLE_COMBO: se da prioridad a SoftAPinterface

Descripción

Establece la función del dispositivo

int esp_now_register_send_cb (cb)

Devoluciones:

• 1 = éxito
• 0 = falla

Parámetros:

• cb: nombre de la función de devolución de llamada después de enviar datos ESPNOW con estos parámetros:

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

    • mac_addr: dirección mac del receptor

    • estado:

      • 1 = éxito
      • 0 = falla

Descripción

Llame a la función OnDataSent después de enviar datos ESPNOW

int esp_now_add_peer (u8 * mac_addr, función u8, canal u8, clave u8 *, clave u8_len)

Devoluciones:

• 1 = éxito
• 0 = falla

Parámetros:

• mac_addr

  dirección mac del par

• papel

• canal

  Si el valor es 0, use el canal actual en el que está la estación o el softap. De lo contrario, debe configurarse como el canal en el que se encuentra la estación o el softap

• *llave

  clave para cifrado

• key_len

  longitud de la llave

Descripción:

Agregar un par a la lista de pares

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

Devoluciones:

• 1 = éxito
• 0 = Falla

Parámetros:

• peer_addr: dirección MAC del mismo nivel
• datos: datos para enviar
• len: longitud de los datos

Descripción:

Envía datos de ESPNOW. En algunos casos, esto sucede:

• Si peer_addr no es NULL, envíe datos al par cuya dirección MAC coincida con peer_addr
• Si peer_addr es NULL, envíe datos a todos los pares que se agregan a la lista de pares
• La longitud máxima de datos debe ser menor que ESP_NOW_MAX_DATA_LEN
• El búfer al que apunta el argumento de datos no necesita ser válido después de que esp_now_send regrese

int esp_now_register_recv_cb (cb)

Devoluciones:

• 1 = éxito
• 0 = Falla

Parámetros:

• cb: función de devolución de llamada para recibir datos ESPNOW

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

    • mac_addr:

      dirección mac del receptor

    • *datos:

      recibir datos

    • data_len

      longitud del byte de datos

Descripción:

Llame a la función cb después de recibir datos de ESPNOW

Paso 5: Comunicación unidireccional (ESP32 como remitente)

El ESP32 envía datos a un ESP8266. con este código. Cambie broadcastAddress por la dirección mac de su receptor correspondiente. El mío era A4: CF: 12: C7: 9C: 77

// Agrega las bibliotecas necesarias

#include // Para acceder a las funciones esp now #include // Para agregar capacidades Wifi en ESP32 // guarde la dirección MAC en una matriz llamada broadcastAddress; uint8_t broadcastAddress = {0xA4, 0xCF, 0x12, 0xC7, 0x9C, 0x77}; // Dirección MAC de mi receptor / * definir los tipos de datos de las múltiples variables estructuradas y renombradas todas ellas como struct_message * / typedef struct struct_message {char a [32]; int b; flotar c; String d; bool e; } struct_message; // Crea un struct_message llamado myData struct_message myData; // función llamada cuando se envían datos para imprimir su estado void OnDataSent (const uint8_t * mac_addr, esp_now_send_status_t status) {Serial.print ("\ r / nLast Packet Send Status: / t"); Serial.println (estado == ESP_NOW_SEND_SUCCESS? "Entrega exitosa": "Entrega fallida"); } void setup () {// Establece la velocidad en baudios para la comunicación serial con ESP Serial.begin (115200); // Establece el dispositivo como una estación Wi-Fi WiFi.mode (WIFI_STA); // Inicia el wifi // Inicia ESP-NOW y devuelve su estado if (esp_now_init ()! = ESP_OK) {Serial.println ("Error al inicializar ESP -AHORA"); regreso; } // llamar a la función OnDataSent después de enviar datos ESPNOW esp_now_register_send_cb (OnDataSent); // Registrar peer esp_now_peer_info_t peerInfo; // inicializar y asignar la información de los pares como un puntero a una dirección memcpy (peerInfo.peer_addr, broadcastAddress, 6); // copia el valor de broadcastAddress con 6 bytes a peerInfo.peer_addr peerInfo.channel = 0; // canal en el que hablan los esp. 0 significa indefinido y los datos se enviarán en el canal actual. 1-14 son canales válidos que es lo mismo con el dispositivo local peerInfo.encrypt = false; // no encriptado // Agregue el dispositivo a la lista de dispositivos emparejados if (esp_now_add_peer (& peerInfo)! = ESP_OK) {Serial.println ("No se pudo agregar par"); regreso; }} void loop () {// Establecer valores para enviar strcpy (myData.a, "ESTO ES UN CHAR"); // guardar "ESTO ES UN CHAR" en la variable a de mis "datos" definidos anteriormente myData.b = random (1, 20); // guarda un valor aleatorio myData.c = 1.2; // guarda un flotante myData.d = "Hola"; // guarda una cadena myData.e = false; // guardar un bool // Enviar datos menores o iguales a 250 bytes a través de ESP-NOW y devuelve su estado esp_err_t result = esp_now_send (broadcastAddress, (uint8_t *) & myData, sizeof (myData)); if (resultado == ESP_OK) {Serial.println ("Enviado con éxito"); } else {Serial.println ("Error al enviar los datos"); } retraso (2000); }

El ESP8266 recibe datos del ESP32 usando este código.

// Agrega las bibliotecas necesarias

#include // Para agregar capacidades Wifi en ESP32 #include // Para acceder a las funciones esp now / * definir los tipos de datos de las múltiples variables estructuradas y renombradas todas como struct_message * / typedef struct struct_message {char a [32]; int b; flotar c; String d; bool e; } struct_message; // Crea una variable struct_message llamada myData struct_message myData; // función llamada cuando se reciben los datos y los imprime void OnDataRecv (uint8_t * mac, uint8_t * entranteData, uint8_t len) {memcpy (& myData, entranteData, sizeof (myData)); Serial.print ("Bytes recibidos:"); Serial.println (len); Serial.print ("Carácter:"); Serial.println (myData.a); Serial.print ("Int:"); Serial.println (myData.b); Serial.print ("Float:"); Serial.println (myData.c); Serial.print ("Cadena:"); Serial.println (myData.d); Serial.print ("Bool:"); Serial.println (myData.e); Serial.println (); } void setup () {// Establece la velocidad en baudios para la comunicación serial con ESP Serial.begin (115200); // Establecer el dispositivo como una estación Wi-Fi WiFi.mode (WIFI_STA); // Inicia wifi // Inicia ESP-NOW y devuelve su estado if (esp_now_init ()! = 0) {Serial.println ("Error al inicializar ESP-NOW"); regreso; } esp_now_set_self_role (ESP_NOW_ROLE_SLAVE); // Define el rol de este esp esp_now_register_recv_cb (OnDataRecv); // llama a la función OnDataRecv después de recibir datos de ESPNOW} void loop () {}

Paso 6: Comunicación unidireccional (ESP8266 como remitente)

El ESP8266 envía datos a un ESP32. con este código. Cambie broadcastAddress por la dirección mac de su receptor correspondiente. Mi dirección esp32 es 30: AE: A4: F5: 03: A4. Para otras funciones para esp8266, vaya aquí

// Agrega las bibliotecas necesarias

#include // Para agregar capacidades Wifi en ESP32 #include // Para acceder a las funciones esp now // guarde la dirección MAC en una matriz llamada broadcastAddress; uint8_t broadcastAddress = {0x30, 0xAE, 0xA4, 0xF5, 0x03, 0xA4}; / * definir los tipos de datos de las múltiples variables estructuradas y renombrarlas todas como struct_message * / typedef struct struct_message {char a [32]; int b; flotar c; String d; bool e; } struct_message; // Cree una variable estructurada llamada myData struct_message myData; // función llamada cuando se envían datos e imprime su estado void OnDataSent (uint8_t * mac_addr, uint8_t sendStatus) {Serial.print ("\ r / nLast Packet Send Status: / t"); Serial.println (sendStatus == 1? "Entrega exitosa": "Entrega fallida"); } void setup () {// Establece la velocidad en baudios para la comunicación serial con ESP Serial.begin (115200); // Establece el dispositivo como una estación Wi-Fi WiFi.mode (WIFI_STA); // Inicia el wifi // Inicia ESP-NOW y devuelve su estado if (esp_now_init ()) {Serial.println ("Error al inicializar ESP-NOW"); regreso; } esp_now_register_send_cb (OnDataSent); // llamar a la función OnDataSent después de enviar datos ESPNOW // Agregar el dispositivo a la lista de dispositivos emparejados si (esp_now_add_peer (broadcastAddress, ESP_NOW_ROLE_CONTROLLER, 1, NULL, 0)) {Serial.println ("No se pudo agregar un par"); regreso; }} void loop () {// Establecer valores para enviar strcpy (myData.a, "ESTO ES UN CHAR"); // guardar "ESTO ES UN CHAR" en la variable a de mis "datos" definidos anteriormente myData.b = random (1, 20); // guarda un valor aleatorio myData.c = 1.2; // guarda un flotante myData.d = "SP8266"; // guarda una cadena myData.e = false; // guarda un bool // Envía datos menores o iguales a 250 bytes a través de ESP-NOW y devuelve su estado int result = esp_now_send (broadcastAddress, (uint8_t *) & myData, sizeof (myData)); if (esp_now_init ()! = 0) {Serial.println ("Enviado con éxito"); } else {Serial.println ("Error al enviar los datos"); } retraso (2000); }

El ESP32 recibe datos de un ESP8266. con este código. Para otras funciones, consulte aquí

// Agrega las bibliotecas necesarias

#include // Para acceder a las funciones esp now #include // Para agregar capacidades Wifi en ESP32 / * definir los tipos de datos de las múltiples variables estructuradas y renombradas todas ellas como struct_message * / typedef struct struct_message {char a [32]; int b; flotar c; String d; bool e; } struct_message; // Crea una variable struct_message llamada myData struct_message myData; // función llamada cuando se reciben los datos y los imprime void OnDataRecv (const uint8_t * mac, const uint8_t * entranteData, int len) {memcpy (& myData, entranteData, sizeof (myData)); Serial.print ("Bytes recibidos:"); Serial.println (len); Serial.print ("Carácter:"); Serial.println (myData.a); Serial.print ("Int:"); Serial.println (myData.b); Serial.print ("Float:"); Serial.println (myData.c); Serial.print ("Cadena:"); Serial.println (myData.d); Serial.print ("Bool:"); Serial.println (myData.e); Serial.println (); } void setup () {// Establece la velocidad en baudios para la comunicación serial con ESP Serial.begin (115200); // Establecer el dispositivo como una estación Wi-Fi WiFi.mode (WIFI_STA); // Inicia wifi // Inicia ESP-NOW y devuelve su estado if (esp_now_init ()! = 0) {Serial.println ("Error al inicializar ESP-NOW"); regreso; } esp_now_register_recv_cb (OnDataRecv); // llama a la función OnDataRecv después de recibir datos de ESPNOW} void loop () {}

Paso 7: COMUNICACIÓN DE DOS VÍAS

El ESP32 envía datos al inicio al ESP8266. El ESP8266 imprime el mensaje recibido y luego responde que el ESP32 imprime en su monitor de serie.

CÓDIGO ESP32

// Agrega las bibliotecas necesarias

#include // Para acceder a las funciones esp now #include // Para agregar capacidades Wifi en ESP32 // guarde la dirección MAC en una matriz llamada broadcastAddress; uint8_t broadcastAddress = {0xA4, 0xCF, 0x12, 0xC7, 0x9C, 0x77}; // Dirección MAC de mi receptor / * definir los tipos de datos de las múltiples variables estructuradas y renombradas todas ellas como struct_message * / typedef struct struct_message {char a [32]; int b; flotar c; String d; bool e; } struct_message; // Crea un struct_message llamado myData struct_message myData; // función llamada cuando se envían datos para imprimir su estado void OnDataSent (const uint8_t * mac_addr, esp_now_send_status_t status) {Serial.print ("\ r / nLast Packet Send Status: / t"); Serial.println (estado == ESP_NOW_SEND_SUCCESS? "Entrega exitosa": "Entrega fallida"); if (status! = ESP_NOW_SEND_SUCCESS) {send_data ();}} void OnDataRecv (const uint8_t * mac, const uint8_t * entranteData, int len) {memcpy (& myData, entranteData, tamaño de (myData)); Serial.print ("Bytes recibidos:"); Serial.println (len); Serial.print ("Carácter:"); Serial.println (myData.a); Serial.print ("Int:"); Serial.println (myData.b); Serial.print ("Float:"); Serial.println (myData.c); Serial.print ("Cadena:"); Serial.println (myData.d); Serial.print ("Bool:"); Serial.println (myData.e); Serial.println (); } void setup () {// Establece la velocidad en baudios para la comunicación en serie con ESP Serial.begin (115200); // Establece el dispositivo como una estación Wi-Fi WiFi.mode (WIFI_STA); // Inicia el wifi // Inicia ESP-NOW y devuelve su estado if (esp_now_init ()! = ESP_OK) {Serial.println ("Error al inicializar ESP -AHORA"); regreso; } // llamar a la función OnDataSent después de enviar datos ESPNOW esp_now_register_send_cb (OnDataSent); // Registrar peer esp_now_peer_info_t peerInfo; // inicializar y asignar la información de los pares como un puntero a una dirección memcpy (peerInfo.peer_addr, broadcastAddress, 6); // copia el valor de broadcastAddress con 6 bytes a peerInfo.peer_addr peerInfo.channel = 0; // canal en el que hablan los esp. 0 significa indefinido y los datos se enviarán en el canal actual.1-14 son canales válidos que es lo mismo con el dispositivo local peerInfo.encrypt = false; // no encriptado // Agregue el dispositivo a la lista de dispositivos emparejados if (esp_now_add_peer (& peerInfo)! = ESP_OK) {Serial.println ("No se pudo agregar par"); regreso; } esp_now_register_recv_cb (OnDataRecv); // llama a la función OnDataRecv después de recibir los datos de ESPNOW send_data (); } void loop () {} void send_data () {Serial.println ("Enviando"); // Establecer valores para enviar strcpy (myData.a, "ESTO ES UN CHAR"); // guardar "ESTO ES UN CHAR" en la variable a de mis "datos" definidos anteriormente myData.b = random (1, 20); // guarda un valor aleatorio myData.c = 1.2; // guarda un flotante myData.d = "ESP32"; // guarda una cadena myData.e = false; // guardar un bool // Enviar datos menores o iguales a 250 bytes a través de ESP-NOW y devuelve su estado esp_err_t result = esp_now_send (broadcastAddress, (uint8_t *) & myData, sizeof (myData)); if (resultado == ESP_OK) {Serial.println ("Enviado con éxito");} else {Serial.println ("Error al enviar los datos"); }}

CÓDIGO ESP8266

// Agrega las bibliotecas necesarias

#include // Para agregar capacidades Wifi en ESP32 #include // Para acceder a las funciones esp now // guarde la dirección MAC en una matriz llamada broadcastAddress; uint8_t broadcastAddress = {0x30, 0xAE, 0xA4, 0xF5, 0x03, 0xA4}; / * definir los tipos de datos de las múltiples variables estructuradas y renombrarlas todas como struct_message * / typedef struct struct_message {char a [32]; int b; flotar c; String d; bool e; } struct_message; // Crea una variable struct_message llamada myData struct_message myData; // función llamada cuando se reciben los datos y los imprime void OnDataRecv (uint8_t * mac, uint8_t * entranteData, uint8_t len) {memcpy (& myData, entranteData, sizeof (myData)); Serial.print ("Bytes recibidos:"); Serial.println (len); Serial.print ("Carácter:"); Serial.println (myData.a); Serial.print ("Int:"); Serial.println (myData.b); Serial.print ("Float:"); Serial.println (myData.c); Serial.print ("Cadena:"); Serial.println (myData.d); Serial.print ("Bool:"); Serial.println (myData.e); Serial.println (); enviar datos(); } void OnDataSent (uint8_t * mac_addr, uint8_t sendStatus) {Serial.print ("\ r / nÚltimo estado de envío de paquetes: / t"); Serial.println (sendStatus == 1? "Entrega exitosa": "Entrega fallida"); if (sendStatus! = 1) {send_data (); }} void send_data () {// Establecer valores para enviar strcpy (myData.a, "ESTO ES UN CHAR"); // guardar "ESTO ES UN CHAR" en la variable a de mis "datos" definidos anteriormente myData.b = random (1, 20); // guarda un valor aleatorio myData.c = 1.2; // guarda un float myData.d = "ESP8266"; // guarda una cadena myData.e = false; // guarda un bool esp_now_send (broadcastAddress, (uint8_t *) & myData, sizeof (myData)); } void setup () {// Establece la velocidad en baudios para la comunicación en serie con ESP Serial.begin (115200); // Establecer el dispositivo como una estación Wi-Fi WiFi.mode (WIFI_STA); // Inicia wifi // Inicia ESP-NOW y devuelve su estado if (esp_now_init ()! = 0) {Serial.println ("Error al inicializar ESP-NOW"); regreso; } if (esp_now_add_peer (broadcastAddress, ESP_NOW_ROLE_SLAVE, 1, NULL, 0)) {Serial.println ("No se pudo agregar un par"); regreso; } 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 el rol de este esp esp_now_register_recv_cb (OnDataRecv); // llama a la función OnDataRecv después de recibir datos de ESPNOW} void loop () {}

Paso 8: REFERENCIAS

ESPNOW_32_Ejemplo

Ejemplo de ESPNOW_8266

WIFI.h

ESP8266WiFi.h

esp_now.h para ESP8266

esp_now.h para ESP32

documento oficial esp_now (Mejor explicación de funciones)

Guía oficial ESP-NOW