EDDPlotDataSource.cpp

Go to the documentation of this file.

#include <EDDSourceLib/inc/EDDPlotDataSource.h>
#include <EDDSourceLib/inc/EDDMsgLoop.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#if defined(WIN32)
#define snprintf sprintf_s
#else
using namespace std;
#endif

static char* maFields[] =
{
    "DESC",
    "X",
    "Y",
    "Z"
};

tcEDDPlotDataSource::tcEDDPlotDataSource(char* apDesc, bool abIsContinuous, int anMaxContPoints)
: tcEDDDataSource()
, mnPlotNo(0)
, mpOutputBuffer(0)
, mnOutputBufferLen(0)
, mbIsContinuous(abIsContinuous)
, mnMaxContPoints(anMaxContPoints)
{
    // initialize labels, etc.
    strncpy(maDescription, apDesc, gnMaxStringLen);
    snprintf(maXLabel, gnMaxStringLen, "X");    
    snprintf(maYLabel, gnMaxStringLen, "Y");    
    snprintf(maZLabel, gnMaxStringLen, "Z"); 
    
    for (int i = 0; i < 3; i++)
    {
        maScale[i] = 1.0;
        maOffset[i] = 0.0;
    }
       
    // register with message loop
    RegisterWithMsgLoop();
}

tcEDDPlotDataSource::~tcEDDPlotDataSource(void)
{
    UnRegisterWithMsgLoop();
    if (NULL != mpOutputBuffer)
    {
        delete [] mpOutputBuffer;
    }
}

int 
tcEDDPlotDataSource::HandleMsg(tsEDDMsgHdr* apMsg)
{
    int rv = EDDMSG_OK;
    switch(apMsg->mnMsgId)
    {
        case EDDMSGID_SOURCEDESCREQMSG:
            {
                char* maDescData[4];
                maDescData[0] = maDescription;
                maDescData[1] = maXLabel;
                maDescData[2] = maYLabel;
                maDescData[3] = maZLabel;
                SendSourceDescMsg(maFields, maDescData, 4);
            }
            break;
        case EDDMSGID_PLOTDESCREQMSG:
            break;
        default:
            rv = EDDMSG_UNHANDLED;
            break;
    }
    return rv;
}


int 
tcEDDPlotDataSource::SendPlotData(float* X, float* Y, int N)
{
    int rv = 0;

    rv = Send2DData(X,Y,N,sizeof(float), EDDPLOTMSG_FLOAT_2D);

    return rv;
}

int 
tcEDDPlotDataSource::SendPlotData(int32_t* X, int32_t* Y, int N)
{
    int rv = 0;

    rv = Send2DData(X,Y,N,sizeof(int32_t), EDDPLOTMSG_INT32_2D);

    return rv;
}

int 
tcEDDPlotDataSource::SendPlotData(int16_t* X, int16_t* Y, int N)
{
    int rv = 0;

    rv = Send2DData(X,Y,N,sizeof(int16_t), EDDPLOTMSG_INT16_2D);

    return rv;
}

int 
tcEDDPlotDataSource::SendPlotData(int8_t* X, int8_t* Y, int N)
{
    int rv = 0;

    rv = Send2DData(X,Y,N,sizeof(int8_t), EDDPLOTMSG_INT8_2D);

    return rv;
}

int 
tcEDDPlotDataSource::SendPlotData(uint32_t* X, uint32_t* Y, int N)
{
    int rv = 0;

    rv = Send2DData(X,Y,N,sizeof(uint32_t), EDDPLOTMSG_UINT32_2D);

    return rv;
}

int 
tcEDDPlotDataSource::SendPlotData(uint16_t* X, uint16_t* Y, int N)
{
    int rv = 0;

    rv = Send2DData(X,Y,N,sizeof(uint16_t), EDDPLOTMSG_UINT16_2D);

    return rv;
}

int 
tcEDDPlotDataSource::SendPlotData(uint8_t* X, uint8_t* Y, int N)
{
    int rv = 0;

    rv = Send2DData(X,Y,N,sizeof(uint8_t), EDDPLOTMSG_UINT8_2D);

    return rv;
}

int 
tcEDDPlotDataSource::SendPlotData(float* Y, int N)
{
    int rv = 0;
        
    rv = Send1DData(Y,N,sizeof(float), EDDPLOTMSG_FLOAT_1D);
    
    return rv;

}

int 
tcEDDPlotDataSource::SendPlotData(uint32_t* Y, int N)
{
    int rv = 0;
        
    rv = Send1DData(Y,N,sizeof(uint32_t), EDDPLOTMSG_UINT32_1D);
    
    return rv;

}

int 
tcEDDPlotDataSource::SendPlotData(uint16_t* Y, int N)
{
    int rv = 0;
        
    rv = Send1DData(Y,N,sizeof(uint16_t), EDDPLOTMSG_UINT16_1D);
    
    return rv;

}

int 
tcEDDPlotDataSource::SendPlotData(uint8_t* Y, int N)
{
    int rv = 0;
        
    rv = Send1DData(Y,N,sizeof(uint8_t), EDDPLOTMSG_UINT8_1D);
    
    return rv;

}

int 
tcEDDPlotDataSource::SendPlotData(int32_t* Y, int N)
{
    int rv = 0;
        
    rv = Send1DData(Y,N,sizeof(int32_t), EDDPLOTMSG_INT32_1D);
    
    return rv;

}

int 
tcEDDPlotDataSource::SendPlotData(int16_t* Y, int N)
{
    int rv = 0;
        
    rv = Send1DData(Y,N,sizeof(int16_t), EDDPLOTMSG_INT16_1D);
    
    return rv;

}

int 
tcEDDPlotDataSource::SendPlotData(int8_t* Y, int N)
{
    int rv = 0;
        
    rv = Send1DData(Y,N,sizeof(int8_t), EDDPLOTMSG_INT8_1D);
    
    return rv;

}

int  
tcEDDPlotDataSource::Send2DData(void* Xdata, void* Ydata, int N, int WordSizeBytes, uint8_t anDataType)
{
    int rv = 0;
    int points = 0;
    int points_to_send;
    int points_per_msg;

    // if no-one is subscribed, don't bother building messages only to throw them on the floor...
    if (!IsSubscribed())
    {
       return rv;
    }
    
    BuildOutputBuffer();
    
    // Send PlotDescriptor
    SendPlotDescriptor(N, anDataType);

    // Get Maximum Message Length
    points_per_msg = (mnOutputBufferLen-sizeof(tsEDDPlotMsg))/WordSizeBytes/2;    
        
    // loop on messages to send
    points = 0;
    
    while(points < N)
    {
       // build plot message
       tsEDDPlotMsg* lpMsg  = (tsEDDPlotMsg*)mpOutputBuffer;
       lpMsg->mnStartOffset = points;
       lpMsg->mnPlotNumber  = mnPlotNo;
       
       // determine number of points to send
       points_to_send = N-points;
       if (points_to_send > points_per_msg) points_to_send = points_per_msg;
       lpMsg->mnNumPoints = points_to_send;
       
       // fill the data 
       char* lpData = (char*)(lpMsg+1);
       memcpy(lpData, (char*)Xdata+WordSizeBytes*points, WordSizeBytes*points_to_send);
       lpData += WordSizeBytes*points_to_send;
       memcpy(lpData, (char*)Ydata+WordSizeBytes*points, WordSizeBytes*points_to_send);
       
       // send the message
       BuildHeader(&lpMsg->msHeader, EDDMSGID_PLOTMSG, sizeof(tsEDDPlotMsg)+lpMsg->mnNumPoints*2*WordSizeBytes);
       tcEDDMsgLoop::GetInstance()->SendMsg(&lpMsg->msHeader);
        
       points += points_to_send;
    }
    mnPlotNo++;
    return rv;


}


int  
tcEDDPlotDataSource::Send1DData(void* Ydata, int N, int WordSizeBytes, uint8_t anDataType)
{
    int rv = 0;
    int points = 0;
    int points_to_send;
    int points_per_msg;

    // if no-one is subscribed, don't bother building messages only to throw them on the floor...
    if (!IsSubscribed())
    {
       return rv;
    }

    BuildOutputBuffer();
    
    // Send PlotDescriptor
    SendPlotDescriptor(N, anDataType);

    // Get Maximum Message Length
    points_per_msg = (mnOutputBufferLen-sizeof(tsEDDPlotMsg))/WordSizeBytes;    
        
    // loop on messages to send
    points = 0;
    
    while(points < N)
    {
       // build plot message
       tsEDDPlotMsg* lpMsg  = (tsEDDPlotMsg*)mpOutputBuffer;
       lpMsg->mnStartOffset = points;
       lpMsg->mnPlotNumber  = mnPlotNo;
       
       // determine number of points to send
       points_to_send = N-points;
       if (points_to_send > points_per_msg) points_to_send = points_per_msg;
       lpMsg->mnNumPoints = points_to_send;
       
       // fill the data 
       char* lpData = (char*)(lpMsg+1);
       memcpy(lpData, (char*)Ydata+WordSizeBytes*points, WordSizeBytes*points_to_send);
       
       // send the message
       BuildHeader(&lpMsg->msHeader, EDDMSGID_PLOTMSG, sizeof(tsEDDPlotMsg)+lpMsg->mnNumPoints*WordSizeBytes);
       tcEDDMsgLoop::GetInstance()->SendMsg(&lpMsg->msHeader);
        
       points += points_to_send;
    }
    mnPlotNo++;
    return rv;

}

int 
tcEDDPlotDataSource::SetLabel(teAxis aeAxis, char* apLabel)
{
    char* lpPtr;
    switch (aeAxis)
    {
        case eeX:
            lpPtr = &maXLabel[0];
            break;
        case eeY:
            lpPtr = &maYLabel[0];
            break;
        case eeZ:
        default:
            lpPtr = &maZLabel[0];
            break;
    }
    strncpy(lpPtr, apLabel, gnMaxStringLen);
    return 0;
}

int 
tcEDDPlotDataSource::SetDescription(char* apDesc)
{
    strncpy(maDescription, apDesc, gnMaxStringLen);
    return 0;
}

void
tcEDDPlotDataSource::SendPlotDescriptor(int32_t anNumPoints, uint8_t anType)
{
    tsEDDPlotDescMsg* lpDescMsg = (tsEDDPlotDescMsg*)mpOutputBuffer;
    // TODO -- lpDescMsg->msTimeStamp;
    lpDescMsg->mnNumPoints    = (mbIsContinuous) ? -mnMaxContPoints : anNumPoints;
    lpDescMsg->mnPlotNumber   = mnPlotNo;
    lpDescMsg->mnPlotType     = anType;
    lpDescMsg->mnOffset[0]    = maOffset[0];
    lpDescMsg->mnOffset[1]    = maOffset[1];
    lpDescMsg->mnOffset[2]    = maOffset[2];
    lpDescMsg->mnScale[0]     = maScale[0];
    lpDescMsg->mnScale[1]     = maScale[1];
    lpDescMsg->mnScale[2]     = maScale[2];
    BuildHeader(&lpDescMsg->msHeader, EDDMSGID_PLOTDESCMSG, sizeof(tsEDDPlotDescMsg));
    tcEDDMsgLoop::GetInstance()->SendMsg(&lpDescMsg->msHeader);
    
}

void 
tcEDDPlotDataSource::BuildOutputBuffer(void)
{
    int maxlen = tcEDDMsgLoop::GetInstance()->GetMaxMessageLen(mnSourceId);
    if (maxlen < 0) maxlen = 1400;
    if (mnOutputBufferLen < maxlen)
    {
        mnOutputBufferLen = maxlen;
        if (NULL != mpOutputBuffer)
        {
            delete [] mpOutputBuffer;
        }
        mpOutputBuffer = new char[mnOutputBufferLen];
    }
}

---