Comment faire parler plusieurs ESP via ESP-NOW en utilisant ESP32 et ESP8266 : 8 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:06

Sur mon projet en cours, j'ai besoin de plusieurs ESP pour communiquer entre eux sans routeur. Pour ce faire, j'utiliserai l'ESP-NOW pour faire communiquer sans fil les uns avec les autres sans routeur sur l'ESP.

Fournitures

Choses que j'ai utilisées:

Module ESP32 DEV

NODEMCU 1.0 (module ESP12E)

Étape 1: Obtenez l'adresse Mac de la carte

Grâce à ESP-now, les appareils ESP communiquent entre eux en envoyant des données à leur adresse unique tout en étant connectés à un réseau de points d'accès interne créé lors de l'intégration de l'esp now.. Ainsi, déterminez l'adresse MAC de chaque appareil. Ci-joint mes paramètres de carte ESP32 et ESP8266

POUR ESP32

#include "WiFi.h" //Pour accéder aux capacités WIFI de l'ESP32

void setup(){ Serial.begin(115200); Serial.print ("Adresse MAC de la carte ESP32: "); Serial.println(WiFi.macAddress()); // imprime son adresse MAC } void loop(){}

POUR ESP8266

#include //Bibliothèque utilisée pour accéder aux capacités WIFI de l'ESP8266

void setup(){ Serial.begin(115200); Serial.println(); Serial.print ("Adresse MAC de la carte ESP8266: "); Serial.println(WiFi.macAddress()); // imprime son adresse MAC } void loop(){}

Mon ADRESSE MAC sont:

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

Étape 2: Comment faire fonctionner ESP-NOW

Voici un aperçu sur la façon de le faire fonctionner:

1. Inclure esp now et les bibliothèques wifi
2. Enregistrer l'adresse mac du destinataire ESP
3. Définir la structure de données du message envoyé/reçu
4. Sur la configuration, mettez le wifi en mode station
5. Initialiser esp_now
6. créer et enregistrer la fonction de rappel appelée après l'envoi et la réception de données
7. Pour Esp8266, définir son rôle
8. enregistrer le pair ou le destinataire esp
9. Envoyer des données

Étape 3: FONCTIONS ESP-NOW (ESP32)

esp_now_init(void)

Revenir:

• ESP_OK: réussir
• ESP_ERR_ESPNOW_INTERNAL: erreur interne

La description:

Initialiser la fonction ESPNOW

esp_now_register_send_cb(cb)

Retour:

• ESP_OK: réussir
• ESP_ERR_ESPNOW_NOT_INIT: ESPNOW n'est pas initialisé
• ESP_ERR_ESPNOW_INTERNAL: erreur interne

Paramètres:

• cb: nom de la fonction de rappel après l'envoi de données ESPNOW avec ces paramètres:

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

    • mac_addr: adresse mac du destinataire

    • statut:

      • 1 = succès
      • 0 = échec

La description:

Appelez la fonction OnDataSent après avoir envoyé des données ESPNOW

esp_now_add_peerconst esp_now_peer_info_t *peer)

Retour:

• ESP_OK: réussir
• ESP_ERR_ESPNOW_NOT_INIT: ESPNOW n'est pas initialisé
• ESP_ERR_ESPNOW_ARG: argument invalide
• ESP_ERR_ESPNOW_FULL: la liste des pairs est pleine
• ESP_ERR_ESPNOW_NO_MEM: manque de mémoire
• ESP_ERR_ESPNOW_EXIST: le pair a existé

Paramètres:

• peer: informations sur les pairs avec les données suivantes:

  • uint8_t

    peer_addr[ESP_NOW_ETH_ALEN]; Adresse MAC du pair ESPNOW qui est également l'adresse MAC de la station ou du logiciel

  • uint8_t lmk[ESP_NOW_KEY_LEN]

    Clé principale locale de pair ESPNOW utilisée pour chiffrer les données

  • canal uint8_t

    Canal Wi-Fi que l'homologue utilise pour envoyer/recevoir des données ESPNOW. Si la valeur est 0, utilisez le canal actuel sur lequel se trouve la station ou le softap. Sinon, il doit être défini comme le canal sur lequel se trouve la station ou le logiciel

  • wifi_interface_t ifidx

    Interface Wi-Fi que le pair utilise pour envoyer/recevoir des données ESPNOW

  • bool crypter

    Les données ESPNOW que ce pair envoie/reçoit sont chiffrées ou non

  • vide *priv

    Données privées des pairs ESPNOW

La description:

Ajouter une liste de pairs à pairs

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

Retour:

• ESP_OK: réussir
• ESP_ERR_ESPNOW_NOT_INIT: ESPNOW n'est pas initialisé
• ESP_ERR_ESPNOW_ARG: argument invalide
• ESP_ERR_ESPNOW_INTERNAL: erreur interne
• ESP_ERR_ESPNOW_NO_MEM: manque de mémoire
• ESP_ERR_ESPNOW_NOT_FOUND: l'homologue n'est pas trouvé
• ESP_ERR_ESPNOW_IF: l'interface WiFi actuelle ne correspond pas à celle du pair

Paramètres:

• peer_addr: adresse MAC du pair
• data: données à envoyer
• len: longueur des données

La description:

Envoyez des données ESPNOW. Dans certains cas, cela se produit:

• Si peer_addr n'est pas NULL, envoyez les données à l'homologue dont l'adresse MAC correspond à peer_addr
• Si peer_addr est NULL, envoyer des données à tous les pairs qui sont ajoutés à la liste de pairs
• La longueur maximale des données doit être inférieure à ESP_NOW_MAX_DATA_LEN
• Le tampon pointé par l'argument data n'a pas besoin d'être valide après le retour de esp_now_send

esp_now_register_recv_cb(cb)

Retour:

• ESP_OK: réussir
• ESP_ERR_ESPNOW_NOT_INIT: ESPNOW n'est pas initialisé
• ESP_ERR_ESPNOW_INTERNAL: erreur interne

Paramètres:

• cb: fonction de rappel pour recevoir les données ESPNOW

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

    • adresse_mac:

      adresse mac du destinataire

    • *Les données:

      données recevoir

    • data_len

      longueur d'octet de données

La description:

Appelez la fonction cb après avoir reçu les données ESPNOW

Étape 4: FONCTIONS ESP-NOW (ESP8266)

FONCTIONS DESCRIPTION ESP32 ESP8266

int esp_now_init(void)

Retour:

• 1 = succès
• 0=échec

La description

Initialiser la fonction ESPNOW

int esp_now_set_self_role (rôle u8)

Paramètres:

• ESP_NOW_ROLE_IDLE: la transmission de données n'est pas autorisée.
• ESP_NOW_ROLE_CONTROLLER: priorité est donnée à l'interface Sation
• ESP_NOW_ROLE_SLAVE: la priorité est donnée à l'interface SoftAP
• ESP_NOW_ROLE_COMBO: la priorité est donnée à SoftAPinterface

La description

Définit le rôle de l'appareil

int esp_now_register_send_cb(cb)

Retour:

• 1 = succès
• 0 = échec

Paramètres:

• cb: nom de la fonction de rappel après l'envoi de données ESPNOW avec ces paramètres:

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

    • mac_addr: adresse mac du destinataire

    • statut:

      • 1 = succès
      • 0 = échec

La description

Appelez la fonction OnDataSent après avoir envoyé des données ESPNOW

int esp_now_add_peer (u8 *mac_addr, rôle u8, canal u8, u8 *key, u8 key_len)

Retour:

• 1 = succès
• 0 = échec

Paramètres:

• adresse_mac

  adresse mac du pair

• rôle

• canaliser

  Si la valeur est 0, utilisez le canal actuel sur lequel se trouve la station ou le softap. Sinon, il doit être défini comme le canal sur lequel se trouve la station ou le logiciel

• *clé

  clé de cryptage

• key_len

  longueur de clé

La description:

Ajouter une liste de pairs à pairs

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

Retour:

• 1 = Succès
• 0 = Échec

Paramètres:

• peer_addr: adresse MAC du pair
• data: données à envoyer
• len: longueur des données

La description:

Envoyez des données ESPNOW. Dans certains cas, cela se produit:

• Si peer_addr n'est pas NULL, envoyer des données à l'homologue dont l'adresse MAC correspond à peer_addr
• Si peer_addr est NULL, envoyer des données à tous les pairs qui sont ajoutés à la liste de pairs
• La longueur maximale des données doit être inférieure à ESP_NOW_MAX_DATA_LEN
• Le tampon pointé par l'argument data n'a pas besoin d'être valide après le retour de esp_now_send

int esp_now_register_recv_cb(cb)

Retour:

• 1 = Succès
• 0 = Échec

Paramètres:

• cb: fonction de rappel pour recevoir les données ESPNOW

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

    • adresse_mac:

      adresse mac du destinataire

    • *Les données:

      données reçues

    • data_len

      longueur d'octet de données

La description:

Appelez la fonction cb après avoir reçu les données ESPNOW

Étape 5: Communication unidirectionnelle (ESP32 en tant qu'expéditeur)

L'ESP32 envoie des données à un ESP8266. avec ce code. Remplacez broadcastAddress par l'adresse MAC de votre récepteur correspondant. Le mien était A4:CF:12:C7:9C:77

//Ajouter les bibliothèques nécessaires

#include //Pour accéder aux fonctions esp now #include //Pour ajouter des capacités Wifi sur ESP32 //enregistrez l'adresse MAC dans un tableau nommé broadcastAddress; uint8_t broadcastAddress = {0xA4, 0xCF, 0x12, 0xC7, 0x9C, 0x77}; //Adresse MAC de mon destinataire /*définir les types de données des multiples variables structurées et toutes renommées en struct_message*/ typedef struct struct_message { char a[32]; int b; flotteur c; Chaîne d; bool e; } struct_message; // Crée un struct_message appelé myData struct_message myData; // fonction appelée lorsque les données sont envoyées pour imprimer son statut void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) { Serial.print("\r\nLast Packet Send Status:\t"); Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success": "Delivery Fail"); } void setup() { //Définir le débit en bauds pour la communication série avec ESP Serial.begin(115200); // Définir l'appareil comme station Wi-Fi WiFi.mode(WIFI_STA); // Démarre le wifi // Init ESP-NOW et renvoie son statut if (esp_now_init() != ESP_OK) { Serial.println("Erreur d'initialisation ESP -MAINTENANT"); revenir; } //appel de la fonction OnDataSent après l'envoi des données ESPNOW esp_now_register_send_cb(OnDataSent); // Enregistrer le pair esp_now_peer_info_t peerInfo; //initialiser et affecter les informations de pair en tant que pointeur vers une adresse memcpy(peerInfo.peer_addr, broadcastAddress, 6); //copier la valeur de broadcastAddress avec 6 octets dans peerInfo.peer_addr peerInfo.channel = 0; //canal sur lequel l'esp parle. 0 signifie indéfini et les données seront envoyées sur le canal actuel. 1-14 sont des canaux valides, ce qui est le même avec le périphérique local peerInfo.encrypt = false; //non chiffré //Ajoute le périphérique à la liste des périphériques couplés if (esp_now_add_peer(&peerInfo) != ESP_OK){ Serial.println("Impossible d'ajouter le pair"); revenir; } } void loop() { // Définir les valeurs à envoyer strcpy(myData.a, "CECI EST UN CHAR"); //enregistrer "CECI EST UN CHAR" dans la variable a de mes "données" définies précédemment myData.b = random(1, 20); //enregistrer une valeur aléatoire myData.c = 1.2; //sauve un flottant myData.d = "Bonjour"; //enregistrer une chaîne myData.e = false; //sauve un bool //Envoie des données inférieures ou égales à 250 octets via ESP-NOW et renvoie son statut esp_err_t result = esp_now_send(broadcastAddress, (uint8_t *) &myData, sizeof(myData)); if (résultat == ESP_OK) { Serial.println("Envoyé avec succès"); } else { Serial.println("Erreur lors de l'envoi des données"); } retard (2000); }

L'ESP8266 reçoit les données de l'ESP32 à l'aide de ce code.

//Ajouter les bibliothèques nécessaires

#include //Pour ajouter des capacités Wifi sur ESP32 #include //Pour accéder aux fonctions esp now /*définir les types de données des multiples variables structurées et toutes renommées en struct_message*/ typedef struct struct_message { char a[32]; int b; flotteur c; Chaîne d; bool e; } struct_message; // Crée une variable struct_message appelée myData struct_message myData; // fonction appelée lorsque les données sont reçues et les imprime void OnDataRecv(uint8_t * mac, uint8_t *incomingData, uint8_t len) { memcpy(&myData, entrantData, sizeof(myData)); Serial.print("Octets reçus: "); Serial.println(len); Serial.print("Car: "); 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() { //Définir le débit en bauds pour la communication série avec ESP Serial.begin(115200); // Définir l'appareil comme station Wi-Fi WiFi.mode(WIFI_STA); //Démarre le wifi // Init ESP-NOW et renvoie son statut if (esp_now_init() != 0) { Serial.println("Error initializing ESP-NOW"); revenir; } esp_now_set_self_role(ESP_NOW_ROLE_SLAVE); //Définit le rôle de cet esp esp_now_register_recv_cb(OnDataRecv); //Appelez la fonction OnDataRecv après avoir reçu les données ESPNOW } void loop() {}

Étape 6: Communication unidirectionnelle (ESP8266 en tant qu'expéditeur)

L'ESP8266 envoie des données à un ESP32. avec ce code. Remplacez broadcastAddress par l'adresse MAC de votre récepteur correspondant. Mon adresse esp32 est 30:AE:A4:F5:03:A4. Pour d'autres fonctions pour esp8266, allez ici

//Ajouter les bibliothèques nécessaires

#include //Pour ajouter des capacités Wifi sur ESP32 #include //Pour accéder aux fonctions esp now //enregistrez l'adresse MAC dans un tableau nommé broadcastAddress; uint8_t broadcastAddress = {0x30, 0xAE, 0xA4, 0xF5, 0x03, 0xA4}; /*définir les types de données des multiples variables structurées et renommées toutes en struct_message*/ typedef struct struct_message { char a[32]; int b; flotteur c; Chaîne d; bool e; } struct_message; // Crée une variable structurée appelée myData struct_message myData; // fonction appelée lorsque les données sont envoyées et affiche son statut void OnDataSent(uint8_t *mac_addr, uint8_t sendStatus) { Serial.print("\r\nLast Packet Send Status:\t"); Serial.println(sendStatus == 1 ? "Delivery Success": "Delivery Fail"); } void setup() { //Définir le débit en bauds pour la communication série avec ESP Serial.begin(115200); // Définir l'appareil comme station Wi-Fi WiFi.mode(WIFI_STA); // Démarre le wifi // Init ESP-NOW et renvoie son état if (esp_now_init()) { Serial.println("Erreur d'initialisation ESP-NOW"); revenir; } esp_now_register_send_cb(OnDataSent); //Appelez la fonction OnDataSent après avoir envoyé des données ESPNOW //Ajoutez le périphérique à la liste des périphériques couplés if (esp_now_add_peer(broadcastAddress, ESP_NOW_ROLE_CONTROLLER, 1, NULL, 0)){ Serial.println("Échec de l'ajout du pair"); revenir; } } void loop() { // Définir les valeurs à envoyer strcpy(myData.a, "CECI EST UN CHAR"); //enregistrer "CECI EST UN CHAR" dans la variable a de mes "données" définies précédemment myData.b = random(1, 20); //enregistrer une valeur aléatoire myData.c = 1.2; //enregistrer un flottant myData.d = "SP8266"; //enregistrer une chaîne myData.e = false; //sauve un bool //Envoie des données inférieures ou égales à 250 octets via ESP-NOW et renvoie son statut int result = esp_now_send(broadcastAddress, (uint8_t *) &myData, sizeof(myData)); if (esp_now_init() != 0) { Serial.println("Envoyé avec succès"); } else { Serial.println("Erreur lors de l'envoi des données"); } retard (2000); }

L'ESP32 reçoit les données d'un ESP8266. avec ce code. Pour d'autres fonctions, référez-vous ici

//Ajouter les bibliothèques nécessaires

#include //Pour accéder aux fonctions esp now #include //Pour ajouter des capacités Wifi sur ESP32 /*définir les types de données des multiples variables structurées et renommées toutes en struct_message*/ typedef struct struct_message { char a[32]; int b; flotteur c; Chaîne d; bool e; } struct_message; // Crée une variable struct_message appelée myData struct_message myData; // fonction appelée lorsque les données sont reçues et les imprime void OnDataRecv(const uint8_t * mac, const uint8_t *incomingData, int len) { memcpy(&myData, entrantData, sizeof(myData)); Serial.print("Octets reçus: "); Serial.println(len); Serial.print("Car: "); 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() { //Définir le débit en bauds pour la communication série avec ESP Serial.begin(115200); // Définir l'appareil comme station Wi-Fi WiFi.mode(WIFI_STA); //Démarre le wifi // Init ESP-NOW et renvoie son statut if (esp_now_init() != 0) { Serial.println("Error initializing ESP-NOW"); revenir; } esp_now_register_recv_cb(OnDataRecv); //Appelez la fonction OnDataRecv après avoir reçu les données ESPNOW } void loop() {}

Étape 7: COMMUNICATION BIDIRECTIONNELLE

L'ESP32 envoie des données au démarrage à l'ESP8266. L'ESP8266 imprime le message reçu puis les réponses dont l'ESP32 imprime sur son moniteur série.

CODE ESP32

//Ajouter les bibliothèques nécessaires

#include //Pour accéder aux fonctions esp now #include //Pour ajouter des capacités Wifi sur ESP32 //enregistrez l'adresse MAC dans un tableau nommé broadcastAddress; uint8_t broadcastAddress = {0xA4, 0xCF, 0x12, 0xC7, 0x9C, 0x77}; //Adresse MAC de mon destinataire /*définir les types de données des multiples variables structurées et toutes renommées en struct_message*/ typedef struct struct_message { char a[32]; int b; flotteur c; Chaîne d; bool e; } struct_message; // Crée un struct_message appelé myData struct_message myData; // fonction appelée lorsque les données sont envoyées pour imprimer son statut void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) { Serial.print("\r\nLast Packet Send Status:\t"); Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success": "Delivery Fail"); if(status!=ESP_NOW_SEND_SUCCESS){send_data();} } void OnDataRecv(const uint8_t * mac, const uint8_t *incomingData, int len) { memcpy(&myData, entrantData, sizeof(myData)); Serial.print("Octets reçus: "); Serial.println(len); Serial.print("Car: "); 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() { //Définir le débit en bauds pour la communication série avec ESP Serial.begin(115200); // Définir l'appareil comme station Wi-Fi WiFi.mode(WIFI_STA); // Démarre le wifi // Init ESP-NOW et renvoie son statut if (esp_now_init() != ESP_OK) { Serial.println("Erreur d'initialisation ESP -MAINTENANT"); revenir; } //appel de la fonction OnDataSent après l'envoi des données ESPNOW esp_now_register_send_cb(OnDataSent); // Enregistrer le pair esp_now_peer_info_t peerInfo; //initialiser et affecter les informations de pair en tant que pointeur vers une adresse memcpy(peerInfo.peer_addr, broadcastAddress, 6); //copier la valeur de broadcastAddress avec 6 octets dans peerInfo.peer_addr peerInfo.channel = 0; //canal sur lequel l'esp parle. 0 signifie indéfini et les données seront envoyées sur le canal actuel.1-14 sont des canaux valides, ce qui est le même avec le périphérique local peerInfo.encrypt = false; //non chiffré //Ajoute le périphérique à la liste des périphériques couplés if (esp_now_add_peer(&peerInfo) != ESP_OK){ Serial.println("Impossible d'ajouter le pair"); revenir; } esp_now_register_recv_cb(OnDataRecv); //Appelez la fonction OnDataRecv après avoir reçu les données ESPNOW send_data(); } void loop() {} void send_data(){ Serial.println("Envoi"); // Définir les valeurs à envoyer strcpy(myData.a, "CECI EST UN CHAR"); //enregistrer "CECI EST UN CHAR" dans la variable a de mes "données" définies précédemment myData.b = random(1, 20); //enregistrer une valeur aléatoire myData.c = 1.2; //enregistrer un flottant myData.d = "ESP32"; //enregistrer une chaîne myData.e = false; //sauve un bool //Envoie des données inférieures ou égales à 250 octets via ESP-NOW et renvoie son statut esp_err_t result = esp_now_send(broadcastAddress, (uint8_t *) &myData, sizeof(myData)); if (result == ESP_OK) { Serial.println("Envoyé avec succès");} else { Serial.println("Erreur lors de l'envoi des données"); } }

ESP8266 CODE

//Ajouter les bibliothèques nécessaires

#include //Pour ajouter des capacités Wifi sur ESP32 #include //Pour accéder aux fonctions esp now //enregistrez l'adresse MAC dans un tableau nommé broadcastAddress; uint8_t broadcastAddress = {0x30, 0xAE, 0xA4, 0xF5, 0x03, 0xA4}; /*définir les types de données des multiples variables structurées et renommées toutes en struct_message*/ typedef struct struct_message { char a[32]; int b; flotteur c; Chaîne d; bool e; } struct_message; // Crée une variable struct_message appelée myData struct_message myData; // fonction appelée lorsque les données sont reçues et les imprime void OnDataRecv(uint8_t * mac, uint8_t *incomingData, uint8_t len) { memcpy(&myData, entrantData, sizeof(myData)); Serial.print("Octets reçus: "); Serial.println(len); Serial.print("Car: "); 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(); envoyer des données(); } void OnDataSent(uint8_t *mac_addr, uint8_t sendStatus) { Serial.print("\r\nLast Packet Send Status:\t"); Serial.println(sendStatus == 1 ? "Delivery Success": "Delivery Fail"); if(sendStatus !=1){ send_data(); } } void send_data(){ // Définir les valeurs à envoyer strcpy(myData.a, "CECI EST UN CHAR"); //enregistrer "CECI EST UN CHAR" dans la variable a de mes "données" définies précédemment myData.b = random(1, 20); //enregistrer une valeur aléatoire myData.c = 1.2; //enregistrer un flottant myData.d = "ESP8266"; //enregistrer une chaîne myData.e = false; //enregistrer un bool esp_now_send(broadcastAddress, (uint8_t *) &myData, sizeof(myData)); } void setup() { //Définir le débit en bauds pour la communication série avec ESP Serial.begin(115200); // Définir l'appareil comme station Wi-Fi WiFi.mode(WIFI_STA); //Démarre le wifi // Init ESP-NOW et renvoie son statut if (esp_now_init() != 0) { Serial.println("Error initializing ESP-NOW"); revenir; } if (esp_now_add_peer(broadcastAddress, ESP_NOW_ROLE_SLAVE, 1, NULL, 0)){ Serial.println("Impossible d'ajouter le pair"); revenir; } esp_now_set_self_role(ESP_NOW_ROLE_COMBO); esp_now_register_send_cb(OnDataSent); esp_now_set_self_role(ESP_NOW_ROLE_COMBO); //Définit le rôle de cet esp esp_now_register_recv_cb(OnDataRecv); //Appelez la fonction OnDataRecv après avoir reçu les données ESPNOW } void loop() {}

Étape 8: RÉFÉRENCES

ESPNOW_32_Exemple

ESPNOW_8266 Exemple

WIFI.h

ESP8266WiFi.h

esp_now.h pour ESP8266

esp_now.h pour ESP32

esp_now document officiel (meilleure explication des fonctions)

Guide officiel ESP-NOW