root/experimental/components/Demodulator/src/DemodulatorDSP.cpp @ 3998

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

Copyright 2007 Virginia Polytechnic Institute and State University

This file is part of the OSSIE Demodulator.

OSSIE Demodulator 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 Demodulator 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 Demodulator; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

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


#include <iostream>
#include "DemodulatorDSP.h"
#include <math.h>

// Default constructor
DemodulatorDSP::DemodulatorDSP()
{
    SetModulationScheme( MOD_BPSK );
}

// Destructor
DemodulatorDSP::~DemodulatorDSP()
{
}

// Set modulation scheme
void DemodulatorDSP::SetModulationScheme( ModulationScheme _ms )
{
    switch ( _ms ) {
    case MOD_BPSK:
        Demodulate = &DemodulateBPSK;
        bitsPerSymbol = 1;
        differentialMode = false;
        break;
    case MOD_QPSK:
        Demodulate = &DemodulateQPSK;
        bitsPerSymbol = 2;
        differentialMode = false;
        break;
    case MOD_8PSK:
        Demodulate = &Demodulate8PSK;
        bitsPerSymbol = 3;
        differentialMode = false;
        break;
    case MOD_16QAM:
        Demodulate = &Demodulate16QAM;
        bitsPerSymbol = 4;
        differentialMode = false;
        break;
    case MOD_4PAM:
        Demodulate = &Demodulate4PAM;
        bitsPerSymbol = 2;
        differentialMode = false;
        break;
    case MOD_DBPSK:
        state_i = 0;
        state_q = 0;
        Demodulate = &DemodulateBPSK;
        bitsPerSymbol = 1;
        differentialMode = true;
        break;
    case MOD_DQPSK:
        state_i = 0;
        state_q = 0;
        Demodulate = &DemodulateQPSK;
        bitsPerSymbol = 2;
        differentialMode = true;
        break;
    case MOD_D8PSK:
        state_i = 0;
        state_q = 0;
        Demodulate = &Demodulate8PSK;
        bitsPerSymbol = 3;
        differentialMode = true;
        break;
    default:
        std::cerr << "ERROR: DemodulatorDSP::SetModulationScheme(): "
                  << "unknown mod. scheme " << _ms << std::endl;
        std::cerr << "  => Using BPSK instead" << std::endl;
        SetModulationScheme( MOD_BPSK );
        //throw 0;
    }
    
    mod_scheme = _ms;
}

///
void DemodulatorDSP::DemodulateSequence(
        short * I_in,
        short * Q_in, 
        unsigned int N_in, 
        char * bits_out)
{
    unsigned int i, j(0);

    // If QAM or PAM correct for amplitude
    if ( mod_scheme == MOD_16QAM || mod_scheme == MOD_4PAM ) {
        ScaleSignalAmplitude(I_in, Q_in, N_in, TARGET_SIGNAL_ENERGY);
    }

    if ( differentialMode ) {
        ///\todo implement differential PSK demodulation
        std::cerr << "ERROR: DemodulatorDSP::DemodulateSequence(): "
                  << "differential mode not yet supported!" << std::endl;
        throw 0;
    } else {
        for (i=0; i<N_in; i++) {
            Demodulate(I_in[i], Q_in[i], bits_out+j);
            j += bitsPerSymbol;
        }
    }
}


//
void DemodulatorDSP::ScaleSignalAmplitude(
    short * I_in,
    short * Q_in,
    unsigned int N_in,
    unsigned int targetEnergy)
{
    unsigned int i;
    float energy(0.0f), scalingFactor;
    for (i=0; i<N_in; i++) {
        energy += float(I_in[i])*float(I_in[i]);
        energy += float(Q_in[i])*float(Q_in[i]);
    }
    energy /= float(N_in);

    scalingFactor = float(targetEnergy)/sqrtf(energy);

    for (i=0; i<N_in; i++) {
        I_in[i] = short( I_in[i]*scalingFactor );
        Q_in[i] = short( Q_in[i]*scalingFactor );
    }
}


//
void DemodulateBPSK(
    short & I_in,
    short & Q_in,
    char * bits_out)
{
    bits_out[0] = ( I_in > 0 ) ? BIT1 : BIT0;
}

//
void DemodulateQPSK(
    short & I_in,
    short & Q_in,
    char * bits_out)
{
    bits_out[0] = ( I_in > 0 ) ? BIT1 : BIT0;
    bits_out[1] = ( Q_in > 0 ) ? BIT1 : BIT0;
}

//
void Demodulate8PSK(
    short & I_in,
    short & Q_in,
    char * bits_out)
{
    // rotate constellation counter-clockwise by 22.5 degrees
    ///\todo Find more efficient way to rotate by 22.5 degrees
    short I = short(  float(I_in*DEMOD_COS_22_5) - float(Q_in*DEMOD_SIN_22_5)  );
    short Q = short(  float(I_in*DEMOD_SIN_22_5) + float(Q_in*DEMOD_COS_22_5)  );

    bits_out[0] = ( I > 0 ) ? BIT0 : BIT1;
    bits_out[1] = ( Q > 0 ) ? BIT0 : BIT1;
    if ( ( Q>I && -I>Q ) || ( Q>-I && I>Q ) )
        bits_out[2] = BIT0;
    else
        bits_out[2] = BIT1;
}

//
void Demodulate16QAM(
    short & I_in,
    short & Q_in,
    char * bits_out)
{
    std::cerr << "ERROR: Demodulate16QAM not yet supported!" << std::endl;
    throw 0;
}

//
void Demodulate4PAM(
    short & I_in,
    short & Q_in,
    char * bits_out)
{
    if ( I_in > 0 ) {
        bits_out[0] = BIT0;
        bits_out[1] = ( I_in >  PAM4_THRESHOLD ) ? BIT0 : BIT1;
    } else {
        bits_out[0] = BIT1;
        bits_out[1] = ( I_in < -PAM4_THRESHOLD ) ? BIT0 : BIT1;
    }
}