Connectez ESP32 et D1 Mini via ESP-Now

Contrairement à la façon traditionnelle de connecter un contrôleur à un autre via Wi-Fi, ESP-Now utilise un protocole spécial qui relie deux microcontrôleurs compatibles WLAN directement sans passer par un routeur. La connexion est faite directement au moyen des adresses MAC respectives et ne peut bien sûr avoir lieu que dans un WLAN.

Ce protocole simplifié rend la connexion beaucoup plus rapide et réduit ainsi la consommation d’énergie du contrôleur. Cependant, ESP-Now a également des inconvénients, la quantité de données par paquet est limitée à 250 octets et l’Internet ne peut être atteint via une passerelle.

Un maître peut être jumelé à jusqu’à 20 esclaves. Si vous voulez chiffrer le réseau ESP-Now, le nombre d’esclaves possibles est réduit à 10.

Dans notre exemple, nous utiliserons un ESP32 comme maître et une D1 Mini comme esclave. L’esclave est commencé comme un point d’accès doux afin que le maître peut le trouver à travers un balayage réseau.

À la demande du maître, l’esclave doit envoyer des valeurs mesurées à partir d’un capteur de température et d’humidité.

Esclave:

L’esclave est un D1 Minivia la broche D0 - GPIO 16 avec la goupille de données d’un Capteurs de température DHT11 Connecté.

L’esquisse annotée détaillée suivante montre le programme utilisé. Le point d’accès exporte le réseau WLAN nommé Slave_1, le mot de passe n’est pas nécessaire pour établir la connexion.  :

Mini D1 avec capteur de température et d’humidité DHT11
 Esclave dans une communication ESP-NOW
 L’esclave génère le réseau WiFi Slave_1 et attend les données du maître
 Chaque fois qu’un paquet de données est reçu, l’esclave répond avec
 les valeurs mesurées du capteur
 */

 Bibliothèques pour WiFi et pour le capteur
#include <ESP8266WiFi.H (en)>
#include <SimpleDHT.H (en)>

Bibliothèque pour ESP-Now
Externe "C"{
#include <espnow espnow.H (en)>
}

Chaîne WiFi
#define Canal 1

Structure de données pour l’échange de données
Struct DATEN_STRUKTUR {     uint16_t Température = 0;     uint32_t Humide = 0;
};

Instance d’accès au capteur
SimpleDHT11 dht11;

La goupille de données sur D1Mini et D0 équivaut à GPIO16 
Const Octet donnéesPin = 16; Épingle de données de la DHT11

variables globales pour les valeurs mesurées
Octet Température = 0;
Octet Humide = 0;

Nous avons besoin d’un point d’accès WiFi
Vide configDeviceAP() {   Char Char* Ssid = "Slave_1";   Bool Résultat = Wifi.softAP (softAP)(Ssid, "Slave_1_Password", Canal, 0);   Si (!Résultat) {     Série.println("AP Config a échoué.");   } Autre {     Série.println("AP Config Succès. Diffusion avec AP: " + String(Ssid));   }
}

Fonction de rappel lorsque les données ont été reçues 
Vide on_receive_data(uint8_t *Mac, uint8_t *r_data, uint8_t Len) {     pour plus d’informations, nous convertissons l’adresse MAC de l’expéditeur en chaîne et la     Char Char Macmaster[6];     Sprintf(Macmaster, "%02X:%02X:%02x:%02X:%02X:%02X",Mac[0],Mac[1],Mac[2],Mac[3],Mac[4],Mac[5]);     Série.Imprimer("Recevoir MAC: "); Série.Imprimer(Macmaster);       DATEN_STRUKTUR Ed;     nous copieons les données reçues à la structure de données     accès à la structure de données     Memcpy Memcpy (Memcpy)(&Ed, r_data, Sizeof(Ed));     ici, nous avons pu accéder à ces données via ed.temperatur et ed.feuchte     que l’expéditeur a envoyé       maintenant nous définissons les valeurs avec les données du capteur     Ed.Température = Température;     Ed.Humide = Humide;     nous copions les données dans un bloc de stockage et les renvoyons à l’expéditeur     uint8_t s_data[Sizeof(Ed)]; Memcpy Memcpy (Memcpy)(s_data, &Ed, Sizeof(Ed));     esp_now_send(Mac, s_data, Sizeof(s_data));        };
 

Vide Configuration() {   Série.Commencer(115200); Série.println();   Configuration du point d’accès   Wifi.Mode(WIFI_AP);   configDeviceAP();    Initialiser ESOP-Maintenant     Si (esp_now_init()!=0) {     Série.println("Protocole ESP-NOW pas initialisé...");     Esp.Redémarrer();     Retard(1);   }     Adresses MAC pour plus d’informations .   Série.Imprimer("AP MAC: "); Série.println(Wifi.softAPmacAddress (en)());   Série.Imprimer("STA MAC: "); Série.println(Wifi.macAddress macAddress (en)());     SET ESP rôle 1-Master, 2 ' Esclave 3 ' Maître et Esclave   esp_now_set_self_role(2);    et enregistrer la fonction de rappel   esp_now_register_recv_cb(on_receive_data);     }

Vide Boucle() {      valeurs mesurées à partir du capteur avec vérification d’erreur   Int Err = SimpleDHTErrSuccess;   Err = dht11.Lire(donnéesPin, &Température, &Humide, Null);   Si (Err != SimpleDHTErrSuccess) {     Série.Imprimer("N’a pas lu le DHT11. Erreur - ");     Série.println(Err);   }   attendre 1.5 s Le DHT11 fait 1 mesure / s   Retard(1500);    }

Maître:

Pour le Maître, j’ai un ESP-32 Developmentboard Utilisé. Bien sûr, tous les autres conseils ESP peuvent être utilisés ici aussi. Le maître commence en mode station. Dans sa boucle principale, il peut utiliser les réseaux WiFi disponibles jusqu’à ce qu’il ait trouvé un réseau dont le nom commence par "esclave". S’il a trouvé le réseau, il détermine l’adresse MAC du point d’accès, qui est utilisé pour une communication ultérieure. Même si le réseau d’esclaves échoue entre-temps, le maître n’a pas à effectuer un autre scan.

Voici le croquis pour le maître:

/ESP32 en tant que maître pour une connexion ESP-Now
 L’ESP32 recherche un Netzerk WiFi dont le nom commence avec l’esclave
 Lorsqu’il a trouvé un tel réseau, il se souvient de l’adresse du MAC
 Les esclaves et peuvent communiquer avec eux par ESP_Now
 */

Inclure les bibliothèques pour Esp-Now et WiFi
#include <esp_now.H (en)>
#include <Wifi.H (en)>

Copie globale de l’information sur les esclaves
et un drapeau pour savoir si l’esclave a déjà été trouvé
Bool esclaveFound = 0;
esp_now_peer_info_t Esclave;

#define Canal 3

Structure de données pour l’échange de données
Struct DATEN_STRUKTUR {     uint16_t Température = 0;     uint32_t Humide = 0;
};
 

Init ESP Maintenant avec redémarrer au cas où ce qui se passe mal
Vide InitESPNow() {   Si (esp_now_init() == ESP_OK) {     Série.println("ESPNow Init Succès");   }   Autre {     Série.println("ESPNow Init a échoué");     Erreur si nouvelle tentative     Esp.Redémarrer();   }
}

Nous sommes à la recherche d’un esclave
Vide ScanForSlave() {   int8_t scanResults = Wifi.scanNetworks (scanNetworks)();   réinitialiser chaque analyse   Memset (Memset)(&Esclave, 0, Sizeof(Esclave));   Série.println("");   Si (scanResults == 0) {     Série.println("NoNo WiFi dispositif trouvé en mode AP");   } Autre {     Série.Imprimer(scanResults); Série.println(" Dispositifs trouvés ");     Pour (Int Ⅰ. = 0; Ⅰ. < scanResults; ++Ⅰ.) {       Imprimer SSID et RSSI pour chaque appareil trouvé       String Ssid = Wifi.Ssid(Ⅰ.);       int32_t Rssi Rssi = Wifi.Rssi Rssi(Ⅰ.);       String BSSIDstr = Wifi.BSSIDstr(Ⅰ.);       Vérifiez si le nom du réseau commence par 'Slave'       Si (Ssid.Indexof("Esclave") == 0) {         Oui, alors nous avons trouvé un esclave         Série.println("Esclave trouvé.");         Série.Imprimer(Ⅰ. + 1); Série.Imprimer(": "); Série.Imprimer(Ssid); Série.Imprimer(" ["); Série.Imprimer(BSSIDstr); Série.Imprimer("]"); Série.Imprimer(" ("); Série.Imprimer(Rssi Rssi); Série.Imprimer(")"); Série.println("");         Déterminer l’adresse MAC des esclaves BSSID ses et les stocker dans la structure d’information sur les esclaves         Int Mac[6];         Si ( 6 == sscanf(BSSIDstr.c_str(), "%x:%x:%x:%x:%x:%x%c",  &Mac[0], &Mac[1], &Mac[2], &Mac[3], &Mac[4], &Mac[5] ) ) {           Pour (Int Ⅱ. = 0; Ⅱ. < 6; ++Ⅱ. ) {             Esclave.peer_addr[Ⅱ.] = (uint8_t) Mac[Ⅱ.];           }         }         Esclave.Canal = Canal; choisir un canal         Esclave.Crypter = 0; pas de cryptage         esclaveFound = 1;         Sans cette pause, vous pourriez également vous connecter à plus d’un esclave         Si aucun chiffrement n’est utilisé, jusqu’à 20 esclaves sont possibles         Pause;       }     }   }   nettoyer bélier   Wifi.scanDelete();
}

Vérifiez si un esclave est déjà jumelé
Sinon, l’esclave est jumelé avec le maître
Bool manageSlave() {   Si (Esclave.Canal == Canal) {     Const esp_now_peer_info_t *Peer = &Esclave;     Const uint8_t *peer_addr = Esclave.peer_addr;     vérifier si le pair existe     Bool Existe = esp_now_is_peer_exist(peer_addr);     Si ( !Existe) {       Esclave pas jumelé, essayer paire       Série.Imprimer("Statut d’esclave: ");       esp_err_t addStatus = esp_now_add_peer(Peer);       Si (addStatus == ESP_OK) {         Succès de paire         Série.println("Succès pair");         Retour Vrai;       } Autre Si (addStatus == ESP_ERR_ESPNOW_NOT_INIT) {         Comment sommes-nous allés jusqu’à présent!!         Série.println("ESPNOW Pas Init");         Retour Faux;       } Autre Si (addStatus == ESP_ERR_ESPNOW_ARG) {         Série.println("Argument invalide");         Retour Faux;       } Autre Si (addStatus == ESP_ERR_ESPNOW_FULL) {         Série.println("Liste des pairs complète");         Retour Faux;       } Autre Si (addStatus == ESP_ERR_ESPNOW_NO_MEM) {         Série.println("Hors mémoire");         Retour Faux;       } Autre Si (addStatus == ESP_ERR_ESPNOW_EXIST) {         Série.println("Peer Existes");         Retour Vrai;       } Autre {         Série.println("Je ne sais pas ce qui s’est passé");         Retour Faux;       }     }   } Autre {     Aucun esclave trouvé à traiter     Série.println("Aucun esclave trouvé à traiter");     Retour Faux;   }
}

envoyer des données à l’esclave
Vide sendData() {
 DATEN_STRUKTUR Ed;       Parce que nous ignorons les données dans cet exemple dans l’esclave     il n’a pas d’importance ce que nous envoyons                        Ed.Température = 0;     Ed.Humide = 0;     nous copions la structure de données en un bloc de mémoire     uint8_t Données[Sizeof(Ed)]; Memcpy Memcpy (Memcpy)(Données, &Ed, Sizeof(Ed));     Const uint8_t *peer_addr = Esclave.peer_addr;     Nous envoyons les données et vérifions l’état   Série.Imprimer("Envoi: ");   esp_err_t Résultat = esp_now_send(peer_addr, Données, Sizeof(Données));   Série.Imprimer("Envoyer le statut: ");   Si (Résultat == ESP_OK) {     Série.println("Succès");   } Autre Si (Résultat == ESP_ERR_ESPNOW_NOT_INIT) {     Comment sommes-nous allés jusqu’à présent!!     Série.println("ESPNOW pas Init.");   } Autre Si (Résultat == ESP_ERR_ESPNOW_ARG) {     Série.println("Argument invalide");   } Autre Si (Résultat == ESP_ERR_ESPNOW_INTERNAL) {     Série.println("Erreur interne");   } Autre Si (Résultat == ESP_ERR_ESPNOW_NO_MEM) {     Série.println("ESP_ERR_ESPNOW_NO_MEM");   } Autre Si (Résultat == ESP_ERR_ESPNOW_NOT_FOUND) {     Série.println("Peer pas trouvé.");   } Autre {     Série.println("Je ne sais pas ce qui s’est passé");   }
}

rappel lorsque les données ont été envoyées à l’esclave
ici, vous pouvez voir si l’esclave n’était pas accessible
Vide on_data_sent(Const uint8_t *mac_addr, esp_now_send_status_t Statut) {   Char Char macStr (en)[18];   Snprintf (Snprintf)(macStr (en), Sizeof(macStr (en)), "%02x:%02x:%02x:%02x:%02x:%02x:%02x",            mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);   Série.Imprimer("Dernier paquet envoyé à: "); Série.println(macStr (en));   Série.Imprimer("Dernier paquet Envoyer statut: "); Série.println(Statut == ESP_NOW_SEND_SUCCESS ? "Succès de livraison" : "Échec de livraison");
}


rappel lorsque nous obtenons des données de l’esclave
Vide on_data_recv(Const uint8_t *mac_addr, Const uint8_t *Données, Int data_len) {   Char Char macStr (en)[18];   Adresse MAC de l’esclave pour info   Snprintf (Snprintf)(macStr (en), Sizeof(macStr (en)), "%02x:%02x:%02x:%02x:%02x:%02x:%02x",            mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);   DATEN_STRUKTUR Ed;   nous copions les données dans la structure des données     Memcpy Memcpy (Memcpy)(&Ed, Données, Sizeof(Ed));     et les afficher     Série.Imprimer("Recevoir"); Série.println(macStr (en));     Série.Imprimer("Température: "); Série.Imprimer(Ed.Température); Série.println(" C ");     Série.Imprimer("Humidité: "); Série.Imprimer(Ed.Humide); Série.println(" %");
}

Vide Configuration() {   Série.Commencer(115200);   Définir l’appareil en mode STA pour commencer   Wifi.Mode(WIFI_STA);   Wifi.Débrancher();   Série.println("ESPNow ESP32 en tant que Maître");   c’est l’adresse mac du maître   Série.Imprimer("STA MAC: "); Série.println(Wifi.macAddress macAddress (en)());   Init ESPNow avec une logique de repli   InitESPNow();   Nous enregistrons la fonction de rappel à la fin du processus d’envoi   esp_now_register_send_cb(on_data_sent);   Nous enregistrons la fonction de rappel pour recevoir   esp_now_register_recv_cb(on_data_recv);
}

Vide Boucle() {   Si nous n’avons pas encore trouvé d’esclave, nous cherchons toujours   Si (!esclaveFound) ScanForSlave();   Si (esclaveFound) {     nous avons un esclave, il doit être jumelé     si cela ne s’est pas encore produit     Bool estPaired = manageSlave();     Si (estPaired) {       Si maître et esclave sont jumelés, nous pouvons envoyer       sendData();     } Autre {       paire d’esclaves a échoué       Série.println("Le couple d’esclaves a échoué !");     }   }   Autre {     Aucun esclave trouvé à traiter   }   5 secondes à attendre   Retard(5000);
}

Pointe:

Vous pouvez modifier plus d’un tableau à partir d’un PC avec l’IDE Arduino en même temps. Pour ce faire, il n’est nécessaire de démarrer l’IDE que dans deux cas, c’est-à-dire pas plusieurs fenêtres d’une même instance. Ensuite, le type de panneau et le numéro de port peuvent être définis séparément.

Test:

Nous commençons le maître en premier: Le moniteur de série indiquera que le maître ne peut pas trouver un réseau approprié. Lorsque nous commençons l’esclave, le maître doit trouver le réseau et se connecter. Le maître doit alors afficher la température et l’humidité qu’il reçoit de l’esclave.

Si nous éteignent l’esclave, le maître continuera d’essayer d’atteindre l’esclave, mais cela se terminera par une erreur. Dès que nous renvoyons l’esclave, le maître peut envoyer et recevoir des données avec succès à nouveau.

NOUS utiliserons également ESP-Now dans le cadre du projet Home-Control.

Amusez-vous à expérimenter.