root/experimental/components/FrameAssembler/src/FrameAssembler.cpp @ 3961

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

Copyright 2007 Virginia Polytechnic Institute and State University

This file is part of the OSSIE FrameAssembler.

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

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


#include <string>
#include <iostream>
#include "FrameAssembler.h"

FrameAssembler_i::FrameAssembler_i(const char *uuid, omni_condition *condition) : 
    Resource_impl(uuid), component_running(condition)
{
    dataIn_0 = new standardInterfaces_i::complexShort_p("SymbolsIn");
    dataOut_0 = new standardInterfaces_i::complexShort_u("FrameSymbolsOut");

    //Create the thread for the writer's processing function 
    processing_thread = new omni_thread(Run, (void *) this);

    //Start the thread containing the writer's processing function 
    processing_thread->start();

}

FrameAssembler_i::~FrameAssembler_i(void)
{   
    delete dataIn_0;
    delete dataOut_0;
}

// Static function for omni thread
void FrameAssembler_i::Run( void * data )
{
    ((FrameAssembler_i*)data)->ProcessData();
}

CORBA::Object_ptr FrameAssembler_i::getPort( const char* portName ) throw (
    CORBA::SystemException, CF::PortSupplier::UnknownPort)
{
    DEBUG(3, FrameAssembler, "getPort() invoked with " << portName)
    
    CORBA::Object_var p;

    p = dataIn_0->getPort(portName);

    if (!CORBA::is_nil(p))
        return p._retn();

    p = dataOut_0->getPort(portName);

    if (!CORBA::is_nil(p))
        return p._retn();

    // Requested port not recognized
    throw CF::PortSupplier::UnknownPort();
}

void FrameAssembler_i::start() throw (CORBA::SystemException, 
    CF::Resource::StartError)
{
    DEBUG(3, FrameAssembler, "start() invoked")
}

void FrameAssembler_i::stop() throw (CORBA::SystemException, CF::Resource::StopError) 
{  
    DEBUG(3, FrameAssembler, "stop() invoked")
}

void FrameAssembler_i::releaseObject() throw (CORBA::SystemException,
    CF::LifeCycle::ReleaseError)
{
    DEBUG(3, FrameAssembler, "releaseObject() invoked")
    
    component_running->signal();
}

void FrameAssembler_i::initialize() throw (CF::LifeCycle::InitializeError,
    CORBA::SystemException)
{
    DEBUG(3, FrameAssembler, "initialize() invoked")
}

void FrameAssembler_i::configure(const CF::Properties& props)
throw (CORBA::SystemException,
    CF::PropertySet::InvalidConfiguration,
    CF::PropertySet::PartialConfiguration)
{
    DEBUG(3, FrameAssembler, "configure() invoked")
    
    std::cout << "props length : " << props.length() << std::endl;

    for (unsigned int i = 0; i <props.length(); i++) {
        std::cout << "Property id : " << props[i].id << std::endl;

        if (strcmp(props[i].id, "DCE:690f320c-5bee-4959-b93d-586dc3450aac") == 0) {
            // Modulation type
            const char * prop_str;
            props[i].value >>= prop_str;

            // Set appropriate modulation function
            if ( strcmp(prop_str, "BPSK") == 0 ) {
                ConfigureModulationScheme(BPSK);
            } else if ( strcmp(prop_str, "QPSK") == 0 ) {
                ConfigureModulationScheme(QPSK);
            } else if ( strcmp(prop_str, "8PSK") == 0 ) {
                ConfigureModulationScheme(PSK8);
            } else if ( strcmp(prop_str, "16QAM") == 0 ) {
                ConfigureModulationScheme(QAM16);
            } else {
                // unknown property
                std::cerr << "ERROR: FrameAssembler::configure() unknown mod. scheme "
                          << prop_str << std::endl;
                throw CF::PropertySet::InvalidConfiguration();
            }
            ///\todo catch exception thrown by FrameAssemblerDSP::ConfigureModulationScheme()

        } else if (strcmp(props[i].id, "DCE:25a1df92-7f22-43af-8720-ad37714a66db") == 0) {
            // Frame size
            CORBA::UShort simple_temp;
            props[i].value >>= simple_temp;

            ConfigureFrameSize(simple_temp);

        } else {
            // unknown property
            std::cerr << "ERROR: FrameAssembler::configure() unknown property" << std::endl;
            throw CF::PropertySet::InvalidConfiguration();
        }
    }

}

void FrameAssembler_i::ProcessData()
{
    DEBUG(3, FrameAssembler, "ProcessData() invoked")

    PortTypes::ShortSequence I_out_0, Q_out_0;

    PortTypes::ShortSequence *I_in_0(NULL), *Q_in_0(NULL);
    unsigned int N_in(0);

    // Prepare preamble phasing pattern
    short * I_phasing_pattern = new short[512];
    short * Q_phasing_pattern = new short[512];
    PortTypes::ShortSequence I_out_phasing_pattern, Q_out_phasing_pattern;
    I_out_phasing_pattern.length(512);
    Q_out_phasing_pattern.length(512);

    AssemblePhasingPattern(I_phasing_pattern, Q_phasing_pattern);
    for (unsigned int i=0; i<512; i++) {
        I_out_phasing_pattern[i] = I_phasing_pattern[i];
        Q_out_phasing_pattern[i] = Q_phasing_pattern[i];
    }
    delete [] I_phasing_pattern;
    delete [] Q_phasing_pattern;


    short * I_header = new short[512];
    short * Q_header = new short[512];

    while( true ) {
        // Get data from port
        dataIn_0->getData(I_in_0, Q_in_0);

        // Read input data length
        N_in = I_in_0->length();

        switch ( operationalMode ) {
        case ASSEMBLE_PREAMBLE:
            DEBUG(4, FrameAssembler, "Assembling preamble")

            // push
            dataOut_0->pushPacket(I_out_phasing_pattern, Q_out_phasing_pattern);

            // do not break; continue to assemble header
            operationalMode = ASSEMBLE_HEADER;

        case ASSEMBLE_HEADER:
            DEBUG(4, FrameAssembler, "Assembling header")
            // copy header
            I_out_0.length(512);
            Q_out_0.length(512);
            AssembleHeader( I_header, Q_header );
            for (unsigned int i=0; i<512; i++) {
                I_out_0[i] = I_header[i];
                Q_out_0[i] = Q_header[i];
            }

            // push data
            dataOut_0->pushPacket(I_out_0, Q_out_0);

            // do not break; continue to assemble frame
            operationalMode = ASSEMBLE_FRAME;

            numFrameSymbolsAssembled = 0;

        case ASSEMBLE_FRAME:
            DEBUG(4, FrameAssembler, "Assembling frame (s=" << numFrameSymbolsAssembled << ")")
            // copy data from input buffer to output
            
            I_out_0.length(N_in);
            Q_out_0.length(N_in);

            for (unsigned int i=0; i<N_in; i++) {
                //
                I_out_0[i] = (*I_in_0)[i];
                Q_out_0[i] = (*Q_in_0)[i];

                numFrameSymbolsAssembled++;
            }

            // empty input buffer; release semaphore
            dataIn_0->bufferEmptied();

            dataOut_0->pushPacket(I_out_0, Q_out_0);

            if ( numFrameSymbolsAssembled == frameSize ) {
                operationalMode = ASSEMBLE_EOM_CODE;
            } else if ( numFrameSymbolsAssembled > frameSize ) {
                operationalMode = ASSEMBLE_EOM_CODE;
                std::cout << "WARNING: FrameAssembler pushing too many symbols in frame! "
                          << std::endl;
            } else {
                break;
            }

        case ASSEMBLE_EOM_CODE:
            // push phasing pattern
            ///\todo assemble EOM code
            dataOut_0->pushPacket(I_out_phasing_pattern, Q_out_phasing_pattern);

            operationalMode = ASSEMBLE_PREAMBLE;
            break;
        }

    }

    delete [] I_header;
    delete [] Q_header;
}