ESP-NOW avec ESP32 : envoyer des données à plusieurs cartes (un à plusieurs)

ESP-NOW avec ESP32 : envoyer des données à plusieurs cartes (un à plusieurs)

Dans ce didacticiel, vous apprendrez à utiliser le protocole de communication ESP-NOW pour envoyer des données d’un ESP32 à plusieurs cartes ESP32 ou ESP8266 (configuration un à plusieurs). Les cartes seront programmées à l’aide de l’IDE Arduino.

ESP-NOW avec ESP32 : envoyer des données à plusieurs cartes un à plusieurs ESP8266 NodeMCU

Pour commencer avec ESP-NOW sur l’ESP32 ou l’ESP8266, lisez d’abord les guides ESP-NOW suivants :

Aperçu du projet

Ce tutoriel montre comment envoyer des données d’un ESP32 à plusieurs cartes ESP32 ou ESP8266 à l’aide d’ESP-NOW (configuration un-à-plusieurs).

ESP-NOW avec ESP32 : Envoyer des données à plusieurs cartes (un à plusieurs) Présentation du projet
  • Un ESP32 agit comme un expéditeur ;
  • Plusieurs cartes ESP32 ou ESP8266 agissent comme des récepteurs. Nous avons testé cette configuration avec deux cartes ESP32 et une carte ESP8266 simultanément. Vous devriez pouvoir ajouter plus de cartes à votre configuration ;
  • L’expéditeur ESP32 reçoit un message d’accusé de réception si les messages sont livrés avec succès. Vous savez quels conseils ont reçu le message et quels conseils ne l’ont pas reçu ;
  • Vous devez télécharger un code de récepteur légèrement différent selon que vous utilisez un ESP32 ou ESP8266 ;
  • A titre d’exemple, nous allons échanger des valeurs aléatoires entre les cartes. Vous devez modifier cet exemple pour envoyer des commandes ou des relevés de capteur (échangez les relevés de capteur à l’aide d’ESP-NOW).

Ce tutoriel couvre ces deux scénarios :

  • envoyer le même message à tous les conseils ;
  • envoyer un message différent à chaque conseil.

Vous aimerez peut-être aussi lire : Communication bidirectionnelle ESP-NOW entre les cartes ESP32.

Conditions préalables

Nous allons programmer les cartes ESP32/ESP8266 à l’aide de l’IDE Arduino, donc avant de poursuivre ce tutoriel, assurez-vous que ces cartes sont installées dans votre IDE Arduino.

Pièces requises

Pour suivre ce tutoriel, vous avez besoin de plusieurs cartes ESP32 et/ou cartes ESP8266.

Vous pouvez utiliser les liens précédents ou accéder directement à MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

1644174010 874 ESP NOW avec ESP32 envoyer des donnees a plusieurs cartes un

Obtenir l’adresse MAC des cartes

Pour envoyer des messages via ESP-NOW, vous devez connaître l’adresse MAC des cartes réceptrices. Chaque carte a une adresse MAC unique (découvrez comment obtenir et modifier l’adresse MAC ESP32).

Téléchargez le code suivant sur chacune de vos cartes réceptrices pour obtenir son adresse MAC.

// Complete Instructions to Get and Change ESP MAC Address: https://Raspberryme.com/get-change-esp32-esp8266-mac-address-arduino/

#ifdef ESP32
  #include <WiFi.h>
#else
  #include <ESP8266WiFi.h>
#endif

void setup(){
  Serial.begin(115200);
  Serial.println();
  Serial.print("ESP Board MAC Address:  ");
  Serial.println(WiFi.macAddress());
}
 
void loop(){

}

Afficher le code brut

Après avoir téléchargé le code, appuyez sur le bouton RST/EN et l’adresse MAC devrait s’afficher sur le moniteur série.

Adresse MAC de la carte ESP32 avec moniteur série Arduino IDE

Vous pouvez noter l’adresse MAC des cartes sur une étiquette pour identifier clairement chaque carte.

Identifier l'adresse MAC de la carte ESP32

Code d’expéditeur ESP32 (ESP-NOW)

Le code suivant envoie des données à plusieurs (trois) cartes ESP via ESP-NOW. Vous devez modifier le code avec l’adresse MAC de vos cartes réceptrices. Vous devez également ajouter ou supprimer des lignes de code en fonction du nombre de cartes réceptrices.

/*********
  Rui Santos
  Complete project details at https://Raspberryme.com/esp-now-one-to-many-esp32-esp8266/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*********/

#include <esp_now.h>
#include <WiFi.h>

// REPLACE WITH YOUR ESP RECEIVER'S MAC ADDRESS
uint8_t broadcastAddress1[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
uint8_t broadcastAddress2[] = {0xFF, , , , , };
uint8_t broadcastAddress3[] = {0xFF, , , , , };

typedef struct test_struct {
  int x;
  int y;
} test_struct;

test_struct test;

// callback when data is sent
void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
  char macStr[18];
  Serial.print("Packet to: ");
  // Copies the sender mac address to a string
  snprintf(macStr, sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x",
           mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);
  Serial.print(macStr);
  Serial.print(" send status:\t");
  Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");
}
 
void setup() {
  Serial.begin(115200);
 
  WiFi.mode(WIFI_STA);
 
  if (esp_now_init() != ESP_OK) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }
  
  esp_now_register_send_cb(OnDataSent);
   
  // register peer
  esp_now_peer_info_t peerInfo;
  peerInfo.channel = 0;  
  peerInfo.encrypt = false;
  // register first peer  
  memcpy(peerInfo.peer_addr, broadcastAddress1, 6);
  if (esp_now_add_peer(&peerInfo) != ESP_OK){
    Serial.println("Failed to add peer");
    return;
  }
  // register second peer  
  memcpy(peerInfo.peer_addr, broadcastAddress2, 6);
  if (esp_now_add_peer(&peerInfo) != ESP_OK){
    Serial.println("Failed to add peer");
    return;
  }
  /// register third peer
  memcpy(peerInfo.peer_addr, broadcastAddress3, 6);
  if (esp_now_add_peer(&peerInfo) != ESP_OK){
    Serial.println("Failed to add peer");
    return;
  }
}
 
void loop() {
  test.x = random(0,20);
  test.y = random(0,20);
 
  esp_err_t result = esp_now_send(0, (uint8_t *) &test, sizeof(test_struct));
   
  if (result == ESP_OK) {
    Serial.println("Sent with success");
  }
  else {
    Serial.println("Error sending the data");
  }
  delay(2000);
}

Afficher le code brut

Comment fonctionne le code

Tout d’abord, incluez le esp_now.h et WiFi.h bibliothèques.

#include <esp_now.h>
#include <WiFi.h>

Adresse MAC des destinataires

Insérez l’adresse MAC des récepteurs. Dans notre exemple, nous envoyons des données à trois cartes.

uint8_t broadcastAddress1[] = {0x3C, 0x71, 0xBF, 0xC3, 0xBF, 0xB0};
uint8_t broadcastAddress2[] = {0x24, 0x0A, 0xC4, 0xAE, 0xAE, 0x44};
uint8_t broadcastAddress3[] = {0x80, 0x7D, 0x3A, 0x58, 0xB4, 0xB0};

Ensuite, créez une structure qui contient les données que nous voulons envoyer. Nous avons appelé cette structure test_struct et il contient deux variables entières. Vous pouvez modifier cela pour envoyer les types de variables que vous souhaitez.

typedef struct test_struct {
  int x;
  int y;
} test_struct;

Créer une nouvelle variable de type test_struct que l’on appelle test qui stockera les valeurs des variables.

test_struct test;

Fonction de rappel OnDataSent()

Ensuite, définissez le OnDataSent() une fonction. Il s’agit d’une fonction de rappel qui sera exécutée lors de l’envoi d’un message. Dans ce cas, cette fonction imprime si le message a été délivré avec succès ou non et pour quelle adresse MAC. Ainsi, vous savez quels conseils ont reçu le message ou et quels conseils ne l’ont pas reçu.

void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
  char macStr[18];
  Serial.print("Packet from: ");
  // Copies the sender mac address to a string
  snprintf(macStr, sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x",
           mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);
  Serial.print(macStr);
  Serial.print(" send status:\t");
  Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");
}

mettre en place()

Dans le mettre en place()initialisez le moniteur série à des fins de débogage :

Serial.begin(115200);

Configurez l’appareil en tant que station Wi-Fi :

WiFi.mode(WIFI_STA);

Initialiser ESP-NOW :

if (esp_now_init() != ESP_OK) {
  Serial.println("Error initializing ESP-NOW");
  return;
}

Après avoir initialisé ESP-NOW avec succès, enregistrez la fonction de rappel qui sera appelée lors de l’envoi d’un message. Dans ce cas, inscrivez-vous au OnDataSent() fonction créée précédemment.

esp_now_register_send_cb(OnDataSent);

Ajouter des pairs

Après cela, nous devons coupler avec d’autres appareils ESP-NOW pour envoyer des données. C’est ce que nous faisons dans les lignes suivantes – enregistrez les pairs :

  // register peer
  esp_now_peer_info_t peerInfo;
  peerInfo.channel = 0;
  peerInfo.encrypt = false;
  // register first peer
  memcpy(peerInfo.peer_addr, broadcastAddress1, 6);
  if (esp_now_add_peer(&peerInfo) != ESP_OK){
    Serial.println("Failed to add peer");
    return;
  }
  // register second peer
  memcpy(peerInfo.peer_addr, broadcastAddress2, 6);
  if (esp_now_add_peer(&peerInfo) != ESP_OK){
    Serial.println("Failed to add peer");
    return;
  }
  /// register third peer
  memcpy(peerInfo.peer_addr, broadcastAddress3, 6);
  if (esp_now_add_peer(&peerInfo) != ESP_OK){
    Serial.println("Failed to add peer");
    return;
  }

Si vous souhaitez ajouter d’autres pairs, il vous suffit de dupliquer ces lignes et de transmettre l’adresse MAC du pair :

memcpy(peerInfo.peer_addr, broadcastAddress, 6);
if (esp_now_add_peer(&peerInfo) != ESP_OK){
  Serial.println("Failed to add peer");
  return;
}

boucler()

Dans le boucler()nous enverrons un message via ESP-NOW toutes les 2 secondes (vous pouvez modifier ce délai).

Attribuez une valeur à chaque variable :

test.x = random(0,20);
test.y = random(0,20);

Rappelez-vous que test est une structure. Attribuez ici les valeurs que vous souhaitez envoyer à l’intérieur de la structure. Dans ce cas, nous envoyons simplement des valeurs aléatoires. Dans une application pratique, ceux-ci doivent être remplacés par des commandes ou des lectures de capteur, par exemple.

Envoyez les mêmes données à plusieurs cartes

Enfin, envoyez le message comme suit :

esp_err_t result = esp_now_send(0, (uint8_t *) &test, sizeof(test_struct));

Le premier argument du esp_now_send() fonction est l’adresse MAC du récepteur. Si vous passez 0 comme argument, il enverra le même message à tous les pairs inscrits. Si vous souhaitez envoyer un message différent à chaque pair, suivez la section suivante.

Vérifiez si le message a été envoyé avec succès :

if (result == ESP_OK) {
  Serial.println("Sent with success");
}
else {
  Serial.println("Error sending the data");
}

le boucler() est exécuté toutes les 2000 millisecondes (2 secondes).

delay(2000);

Envoyer des données différentes à chaque tableau

Le code pour envoyer un message différent à chaque carte est très similaire au précédent. Donc, nous allons juste jeter un œil aux différences.

Si vous souhaitez envoyer un message différent à chaque tableau, vous devez créer une structure de données pour chacun de vos tableaux, par exemple :

test_struct test;
test_struct test2;
test_struct test3;

Dans ce cas, nous envoyons le même type de structure (test_struct). Vous pouvez envoyer un type de structure différent tant que le code récepteur est prêt à recevoir ce type de structure.

Ensuite, attribuez des valeurs différentes aux variables de chaque structure. Dans cet exemple, nous les définissons simplement sur des nombres aléatoires.

test.x = random(0,20);
test.y = random(0,20);
test2.x = random(0,20);
test2.y = random(0,20);
test3.x = random(0,20);
test3.y = random(0,20);

Enfin, vous devez appeler le esp_now_send() fonction pour chaque récepteur.

Par exemple, envoyez le test structure à la carte dont l’adresse MAC est broadcastAddress1.

esp_err_t result1 = esp_now_send(
  broadcastAddress1, 
  (uint8_t *) &test,
  sizeof(test_struct));
   
if (result1 == ESP_OK) {
  Serial.println("Sent with success");
}
else {
  Serial.println("Error sending the data");
}

Faites de même pour les autres planches. Pour la deuxième planche envoyer le test2 structure:

esp_err_t result2 = esp_now_send(
  broadcastAddress2, 
  (uint8_t *) &test2,
  sizeof(test_struct));

if (result2 == ESP_OK) {
  Serial.println("Sent with success");
}
else {
  Serial.println("Error sending the data");
}

Et enfin, pour la troisième planche, envoyez le test3 structure:

esp_err_t result3 = esp_now_send(
  broadcastAddress3, 
  (uint8_t *) &test3,
  sizeof(test_struct));

if (result3 == ESP_OK) {
  Serial.println("Sent with success");
}
else {
  Serial.println("Error sending the data");
}

Voici le code complet qui envoie un message différent à chaque carte.

/*********
  Rui Santos
  Complete project details at https://Raspberryme.com/esp-now-one-to-many-esp32-esp8266/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*********/

#include <esp_now.h>
#include <WiFi.h>

// REPLACE WITH YOUR ESP RECEIVER'S MAC ADDRESS
uint8_t broadcastAddress1[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
uint8_t broadcastAddress2[] = {0xFF, , , , , };
uint8_t broadcastAddress3[] = {0xFF, , , , , };

typedef struct test_struct {
  int x;
  int y;
} test_struct;

void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
  char macStr[18];
  Serial.print("Packet to: ");
  // Copies the sender mac address to a string
  snprintf(macStr, sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x",
           mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);
  Serial.print(macStr);
  Serial.print(" send status:\t");
  Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");
}
 
void setup() {
 
  Serial.begin(115200);
 
  WiFi.mode(WIFI_STA);
 
  if (esp_now_init() != ESP_OK) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }

  esp_now_register_send_cb(OnDataSent);

  // register peer
  esp_now_peer_info_t peerInfo;
  peerInfo.channel = 0;  
  peerInfo.encrypt = false;
    
  memcpy(peerInfo.peer_addr, broadcastAddress1, 6);
  if (esp_now_add_peer(&peerInfo) != ESP_OK){
    Serial.println("Failed to add peer");
    return;
  }
  
  memcpy(peerInfo.peer_addr, broadcastAddress2, 6);
  if (esp_now_add_peer(&peerInfo) != ESP_OK){
    Serial.println("Failed to add peer");
    return;
  }
  memcpy(peerInfo.peer_addr, broadcastAddress3, 6);
  if (esp_now_add_peer(&peerInfo) != ESP_OK){
    Serial.println("Failed to add peer");
    return;
  }
}
 
void loop() {
  test_struct test;
  test_struct test2;
  test_struct test3;
  test.x = random(0,20);
  test.y = random(0,20);
  test2.x = random(0,20);
  test2.y = random(0,20);
  test3.x = random(0,20);
  test3.y = random(0,20);
 
  esp_err_t result1 = esp_now_send(
    broadcastAddress1, 
    (uint8_t *) &test,
    sizeof(test_struct));
   
  if (result1 == ESP_OK) {
    Serial.println("Sent with success");
  }
  else {
    Serial.println("Error sending the data");
  }
  delay(500);
  esp_err_t result2 = esp_now_send(
    broadcastAddress2, 
    (uint8_t *) &test2,
    sizeof(test_struct));

  if (result2 == ESP_OK) {
    Serial.println("Sent with success");
  }
  else {
    Serial.println("Error sending the data");
  }
  
  delay(500);  
  esp_err_t result3 = esp_now_send(
    broadcastAddress3, 
    (uint8_t *) &test3,
    sizeof(test_struct));
   
  if (result3 == ESP_OK) {
    Serial.println("Sent with success");
  }
  else {
    Serial.println("Error sending the data");
  }
  delay(2000);
}

Afficher le code brut

Code récepteur ESP32 (ESP-NOW)

Téléchargez le code suivant sur les cartes réceptrices (dans notre exemple, nous avons utilisé trois cartes réceptrices).

/*********
  Rui Santos
  Complete project details at https://Raspberryme.com/esp-now-one-to-many-esp32-esp8266/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*********/

#include <esp_now.h>
#include <WiFi.h>

//Structure example to receive data
//Must match the sender structure
typedef struct test_struct {
  int x;
  int y;
} test_struct;

//Create a struct_message called myData
test_struct myData;

//callback function that will be executed when data is received
void OnDataRecv(const uint8_t * mac, const uint8_t *incomingData, int len) {
  memcpy(&myData, incomingData, sizeof(myData));
  Serial.print("Bytes received: ");
  Serial.println(len);
  Serial.print("x: ");
  Serial.println(myData.x);
  Serial.print("y: ");
  Serial.println(myData.y);
  Serial.println();
}
 
void setup() {
  //Initialize Serial Monitor
  Serial.begin(115200);
  
  //Set device as a Wi-Fi Station
  WiFi.mode(WIFI_STA);

  //Init ESP-NOW
  if (esp_now_init() != ESP_OK) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }
  
  // Once ESPNow is successfully Init, we will register for recv CB to
  // get recv packer info
  esp_now_register_recv_cb(OnDataRecv);
}
 
void loop() {

}

Afficher le code brut

Comment fonctionne le code

Comme pour l’expéditeur, commencez par inclure les bibliothèques :

#include <esp_now.h>
#include <WiFi.h>

Créez une structure pour recevoir les données. Cette structure doit être la même que celle définie dans l’esquisse de l’expéditeur.

typedef struct test_struct {
  int x;
  int y;
} test_struct;

Créer un test_struct variable appelée mes données.

test_struct myData;

Créez une fonction de rappel qui est appelée lorsque l’ESP32 reçoit les données via ESP-NOW. La fonction s’appelle onDataRecv() et doit accepter plusieurs paramètres comme suit :

void OnDataRecv(const uint8_t * mac, const uint8_t *incomingData, int len) {

Copiez le contenu du entrantDonnées variable de données dans la mes données variable.

memcpy(&myData, incomingData, sizeof(myData));

Maintenant le mes données La structure contient plusieurs variables à l’intérieur avec les valeurs envoyées par l’expéditeur ESP32. Pour accéder aux variables Xpar exemple, appelez mesDonnées.x.

Dans cet exemple, nous imprimons les données reçues, mais dans une application pratique, vous pouvez imprimer les données sur un écran OLED, par exemple.

Serial.print("Bytes received: ");
Serial.println(len);
Serial.print("x: ");
Serial.println(myData.x);
Serial.print("y: ");
Serial.println(myData.y);
Serial.println();

Dans le mettre en place()initialisez le moniteur série.

Serial.begin(115200);

Configurez l’appareil en tant que station Wi-Fi.

WiFi.mode(WIFI_STA);

Initialiser ESP-NOW :

if (esp_now_init() != ESP_OK) {
  Serial.println("Error initializing ESP-NOW");
  return;
}

Enregistrez-vous pour une fonction de rappel qui sera appelée lorsque les données seront reçues. Dans ce cas, nous nous inscrivons au OnDataRecv() fonction créée précédemment.

esp_now_register_recv_cb(OnDataRecv);

Code récepteur ESP8266 (ESP-MAINTENANT)

Si vous utilisez une carte ESP8266 comme récepteur, téléchargez plutôt le code suivant.

/*********
  Rui Santos
  Complete project details at https://Raspberryme.com/esp-now-one-to-many-esp32-esp8266/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*********/

#include <ESP8266WiFi.h>
#include <espnow.h>

//Structure example to receive data
//Must match the sender structure
typedef struct test_struct {
  int x;
  int y;
} test_struct;

//Create a struct_message called myData
test_struct myData;

//callback function that will be executed when data is received
void OnDataRecv(uint8_t * mac, uint8_t *incomingData, uint8_t len) {
  memcpy(&myData, incomingData, sizeof(myData));
  Serial.print("Bytes received: ");
  Serial.println(len);
  Serial.print("x: ");
  Serial.println(myData.x);
  Serial.print("y: ");
  Serial.println(myData.y);
  Serial.println();
}
 
void setup() {
  //Initialize Serial Monitor
  Serial.begin(115200);
  
  //Set device as a Wi-Fi Station
  WiFi.mode(WIFI_STA);

  //Init ESP-NOW
  if (esp_now_init() != 0) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }
  
  // Once ESPNow is successfully Init, we will register for recv CB to
  // get recv packer info
  esp_now_set_self_role(ESP_NOW_ROLE_SLAVE);
  esp_now_register_recv_cb(OnDataRecv);
}
 
void loop() {

}

Afficher le code brut

Mis à part de petits détails, ce code est très similaire au code du récepteur ESP32. Donc, nous n’expliquerons pas comment cela fonctionne. Pour en savoir plus, vous pouvez lire notre guide de démarrage ESP-NOW avec ESP8266 NodeMCU.

Manifestation

Après avoir allumé toutes vos cartes, ouvrez le moniteur série Arduino IDE pour le port COM auquel l’expéditeur est connecté.

Vous devriez commencer à recevoir « Succès de la livraison” messages avec l’adresse MAC du récepteur correspondant dans le moniteur série.

ESP32 ESP-NOW envoyer des données à plusieurs cartes moniteur série d'état de livraison

Si vous coupez l’alimentation de l’une des cartes, vous recevrez un « Échec de la livraison” message pour ce tableau spécifique. Ainsi, vous pouvez identifier rapidement quel tableau n’a pas reçu le message.

ESP32 ESP-NOW Envoyer des données à plusieurs cartes État de livraison Échec du moniteur série

Si vous voulez vérifier si les cartes reçoivent réellement les messages, vous pouvez ouvrir le moniteur série pour le port COM auquel elles sont connectées, ou vous pouvez utiliser Mastic pour établir une communication série avec vos cartes.

Si vous utilisez PuTTY, sélectionnez Communication série, écrivez le numéro de port COM et le débit en bauds (115200) comme indiqué ci-dessous et cliquez sur Ouvert.

Cartes ESP de communication série PuTTY

Ensuite, vous devriez voir les messages reçus.

ESP32 ESP8266 NodeMCU ESP-NOW Envoyer des données à plusieurs cartes Démonstration réussie de livraison

Ouvrez une communication série pour chacune de vos cartes et vérifiez qu’elles reçoivent bien les messages.

Conclusion

Dans ce didacticiel, vous avez appris à envoyer des données à plusieurs cartes ESP32 ou ESP8266 à partir d’un seul ESP32 à l’aide d’ESP-NOW (communication un à plusieurs).

Nous espérons que vous avez trouvé ce tutoriel utile. Nous avons d’autres tutoriels ESP-NOW que vous pourriez aimer :

En savoir plus sur l’ESP32 avec nos ressources :

Merci d’avoir lu.