720 lines
17 KiB
C
720 lines
17 KiB
C
/*----------------------------------------------------------------------
|
|
This is driver for a standard PSI EL737 counter box as used at
|
|
SINQ
|
|
|
|
copyright: see file COPYRIGHT
|
|
|
|
extracted from countdriv.c. Mark Koennecke, June 2003
|
|
-----------------------------------------------------------------------*/
|
|
#include <stdlib.h>
|
|
#include <assert.h>
|
|
#include <math.h>
|
|
#include <fortify.h>
|
|
#include <string.h>
|
|
#include <sics.h>
|
|
#include <countdriv.h>
|
|
#include <splitter.h>
|
|
#include "hardsup/sinq_prototypes.h"
|
|
#include "hardsup/el737_def.h"
|
|
#include "hardsup/el737fix.h"
|
|
|
|
#define BADTRANGE -117766
|
|
/*----------------------------- EL737 ------------------------------------*/
|
|
typedef struct {
|
|
char *host;
|
|
int iPort;
|
|
int iChannel;
|
|
void *pData;
|
|
int finishCount;
|
|
} EL737st;
|
|
/*------------------------------------------------------------------------*/
|
|
static int EL737GetStatus(struct __COUNTER *self, float *fControl)
|
|
{
|
|
int iRet;
|
|
int iC1, iC2, iC3,iC4,iRS;
|
|
float fTime;
|
|
EL737st *pEL737;
|
|
|
|
assert(self);
|
|
pEL737 = (EL737st *)self->pData;
|
|
assert(pEL737);
|
|
iRet = EL737_GetStatus(&pEL737->pData,&iC1,&iC2,&iC3,&iC4,&fTime,&iRS);
|
|
if(self->eMode == eTimer)
|
|
{
|
|
*fControl = fTime;
|
|
}
|
|
else
|
|
{
|
|
*fControl = iC1;
|
|
}
|
|
/* store time */
|
|
self->fTime = fTime;
|
|
|
|
if(iRet != 1)
|
|
{
|
|
return HWFault;
|
|
}
|
|
self->lCounts[0] = iC2;
|
|
self->lCounts[1] = iC1;
|
|
self->lCounts[2] = iC3;
|
|
self->lCounts[3] = iC4;
|
|
|
|
/* get extra counters for 8-fold counter boxes */
|
|
iRet = EL737_GetStatusExtra(&pEL737->pData,&iC1,&iC2,&iC3,&iC4);
|
|
self->lCounts[4] = iC1;
|
|
self->lCounts[5] = iC2;
|
|
self->lCounts[6] = iC3;
|
|
self->lCounts[7] = iC4;
|
|
if(iRS == 0)
|
|
{
|
|
pEL737->finishCount++;
|
|
if(pEL737->finishCount >= 2)
|
|
{
|
|
return HWIdle;
|
|
}
|
|
else
|
|
{
|
|
return HWBusy;
|
|
}
|
|
}
|
|
else if((iRS == 1) || (iRS == 2))
|
|
{
|
|
pEL737->finishCount = 0;
|
|
return HWBusy;
|
|
}
|
|
else if( (iRS == 5) || (iRS == 6))
|
|
{
|
|
pEL737->finishCount = 0;
|
|
return HWNoBeam;
|
|
}
|
|
else
|
|
{
|
|
pEL737->finishCount = 0;
|
|
return HWPause;
|
|
}
|
|
}
|
|
#ifdef NONINTF
|
|
extern float nintf(float f);
|
|
#endif
|
|
/*-------------------------------------------------------------------------*/
|
|
static int EL737Start(struct __COUNTER *self)
|
|
{
|
|
int iRet, iRS;
|
|
EL737st *pEL737;
|
|
|
|
assert(self);
|
|
pEL737 = (EL737st *)self->pData;
|
|
assert(pEL737);
|
|
|
|
|
|
self->fTime = 0.;
|
|
|
|
if(self->eMode == ePreset)
|
|
{
|
|
iRet = EL737_StartCnt(&pEL737->pData,(int)nintf(self->fPreset),&iRS);
|
|
if(iRet == 1)
|
|
{
|
|
pEL737->finishCount = 0;
|
|
return OKOK;
|
|
}
|
|
else
|
|
{
|
|
return HWFault;
|
|
}
|
|
}
|
|
else if(self->eMode == eTimer)
|
|
{
|
|
if(self->fPreset < .1 || self->fPreset > 200000)
|
|
{
|
|
self->iErrorCode = BADTRANGE;
|
|
return HWFault;
|
|
}
|
|
iRet = EL737_StartTime(&pEL737->pData,self->fPreset,&iRS);
|
|
if(iRet == 1)
|
|
{
|
|
pEL737->finishCount = 0;
|
|
return OKOK;
|
|
}
|
|
else
|
|
{
|
|
return HWFault;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
static int EL737Pause(struct __COUNTER *self)
|
|
{
|
|
int iRet, iRS;
|
|
EL737st *pEL737;
|
|
|
|
assert(self);
|
|
pEL737 = (EL737st *)self->pData;
|
|
assert(pEL737);
|
|
|
|
|
|
iRet = EL737_Pause(&pEL737->pData,&iRS);
|
|
if(iRet == 1)
|
|
{
|
|
return OKOK;
|
|
}
|
|
else
|
|
{
|
|
return HWFault;
|
|
}
|
|
return 0;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
static int EL737Continue(struct __COUNTER *self)
|
|
{
|
|
int iRet, iRS;
|
|
EL737st *pEL737;
|
|
|
|
assert(self);
|
|
pEL737 = (EL737st *)self->pData;
|
|
assert(pEL737);
|
|
|
|
|
|
iRet = EL737_Continue(&pEL737->pData,&iRS);
|
|
if(iRet == 1)
|
|
{
|
|
return OKOK;
|
|
}
|
|
else
|
|
{
|
|
return HWFault;
|
|
}
|
|
return 0;
|
|
}
|
|
/*--------------------------------------------------------------------------*/
|
|
static int EL737Halt(struct __COUNTER *self)
|
|
{
|
|
int iRet, iC1, iC2, iC3, iC4,iRS;
|
|
float fPreset;
|
|
EL737st *pEL737;
|
|
|
|
assert(self);
|
|
pEL737 = (EL737st *)self->pData;
|
|
assert(pEL737);
|
|
|
|
|
|
|
|
iRet = EL737_Stop(&pEL737->pData,&iC1, &iC2,&iC3,&iC4,&fPreset,&iRS);
|
|
if(iRet == 1)
|
|
{
|
|
self->lCounts[0] = iC2;
|
|
self->lCounts[1] = iC1;
|
|
self->lCounts[2] = iC3;
|
|
self->lCounts[3] = iC4;
|
|
return OKOK;
|
|
}
|
|
return HWFault;
|
|
}
|
|
/*--------------------------------------------------------------------------*/
|
|
static int EL737ReadValues(struct __COUNTER *self)
|
|
{
|
|
int iRet;
|
|
int iC1, iC2, iC3,iC4,iRS;
|
|
float fTime;
|
|
EL737st *pEL737;
|
|
|
|
assert(self);
|
|
pEL737 = (EL737st *)self->pData;
|
|
assert(pEL737);
|
|
|
|
|
|
iRet = EL737_GetStatus(&pEL737->pData,&iC1,&iC2,&iC3,&iC4,&fTime,&iRS);
|
|
if(iRet != 1)
|
|
{
|
|
return HWFault;
|
|
}
|
|
self->fTime = fTime;
|
|
|
|
self->lCounts[0] = iC2;
|
|
self->lCounts[1] = iC1;
|
|
self->lCounts[2] = iC3;
|
|
self->lCounts[3] = iC4;
|
|
/* get extra counters for 8-fold counter boxes */
|
|
iRet = EL737_GetStatusExtra(&pEL737->pData,&iC1,&iC2,&iC3,&iC4);
|
|
self->lCounts[4] = iC1;
|
|
self->lCounts[5] = iC2;
|
|
self->lCounts[6] = iC3;
|
|
self->lCounts[7] = iC4;
|
|
|
|
return OKOK;
|
|
}
|
|
/*---------------------------------------------------------------------------
|
|
|
|
EL737Error2Text converts between an EL734 error code to text
|
|
-----------------------------------------------------------------------------*/
|
|
static void EL737Error2Text(char *pBuffer, int iErr)
|
|
{
|
|
switch(iErr)
|
|
{
|
|
case EL737__BAD_ADR:
|
|
strcpy(pBuffer,"EL737__BAD_ADR");
|
|
break;
|
|
case EL737__BAD_OVFL:
|
|
strcpy(pBuffer,"EL737__BAD_OVFL");
|
|
break;
|
|
case EL737__BAD_BSY:
|
|
strcpy(pBuffer,"EL737__BAD_BSY");
|
|
break;
|
|
case EL737__BAD_SNTX:
|
|
strcpy(pBuffer,"EL737__BAD_SNTX");
|
|
break;
|
|
case EL737__BAD_CONNECT:
|
|
strcpy(pBuffer,"EL737__BAD_CONNECT");
|
|
break;
|
|
case EL737__BAD_FLUSH:
|
|
strcpy(pBuffer,"EL737__BAD_FLUSH");
|
|
break;
|
|
case EL737__BAD_DEV:
|
|
strcpy(pBuffer,"EL734__BAD_DEV");
|
|
break;
|
|
case EL737__BAD_ID:
|
|
strcpy(pBuffer,"EL737__BAD_ID");
|
|
break;
|
|
case EL737__BAD_ILLG:
|
|
strcpy(pBuffer,"EL737__BAD_ILLG");
|
|
break;
|
|
case EL737__BAD_LOC:
|
|
strcpy(pBuffer,"EL737__BAD_LOC");
|
|
break;
|
|
case EL737__BAD_MALLOC:
|
|
strcpy(pBuffer,"EL737__BAD_MALLOC");
|
|
break;
|
|
case EL737__BAD_NOT_BCD:
|
|
strcpy(pBuffer,"EL737__BAD_NOT_BCD");
|
|
break;
|
|
case EL737__BAD_OFL:
|
|
strcpy(pBuffer,"EL737__BAD_OFL");
|
|
break;
|
|
case EL737__BAD_PAR:
|
|
strcpy(pBuffer,"EL737__BAD_PAR");
|
|
break;
|
|
|
|
case EL737__BAD_RECV:
|
|
strcpy(pBuffer,"EL737__BAD_RECV");
|
|
break;
|
|
case EL737__BAD_RECV_NET:
|
|
strcpy(pBuffer,"EL737__BAD_RECV_NET");
|
|
break;
|
|
case EL737__BAD_RECV_PIPE:
|
|
strcpy(pBuffer,"EL737__BAD_RECV_PIPE");
|
|
break;
|
|
case EL737__BAD_RECV_UNKN:
|
|
strcpy(pBuffer,"EL737__BAD_RECV_UNKN");
|
|
break;
|
|
case EL737__BAD_RECVLEN:
|
|
strcpy(pBuffer,"EL737__BAD_RECVLEN");
|
|
break;
|
|
case EL737__BAD_RECV1:
|
|
strcpy(pBuffer,"EL737__BAD_RECV1");
|
|
break;
|
|
case EL737__BAD_RECV1_NET:
|
|
strcpy(pBuffer,"EL737__BAD_RECV1_NET");
|
|
break;
|
|
case EL737__BAD_RECV1_PIPE:
|
|
strcpy(pBuffer,"EL737__BAD_RECV1_PIPE");
|
|
break;
|
|
case EL737__BAD_RNG:
|
|
strcpy(pBuffer,"EL737__BAD_RNG");
|
|
break;
|
|
case EL737__BAD_SEND:
|
|
strcpy(pBuffer,"EL737__BAD_SEND");
|
|
break;
|
|
case EL737__BAD_SEND_PIPE:
|
|
strcpy(pBuffer,"EL737__BAD_SEND_PIPE");
|
|
break;
|
|
case EL737__BAD_SEND_NET:
|
|
strcpy(pBuffer,"EL737__BAD_SEND_NET");
|
|
break;
|
|
case EL737__BAD_SEND_UNKN:
|
|
strcpy(pBuffer,"EL737__BAD_SEND_UNKN");
|
|
break;
|
|
case EL737__BAD_SENDLEN:
|
|
strcpy(pBuffer,"EL737__BAD_SENDLEN");
|
|
break;
|
|
case EL737__BAD_SOCKET:
|
|
strcpy(pBuffer,"EL737__BAD_SOCKET");
|
|
break;
|
|
case EL737__BAD_TMO:
|
|
strcpy(pBuffer,"EL737__BAD_TMO");
|
|
break;
|
|
case EL737__FORCED_CLOSED:
|
|
strcpy(pBuffer,"EL737__FORCED_CLOSED");
|
|
break;
|
|
case EL737__BAD_ASYNSRV:
|
|
strcpy(pBuffer,"EL737__BAD_ASYNSRV");
|
|
break;
|
|
default:
|
|
sprintf(pBuffer,"Unknown EL737 error %d", iErr);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
static int EL737GetError(struct __COUNTER *self, int *iCode,
|
|
char *error, int iErrLen)
|
|
{
|
|
char *pErr = NULL;
|
|
int iC1, iC2, iC3;
|
|
char pBueffel[256];
|
|
|
|
if(self->iErrorCode == UNKNOWNPAR)
|
|
{
|
|
strncpy(error,"unknown internal parameter code",iErrLen);
|
|
*iCode = self->iErrorCode;
|
|
self->iErrorCode = 0;
|
|
return 1;
|
|
}
|
|
else if(self->iErrorCode == BADCOUNTER)
|
|
{
|
|
strncpy(error,"monitor cannot be selected",iErrLen);
|
|
*iCode = self->iErrorCode;
|
|
self->iErrorCode = 0;
|
|
return 1;
|
|
}
|
|
else if(self->iErrorCode == BADTRANGE)
|
|
{
|
|
strncpy(error,"preset time out of range",iErrLen);
|
|
*iCode = self->iErrorCode;
|
|
self->iErrorCode = 0;
|
|
return 1;
|
|
}
|
|
|
|
|
|
EL737_ErrInfo(&pErr,&iC1,&iC2, &iC3);
|
|
EL737Error2Text(pBueffel,iC1);
|
|
|
|
strncpy(error,pBueffel,iErrLen);
|
|
*iCode = iC1;
|
|
return 1;
|
|
}
|
|
/*--------------------------------------------------------------------------*/
|
|
static int EL737TryAndFixIt(struct __COUNTER *self, int iCode)
|
|
{
|
|
EL737st *pEL737;
|
|
int iRet;
|
|
char pCommand[50], pReply[50];
|
|
|
|
assert(self);
|
|
pEL737 = (EL737st *)self->pData;
|
|
assert(pEL737);
|
|
|
|
switch(iCode)
|
|
{
|
|
case EL737__BAD_ILLG:
|
|
case EL737__BAD_ADR:
|
|
case EL737__BAD_PAR:
|
|
case EL737__BAD_TMO:
|
|
case EL737__BAD_REPLY:
|
|
case EL737__BAD_SNTX:
|
|
case EL737__BAD_OVFL:
|
|
return COREDO;
|
|
break;
|
|
case EL737__BAD_BSY:
|
|
strcpy(pCommand,"S \r");
|
|
iRet = EL737_SendCmnd(&pEL737->pData,pCommand,pReply,49);
|
|
if(iRet < 0)
|
|
{
|
|
return COTERM;
|
|
}
|
|
else
|
|
{
|
|
return COREDO;
|
|
}
|
|
break;
|
|
case EL737__BAD_LOC:
|
|
strcpy(pCommand,"rmt 1\r");
|
|
iRet = EL737_SendCmnd(&pEL737->pData,pCommand,pReply,49);
|
|
if(iRet < 0)
|
|
{
|
|
return COTERM;
|
|
}
|
|
strcpy(pCommand,"echo 2\r");
|
|
iRet = EL737_SendCmnd(&pEL737->pData,pCommand,pReply,49);
|
|
if(iRet < 0)
|
|
{
|
|
return COTERM;
|
|
}
|
|
strcpy(pCommand,"ra\r");
|
|
iRet = EL737_SendCmnd(&pEL737->pData,pCommand,pReply,49);
|
|
if(iRet < 0)
|
|
{
|
|
return COTERM;
|
|
}
|
|
return COREDO;
|
|
break;
|
|
case EL737__BAD_DEV:
|
|
case EL737__BAD_ID:
|
|
case EL737__BAD_NOT_BCD:
|
|
case UNKNOWNPAR:
|
|
case BADCOUNTER:
|
|
case BADTRANGE:
|
|
return COTERM;
|
|
break;
|
|
case EL737__FORCED_CLOSED:
|
|
iRet = EL737_Open(&pEL737->pData,pEL737->host, pEL737->iPort,
|
|
pEL737->iChannel);
|
|
if(iRet == 1)
|
|
{
|
|
return COREDO;
|
|
}
|
|
else
|
|
{
|
|
return COTERM;
|
|
}
|
|
break;
|
|
case EL737__BAD_OFL:
|
|
EL737_Close(&pEL737->pData,0);
|
|
iRet = EL737_Open(&pEL737->pData,pEL737->host, pEL737->iPort,
|
|
pEL737->iChannel);
|
|
if(iRet == 1)
|
|
{
|
|
return COREDO;
|
|
}
|
|
else
|
|
{
|
|
return COTERM;
|
|
}
|
|
break;
|
|
/* case EL737__BAD_ASYNSRV:
|
|
EL737_Close(&pEL737->pData,1);
|
|
return COREDO;
|
|
*/ default:
|
|
/* try to reopen connection */
|
|
|
|
EL737_Close(&pEL737->pData,1);
|
|
iRet = EL737_Open(&pEL737->pData,pEL737->host, pEL737->iPort,
|
|
pEL737->iChannel);
|
|
if(iRet == 1)
|
|
{
|
|
return COREDO;
|
|
}
|
|
else
|
|
{
|
|
return COTERM;
|
|
}
|
|
break;
|
|
}
|
|
return COTERM;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
static int EL737Set(struct __COUNTER *self, char *name, int iCter,
|
|
float fVal)
|
|
{
|
|
int iRet;
|
|
EL737st *pEL737;
|
|
char pCommand[80],pReply[80];
|
|
|
|
assert(self);
|
|
pEL737 = (EL737st *)self->pData;
|
|
assert(pEL737);
|
|
|
|
if(strcmp(name,"threshold") == 0)
|
|
{
|
|
sprintf(pCommand,"DL %1.1d %6.2f\r",iCter,fVal);
|
|
iRet = EL737_SendCmnd(&pEL737->pData,pCommand,pReply,79);
|
|
if(iRet == 1)
|
|
{
|
|
if(pReply[0] == '?')
|
|
{
|
|
self->iErrorCode = BADCOUNTER;
|
|
return HWFault;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return HWFault;
|
|
}
|
|
sprintf(pCommand,"DR %1.1d \r",iCter);
|
|
iRet = EL737_SendCmnd(&pEL737->pData,pCommand,pReply,79);
|
|
if(iRet == 1)
|
|
{
|
|
if(pCommand[0] == '?')
|
|
{
|
|
self->iErrorCode = BADCOUNTER;
|
|
return HWFault;
|
|
}
|
|
return OKOK;
|
|
}
|
|
else
|
|
{
|
|
return HWFault;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
self->iErrorCode = UNKNOWNPAR;
|
|
return HWFault;
|
|
}
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
static int EL737Get(struct __COUNTER *self, char *name, int iCter,
|
|
float *fVal)
|
|
{
|
|
int iRet;
|
|
EL737st *pEL737;
|
|
char pCommand[80],pReply[80];
|
|
|
|
assert(self);
|
|
pEL737 = (EL737st *)self->pData;
|
|
assert(pEL737);
|
|
|
|
if(strcmp(name,"threshold") == 0)
|
|
{
|
|
sprintf(pCommand,"DL %1.1d\r",iCter);
|
|
iRet = EL737_SendCmnd(&pEL737->pData,pCommand,pReply,79);
|
|
if(iRet == 1)
|
|
{
|
|
if(pReply[0] == '?')
|
|
{
|
|
self->iErrorCode = BADCOUNTER;
|
|
return HWFault;
|
|
}
|
|
sscanf(pReply,"%f",fVal);
|
|
return OKOK;
|
|
}
|
|
else
|
|
{
|
|
return HWFault;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
self->iErrorCode = UNKNOWNPAR;
|
|
return HWFault;
|
|
}
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
static int EL737Send(struct __COUNTER *self, char *pText, char *pReply,
|
|
int iReplyLen)
|
|
{
|
|
EL737st *pEL737;
|
|
char pBuffer[256];
|
|
|
|
assert(self);
|
|
pEL737 = (EL737st *)self->pData;
|
|
assert(pEL737);
|
|
|
|
/* ensure a \r at the end of the text */
|
|
if(strlen(pText) > 254)
|
|
{
|
|
strncpy(pReply,"Command to long",iReplyLen);
|
|
return 1;
|
|
}
|
|
strcpy(pBuffer,pText);
|
|
if(strchr(pBuffer,(int)'\r') == NULL)
|
|
{
|
|
strcat(pBuffer,"\r");
|
|
}
|
|
|
|
return EL737_SendCmnd(&pEL737->pData,pBuffer,pReply,iReplyLen);
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
pCounterDriver CreateEL737Counter(SConnection *pCon, char *name,
|
|
int argc, char *argv[]){
|
|
char *pHost;
|
|
int iPort, iChannel;
|
|
|
|
if(argc < 3){
|
|
SCWrite(pCon,
|
|
"ERROR: insuficient number of arguments to create EL737 counter",
|
|
eError);
|
|
return NULL;
|
|
}
|
|
if(!isNumeric(argv[1]) || !isNumeric(argv[2])){
|
|
SCWrite(pCon,"ERROR: expected numeric arguments for port and channel",
|
|
eError);
|
|
return NULL;
|
|
}
|
|
iPort = atoi(argv[1]);
|
|
iChannel = atoi(argv[2]);
|
|
return NewEL737Counter(name,argv[0],iPort,iChannel);
|
|
}
|
|
/*--------------------------------------------------------------------------*/
|
|
pCounterDriver NewEL737Counter(char *name, char *host, int iPort, int iChannel)
|
|
{
|
|
pCounterDriver pRes = NULL;
|
|
EL737st *pData = NULL;
|
|
int iRet;
|
|
int iC1, iC2, iC3;
|
|
char *pErr;
|
|
char pBueffel[132];
|
|
|
|
pRes = CreateCounterDriver(name, "EL737");
|
|
if(!pRes)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
/* open connection to counter */
|
|
pData = (EL737st *)malloc(sizeof(EL737st));
|
|
if(!pData)
|
|
{
|
|
DeleteCounterDriver(pRes);
|
|
return NULL;
|
|
}
|
|
pData->host = strdup(host);
|
|
pData->iPort = iPort;
|
|
pData->iChannel = iChannel;
|
|
pData->pData = NULL;
|
|
iRet = EL737_Open(&(pData->pData), host,iPort,iChannel);
|
|
if(iRet != 1)
|
|
{
|
|
EL737_ErrInfo(&pErr,&iC1,&iC2, &iC3);
|
|
DeleteCounterDriver(pRes);
|
|
if(pData->host)
|
|
{
|
|
free(pData->host);
|
|
}
|
|
return NULL;
|
|
}
|
|
pRes->pData = (void *)pData;
|
|
|
|
/* assign functions */
|
|
pRes->GetStatus = EL737GetStatus;
|
|
pRes->Start = EL737Start;
|
|
pRes->Halt = EL737Halt;
|
|
pRes->ReadValues = EL737ReadValues;
|
|
pRes->GetError = EL737GetError;
|
|
pRes->TryAndFixIt = EL737TryAndFixIt;
|
|
pRes->Pause = EL737Pause;
|
|
pRes->Continue = EL737Continue;
|
|
pRes->Set = EL737Set;
|
|
pRes->Get = EL737Get;
|
|
pRes->Send = EL737Send;
|
|
pRes->KillPrivate = KillEL737Counter;
|
|
pRes->iNoOfMonitors = 7;
|
|
pRes->fTime = 0.;
|
|
|
|
return pRes;
|
|
}
|
|
/*--------------------------------------------------------------------------*/
|
|
void KillEL737Counter(pCounterDriver self)
|
|
{
|
|
EL737st *pEL737 = NULL;
|
|
|
|
assert(self);
|
|
pEL737 = (EL737st *)self->pData;
|
|
assert(pEL737);
|
|
|
|
EL737_Close(&pEL737->pData,0);
|
|
if(pEL737->host)
|
|
{
|
|
free(pEL737->host);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|