Meshtastic ist ein Open-Source-Projekt, das die Möglichkeit bietet, dezentrale Funknetzwerke aufzubauen – und das mit kostengünstiger IoT-Hardware wie ESP32-Boards. Die Kommunikation erfolgt abseits der üblichen Mobilfunknetze und nutzt stattdessen Frequenzen im Bereich von 433 MHz oder 868 MHz, die in Deutschland frei verwendet werden können. Dies eröffnet zahlreiche Anwendungsmöglichkeiten, sei es für private Chats, Sensordaten oder spezielle Szenarien, in denen herkömmliche Netze nicht verfügbar sind.
Das Projekt basiert auf der LoRa-Technologie (Long Range), die speziell für die Übertragung kurzer Nachrichten bei minimalem Energieverbrauch über große Distanzen entwickelt wurde. Wie der Name „Meshtastic“ schon andeutet, wird dabei ein sogenanntes Mesh-Netzwerk aufgebaut. In diesem schließen sich die Teilnehmer automatisch zusammen, um Datenpakete weiterzuleiten. Dies ermöglicht eine deutliche Erweiterung der Reichweite – vorausgesetzt, in der Umgebung sind ausreichend viele Nutzer aktiv.
Praktische Einsatzmöglichkeiten gibt es viele: Von der Überwachung der Garage, über das Übermitteln von Wetterdaten, bis hin zur Benachrichtigung, wenn die Waschmaschine fertig ist. Unter optimalen Bedingungen wurden sogar Reichweiten von bis zu 331 Kilometern erzielt, in städtischen Gebieten ist da mit „etwas“ weniger zu rechnen.
In meinem aktuellen Video teste ich die Reichweite von Meshtastic unter verschiedenen Bedingungen und Standorten. Dabei nutze ich ein einfaches Setup mit günstigen Komponenten, um zu sehen, was unter realistischen Bedingungen möglich ist. Das Ergebnis und weitere Eindrücke findet ihr im Video. Schaut gerne vorbei, um mehr über Meshtastic zu erfahren und einen Blick auf die Testergebnisse zu werfen!
Telegram Proxy
Für den Test habe ich mir ein kleines Script geschrieben, welches die API des Meshtastic Webinterfaces nutzt. Empfangene Nachrichten werden von folgendem Script abgerufen und dann an meinen Telegram-Bot weitergeleitet. Somit kann ich direkt sehen, ob eine Nachricht empfangen wurde oder nicht. Falls Interesse besteht mit dem Script zu experimentieren, hier ist es:
import requests
import time
from meshtastic import mesh_pb2 # Meshtastic Protobuf-Dateien nutzen
# Meshtastic HTTP-API-Konfiguration
MESHTASTIC_IP = "192.168.178.98" # IP-Adresse des Meshtastic-Geräts
FROM_RADIO_URL = f"http://{MESHTASTIC_IP}/api/v1/fromradio"
SEND_URL = f"http://{MESHTASTIC_IP}/api/v1/send"
# Telegram-Konfiguration
BOT_TOKEN = "abc..." # Telegram-Bot Token
CHAT_ID = "123..." # Telegram Chat ID
TELEGRAM_URL = f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage"
# Funktion: Nachricht an Telegram senden
def send_to_telegram(message):
try:
response = requests.post(
TELEGRAM_URL, data={"chat_id": CHAT_ID, "text": message}
)
if response.status_code == 200:
print("Nachricht erfolgreich an Telegram gesendet!")
else:
print(f"Fehler beim Senden an Telegram: {response.status_code}, {response.text}")
except Exception as e:
print(f"Telegram-Fehler: {e}")
# Funktion: Nachrichten von Meshtastic abrufen (Protobuf-Format)
def get_messages():
try:
response = requests.get(FROM_RADIO_URL, stream=True)
if response.status_code == 200:
for raw_message in response.iter_content(chunk_size=None):
if raw_message:
process_protobuf_message(raw_message)
else:
print(f"Fehler beim Abrufen von Nachrichten: {response.status_code}, {response.text}")
except Exception as e:
print(f"Fehler beim Abrufen der Nachrichten: {e}")
# Funktion: Protobuf-Nachricht verarbeiten
def process_protobuf_message(raw_message):
try:
# Protobuf-Daten dekodieren
message = mesh_pb2.FromRadio()
message.ParseFromString(raw_message)
print(message)
# Nur Textnachrichten verarbeiten
if message.packet.decoded.payload.decode("utf-8") and message.packet.decoded.portnum == 1:
text_message = message.packet.decoded.payload.decode("utf-8")
rx_rssi = message.packet.rx_rssi
#sender_id = message.packet["from"]
# Nachricht an Telegram weiterleiten
print(f"Neue Nachricht: {text_message}")
send_to_telegram(f"Received: {text_message} (RX RSSI: {rx_rssi} dBm)")
# ACK-Nachricht zurücksenden
#send_ack(sender_id, text_message)
except Exception as e:
print(f"Fehler beim Verarbeiten der Protobuf-Nachricht: {e}")
# Funktion: ACK-Nachricht über HTTP-API senden
def send_ack(destination_id, original_message):
ack_message = f"ack: {original_message}"
try:
response = requests.post(
SEND_URL,
json={"destinationId": destination_id, "text": ack_message}
)
if response.status_code == 200:
print(f"ACK gesendet an {destination_id}: {ack_message}")
else:
print(f"Fehler beim Senden der ACK: {response.status_code}, {response.text}")
except Exception as e:
print(f"Fehler beim Senden der ACK: {e}")
# Hauptschleife
try:
print("Starte Abfrage... (Drücke STRG+C zum Beenden)")
while True:
get_messages()
time.sleep(1) # CPU-Schonzeit
except KeyboardInterrupt:
print("Beendet.")
Man muss sich zunächst selbst einen Telegram-Bot einrichten, um die Nachrichten dann später abzusetzen. Dazu müssen dann die ID des Bots sowie eine Chat-ID hinterlegt werden.