c++ grab in position signal

EMC_STAT *emcStatus == 0L;
..
..
// try to connect to EMC status
    if (emcStatusBuffer == 0) 
        {
    	emcStatusBuffer = new RCS_STAT_CHANNEL(emcFormat, "emcStatus", "xemc", emc_nmlfile);
    	if (!emcStatusBuffer->valid()) 
    	    {
    	    delete emcStatusBuffer;
	        emcStatusBuffer = 0;
	        emcStatus = 0;
	        retval = -1;
	        } 
	    else 
    	    emcStatus = (EMC_STAT *) emcStatusBuffer->get_address();
	    }
	}

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

Specimen program to show the calls necessary to create a hal userspace
component, within a Qt5 class.

The component runs a QTcpSocket to receive commands from a remote
source and then executes them via axis-remote --mdi calls

(c) ArcEye 10/09/2014 <arceyeATmgwareDOTcoDOTuk>

Licence GPL

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


#include "tcpsocket.h"
#include <QHostAddress>


TcpSocket::TcpSocket(int argc, char** argv, QObject *parent) :
    QObject(parent)
{
int r;
    progress = 0;
    
    socket = new QTcpSocket(this);

    connect(socket, SIGNAL(readyRead()),this, SLOT(readyRead()));

    qDebug() << "connecting to socket...";

    socket->connectToHost(QHostAddress::LocalHost, 9999);

    if(!socket->waitForConnected(5000))
        qDebug() << "Error: " << socket->errorString();
    
    // rt stuff
     
    strcpy(prefix, "tcpsocket\0");  // used later in pins
    comp_id = hal_init("tcpsocket");
    
    if(comp_id < 0) 
        exit(-1);
        
    if((r = connectPins())) 
        hal_exit(comp_id);    
    else
        {
        hal_ready(comp_id);
        qDebug() << "Component registered and ready" << "comp_ID " << comp_id;
        }

    startTimer();    
}


TcpSocket::~TcpSocket()
{
    socket->close();
    hal_exit(comp_id);
}


int TcpSocket::connectPins()
{
int r = 0;
int sz = sizeof(struct __comp_state) + 2;  //fudge factor

    inst = (struct __comp_state*)hal_malloc(sz);
    memset(inst, 0, sz);
    
    if( (r = hal_pin_bit_newf(HAL_IN, &(inst->homed), comp_id,"%s.homed", prefix)) != 0)
        return -1;
  
    *(inst->homed) = 0;
    
    if( (r = hal_pin_bit_newf(HAL_IN, &(inst->machineon), comp_id,"%s.machineon", prefix)) != 0)
        return -1;
  
    *(inst->machineon) = 0;

    if( (r = hal_pin_bit_newf(HAL_IN, &(inst->finished), comp_id,"%s.finished", prefix)) != 0)
        return -1;
  
    *(inst->finished) = 0;
    
    return 0;
}

void TcpSocket::startTimer()
{
  
    timer = new QTimer(this);
    connect(timer, SIGNAL(timeout()), this, SLOT(eventsLoop()));
    timer->start(250);
}


void TcpSocket::eventsLoop()
{
char cmdline[80];
char line[80];

    if(*(inst->homed) && *(inst->machineon))
        {
        switch(progress)
            {
            case 0: 
                if(*(inst->finished) && cmdList.size())
                	{
                    	QStrncpy(line, cmdList[0], (cmdList[0]).size() );
                    	sprintf(cmdline, "axis-remote --mdi '%s'", line);
                    	system(cmdline);
                    	cmdList.removeFirst();
                    	progress = 1;
                    	}
                break;
                
            case 1: if(!*(inst->finished))
                        break;
                    else
                        progress = 0;
                        
           default:
                    break;               
              
           }
       }

}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//  This function is called by signal / slot mechanism and is outside the QTimer switched loop that checks pins and
//  implements the commands fetched here
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void TcpSocket::readyRead()
{
QString str, str1;

    qDebug() << "reading...";

    if(socket->bytesAvailable())
        {
        str1 = socket->readLine();
        if(str1.contains("NAK") )
            {
            qDebug() << "NAK received - Exiting";
            socket->close();
            //exit(0);  don't exit in a component, with socket closed will not come back here again
            }
        else
            {
            // first connection send back ACK
            if(!str1.contains("ACK"))
                {
                cmdList.append(str1);
                }
            qDebug() << "Received " << str1;
            str = "ACK\n";
	        writeOut(str);
	        }
	    }
}


void TcpSocket::writeOut(QString& str)
{
    socket->write(str.toLatin1());
    socket->flush();
    socket->waitForBytesWritten(3000);
}


////////////////////////////////////////////////////////////////
//
// helper to save problems translating QStrings to char*


void TcpSocket::QStrncpy(char* str, QString& qstr, int num)
{
int x;

    for(x = 0; x < num; x++)
        {
        str[x] = (char)qstr.at(x).unicode();
        }
    str[x] = 0;

}