> your AI agent picks dependencies from memory; give it dated facts — try starlog.dev ↗ vet your agent's deps ↗ vibe-coding is fine. vibe-importing isn’t. — try starlog.dev ↗ vibe-importing isn’t fine ↗ your agent has never seen your private packages — try starlog.dev ↗ facts for private packages ↗ a linter for the dependencies your AI agent picks — try starlog.dev ↗ a linter for agent deps ↗ whois is redacted, cdns mask the rest — get the real operator — try whoisgeni.us ↗ who really runs that domain ↗ domain attribution that shows its work — full evidence chain — try whoisgeni.us ↗ domain intel w/ evidence ↗

← Back to Articles

SatDump: How Pipeline-as-Configuration Solved Satellite Signal Processing

[ View on GitHub ]

SatDump: How Pipeline-as-Configuration Solved Satellite Signal Processing

Hook

When NOAA-15's APT transmitter started glitching in 2020, hobbyists needed updated decoders within days. SatDump users edited a JSON file. Everyone else waited for software patches that never came.

Context

Receiving satellite signals has always been a game of catch-up. Traditional tools like WXtoImg and LrptRx hardcode demodulation parameters and frame formats into C binaries, meaning every new satellite—or protocol change—requires developers to release updated software. For active satellites like Meteor-M N2, which switched transponder frequencies multiple times due to hardware failures, this model fails catastrophically. Meanwhile, GNU Radio offers flexibility through visual flowgraphs, but building a complete satellite decoder from baseband to imagery requires assembling dozens of blocks, tweaking parameters, and debugging signal chains that rarely work correctly on the first attempt.

SatDump emerged from the satellite enthusiast community as a third path: treat satellite protocols as data rather than code. Instead of recompiling when FengYun-3C changes its Reed-Solomon interleaving or MetOp-C broadcasts on a new frequency, operators edit declarative pipeline configurations that describe the signal chain. The architecture separates the how (C++ DSP kernels optimized with VOLK SIMD instructions) from the what (JSON definitions of modulation schemes, frame synchronization words, and CCSDS packet structures). This isn't just convenience—it's critical infrastructure for a domain where satellites are launched faster than software maintainers can keep pace, and hardware failures force protocol changes mid-mission.

Technical Insight

SatDump's pipeline architecture treats signal processing as a directed acyclic graph where data flows through stages defined in configuration files. Each pipeline specifies a satellite, frequency band, and sequence of processing modules. Here's a simplified NOAA HRPT pipeline definition:

{
  "noaa_hrpt": {
    "name": "NOAA HRPT",
    "live": true,
    "live_cfg": [
      ["1", "baseband"],
      ["2", "soft_symbols"],
      ["3", "frames"]
    ],
    "frequencies": [
      ["NOAA-15", 1702.5e6],
      ["NOAA-18", 1707.0e6],
      ["NOAA-19", 1698.0e6]
    ],
    "parameters": {
      "samplerate": 6e6,
      "symbolrate": 665400
    },
    "work": {
      "baseband": {},
      "soft_symbols": {
        "qpsk_demod": {
          "constellation": "qpsk",
          "rrc_alpha": 0.5
        }
      },
      "frames": {
        "ccsds_conv_decoder": {
          "viterbi_ber_thres": 0.300,
          "viterbi_outsync_after": 20,
          "derandomize": true,
          "sync_word": "1acffc1d"
        }
      },
      "products": {
        "hrpt_decoder": {}
      }
    }
  }
}

When you launch SatDump with this pipeline, the framework instantiates a chain of processing modules: first a qpsk_demod reads complex samples from your SDR, applies root-raised-cosine filtering (alpha=0.5), and outputs soft symbols. These feed into ccsds_conv_decoder, which performs Viterbi decoding on the convolutional-coded stream, locks to the synchronization word 0x1ACFFC1D, derandomizes the bits, and emits CCSDS frames. Finally, hrpt_decoder parses the frame payloads into instrument channels (AVHRR imagery, HIRS soundings, etc.).

The critical architectural decision here is module reusability. That same ccsds_conv_decoder module handles Meteor-M LRPT, MetOp AHRPT, and Elektro-L LRIT—satellites with completely different purposes but standardized CCSDS framing. Adding a new satellite often means referencing existing modules with tweaked parameters:

// Simplified module interface (actual code in src/common/dsp/)
class ProcessingModule {
public:
    virtual void process(uint8_t *input, size_t size) = 0;
    virtual std::vector<uint8_t> getOutput() = 0;
    
    // VOLK-accelerated correlation for frame sync
    void findSyncMarker(const uint8_t *data, size_t len) {
        volk_32f_x2_dot_prod_32f(
            correlation_output,
            reinterpret_cast<const float*>(data),
            sync_word_pattern,
            len
        );
    }
};

VOLK (Vector-Optimized Library of Kernels) is the performance secret here. Operations like correlation, FIR filtering, and symbol timing recovery compile to AVX2 instructions on x86 or NEON on ARM, automatically detected at runtime. This matters enormously: demodulating a 6 MSPS QPSK signal requires ~24 million multiply-accumulates per second for RRC filtering alone. Without SIMD, you'd need a 4+ GHz CPU; with VOLK, a Raspberry Pi 4 manages in real-time.

The plugin architecture for SDR hardware follows a similar probe-and-configure pattern. At startup, SatDump queries registered source plugins:

// Pseudocode for SDR source abstraction
class SDRSource {
public:
    virtual std::string getName() = 0;
    virtual bool probe() = 0;  // Check if hardware is present
    virtual void start(double freq, double samplerate) = 0;
    virtual int receive(std::complex<float> *buffer, int count) = 0;
};

// Implementations for RTL-SDR, Airspy, HackRF, etc.
class RTLSDRSource : public SDRSource {
    bool probe() override {
        return rtlsdr_get_device_count() > 0;
    }
};

This abstraction means pipeline configs never reference hardware specifics—you run the same noaa_hrpt pipeline with an RTL-SDR Blog v3 or a $3000 Ettus B210, and SatDump handles the differences in gain ranges, sample formats, and driver quirks.

The offline processing capability deserves special attention. SatDump introduces ZIQ (compressed IQ format with zstd) for recording:

# Record 10 minutes of baseband at 6 MSPS (~1.4 GB compressed)
satdump record ziq output.ziq --source rtlsdr --frequency 1698M --samplerate 6M --duration 600

# Later, process through any pipeline without re-receiving
satdump offline_pipeline noaa_hrpt output.ziq output_dir --start_level baseband

# Or skip demod if you cached soft symbols
satdump offline_pipeline noaa_hrpt cached_symbols.soft output_dir --start_level soft_symbols

This --start_level parameter exploits the pipeline graph: if you've already demodulated to soft symbols and want to experiment with Viterbi BER thresholds, you resume at the frames stage without reprocessing gigabytes of baseband. For researchers iterating on decoder parameters, this cuts feedback loops from minutes to seconds.

The final piece is product generation. Unlike tools that dump raw sensor data, SatDump includes calibration routines and projection algorithms. For NOAA AVHRR, it applies nonlinearity corrections to thermal infrared channels, computes brightness temperatures using satellite-specific calibration coefficients (stored per-satellite in JSON), and generates georeferenced false-color composites. The output isn't just pictures—it's HDF5 files compatible with EUMETSAT's EPS tooling and Python's xarray ecosystem, bridging amateur reception and professional meteorology workflows.

Gotcha

SatDump assumes you already know what you're looking for. There's no spectrum analyzer, no automatic signal detection, no database of active satellites with current frequencies. You need to arrive with a satellite name ("NOAA-18"), a pipeline ID ("noaa_hrpt"), and correct RF parameters. For beginners, this means consulting external resources like SatNOGS DB for frequencies, then using a separate tool like SDR++ to confirm the signal exists before launching SatDump. The learning curve is steep: you must understand concepts like symbol rate, root-raised-cosine filtering, and frame synchronization before the pipeline configs make sense. Error messages reference DSP internals ("Viterbi outsync after 47 frames") rather than user-facing guidance ("signal too weak, increase antenna gain").

The Windows build story is frustrating. SatDump requires Visual Studio 2019 runtime and explicitly rejects MinGW/GCC builds because VOLK's Windows implementation depends on MSVC-specific intrinsics. This fragments distribution: you can't package it for MSYS2, and users need to install 400MB of MSVC redistributables for a satellite decoder. The dependency chain is equally heavy—OpenCV for image processing, FFTW for spectral analysis, volk for SIMD, plus optional OpenCL drivers. On Linux this resolves through package managers; on Windows it's DLL hell. Hardware support also has gaps: SDRplay devices require proprietary API binaries, and LimeSDR support is experimental at best. If your workflow involves automated unattended reception (like a rooftop station recording all passes), you'll need custom scripting around SatDump since it lacks built-in scheduling or TLE-based automation—that's where SatNOGS excels but requires integrating SatDump as a subprocess decoder.

Verdict

Use SatDump if you're processing weather satellite signals (NOAA POES, Meteor-M, MetOp, FengYun, GOES, Elektro-L) and need proven decoders that output scientific data products, not just pretty pictures. It's the right choice when you're adding support for new satellites or experimental protocols—editing JSON beats recompiling C++. Choose this over GNU Radio when you want curated pipelines instead of flowgraph archaeology, and over abandoned tools like WXtoImg when you need L-band HRPT or satellites launched after 2010. The ZIQ recording format and offline processing make it ideal for research workflows where you capture now, decode later, and iterate on parameters. Skip SatDump if you need signal discovery and don't already know satellite frequencies and schedules—pair it with SDR++ or GQRX for spectrum visibility first. Avoid it for Windows-primary environments unless you're comfortable with MSVC toolchains, and skip entirely for non-satellite DSP work where the CCSDS-centric architecture adds overhead without benefit. If you want turnkey automated reception, look to SatNOGS for orchestration and use SatDump as the decoder backend. This isn't software for casual experimentation; it's infrastructure for serious satellite operators who understand RF fundamentals and need the flexibility to adapt when satellites misbehave or new birds reach orbit.