root/components/RandomBits/trunk/RandomBits/RandomBits.cpp @ 2260

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

Copyright 2006 Virginia Polytechnic Institute and State University

This file is part of the OSSIE RandomBits.

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

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


#include <string>
#include <iostream>

#include <math.h>

#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif

#include "ossie/cf.h"
#include "RandomBits.h"
#include "ossie/PortTypes.h"

#include "ossie/Resource_impl.h"

RandomBits_i::RandomBits_i(const char *uuid, omni_condition *condition) : Resource_impl(uuid), thread_started(false), component_running(condition) 
{
    dataOut = new standardInterfaces_i::realChar_u("DataOut");
}


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

    p = dataOut->getPort(portName);

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

    if (strcmp(portName, "Control") == 0)
        return myObjectRef._retn();

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

void RandomBits_i::start() throw (CORBA::SystemException, CF::Resource::StartError)
{
    std::cout << "start called on RandomBits" << std::endl;
    processing_thread = new omni_thread(do_process_data, (void *) this);
    thread_started = true;
    processing_thread->start();
}

void RandomBits_i::stop() throw (CORBA::SystemException, CF::Resource::StopError) 
{  
    std::cout << "stop called on RandomBits" << std::endl;
    thread_started = false;
}

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

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

void RandomBits_i::configure(const CF::Properties& props) throw (CORBA::SystemException, CF::PropertySet::InvalidConfiguration, CF::PropertySet::PartialConfiguration)
{
    std::cout << "configure called on RandomBits" << std::endl;
    
    std::cout << "props length : " << props.length() << std::endl;

    for (unsigned int i = 0; i <props.length(); i++) {
        // Packet Size property, short
        if (strcmp(props[i].id, "DCE:377d6aa8-fe71-4297-8a74-3ca0dd008cb4") == 0) {
            CORBA::Short j;
            props[i].value >>= j;

            omni_mutex_lock l(privateDataAccess);
            packetSize = j;
        }

        // Delay between packets in seconds, float
        if (strcmp(props[i].id, "DCE:9048e51b-a132-44a6-8f31-adf272bd62ce") == 0) {
            CORBA::Float delay;
            props[i].value >>= delay;

            omni_mutex_lock l(privateDataAccess);
            packetDelay.tv_sec = (time_t) floor(delay);
            packetDelay.tv_nsec = (long) ((delay - floor(delay)) * 1e9);

            std::cout << "Delay = " << delay << " seconds = " << packetDelay.tv_sec << " nanoseconds = " << packetDelay.tv_nsec << std::endl;
        }
    }
}

void RandomBits_i::process_data()
{
    std::cout << "process_data thread started" << std::endl;

    PortTypes::CharSequence bits;

    while(thread_started) {
        struct timespec delayTime, rem;

        { // Read private data
            omni_mutex_lock l(privateDataAccess);
            bits.length(packetSize);
            delayTime.tv_sec = packetDelay.tv_sec;
            delayTime.tv_nsec = packetDelay.tv_nsec;
        }

        for (unsigned int i = 0; i < bits.length(); i++)
            bits[i] = (rand() > RAND_MAX/2 ? 1 : 0);

        dataOut->pushPacket(bits);

        bool done(false);
        while (!done) {
            int ret = nanosleep(&delayTime, &rem);

            if (ret == EINTR) {
                delayTime = rem;
            } else 
                done = true;
        }
    }
    processing_thread->exit();
}