Wie man ein einfaches IoT-Sensornetz mit dem ThinkNode aufbaut mit den M1 & M2 Meshtastic Geräten von Elecrow.

Die M1 und M2 sind kleine LoRa-Transceiver, mit denen du Textnachrichten über ein Meshtastic Mesh-Netzwerk senden kannst. Häufige Anwendungen sind Kommunikation in abgelegenen Gebieten ohne Wi-Fi-Abdeckung, Notfallsituationen, wenn die Kommunikationsinfrastruktur ausgefallen ist, oder IoT-Sensornetzwerke.

In diesem Tutorial zeige ich dir, wie du Umweltdaten wie Temperatur, Luftfeuchtigkeit und Druck von einem ThinkNode M2 zu einem ThinkNode M1 sendest – im Grunde baust du damit ein kleines IoT-Sensornetz auf.

Was ist Meshtastic?

Meshtastic ist ein Open-Source-Projekt, das LoRa-Radios nutzt, um dezentrale Mesh-Netzwerke zu bilden, mit dem Ziel, Textnachrichten zu übertragen. Nachrichten werden automatisch von einem Knoten zum nächsten weitergeleitet, sodass Kommunikation über große Entfernungen ohne zentrale Infrastruktur wie Wi-Fi möglich ist.

Da Meshtastic auf LoRa basiert, einem lizenzfreien Frequenzband, benötigst du keine Lizenz zur Nutzung, und Meshtastic-Geräte sind in der Regel günstig. Siehe das Long range communication with LoRa SX1276 and ESP32Tutorial, um mehr über LoRa zu erfahren.

Der Hauptnachteil von LoRa ist, dass nur kleine Datenmengen (Textnachrichten) übertragen werden können. Außerdem sind große Entfernungen nur erreichbar, wenn das Gebiet mit ausreichend vielen, nah beieinander liegenden Meshtastic-Knoten abgedeckt ist, die Nachrichten weiterleiten können.

Meshtastic versus LoRaWAN

Wenn du LoRa kennst, hast du vielleicht auch von LoRaWAN gehört. Meshtastic und LoRaWAN sind beide Technologien, die LoRa-Radios nutzen, aber sie haben unterschiedliche Architekturen und Zwecke. 

LoRaWAN ist ein Low-Power-Wide-Area-Network-Protokoll, das für langreichweitige, bandbreitenarme Kommunikation entwickelt wurde und Geräte typischerweise über Gateways mit dem Internet verbindet. Siehe unser LoRaWAN with Thinknode G1 Gateway Tutorial. Meshtastic hingegen erstellt dezentrale, Ad-hoc-Mesh-Netzwerke, die es Geräten ermöglichen, direkt miteinander zu kommunizieren, ohne auf Infrastruktur wie Gateways angewiesen zu sein. 

LoRaWAN verwendet eine Stern-von-Stern-Topologie, bei der Endgeräte über Gateways mit einem zentralen Server kommunizieren. Meshtastic bildet ein Mesh-Netzwerk, in dem Geräte Nachrichten untereinander weiterleiten und so ein dezentrales, selbstheilendes Netzwerk schaffen. 

LoRaWAN eignet sich für großflächige IoT-Anwendungen wie Smart Cities und Umweltüberwachung, bei denen Geräte Daten an einen zentralen Server senden müssen. Meshtastic ist besser geeignet für Off-Grid-Kommunikation, Notfallsituationen oder Situationen mit begrenzter Infrastruktur, etwa in abgelegenen Gebieten oder bei Katastrophen. 

Was sind ThinkNode M1 & M2

Die ThinkNode M1 & M2 und ähnliche Meshtastic-Geräte sind im Grunde wie Walkie-Talkies, aber für Textnachrichten. Sie enthalten einen LoRa-Transceiver und nutzen das Meshtastic-Protokoll, um Daten zwischen Geräten/Knoten zu übertragen. Das Bild unten zeigt den ThinkNode M1:

Du wirst feststellen, dass das Gerät nur einen Bildschirm, aber keine Tastatur hat. Um Nachrichten zu senden, musst du die Meshtastic App auf deinem Handy installieren und es per Bluetooth mit dem ThinkNode verbinden. Dann kannst du Nachrichten auf deinem Handy tippen, die vom ThinkNode über das LoRa/Meshtastic-Netzwerk an andere Meshtastic-Geräte gesendet werden.

Beachte, dass es auch andere Meshtastic devices mit integrierter Tastatur oder Touchscreen gibt, die die Meshtastic UI App direkt auf dem Gerät ausführen. In diesem Fall benötigst du kein zusätzliches Handy, um Nachrichten zu senden.

Vergleich ThinkNode M1 & M2

Meshtastic-Geräte basieren entweder auf dem nRF52 oder dem ESP32 als Mikrocontroller. Geräte mit nRF52 verbrauchen weniger Strom und eignen sich besser für solarbetriebene oder Handheld-Anwendungen. ESP32-Geräte bieten dagegen mehr Rechenleistung, Wi-Fi-Konnektivität und sind günstiger.

Und das ist auch der Hauptunterschied zwischen ThinkNode M1 & M2. Der M1 basiert auf dem nRF52840-Prozessor und ist für längere Laufzeit ausgelegt dank größerem Akku und E-Ink-Display. Der M2 nutzt den leistungsstärkeren ESP32-S3 als Mikrocontroller und ist generell leichter zu programmieren/anpassen, wenn du aus der Arduino-Welt kommst. Die folgende Tabelle vergleicht die Hauptmerkmale der beiden Geräte:

In den nächsten zwei Abschnitten schauen wir uns M1 und M2 einzeln an. Für einen detaillierteren Vergleich siehe den Vergleich der M1 & M2 Geräte auf der Elecrow-Website.

ThinkNode M1

Wie oben erwähnt, verwendet der ThinkNode M1den nRF52840 als Hauptprozessor. Er hat einen SX1262-Chip für LoRa-Kommunikation, einen 1200mAh wiederaufladbaren Akku, ein 1,54-Zoll-EPD-Display mit Hintergrundbeleuchtung, einen kleinen Summer und ein eingebautes GPS-Modul. Das Bild unten zeigt das Gerät:

Das Laden erfolgt über einen USB-Typ-C-Anschluss, und das Gerät kann mit der Meshtastic App konfiguriert werden, die per Bluetooth mit dem Gerät kommuniziert. Die App ermöglicht auch Karten- und Standortfreigabe, Netzwerkstatusüberwachung, Datenexport und mehr. Für weitere Informationen siehe das Radio Configuration Website.

Alle technischen Details des ThinkNode M1 findest du im ThinkNode M1 Datasheet und für allgemeine Nutzungshinweise siehe das ThinkNode M1 Manual.

ThinkNode M2

Der ThinkNode M2verwendet den ESP32-S3 als Hauptprozessor, der leistungsstärker ist als der nRF52840. Aufgrund des Prozessors und des kleineren 1000mAh-Akkus ist die Laufzeit jedoch kürzer. Außerdem nutzt der M2 ein 1,3-Zoll-OLED-Display, das ebenfalls mehr Strom verbraucht. Das Foto unten zeigt den ThinkNode M2:

Beachte, dass der M2 das GPS-Modul des M1 nicht hat, aber dieselbe Software nutzt und ebenfalls mit der Meshtastic App konfiguriert wird.

Alle technischen Details des ThinkNode M2 findest du im ThinkNode M2 Datasheet und für allgemeine Nutzungshinweise siehe das ThinkNode M2 Manual.

Sensoren an einen Meshtastic-Knoten anschließen

Die Meshtastic-Firmware unterstützt einfache, sogenannte Detection Sensors Sensoren, die an bestimmte GPIO-Pins angeschlossen sind, oder eine Auswahl von Complex sensorsSensoren, die über I2C verbunden und in der Telemetry Module konfiguriert werden. Diese Auswahl an Sensoren umfasst den BM680 Umweltsensor, den ich in diesem Tutorial verwenden möchte.

Leider gibt das ThinkNode M2-Modul zwar einige GPIO-Pins frei, aber keine Pins für I2C – zumindest habe ich keine gefunden. Laut Datasheet sollten das IO15_SCL und IO16_SDA sein, aber sie tauchen nicht in der Tabelle der verfügbaren GPIO-Pins auf:

Beachte, dass GPIO-Pins von außen nicht zugänglich sind. Du musst entweder das Gehäuse des ThinkNode M2 öffnen oder das nackte Modul (ohne Gehäuse) verwenden. Das Bild unten zeigt Vorder- und Rückseite des nackten ThinkNode M2-Moduls:

Wie also einen BM680 Umweltsensor an einen ThinkNode M2 anschließen? Wir könnten die Meshtastic-Firmware modifizieren, um andere oder zusätzliche I2C-Pins zu konfigurieren, aber das wäre nicht einfach.

Alternativ könnten wir den ESP32-lite so programmieren, dass er Nachrichten mit dem Meshtastic-Protokoll sendet, dann bräuchten wir den ThinkNode M2 nicht. Aber ich habe keine Bibliothek gefunden, die das ermöglicht.

Bleibt also die dritte Option, die auch der übliche Weg zu sein scheint: Wir konfigurieren den ThinkNode M2 so, dass er Textnachrichten, die über die serielle Schnittstelle (UART) gesendet werden, weiterleitet.

Das bedeutet allerdings, dass wir einen zusätzlichen Mikrocontroller brauchen, hier einen ESP32-lite. Der ESP32-lite ist mit dem BME680 verbunden, verarbeitet dessen Daten und sendet sie als Textnachricht über die serielle Schnittstelle an den ThinkNode M2. Diese Methode verwenden wir, um ein einfaches IoT-Netz aufzubauen, wie im nächsten Abschnitt beschrieben.

Ein IoT-Netz mit ThinkNodes aufbauen

Unser kleines IoT-Sensornetz besteht aus einem ESP32-lite mit angeschlossenem BME680-Sensor, einem ThinkNode M2, der Umweltdaten sendet, und einem ThinkNode M1, der die Daten empfängt und anzeigt. Das folgende Bild zeigt die Systemarchitektur:

Der BME680-Sensor, verbunden mit dem ESP32-lite, misst Temperatur, Luftfeuchtigkeit und Druck. Der ESP32-lite kommuniziert über die serielle Schnittstelle (UART) mit dem ThinkNode M2.

Umweltdaten vom BME680 werden als Textnachrichten vom ESP32-lite an den ThinkNode M2 gesendet. Der ThinkNode M2 überträgt diese Daten dann drahtlos via LoRa an den ThinkNode M1, der sie auf seinem Bildschirm anzeigt.

ESP32-lite mit ThinkNode M2 via UART verbinden

Ich habe den ThinkNode M2 mit Gehäuse und obwohl das Gehäuse leicht zu öffnen ist (einfach die vier Schrauben hinten entfernen), scheint die eigentliche Platine verklebt zu sein. Ich konnte das Modul nicht entfernen, ohne es zu beschädigen.

Das bedeutet, ich konnte keinen Pin-Header an die GPIO-Löcher auf der Platine löten, wie geplant. Stattdessen habe ich Drähte mit Clips an IO18, IO19 und GND angeschlossen, wie auf dem Foto unten zu sehen ist:

Diese Drähte habe ich dann wie im Schaltplan unten gezeigt mit dem ESP32-lite verbunden:

IO17 des ESP32 ist mit IO18 des M2 verbunden, und IO16 des ESP32 mit IO19 des M2. Mit dieser Verkabelung können wir eine serielle Kommunikation (UART) zwischen ESP32-lite und ThinkNode M2 herstellen.

ESP32-lite mit BME680 an ThinkNode M2 anschließen

Als nächstes müssen wir den BME680 mit dem ESP32-lite verbinden. Das Bild unten zeigt die komplette Verkabelung von BME680 mit ESP32-lite und ThinkNode M2:

Der BME680 unterstützt I2C und ist daher an die Standard-I2C-Pins (SDA=19, SCL=23) des ESP32-lite angeschlossen. Außerdem müssen wir die Stromversorgung (3,3V und Masse) anschließen. Wenn du mehr Informationen zum BME680 brauchst, schau dir das BME680 Environmental Sensor with Arduino, das Measure Air Quality with BME680 und das Send Environmental Data with LoRa Tutorial an.

Das folgende Foto zeigt die komplette Verkabelung auf einem Breadboard inklusive ThinkNode M2 und ThinkNode M1:

ThinkNode M1 und M2 konfigurieren

Bevor wir Daten zwischen den beiden ThinkNodes senden können, müssen wir sie konfigurieren. Insbesondere müssen wir die LoRa-Frequenz einstellen und sicherstellen, dass sie bei beiden Knoten gleich ist.

Um einen ThinkNode zu konfigurieren, öffne die Meshtastic App auf deinem Handy, verbinde sie per Bluetooth mit dem ThinkNode (du erhältst einen Code) und klicke dann oben links auf die drei Punkte, um das Menü zu öffnen. Siehe das Wiki for the ThinkNode M1 und das Wiki for the ThinkNode M2für detailliertere Informationen.

LoRa-Frequenz konfigurieren

Im Menü wähle „Radio configuration“ und dann „LoRa“, was die Seite „LoRa Config“ öffnet:

Dort kannst du die Region mit der zugehörigen Frequenz einstellen. Du musst deine Region/Land auswählen und das bei beiden ThinkNodes M1 und M2 gleich einstellen, sonst können sie nicht kommunizieren!

Beachte, dass die erlaubten LoRa-Frequenzen vom Land abhängen (frequencies). Für Europa sind es 868 MHz, für Nordamerika 915 MHz und für Asien 433 MHz. Da ich in Europa lebe, habe ich im Screenshot „European Union 868MHz“ als Region/Frequenz gewählt.

Wenn du Probleme mit der Konfiguration hast, gibt es viele Tutorials, die beim Setup helfen. Zum Beispiel das ThinkNode M1/M2 Review – Getting started with MeshtasticTutorial oder das Meshtastic Configuration info.

Nach der Konfiguration solltest du überprüfen, ob du Textnachrichten vom ThinkNode M2 zum ThinkNode M1 senden kannst. Wenn das funktioniert, können wir die serielle Schnittstelle des ThinkNode M2 konfigurieren.

Serielle Schnittstelle konfigurieren

Wir wollen den ESP32-lite über die serielle Schnittstelle mit dem ThinkNode M2 verbinden. Das erfordert eine zusätzliche Konfiguration des ThinkNode M2.

Öffne das Menü über die drei Punkte (wie zuvor). Wähle „Radio Configuration“ und dann „Serial“. Das öffnet die Seite „Serial Config“, wie unten gezeigt:

Schalte „Serial enabled“ ein und setze die GPIO-Pins für die serielle Kommunikation (RX und TX). Ich habe RX=18 und TX=19 gewählt. Setze die Baudrate auf 115200 und den Modus auf „TEXTMSG“. Dieser Modus sagt dem ThinkNode, alle über die serielle Schnittstelle empfangenen Texte weiterzuleiten/zu übertragen.

Damit sind wir endlich bereit, etwas Code zu schreiben, der uns erlaubt, Daten zu übertragen.

Daten vom ThinkNode M2 zum M1 senden

Wir starten mit einem einfachen Testcode, der auf dem ESP32-lite einen laufenden Zähler erzeugt, der per serieller Kommunikation an den ThinkNode M2 gesendet wird, der ihn dann via LoRa an den ThinkNode M1 überträgt. Unten ist der Code für den 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);
}

Lade diesen Code auf den ESP32-lite, schalte ThinkNode M1 und M2 ein, und du solltest jede Minute eine Textnachricht „counter=…“ auf dem ThinkNode M1 erhalten.

Schauen wir uns den Code genauer an. Wir beginnen mit der Definition der Pins für die serielle Schnittstelle und Konstanten für Baudrate und Zeit zwischen den Übertragungen (60 Sekunden):

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

Du solltest Pins für die serielle Kommunikation wählen, die von deinem Mikrocontroller unterstützt werden. Beim ESP32-lite gibt es drei serielle Hardware-Schnittstellen (0,1,2), ich nutze die dritte:

HardwareSerial serial2(2);

In der setup-Funktion starten wir die serielle Kommunikation zum Serial Monitor für Debugging und die serielle Kommunikation zum ThinkNode M2 mit den definierten Pins und der Baudrate:

void setup() {
  Serial.begin(115200);
  serial2.begin(BAUD_RATE, SERIAL_8N1, RX_PIN, TX_PIN);
}

In der loop-Funktion erhöhen wir einen Zähler, erstellen eine Textnachricht mit dem Zählerwert, geben sie im Serial Monitor aus und senden sie auch über die serielle Schnittstelle an den ThinkNode M2. Die Verzögerung am Ende sorgt dafür, dass das jede Minute passiert:

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

Auf dem Display des ThinkNode M1 solltest du dann den Zähler sehen:

Beachte, dass du eventuell die Funktionstaste drücken musst, damit das Display aktualisiert wird. Wenn das funktioniert, können wir echte Daten senden.

Code zum Senden von Umweltdaten

Der folgende Code liest Umweltdaten wie Temperatur, Luftfeuchtigkeit und Druck vom BME680-Sensor und sendet sie an den ThinkNode M2, der sie wiederum an den ThinkNode M1 weiterleitet:

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

Der Code ist eine einfache Erweiterung des vorherigen Codes. Wir fügen nur die Initialisierung des BME680 in die setup Funktion ein:

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
}

und erstellen die Textnachricht aus den BME680-Messwerten in der loopFunktion, wenn Messwerte vorliegen:

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

Beachte, dass du die Adafruit BME680 Bibliothek installiert haben musst. Sie stellt alle wichtigen Funktionen zur Steuerung des BME680-Sensors bereit.

Wenn du mehr über den BME680 und den entsprechenden Code erfahren möchtest, sieh dir die BME680 Environmental Sensor with Arduino, das Measure Air Quality with BME680 und das Send Environmental Data with LoRaTutorial an.

Auf dem Display des ThinkNode M1 solltest du nun folgende Umweltdaten sehen:

Und das war’s. Du hast jetzt ein kleines Meshtastic IoT-Sensornetz mit einem BME680-Sensor und den ThinkNodes M1 und M2 als Meshtastic-Knoten. Du kannst die Reichweite und Funktionalität dieses Netzwerks leicht erweitern, indem du weitere Meshtastic-Knoten oder Sensoren hinzufügst.

Fazit und Kommentare

In diesem Artikel hast du gelernt, wie man ein kleines IoT-Sensornetz mit einem BME680-Sensor und den M1- und M2-Meshtastic-ThinkNodes aufbaut.

Das Meshtastic-Mesh ermöglicht es, Sensordaten über größere Entfernungen als LoRa allein zu senden und benötigt keine Wi-Fi- oder ähnliche Kommunikationsinfrastruktur. Allerdings sind andere Meshtastic-Knoten in der Nähe nötig, die Daten weiterleiten können. Stand Juli 2025 ist die Anzahl der Meshtastic-Knoten in den meisten Gebieten noch nicht hoch genug für eine vollständige Abdeckung. Siehe das Meshmap.

Zwischen M1 und M2 erreichte ich eine Entfernung von etwa 200 bis 300 Metern, bevor die Verbindung abbrach. Für einen detaillierten Reichweitentest und Vergleich lies den ThinkNode M1/M2 Review – Getting started with Meshtastic Beitrag von Jean-Luc Aufranc.

Wenn du Sensordaten über einige hundert Meter übertragen willst, bist du mit reinem LoRa besser beraten. Es ist einfacher und bietet mehr Flexibilität. Siehe das Send Environmental Data with LoRa Tutorial dazu.

Für größere Reichweiten oder Setups mit vielen Sensoren, die Messwerte ins Internet senden müssen, ist LoRaWAN eine weitere Option. Siehe das LoRaWAN with Thinknode G1 Gateway Tutorial für mehr Informationen. Und wenn du nur Informationen über das Internet übertragen willst, könnte das ESP32 send Telegram Message Tutorial hilfreich sein.

Trotz seiner aktuellen Einschränkungen und vergleichsweise kleinen Abdeckung ist Meshtastic eine spaßige Technologie zum Ausprobieren, und die Community wächst. Ich empfehle dir dringend, mehr About Meshtastic zu lesen.

Wenn du Fragen hast, hinterlasse sie gerne im Kommentarbereich.

Viel Spaß beim Tüfteln ; )