root/ossiedev/branches/mcarrick/ossiedev-trunk/components/CostasLoop/CostasLoop_FPGAInterfaceOnly.cpp @ 9327

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

Copyright 2007 Virginia Polytechnic Institute and State University

This file is part of the OSSIE CostasLoop.

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

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


#include <string>
#include <iostream>
#include <fstream>
#include <sys/time.h>
#include <sys/resource.h>
#include "CostasLoop.h"

#include "CostasLoopFPGAInterface.h"

CostasLoop_i::CostasLoop_i(const char *uuid, omni_condition *condition) : 
    Resource_impl(uuid), component_running(condition) 
{
    dataOut_0 = new standardInterfaces_i::complexShort_u("dataOut");
    dataIn_0 = new standardInterfaces_i::complexShort_p("dataIn");

    //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();

    // open interface to FPGA
    openFPGAInterface();
}

CostasLoop_i::~CostasLoop_i(void)
{   
    // close interface to FPGA
    closeFPGAInterface();

    delete dataOut_0;
    delete dataIn_0;
}

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

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

    p = dataOut_0->getPort(portName);

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

    p = dataIn_0->getPort(portName);

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

    /*exception*/
    throw CF::PortSupplier::UnknownPort();
}

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

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

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

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

void CostasLoop_i::configure(const CF::Properties& props)
throw (CORBA::SystemException,
    CF::PropertySet::InvalidConfiguration,
    CF::PropertySet::PartialConfiguration)
{
    DEBUG(3, CostasLoop, "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;

    }
}

void CostasLoop_i::ProcessData()
{
    DEBUG(3, CostasLoop, "ProcessData() invoked")

    PortTypes::ShortSequence I_out_0, Q_out_0;
    PortTypes::ShortSequence *I_in_0(NULL), *Q_in_0(NULL);
    CORBA::UShort I_in_0_length, Q_in_0_length;

    // vector to be passed to FPGA
    unsigned long fpgaData[512];

    // bit masks for FPGA data
    unsigned long Imask = 0xFFFF0000;
    unsigned long Qmask = 0x0000FFFF;

    while(1)
    {

        dataIn_0->getData(I_in_0, Q_in_0);

        I_in_0_length = I_in_0->length();
        Q_in_0_length = Q_in_0->length();

        I_out_0.length(I_in_0_length); //must define length of output
        Q_out_0.length(Q_in_0_length); //must define length of output

        // verify that input samples are length of 512
        if (I_out_0.length() != 512)
        {
            std::cout << "[CostasLoop::ProcessData] Error: Input sequences to CostasLoop ";
            std::cout << "must be of length 512\n";
            exit(EXIT_FAILURE);
        }

        // pull data from CORBA sequence, add to data vector
        // (only I vector will be used, Q vector carries no valid data)
        for (unsigned int i = 0; i < I_out_0.length(); i++)
        {
            fpgaData[i] = (*I_in_0)[i];
        }

        // get wall clock, user and system time
        struct timeval start, end;
        int who = RUSAGE_SELF;
        struct rusage usageSTART, usageEND;

        getrusage(who,&usageSTART);
        gettimeofday(&start,NULL);
        for (int l = 0; l < 1000000; l++)
            CostasLoopProcessing(fpgaData);
        gettimeofday(&end,NULL);
        getrusage(who,&usageEND);

        // calculate wall statistics
        float Wsec = end.tv_sec - start.tv_sec;
        float Wmicrosec = end.tv_usec - start.tv_usec;
        std::cout << "Wall Clock Difference: " << (Wsec*1000) + (Wmicrosec/1000.0) << "\n";

        // calculate usage statistics
        struct timeval StimeStart = usageSTART.ru_stime;
        struct timeval StimeEnd = usageEND.ru_stime;

        float Usec = usageEND.ru_utime.tv_sec - usageSTART.ru_utime.tv_sec;
        float Umicrosec = usageEND.ru_utime.tv_usec - usageSTART.ru_utime.tv_usec;

        std::cout << "User Time: " << (Usec*1000) + (Umicrosec/1000.0) << "\n";

        float Ssec = usageEND.ru_stime.tv_sec - usageSTART.ru_stime.tv_sec;
        float Smicrosec = usageEND.ru_stime.tv_usec - usageEND.ru_stime.tv_usec;

        std::cout << "System Time: " << (Ssec*1000) + (Smicrosec/1000.0) << "\n";


        exit(EXIT_FAILURE);

        for (unsigned int k = 0; k < 512; k++)
        {
            I_out_0[k] = (signed(Imask & fpgaData[k])) >> 16;
            Q_out_0[k] = (signed(Qmask & fpgaData[k]));
        }

        dataIn_0->bufferEmptied();
        dataOut_0->pushPacket(I_out_0, Q_out_0);
    }

}