Mesh Node Monitoring & Data Capture

# Install the Meshtastic CLI
pip3 install --upgrade "meshtastic[cli]"

# Verify connection (auto-detects port)
meshtastic --info

# Or specify port explicitly
meshtastic --port /dev/ttyUSB0 --info        # Linux
meshtastic --port /dev/cu.usbmodem* --info   # macOS
meshtastic --port COM4 --info                # Windows

# Stream all packets (enables debug output)
meshtastic --listen

# Log raw serial output to a file
meshtastic --seriallog mesh-capture.txt

# Stream to file while watching in terminal
meshtastic --listen 2>&1 | tee mesh-log-$(date +%Y%m%d).txt

# Show all nodes the device has heard
meshtastic --nodes

# Request telemetry from a specific node
meshtastic --request-telemetry --dest '!ba4bf9d0'

# Request position from a node
meshtastic --request-position --dest '!ba4bf9d0'

# Run a traceroute to see the path
meshtastic --traceroute '!ba4bf9d0'

# Export full device config as YAML
meshtastic --export-config > node-config.yaml

import meshtastic
import meshtastic.serial_interface
from pubsub import pub

def on_receive(packet, interface):
    """Called for every received packet."""
    print(f"From: {packet.get('fromId', 'unknown')}")
    print(f"Type: {packet.get('decoded', {}).get('portnum', 'unknown')}")

    # Extract telemetry
    decoded = packet.get('decoded', {})
    if decoded.get('portnum') == 'TELEMETRY_APP':
        telemetry = decoded.get('telemetry', {})
        env = telemetry.get('environmentMetrics', {})
        if env:
            print(f"  Temp: {env.get('temperature')}°C")
            print(f"  Humidity: {env.get('relativeHumidity')}%")
            print(f"  Pressure: {env.get('barometricPressure')} hPa")

        device = telemetry.get('deviceMetrics', {})
        if device:
            print(f"  Battery: {device.get('batteryLevel')}%")
            print(f"  Voltage: {device.get('voltage')}V")
            print(f"  Uptime: {device.get('uptimeSeconds')}s")

    # Extract position
    if decoded.get('portnum') == 'POSITION_APP':
        pos = decoded.get('position', {})
        print(f"  Lat: {pos.get('latitude')}")
        print(f"  Lon: {pos.get('longitude')}")
        print(f"  Alt: {pos.get('altitude')}m")

# Subscribe to receive events
pub.subscribe(on_receive, "meshtastic.receive")

# Connect via USB
interface = meshtastic.serial_interface.SerialInterface()

# Keep running
import time
while True:
    time.sleep(1)

# Scan for nearby Meshtastic devices
meshtastic --ble-scan

# Connect by name or address
meshtastic --ble "device_name" --info
meshtastic --ble "AA:BB:CC:DD:EE:FF" --nodes

# Stream packets over BLE
meshtastic --ble "device_name" --listen

# Connect to node on your local network
meshtastic --host meshtastic.local --info
meshtastic --host 192.168.1.50 --nodes

# Stream packets over WiFi
meshtastic --host 192.168.1.50 --listen

# Log to file over network
meshtastic --host 192.168.1.50 --seriallog ~/mesh-logs/log.txt

meshtastic --set network.wifi_ssid "YourSSID"
meshtastic --set network.wifi_psk "YourPassword"
meshtastic --set network.wifi_enabled true

# Enable WiFi
meshtastic --set network.wifi_ssid "YourSSID"
meshtastic --set network.wifi_psk "YourPassword"
meshtastic --set network.wifi_enabled true

# Point to your MQTT broker (or use the public one)
meshtastic --set mqtt.address "mqtt://your-broker:1883"
meshtastic --set mqtt.username "meshuser"
meshtastic --set mqtt.password "meshpass"
meshtastic --set mqtt.enabled true

# Enable JSON output (easier to consume than protobuf)
meshtastic --set mqtt.json_enabled true

# Enable uplink on your primary channel
meshtastic --ch-index 0 --ch-set uplink_enabled true

# Subscribe to all JSON messages from your region
mosquitto_sub -h your-broker -t "msh/US/2/json/#" -v

# Example JSON output for a position packet:
# {
#   "from": 2130636288,
#   "to": -1,
#   "channel": 0,
#   "type": "position",
#   "payload": {
#     "latitude_i": 285123456,
#     "longitude_i": -814567890,
#     "altitude": 25,
#     "time": 1646832724
#   },
#   "timestamp": 1646832724
# }

import paho.mqtt.client as mqtt
import json

def on_message(client, userdata, msg):
        data = json.loads(msg.payload)
        msg_type = data.get('type', 'unknown')
        node_id = hex(data.get('from', 0))

        if msg_type == 'telemetry':
    | **USB-C Cable (6ft)** | Connect node to computer | ~$7 | [Amazon](https://www.amazon.com/s?k=USB-C+to+USB-A+cable+6ft&tag=v00ko-20) |
    | **USB-C Cable (10ft)** | Reach nodes mounted higher | ~$9 | [Amazon](https://www.amazon.com/s?k=USB-C+to+USB-A+cable+10ft&tag=v00ko-20) |
    | **Raspberry Pi 5** | Dedicated monitoring server | ~$60 | [Amazon](https://www.amazon.com/s?k=Raspberry+Pi+5+8GB&tag=v00ko-20) |
    | **Raspberry Pi Zero 2 W** | Lightweight MQTT gateway | ~$20 | [Amazon](https://www.amazon.com/s?k=Raspberry+Pi+Zero+2+W&tag=v00ko-20) |
    | **USB Hub (powered)** | Monitor multiple nodes | ~$12 | [Amazon](https://www.amazon.com/s?k=powered+USB+hub+4+port&tag=v00ko-20) |
            payload = data.get('payload', {})
            lat = payload.get('latitude_i', 0) / 1e7
            lon = payload.get('longitude_i', 0) / 1e7
            print(f"[{node_id}] Position: {lat}, {lon}")

        elif msg_type == 'text':
            print(f"[{node_id}] Message: {data.get('payload')}")

    except json.JSONDecodeError:
        pass  # Skip protobuf messages

client = mqtt.Client()
client.on_message = on_message
client.connect("your-broker", 1883, 60)
client.subscribe("msh/US/2/json/#")
client.loop_forever()

# Enable serial module in TEXTMSG mode
meshtastic --set serial.enabled true
meshtastic --set serial.mode TEXTMSG
meshtastic --set serial.rxd 13      # RX pin (connect to other device TX)
meshtastic --set serial.txd 14      # TX pin (connect to other device RX)
meshtastic --set serial.baud BAUD_38400

# macOS/Linux — use screen, minicom, or tio
tio /dev/cu.usbmodem* -b 115200

# Or use PlatformIO Serial Monitor in VS Code

import meshtastic.serial_interface
from pubsub import pub
import sqlite3
import time

db = sqlite3.connect('mesh_telemetry.db')
db.execute('''CREATE TABLE IF NOT EXISTS telemetry (
    timestamp INTEGER, node_id TEXT, battery_level REAL,
    voltage REAL, temperature REAL, humidity REAL
)''')

def on_receive(packet, interface):
    decoded = packet.get('decoded', {})
    if decoded.get('portnum') != 'TELEMETRY_APP':
        return
    t = decoded.get('telemetry', {})
    dev = t.get('deviceMetrics', {})
    env = t.get('environmentMetrics', {})
    db.execute('INSERT INTO telemetry VALUES (?,?,?,?,?,?)', (
        int(time.time()),
        packet.get('fromId', ''),
        dev.get('batteryLevel'),
        dev.get('voltage'),
        env.get('temperature'),
        env.get('relativeHumidity'),
    ))
    db.commit()

pub.subscribe(on_receive, "meshtastic.receive")
interface = meshtastic.serial_interface.SerialInterface()

while True:
    time.sleep(1)