Meshtastic Detection

v0.1.1

Receive DETECTION_SENSOR_APP alerts from Meshtastic LoRa devices via USB. When the remote sensor GPIO triggers (preset target detected), store the event and...

0· 272·0 current·0 all-time
Security Scan
VirusTotalVirusTotal
Benign
View report →
OpenClawOpenClaw
Benign
high confidence
Purpose & Capability
Name/description match the files and scripts: usb_receiver.py listens on a USB serial device for DETECTION_SENSOR_APP messages, sensor_cli.py and event_monitor.py query/read the local JSONL store, and cron/OpenClaw are used to deliver Feishu alerts. Required binaries (Python 3.10+) are appropriate and expected.
Instruction Scope
SKILL.md instructs the agent to run the provided scripts, set up a venv, and create an OpenClaw cron job that runs event_monitor.py. The instructions only reference local files, the serial device, and OpenClaw's messaging delivery; they do not instruct reading unrelated system files or exfiltrating data to unknown endpoints.
Install Mechanism
No formal registry install spec is present; installation is via the included setup.sh which creates a venv and pip-installs requirements from PyPI. setup.sh may download get-pip.py from https://bootstrap.pypa.io if necessary (a known source). This is expected for a Python-based project, but the user should review setup.sh before running to confirm the network fetch and sudo/apt steps are acceptable in their environment.
Credentials
The skill requests no secrets/env vars in the registry metadata. The code optionally respects MESH_SERIAL_PORT and MESH_DATA_DIR environment variables (reasonable). The skill references Feishu delivery via OpenClaw cron but does not ask for Feishu tokens itself (OpenClaw handles delivery), which is coherent.
Persistence & Privilege
always is false and model invocation is allowed (platform default). The project offers installing a systemd/launchd service and a Docker entrypoint; the Docker example shows 'privileged: true' and device mappings, which are typical for direct serial device access but grants broad host device privileges. Installing system services requires elevated privileges (sudo). Users should be aware and approve these actions before installing.
Assessment
This skill appears to do exactly what it claims: read detection messages from a Meshtastic USB device, store them locally, and trigger OpenClaw/Feishu alerts. Before installing, review setup.sh (it may download get-pip.py and runs pip install), confirm you are comfortable granting the service access to the serial device (systemd/launchd install or Docker with device mapping and optional privileged mode), and ensure the OpenClaw cron is configured to deliver to the correct Feishu open_id. If you run this on a shared/production host, prefer installing as an unprivileged user with explicit device mappings and inspect the Python dependencies (meshtastic, pypubsub) from PyPI if you require stricter supply-chain auditing.

Like a lobster shell, security has layers — review code before you run it.

Runtime requirements

📡 Clawdis
OSmacOS · Linux
Any binpython3.12, python3.11, python3.10, python3
latestvk97d9d85arfky17829bkk0ysts82cr3w
272downloads
0stars
2versions
Updated 1mo ago
v0.1.1
MIT-0
macOS, Linux

Meshtastic Detection Skill

Receive detection sensor alerts from a remote Meshtastic device over LoRa. When the remote device's GPIO pin triggers (preset target detected), the event is stored locally and requires immediate user notification via feishu.

Prerequisites

  • Meshtastic-compatible hardware connected via USB (RAK4631, T-Beam, Heltec, etc.)
  • Python 3.10+ with meshtastic and pypubsub packages (venv at {baseDir}/venv)
  • usb_receiver.py daemon running
  • Quick setup: cd {baseDir} && ./setup.sh
  • Detailed guide: {baseDir}/references/SETUP.md

Architecture

┌──────────────────────────────────────────────────────────────┐
│                     USB Receiver Daemon                       │
├──────────────────────────────────────────────────────────────┤
│  LISTEN:  DETECTION_SENSOR_APP only (GPIO trigger events)    │
│  STORE:   data/sensor_data.jsonl (append per detection)      │
│  LATEST:  data/latest.json (most recent detection)           │
└──────────────────────────────────────────────────────────────┘

┌─────────────┐     USB      ┌──────────────┐
│  LoRa Node  │◄────────────►│ usb_receiver │
│  (Radio)    │              │   daemon     │
└─────────────┘              └──────┬───────┘
                                    │
                    ┌───────────────┼───────────────┐
                    │               │               │
                    ▼               ▼               ▼
          sensor_cli.py     event_monitor.py   OpenClaw cron
          (query data)      (check alerts)     (feishu alert)

Quick Reference

Run the Receiver

cd {baseDir}
source venv/bin/activate
python scripts/usb_receiver.py --port /dev/cu.usbmodem1CDBD4A896441

Check for New Alerts

cd {baseDir}
./venv/bin/python scripts/event_monitor.py

Every DETECTION_SENSOR_APP record = high-priority alert. Output:

{
  "alerts": [{"priority": "high", "sender": "!1dd29c50", "text": "alert detected", "received_at": "...", "channel": "ch0", "portnum": "DETECTION_SENSOR_APP"}],
  "summary": "🚨 3 new detection alert(s) from 3 record(s)",
  "alert_count": 3,
  "new_records": 3
}

Query Historical Data

python scripts/sensor_cli.py latest
python scripts/sensor_cli.py stats --since 24h
python scripts/sensor_cli.py query --since 1h

Data Format

Each record in data/sensor_data.jsonl:

{"received_at": "2026-03-04T11:07:06+00:00", "sender": "!1dd29c50", "channel": "ch0", "portnum": "DETECTION_SENSOR_APP", "data": {"type": "detection", "text": "alert detected"}}

Only DETECTION_SENSOR_APP messages are captured. This portnum means the remote sensor's GPIO pin was triggered — a preset target has been detected. Every detection event requires immediate user alert.

All other message types (TEXT_MESSAGE_APP, telemetry, position, etc.) are ignored.

Log Rotation

sensor_data.jsonl is automatically rotated at 5 MB (keeps 2 archive files, total max ~15 MB). Rotation is transparent — event_monitor auto-resets offset, sensor_cli reads across archives.

Monitoring & Alerts

Cron Job (Active)

The cron job runs event_monitor.py every 60 seconds and delivers alerts to feishu:

# Check status
openclaw cron list

# View run history
openclaw cron runs --id <job-id>

# Manual test
openclaw cron run <job-id>

# Edit config
openclaw cron edit <id> --timeout-seconds 60 --to <feishu-open-id>

Cron message template (for reference):

Run this command and report the output:
cd {baseDir} && ./venv/bin/python scripts/event_monitor.py
— If alert_count > 0, tell me how many alerts, the latest sender and time.
  If alert_count is 0, reply: 暂无新告警。

Key settings:

  • timeoutSeconds: 60 (agent needs ~20-40s)
  • channel: feishu
  • delivery.to: ou_16c6dc8bda8ac97abfd0194568edee59

Alert Behavior

All DETECTION_SENSOR_APP events are treated as high priority. No rule configuration needed — every detection triggers an immediate alert. The alert message includes:

  • Sender device ID
  • Detection text (from remote sensor config)
  • Timestamp

Configuration

Edit CONFIG.md to customize:

  • Serial port — USB device path
  • Notification channelfeishu (configured in OpenClaw)

Common Conversation Patterns

User asks about recent detections:

"What was detected in the last hour?"

Run: cd {baseDir} && ./venv/bin/python scripts/sensor_cli.py query --since 1h

User asks for statistics:

"Give me a summary of detections today"

Run: cd {baseDir} && ./venv/bin/python scripts/sensor_cli.py stats --since 24h

User asks about system status:

"Is the sensor still working?"

Run: cd {baseDir} && ./venv/bin/python scripts/sensor_cli.py status

Files

{baseDir}/
├── SKILL.md               # This file (agent instructions + metadata)
├── CONFIG.md              # User configuration
├── setup.sh               # One-click setup
├── scripts/
│   ├── usb_receiver.py    # USB serial daemon (DETECTION_SENSOR_APP only)
│   ├── event_monitor.py   # Incremental alert monitor
│   └── sensor_cli.py      # Query CLI
├── data/
│   ├── sensor_data.jsonl  # Detection records (auto-rotated at 5 MB)
│   ├── latest.json        # Most recent detection
│   └── monitor_state.json # Monitor byte offset + seen hashes
└── references/
    └── SETUP.md           # Detailed installation guide

Troubleshooting

"No records found"

  • Check that usb_receiver.py is running
  • Verify USB device: ls /dev/cu.usb*

"Resource temporarily unavailable"

  • Only one process can use the serial port. Check: lsof /dev/cu.usbmodem*

Receiver connects but no data appears

  • The receiver only captures DETECTION_SENSOR_APP messages (other types are ignored)
  • Run with --debug to see all packets: python scripts/usb_receiver.py --port ... --debug
  • Verify the remote device is on the same channel and frequency
  • Confirm the remote device has Detection Sensor Settings configured (GPIO pin monitoring)

Cron job times out or fails delivery

  • Check: openclaw cron runs --id <job-id>
  • Fix timeout: openclaw cron edit <id> --timeout-seconds 60
  • Fix delivery: openclaw cron edit <id> --to <feishu-open-id>

Comments

Loading comments...