leansdr::cstln_receiver< T, SOFTSYMB > Struct Template Reference

#include <sdr.h>

Inheritance diagram for leansdr::cstln_receiver< T, SOFTSYMB >:

Collaboration diagram for leansdr::cstln_receiver< T, SOFTSYMB >:

Public Member Functions
	cstln_receiver (scheduler *sch, sampler_interface< T > *_sampler, pipebuf< complex< T >> &_in, pipebuf< SOFTSYMB > &_out, pipebuf< float > *_freq_out=NULL, pipebuf< float > *_ss_out=NULL, pipebuf< float > *_mer_out=NULL, pipebuf< cf32 > *_cstln_out=NULL)
void	set_omega (float _omega, float tol=10e-6)
void	set_freq (float freq)
void	set_allow_drift (bool d)
void	update_freq_limits ()
void	run ()
void	refresh_freq_tap ()
Public Member Functions inherited from leansdr::runnable
	runnable (scheduler *_sch, const char *name)
Public Member Functions inherited from leansdr::runnable_common
	runnable_common (const char *_name)
virtual	~runnable_common ()
virtual void	shutdown ()

Public Attributes
sampler_interface< T > *	sampler
cstln_lut< SOFTSYMB, 256 > *	cstln
unsigned long	meas_decimation
float	omega
float	min_omega
float	max_omega
float	freqw
float	min_freqw
float	max_freqw
float	pll_adjustment
bool	allow_drift
float	kest
float	freq_tap
complex< float >	p
complex< float >	c
Public Attributes inherited from leansdr::runnable_common
const char *	name

Static Public Attributes
static const unsigned int	chunk_size = 128

Private Attributes
struct {
complex< float >   p
complex< float >   c
}	hist [3]
pipereader< complex< T > >	in
pipewriter< SOFTSYMB >	out
float	est_insp
float	agc_gain
float	mu
float	phase
float	est_sp
float	est_ep
unsigned long	meas_count
pipewriter< float > *	freq_out
pipewriter< float > *	ss_out
pipewriter< float > *	mer_out
pipewriter< cf32 > *	cstln_out

Additional Inherited Members
Protected Attributes inherited from leansdr::runnable
scheduler *	sch

Detailed Description

template<typename T, typename SOFTSYMB>
struct leansdr::cstln_receiver< T, SOFTSYMB >

Definition at line 1037 of file sdr.h.

Constructor & Destructor Documentation

cstln_receiver()

template<typename T, typename SOFTSYMB>

leansdr::cstln_receiver< T, SOFTSYMB >::cstln_receiver ( scheduler *  sch, sampler_interface< T > *  _sampler, pipebuf< complex< T >> &  _in, pipebuf< SOFTSYMB > &  _out, pipebuf< float > *  _freq_out = NULL, pipebuf< float > *  _ss_out = NULL, pipebuf< float > *  _mer_out = NULL, pipebuf< cf32 > *  _cstln_out = NULL  )

inline

Definition at line 1049 of file sdr.h.

                                                     : runnable(sch, "Constellation receiver"),
                                                       sampler(_sampler),
                                                       cstln(NULL),
                                                       meas_decimation(1048576),
                                                       pll_adjustment(1.0),
                                                       allow_drift(false),
                                                       kest(0.01),
                                                       in(_in),
                                                       out(_out, chunk_size),
                                                       est_insp(cstln_amp * cstln_amp),
                                                       agc_gain(1),
                                                       mu(0),
                                                       phase(0),
                                                       est_sp(0),
                                                       est_ep(0),
                                                       meas_count(0)
    {
        set_omega(1);
        set_freq(0);
        freq_out = _freq_out ? new pipewriter<float>(*_freq_out) : NULL;
        ss_out = _ss_out ? new pipewriter<float>(*_ss_out) : NULL;
        mer_out = _mer_out ? new pipewriter<float>(*_mer_out) : NULL;
        cstln_out = _cstln_out ? new pipewriter<cf32>(*_cstln_out) : NULL;
        memset(hist, 0, sizeof(hist));
    }

Member Function Documentation

refresh_freq_tap()

template<typename T, typename SOFTSYMB>

void leansdr::cstln_receiver< T, SOFTSYMB >::refresh_freq_tap ( )

inline

Definition at line 1290 of file sdr.h.

    {
        freq_tap = freqw / 65536;
    }

run()

template<typename T, typename SOFTSYMB>

void leansdr::cstln_receiver< T, SOFTSYMB >::run ( )

inlinevirtual

Reimplemented from leansdr::runnable_common.

Definition at line 1136 of file sdr.h.

    {
        if (!cstln)
            fail("constellation not set");

        // Magic constants that work with the qa recordings.
        float freq_alpha = 0.04;
        float freq_beta = 0.0012 / omega * pll_adjustment;
        float gain_mu = 0.02 / (cstln_amp * cstln_amp) * 2;

        int max_meas = chunk_size / meas_decimation + 1;
        // Large margin on output_size because mu adjustments
        // can lead to more than chunk_size/min_omega symbols.
        while (in.readable() >= chunk_size + sampler->readahead() && out.writable() >= chunk_size && (!freq_out || freq_out->writable() >= max_meas) && (!ss_out || ss_out->writable() >= max_meas) && (!mer_out || mer_out->writable() >= max_meas) && (!cstln_out || cstln_out->writable() >= max_meas))
        {
            sampler->update_freq(freqw, chunk_size);

            complex<T> *pin = in.rd(), *pin0 = pin, *pend = pin + chunk_size;
            SOFTSYMB *pout = out.wr(), *pout0 = pout;

            // These are scoped outside the loop for SS and MER estimation.
            complex<float> sg{0.0f, 0.0f}; // Symbol before AGC;
            complex<float> s;  // For MER estimation and constellation viewer
            complex<signed char> *cstln_point = NULL;

            while (pin < pend)
            {
                // Here mu is the time of the next symbol counted from 0 at pin.
                if (mu < 1)
                {
                    // Here 0<=mu<1 is the fractional time of the next symbol
                    // between pin and pin+1.
                    sg = sampler->interp(pin, mu, phase + mu * freqw);
                    s = sg * agc_gain;

                    // Constellation look-up
                    typename cstln_lut<SOFTSYMB, 256>::result *cr =
                        cstln->lookup(s.re, s.im);
                    *pout = cr->ss;
                    ++pout;

                    // PLL
                    phase += cr->phase_error * freq_alpha;
                    freqw += cr->phase_error * freq_beta;

                    // Modified Mueller and Müller
                    // mu[k]=real((c[k]-c[k-2])*conj(p[k-1])-(p[k]-p[k-2])*conj(c[k-1]))
                    //      =dot(c[k]-c[k-2],p[k-1]) - dot(p[k]-p[k-2],c[k-1])
                    // p = received signals
                    // c = decisions (constellation points)
                    hist[2] = hist[1];
                    hist[1] = hist[0];
                    hist[0].p.re = s.re;
                    hist[0].p.im = s.im;
                    cstln_point = &cstln->symbols[cr->symbol];
                    hist[0].c.re = cstln_point->re;
                    hist[0].c.im = cstln_point->im;
                    float muerr = ((hist[0].p.re - hist[2].p.re) * hist[1].c.re + (hist[0].p.im - hist[2].p.im) * hist[1].c.im) - ((hist[0].c.re - hist[2].c.re) * hist[1].p.re + (hist[0].c.im - hist[2].c.im) * hist[1].p.im);
                    float mucorr = muerr * gain_mu;
                    const float max_mucorr = 0.1;
                    // TBD Optimize out statically
                    if (mucorr < -max_mucorr)
                        mucorr = -max_mucorr;
                    if (mucorr > max_mucorr)
                        mucorr = max_mucorr;
                    mu += mucorr;
                    mu += omega; // Next symbol time;
                }                // mu<1

                // Next sample
                ++pin;
                --mu;
                phase += freqw;
            } // chunk_size

            in.read(pin - pin0);
            out.written(pout - pout0);

            // Normalize phase so that it never exceeds 32 bits.
            // Max freqw is 2^31/65536/chunk_size = 256 Hz
            // (this may happen with leandvb --drift --decim).
            phase = fmodf(phase, 65536); // Rounding direction irrelevant

            if (cstln_point)
            {
                // Output the last interpolated PSK symbol, max once per chunk_size
                if (cstln_out)
                    cstln_out->write(s);

                // AGC
                // For APSK we must do AGC on the symbols, not the whole signal.
                // TODO Use a better estimator at low SNR.
                float insp = sg.re * sg.re + sg.im * sg.im;
                est_insp = insp * kest + est_insp * (1 - kest);

                if (est_insp)
                    agc_gain = cstln_amp / gen_sqrt(est_insp);

                // SS and MER
                complex<float> ev(s.re - cstln_point->re,
                                  s.im - cstln_point->im);
                float sig_power, ev_power;

                if (cstln->nsymbols == 2)
                {
                    // Special case for BPSK: Ignore quadrature component of noise.
                    // TBD Projection on I axis assumes BPSK at 45°
                    float sig_real = (cstln_point->re + cstln_point->im) * 0.707;
                    float ev_real = (ev.re + ev.im) * 0.707;
                    sig_power = sig_real * sig_real;
                    ev_power = ev_real * ev_real;
                }
                else
                {
                    sig_power = (int)cstln_point->re * cstln_point->re + (int)cstln_point->im * cstln_point->im;
                    ev_power = ev.re * ev.re + ev.im * ev.im;
                }

                est_sp = sig_power * kest + est_sp * (1 - kest);
                est_ep = ev_power * kest + est_ep * (1 - kest);
            }

            // This is best done periodically ouside the inner loop,
            // but will cause non-deterministic output.

            if (!allow_drift)
            {
                if (freqw < min_freqw || freqw > max_freqw)
                    freqw = (max_freqw + min_freqw) / 2;
            }

            // Output measurements

            refresh_freq_tap();

            meas_count += pin - pin0;

            while (meas_count >= meas_decimation)
            {
                meas_count -= meas_decimation;
                if (freq_out)
                    freq_out->write(freq_tap);
                if (ss_out)
                    ss_out->write(sqrtf(est_insp));
                if (mer_out)
                    mer_out->write(
                        est_ep ? 10 * logf(est_sp / est_ep) / logf(10) : 0);
            }

        } // Work to do
    }

set_allow_drift()

template<typename T, typename SOFTSYMB>

void leansdr::cstln_receiver< T, SOFTSYMB >::set_allow_drift ( bool  d )

inline

Definition at line 1097 of file sdr.h.

    {
        allow_drift = d;
    }

set_freq()

template<typename T, typename SOFTSYMB>

void leansdr::cstln_receiver< T, SOFTSYMB >::set_freq ( float  freq )

inline

Definition at line 1090 of file sdr.h.

    {
        freqw = freq * 65536;
        update_freq_limits();
        refresh_freq_tap();
    }

set_omega()

template<typename T, typename SOFTSYMB>

void leansdr::cstln_receiver< T, SOFTSYMB >::set_omega ( float  _omega, float  tol = 10e-6  )

inline

Definition at line 1082 of file sdr.h.

    {
        omega = _omega;
        min_omega = omega * (1 - tol);
        max_omega = omega * (1 + tol);
        update_freq_limits();
    }

update_freq_limits()

template<typename T, typename SOFTSYMB>

void leansdr::cstln_receiver< T, SOFTSYMB >::update_freq_limits ( )

inline

Definition at line 1102 of file sdr.h.

    {
        // Prevent PLL from crossing +-SR/n/2 and locking at +-SR/n.
        int n = 4;

        if (cstln)
        {
            switch (cstln->nsymbols)
            {
            case 2:
                n = 2;
                break; // BPSK
            case 4:
                n = 4;
                break; // QPSK
            case 8:
                n = 8;
                break; // 8PSK
            case 16:
                n = 12;
                break; // 16APSK
            case 32:
                n = 16;
                break; // 32APSK
            default:
                n = 4;
                break;
            }
        }

        min_freqw = freqw - 65536 / max_omega / n / 2;
        max_freqw = freqw + 65536 / max_omega / n / 2;
    }

Member Data Documentation

agc_gain

template<typename T, typename SOFTSYMB>

float leansdr::cstln_receiver< T, SOFTSYMB >::agc_gain

private

Definition at line 1304 of file sdr.h.

allow_drift

template<typename T, typename SOFTSYMB>

bool leansdr::cstln_receiver< T, SOFTSYMB >::allow_drift

Definition at line 1045 of file sdr.h.

c

template<typename T, typename SOFTSYMB>

complex<float> leansdr::cstln_receiver< T, SOFTSYMB >::c

Definition at line 1299 of file sdr.h.

chunk_size

template<typename T, typename SOFTSYMB>

const unsigned int leansdr::cstln_receiver< T, SOFTSYMB >::chunk_size = 128

static

Definition at line 1046 of file sdr.h.

cstln

template<typename T, typename SOFTSYMB>

cstln_lut<SOFTSYMB, 256>* leansdr::cstln_receiver< T, SOFTSYMB >::cstln

Definition at line 1040 of file sdr.h.

Referenced by DATVDemod::InitDATVFramework().

cstln_out

template<typename T, typename SOFTSYMB>

pipewriter<cf32>* leansdr::cstln_receiver< T, SOFTSYMB >::cstln_out

private

Definition at line 1312 of file sdr.h.

est_ep

template<typename T, typename SOFTSYMB>

float leansdr::cstln_receiver< T, SOFTSYMB >::est_ep

private

Definition at line 1309 of file sdr.h.

est_insp

template<typename T, typename SOFTSYMB>

float leansdr::cstln_receiver< T, SOFTSYMB >::est_insp

private

Definition at line 1304 of file sdr.h.

est_sp

template<typename T, typename SOFTSYMB>

float leansdr::cstln_receiver< T, SOFTSYMB >::est_sp

private

Definition at line 1308 of file sdr.h.

freq_out

template<typename T, typename SOFTSYMB>

pipewriter<float>* leansdr::cstln_receiver< T, SOFTSYMB >::freq_out

private

Definition at line 1311 of file sdr.h.

freq_tap

template<typename T, typename SOFTSYMB>

float leansdr::cstln_receiver< T, SOFTSYMB >::freq_tap

Definition at line 1288 of file sdr.h.

freqw

template<typename T, typename SOFTSYMB>

float leansdr::cstln_receiver< T, SOFTSYMB >::freqw

Definition at line 1043 of file sdr.h.

hist

struct { ... } leansdr::cstln_receiver< T, SOFTSYMB >::hist[3]

in

template<typename T, typename SOFTSYMB>

pipereader<complex<T> > leansdr::cstln_receiver< T, SOFTSYMB >::in

private

Definition at line 1302 of file sdr.h.

kest

template<typename T, typename SOFTSYMB>

float leansdr::cstln_receiver< T, SOFTSYMB >::kest

Definition at line 1047 of file sdr.h.

max_freqw

template<typename T, typename SOFTSYMB>

float leansdr::cstln_receiver< T, SOFTSYMB >::max_freqw

Definition at line 1043 of file sdr.h.

max_omega

template<typename T, typename SOFTSYMB>

float leansdr::cstln_receiver< T, SOFTSYMB >::max_omega

Definition at line 1042 of file sdr.h.

meas_count

template<typename T, typename SOFTSYMB>

unsigned long leansdr::cstln_receiver< T, SOFTSYMB >::meas_count

private

Definition at line 1310 of file sdr.h.

meas_decimation

template<typename T, typename SOFTSYMB>

unsigned long leansdr::cstln_receiver< T, SOFTSYMB >::meas_decimation

Definition at line 1041 of file sdr.h.

mer_out

template<typename T, typename SOFTSYMB>

pipewriter<float> * leansdr::cstln_receiver< T, SOFTSYMB >::mer_out

private

Definition at line 1311 of file sdr.h.

min_freqw

template<typename T, typename SOFTSYMB>

float leansdr::cstln_receiver< T, SOFTSYMB >::min_freqw

Definition at line 1043 of file sdr.h.

min_omega

template<typename T, typename SOFTSYMB>

float leansdr::cstln_receiver< T, SOFTSYMB >::min_omega

Definition at line 1042 of file sdr.h.

mu

template<typename T, typename SOFTSYMB>

float leansdr::cstln_receiver< T, SOFTSYMB >::mu

private

Definition at line 1305 of file sdr.h.

omega

template<typename T, typename SOFTSYMB>

float leansdr::cstln_receiver< T, SOFTSYMB >::omega

Definition at line 1042 of file sdr.h.

out

template<typename T, typename SOFTSYMB>

pipewriter<SOFTSYMB> leansdr::cstln_receiver< T, SOFTSYMB >::out

private

Definition at line 1303 of file sdr.h.

p

template<typename T, typename SOFTSYMB>

complex<float> leansdr::cstln_receiver< T, SOFTSYMB >::p

Definition at line 1298 of file sdr.h.

phase

template<typename T, typename SOFTSYMB>

float leansdr::cstln_receiver< T, SOFTSYMB >::phase

private

Definition at line 1306 of file sdr.h.

pll_adjustment

template<typename T, typename SOFTSYMB>

float leansdr::cstln_receiver< T, SOFTSYMB >::pll_adjustment

Definition at line 1044 of file sdr.h.

sampler

template<typename T, typename SOFTSYMB>

sampler_interface<T>* leansdr::cstln_receiver< T, SOFTSYMB >::sampler

Definition at line 1039 of file sdr.h.

ss_out

template<typename T, typename SOFTSYMB>

pipewriter<float> * leansdr::cstln_receiver< T, SOFTSYMB >::ss_out

private

Definition at line 1311 of file sdr.h.

---

The documentation for this struct was generated from the following file:

• plugins/channelrx/demoddatv/leansdr/sdr.h