Rust telemetry manual

Pitgun docs
built for operators.

A concise guide to running Pitgun under race conditions: UDP-first ingestion, manifest-driven processors, deterministic sinks, and an emulator that lets you rehearse every lap before going live.

Read quickstart Open sample manifest
UDP ingestion (unicast/multicast join) Processors: channel_filter · scale · formula · stats Sinks: console JSON · per-channel CSV (CLI)
PG
Documentation
Telemetry that computes
$ cargo run -p pitgun-cli -- subscribe --bind 0.0.0.0:5001 --json
$ cargo run -p pitgun-emulator -- --target 127.0.0.1:5001 \
  --input nEngine=datasets/telemetry/nEngine.csv --pace

Optimized for deterministic, frame-based telemetry: small binary frames, processor traits, and a manifest that stays under version control.

Documentation Structure

Blueprint for the Pitgun manual. Each section is scoped to the code that exists today—no ghost features, just the telemetry engine as shipped.

Introduction Now

What Pitgun is, why it exists, and the constraints it is built to survive.
System Overview Draft

Core crates, how sources, processors, and sinks cooperate, and where the emulator fits.
Wire Format Draft

Binary frame structure, channel naming, timestamps, and expectations for UDP links.
Pipeline Model Draft

Sources (UDP), processors (channel_filter, scale, formula, stats), and sinks (console, CSV) as traits.
Manifest Draft

YAML schema used by pitgun-cli to assemble pipelines, with required fields and safe defaults.
Processors Draft

Reference for channel_filter, scale, formula (AST JSON), and stats including required keys.
Sinks Draft

Console JSON output and optional per-channel CSV recording via pitgun-cli.
CLI Usage Draft

Subscribe workflow, flags for binding, multicast, stats, JSON output, and manifest selection.
Emulator Draft

Replay CSV telemetry over UDP with pacing, multi-channel merges, and multicast options.
Operations Draft

Performance posture, batching behavior, and how stats helps detect gaps or regressions.

Introduction

Pitgun is a Rust-based telemetry processing engine designed for the constraints you find in motorsport and high-frequency test benches. It consumes binary UDP frames, applies a manifest-driven chain of processors, and emits enriched metrics with deterministic behavior. The codebase favors small, explicit building blocks over magic: traits for sources, processors, and sinks; minimal wire formats; and a CLI that mirrors the pipeline used in production.

What it solves
  • Low-latency ingestion of timestamped channel data over UDP, including multicast joins.
  • Deterministic, declarative processing: channel whitelisting, scaling, math formulas (JSON AST), and real-time stats.
  • Sink discipline: print structured JSON for inspection and optionally record per-channel CSVs for offline analysis.
Why it exists
  • Provide a small, auditable pipeline that behaves under F1-grade data rates without GC pauses or hidden buffering.
  • Keep manifests versionable and LLM-ready: the same YAML runs locally and on a rig, no code forks.
  • Ship an emulator that lets teams dry-run datasets before track time, verifying formulas and channel coverage.
Transport

UDP only (unicast or multicast join). Batching is driven by size and nanosecond thresholds to keep latency bounded.

Processors

channel_filter, scale, formula (supports +, -, *, /, negation, trig/exp/log funcs), stats (rates, per-channel counts, gap detection).

Sinks

Console JSON (manifest-driven) and per-channel CSV writer (CLI flag). Sinks are composable via the CLI composite sink.

Ready to test
Run the emulator against the CLI

Rehearse with nEngine and throttle datasets before deploying to a rig.

$ cargo run -p pitgun-emulator -- --target 127.0.0.1:5000 \
  --input nEngine=datasets/telemetry/nEngine.csv \
  --input throttle=datasets/telemetry/rThrottle.csv --pace
$ cargo run -p pitgun-cli -- subscribe --bind 0.0.0.0:5000 --json