howto:arduino-esp:esp-now

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentes Révision précédente
Prochaine révision
Révision précédente
howto:arduino-esp:esp-now [2021/10/08 17:48]
guillaume
howto:arduino-esp:esp-now [2021/10/22 13:47]
guillaume [Tester et aller plus loin]
Ligne 2: Ligne 2:
  
 ESP-NOW est un protocole d'échange de données entre **ESP-32** (ou ESP8266) que l'on peut programmer avec l'IDE Arduino. C'est un protocole développé par Espressif, le fabricant des puces ESP, et qui permet d'échanger de courts paquets de données directement et simplement. Il est possible de réaliser des échanges entre plusieurs ESP dans les deux sens (émission et réception) sans intermédiaire central (sans routeur).   ESP-NOW est un protocole d'échange de données entre **ESP-32** (ou ESP8266) que l'on peut programmer avec l'IDE Arduino. C'est un protocole développé par Espressif, le fabricant des puces ESP, et qui permet d'échanger de courts paquets de données directement et simplement. Il est possible de réaliser des échanges entre plusieurs ESP dans les deux sens (émission et réception) sans intermédiaire central (sans routeur).  
- 
-Ce qui va suivre s'inspire très fort de l'excellent article de **Random Nerd Tutorials**: [[https://randomnerdtutorials.com/esp-now-esp32-arduino-ide/]]. 
  
 ===== Le protocole ESP-NOW ===== ===== Le protocole ESP-NOW =====
-Tel qu'il est décrit sur le site d'Espressif, le protocole ESP-NOW permet d'échanger des paquets sans Wifi, s'approchant en cela du système utilisé par les objets connectés en 2.4Ghz (souris ou claviers sans fil, en particulier). L'appairage entre modules est nécessaire (nous verrons plus loin qu'il faut utiliser l'adresse MAC des ESP), mais une fois que cet appairage est réalisé la connexion s'effectue très rapidement, sans "handshake". Dis plus simplement, lorsque l'appairage est effectué, on peut éteindre ou redémarrer un module, la reconnexion sera automatique et immédiate. +Tel qu'il est décrit sur le site d'Espressif, le protocole ESP-NOW permet d'échanger des paquets sans routeur Wifi, s'approchant en cela du système utilisé par les objets connectés en 2.4Ghz (souris ou claviers sans fil, en particulier). L'appairage entre modules est nécessaire (nous verrons plus loin qu'il faut utiliser l'adresse MAC des ESP), mais une fois que cet appairage est réalisé la connexion s'effectue très rapidement, sans "handshake". Dis plus simplement, lorsque l'appairage est effectué, on peut éteindre ou redémarrer un module, la reconnexion sera automatique et immédiate. 
  
-Il est possible de réaliser un schéma ou un module central envoie des informations à de nombreux autres modules (//one to many//), ou au contraire de nombreux modules envoient à un module central (//many to one//), mais aussi un réseau maillé ou chaque module peut envoyer à tous les autres.+Il est possible de réaliser un schéma où un module central envoie des informations à de nombreux autres modules (//one to many//), ou au contraire de nombreux modules envoient à un module central (//many to one//), mais aussi un réseau maillé ou chaque module peut envoyer à tous les autres. Chaque module, au sein d'un réseau, peut-être à le fois émetteur //ET// récepteur
  
 Il est possible de chiffrer les communications, et de mélanger des communications chiffrées ou non dans un même réseau. Le nombre de modules doit rester en dessous de 10 lorsque l'on utilise le chiffrement et 20 lorsque l'on échange en clair.  Il est possible de chiffrer les communications, et de mélanger des communications chiffrées ou non dans un même réseau. Le nombre de modules doit rester en dessous de 10 lorsque l'on utilise le chiffrement et 20 lorsque l'on échange en clair. 
  
-Il n'est possible d'échanger que 250 octets au maximum à chaque envoi. Une fonction de rappel peut être envoyée pour confirmer la bonne réception. +Il n'est possible d'échanger que 250 octets au maximum à chaque envoi. Une fonction de rappel peut être déclenchée pour confirmer la bonne réception ou l'envoi des données
  
 ===== Connaître l'adresse MAC ===== ===== Connaître l'adresse MAC =====
Ligne 19: Ligne 17:
 Il est possible de changer de manière logicielle l'adresse MAC de l'ESP, mais cela ne survit pas à un reboot, il faut donc l'inclure dans le code exécuté à chaque fois (tuto [[https://randomnerdtutorials.com/get-change-esp32-esp8266-mac-address-arduino/|ici]]). Il est possible de changer de manière logicielle l'adresse MAC de l'ESP, mais cela ne survit pas à un reboot, il faut donc l'inclure dans le code exécuté à chaque fois (tuto [[https://randomnerdtutorials.com/get-change-esp32-esp8266-mac-address-arduino/|ici]]).
  
-Uploader le code suivant dans chaque ESP, noter soigneusement le résultat qui va s'afficher dans la console.+Téléverser le code suivant dans chaque ESP, et noter soigneusement le résultat qui va s'afficher dans la console.
  
 <code> <code>
Ligne 34: Ligne 32:
 } }
 </code>    </code>   
 +
 +Cette étape manuelle permettra d'appairer facilement chaque module. Néanmoins, il est à noter qu'une méthode très astucieuse permet de se passer de cette manip préalable, et de connecter de manière automatique chaque module. Néanmoins, elle est un peu plus complexe. L'idée est la suivante: les "récepteurs" émettent un réseau wifi dont le SSID comporte une chaîne prédéfinie (par exemple, "RECEPTION". L'émetteur scanne les réseaux Wifi environnants, et lorsqu'il détecte un SSID commençant par "RECEPTION", il en récupère l'adresse MAC, avant de créer l'appairage. C'est de cette manière que fonctionnent les deux exemples //Master// et //Slave// que l'on trouvera dans les exemples ESP32>ESP-NOW de l'IDE Arduino.
  
 ===== Principe de communication ===== ===== Principe de communication =====
  
-Pour commencer, nous allons simplement envoyer des informations d'un ESP vers un autre. Par commodité, nous les appellerons "Émetteur" et "Récepteur"+Pour commencer, nous allons simplement envoyer des informations d'un ESP vers un autre. Par commodité, nous les appellerons donc "Émetteur" et "Récepteur"
  
 **Côté émetteur:** **Côté émetteur:**
    * Initialiser ESP-NOW.    * Initialiser ESP-NOW.
-   * Enregistrer une fonction de rappel, qui sera exécutée quant un message est envoyé. Cela nous permettra de vérifier la bonne livraison du message.+   * Enregistrer une fonction de rappel, qui sera exécutée quant un message est envoyé. Cela nous permettra de vérifier la bonne transmission du message.
    * On ajoute l'adresse MAC du récepteur, pour l'appairage.    * On ajoute l'adresse MAC du récepteur, pour l'appairage.
    * On envoie le message.    * On envoie le message.
Ligne 50: Ligne 50:
    * Dans cette fonction de rappel, on sauve le contenu du message dans une variable pour en faire quelque chose.    * Dans cette fonction de rappel, on sauve le contenu du message dans une variable pour en faire quelque chose.
  
-===== Résumé des fonctions les plus utiles =====+À Chaque étape listée ci-dessus va correspondre une fonction spécifique à l'utilisation du protocole:
  
-**esp_now_init()** Initialise ESP-NOW. Il faut initialiser le wifi avant d'initialiser ESP-NOW.\\   +**esp_now_init()** Initialiser ESP-NOW. Il faut initialiser le wifi avant d'initialiser ESP-NOW.\\   
 **esp_now_add_peer()** On appelle cette fonction pour appairer un ESP, on passe son adresse MAC en argument.\\    **esp_now_add_peer()** On appelle cette fonction pour appairer un ESP, on passe son adresse MAC en argument.\\   
 **esp_now_send()** Envoie des données avec ESP-NOW.\\    **esp_now_send()** Envoie des données avec ESP-NOW.\\   
Ligne 60: Ligne 60:
 ===== Code de l'émetteur =====    ===== Code de l'émetteur =====   
  
-Ci-dessous, le code tel que proposé par Rui Santos, de Random Nerd Tutorials:+Ci-dessous, le code commenté:
  
 <code> <code>
-/+// Référence technique: https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/network/esp_now.html
-  Rui Santos +
-  Complete project details at https://RandomNerdTutorials.com/esp-now-esp32-arduino-ide/ +
-   +
-  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. +
-*/+
  
 +// Inclure les librairies
 #include <esp_now.h> #include <esp_now.h>
 #include <WiFi.h> #include <WiFi.h>
  
-// REPLACE WITH YOUR RECEIVER MAC Address +// Stockage de l'adresse MAC du récepteur pour usage ultérieur. Remplacer les 'FF' par les valeur notées plus avant. 
-uint8_t broadcastAddress[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};+uint8_t MAC_recepteur[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
  
-// Structure example to send data +// La variable qui sera envoyée au récepteur (nous générerons une valeur aléatoire pour l'exemple) 
-// Must match the receiver structure +float maValeurEnvoyee;
-typedef struct struct_message { +
-  char a[32]; +
-  int b; +
-  float c; +
-  bool d; +
-} struct_message;+
  
-// Create a struct_message called myData +// La fonction de rappel qui nous assurera de la bonne livraison du message 
-struct_message myData; +void quand_donnees_Envoyees(const uint8_t *mac_addr, esp_now_send_status_t status) { 
- +  Serial.print("\r\nDernier paquet envoyé:\t"); 
-// callback when data is sent +  Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Succès" : "Échec");
-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");+
 } }
 +
 +// Une variable qui servira à stocker les réglages concernant le récepteur
 +esp_now_peer_info_t infosRecepteur;
 +
    
 void setup() { void setup() {
-  // Init Serial Monitor+  // On initie la comm série à 115200 Bauds
   Serial.begin(115200);   Serial.begin(115200);
    
-  // Set device as a Wi-Fi Station+  // On démarre le Wifi en mode Station
   WiFi.mode(WIFI_STA);   WiFi.mode(WIFI_STA);
  
-  // Init ESP-NOW+  // Puis on initialise ESP-NOW
   if (esp_now_init() != ESP_OK) {   if (esp_now_init() != ESP_OK) {
-    Serial.println("Error initializing ESP-NOW");+    Serial.println("Erreur d'initialisation ESP-NOW");
     return;     return;
   }   }
  
-  // Once ESPNow is successfully Initwe will register for Send CB to +  // Si ESP-NOW a correctement démarréil est temps d'enregistrer la fonction de rappel: 
-  // get the status of Trasnmitted packet +  esp_now_register_send_cb(quand_donnees_Envoyees);
-  esp_now_register_send_cb(OnDataSent);+
      
-  // Register peer +  // Tout est prêt pour l'appairage avec notre récepteur: 
-  esp_now_peer_info_t peerInfo; +  memcpy(infosRecepteur.peer_addr, MAC_recepteur, 6);
-  memcpy(peerInfo.peer_addr, broadcastAddress, 6)+
-  peerInfo.channel = 0;   +
-  peerInfo.encrypt = false;+
      
-  // Add peer         +  // On définit un canal (0 utilisera automatiquement le même canal que celui utilisé par le wifi) 
-  if (esp_now_add_peer(&peerInfo) != ESP_OK){ +  infosRecepteur.channel = 0;   
-    Serial.println("Failed to add peer");+ 
 +  // On ne chiffre pas les échanges 
 +  infosRecepteur.encrypt = false; 
 +   
 +  // Appairage         
 +  if (esp_now_add_peer(&infosRecepteur) != ESP_OK){ 
 +    Serial.println("Échec de l'appairage");
     return;     return;
   }   }
Ligne 129: Ligne 118:
    
 void loop() { void loop() {
-  // Set values to send 
-  strcpy(myData.a, "THIS IS A CHAR"); 
-  myData.b = random(1,20); 
-  myData.c = 1.2; 
-  myData.d = false; 
      
-  // Send message via ESP-NOW +  // On définit la valeur de la variable à envoyer à l'aide d'un générateur aléatoire 
-  esp_err_t result = esp_now_send(broadcastAddress, (uint8_t *) &myData, sizeof(myData));+  maValeurEnvoyee = random(1,20); 
 +   
 +  // On envoie le message 
 +  esp_err_t resultat = esp_now_send(MAC_recepteur, (uint8_t *) &maValeurEnvoyee, sizeof(maValeurEnvoyee));
        
-  if (result == ESP_OK) { +  if (resultat == ESP_OK) { 
-    Serial.println("Sent with success");+    Serial.println("Envoi OK");
   }   }
   else {   else {
-    Serial.println("Error sending the data");+    Serial.println("Erreur envoi");
   }   }
-  delay(2000);+ 
 +  // On effectue cette opération toutes les secondes 
 +  delay(1000);
 } }
 </code> </code>
  
-Quelques explications:+===== Code du récepteur ===== 
 + 
 +Voici le code du récepteur, commenté en détail:
  
-D'abord, inclure les librairies: 
 <code> <code>
 +// Inclure les librairies
 #include <esp_now.h> #include <esp_now.h>
 #include <WiFi.h> #include <WiFi.h>
-</code> 
  
-Ensuite, nous stockons dans une variable l'adresse MAC du récepteur: +// La variable qui sera envoyée au récepteur (nous générerons une valeur aléatoire pour l'exemple) 
-<code> +float maValeurRecue;
-uint8_t broadcastAddress[] = {0x30, 0xAE, 0xA4, 0x07, 0x0D, 0x64}; +
-</code> +
-Pensez évidemment à remplacer l'adresse MAC par celle spécifique de votre ESP.+
  
-Ensuite, il faut créer une structure qui contiendra les données envoyées. Elle s'appelera *struct_messageet contiendra 4 types de variables différents. Il faudra modifier cette partie pour l'adapter aux spécificités de votre pojet. +// La fonction de rappel qui nous assurera de la bonne livraison du message 
-<code> +void quand_donnees_Recues(const uint8_t mac, const uint8_t *data_reception, int taille) { 
-typedef struct struct_message { +  memcpy(&maValeurRecue, data_reception, sizeof(maValeurRecue)); 
-  char a[32]+  Serial.print("Bytes received: "); 
-  int b+  Serial.println(taille)
-  float c+  Serial.print("valeur reçue: ")
-  bool d+  Serial.println(maValeurRecue)
-struct_message+  Serial.println()
-</code>+} 
 +  
 +void setup() { 
 +  // On initie la comm série à 115200 Bauds 
 +  Serial.begin(115200)
 +  
 +  // On démarre le Wifi en mode Station 
 +  WiFi.mode(WIFI_STA);
  
-On créé ensuite une variable de type *struct_message* et que l'on appelera *myData*. Cette variable servira à stocker... des variables, celles à envoyer. +  // Puis on initialise ESP-NOW 
-<code> +  if (esp_now_init() != ESP_OK) { 
-struct_message myData+    Serial.println("Erreur d'initialisation ESP-NOW")
-</code>+    return; 
 +  }
  
-Enfinnous allond définir notre fonction de rappel, qui sera exécutée automatiquement lorsqu'un message aura été envoyé. Ici, on affiche seulement la réussite ou l'échec de la livraison. +  // Si ESP-NOW a correctement démarréil est temps d'enregistrer la fonction de rappel: 
-<code> +  esp_now_register_recv_cb(quand_donnees_Recues); 
-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 loop() { 
 +  
 } }
 </code> </code>
  
 +===== Tester et aller plus loin =====
 +
 +Lorsque vous regarderez les console série des deux ESP, vous constaterez que les messages sont bien expédiés, bien reçus et leur contenu correctement interprété côté récepteur. Les différentes sources trouvées sur le net parlent d'une portée en extérieur supérieur à 200 mètres, avec les deux antennes pointant l'une vers l'autre. À tester, les essais réalisés autour de notre [[howto:arduino-esp:esp-now_compteurs|projet de compteur]] ont plutôt été concluants jusqu'à 100 mètres environ. 
 +
 +Nous vous renvoyons aux exemples disponibles dans la bibliothèque Arduino pour aller plus loin !
  
 +===== Sources de l'article=====
 +{{ :howto:arduino-esp:esp-now_programmes.zip |}}
  
  • howto/arduino-esp/esp-now.txt
  • Dernière modification: 2021/10/22 13:47
  • de guillaume