Projector Class Reference

#include <projector.h>

Public Types
enum	ProjectionType {   ProjectionReal = 0, ProjectionImag, ProjectionMagLin, ProjectionMagSq,   ProjectionMagDB, ProjectionPhase, ProjectionDPhase, ProjectionBPSK,   ProjectionQPSK, Projection8PSK, Projection16PSK, nbProjectionTypes }

Public Member Functions
	Projector (ProjectionType projectionType)
	~Projector ()
ProjectionType	getProjectionType () const
void	settProjectionType (ProjectionType projectionType)
void	setCache (Real *cache)
void	setCacheMaster (bool cacheMaster)
Real	run (const Sample &s)

Static Private Member Functions
static Real	normalizeAngle (Real angle)

Private Attributes
ProjectionType	m_projectionType
Real	m_prevArg
Real *	m_cache
bool	m_cacheMaster

Detailed Description

Definition at line 22 of file projector.h.

Member Enumeration Documentation

ProjectionType

enum Projector::ProjectionType

Enumerator
ProjectionReal	Extract real part.
ProjectionImag	Extract imaginary part.
ProjectionMagLin	Calculate linear magnitude or modulus.
ProjectionMagSq	Calculate linear squared magnitude or power.
ProjectionMagDB	Calculate logarithmic (dB) of squared magnitude.
ProjectionPhase	Calculate phase.
ProjectionDPhase	Calculate phase derivative i.e. instantaneous frequency scaled to sample rate.
ProjectionBPSK	Phase comparator BPSK evaluation.
ProjectionQPSK	Phase comparator QPSK evaluation.
Projection8PSK	Phase comparator 8-PSK evaluation.
Projection16PSK	Phase comparator 16-PSK evaluation.
nbProjectionTypes	Gives the number of projections in the enum.

Definition at line 25 of file projector.h.

    {
        ProjectionReal = 0, 
        ProjectionImag,     
        ProjectionMagLin,   
        ProjectionMagSq,    
        ProjectionMagDB,    
        ProjectionPhase,    
        ProjectionDPhase,   
        ProjectionBPSK,     
        ProjectionQPSK,     
        Projection8PSK,     
        Projection16PSK,    
        nbProjectionTypes   
    };

Constructor & Destructor Documentation

Projector()

Projector::Projector

(

ProjectionType

projectionType

)

Definition at line 23 of file projector.cpp.

                                                  :
    m_projectionType(projectionType),
    m_prevArg(0.0f),
    m_cache(0),
    m_cacheMaster(true)
{
}

~Projector()

Projector::~Projector

(

)

Definition at line 31 of file projector.cpp.

{
}

Member Function Documentation

getProjectionType()

ProjectionType Projector::getProjectionType ( ) const

inline

Definition at line 44 of file projector.h.

Referenced by ScopeVis::TriggerCondition::setData(), and ScopeVis::TriggerComparator::triggered().

{ return m_projectionType; }

Here is the caller graph for this function:

normalizeAngle()

Real Projector::normalizeAngle ( Real  angle )

staticprivate

Definition at line 204 of file projector.cpp.

References M_PI.

Referenced by run().

{
    while (angle <= -M_PI) {
        angle += 2.0*M_PI;
    }
    while (angle > M_PI) {
        angle -= 2.0*M_PI;
    }
    return angle;
}

Here is the caller graph for this function:

run()

Real Projector::run

(

const Sample &

s

)

Definition at line 35 of file projector.cpp.

References arg(), m_cache, m_cacheMaster, Sample::m_imag, M_PI, m_prevArg, m_projectionType, Sample::m_real, normalizeAngle(), Projection16PSK, Projection8PSK, ProjectionBPSK, ProjectionDPhase, ProjectionImag, ProjectionMagDB, ProjectionMagLin, ProjectionMagSq, ProjectionPhase, ProjectionQPSK, ProjectionReal, SDR_RX_SCALEF, and sqrt().

Referenced by ScopeVis::TriggerComparator::triggered().

{
    Real v;

    if ((m_cache) && !m_cacheMaster) {
        return m_cache[(int) m_projectionType];
    }
    else
    {
        switch (m_projectionType)
        {
        case ProjectionImag:
            v = s.m_imag / SDR_RX_SCALEF;
            break;
        case ProjectionMagLin:
        {
            Real re = s.m_real / SDR_RX_SCALEF;
            Real im = s.m_imag / SDR_RX_SCALEF;
            Real magsq = re*re + im*im;
            v = std::sqrt(magsq);
        }
            break;
        case ProjectionMagSq:
        {
            Real re = s.m_real / SDR_RX_SCALEF;
            Real im = s.m_imag / SDR_RX_SCALEF;
            v = re*re + im*im;
        }
            break;
        case ProjectionMagDB:
        {
            Real re = s.m_real / SDR_RX_SCALEF;
            Real im = s.m_imag / SDR_RX_SCALEF;
            Real magsq = re*re + im*im;
            v = log10f(magsq) * 10.0f;
        }
            break;
        case ProjectionPhase:
            v = std::atan2((float) s.m_imag, (float) s.m_real) / M_PI;
            break;
        case ProjectionDPhase:
        {
            Real curArg = std::atan2((float) s.m_imag, (float) s.m_real);
            Real dPhi = (curArg - m_prevArg) / M_PI;
            m_prevArg = curArg;

            if (dPhi < -1.0f) {
                dPhi += 2.0f;
            } else if (dPhi > 1.0f) {
                dPhi -= 2.0f;
            }

            v = dPhi;
        }
            break;
        case ProjectionBPSK:
        {
            Real arg = std::atan2((float) s.m_imag, (float) s.m_real);
            v = normalizeAngle(2*arg) / (2.0*M_PI); // generic estimation around 0
            // mapping on 2 symbols
            if (arg < -M_PI/2) {
                v -= 1.0/2;
            } else if (arg < M_PI/2) {
                v += 1.0/2;
            } else if (arg < M_PI) {
                v -= 1.0/2;
            }
        }
            break;
        case ProjectionQPSK:
        {
            Real arg = std::atan2((float) s.m_imag, (float) s.m_real);
            v = normalizeAngle(4*arg) / (4.0*M_PI); // generic estimation around 0
            // mapping on 4 symbols
            if (arg < -3*M_PI/4) {
                v -= 3.0/4;
            } else if (arg < -M_PI/4) {
                v -= 1.0/4;
            } else if (arg < M_PI/4) {
                v += 1.0/4;
            } else if (arg < 3*M_PI/4) {
                v += 3.0/4;
            } else if (arg < M_PI) {
                v -= 3.0/4;
            }
        }
            break;
        case Projection8PSK:
        {
            Real arg = std::atan2((float) s.m_imag, (float) s.m_real);
            v = normalizeAngle(8*arg) / (8.0*M_PI); // generic estimation around 0
            // mapping on 8 symbols
            if (arg < -7*M_PI/8) {
               v -= 7.0/8;
            } else if (arg < -5*M_PI/8) {
                v -= 5.0/8;
            } else if (arg < -3*M_PI/8) {
                v -= 3.0/8;
            } else if (arg < -M_PI/8) {
                v -= 1.0/8;
            } else if (arg < M_PI/8) {
                v += 1.0/8;
            } else if (arg < 3*M_PI/8) {
                v += 3.0/8;
            } else if (arg < 5*M_PI/8) {
                v += 5.0/8;
            } else if (arg < 7*M_PI/8) {
                v += 7.0/8;
            } else if (arg < M_PI) {
                v -= 7.0/8;
            }
        }
            break;
        case Projection16PSK:
        {
            Real arg = std::atan2((float) s.m_imag, (float) s.m_real);
            v = normalizeAngle(16*arg) / (16.0*M_PI); // generic estimation around 0
            // mapping on 16 symbols
            if (arg < -15*M_PI/16) {
               v -= 15.0/16;
            } else if (arg < -13*M_PI/16) {
                v -= 13.0/6;
            } else if (arg < -11*M_PI/16) {
                v -= 11.0/16;
            } else if (arg < -9*M_PI/16) {
                v -= 9.0/16;
            } else if (arg < -7*M_PI/16) {
                v -= 7.0/16;
            } else if (arg < -5*M_PI/16) {
                v -= 5.0/16;
            } else if (arg < -3*M_PI/16) {
                v -= 3.0/16;
            } else if (arg < -M_PI/16) {
                v -= 1.0/16;
            } else if (arg < M_PI/16) {
                v += 1.0/16;
            } else if (arg < 3.0*M_PI/16) {
                v += 3.0/16;
            } else if (arg < 5.0*M_PI/16) {
                v += 5.0/16;
            } else if (arg < 7.0*M_PI/16) {
                v += 7.0/16;
            } else if (arg < 9.0*M_PI/16) {
                v += 9.0/16;
            } else if (arg < 11.0*M_PI/16) {
                v += 11.0/16;
            } else if (arg < 13.0*M_PI/16) {
                v += 13.0/16;
            } else if (arg < 15.0*M_PI/16) {
                v += 15.0/16;
            } else if (arg < M_PI) {
                v -= 15.0/16;
            }
        }
            break;
        case ProjectionReal:
        default:
            v = s.m_real / SDR_RX_SCALEF;
            break;
        }

        if (m_cache) {
            m_cache[(int) m_projectionType] = v;
        }

        return v;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

setCache()

void Projector::setCache ( Real *  cache )

inline

Definition at line 46 of file projector.h.

{ m_cache = cache; }

setCacheMaster()

void Projector::setCacheMaster ( bool  cacheMaster )

inline

Definition at line 47 of file projector.h.

{ m_cacheMaster = cacheMaster; }

settProjectionType()

void Projector::settProjectionType ( ProjectionType  projectionType )

inline

Definition at line 45 of file projector.h.

Referenced by ScopeVis::TriggerCondition::initProjector(), ScopeVis::TraceControl::initProjector(), and ScopeVis::TriggerCondition::setData().

{ m_projectionType = projectionType; }

Here is the caller graph for this function:

Member Data Documentation

m_cache

Real* Projector::m_cache

private

Definition at line 55 of file projector.h.

Referenced by run().

m_cacheMaster

bool Projector::m_cacheMaster

private

Definition at line 56 of file projector.h.

Referenced by run().

m_prevArg

Real Projector::m_prevArg

private

Definition at line 54 of file projector.h.

Referenced by run().

m_projectionType

ProjectionType Projector::m_projectionType

private

Definition at line 53 of file projector.h.

Referenced by run().

---

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

• sdrbase/dsp/projector.h
• sdrbase/dsp/projector.cpp