PhaseLock Class Reference

#include <phaselock.h>

Inheritance diagram for PhaseLock:

Classes
struct	PpsEvent

Public Member Functions
	PhaseLock (Real freq, Real bandwidth, Real minsignal)
virtual	~PhaseLock ()
void	configure (Real freq, Real bandwidth, Real minsignal)
void	process (const std::vector< Real > &samples_in, std::vector< Real > &samples_out)
void	process (const Real &sample_in, Real *samples_out)
void	process (const Real &real_in, const Real &imag_in, Real *samples_out)
bool	locked () const
Real	get_pilot_level () const

Static Public Attributes
static const int	pilot_frequency = 19000

Protected Member Functions
virtual void	processPhase (Real *samples_out) const

Protected Attributes
Real	m_phase
Real	m_psin
Real	m_pcos

Private Member Functions
void	process_phasor (Real &phasor_i, Real &phasor_q)

Private Attributes
Real	m_minfreq
Real	m_maxfreq
Real	m_phasor_b0
Real	m_phasor_a1
Real	m_phasor_a2
Real	m_phasor_i1
Real	m_phasor_i2
Real	m_phasor_q1
Real	m_phasor_q2
Real	m_loopfilter_b0
Real	m_loopfilter_b1
Real	m_loopfilter_x1
Real	m_freq
Real	m_minsignal
Real	m_pilot_level
int	m_lock_delay
int	m_lock_cnt
int	m_pilot_periods
quint64	m_pps_cnt
quint64	m_sample_cnt
std::vector< PpsEvent >	m_pps_events

Detailed Description

Phase-locked loop mainly for broadcadt FM stereo pilot.

Definition at line 24 of file phaselock.h.

Constructor & Destructor Documentation

PhaseLock()

PhaseLock::PhaseLock	(	Real	freq,
		Real	bandwidth,
		Real	minsignal
	)

Construct phase-locked loop.

freq :: 19 kHz center frequency relative to sample freq (0.5 is Nyquist) bandwidth :: bandwidth relative to sample frequency minsignal :: minimum pilot amplitude

Definition at line 26 of file phaselock.cpp.

References exp(), m_freq, m_lock_cnt, m_lock_delay, m_loopfilter_b0, m_loopfilter_b1, m_loopfilter_x1, m_maxfreq, m_minfreq, m_minsignal, m_pcos, m_phase, m_phasor_a1, m_phasor_a2, m_phasor_b0, m_phasor_i1, m_phasor_i2, m_phasor_q1, m_phasor_q2, M_PI, m_pilot_level, m_pilot_periods, m_pps_cnt, m_psin, and m_sample_cnt.

{
    /*
     * This is a type-2, 4th order phase-locked loop.
     *
     * Open-loop transfer function:
     *   G(z) = K * (z - q1) / ((z - p1) * (z - p2) * (z - 1) * (z - 1))
     *   K  = 3.788 * (bandwidth * 2 * Pi)**3
     *   q1 = exp(-0.1153 * bandwidth * 2*Pi)
     *   p1 = exp(-1.146 * bandwidth * 2*Pi)
     *   p2 = exp(-5.331 * bandwidth * 2*Pi)
     *
     * I don't understand what I'm doing; hopefully it will work.
     */

    // Set min/max locking frequencies.
    m_minfreq = (freq - bandwidth) * 2.0 * M_PI;
    m_maxfreq = (freq + bandwidth) * 2.0 * M_PI;

    // Set valid signal threshold.
    m_minsignal  = minsignal;
    m_lock_delay = int(20.0 / bandwidth);
    m_lock_cnt   = 0;
    m_pilot_level = 0;
    m_psin = 0.0;
    m_pcos = 1.0;

    // Create 2nd order filter for I/Q representation of phase error.
    // Filter has two poles, unit DC gain.
    double p1 = exp(-1.146 * bandwidth * 2.0 * M_PI);
    double p2 = exp(-5.331 * bandwidth * 2.0 * M_PI);
    m_phasor_a1 = - p1 - p2;
    m_phasor_a2 = p1 * p2;
    m_phasor_b0 = 1 + m_phasor_a1 + m_phasor_a2;

    // Create loop filter to stabilize the loop.
    double q1 = exp(-0.1153 * bandwidth * 2.0 * M_PI);
    m_loopfilter_b0 = 0.62 * bandwidth * 2.0 * M_PI;
    m_loopfilter_b1 = - m_loopfilter_b0 * q1;

    // After the loop filter, the phase error is integrated to produce
    // the frequency. Then the frequency is integrated to produce the phase.
    // These integrators form the two remaining poles, both at z = 1.

    // Initialize frequency and phase.
    m_freq  = freq * 2.0 * M_PI;
    m_phase = 0;

    m_phasor_i1 = 0;
    m_phasor_i2 = 0;
    m_phasor_q1 = 0;
    m_phasor_q2 = 0;
    m_loopfilter_x1 = 0;

    // Initialize PPS generator.
    m_pilot_periods = 0;
    m_pps_cnt       = 0;
    m_sample_cnt    = 0;
}

Here is the call graph for this function:

~PhaseLock()

virtual PhaseLock::~PhaseLock ( )

inlinevirtual

Definition at line 49 of file phaselock.h.

    {}

Member Function Documentation

configure()

void PhaseLock::configure	(	Real	freq,
		Real	bandwidth,
		Real	minsignal
	)

Change phase locked loop parameters

freq :: 19 kHz center frequency relative to sample freq (0.5 is Nyquist) bandwidth :: bandwidth relative to sample frequency minsignal :: minimum pilot amplitude

Definition at line 87 of file phaselock.cpp.

References exp(), m_freq, m_lock_cnt, m_lock_delay, m_loopfilter_b0, m_loopfilter_b1, m_loopfilter_x1, m_maxfreq, m_minfreq, m_minsignal, m_phase, m_phasor_a1, m_phasor_a2, m_phasor_b0, m_phasor_i1, m_phasor_i2, m_phasor_q1, m_phasor_q2, M_PI, m_pilot_level, m_pilot_periods, m_pps_cnt, and m_sample_cnt.

Referenced by BFMDemod::applyChannelSettings(), BFMDemod::applySettings(), and ATVDemod::applySettings().

{
    qDebug("PhaseLock::configure: freq: %f bandwidth: %f minsignal: %f", freq, bandwidth, minsignal);
    /*
     * This is a type-2, 4th order phase-locked loop.
     *
     * Open-loop transfer function:
     *   G(z) = K * (z - q1) / ((z - p1) * (z - p2) * (z - 1) * (z - 1))
     *   K  = 3.788 * (bandwidth * 2 * Pi)**3
     *   q1 = exp(-0.1153 * bandwidth * 2*Pi)
     *   p1 = exp(-1.146 * bandwidth * 2*Pi)
     *   p2 = exp(-5.331 * bandwidth * 2*Pi)
     *
     * I don't understand what I'm doing; hopefully it will work.
     */

    // Set min/max locking frequencies.
    m_minfreq = (freq - bandwidth) * 2.0 * M_PI;
    m_maxfreq = (freq + bandwidth) * 2.0 * M_PI;

    // Set valid signal threshold.
    m_minsignal  = minsignal;
    m_lock_delay = int(20.0 / bandwidth);
    m_lock_cnt   = 0;
    m_pilot_level = 0;

    // Create 2nd order filter for I/Q representation of phase error.
    // Filter has two poles, unit DC gain.
    double p1 = exp(-1.146 * bandwidth * 2.0 * M_PI);
    double p2 = exp(-5.331 * bandwidth * 2.0 * M_PI);
    m_phasor_a1 = - p1 - p2;
    m_phasor_a2 = p1 * p2;
    m_phasor_b0 = 1 + m_phasor_a1 + m_phasor_a2;

    // Create loop filter to stabilize the loop.
    double q1 = exp(-0.1153 * bandwidth * 2.0 * M_PI);
    m_loopfilter_b0 = 0.62 * bandwidth * 2.0 * M_PI;
    m_loopfilter_b1 = - m_loopfilter_b0 * q1;

    // After the loop filter, the phase error is integrated to produce
    // the frequency. Then the frequency is integrated to produce the phase.
    // These integrators form the two remaining poles, both at z = 1.

    // Initialize frequency and phase.
    m_freq  = freq * 2.0 * M_PI;
    m_phase = 0;

    m_phasor_i1 = 0;
    m_phasor_i2 = 0;
    m_phasor_q1 = 0;
    m_phasor_q2 = 0;
    m_loopfilter_x1 = 0;

    // Initialize PPS generator.
    m_pilot_periods = 0;
    m_pps_cnt       = 0;
    m_sample_cnt    = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_pilot_level()

Real PhaseLock::get_pilot_level ( ) const

inline

Return detected amplitude of pilot signal.

Definition at line 86 of file phaselock.h.

    {
        return 2 * m_pilot_level;
    }

locked()

bool PhaseLock::locked ( ) const

inline

Return true if the phase-locked loop is locked.

Definition at line 80 of file phaselock.h.

Referenced by ATVDemod::getBFOLocked().

    {
        return m_lock_cnt >= m_lock_delay;
    }

Here is the caller graph for this function:

process() [1/3]

void PhaseLock::process	(	const std::vector< Real > &	samples_in,
		std::vector< Real > &	samples_out
	)

Process samples and extract 19 kHz pilot tone. Generate phase-locked 38 kHz tone with unit amplitude. Bufferized version with input and output vectors

Definition at line 148 of file phaselock.cpp.

References abs(), PhaseLock::PpsEvent::block_position, cos(), i, m_freq, m_lock_cnt, m_lock_delay, m_loopfilter_b0, m_loopfilter_b1, m_loopfilter_x1, m_maxfreq, m_minfreq, m_minsignal, m_phase, m_phasor_a1, m_phasor_a2, m_phasor_b0, m_phasor_i1, m_phasor_i2, m_phasor_q1, m_phasor_q2, M_PI, m_pilot_level, m_pilot_periods, m_pps_cnt, m_pps_events, m_sample_cnt, leansdr::max(), leansdr::min(), pilot_frequency, PhaseLock::PpsEvent::pps_index, PhaseLock::PpsEvent::sample_index, and sin().

Referenced by ATVDemod::demod(), and BFMDemod::feed().

{
    unsigned int n = samples_in.size();

    samples_out.resize(n);

    bool was_locked = (m_lock_cnt >= m_lock_delay);
    m_pps_events.clear();

    if (n > 0)
        m_pilot_level = 1000.0;

    for (unsigned int i = 0; i < n; i++) {

        // Generate locked pilot tone.
        Real psin = sin(m_phase);
        Real pcos = cos(m_phase);

        // Generate double-frequency output.
        // sin(2*x) = 2 * sin(x) * cos(x)
        samples_out[i] = 2 * psin * pcos;

        // Multiply locked tone with input.
        Real x = samples_in[i];
        Real phasor_i = psin * x;
        Real phasor_q = pcos * x;

        // Run IQ phase error through low-pass filter.
        phasor_i = m_phasor_b0 * phasor_i
                   - m_phasor_a1 * m_phasor_i1
                   - m_phasor_a2 * m_phasor_i2;
        phasor_q = m_phasor_b0 * phasor_q
                   - m_phasor_a1 * m_phasor_q1
                   - m_phasor_a2 * m_phasor_q2;
        m_phasor_i2 = m_phasor_i1;
        m_phasor_i1 = phasor_i;
        m_phasor_q2 = m_phasor_q1;
        m_phasor_q1 = phasor_q;

        // Convert I/Q ratio to estimate of phase error.
        Real phase_err;
        if (phasor_i > std::abs(phasor_q)) {
            // We are within +/- 45 degrees from lock.
            // Use simple linear approximation of arctan.
            phase_err = phasor_q / phasor_i;
        } else if (phasor_q > 0) {
            // We are lagging more than 45 degrees behind the input.
            phase_err = 1;
        } else {
            // We are more than 45 degrees ahead of the input.
            phase_err = -1;
        }

        // Detect pilot level (conservative).
        m_pilot_level = std::min(m_pilot_level, phasor_i);

        // Run phase error through loop filter and update frequency estimate.
        m_freq += m_loopfilter_b0 * phase_err
                  + m_loopfilter_b1 * m_loopfilter_x1;
        m_loopfilter_x1 = phase_err;

        // Limit frequency to allowable range.
        m_freq = std::max(m_minfreq, std::min(m_maxfreq, m_freq));

        // Update locked phase.
        m_phase += m_freq;
        if (m_phase > 2.0 * M_PI) {
            m_phase -= 2.0 * M_PI;
            m_pilot_periods++;

            // Generate pulse-per-second.
            if (m_pilot_periods == pilot_frequency) {
                m_pilot_periods = 0;
                if (was_locked) {
                    struct PpsEvent ev;
                    ev.pps_index      = m_pps_cnt;
                    ev.sample_index   = m_sample_cnt + i;
                    ev.block_position = double(i) / double(n);
                    m_pps_events.push_back(ev);
                    m_pps_cnt++;
                }
            }
        }
    }

    // Update lock status.
    if (2 * m_pilot_level > m_minsignal) {
        if (m_lock_cnt < m_lock_delay)
            m_lock_cnt += n;
    } else {
        m_lock_cnt = 0;
    }

    // Drop PPS events when pilot not locked.
    if (m_lock_cnt < m_lock_delay) {
        m_pilot_periods = 0;
        m_pps_cnt = 0;
        m_pps_events.clear();
    }

    // Update sample counter.
    m_sample_cnt += n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

process() [2/3]

void PhaseLock::process	(	const Real &	sample_in,
		Real *	samples_out
	)

Process samples and track a pilot tone. Generate samples for single or multiple phase-locked signals. Implement the processPhase virtual method to produce the output samples. In flow version. Ex: Use 19 kHz stereo pilot tone to generate 38 kHz (stereo) and 57 kHz pilots (see RDSPhaseLock class below). This is the in flow version

Definition at line 254 of file phaselock.cpp.

References cos(), m_pcos, m_phase, m_pps_events, m_psin, process_phasor(), processPhase(), and sin().

{
    m_pps_events.clear();

    // Generate locked pilot tone.
    m_psin = sin(m_phase);
    m_pcos = cos(m_phase);

    // Generate output
    processPhase(samples_out);

    // Multiply locked tone with input.
    Real phasor_i = m_psin * sample_in;
    Real phasor_q = m_pcos * sample_in;

    // Actual PLL
    process_phasor(phasor_i, phasor_q);
}

Here is the call graph for this function:

process() [3/3]

void PhaseLock::process	(	const Real &	real_in,
		const Real &	imag_in,
		Real *	samples_out
	)

Definition at line 273 of file phaselock.cpp.

References cos(), m_pcos, m_phase, m_pps_events, m_psin, process_phasor(), processPhase(), and sin().

{
    m_pps_events.clear();

    // Generate locked pilot tone.
    m_psin = sin(m_phase);
    m_pcos = cos(m_phase);

    // Generate output
    processPhase(samples_out);

    // Multiply locked tone with input.
    Real phasor_i = m_psin * real_in - m_pcos * imag_in;
    Real phasor_q = m_pcos * real_in + m_psin * imag_in;

    // Actual PLL
    process_phasor(phasor_i, phasor_q);
}

Here is the call graph for this function:

process_phasor()

void PhaseLock::process_phasor ( Real &  phasor_i, Real &  phasor_q  )

private

Definition at line 292 of file phaselock.cpp.

References abs(), m_freq, m_lock_cnt, m_lock_delay, m_loopfilter_b0, m_loopfilter_b1, m_loopfilter_x1, m_maxfreq, m_minfreq, m_minsignal, m_phase, m_phasor_a1, m_phasor_a2, m_phasor_b0, m_phasor_i1, m_phasor_i2, m_phasor_q1, m_phasor_q2, M_PI, m_pilot_level, m_pilot_periods, m_pps_cnt, m_pps_events, m_sample_cnt, leansdr::max(), leansdr::min(), and pilot_frequency.

Referenced by process().

{
    // Run IQ phase error through low-pass filter.
    phasor_i = m_phasor_b0 * phasor_i
               - m_phasor_a1 * m_phasor_i1
               - m_phasor_a2 * m_phasor_i2;
    phasor_q = m_phasor_b0 * phasor_q
               - m_phasor_a1 * m_phasor_q1
               - m_phasor_a2 * m_phasor_q2;
    m_phasor_i2 = m_phasor_i1;
    m_phasor_i1 = phasor_i;
    m_phasor_q2 = m_phasor_q1;
    m_phasor_q1 = phasor_q;

    // Convert I/Q ratio to estimate of phase error.
    Real phase_err;
    if (phasor_i > std::abs(phasor_q)) {
        // We are within +/- 45 degrees from lock.
        // Use simple linear approximation of arctan.
        phase_err = phasor_q / phasor_i;
    } else if (phasor_q > 0) {
        // We are lagging more than 45 degrees behind the input.
        phase_err = 1;
    } else {
        // We are more than 45 degrees ahead of the input.
        phase_err = -1;
    }

    // Detect pilot level (conservative).
    // m_pilot_level = std::min(m_pilot_level, phasor_i);
    m_pilot_level = phasor_i;

    // Run phase error through loop filter and update frequency estimate.
    m_freq += m_loopfilter_b0 * phase_err
              + m_loopfilter_b1 * m_loopfilter_x1;
    m_loopfilter_x1 = phase_err;

    // Limit frequency to allowable range.
    m_freq = std::max(m_minfreq, std::min(m_maxfreq, m_freq));

    // Update locked phase.
    m_phase += m_freq;
    if (m_phase > 2.0 * M_PI)
    {
        m_phase -= 2.0 * M_PI;
        m_pilot_periods++;

        // Generate pulse-per-second.
        if (m_pilot_periods == pilot_frequency)
        {
            m_pilot_periods = 0;
        }
    }

    // Update lock status.
    if (2 * m_pilot_level > m_minsignal)
    {
        if (m_lock_cnt < m_lock_delay)
        {
            m_lock_cnt += 1; // n
        }
    }
    else
    {
        m_lock_cnt = 0;
    }

    // Drop PPS events when pilot not locked.
    if (m_lock_cnt < m_lock_delay) {
        m_pilot_periods = 0;
        m_pps_cnt = 0;
        m_pps_events.clear();
    }

    // Update sample counter.
    m_sample_cnt += 1; // n
}

Here is the call graph for this function:

Here is the caller graph for this function:

processPhase()

virtual void PhaseLock::processPhase ( Real *  samples_out ) const

inlineprotectedvirtual

Callback method to produce multiple outputs from the current phase value in m_phase and/or the sin and cos values in m_psin and m_pcos

Reimplemented in RDSPhaseLock, StereoPhaseLock, and SimplePhaseLock.

Definition at line 99 of file phaselock.h.

Referenced by process().

{ (void) samples_out; }

Here is the caller graph for this function:

Member Data Documentation

m_freq

Real PhaseLock::m_freq

private

Definition at line 107 of file phaselock.h.

Referenced by configure(), PhaseLock(), process(), and process_phasor().

m_lock_cnt

int PhaseLock::m_lock_cnt

private

Definition at line 111 of file phaselock.h.

Referenced by configure(), PhaseLock(), process(), and process_phasor().

m_lock_delay

int PhaseLock::m_lock_delay

private

Definition at line 110 of file phaselock.h.

Referenced by configure(), PhaseLock(), process(), and process_phasor().

m_loopfilter_b0

Real PhaseLock::m_loopfilter_b0

private

Definition at line 105 of file phaselock.h.

Referenced by configure(), PhaseLock(), process(), and process_phasor().

m_loopfilter_b1

Real PhaseLock::m_loopfilter_b1

private

Definition at line 105 of file phaselock.h.

Referenced by configure(), PhaseLock(), process(), and process_phasor().

m_loopfilter_x1

Real PhaseLock::m_loopfilter_x1

private

Definition at line 106 of file phaselock.h.

Referenced by configure(), PhaseLock(), process(), and process_phasor().

m_maxfreq

Real PhaseLock::m_maxfreq

private

Definition at line 102 of file phaselock.h.

Referenced by configure(), PhaseLock(), process(), and process_phasor().

m_minfreq

Real PhaseLock::m_minfreq

private

Definition at line 102 of file phaselock.h.

Referenced by configure(), PhaseLock(), process(), and process_phasor().

m_minsignal

Real PhaseLock::m_minsignal

private

Definition at line 108 of file phaselock.h.

Referenced by configure(), PhaseLock(), process(), and process_phasor().

m_pcos

Real PhaseLock::m_pcos

protected

Definition at line 94 of file phaselock.h.

Referenced by PhaseLock(), and process().

m_phase

Real PhaseLock::m_phase

protected

Definition at line 92 of file phaselock.h.

Referenced by configure(), PhaseLock(), process(), and process_phasor().

m_phasor_a1

Real PhaseLock::m_phasor_a1

private

Definition at line 103 of file phaselock.h.

Referenced by configure(), PhaseLock(), process(), and process_phasor().

m_phasor_a2

Real PhaseLock::m_phasor_a2

private

Definition at line 103 of file phaselock.h.

Referenced by configure(), PhaseLock(), process(), and process_phasor().

m_phasor_b0

Real PhaseLock::m_phasor_b0

private

Definition at line 103 of file phaselock.h.

Referenced by configure(), PhaseLock(), process(), and process_phasor().

m_phasor_i1

Real PhaseLock::m_phasor_i1

private

Definition at line 104 of file phaselock.h.

Referenced by configure(), PhaseLock(), process(), and process_phasor().

m_phasor_i2

Real PhaseLock::m_phasor_i2

private

Definition at line 104 of file phaselock.h.

Referenced by configure(), PhaseLock(), process(), and process_phasor().

m_phasor_q1

Real PhaseLock::m_phasor_q1

private

Definition at line 104 of file phaselock.h.

Referenced by configure(), PhaseLock(), process(), and process_phasor().

m_phasor_q2

Real PhaseLock::m_phasor_q2

private

Definition at line 104 of file phaselock.h.

Referenced by configure(), PhaseLock(), process(), and process_phasor().

m_pilot_level

Real PhaseLock::m_pilot_level

private

Definition at line 109 of file phaselock.h.

Referenced by configure(), PhaseLock(), process(), and process_phasor().

m_pilot_periods

int PhaseLock::m_pilot_periods

private

Definition at line 112 of file phaselock.h.

Referenced by configure(), PhaseLock(), process(), and process_phasor().

m_pps_cnt

quint64 PhaseLock::m_pps_cnt

private

Definition at line 113 of file phaselock.h.

Referenced by configure(), PhaseLock(), process(), and process_phasor().

m_pps_events

std::vector<PpsEvent> PhaseLock::m_pps_events

private

Definition at line 115 of file phaselock.h.

Referenced by process(), and process_phasor().

m_psin

Real PhaseLock::m_psin

protected

Definition at line 93 of file phaselock.h.

Referenced by PhaseLock(), and process().

m_sample_cnt

quint64 PhaseLock::m_sample_cnt

private

Definition at line 114 of file phaselock.h.

Referenced by configure(), PhaseLock(), process(), and process_phasor().

pilot_frequency

const int PhaseLock::pilot_frequency = 19000

static

Expected pilot frequency (used for PPS events).

Definition at line 29 of file phaselock.h.

Referenced by process(), and process_phasor().

---

The documentation for this class was generated from the following files:

• sdrbase/dsp/phaselock.h
• sdrbase/dsp/phaselock.cpp