ESP-MESH avec ESP32 et ESP8266 : Mise en route

Apprenez à utiliser le protocole réseau ESP-MESH pour créer un réseau maillé avec les cartes ESP32 et ESP8266 NodeMCU. ESP-MESH permet à plusieurs appareils (nœuds) de communiquer entre eux via un seul réseau local sans fil. Il est pris en charge sur les cartes ESP32 et ESP8266. Dans ce guide, nous allons vous montrer comment démarrer avec ESP-MESH en utilisant le noyau Arduino.

Cet article couvre les sujets suivants :

EDI Arduino

Si vous voulez programmer le ESP32 et ESP8266 cartes utilisant Arduino IDE, vous devez avoir installé les add-ons ESP32 ou ESP8266. Suivez les guides suivants :

Si vous souhaitez programmer l’ESP32/ESP8266 en utilisant VS Code + PlatformIO, suivez le tutoriel suivant :

Présentation ESP-MESH

En conséquence de la documentation Espressif :

« ESP-MESH est un protocole de réseau construit au-dessus du protocole Wi-Fi. ESP-MESH permet à de nombreux appareils (appelés nœuds) répartis sur une grande surface physique (à la fois à l’intérieur et à l’extérieur) d’être interconnectés sous un seul WLAN (Wireless Local-Area Network).

ESP-MESH s’auto-organise et s’auto-répare, ce qui signifie que le réseau peut être construit et maintenu de manière autonome. Pour plus d’informations, visitez le Documentation officielle ESP-MESH.

Architecture de réseau Wi-Fi traditionnelle

Dans une architecture de réseau Wi-Fi traditionnelle, un seul nœud (point d’accès – généralement le routeur) est connecté à tous les autres nœuds (stations). Chaque nœud peut communiquer entre eux à l’aide du point d’accès. Cependant, cela est limité à la couverture Wi-Fi du point d’accès. Chaque station doit être à portée pour se connecter directement au point d’accès. Cela ne se produit pas avec ESP-MESH.

Architecture réseau ESP-MESH

Avec ESP-MESH, les nœuds n’ont pas besoin de se connecter à un nœud central. Les nœuds sont chargés de relayer les transmissions les uns des autres. Cela permet à plusieurs appareils de se répartir sur une grande surface physique. Les nœuds peuvent s’auto-organiser et se parler dynamiquement pour s’assurer que le paquet atteint sa destination de nœud finale. Si un nœud est supprimé du réseau, il est capable de s’auto-organiser pour s’assurer que les paquets atteignent leur destination.

bibliothèque painlessMesh

Le bibliothèque painlessMesh nous permet de créer un réseau maillé avec les cartes ESP8266 ou/et ESP32 de manière simple.

«painlessMesh est un véritable réseau ad hoc, ce qui signifie qu’aucune planification, aucun contrôleur central ou routeur n’est requis. Tout système d’un ou plusieurs nœuds s’auto-organisera en un maillage entièrement fonctionnel. La taille maximale du maillage est limitée (nous pensons) par la quantité de mémoire dans le tas qui peut être allouée au tampon de sous-connexions et devrait donc être vraiment assez élevée. Plus d’informations sur la bibliothèque painlessMesh.

Installation de la bibliothèque PainlessMesh

Vous pouvez installer painlessMesh via le gestionnaire de bibliothèque Arduino. Accédez à Outils > Gérer les bibliothèques. Le gestionnaire de bibliothèque devrait s’ouvrir.

Recherchez « painlessmesh » et installez la bibliothèque. Nous utilisons la version 1.4.5

Cette bibliothèque a besoin d’autres dépendances de bibliothèque. Une nouvelle fenêtre devrait apparaître vous demandant d’installer les dépendances manquantes. Sélectionnez « Tout installer ».

Si cette fenêtre ne s’affiche pas, vous devrez installer les dépendances de bibliothèque suivantes :

Si vous utilisez PlatformIO, ajoutez les lignes suivantes au fichier platformio.ini pour ajouter les bibliothèques et modifier la vitesse du moniteur.

Pour l’ESP32 :

monitor_speed = 115200
lib_deps = painlessmesh/painlessMesh @ ^1.4.5
    ArduinoJson
    arduinoUnity
    TaskScheduler
    AsyncTCP

Pour l’ESP8266 :

monitor_speed = 115200
lib_deps = painlessmesh/painlessMesh @ ^1.4.5
    ArduinoJson
    TaskScheduler
    ESPAsyncTCP

Exemple de base ESP-MESH (messages de diffusion)

Pour commencer avec ESP-MESH, nous allons d’abord expérimenter avec l’exemple de base de la bibliothèque. Cet exemple crée un réseau maillé dans lequel toutes les cartes diffusent des messages à toutes les autres cartes.

Nous avons expérimenté cet exemple avec quatre cartes (deux ESP32 et deux ESP8266). Vous pouvez ajouter ou supprimer des tableaux. Le code est compatible avec les cartes ESP32 et ESP8266.

Code – exemple de base de la bibliothèque painlessMesh

Copiez le code suivant dans votre IDE Arduino (code des exemples de la bibliothèque). Le code est compatible avec les cartes ESP32 et ESP8266.

/*
  Rui Santos
  Complete project details at https://Raspberryme.com/esp-mesh-esp32-esp8266-painlessmesh/
  
  This is a simple example that uses the painlessMesh library: https://github.com/gmag11/painlessMesh/blob/master/examples/basic/basic.ino
*/

#include "painlessMesh.h"

#define   MESH_PREFIX     "whateverYouLike"
#define   MESH_PASSWORD   "somethingSneaky"
#define   MESH_PORT       5555

Scheduler userScheduler; // to control your personal task
painlessMesh  mesh;

// User stub
void sendMessage() ; // Prototype so PlatformIO doesn't complain

Task taskSendMessage( TASK_SECOND * 1 , TASK_FOREVER, &sendMessage );

void sendMessage() {
  String msg = "Hi from node1";
  msg += mesh.getNodeId();
  mesh.sendBroadcast( msg );
  taskSendMessage.setInterval( random( TASK_SECOND * 1, TASK_SECOND * 5 ));
}

// Needed for painless library
void receivedCallback( uint32_t from, String &msg ) {
  Serial.printf("startHere: Received from %u msg=%s\n", from, msg.c_str());
}

void newConnectionCallback(uint32_t nodeId) {
    Serial.printf("--> startHere: New Connection, nodeId = %u\n", nodeId);
}

void changedConnectionCallback() {
  Serial.printf("Changed connections\n");
}

void nodeTimeAdjustedCallback(int32_t offset) {
    Serial.printf("Adjusted time %u. Offset = %d\n", mesh.getNodeTime(),offset);
}

void setup() {
  Serial.begin(115200);

//mesh.setDebugMsgTypes( ERROR | MESH_STATUS | CONNECTION | SYNC | COMMUNICATION | GENERAL | MSG_TYPES | REMOTE ); // all types on
  mesh.setDebugMsgTypes( ERROR | STARTUP );  // set before init() so that you can see startup messages

  mesh.init( MESH_PREFIX, MESH_PASSWORD, &userScheduler, MESH_PORT );
  mesh.onReceive(&receivedCallback);
  mesh.onNewConnection(&newConnectionCallback);
  mesh.onChangedConnections(&changedConnectionCallback);
  mesh.onNodeTimeAdjusted(&nodeTimeAdjustedCallback);

  userScheduler.addTask( taskSendMessage );
  taskSendMessage.enable();
}

void loop() {
  // it will run the user scheduler as well
  mesh.update();
}

Afficher le code brut

Avant de télécharger le code, vous pouvez configurer les variables MESH_PREFIX (c’est comme le nom du réseau MESH) et les variables MESH_PASSWORD (vous pouvez le définir comme vous le souhaitez).

Ensuite, nous vous recommandons de modifier la ligne suivante pour chaque carte afin d’identifier facilement le nœud qui a envoyé le message. Par exemple, pour le nœud 1, modifiez le message comme suit :

String msg = "Hi from node 1 ";

Comment fonctionne le code

Commencez par inclure la bibliothèque painlessMesh.

#include "painlessMesh.h"

Détails MAILLE

Ensuite, ajoutez les détails du maillage. Le MESH_PREFIX fait référence au nom du maillage. Vous pouvez le changer en ce que vous voulez.

#define MESH_PREFIX "whateverYouLike"

Le MESH_PASSWORD, comme son nom l’indique, est le mot de passe du maillage. Vous pouvez le changer en ce que vous voulez.

#define MESH_PASSWORD "somethingSneaky"

Tous les nœuds du maillage doivent utiliser les mêmes MESH_PREFIX et MESH_PASSWORD.

MESH_PORT fait référence au port TCP sur lequel vous souhaitez que le serveur maillé s’exécute. La valeur par défaut est 5555.

#define MESH_PORT 5555

Planificateur

Il est recommandé d’éviter d’utiliser delay() dans le code du réseau maillé. Pour maintenir le maillage, certaines tâches doivent être effectuées en arrière-plan. L’utilisation de delay() empêchera ces tâches de se produire et peut entraîner la perte de stabilité/l’effondrement du maillage.

Au lieu de cela, il est recommandé d’utiliser TaskScheduler pour exécuter vos tâches qui sont utilisées dans painlessMesh lui-même.

La ligne suivante crée un nouveau planificateur appelé userScheduler.

Scheduler userScheduler; // to control your personal task

maille indolore

Créez un objet painlessMesh appelé mesh pour gérer le réseau maillé.

Créer des tâches

Créez une tâche appelée taskSendMessage chargée d’appeler la fonction sendMessage() toutes les secondes tant que le programme est en cours d’exécution.

Task taskSendMessage(TASK_SECOND * 1 , TASK_FOREVER, &sendMessage);

Envoyer un message au maillage

La fonction sendMessage() envoie un message à tous les nœuds du réseau de messagerie (diffusion).

void sendMessage() {
  String msg = "Hi from node 1";
  msg += mesh.getNodeId();
  mesh.sendBroadcast( msg );
  taskSendMessage.setInterval(random(TASK_SECOND * 1, TASK_SECOND * 5));
}

Le message contient le texte « Hi from node 1 » suivi de l’ID de la puce de la carte.

String msg = "Hi from node 1";
msg += mesh.getNodeId();

Pour diffuser un message, utilisez simplement la méthode sendBroadcast() sur l’objet mesh et passez en argument le message (msg) que vous souhaitez envoyer.

mesh.sendBroadcast(msg);

Chaque fois qu’un nouveau message est envoyé, le code modifie l’intervalle entre les messages (une à cinq secondes).

taskSendMessage.setInterval(random(TASK_SECOND * 1, TASK_SECOND * 5));

Fonctions de rappel de maillage

Ensuite, plusieurs fonctions de rappel sont créées et seront appelées lorsque des événements spécifiques se produisent sur le maillage.

La fonction receiveCallback() imprime l’expéditeur du message (from) et le contenu du message (msg.c_str()).

void receivedCallback( uint32_t from, String &msg ) {
  Serial.printf("startHere: Received from %u msg=%s\n", from, msg.c_str());
}

La fonction newConnectionCallback() s’exécute chaque fois qu’un nouveau nœud rejoint le réseau. Cette fonction imprime simplement l’ID de puce du nouveau nœud. Vous pouvez modifier la fonction pour effectuer toute autre tâche.

void newConnectionCallback(uint32_t nodeId) {
  Serial.printf("--> startHere: New Connection, nodeId = %u\n", nodeId);
}

La fonction modifiedConnectionCallback() s’exécute chaque fois qu’une connexion change sur le réseau (lorsqu’un nœud rejoint ou quitte le réseau).

void changedConnectionCallback() {
  Serial.printf("Changed connections\n");
}

La fonction nodeTimeAdjustedCallback() s’exécute lorsque le réseau ajuste l’heure, afin que tous les nœuds soient synchronisés. Il imprime le décalage.

void nodeTimeAdjustedCallback(int32_t offset) {
  Serial.printf("Adjusted time %u. Offset = %d\n", mesh.getNodeTime(),offset);
}

installation()

Dans le setup(), initialisez le moniteur série.

void setup() {
  Serial.begin(115200);

Choisissez les types de messages de débogage souhaités :

//mesh.setDebugMsgTypes( ERROR | MESH_STATUS | CONNECTION | SYNC | COMMUNICATION | GENERAL | MSG_TYPES | REMOTE ); // all types on

mesh.setDebugMsgTypes( ERROR | STARTUP );  // set before init() so that you can see startup messages

Initialisez le maillage avec les détails définis précédemment.

mesh.init(MESH_PREFIX, MESH_PASSWORD, &userScheduler, MESH_PORT);

Affectez toutes les fonctions de rappel à leurs événements correspondants.

mesh.onReceive(&receivedCallback);
mesh.onNewConnection(&newConnectionCallback);
mesh.onChangedConnections(&changedConnectionCallback);
mesh.onNodeTimeAdjusted(&nodeTimeAdjustedCallback);

Enfin, ajoutez la fonction taskSendMessage au userScheduler. Le planificateur est responsable de la gestion et de l’exécution des tâches au bon moment.

userScheduler.addTask(taskSendMessage);

Enfin, activez la tâcheSendMessage, afin que le programme commence à envoyer les messages au maillage.

taskSendMessage.enable();

Pour que le maillage continue de fonctionner, ajoutez mesh.update() à la boucle().

void loop() {
  // it will run the user scheduler as well
  mesh.update();
}

Manifestation

Téléchargez le code fourni à tous vos tableaux. N’oubliez pas de modifier le message pour identifier facilement le noeud expéditeur

Avec les cartes connectées à votre ordinateur, ouvrez une connexion série avec chaque carte. Vous pouvez utiliser le Serial Monitor, ou vous pouvez utiliser un logiciel comme Mastic et ouvrez plusieurs fenêtres pour tous les tableaux.

Vous devriez voir que tous les tableaux reçoivent les messages les uns des autres. Par exemple, ce sont les messages reçus par le nœud 1. Il reçoit les messages des nœuds 2, 3 et 4.

Vous devriez également voir d’autres messages lorsqu’il y a des changements sur le maillage : lorsqu’une carte quitte ou rejoint le réseau.

Échanger les lectures de capteur à l’aide d’ESP-MESH

Dans cet exemple suivant, nous allons échanger les lectures des capteurs entre 4 cartes (vous pouvez utiliser un nombre différent de cartes). Chaque conseil reçoit les relevés des autres conseils.

Par exemple, nous échangerons les relevés de capteur d’un Capteur BME280mais vous pouvez utiliser n’importe quel autre capteur.

Pièces requises

Voici les pièces nécessaires pour cet exemple :

Bibliothèque Arduino_JSON

Dans cet exemple, nous échangerons les lectures des capteurs au format JSON. Pour faciliter la gestion des variables JSON, nous utiliserons le Bibliothèque Arduino_JSON.

Vous pouvez installer cette bibliothèque dans le gestionnaire de bibliothèque Arduino IDE. Accédez simplement à Sketch > Inclure la bibliothèque > Gérer les bibliothèques et recherchez le nom de la bibliothèque comme suit :

Si vous utilisez VS Code avec PlatformIO, incluez les bibliothèques dans le fichier platformio.ini comme suit :

ESP32

monitor_speed = 115200
lib_deps = painlessmesh/painlessMesh @ ^1.4.5
    ArduinoJson
    arduinoUnity
    AsyncTCP
    TaskScheduler
    adafruit/Adafruit Unified Sensor @ ^1.1.4
    adafruit/Adafruit BME280 Library @ ^2.1.2
    arduino-libraries/Arduino_JSON @ ^0.1.0

ESP8266

monitor_speed = 115200
lib_deps = painlessmesh/painlessMesh @ ^1.4.5
    ArduinoJson
    TaskScheduler
    ESPAsyncTCP
    adafruit/Adafruit Unified Sensor @ ^1.1.4
    adafruit/Adafruit BME280 Library @ ^2.1.2
    arduino-libraries/Arduino_JSON @ ^0.1.0

Schéma

Câblez le capteur BME280 aux broches I2C par défaut ESP32 ou ESP8266 comme indiqué dans les schémas suivants.

ESP32

Lecture recommandée : ESP32 avec capteur BME280 utilisant Arduino IDE (pression, température, humidité)

ESP8266 NodeMCU

Lecture recommandée : ESP8266 avec BME280 utilisant Arduino IDE (pression, température, humidité)

Code – Lectures du capteur de diffusion ESP-MESH

Téléchargez le code suivant sur chacun de vos tableaux. Ce code lit et diffuse les relevés actuels de température, d’humidité et de pression sur toutes les cartes du réseau maillé. Les lectures sont envoyées sous forme de chaîne JSON qui contient également le numéro de nœud pour identifier la carte émettrice.

/*
  Rui Santos
  Complete project details at https://Raspberryme.com/esp-mesh-esp32-esp8266-painlessmesh/
  
  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 <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
#include "painlessMesh.h"
#include <Arduino_JSON.h>

// MESH Details
#define   MESH_PREFIX     "RNTMESH" //name for your MESH
#define   MESH_PASSWORD   "MESHpassword" //password for your MESH
#define   MESH_PORT       5555 //default port

//BME object on the default I2C pins
Adafruit_BME280 bme;

//Number for this node
int nodeNumber = 2;

//String to send to other nodes with sensor readings
String readings;

Scheduler userScheduler; // to control your personal task
painlessMesh  mesh;

// User stub
void sendMessage() ; // Prototype so PlatformIO doesn't complain
String getReadings(); // Prototype for sending sensor readings

//Create tasks: to send messages and get readings;
Task taskSendMessage(TASK_SECOND * 5 , TASK_FOREVER, &sendMessage);

String getReadings () {
  JSONVar jsonReadings;
  jsonReadings["node"] = nodeNumber;
  jsonReadings["temp"] = bme.readTemperature();
  jsonReadings["hum"] = bme.readHumidity();
  jsonReadings["pres"] = bme.readPressure()/100.0F;
  readings = JSON.stringify(jsonReadings);
  return readings;
}

void sendMessage () {
  String msg = getReadings();
  mesh.sendBroadcast(msg);
}

//Init BME280
void initBME(){
  if (!bme.begin(0x76)) {
    Serial.println("Could not find a valid BME280 sensor, check wiring!");
    while (1);
  }  
}

// Needed for painless library
void receivedCallback( uint32_t from, String &msg ) {
  Serial.printf("Received from %u msg=%s\n", from, msg.c_str());
  JSONVar myObject = JSON.parse(msg.c_str());
  int node = myObject["node"];
  double temp = myObject["temp"];
  double hum = myObject["hum"];
  double pres = myObject["pres"];
  Serial.print("Node: ");
  Serial.println(node);
  Serial.print("Temperature: ");
  Serial.print(temp);
  Serial.println(" C");
  Serial.print("Humidity: ");
  Serial.print(hum);
  Serial.println(" %");
  Serial.print("Pressure: ");
  Serial.print(pres);
  Serial.println(" hpa");
}

void newConnectionCallback(uint32_t nodeId) {
  Serial.printf("New Connection, nodeId = %u\n", nodeId);
}

void changedConnectionCallback() {
  Serial.printf("Changed connections\n");
}

void nodeTimeAdjustedCallback(int32_t offset) {
  Serial.printf("Adjusted time %u. Offset = %d\n", mesh.getNodeTime(),offset);
}

void setup() {
  Serial.begin(115200);
  
  initBME();

  //mesh.setDebugMsgTypes( ERROR | MESH_STATUS | CONNECTION | SYNC | COMMUNICATION | GENERAL | MSG_TYPES | REMOTE ); // all types on
  mesh.setDebugMsgTypes( ERROR | STARTUP );  // set before init() so that you can see startup messages

  mesh.init( MESH_PREFIX, MESH_PASSWORD, &userScheduler, MESH_PORT );
  mesh.onReceive(&receivedCallback);
  mesh.onNewConnection(&newConnectionCallback);
  mesh.onChangedConnections(&changedConnectionCallback);
  mesh.onNodeTimeAdjusted(&nodeTimeAdjustedCallback);

  userScheduler.addTask(taskSendMessage);
  taskSendMessage.enable();
}

void loop() {
  // it will run the user scheduler as well
  mesh.update();
}

Afficher le code brut

Le code est compatible avec les cartes ESP32 et ESP8266.

Comment fonctionne le code

Continuez à lire cette section pour savoir comment fonctionne le code.

Bibliothèques

Commencez par inclure les bibliothèques requises : Adafruit_Sensor et Adafruit_BME280 pour s’interfacer avec le capteur BME280 ; la bibliothèque painlessMesh pour gérer le réseau maillé et Arduino_JSON pour créer et gérer facilement les chaînes JSON.

#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
#include "painlessMesh.h"
#include <Arduino_JSON.h>

Détails en maille

Insérez les détails du maillage dans les lignes suivantes.

#define MESH_PREFIX    "RNTMESH" //name for your MESH
#define MESH_PASSWORD  "MESHpassword" //password for your MESH
#define MESH_PORT      5555 //default port

Le MESH_PREFIX fait référence au nom du maillage. Vous pouvez le changer en ce que vous voulez. Le MESH_PASSWORD, comme son nom l’indique, est le mot de passe du maillage. Vous pouvez le changer en ce que vous voulez. Tous les nœuds du maillage doivent utiliser les mêmes MESH_PREFIX et MESH_PASSWORD.

MESH_PORT fait référence au port TCP sur lequel vous souhaitez que le serveur maillé s’exécute. La valeur par défaut est 5555.

BME280

Créez un objet Adafruit_BME280 appelé bme sur les broches ESP32 ou ESP8266 par défaut.

Adafruit_BME280 bme;

Dans la variable nodeNumber, insérez le numéro de nœud de votre carte. Il doit s’agir d’un numéro différent pour chaque carte.

int nodeNumber = 2;

La variable lectures sera utilisée pour enregistrer les lectures à envoyer aux autres cartes.

String readings;

Planificateur

La ligne suivante crée un nouveau planificateur appelé userScheduler.

Scheduler userScheduler; // to control your personal task

maille indolore

Créez un objet painlessMesh appelé mesh pour gérer le réseau maillé.

Créer des tâches

Créez une tâche appelée taskSendMessage chargée d’appeler la fonction sendMessage() toutes les cinq secondes tant que le programme est en cours d’exécution.

Task taskSendMessage(TASK_SECOND * 5 , TASK_FOREVER, &sendMessage);

getLectures()

La fonction getReadings() obtient les lectures de température, d’humidité et de pression du capteur BME280 et concatène toutes les informations, y compris le numéro de nœud sur une variable JSON appelée jsonReadings.

JSONVar jsonReadings;
jsonReadings["node"] = nodeNumber;
jsonReadings["temp"] = bme.readTemperature();
jsonReadings["hum"] = bme.readHumidity();
jsonReadings["pres"] = bme.readPressure()/100.0F;

La ligne suivante montre la structure de la variable jsonReadings avec des valeurs arbitraires.

{
  "node":2,
  "temperature":24.51,
  "humidity":52.01,
  "pressure":1005.21
}

La variable jsonReadings est ensuite convertie en chaîne JSON à l’aide de la méthode stringify() et enregistrée sur la variable readings.

readings = JSON.stringify(jsonReadings);

Cette variable est ensuite retournée par la fonction.

return readings;

Envoyer un message au maillage

La fonction sendMessage() envoie la chaîne JSON avec les lectures et le numéro de nœud (getReadings()) à tous les nœuds du réseau (diffusion).

void sendMessage () {
  String msg = getReadings();
  mesh.sendBroadcast(msg);
}

Initialiser le capteur BME280

La fonction initBME() initialise le capteur BME280.

void initBME(){
  if (!bme.begin(0x76)) {
    Serial.println("Could not find a valid BME280 sensor, check wiring!");
    while (1);
  }
}

Fonctions de rappel de maillage

Ensuite, plusieurs fonctions de rappel sont créées et seront appelées lorsqu’un événement sur le maillage se produit.

La fonction receiveCallback() imprime l’expéditeur du message (from) et le contenu du message (msg.c_str()).

void receivedCallback( uint32_t from, String &msg ) {
  Serial.printf("startHere: Received from %u msg=%s\n", from, msg.c_str());

Le message est au format JSON, nous pouvons donc accéder aux variables comme suit :

JSONVar myObject = JSON.parse(msg.c_str());
int node = myObject["node"];
double temp = myObject["temp"];
double hum = myObject["hum"];
double pres = myObject["pres"];

Enfin, imprimez toutes les informations sur le Serial Monitor.

Serial.print("Node: ");
Serial.println(node);
Serial.print("Temperature: ");
Serial.print(temp);
Serial.println(" C");
Serial.print("Humidity: ");
Serial.print(hum);
Serial.println(" %");
Serial.print("Pressure: ");
Serial.print(pres);
Serial.println(" hpa");

La fonction newConnectionCallback() s’exécute chaque fois qu’un nouveau nœud rejoint le réseau. Cette fonction imprime simplement l’ID de puce du nouveau nœud. Vous pouvez modifier la fonction pour effectuer toute autre tâche.

void newConnectionCallback(uint32_t nodeId) {
  Serial.printf("--> startHere: New Connection, nodeId = %u\n", nodeId);
}

La fonction modifiedConnectionCallback() s’exécute chaque fois qu’une connexion change sur le réseau (lorsqu’un nœud rejoint ou quitte le réseau).

void changedConnectionCallback() {
  Serial.printf("Changed connections\n");
}

La fonction nodeTimeAdjustedCallback() s’exécute lorsque le réseau ajuste l’heure, afin que tous les nœuds soient synchronisés. Il imprime le décalage.

void nodeTimeAdjustedCallback(int32_t offset) {
  Serial.printf("Adjusted time %u. Offset = %d\n", mesh.getNodeTime(),offset);
}

installation()

Dans le setup(), initialisez le moniteur série.

void setup() {
  Serial.begin(115200);

Appelez la fonction initBME() pour initialiser le capteur BME280.

initBME();

Choisissez les types de messages de débogage souhaités :

//mesh.setDebugMsgTypes( ERROR | MESH_STATUS | CONNECTION | SYNC | COMMUNICATION | GENERAL | MSG_TYPES | REMOTE ); // all types on

mesh.setDebugMsgTypes( ERROR | STARTUP );  // set before init() so that you can see startup messages

Initialisez le maillage avec les détails définis précédemment.

mesh.init(MESH_PREFIX, MESH_PASSWORD, &userScheduler, MESH_PORT);

Affectez toutes les fonctions de rappel à leurs événements correspondants.

mesh.onReceive(&receivedCallback);
mesh.onNewConnection(&newConnectionCallback);
mesh.onChangedConnections(&changedConnectionCallback);
mesh.onNodeTimeAdjusted(&nodeTimeAdjustedCallback);

Enfin, ajoutez la fonction taskSendMessage au userScheduler. Le planificateur est responsable de la gestion et de l’exécution des tâches au bon moment.

userScheduler.addTask(taskSendMessage);

Enfin, activez la tâcheSendMessage, afin que le programme commence à envoyer les messages au maillage.

taskSendMessage.enable();

Pour que le maillage continue de fonctionner, ajoutez mesh.update() à la boucle().

void loop() {
  // it will run the user scheduler as well
  mesh.update();
}

Manifestation

Après avoir téléchargé le code sur tous vos tableaux (chaque tableau avec un numéro de nœud différent), vous devriez voir que chaque tableau reçoit les messages des autres tableaux.

La capture d’écran suivante montre les messages reçus par le nœud 1. Il reçoit les lectures des capteurs des nœuds 2, 3 et 4.

Conclusion

Nous espérons que cette introduction rapide au protocole réseau ESP-MESH vous a plu. Vous pouvez jeter un oeil à la bibliothèque painlessMesh pour plus d’exemples.

Nous avons l’intention de créer plus de tutoriels sur ce sujet dans un futur proche. Alors, écrivez vos suggestions dans la section des commentaires.

Vous aimerez aussi les articles suivants :

Apprenez-en plus sur l’ESP32 et l’ESP8266 avec nos ressources :

Merci d’avoir lu.

Cette vidéo vous emmène dans l’histoire de Raspberry Pi :