dummyFunctions.cpp

Go to the documentation of this file.

/*************************************************************************\ 
* Copyright (c) 2013 Science and Technology Facilities Council (STFC), GB. 
* All rights reverved. 
* This file is distributed subject to a Software License Agreement found 
* in the file LICENSE.txt that is included with this distribution. 
\*************************************************************************/ 



#include <string>
#include <sstream>
#include <iostream>
#include <string>
#include <vector>
#include <time.h>

#include <epicsStdio.h>

#include "ECLabInterface.h"

static int my_connection_id = 2382312;

bool ECLabInterface::BLSIM = false;

struct MyTechnique
{
    std::string name;
        TEccParams_t params;
        MyTechnique() { params.pParams = 0; }
        MyTechnique(const char* nname, const TEccParams_t& nparams) { params.pParams = 0; copy(nname, nparams); }
        MyTechnique(const MyTechnique& t) { params.pParams = 0; copy(t.name.c_str(), t.params); }
        
        void copy(const char* nname, const TEccParams_t& nparams)
        {
            name = nname;
            delete params.pParams;
                params.pParams = new TEccParam_t[nparams.len];
                params.len = nparams.len;
                memcpy(params.pParams, nparams.pParams,  nparams.len * sizeof(TEccParam_t));
        }
        void print(std::ostream& os)
        {
            os << "Technique " << name << std::endl;
                for (int i = 0; i<params.len; ++i)
                {
                        os << "Param name " << params.pParams[i].ParamStr << std::endl;
                        os << "Param type " << params.pParams[i].ParamType << std::endl;
                        os << "Param val " << params.pParams[i].ParamVal << std::endl;
                        os << "Param index " << params.pParams[i].ParamIndex << std::endl;
                }
        }
};

struct MyChannel
{
    TChannelInfos_t info;
        time_t start;
        std::vector<MyTechnique> techniques;
        void print(std::ostream& os)
        {
            for(int i=0; i<techniques.size(); ++i)
                {
                    techniques[i].print(os);
                }
        }
};

static MyChannel my_channels[16];

#define NCHANNELS 1  // 1 to `16

static void init_channels()
{
    for(int i=0; i<16; ++i)
        {
            my_channels[i].info.Channel = i;
            my_channels[i].info.State = KBIO_STATE_STOP;
            my_channels[i].info.NbOfTechniques = 0;
        }
}

#define CHECK_CONNECTION_ID(__ID) \
    if (__ID != my_connection_id) \
        { \
            return -1; \
        }
#define CHECK_CHANNEL(__CH) \
        if (__CH >= NCHANNELS) \
        { \
            return -1; \
        }

//#define DEBUG_PRINT(__arg) std::cerr << __arg << std::endl
#define DEBUG_PRINT(__arg) 

BIOLOGIC_API(int) BL_GetLibVersionStub(char*  pVersion, unsigned int* psize)
{
    DEBUG_PRINT("BL_GetLibVersion");
    static const char* version = "5.34.0.1";
        strncpy(pVersion, version, *psize);
        pVersion[*psize-1] = '\0';
        *psize = strlen(version);
        return 0;
}

//BIOLOGIC_API(int) BL_GetErrorMsgStub( int errorcode, char*  pmsg, unsigned int* psize ) 
//{
//    DEBUG_PRINT("BL_GetErrorMsg");
//    if (errorcode == 0)
//      {
//          strncpy(pmsg, "No ERROR", *psize);
//       return 0; 
//      }
//      else if (errorcode < 0)
//      {
//          epicsSnprintf(pmsg, *psize, "Dummy Error code %d", errorcode);
//              return 0;
//      }
//      else
//      {
//              return -1;
//      }
//}

BIOLOGIC_API(int) BL_ConnectStub(const char* address, uint8 timeout, int* pID, TDeviceInfos_t* pInfos) 
{
    DEBUG_PRINT("BL_Connect");
        *pID = my_connection_id;
        pInfos->DeviceCode = KBIO_DEV_SP200;
        pInfos->NumberOfChannels = NCHANNELS;
        pInfos->NumberOfSlots = 1;
        init_channels();
        return 0;
}

BIOLOGIC_API(int) BL_TestConnectionStub(int ID)
{
    DEBUG_PRINT("BL_TestConnection");
        CHECK_CONNECTION_ID(ID);
        return 0;
}

BIOLOGIC_API(int) BL_DisconnectStub(int ID)
{
    DEBUG_PRINT("BL_Disconnect");
    if (ID == my_connection_id)
        {
                ++my_connection_id;  // this ensures closing or using a previously closed channel will generate an error
            return 0;
        }
        else
        {
                return -1;
        }
}

BIOLOGIC_API(int) BL_LoadFirmwareStub( int ID, uint8* pChannels, int* pResults, uint8 Length, 
                             bool ShowGauge, bool ForceReload, const char* BinFile, const char* XlxFile)
{
        return 0;
}

BIOLOGIC_API(bool) BL_IsChannelPluggedStub( int ID, uint8 ch ) 
{ 
    DEBUG_PRINT("BL_IsChannelPlugged");
    if (ID == my_connection_id)
        {
            return true; 
        }
        else
        {
            return false; 
        }
}

BIOLOGIC_API(int) BL_GetChannelsPluggedStub ( int ID, uint8* pChPlugged, uint8 Size ) 
{
    DEBUG_PRINT("BL_GetChannelsPlugged");
        CHECK_CONNECTION_ID(ID);
        if (Size > NCHANNELS)
        {
            return -1;
        }
        for(int i=0; i<Size; ++i)
        {
            pChPlugged[i] = 1;
        }
    return 0; 
}

BIOLOGIC_API(int) BL_GetChannelInfosStub( int ID, uint8 ch, TChannelInfos_t* pInfos ) 
{ 
    DEBUG_PRINT("BL_GetChannelInfos");
        CHECK_CONNECTION_ID(ID);
        CHECK_CHANNEL(ch);
        memcpy(pInfos, &(my_channels[ch].info), sizeof(TChannelInfos_t));
        return 0; 
}


BIOLOGIC_API(int) BL_LoadTechniqueStub(int ID, uint8 channel, const char* pFName, TEccParams_t Params, bool FirstTechnique, bool LastTechnique, bool DisplayParams)
{
    DEBUG_PRINT("BL_LoadTechnique");
        CHECK_CONNECTION_ID(ID);
        CHECK_CHANNEL(channel);
        if (FirstTechnique)
        {
            my_channels[channel].info.NbOfTechniques = 0;
            my_channels[channel].techniques.resize(0);
        }
        my_channels[channel].techniques.push_back(MyTechnique(pFName, Params));
        ++(my_channels[channel].info.NbOfTechniques);
        if (DisplayParams == true)
        {
            my_channels[channel].techniques.back().print(std::cout);
        }
        return 0;
}

BIOLOGIC_API(int) BL_UpdateParametersStub( int ID, uint8 channel, int TechIndx, TEccParams_t Params, const char* EccFileName ) 
{ 
    DEBUG_PRINT("BL_UpdateParameters");
        CHECK_CONNECTION_ID(ID);
        CHECK_CHANNEL(channel);
        if (TechIndx >= my_channels[channel].techniques.size())
        {
            return -1;
        }
        my_channels[channel].techniques[TechIndx].copy(EccFileName, Params);
        my_channels[channel].print(std::cout);
    return 0; 
}

BIOLOGIC_API(int) BL_StartChannelStub (int ID, uint8 channel)
{
    DEBUG_PRINT("BL_StartChannel");
        CHECK_CONNECTION_ID(ID);
        CHECK_CHANNEL(channel);
        my_channels[channel].info.State = KBIO_STATE_RUN;
        my_channels[channel].print(std::cout);
        time(&(my_channels[channel].start));
    return 0; 
}

BIOLOGIC_API(int) BL_StopChannelStub (int ID, uint8 channel)
{
    DEBUG_PRINT("BL_StopChannel");
        CHECK_CONNECTION_ID(ID);
        CHECK_CHANNEL(channel);
        my_channels[channel].info.State = KBIO_STATE_STOP;
    return 0; 
}

BIOLOGIC_API(int) BL_GetCurrentValuesStub (int ID, uint8 channel, TCurrentValues_t *pValues) 
{
    DEBUG_PRINT("BL_GetCurrentValues");
        CHECK_CONNECTION_ID(ID);
        CHECK_CHANNEL(channel);
        pValues->State = my_channels[channel].info.State;
        pValues->Ece = 2;
        pValues->Eoverflow = 3;
        pValues->TimeBase = 1e-6;
        pValues->MemFilled = 0;
        pValues->ElapsedTime = time(NULL) - my_channels[channel].start;
        return 0;
}

static unsigned castFloatToInt(float f)
{
        union
        {
                float f;
                unsigned u;
        } cf;
        cf.f = f;
        return cf.u;
}

BIOLOGIC_API(int) BL_GetDataStub( int ID, uint8 channel, TDataBuffer_t* pBuf, TDataInfos_t* pInfos, TCurrentValues_t* pValues ) 
{ 
    DEBUG_PRINT("BL_GetData");
        CHECK_CONNECTION_ID(ID);
        CHECK_CHANNEL(channel);
        BL_GetCurrentValuesStub(ID, channel, pValues);
        pInfos->NbRows = 0;
        pInfos->NbCols = 0;
        for(int i=0; i<my_channels[channel].techniques.size(); ++i)
        {
                size_t pos = my_channels[channel].techniques[i].name.find_last_of("\\/");
                if (pos == std::string::npos)
                {
                        pos = 0;
                }
                if (my_channels[channel].techniques[i].name.substr(pos+1) == "ocv4.ecc")
                {
                        pInfos->NbRows = 1;
                        pInfos->NbCols = 3;
                        pInfos->TechniqueID = KBIO_TECHID_OCV;
                        pInfos->ProcessIndex = 0;
                        pInfos->StartTime = my_channels[channel].start;
                        __int64 t;
                        t = (time(NULL) - pInfos->StartTime) / pValues->TimeBase;
                        pBuf->data[0] = (t >> 32);      // thigh
                        pBuf->data[1] = (t & 0xffffffff);       // tlow
                        pBuf->data[2] = castFloatToInt(5);      // ewe  
                }
                if (my_channels[channel].techniques[i].name.substr(pos+1) == "peis4.ecc")
                {
                        pInfos->TechniqueID = KBIO_TECHID_PEIS;
                        pInfos->NbRows = 1;
                        pInfos->StartTime = my_channels[channel].start;
                        if (time(NULL) % 2 == 0)
                        {
                            pInfos->ProcessIndex = 0;
                            pInfos->NbCols = 4;
                            __int64 t;
                            t = (time(NULL) - pInfos->StartTime) / pValues->TimeBase;
                            pBuf->data[0] = (t >> 32);  // thigh
                            pBuf->data[1] = (t & 0xffffffff);   // tlow
                            pBuf->data[2] = castFloatToInt(5);  // ewe  
                            pBuf->data[3] = castFloatToInt(5);  // I    
                        }
                        else
                        {
                            pInfos->ProcessIndex = 1;
                            pInfos->NbCols = 14;
                            pBuf->data[13] = castFloatToInt(10);        // time                                 
                        }
                }
        }
    return 0; 
}

BIOLOGIC_API(int) BL_SetExperimentInfosStub( int ID, uint8 channel, TExperimentInfos_t TExpInfos ) 
{ 
    DEBUG_PRINT("BL_SetExperimentInfos");
        CHECK_CONNECTION_ID(ID);
        CHECK_CHANNEL(channel);
    return 0; 
}

BIOLOGIC_API(int) BL_GetExperimentInfosStub( int ID, uint8 channel, TExperimentInfos_t* TExpInfos )
{ 
    DEBUG_PRINT("BL_GetExperimentInfos");
        CHECK_CONNECTION_ID(ID);
        CHECK_CHANNEL(channel);
        memset(TExpInfos, 0, sizeof(TExperimentInfos_t));
    return 0; 
}