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.
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).
- 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 !
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(){
}
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.
Vous pouvez noter l’adresse MAC des cartes sur une étiquette pour identifier clairement chaque carte.
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);
}
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);
}
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() {
}
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() {
}
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.
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.
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.
Ensuite, vous devriez voir les messages reçus.
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.