root/components/ChannelDemo/trunk/ChannelDemo/ChannelDemo.cpp @ 4249

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

Copyright 2006 Virginia Polytechnic Institute and State University

This file is part of the OSSIE ChannelDemo.

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

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


#include <string>
#include <iostream>
//#include "ossie/cf.h"
#include "ChannelDemo.h"
//#include ossie/PortTypes.h"

//#include "ossie/Resource_impl.h"

ChannelDemo_i::ChannelDemo_i(const char *uuid, omni_condition *condition) : Resource_impl(uuid), component_running(condition) 
{
    dataOut = new standardInterfaces_i::complexShort_u("outPort");
    dataIn = new standardInterfaces_i::complexShort_p("inPort");

    processing_thread = new omni_thread(process_data, (void *) this);   //Create the thread for the writer's processing function 
    processing_thread->start();    //Start the thread containing the writer's processing function 

}

CORBA::Object_ptr ChannelDemo_i::getPort( const char* portName ) throw (CORBA::SystemException, CF::PortSupplier::UnknownPort)
{
    std::cout << "ChannelDemo_i getPort called with : " << portName << std::endl;
    
    CORBA::Object_var p;

    p = dataOut->getPort(portName);

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

    p = dataIn->getPort(portName);

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

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

void ChannelDemo_i::start() throw (CORBA::SystemException, CF::Resource::StartError)
{
    std::cout << "start called on ChannelDemo" << std::endl;
}

void ChannelDemo_i::stop() throw (CORBA::SystemException, CF::Resource::StopError) 
{  
    std::cout << "stop called on ChannelDemo" << std::endl;
}

void ChannelDemo_i::releaseObject() throw (CORBA::SystemException, CF::LifeCycle::ReleaseError)
{
    std::cout << "releaseObject called on ChannelDemo" << std::endl;
    
    component_running->signal();
}

void ChannelDemo_i::initialize() throw (CF::LifeCycle::InitializeError, CORBA::SystemException)
{
    std::cout << "initialize called on ChannelDemo" << std::endl;
}

void ChannelDemo_i::configure(const CF::Properties& props) throw (CORBA::SystemException, CF::PropertySet::InvalidConfiguration, CF::PropertySet::PartialConfiguration)
{
    std::cout << "configure called on ChannelDemo" << std::endl;
    
    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:85d02594-1d91-49cf-ab93-2c533b55abe5") == 0)
        {
            props[i].value >>= simple;
            att_factor = (short)simple;
            
        }

    }
}

void process_data(void *data)
{
    std::cout << "ChannelDemo process_data thread started" << std::endl;

    ChannelDemo_i *channel = (ChannelDemo_i *) data;
    PortTypes::ShortSequence *I_in(NULL), *Q_in(NULL);
    PortTypes::ShortSequence I_out, Q_out;
    while(1)
    {
        channel->dataIn->getData(I_in, Q_in);
        std::cout<<"Data is in Channel"<<std::endl;
        std::cout<<"Applying Simple Scaling Factor of 1/"<< channel->att_factor << std::endl;
        std::cout<<"Output from Channel is..." <<std::endl;
        I_out.length(I_in->length());
        Q_out.length(Q_in->length());
        for(unsigned int i=0; i < I_out.length(); i = i+1)
        {
                I_out[i] = (*I_in)[i]/(channel->att_factor);    
                Q_out[i] = (*Q_in)[i]/(channel->att_factor);
                std::cout << "Input (" << i << ") to channel is I " << (*I_in)[i] << ", and Q " << (*Q_in)[i] << std::endl;
                std::cout << "Output (" << i << ") from channel I " << I_out[i] << ", and Q " << Q_out[i] <<std::endl;
        }
        channel->dataIn->bufferEmptied();
        std::cout<<"Channel pushing data"<<std::endl;
        channel->dataOut->pushPacket(I_out, Q_out);
    }
}