ESP-NOW avec ESP8266 : 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’une carte ESP8266 NodeMCU à plusieurs cartes ESP8266 (configuration un à plusieurs). Les cartes seront programmées à l’aide de l’IDE Arduino.

Nous avons d’autres tutoriels sur ESP-NOW avec l’ESP8266 :

Aperçu du projet

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

• Un ESP8266 agit comme un expéditeur ;
• Plusieurs cartes ESP8266 agissent comme des récepteurs. Nous avons testé cette configuration avec deux cartes ESP8266 simultanément. Vous devriez pouvoir ajouter plus de cartes à votre configuration ;
• L’expéditeur ESP8266 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 ;
• 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 lectures de capteur.

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 ESP8266.

Conditions préalables

Nous allons programmer l’ESP8266 à l’aide de l’IDE Arduino. Par conséquent, avant de poursuivre ce didacticiel, vous devez avoir installé le module complémentaire ESP8266 dans votre IDE Arduino. Suivez le guide suivant :

Pièces requises

Pour suivre ce tutoriel, vous avez besoin de plusieurs 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 (apprenez comment obtenir et modifier l’adresse MAC ESP8266).

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.

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

Code d’expéditeur ESP8266 NodeMCU (ESP-NOW)

Le code suivant envoie des données à plusieurs (deux) 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-esp8266-nodemcu/
  
  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>

// REPLACE WITH RECEIVER MAC Address
uint8_t broadcastAddress1[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
uint8_t broadcastAddress2[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};

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

// Create a struct_message called test to store variables to be sent
test_struct test;

unsigned long lastTime = 0;  
unsigned long timerDelay = 2000;  // send readings timer

// Callback when data is sent
void OnDataSent(uint8_t *mac_addr, uint8_t sendStatus) {
  char macStr[18];
  Serial.print("Packet to:");
  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: ");
  if (sendStatus == 0){
    Serial.println("Delivery success");
  }
  else{
    Serial.println("Delivery fail");
  }
}
 
void setup() {
  // Init Serial Monitor
  Serial.begin(115200);
 
  // Set device as a Wi-Fi Station
  WiFi.mode(WIFI_STA);
  WiFi.disconnect();

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

  esp_now_set_self_role(ESP_NOW_ROLE_CONTROLLER);
  
  // Once ESPNow is successfully Init, we will register for Send CB to
  // get the status of Trasnmitted packet
  esp_now_register_send_cb(OnDataSent);
  
  // Register peer
  esp_now_add_peer(broadcastAddress1, ESP_NOW_ROLE_SLAVE, 1, NULL, 0);
  esp_now_add_peer(broadcastAddress2, ESP_NOW_ROLE_SLAVE, 1, NULL, 0);

}
 
void loop() {
  if ((millis() - lastTime) > timerDelay) {
    // Set values to send
    test.x = random(1, 50);
    test.y = random(1, 50);

    // Send message via ESP-NOW
    esp_now_send(0, (uint8_t *) &test, sizeof(test));

    lastTime = millis();
  }
}

Afficher le code brut

Comment fonctionne le code

Tout d’abord, incluez le espnow.h et ESP8266WiFi.h bibliothèques.

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

Adresse MAC des destinataires

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

uint8_t broadcastAddress1[] = {0x5C, 0xCF, 0x7F, 0x99, 0xA1, 0x70};
uint8_t broadcastAddress2[] = {0x5C, 0xCF, 0x7F, 0x99, 0x9A, 0xEA};

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(uint8_t *mac_addr, uint8_t sendStatus) {
  char macStr[18];
  Serial.print("Packet to:");
  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: ");
  if (sendStatus == 0){
    Serial.println("Delivery success");
  }
  else{
    Serial.println("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 et déconnectez le Wi-Fi :

WiFi.mode(WIFI_STA);
WiFi.disconnect();

Initialiser ESP-NOW :

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

Définissez le rôle ESP8266. Il s’agit d’une carte émettrice, définissez donc son rôle sur ESP_NOW_ROLE_CONTROLLER

esp_now_set_self_role(ESP_NOW_ROLE_CONTROLLER);

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 :

esp_now_add_peer(broadcastAddress1, ESP_NOW_ROLE_SLAVE, 1, NULL, 0);
esp_now_add_peer(broadcastAddress2, ESP_NOW_ROLE_SLAVE, 1, NULL, 0);

Si vous souhaitez ajouter plus de pairs, il vous suffit de dupliquer ces lignes précédentes et de transmettre l’adresse MAC du pair :

boucler()

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

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_now_send(0, (uint8_t *) &test, sizeof(test));

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 :

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

if ((millis() - lastTime) > timerDelay) {
  // Set values to send
  test.x = random(1, 50);
  test.y = random(1, 50);

  // Send message via ESP-NOW
  esp_now_send(0, (uint8_t *) &test, sizeof(test));

  lastTime = millis();
}

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;

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);

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_now_send(broadcastAddress1, (uint8_t *) &test, sizeof(test));

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

esp_now_send(broadcastAddress2, (uint8_t *) &test2, sizeof(test2));

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-esp8266-nodemcu/
  
  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>

// REPLACE WITH RECEIVER MAC Address
uint8_t broadcastAddress1[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
uint8_t broadcastAddress2[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};

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

// Create a struct_message called test to store variables to be sent
test_struct test;
test_struct test2;

unsigned long lastTime = 0;  
unsigned long timerDelay = 2000;  // send readings timer

// Callback when data is sent
void OnDataSent(uint8_t *mac_addr, uint8_t sendStatus) {
  char macStr[18];
  Serial.print("Packet to:");
  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: ");
  if (sendStatus == 0){
    Serial.println("Delivery success");
  }
  else{
    Serial.println("Delivery fail");
  }
}
 
void setup() {
  // Init Serial Monitor
  Serial.begin(115200);
 
  // Set device as a Wi-Fi Station
  WiFi.mode(WIFI_STA);
  WiFi.disconnect();

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

  esp_now_set_self_role(ESP_NOW_ROLE_CONTROLLER);
  
  // Once ESPNow is successfully Init, we will register for Send CB to
  // get the status of Trasnmitted packet
  esp_now_register_send_cb(OnDataSent);
  
  // Register peer
  esp_now_add_peer(broadcastAddress1, ESP_NOW_ROLE_SLAVE, 1, NULL, 0);
  esp_now_add_peer(broadcastAddress2, ESP_NOW_ROLE_SLAVE, 1, NULL, 0);

}
 
void loop() {
  if ((millis() - lastTime) > timerDelay) {
    // Set values to send
    test.x = random(1, 50);
    test.y = random(1, 50);
    test2.x = random(1, 50);
    test2.y = random(1, 50);

    // Send message via ESP-NOW
    esp_now_send(broadcastAddress1, (uint8_t *) &test, sizeof(test));
    esp_now_send(broadcastAddress2, (uint8_t *) &test2, sizeof(test2));
    lastTime = millis();
  }
}

Afficher le code brut

Code récepteur ESP8266 NodeMCU (ESP-NOW)

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

/*
  Rui Santos
  Complete project details at https://Raspberryme.com/esp-now-one-to-many-esp8266-nodemcu/
  
  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);
  WiFi.disconnect();

  // 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

Comment fonctionne le code

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

#include <ESP8266WiFi.h>
#include <espnow.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’ESP8266 reçoit les données via ESP-NOW. La fonction s’appelle onDataRecv() et doit accepter plusieurs paramètres comme suit :

void OnDataRecv(uint8_t * mac, uint8_t *incomingData, uint8_t 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 ESP8266. Pour accéder aux variables X, par 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 et déconnectez le Wi-Fi.

WiFi.mode(WIFI_STA);
WiFi.disconnect();

Initialiser ESP-NOW :

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

Définissez le rôle ESP8266. Il s’agit d’une carte réceptrice, définissez donc son rôle sur ESP_NOW_ROLE_SLAVE.

esp_now_set_self_role(ESP_NOW_ROLE_SLAVE);

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);

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 ESP8266 à partir d’un seul ESP8266 à l’aide d’ESP-NOW (communication un à plusieurs). Vous pouvez faire quelque chose de similaire avec les cartes ESP32 (ESP32 ESP-NOW : One-to-many).

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’ESP8266 avec nos ressources :

Merci d’avoir lu.