root/experimental/components/DataComparator/DataComparator.cpp @ 4401

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

Copyright 2006 Virginia Polytechnic Institute and State University

This file is part of the OSSIE DataComparator.

OSSIE DataComparator 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 DataComparator 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 DataComparator; 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 "DataComparator.h"

#undef LOGGING

#ifdef LOGGING
#define LOG_SIZE_MAX 32
#endif

#define BIT0 0
#define BIT1 1

const char DataComparator_i::packet_tmp[400] =
{
    1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1,
    0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1,
    1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0,
    0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1,
    1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1,
    1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0,
    1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0,
    1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1,
    0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1,
    0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0,
    0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1,
    1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1,
    0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1,
    0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1,
    1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0,
    0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1,
    0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0,
    1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1,
    0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1,
    1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0
};


DataComparator_i::DataComparator_i(const char *uuid, omni_condition *condition) : Resource_impl(uuid), component_running(condition) 
{
    dataIn_0 = new standardInterfaces_i::realChar_p("data_bits_in");
    dataIn_1 = new standardInterfaces_i::realChar_p("control_bits_in");

    // initialze algorithm variables
    packet_length = 400;
    packet = NULL;
    control_data_length = 15;
    control_data = new signed char[control_data_length];

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

}

DataComparator_i::~DataComparator_i(void)
{   
    delete dataIn_0;
    delete dataIn_1;
    if ( packet != NULL )
        delete [] packet;
    if ( control_data != NULL )
        delete [] control_data;
}

void DataComparator_i::run( void * data )
{
    ((DataComparator_i*) data)->run_loop();
}

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

    p = dataIn_0->getPort(portName);

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

    p = dataIn_1->getPort(portName);

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

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

void DataComparator_i::start() throw (CORBA::SystemException, CF::Resource::StartError)
{
    DEBUG(5, DataComparator, "start() invoked")
}

void DataComparator_i::stop() throw (CORBA::SystemException, CF::Resource::StopError) 
{  
    DEBUG(5, DataComparator, "stop() invoked")
}

void DataComparator_i::releaseObject() throw (CORBA::SystemException, CF::LifeCycle::ReleaseError)
{
    DEBUG(5, DataComparator, "releaseObject() invoked")
    
    component_running->signal();
}

void DataComparator_i::initialize() throw (CF::LifeCycle::InitializeError, CORBA::SystemException)
{
    DEBUG(5, DataComparator, "initialize() invoked")
}

void DataComparator_i::configure(const CF::Properties& props) throw (CORBA::SystemException, CF::PropertySet::InvalidConfiguration, CF::PropertySet::PartialConfiguration)
{
    DEBUG(5, DataComparator, "configure() invoked")
    
    DEBUG(5, DataComparator, "props length : " << props.length())

    for (unsigned int i = 0; i <props.length(); i++)
    {
        DEBUG(5, DataComparator, "Property id : " << props[i].id)

        if (strcmp(props[i].id, "DCE:111132a5-3d23-4632-be1e-b00403b03fe2")==0)
        // packet_length
        {
            CORBA::Long simple_temp;
            props[i].value >>= simple_temp;
            simple_0_value = simple_temp;
        }

    }
}

void DataComparator_i::run_loop()
{
    DEBUG(5, DataComparator, "run_loop() thread started")

#ifdef LOGGING
    unsigned int log_size_counter(0);
    std::ofstream packet_log;
    packet_log.open("packet_log.dat");
#endif

    unsigned int i, N, num_errors, num_total_errors(0);
    unsigned int packet_id(0), prev_packet_id(0);
    signed int packet_index_diff(0);
    unsigned int num_dropped_packets(0);
    unsigned int num_packets_to_observe(100);
    unsigned int num_received_packets(0);
    unsigned int M(control_data_length);

    bool first_packet(true);

    packet_length = 400;
    if ( packet != NULL )
    {
        delete [] packet;
        packet = new signed char[packet_length];
    }

    PortTypes::CharSequence * data_bits_in(NULL);
    PortTypes::CharSequence * control_bits_in(NULL);

    while( true )
    {
        data_bits_in = NULL;
        dataIn_0->getData(data_bits_in);
        N = data_bits_in->length();
        DEBUG(7, DataComparator, "received " << N << " data samples")

        dataIn_1->getData(control_bits_in);
        M = control_bits_in->length();
        DEBUG(7, DataComparator, "received " << M << " control samples")

        if ( N != packet_length ) {
            DEBUG(1, DataComparator, "WARNING: data packet sizes do not match")
        }

        if ( M != 1 ) {
            DEBUG(1, DataComparator, "WARNING: control packet sizes do not match")
        }
        packet_id = (*control_bits_in)[0];
      //  packet_id=1;        
        DEBUG(5, DataComparator, "packet id : " << packet_id);

        if ( first_packet )
            first_packet = false;
        else
        {
            // determine if packets have been dropped
            if ( packet_id == 0 )
                packet_index_diff = 127 - prev_packet_id;
            else
                packet_index_diff = packet_id - prev_packet_id - 1;

            while (packet_index_diff<0)
                packet_index_diff += 127;

            num_dropped_packets += (unsigned int) packet_index_diff;
        }

        num_received_packets++;
        prev_packet_id = packet_id;
                
        num_errors = 0;

        // compare data values
        for (i=0; i<N; i++) {
            if ( (signed char) (*data_bits_in)[i] != packet_tmp[i] )
                num_errors += 1;
        }

        DEBUG(2, DataComparator, "data errors [" << packet_id << "] : " << num_errors << " / " << N)
        num_total_errors += num_errors;

        if ( (num_received_packets+num_dropped_packets) >= num_packets_to_observe ) {
            DEBUG(1, DataComparator, "------------------ dropped packets : " << num_dropped_packets << " / " << num_received_packets + num_dropped_packets)
            DEBUG(1, DataComparator, "------------------      error rate : " << float(num_total_errors)/float(num_received_packets*4) << " %")
            num_received_packets = 0;
            num_dropped_packets = 0;
            num_total_errors = 0;
        }

        // Release input buffers
        dataIn_0->bufferEmptied();
        dataIn_1->bufferEmptied();


#ifdef LOGGING
        if ( log_size_counter < LOG_SIZE_MAX )
        {
            packet_log << packet_id << " " << num_errors << std::endl;
            log_size_counter++;
        }
#endif
    }
#ifdef LOGGING
    packet_log.close();
#endif
}