Comment construire une grille de capteurs IoT simple avec le ThinkNode M1 & M2 Meshtastic appareils par Elecrow.
Les M1 et M2 sont de petits émetteurs-récepteurs LoRa qui vous permettent d’envoyer des messages texte via un Meshtastic réseau maillé. Les applications courantes sont la communication dans des zones isolées sans couverture Wi-Fi, les situations d’urgence lorsque l’infrastructure de communication est hors service, ou les grilles de capteurs IoT.
Dans ce tutoriel, je vous montre comment envoyer des données environnementales telles que la température, l’humidité et la pression d’un ThinkNode M2 à un ThinkNode M1 – en construisant essentiellement une petite grille de capteurs IoT.
Qu’est-ce que Meshtastic ?
Meshtastic est un projet open-source qui utilise des radios LoRa pour former des réseaux maillés décentralisés dans le but de transporter des messages texte. Les messages sont automatiquement relayés d’un nœud à un autre, permettant de communiquer sur de longues distances sans infrastructure centrale comme le Wi-Fi.
Puisque Meshtastic utilise LoRa, une bande de fréquence libre, vous n’avez pas besoin de licence pour l’utiliser et les appareils Meshtastic sont généralement peu coûteux. Consultez le Long range communication with LoRa SX1276 and ESP32 tutoriel pour en savoir plus sur LoRa.
Le principal inconvénient de LoRa est que vous ne pouvez transmettre que de petites quantités de données (messages texte). De plus, les longues distances ne peuvent être atteintes que si la zone est couverte par un nombre suffisant de nœuds Meshtastic assez proches pour relayer les messages.
Meshtastic versus LoRaWAN
Si vous connaissez LoRa, vous avez peut-être aussi entendu parler de LoRaWAN. Meshtastic et LoRaWAN sont deux technologies utilisant des radios LoRa, mais elles ont des architectures et des objectifs différents.
LoRaWAN est un protocole réseau étendu à faible consommation conçu pour une communication longue portée et faible bande passante, connectant généralement les appareils à Internet via des passerelles. Voir notre LoRaWAN with Thinknode G1 Gateway tutoriel. Meshtastic, en revanche, crée des réseaux maillés décentralisés et ad hoc, permettant aux appareils de communiquer directement entre eux sans dépendre d’infrastructures comme les passerelles.
LoRaWAN utilise une topologie en étoile d’étoiles avec des appareils finaux communiquant via des passerelles vers un serveur central. Meshtastic forme un réseau maillé où les appareils relaient les messages entre eux, créant un réseau décentralisé et auto-réparateur.
LoRaWAN convient aux applications IoT à grande échelle comme les villes intelligentes et la surveillance environnementale, où les appareils doivent transmettre des données à un serveur central. Meshtastic est mieux adapté aux communications hors réseau, aux situations d’urgence ou aux zones où l’infrastructure est limitée, comme dans les zones isolées ou en cas de catastrophe.
Qu’est-ce que ThinkNode M1 & M2
Les ThinkNode M1 & M2 et appareils Meshtastic similaires sont essentiellement comme des talkies-walkies mais pour le texte. Ils contiennent un émetteur-récepteur LoRa et utilisent le protocole Meshtastic pour transporter les données entre appareils/nœuds. La photo ci-dessous montre le ThinkNode M1 :
Vous remarquerez que l’appareil n’a qu’un écran mais pas de clavier. Pour envoyer des messages, vous devez installer l’application Meshtastic sur votre téléphone mobile et la connecter via Bluetooth au ThinkNode. Vous pouvez alors taper des messages sur votre téléphone qui seront transmis par le ThinkNode via le réseau LoRa/Meshtastic aux autres appareils Meshtastic.
Notez qu’il existe d’autres appareils Meshtastic devices avec clavier intégré ou écran tactile qui exécutent le Meshtastic UI directement sur l’appareil. Dans ce cas, vous n’avez pas besoin d’un téléphone mobile supplémentaire connecté pour envoyer des messages.
Comparaison des ThinkNode M1 & M2
Les appareils Meshtastic sont basés soit sur le nRF52 soit sur l’ESP32 comme microcontrôleur. Les appareils basés sur nRF52 consomment moins d’énergie et conviennent mieux aux applications alimentées par énergie solaire ou portables. Les appareils basés sur ESP32 offrent plus de puissance de calcul, une connectivité Wi-Fi et sont moins chers.
C’est aussi la principale différence entre le ThinkNode M1 & M2. Le M1 est basé sur le processeur nRF52840 et est conçu pour une autonomie plus longue grâce à une batterie plus grande et un écran E-Ink. Le M2 utilise le plus puissant ESP32-S3 comme microcontrôleur et est généralement plus facile à programmer/personnaliser si vous venez du monde Arduino. Le tableau suivant compare les principales caractéristiques des deux appareils :
Dans les deux sections suivantes, nous examinons rapidement le M1 et le M2 individuellement. Pour une comparaison plus détaillée, consultez la comparaison de M1 & M2 sur le site Elecrow.
ThinkNode M1
Comme mentionné plus haut, le ThinkNode M1 utilise le nRF52840 comme processeur principal. Il possède une puce SX1262 pour la communication LoRa, une batterie rechargeable de 1200mAh , un écran EPD de 1,54 pouce avec rétroéclairage, un petit buzzer et un module GPS intégré. La photo ci-dessous montre l’appareil :
La charge se fait via un port USB Type-C et l’appareil peut être configuré avec l’application Meshtastic, qui communique avec l’appareil via Bluetooth. L’application permet aussi le partage de cartes et de localisation, la surveillance du réseau, l’exportation de données et plus encore. Pour plus d’informations, consultez le Radio Configuration Website.
Tous les détails techniques du ThinkNode M1 se trouvent dans le ThinkNode M1 Datasheet et pour des informations d’utilisation générale, voir le ThinkNode M1 Manual.
ThinkNode M2
Le ThinkNode M2 utilise le ESP32-S3 comme processeur principal, qui est plus puissant que le nRF52840. En raison du processeur et de la batterie plus petite de 1000mAh, l’autonomie est cependant plus courte. De plus, le M2 utilise un écran OLED de 1,3 pouce, qui consomme également plus d’énergie. La photo ci-dessous montre le ThinkNode M2 :
Notez que le M2 ne possède pas le module GPS du M1 mais utilise le même logiciel et est également configuré avec l’application Meshtastic.
Tous les détails techniques du ThinkNode M2 se trouvent dans le ThinkNode M2 Datasheet et pour des informations d’utilisation générale, voir le ThinkNode M2 Manual.
Connexion des capteurs à un nœud Meshtastic
Le firmware Meshtastic supporte des capteurs simples, appelés Detection Sensors connectés à des broches GPIO spécifiées ou une sélection de capteurs Complex sensors connectés via I2C et configurés dans le Telemetry Module. Cette sélection de capteurs inclut le capteur environnemental BM680 que je souhaite utiliser dans ce tutoriel.
Malheureusement, bien que le module ThinkNode M2 expose quelques broches GPIO, il n’expose pas les broches pour I2C – du moins pas à ma connaissance. Selon le Datasheet, ce devraient être IO15_SCL et IO16_SDA mais elles n’apparaissent pas dans la table des broches GPIO disponibles :
Notez que les broches GPIO ne sont pas accessibles de l’extérieur. Vous devez soit ouvrir le boîtier du ThinkNode M2, soit obtenir le module nu (sans boîtier). La photo ci-dessous montre le devant et le dos du module ThinkNode M2 nu :
Alors, comment connecter un capteur environnemental BM680 à un ThinkNode M2 ? Nous pourrions modifier le firmware Meshtastic pour configurer des broches I2C supplémentaires ou différentes, mais ce ne serait pas simple.
Alternativement, si nous pouvions programmer l’ESP32-lite pour envoyer des messages en utilisant le protocole Meshtastic, nous n’aurions alors pas besoin du ThinkNode M2. Mais je n’ai pas trouvé de bibliothèque permettant de faire cela.
Il nous reste donc la troisième option, qui semble être la méthode courante pour résoudre ce problème. Nous configurons le ThinkNode M2 pour qu’il relaie les messages texte envoyés via l’interface série (UART).
Cela signifie cependant que nous avons besoin d’un microcontrôleur supplémentaire, ici un ESP32-lite. L’ESP32-lite est connecté au BME680 pour traiter ses données et les envoie sous forme de message texte via l’interface série au ThinkNode M2. C’est la méthode que nous allons utiliser pour construire une grille IoT simple comme décrit dans la section suivante.
Construire une grille IoT avec les ThinkNodes
Notre petite grille de capteurs IoT est composée d’un ESP32-lite avec un capteur BME680 attaché, d’un ThinkNode M2 qui envoie les données environnementales, et d’un ThinkNode M1 qui reçoit et affiche les données. L’image suivante montre l’architecture du système :
Le capteur BME680 connecté à un ESP32-lite mesure la température, l’humidité et la pression. L’ESP32-lite communique avec un ThinkNode M2 via l’interface série (UART).
Les données environnementales du BME680 sont envoyées sous forme de messages texte de l’ESP32-lite au ThinkNode M2. Le ThinkNode M2 transmet ensuite ces données sans fil via LoRa au ThinkNode M1, qui les affiche sur son écran.
Connexion de l’ESP32-lite au ThinkNode M2 via UART
J’ai le ThinkNode M2 avec le boîtier et bien qu’il soit facile d’ouvrir le boîtier (il suffit de retirer les quatre vis à l’arrière), la carte électronique semble collée. Je n’ai pas pu retirer le module sans risquer de le casser.
Ce qui signifie que je n’ai pas pu souder un connecteur à broches sur les trous GPIO de la carte comme prévu. À la place, j’ai connecté des fils avec des pinces aux broches IO18, IO19 et GND comme montré sur la photo ci-dessous :
Ces fils, je les ai ensuite connectés à l’ESP32-lite comme indiqué dans le schéma de câblage ci-dessous :
La broche IO17 de l’ESP32 est connectée à IO18 du M2, et IO16 de l’ESP32 est connectée à IO19 du M2. Avec ce câblage, nous pouvons établir une communication série (UART) entre l’ESP32-lite et le ThinkNode M2.
Connexion de l’ESP32-lite avec BME680 au ThinkNode M2
Ensuite, nous devons connecter le BME680 à l’ESP32-lite. La photo ci-dessous montre le câblage complet du BME680 avec l’ESP32-lite et le ThinkNode M2 :
Le BME680 supporte l’I2C et est donc connecté aux broches I2C par défaut (SDA=19, SCL=23) de l’ESP32-lite. Nous devons aussi connecter l’alimentation (3,3V et masse). Si vous avez besoin de plus d’informations sur le BME680, consultez le BME680 Environmental Sensor with Arduino, le Measure Air Quality with BME680 et les Send Environmental Data with LoRa tutoriels.
La photo suivante montre le câblage complet sur une breadboard incluant le ThinkNode M2 et le ThinkNode M1 :
Configuration des ThinkNode M1 et M2
Avant de pouvoir envoyer des données entre les deux ThinkNodes, nous devons les configurer. Plus précisément, il faut régler la fréquence LoRa et s’assurer qu’elle est la même pour les deux nœuds.
Pour configurer un ThinkNode, ouvrez l’application Meshtastic sur votre téléphone, connectez-la via Bluetooth au ThinkNode (vous recevrez un code), puis cliquez sur les trois points en haut à gauche pour ouvrir le menu. Voir le Wiki for the ThinkNode M1 et le Wiki for the ThinkNode M2 si vous avez besoin d’informations plus détaillées.
Configuration de la fréquence LoRa
Dans le menu, sélectionnez « Radio configuration » puis « LoRa », ce qui ouvrira la page « LoRa Config » :
Là, vous pouvez définir la région avec une fréquence associée. Vous devez sélectionner votre région/pays et faire de même pour les deux ThinkNodes M1 et M2, sinon ils ne pourront pas communiquer !
Notez que les fréquences LoRa autorisées dépendent du pays (frequencies). C’est 868MHz pour l’Europe, 915MHz pour l’Amérique du Nord et 433MHz pour l’Asie. Comme je vis en Europe, j’ai sélectionné « Union Européenne 868MHz » comme région/fréquence dans la capture d’écran ci-dessus.
Si vous avez des problèmes avec la configuration, de nombreux tutoriels peuvent vous aider. Par exemple, consultez le ThinkNode M1/M2 Review – Getting started with Meshtastic tutoriel. Ou le Meshtastic Configuration info.
Une fois configuré, vous devriez vérifier que vous pouvez envoyer des messages texte du ThinkNode M2 au ThinkNode M1. Si cela fonctionne, nous pouvons alors configurer l’interface série du ThinkNode M2.
Configuration de l’interface série
Nous voulons connecter l’ESP32-lite via l’interface série au ThinkNode M2. Cela nécessite une configuration supplémentaire du ThinkNode M2.
Ouvrez le menu en cliquant sur les trois points (comme précédemment). Sélectionnez « Radio Configuration » puis « Serial ». Cela ouvrira la page « Serial Config » comme montré ci-dessous :
Activez « Serial enabled » et définissez les broches GPIO pour la communication série (RX et TX). J’ai choisi RX=18 et TX=19. Réglez le débit en bauds à 115200 et le mode sur « TEXTMSG ». Ce mode indique au ThinkNode de relayer/transmettre tout texte reçu via l’interface série.
Et avec cela, nous sommes enfin prêts à écrire un peu de code qui nous permettra de transmettre des données.
Envoyer des données via ThinkNode M2 vers M1
Nous commençons par un code de test simple qui crée un compteur en cours d’exécution sur l’ESP32-lite, envoyé via communication série au ThinkNode M2, qui le transmet ensuite via LoRa au ThinkNode M1. Voici le code pour l’ESP32-lite :
#define TX_PIN 17 // ESP32 TX -> M2 RX 18
#define RX_PIN 16 // ESP32 RX <- M2 TX 19
#define BAUD_RATE 115200
#define SEND_PERIOD (60 * 1000)
HardwareSerial serial2(2);
void setup() {
Serial.begin(115200);
serial2.begin(BAUD_RATE, SERIAL_8N1, RX_PIN, TX_PIN);
}
void loop() {
static int cnt = 0;
static char msg[128];
sprintf(msg, "counter=%d", cnt++);
serial2.println(msg); // Sending to ThinkNode M2
Serial.println(msg);
delay(SEND_PERIOD);
}
Téléversez ce code sur l’ESP32-lite, allumez les ThinkNode M1 et M2 et vous devriez recevoir toutes les minutes un message texte « counter=… » sur le ThinkNode M1.
Examinons de plus près le code. Nous commençons par définir les broches pour l’interface série et les constantes pour le débit en bauds et le temps entre les transmissions (60 secondes) :
#define TX_PIN 17 // ESP32 TX -> M2 RX 18 #define RX_PIN 16 // ESP32 RX <- M2 TX 19 #define BAUD_RATE 115200 #define SEND_PERIOD (60 * 1000)
Vous devez choisir des broches pour la communication série supportées par votre microcontrôleur. Dans le cas de l’ESP32-lite, il y a trois interfaces série matérielles (0,1,2) et j’utilise la troisième :
HardwareSerial serial2(2);
Dans la fonction setup, nous démarrons la communication série vers le moniteur série pour le débogage et la communication série vers le ThinkNode M2, avec les broches et le débit en bauds définis :
void setup() {
Serial.begin(115200);
serial2.begin(BAUD_RATE, SERIAL_8N1, RX_PIN, TX_PIN);
}
Pour la fonction loop : nous incrémentons un compteur, créons un message texte avec la valeur du compteur, l’affichons sur le moniteur série et l’envoyons aussi via l’interface série au ThinkNode M2. Le délai à la fin garantit que cela se produit toutes les minutes :
void loop() {
static int cnt = 0;
static char msg[128];
sprintf(msg, "counter=%d", cnt++);
serial2.println(msg); // Sending to M2
Serial.println(msg);
delay(SEND_PERIOD);
}
Sur l’écran du ThinkNode M1, vous devriez alors voir le compteur :
Notez que vous devrez peut-être appuyer sur le bouton Fonction pour que l’écran se mette à jour. Si cela fonctionne, nous pouvons passer à l’envoi de données réelles.
Code pour envoyer des données environnementales
Le code suivant lit des données environnementales telles que la température, l’humidité et la pression du capteur BME680 et les envoie au ThinkNode M2, qui les relaie ensuite au ThinkNode M1 :
#include "Adafruit_BME680.h"
#define SEALEVELPRESSURE_HPA (1013.25)
#define TX_PIN 17 // ESP32 TX -> M2 RX 18
#define RX_PIN 16 // ESP32 RX <- M2 TX 19
#define BAUD_RATE 115200
#define SEND_PERIOD (60 * 1000)
HardwareSerial serial2(2);
Adafruit_BME680 bme;
void setup() {
Serial.begin(115200);
serial2.begin(BAUD_RATE, SERIAL_8N1, RX_PIN, TX_PIN);
bme.begin();
bme.setTemperatureOversampling(BME680_OS_8X);
bme.setHumidityOversampling(BME680_OS_2X);
bme.setPressureOversampling(BME680_OS_4X);
bme.setIIRFilterSize(BME680_FILTER_SIZE_3);
bme.setGasHeater(320, 150); // 320*C for 150 ms
}
void loop() {
static char msg[128];
if (bme.performReading()) {
sprintf(msg, "temperature: %.0f C\nhumidity: %.1f %%\npressure: %.0f hPa\n",
bme.temperature, bme.humidity, bme.pressure/100.0);
serial2.println(msg); // Sending to ThinkNode M2
Serial.println(msg);
delay(SEND_PERIOD);
}
}
Le code est une simple extension du code précédent. Nous ajoutons juste l’initialisation du BME680 dans la fonction setup :
void setup() {
...
bme.begin();
bme.setTemperatureOversampling(BME680_OS_8X);
bme.setHumidityOversampling(BME680_OS_2X);
bme.setPressureOversampling(BME680_OS_4X);
bme.setIIRFilterSize(BME680_FILTER_SIZE_3);
bme.setGasHeater(320, 150); // 320*C for 150 ms
}
et créons le message texte à partir des mesures du BME680 dans la fonction loop lorsque les mesures sont disponibles :
void loop() {
...
if (bme.performReading()) {
sprintf(msg, "temperature: %.0f C\nhumidity: %.1f %%\npressure: %.0f hPa\n",
bme.temperature, bme.humidity, bme.pressure/100.0);
serial2.println(msg); // Sending to ThinkNode M2
...
}
}
Notez que vous devrez avoir la bibliothèque Adafruit BME680 installée. Elle fournit toutes les fonctions essentielles pour contrôler le capteur BME680.
Si vous souhaitez en savoir plus sur le BME680 et le code correspondant, consultez les tutoriels BME680 Environmental Sensor with Arduino, Measure Air Quality with BME680 et Send Environmental Data with LoRa.
Sur l’écran du ThinkNode M1, vous devriez maintenant recevoir les données environnementales suivantes :
Et voilà. Vous avez maintenant une petite grille de capteurs IoT Meshtastic avec un capteur BME680 et les ThinkNodes M1 et M2 comme nœuds Meshtastic. Vous pouvez facilement étendre la portée et les fonctions de ce réseau en ajoutant plus de nœuds ou de capteurs Meshtastic.
Conclusions et commentaires
Dans cet article, vous avez appris à construire une petite grille de capteurs IoT avec un capteur BME680 et les ThinkNodes M1 et M2 Meshtastic.
Le maillage Meshtastic vous permet d’envoyer des données de capteurs sur de plus longues distances que LoRa seul et ne nécessite pas de Wi-Fi ou d’infrastructure similaire. Cependant, il nécessite d’autres nœuds Meshtastic à proximité capables de relayer les données. En juillet 2025, le nombre de nœuds Meshtastic dans la plupart des zones n’est pas encore suffisant pour assurer une couverture complète. Voir le Meshmap.
Entre le M1 et le M2, j’ai atteint une distance d’environ 200 à 300 mètres avant que les appareils ne perdent la connexion. Pour un test de portée détaillé et une comparaison, lisez le post ThinkNode M1/M2 Review – Getting started with Meshtastic de Jean-Luc Aufranc.
Si vous souhaitez transmettre des données de capteurs sur quelques centaines de mètres, il est préférable d’utiliser simplement LoRa brut. Ce sera plus simple et vous offrira plus de flexibilité. Voir le tutoriel Send Environmental Data with LoRa pour apprendre comment faire.
Pour une portée plus grande ou des configurations avec de nombreux capteurs devant envoyer des mesures à Internet, LoRaWAN est une autre option. Voir le tutoriel LoRaWAN with Thinknode G1 Gateway pour plus d’informations sur ce sujet. Et si vous voulez juste transmettre des informations via Internet, le tutoriel ESP32 send Telegram Message pourrait être utile.
Malgré ses limitations actuelles et sa couverture relativement faible, Meshtastic est une technologie amusante à explorer et la communauté grandit. Je vous recommande vivement de lire plus About Meshtastic.
Si vous avez des questions, n’hésitez pas à les laisser dans la section commentaires.
Bon bricolage ; )
