317 lines
8.5 KiB
C
317 lines
8.5 KiB
C
/*--------------------------------------------------------------------------
|
|
E L 7 5 5 D R I V
|
|
|
|
This file contains the implementation for the EL755 magnet controller
|
|
driver.
|
|
|
|
Mark Koennecke, November 1999
|
|
|
|
Copyright: see copyright.h
|
|
----------------------------------------------------------------------------*/
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <time.h>
|
|
#include <math.h>
|
|
#include <assert.h>
|
|
#include <fortify.h>
|
|
#include <conman.h>
|
|
#include <servlog.h>
|
|
#include <fortify.h>
|
|
|
|
#include "evdriver.h"
|
|
#include "hardsup/el755_def.h"
|
|
#include "hardsup/el755_errcodes.h"
|
|
#include "hardsup/sinq_prototypes.h"
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
typedef struct {
|
|
void *pData;
|
|
char *pHost;
|
|
int iPort;
|
|
int iChannel;
|
|
int iIndex;
|
|
int iLastError;
|
|
} EL755Driv, *pEL755Driv;
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
static int GetEL755Pos(pEVDriver self, float *fPos)
|
|
{
|
|
pEL755Driv pMe = NULL;
|
|
int iRet;
|
|
float fSoll;
|
|
|
|
assert(self);
|
|
pMe = (pEL755Driv)self->pPrivate;
|
|
assert(pMe);
|
|
|
|
iRet = EL755_GetCurrents(&(pMe->pData),&fSoll,fPos);
|
|
if(iRet != 1)
|
|
{
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
/*----------------------------------------------------------------------------*/
|
|
static int EL755Run(pEVDriver self, float fVal)
|
|
{
|
|
pEL755Driv pMe = NULL;
|
|
int iRet;
|
|
|
|
assert(self);
|
|
pMe = (pEL755Driv )self->pPrivate;
|
|
assert(pMe);
|
|
|
|
iRet = EL755_SetCurrent(&(pMe->pData),fVal);
|
|
if(iRet != 1)
|
|
{
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
/*--------------------------------------------------------------------------*/
|
|
static int EL755Error(pEVDriver self, int *iCode, char *error, int iErrLen)
|
|
{
|
|
pEL755Driv pMe = NULL;
|
|
char *pPtr = NULL;
|
|
int i1, i2;
|
|
char pBueffel[132];
|
|
|
|
assert(self);
|
|
pMe = (pEL755Driv)self->pPrivate;
|
|
assert(pMe);
|
|
|
|
/* retrieve error */
|
|
EL755_ErrInfo(&pPtr,iCode,&i1,&i2);
|
|
switch(*iCode)
|
|
{
|
|
case EL755__TURNED_OFF:
|
|
strncpy(error,"EL755__TURNED_OF",iErrLen);
|
|
break;
|
|
case EL755__TOO_MANY:
|
|
strncpy(error,"EL755__TO_MANY",iErrLen);
|
|
break;
|
|
case EL755__TOO_LARGE:
|
|
strncpy(error,"EL755__TOO_LARGE",iErrLen);
|
|
break;
|
|
case EL755__OVFLOW:
|
|
strncpy(error,"EL755_OVFLOW",iErrLen);
|
|
break;
|
|
case EL755__OUT_OF_RANGE:
|
|
strncpy(error,"EL755_OUT_OF_RANGE",iErrLen);
|
|
break;
|
|
case EL755__OFFLINE:
|
|
strncpy(error,"EL755_OFFLINE",iErrLen);
|
|
break;
|
|
case EL755__NO_SOCKET:
|
|
strncpy(error,"EL755__NO_SOCKET",iErrLen);
|
|
break;
|
|
case EL755__NOT_OPEN:
|
|
strncpy(error,"EL755__NOT_OPEN",iErrLen);
|
|
break;
|
|
case EL755__FORCED_CLOSED:
|
|
strncpy(error,"EL755__FORCED_CLOSED",iErrLen);
|
|
break;
|
|
case EL755__BAD_TMO:
|
|
strncpy(error,"EL755__BAD_TMO",iErrLen);
|
|
break;
|
|
case EL755__BAD_SOCKET:
|
|
strncpy(error,"EL755__BAD_SOCKET",iErrLen);
|
|
break;
|
|
case EL755__BAD_PAR:
|
|
strncpy(error,"EL755__BAD_PAR",iErrLen);
|
|
break;
|
|
case EL755__BAD_OFL:
|
|
strncpy(error,"EL755__BAD_OFL",iErrLen);
|
|
break;
|
|
case EL755__BAD_MALLOC:
|
|
strncpy(error,"EL755__BAD_MALLOC",iErrLen);
|
|
break;
|
|
case EL755__BAD_ILLG:
|
|
strncpy(error,"EL755__BAD_ILLG",iErrLen);
|
|
break;
|
|
case EL755__BAD_DEV:
|
|
strncpy(error,"EL755__BAD_DEV",iErrLen);
|
|
break;
|
|
case EL755__BAD_CMD:
|
|
strncpy(error,"EL755__BAD_CMD",iErrLen);
|
|
break;
|
|
case EL755__BAD_ASYNSRV:
|
|
strncpy(error,"EL755__BAD_ASYNSRV",iErrLen);
|
|
break;
|
|
default:
|
|
sprintf(pBueffel,"Unknown error %d found",*iCode);
|
|
strncpy(error,pBueffel,iErrLen);
|
|
break;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
/*-----------------------------------------------------------------------*/
|
|
int EL755_Send(void **handle, char *pCom, char *reply, int iLen);
|
|
/*
|
|
* added to el755_utility by M.K.
|
|
*/
|
|
/*--------------------------------------------------------------------------*/
|
|
static int EL755Send(pEVDriver self, char *pCommand, char *pReply, int iLen)
|
|
{
|
|
pEL755Driv pMe = NULL;
|
|
char *pPtr = NULL;
|
|
char pBueffel[132];
|
|
int iRet;
|
|
|
|
assert(self);
|
|
pMe = (pEL755Driv)self->pPrivate;
|
|
assert(pMe);
|
|
|
|
if(strlen(pCommand) > 130)
|
|
return 0;
|
|
|
|
/* make sure that we have a \r at the end */
|
|
strcpy(pBueffel,pCommand);
|
|
if(strrchr(pBueffel,(int)'\r') == NULL)
|
|
{
|
|
strcat(pBueffel,"\r");
|
|
}
|
|
|
|
return EL755_Send(&(pMe->pData),pBueffel,pReply,iLen);
|
|
}
|
|
/*--------------------------------------------------------------------------*/
|
|
static int EL755Init(pEVDriver self)
|
|
{
|
|
pEL755Driv pMe = NULL;
|
|
int iRet;
|
|
|
|
assert(self);
|
|
pMe = (pEL755Driv )self->pPrivate;
|
|
assert(pMe);
|
|
|
|
pMe->pData = NULL;
|
|
iRet = EL755_Open(&(pMe->pData),pMe->pHost,pMe->iPort,pMe->iChannel,
|
|
pMe->iIndex);
|
|
return iRet;
|
|
}
|
|
/*--------------------------------------------------------------------------*/
|
|
static int EL755Close(pEVDriver self)
|
|
{
|
|
pEL755Driv pMe = NULL;
|
|
int iRet;
|
|
|
|
assert(self);
|
|
pMe = (pEL755Driv )self->pPrivate;
|
|
assert(pMe);
|
|
|
|
EL755_Close(&(pMe->pData),0);
|
|
return 1;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
static int EL755Fix(pEVDriver self, int iError)
|
|
{
|
|
pEL755Driv pMe = NULL;
|
|
int iRet;
|
|
|
|
assert(self);
|
|
pMe = (pEL755Driv )self->pPrivate;
|
|
assert(pMe);
|
|
|
|
switch(iError)
|
|
{
|
|
case EL755__TURNED_OFF:
|
|
case EL755__TOO_MANY:
|
|
case EL755__TOO_LARGE:
|
|
case EL755__OUT_OF_RANGE:
|
|
case EL755__BAD_PAR:
|
|
case EL755__BAD_SOCKET:
|
|
case EL755__BAD_MALLOC:
|
|
case EL755__BAD_DEV:
|
|
case EL755__BAD_CMD:
|
|
case EL755__BAD_ASYNSRV:
|
|
return DEVFAULT;
|
|
break;
|
|
case EL755__OVFLOW:
|
|
case EL755__BAD_TMO:
|
|
case EL755__BAD_ILLG:
|
|
return DEVREDO;
|
|
break;
|
|
case EL755__OFFLINE:
|
|
case EL755__BAD_OFL:
|
|
EL755_PutOnline(&(pMe->pData),2);
|
|
return DEVREDO;
|
|
break;
|
|
case EL755__NO_SOCKET:
|
|
case EL755__NOT_OPEN:
|
|
case EL755__FORCED_CLOSED:
|
|
EL755_Open(&(pMe->pData),pMe->pHost,pMe->iPort,
|
|
pMe->iChannel,pMe->iIndex);
|
|
return DEVREDO;
|
|
break;
|
|
default:
|
|
return DEVFAULT;
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
static int EL755Halt(pEVDriver *self)
|
|
{
|
|
assert(self);
|
|
|
|
return 1;
|
|
}
|
|
/*------------------------------------------------------------------------*/
|
|
void KillEL755(void *pData)
|
|
{
|
|
pEL755Driv pMe = NULL;
|
|
|
|
pMe = (pEL755Driv)pData;
|
|
assert(pMe);
|
|
|
|
if(pMe->pHost)
|
|
{
|
|
free(pMe->pHost);
|
|
}
|
|
free(pMe);
|
|
}
|
|
/*------------------------------------------------------------------------*/
|
|
pEVDriver CreateEL755Driv(int argc, char *argv[])
|
|
{
|
|
pEVDriver pNew = NULL;
|
|
pEL755Driv pSim = NULL;
|
|
|
|
/* check for arguments */
|
|
if(argc < 4)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
pNew = CreateEVDriver(argc,argv);
|
|
pSim = (pEL755Driv)malloc(sizeof(EL755Driv));
|
|
memset(pSim,0,sizeof(EL755Driv));
|
|
if(!pNew || !pSim)
|
|
{
|
|
return NULL;
|
|
}
|
|
pNew->pPrivate = pSim;
|
|
pNew->KillPrivate = KillEL755;
|
|
|
|
pSim->iLastError = 0;
|
|
pSim->pHost = strdup(argv[0]);
|
|
pSim->iPort = atoi(argv[1]);
|
|
pSim->iChannel = atoi(argv[2]);
|
|
pSim->iIndex = atoi(argv[3]);
|
|
|
|
/* initialise function pointers */
|
|
pNew->SetValue = EL755Run;
|
|
pNew->GetValue = GetEL755Pos;
|
|
pNew->Send = EL755Send;
|
|
pNew->GetError = EL755Error;
|
|
pNew->TryFixIt = EL755Fix;
|
|
pNew->Init = EL755Init;
|
|
pNew->Close = EL755Close;
|
|
|
|
return pNew;
|
|
}
|
|
|
|
|
|
|