root/experimental/components/SymbolSyncPoly/branches/SymbolSyncPoly-metadata/src/MultirateSynchronizerDSP.h @ 4767

/****************************************************************************

Copyright 2007 Virginia Polytechnic Institute and State University

This file is part of the OSSIE MultirateSynchronizer.

OSSIE MultirateSynchronizer is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

OSSIE MultirateSynchronizer is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with OSSIE MultirateSynchronizer; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

****************************************************************************/


#ifndef MULTIRATESYNCHRONIZERDSP_IMPL_H
#define MULTIRATESYNCHRONIZERDSP_IMPL_H

#include <stdlib.h>
#include "SymbolSyncPolyDSP.h"

#define ALPHA_C_LO 0.0066667
#define ALPHA_C_HI 0.066667
#define BETA_C_LO  7.8567e-06
#define BETA_C_HI  0.0023570

#define QAM16_PHASE_ERROR_THRESHOLD_1 7236
#define QAM16_PHASE_ERROR_THRESHOLD_2 11708

/// Modulation scheme for phase error generator
enum ModulationScheme {
    MOD_BPSK  = 0,
    MOD_QPSK  = 1,
    MOD_8PSK  = 2,
    MOD_16QAM = 3,
    MOD_4PAM  = 4
};


/** \brief Digital signal processing for the synchronizer component
 *  implemented with the polyphase filter bank
 *
 *
 */
class MultirateSynchronizerDSP : public SymbolSyncPolyDSP
{
  public:
    /// Initializing constructor
    MultirateSynchronizerDSP();

    /// Destructor
    ~MultirateSynchronizerDSP();

    /// Set modulation scheme for phase error generator
    void SetModulationScheme(ModulationScheme _ms);

    ///
    ///\todo change to : void UpdatePhaseLoopFilterCoefficients(float _BT);
    void UpdatePhaseLoopFilterCoefficients(float _alpha_c, float _beta_c) {
        alpha_c = _alpha_c;
        beta_c = _beta_c;
    }

    /// Overriding method...
    void SynchronizeAndDecimate(short * I_in,
        short * Q_in,
        unsigned int N_in,
        short * I_out,
        short * Q_out,
        unsigned int & N_out);

  protected:
    ///
    ModulationScheme mod_scheme;

    /// 
    float (*GeneratePhaseError) (short &I, short &Q);

    /// Pushes inputs determined by flow control as necessary (overloaded function)
    void PushInputs( short * I_in, short * Q_in, unsigned int &i, unsigned int N_in );

    ///
    void AdvancePhaseLoopFilter() {
        q_prime_c = q_c*beta_c + buff2_c;
        q_hat_c = alpha_c*q_c + q_prime_c;
        buff2_c = q_prime_c;
    }

    /// Apply numerically controlled oscillator
    void ApplyNCO( short I_in, short Q_in, short &I_out, short &Q_out ) {
        I_out = short( float(I_in) * nco_i + float(Q_in) * nco_q );
        Q_out = short( float(Q_in) * nco_i - float(I_in) * nco_q );
    }

    /// Update numerically controlled oscillator
    void UpdateNCO();

    // Carrier phase loop filter
    float alpha_c;      ///< Phase loop filter coefficient, \f$\alpha_c\f$
    float beta_c;       ///< Phase loop filter coefficient, \f$\beta_c\f$
    float q_c;          ///< Phase error signal
    float q_hat_c;      ///< Filtered phase error signal
    float q_prime_c;    ///< Phase loop filter buffer 1
    float buff2_c;      ///< Phase loop filter buffer 2

    // Numerically-controlled oscillator
    float nco_control;  ///< NCO control phase, \f$\int{cv}\f$
    float cv;           ///< NCO control voltage
    float wcTs;         ///< Initial frequency offset estimate
    float nco_i;        ///< NCO in-phase output
    float nco_q;        ///< NCO quadrature output

  private:
    /// Disallow copy constructor
    MultirateSynchronizerDSP(MultirateSynchronizerDSP&);

};

/// Phase error generator for BPSK modulation
float GeneratePhaseErrorBPSK(short &I, short &Q);

/// Phase error generator for QPSK modulation
float GeneratePhaseErrorQPSK(short &I, short &Q);

/// Phase error generator for 8PSK modulation
float GeneratePhaseError8PSK(short &I, short &Q);

/// Phase error generator for 16QAM modulation
float GeneratePhaseError16QAM(short &I, short &Q);

/// Phase error generator for 4-PAM modulation
float GeneratePhaseError4PAM(short &I, short &Q);

#endif