This is the xmt.cpp file

#include <iostream>

#include "BPSK_XMT.h"

#include "port_impl.h"
// addition to generated code
#include <iostream.h>
#include <cstdlib.h>


BPSK_XMT_i::BPSK_XMT_i(const char *uuid, omni_condition *con) : Resource_impl(uuid)
{
    component_running = con;


    outPort0_servant = new dataOut_complexShort_i(this);
    outPort0_var = outPort0_servant->_this();
    outPort0_active = false;

    component_alive = true;
}


BPSK_XMT_i::~BPSK_XMT_i(void)
{

    delete outPort0_servant;

}

CORBA::Object_ptr BPSK_XMT_i::getPort( const char* _id ) throw (CORBA::SystemException, CF::PortSupplier::UnknownPort)
{

    if (strcmp(_id,"XMTout") == 0) {
        outPort0_active = true;
        return CF::Port::_duplicate(outPort0_var);
    }

    return NULL;
}

void BPSK_XMT_i::start() throw (CORBA::SystemException, CF::Resource::StartError)
{
tx_active=true;
// addition to code 4 lines 
cout << "start BPSK XMT program!!!" << endl;
cout << "start BPSK XMT program" << endl;
output_thread= new omni_thread(process_data,((void *)this));
tx_active = true;
output_thread->start();
}

void BPSK_XMT_i::stop() throw (CORBA::SystemException, CF::Resource::StopError)
 {
// addition
 tx_active = false; 
  }

void BPSK_XMT_i::releaseObject() throw (CORBA::SystemException, CF::LifeCycle::ReleaseError)
{
    // Clear the component running condition so main shuts down everything
    component_alive = false;
    component_running->signal();
}




void BPSK_XMT_i::initialize() throw (CF::LifeCycle::InitializeError, CORBA::SystemException)
{

}

void BPSK_XMT_i::configure(const CF::Properties& props) throw (CORBA::SystemException, CF::PropertySet::InvalidConfiguration, CF::PropertySet::PartialConfiguration)
{

}

//Addition to generated code - whole function
void process_data(void *data)
{
    BPSK_XMT_i *tx = (BPSK_XMT_i *) data;

    CORBA::ULong packet_size = (CORBA::ULong) 16;

    PortTypes::ShortSequence I;
    PortTypes::ShortSequence Q;

    I.length(packet_size);
    Q.length(packet_size);

    while(tx->tx_active){
        for (unsigned int i = 0; i < packet_size * 2; i += 2) {
            I[i/2] = (CORBA::Short) i;
            Q[i/2] = (CORBA::Short) i*2;
         cout << "start BPSK XMT program" << endl;
        }

        tx->outPort0_servant->send_data(I,Q);
        sleep(1);

    }
    tx->output_thread->exit();
}

This is the port_impl.cpp file
#include <iostream>

#include "port_impl.h"

using namespace std;

dataIn_complexShort_i::dataIn_complexShort_i(BPSK_XMT_i *_bpsk_xmt)
{
    bpsk_xmt = _bpsk_xmt;
}

void dataIn_complexShort_i::pushPacket(const PortTypes::ShortSequence &I,const PortTypes::ShortSequence &Q)
{

}

dataOut_complexShort_i::dataOut_complexShort_i(BPSK_XMT_i *_bpsk_xmt)
{
    bpsk_xmt = _bpsk_xmt;
}

void dataOut_complexShort_i::connectPort(CORBA::Object_ptr connection, const char *connectionId)
{
  standardInterfaces::complexShort_var port = standardInterfaces::complexShort::_narrow(connection);
  outPorts.push_back(dataOut_complexShort_i::PortInfo(port,connectionId));
}

void dataOut_complexShort_i::disconnectPort(const char *connectionId)
{
  std::vector<dataOut_complexShort_i::PortInfo>::iterator i;

  for (i = outPorts.begin(); i != outPorts.end(); ++i) {
      if ((*i).connectionId == connectionId) {
          outPorts.erase(i);
          break;
      }
  }
}

std::vector<dataOut_complexShort_i::PortInfo> dataOut_complexShort_i::get_ports()
{
    return outPorts;
}

//Addition to generated code - whole function

void dataOut_complexShort_i::send_data(const PortTypes::ShortSequence &I,const PortTypes::ShortSequence &Q)
{
for (unsigned int i = 0; i < outPorts.size(); i++) {
outPorts[i].port_var->pushPacket(I,Q);

}