M-PSK Receiver — Performance Characterisation¶

This is the receiver's characterisation, not a demo of it. Everything on the page is measured over randomly drawn geometries rather than a fixed grid, on both track.MpskReceiver (complex baseband) and track.MpskReceiverR (real IF) — see the walkthrough page for what they are and the design note for how they work.

Each trial independently draws the constellation order, m_out, a non-integer samples-per-symbol, the IF placement, both loop bandwidths, the frequency and clock offsets, the absolute level, and the data. That is the point:

The measurement rules the panels obey¶

These are not incidental — get any of them wrong and the numbers look like DSP defects. They are the same rules the design note and the receiver's test harness encode.

The two panels¶

EVM vs the coherent bound. Self-referenced EVM — each symbol against its own hard decision — against EVM_dB = −(Es/N0)_dB. EVM is an I/Q-plane quantity, so there is no factor of two, and an EVM beating the bound means the measurement is wrong. Median margin over the whole random sweep: +0.1 dB.

Lock time against each trial's own budget. Not an absolute symbol count — a fraction of that trial's 2·(5/bn_t + 5/bn_c), which is the only way to compare trials with different loop bandwidths.

Streaming a real capture in¶

The receivers are streaming objects: state carries across calls, so a capture arrives in whatever blocks your transport hands you.

# Feeding a stream in chunks: the receiver is a streaming object, so `steps()`
# may be called with whatever block the source hands you. It keeps every piece
# of state that spans a call -- the LO phase, the cascade's delay lines, the
# timing accumulator, both loop integrators, and (on the real path) the R2C
# halfband's orphan sample when a chunk has odd length -- so a chunked run is
# BIT-IDENTICAL to one big call. Chunk size is a buffering decision, not a
# signal-processing one.
import numpy as np  # noqa: E402  (region must be self-contained)


def demod_stream(rx, blocks):
    """Feed an iterable of blocks; yield the symbols each call produced.

    The output count per call VARIES -- a chunk of N samples yields about
    N/sps symbols, but which side of the boundary a symbol lands on depends
    on the timing accumulator's phase, so never assume a fixed ratio.
    """
    for block in blocks:
        symbols = rx.steps(block)  # may be empty for a short block
        if len(symbols):
            yield symbols


def chunk_randomly(x, rng, lo=997, hi=9973):
    """Split `x` into chunks of random length -- deliberately including ODD
    lengths, which is what exercises the real path's even/odd halfband pairing
    across a call boundary."""
    i = 0
    while i < x.size:
        n = int(rng.integers(lo, hi))
        yield x[i : i + n]
        i += n

Reproduce¶

Every panel is independently selectable, so a single question is cheap to ask:

# the two panels above (the default, and what the figure is)
python src/doppler/examples/mpsk_receiver_performance_demo.py

# every panel, including the six pass/fail ones
python src/doppler/examples/mpsk_receiver_performance_demo.py --only all

# one question at a time
python src/doppler/examples/mpsk_receiver_performance_demo.py --only falsealarm

# more draws for a tighter distribution
python src/doppler/examples/mpsk_receiver_performance_demo.py --trials 400