- Rearranged directory structure for forking out ANSTO
- Refactored site specific stuff into a site module - PSI specific stuff is now in the PSI directory. - The old version has been tagged with pre-ansto
This commit is contained in:
cvs
999
bruker.c
Normal file
999
bruker.c
Normal file
@ -0,0 +1,999 @@
|
||||
/*-------------------------------------------------------------------------
|
||||
B r u k e r
|
||||
|
||||
An environment control driver and an additonal wrapper function for
|
||||
controlling a Bruker B-EC-1 magnet controller. This controller can
|
||||
either control a current or control the current through an external hall
|
||||
sensor mesuring the magnetic field. In both cases both values: the field
|
||||
and the current must be readable.
|
||||
|
||||
copyright: see copyright.h
|
||||
|
||||
Mark Koennecke, October 1998
|
||||
---------------------------------------------------------------------------*/
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
#include <tcl.h>
|
||||
#include <math.h>
|
||||
#include <assert.h>
|
||||
#include <fortify.h>
|
||||
#include <sics.h>
|
||||
#include <obpar.h>
|
||||
#include <evcontroller.h>
|
||||
#include <evcontroller.i>
|
||||
#include <evdriver.i>
|
||||
#include "hardsup/serialsinq.h"
|
||||
#include "hardsup/el734_errcodes.h"
|
||||
#include "hardsup/el734fix.h"
|
||||
#include "bruker.h"
|
||||
|
||||
/*
|
||||
#define debug 1
|
||||
*/
|
||||
/*-----------------------------------------------------------------------
|
||||
The Bruker Data Structure
|
||||
*/
|
||||
typedef struct {
|
||||
void *pData;
|
||||
char *pHost;
|
||||
int iPort;
|
||||
int iChannel;
|
||||
int iMode;
|
||||
int iLastError;
|
||||
} BrukerDriv, *pBrukerDriv;
|
||||
/*-----------------------------------------------------------------------
|
||||
A couple of defines for Bruker modes and special error conditions
|
||||
*/
|
||||
#define FIELD 100
|
||||
#define CURRENT 200
|
||||
|
||||
/* errors */
|
||||
#define NOFUNC -1601
|
||||
#define BADARG -1602
|
||||
#define NOACCESS -1603
|
||||
#define BADRANGE -1604
|
||||
#define ERRPENDING -1605
|
||||
#define NOPOWER -1606
|
||||
#define NOTFIELD -1607
|
||||
#define BADINTERN -1608
|
||||
#define NOCONN -1609
|
||||
#define BTIMEOUT -1610
|
||||
#define NOPOLUNIT -1620
|
||||
|
||||
/* polarity */
|
||||
#define PPLUS 0
|
||||
#define PMINUS 1
|
||||
#define PBUSY 3
|
||||
|
||||
/* rmtrail.c */
|
||||
extern char *rmtrail(char *p);
|
||||
|
||||
/*---------------------------------------------------------------------------
|
||||
This Bruker thing has a lot of internal error conditions and a few nasty
|
||||
habits. Such as to lock up after an error ocurred until the error is reset.
|
||||
Or to switch the power off, when a current above the limit is requested
|
||||
after setting a bad value for the magnetic field. These problems can be
|
||||
detected by analysing the return values from the Bruker. Usually the Bruker
|
||||
returns the command given to the user plus additional values if requested.
|
||||
On an error a string of the type E0n is appended to the command echo with
|
||||
n being a small integer. In order to handle this all commands to the Bruker
|
||||
are processed through this special function which takes care of the error
|
||||
handling.
|
||||
*/
|
||||
static int BrukerCommand(pBrukerDriv self, char *pCommand,
|
||||
char *pReplyBuffer, int iReplyLen)
|
||||
{
|
||||
int iTest, iCode;
|
||||
char *pPtr;
|
||||
|
||||
assert(self);
|
||||
assert(iReplyLen > 20); /* so small a buffer will hide errors */
|
||||
|
||||
if(self->pData == NULL)
|
||||
{
|
||||
self->iLastError = NOCONN;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* send the command to the Bruker */
|
||||
rmtrail(pCommand);
|
||||
iTest = SerialWriteRead(&(self->pData), pCommand,pReplyBuffer, iReplyLen);
|
||||
#ifdef debug
|
||||
printf("Comm: %s , Reply %s\n",pCommand,pReplyBuffer);
|
||||
#endif
|
||||
if(iTest != 1) /* communication error */
|
||||
{
|
||||
self->iLastError = iTest;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* identify timeout */
|
||||
if(strstr(pReplyBuffer,"?TMO") != NULL)
|
||||
{
|
||||
self->iLastError = BTIMEOUT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* try to find a E0 response indicating a Bruker error */
|
||||
if( (pPtr = strstr(pReplyBuffer,"E0")) == NULL)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* decode the error */
|
||||
sscanf(pPtr+1,"%x",&iCode);
|
||||
switch(iCode)
|
||||
{
|
||||
case 1:
|
||||
self->iLastError = NOFUNC;
|
||||
break;
|
||||
case 2:
|
||||
self->iLastError = BADARG;
|
||||
break;
|
||||
case 4:
|
||||
self->iLastError = NOACCESS;
|
||||
break;
|
||||
case 5:
|
||||
self->iLastError = BADRANGE;
|
||||
break;
|
||||
case 7:
|
||||
self->iLastError = ERRPENDING;
|
||||
break;
|
||||
case 9:
|
||||
self->iLastError = NOPOWER;
|
||||
break;
|
||||
case 10:
|
||||
self->iLastError = NOTFIELD;
|
||||
break;
|
||||
default:
|
||||
self->iLastError = BADINTERN;
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
/*-------------------------------------------------------------------------*/
|
||||
int BrukerReadField(pEVControl pEva, float *fField)
|
||||
{
|
||||
pBrukerDriv self = NULL;
|
||||
int iRet;
|
||||
char pBueffel[80];
|
||||
char pCommand[6];
|
||||
char *pPtr,*pSign;
|
||||
int iSign = 1;
|
||||
float fVal;
|
||||
|
||||
self = (pBrukerDriv)pEva->pDriv->pPrivate;
|
||||
assert(self);
|
||||
|
||||
if(self->pData == NULL)
|
||||
{
|
||||
self->iLastError = NOCONN;
|
||||
return 0;
|
||||
}
|
||||
|
||||
strcpy(pCommand,"FIE/");
|
||||
iRet = BrukerCommand(self,pCommand,pBueffel,79);
|
||||
if(!iRet)
|
||||
{
|
||||
*fField = -99;
|
||||
return 0;
|
||||
}
|
||||
|
||||
pPtr = pBueffel+4; /* skip over echo */
|
||||
/* deal with obstructing sign */
|
||||
if( (pSign = strchr(pPtr,'+')) != NULL)
|
||||
{
|
||||
*pSign = ' ';
|
||||
iSign = 1;
|
||||
}
|
||||
if( (pSign = strchr(pPtr,'-')) != NULL)
|
||||
{
|
||||
*pSign = ' ';
|
||||
iSign = -1;
|
||||
}
|
||||
sscanf(pPtr,"%f",&fVal);
|
||||
*fField = iSign * fVal;
|
||||
return 1;
|
||||
}
|
||||
/*-------------------------------------------------------------------------*/
|
||||
int BrukerReadCurrent(pEVControl pEva, float *fField)
|
||||
{
|
||||
pBrukerDriv self = NULL;
|
||||
int iRet, iSign = 1;
|
||||
char pBueffel[80];
|
||||
char pCommand[6];
|
||||
char *pPtr, *pSign = NULL;
|
||||
float fVal;
|
||||
|
||||
self = (pBrukerDriv)pEva->pDriv->pPrivate;
|
||||
assert(self);
|
||||
|
||||
if(self->pData == NULL)
|
||||
{
|
||||
self->iLastError = NOCONN;
|
||||
return 0;
|
||||
}
|
||||
|
||||
strcpy(pCommand,"CHN/");
|
||||
iRet = BrukerCommand(self,pCommand,pBueffel,79);
|
||||
if(!iRet)
|
||||
{
|
||||
*fField = -99;
|
||||
return 0;
|
||||
}
|
||||
|
||||
pPtr = pBueffel+4; /* skip over echo */
|
||||
/* deal with obstructing sign */
|
||||
if( (pSign = strchr(pPtr,'+')) != NULL)
|
||||
{
|
||||
*pSign = ' ';
|
||||
iSign = 1;
|
||||
}
|
||||
if( (pSign = strchr(pPtr,'-')) != NULL)
|
||||
{
|
||||
*pSign = ' ';
|
||||
iSign = -1;
|
||||
}
|
||||
sscanf(pPtr,"%f",&fVal);
|
||||
*fField = iSign * fVal;
|
||||
return 1;
|
||||
}
|
||||
/*-------------------------------------------------------------------------*/
|
||||
static int BrukerGet(pEVDriver pEva, float *fValue)
|
||||
{
|
||||
pBrukerDriv self = NULL;
|
||||
int iRet, iSign = 1;
|
||||
char pBueffel[80];
|
||||
char pCommand[6];
|
||||
char *pPtr, *pSign = NULL;
|
||||
float fVal;
|
||||
|
||||
self = (pBrukerDriv)pEva->pPrivate;
|
||||
assert(self);
|
||||
|
||||
if(self->pData == NULL)
|
||||
{
|
||||
self->iLastError = NOCONN;
|
||||
return 0;
|
||||
}
|
||||
|
||||
if(self->iMode == FIELD)
|
||||
{
|
||||
strcpy(pCommand,"CUF/");
|
||||
iRet = BrukerCommand(self,pCommand,pBueffel,79);
|
||||
}
|
||||
else if(self->iMode == CURRENT)
|
||||
{
|
||||
strcpy(pCommand,"CUR/");
|
||||
iRet = BrukerCommand(self,pCommand,pBueffel,79);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* programming error */
|
||||
assert(1);
|
||||
}
|
||||
|
||||
if(!iRet)
|
||||
{
|
||||
*fValue = -99;
|
||||
return 0;
|
||||
}
|
||||
|
||||
pPtr = pBueffel+4; /* skip over echo */
|
||||
/* deal with obstructing sign */
|
||||
if( (pSign = strchr(pPtr,'+')) != NULL)
|
||||
{
|
||||
*pSign = ' ';
|
||||
iSign = 1;
|
||||
}
|
||||
if( (pSign = strchr(pPtr,'-')) != NULL)
|
||||
{
|
||||
*pSign = ' ';
|
||||
iSign = -1;
|
||||
}
|
||||
sscanf(pPtr,"%f",&fVal);
|
||||
*fValue = iSign * fVal;
|
||||
return 1;
|
||||
}
|
||||
/*-------------------------------------------------------------------------*/
|
||||
static int BrukerRun(pEVDriver pEva, float fVal)
|
||||
{
|
||||
pBrukerDriv self = NULL;
|
||||
int iRet;
|
||||
char pBueffel[80];
|
||||
char pCommand[40];
|
||||
char *pPtr;
|
||||
|
||||
self = (pBrukerDriv)pEva->pPrivate;
|
||||
assert(self);
|
||||
|
||||
if(self->pData == NULL)
|
||||
{
|
||||
self->iLastError = NOCONN;
|
||||
return 0;
|
||||
}
|
||||
|
||||
if(self->iMode == FIELD)
|
||||
{
|
||||
sprintf(pCommand,"PTF=%-6.2f",fVal);
|
||||
iRet = BrukerCommand(self,pCommand,pBueffel,79);
|
||||
}
|
||||
else if(self->iMode == CURRENT)
|
||||
{
|
||||
sprintf(pCommand,"PNT=%-6.2f",fVal);
|
||||
iRet = BrukerCommand(self,pCommand,pBueffel,79);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* programming error */
|
||||
assert(1);
|
||||
}
|
||||
|
||||
if(!iRet)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
/*------------------------------------------------------------------------*/
|
||||
static int BrukerError(pEVDriver pEva, int *iCode, char *pError,
|
||||
int iErrLen)
|
||||
{
|
||||
pBrukerDriv self = NULL;
|
||||
|
||||
self = (pBrukerDriv)pEva->pPrivate;
|
||||
assert(self);
|
||||
|
||||
*iCode = self->iLastError;
|
||||
switch(*iCode)
|
||||
{
|
||||
case NOFUNC:
|
||||
strncpy(pError,
|
||||
"Function not supported",
|
||||
iErrLen);
|
||||
break;
|
||||
case BADINTERN:
|
||||
case BADARG:
|
||||
strncpy(pError,
|
||||
"Programming problem, reset Controller & contact Programmer",
|
||||
iErrLen);
|
||||
break;
|
||||
case NOTFIELD:
|
||||
strncpy(pError,"Bruker not switched to field mode",iErrLen);
|
||||
break;
|
||||
case BADRANGE:
|
||||
strncpy(pError,"Requested value out of range",iErrLen);
|
||||
break;
|
||||
case NOACCESS:
|
||||
strncpy(pError,"No Access, check key position at Controller",
|
||||
iErrLen);
|
||||
break;
|
||||
case ERRPENDING:
|
||||
strncpy(pError,"Error condition pending in Bruker Controller",
|
||||
iErrLen);
|
||||
break;
|
||||
case NOPOWER:
|
||||
strncpy(pError,
|
||||
"Power OFF as consequence of some error in Bruker Controller",
|
||||
iErrLen);
|
||||
break;
|
||||
case NOCONN:
|
||||
strncpy(pError,"No Connection to Bruker Controller",iErrLen);
|
||||
break;
|
||||
case BTIMEOUT:
|
||||
strncpy(pError,"Timeout at serial port",iErrLen);
|
||||
break;
|
||||
case NOPOLUNIT:
|
||||
strncpy(pError,"No polarity switching unit, try setting negative current",
|
||||
iErrLen);
|
||||
break;
|
||||
default:
|
||||
SerialError(*iCode,pError,iErrLen);
|
||||
break;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
static int BrukerSend(pEVDriver pEva, char *pCommand, char *pReply,
|
||||
int iReplyLen)
|
||||
{
|
||||
pBrukerDriv self = NULL;
|
||||
int iRet;
|
||||
|
||||
self = (pBrukerDriv)pEva->pPrivate;
|
||||
assert(self);
|
||||
|
||||
if(self->pData == NULL)
|
||||
{
|
||||
self->iLastError = NOCONN;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
iRet = SerialWriteRead(&(self->pData),pCommand, pReply, iReplyLen);
|
||||
if(iRet != 1)
|
||||
{
|
||||
self->iLastError = iRet;
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
/*--------------------------------------------------------------------------*/
|
||||
static int BrukerInit(pEVDriver pEva)
|
||||
{
|
||||
pBrukerDriv self = NULL;
|
||||
int iRet;
|
||||
char pBueffel[80], pCommand[20];
|
||||
|
||||
self = (pBrukerDriv)pEva->pPrivate;
|
||||
assert(self);
|
||||
|
||||
/* open port connection */
|
||||
self->pData = NULL;
|
||||
iRet = SerialOpen(&(self->pData),self->pHost, self->iPort, self->iChannel);
|
||||
if(iRet != 1)
|
||||
{
|
||||
self->iLastError = iRet;
|
||||
return 0;
|
||||
}
|
||||
/* configure serial port terminators */
|
||||
SerialSendTerm(&(self->pData),"\r");
|
||||
SerialATerm(&(self->pData),"1\r\n");
|
||||
|
||||
/* set power on */
|
||||
strcpy(pCommand,"DCP=1");
|
||||
iRet = SerialWriteRead(&(self->pData),pCommand,pBueffel,80);
|
||||
if(iRet != 1)
|
||||
{
|
||||
self->iLastError = iRet;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* switch to current mode as default init mode */
|
||||
self->iMode = CURRENT;
|
||||
strcpy(pCommand,"EXT=0");
|
||||
iRet = SerialWriteRead(&(self->pData),pCommand,pBueffel,80);
|
||||
if(iRet != 1)
|
||||
{
|
||||
self->iLastError = iRet;
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
/*-------------------------------------------------------------------------*/
|
||||
static int BrukerClose(pEVDriver pEva)
|
||||
{
|
||||
pBrukerDriv self = NULL;
|
||||
|
||||
self = (pBrukerDriv)pEva->pPrivate;
|
||||
assert(self);
|
||||
|
||||
SerialClose(&(self->pData));
|
||||
self->pData = 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
static int BrukerFix(pEVDriver self, int iError)
|
||||
{
|
||||
pBrukerDriv pMe = NULL;
|
||||
int iRet;
|
||||
char pCommand[20], pBueffel[80];
|
||||
|
||||
assert(self);
|
||||
pMe = (pBrukerDriv )self->pPrivate;
|
||||
assert(pMe);
|
||||
|
||||
switch(iError)
|
||||
{
|
||||
/* network errors */
|
||||
case EL734__BAD_FLUSH:
|
||||
case EL734__BAD_RECV:
|
||||
case EL734__BAD_RECV_NET:
|
||||
case EL734__BAD_RECV_UNKN:
|
||||
case EL734__BAD_RECVLEN:
|
||||
case EL734__BAD_RECV1:
|
||||
case EL734__BAD_RECV1_PIPE:
|
||||
case EL734__BAD_RNG:
|
||||
case EL734__BAD_SEND:
|
||||
case EL734__BAD_SEND_PIPE:
|
||||
case EL734__BAD_SEND_NET:
|
||||
case EL734__BAD_SEND_UNKN:
|
||||
case EL734__BAD_SENDLEN:
|
||||
BrukerClose(self);
|
||||
iRet = BrukerInit(self);
|
||||
if(iRet)
|
||||
{
|
||||
return DEVREDO;
|
||||
}
|
||||
else
|
||||
{
|
||||
return DEVFAULT;
|
||||
}
|
||||
break;
|
||||
case EL734__FORCED_CLOSED:
|
||||
case NOCONN:
|
||||
iRet = BrukerInit(self);
|
||||
if(iRet)
|
||||
{
|
||||
return DEVREDO;
|
||||
}
|
||||
else
|
||||
{
|
||||
return DEVFAULT;
|
||||
}
|
||||
break;
|
||||
/* fixable Bruker Errors */
|
||||
case ERRPENDING:
|
||||
strcpy(pCommand,"RST=0");
|
||||
iRet = BrukerCommand(pMe,pCommand, pBueffel,79);
|
||||
if(iRet)
|
||||
{
|
||||
return DEVREDO;
|
||||
}
|
||||
else
|
||||
{
|
||||
return DEVFAULT;
|
||||
}
|
||||
break;
|
||||
case NOPOWER:
|
||||
strcpy(pCommand,"RST=0");
|
||||
iRet = BrukerCommand(pMe,pCommand, pBueffel,79);
|
||||
strcpy(pCommand,"DCP=1");
|
||||
iRet = BrukerCommand(pMe,pCommand, pBueffel,79);
|
||||
if(iRet)
|
||||
{
|
||||
return DEVREDO;
|
||||
}
|
||||
else
|
||||
{
|
||||
return DEVFAULT;
|
||||
}
|
||||
break;
|
||||
case NOTFIELD:
|
||||
strcpy(pCommand,"EXT=2");
|
||||
iRet = BrukerCommand(pMe,pCommand, pBueffel,79);
|
||||
if(iRet)
|
||||
{
|
||||
return DEVREDO;
|
||||
}
|
||||
else
|
||||
{
|
||||
return DEVFAULT;
|
||||
}
|
||||
break;
|
||||
/* handable protocoll errors */
|
||||
case EL734__BAD_TMO:
|
||||
case BTIMEOUT:
|
||||
case NOFUNC:
|
||||
return DEVREDO;
|
||||
break;
|
||||
default:
|
||||
return DEVFAULT;
|
||||
break;
|
||||
}
|
||||
return DEVFAULT;
|
||||
}
|
||||
/*------------------------------------------------------------------------*/
|
||||
void KillBruker(void *pData)
|
||||
{
|
||||
pBrukerDriv pMe = NULL;
|
||||
|
||||
pMe = (pBrukerDriv)pData;
|
||||
assert(pMe);
|
||||
|
||||
if(pMe->pHost)
|
||||
{
|
||||
free(pMe->pHost);
|
||||
}
|
||||
free(pMe);
|
||||
}
|
||||
/*------------------------------------------------------------------------*/
|
||||
pEVDriver CreateBrukerDriver(int argc, char *argv[])
|
||||
{
|
||||
pEVDriver pNew = NULL;
|
||||
pBrukerDriv pSim = NULL;
|
||||
|
||||
/* check for arguments */
|
||||
if(argc < 3)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
pNew = CreateEVDriver(argc,argv);
|
||||
pSim = (pBrukerDriv)malloc(sizeof(BrukerDriv));
|
||||
memset(pSim,0,sizeof(BrukerDriv));
|
||||
if(!pNew || !pSim)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
pNew->pPrivate = pSim;
|
||||
pNew->KillPrivate = KillBruker;
|
||||
|
||||
/* initalise pBrukerDriver */
|
||||
pSim->iLastError = 0;
|
||||
pSim->pHost = strdup(argv[0]);
|
||||
pSim->iPort = atoi(argv[1]);
|
||||
pSim->iChannel = atoi(argv[2]);
|
||||
|
||||
|
||||
/* initialise function pointers */
|
||||
pNew->SetValue = BrukerRun;
|
||||
pNew->GetValue = BrukerGet;
|
||||
pNew->Send = BrukerSend;
|
||||
pNew->GetError = BrukerError;
|
||||
pNew->TryFixIt = BrukerFix;
|
||||
pNew->Init = BrukerInit;
|
||||
pNew->Close = BrukerClose;
|
||||
|
||||
return pNew;
|
||||
}
|
||||
/*-------------------------------------------------------------------------*/
|
||||
int BrukerSetMode(pEVControl pEva, SConnection *pCon, int iMode)
|
||||
{
|
||||
pBrukerDriv self = NULL;
|
||||
int iRet;
|
||||
char pBueffel[80];
|
||||
char pCommand[6];
|
||||
char *pPtr;
|
||||
|
||||
self = (pBrukerDriv)pEva->pDriv->pPrivate;
|
||||
assert(self);
|
||||
|
||||
if(self->pData == NULL)
|
||||
{
|
||||
self->iLastError = NOCONN;
|
||||
return 0;
|
||||
}
|
||||
|
||||
if(iMode == CURRENT)
|
||||
{
|
||||
strcpy(pCommand,"EXT=0");
|
||||
}
|
||||
else if(iMode == FIELD)
|
||||
{
|
||||
strcpy(pCommand,"EXT=2");
|
||||
}
|
||||
else
|
||||
{
|
||||
SCWrite(pCon,"ERROR: Internal: invalid mode for Bruker given",eError);
|
||||
return 0;
|
||||
}
|
||||
iRet = BrukerCommand(self,pCommand,pBueffel,79);
|
||||
if(!iRet)
|
||||
{
|
||||
strcpy(pBueffel,"ERROR:");
|
||||
BrukerError(pEva->pDriv,&iRet,(pBueffel+7),70);
|
||||
SCWrite(pCon,pBueffel,eError);
|
||||
return 0;
|
||||
}
|
||||
self->iMode = iMode;
|
||||
return 1;
|
||||
}
|
||||
/*-------------------------------------------------------------------------*/
|
||||
int BrukerGetPolarity(pEVControl pEva, SConnection *pCon, int *iMode)
|
||||
{
|
||||
pBrukerDriv self = NULL;
|
||||
int iRet;
|
||||
char pBueffel[80];
|
||||
char pCommand[6];
|
||||
char *pPtr;
|
||||
|
||||
self = (pBrukerDriv)pEva->pDriv->pPrivate;
|
||||
assert(self);
|
||||
|
||||
if(self->pData == NULL)
|
||||
{
|
||||
self->iLastError = NOCONN;
|
||||
return 0;
|
||||
}
|
||||
strcpy(pCommand,"POL/");
|
||||
iRet = BrukerCommand(self,pCommand,pBueffel,79);
|
||||
if(!iRet)
|
||||
{
|
||||
strcpy(pBueffel,"ERROR:");
|
||||
BrukerError(pEva->pDriv,&iRet,(pBueffel+7),70);
|
||||
SCWrite(pCon,pBueffel,eError);
|
||||
return 0;
|
||||
}
|
||||
pPtr = pBueffel+4;
|
||||
sscanf(pPtr,"%d",iMode);
|
||||
return 1;
|
||||
}
|
||||
/*------------------------------------------------------------------------*/
|
||||
int BrukerSetPolarity(pEVControl pEva, SConnection *pCon, int iMode)
|
||||
{
|
||||
pBrukerDriv self = NULL;
|
||||
int iRet;
|
||||
char pBueffel[80];
|
||||
char pCommand[6];
|
||||
char *pPtr;
|
||||
|
||||
self = (pBrukerDriv)pEva->pDriv->pPrivate;
|
||||
assert(self);
|
||||
|
||||
if(self->pData == NULL)
|
||||
{
|
||||
self->iLastError = NOCONN;
|
||||
return 0;
|
||||
}
|
||||
|
||||
if(iMode == PPLUS)
|
||||
{
|
||||
strcpy(pCommand,"POL=0");
|
||||
}
|
||||
else if(iMode == PMINUS)
|
||||
{
|
||||
strcpy(pCommand,"POL=1");
|
||||
}
|
||||
else
|
||||
{
|
||||
assert(1); /* programming error */
|
||||
}
|
||||
|
||||
iRet = BrukerCommand(self,pCommand,pBueffel,79);
|
||||
if( (strstr(pBueffel,"POL=0E01") != NULL) ||
|
||||
(strstr(pBueffel,"POL=1E01") != NULL) )
|
||||
{
|
||||
self->iLastError = NOPOLUNIT;
|
||||
iRet = 0;
|
||||
}
|
||||
if(!iRet)
|
||||
{
|
||||
strcpy(pBueffel,"ERROR:");
|
||||
BrukerError(pEva->pDriv,&iRet,(pBueffel+6),70);
|
||||
SCWrite(pCon,pBueffel,eError);
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
/*--------------------------------------------------------------------------
|
||||
handle Bruker specific commands:
|
||||
- polarity for switching polarity
|
||||
- field for reading field
|
||||
- current for reading current
|
||||
- mode for setting and retrieving the current control mode
|
||||
- list append our own stuff to the rest
|
||||
in all other cases fall back and call EVControllerWrapper to handle it or
|
||||
eventually throw an error.
|
||||
*/
|
||||
int BrukerAction(SConnection *pCon, SicsInterp *pSics, void *pData,
|
||||
int argc, char *argv[])
|
||||
{
|
||||
|
||||
pEVControl self = NULL;
|
||||
int iRet, iMode;
|
||||
char pBueffel[256];
|
||||
pBrukerDriv pMe = NULL;
|
||||
float fVal;
|
||||
|
||||
self = (pEVControl)pData;
|
||||
assert(self);
|
||||
pMe = (pBrukerDriv)self->pDriv->pPrivate;
|
||||
assert(pMe);
|
||||
|
||||
if(argc > 1)
|
||||
{
|
||||
strtolower(argv[1]);
|
||||
/*------ polarity */
|
||||
if(strcmp(argv[1],"polarity") == 0)
|
||||
{
|
||||
if(argc > 2) /* set case */
|
||||
{
|
||||
strtolower(argv[2]);
|
||||
if(strcmp(argv[2],"plus") == 0)
|
||||
{
|
||||
iMode = PPLUS;
|
||||
}
|
||||
else if(strcmp(argv[2],"minus") == 0)
|
||||
{
|
||||
iMode = PMINUS;
|
||||
}
|
||||
else
|
||||
{
|
||||
sprintf(pBueffel,"ERROR: %s is no knwon polarity mode", argv[2]);
|
||||
SCWrite(pCon,pBueffel,eError);
|
||||
return 0;
|
||||
}
|
||||
/* check permission */
|
||||
if(!SCMatchRights(pCon,usUser))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
/* do it */
|
||||
iRet = BrukerSetPolarity(self,pCon,iMode);
|
||||
if(iRet)
|
||||
{
|
||||
SCSendOK(pCon);
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
else /* get case */
|
||||
{
|
||||
iRet = BrukerGetPolarity(self,pCon,&iMode);
|
||||
if(iRet)
|
||||
{
|
||||
if(iMode == PPLUS)
|
||||
{
|
||||
sprintf(pBueffel,"%s.polarity = plus",argv[0]);
|
||||
}
|
||||
else if (iMode == PMINUS)
|
||||
{
|
||||
sprintf(pBueffel,"%s.polarity = minus",argv[0]);
|
||||
}
|
||||
else
|
||||
{
|
||||
assert(1); /* programming problem */
|
||||
}
|
||||
SCWrite(pCon,pBueffel,eValue);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
/*-------- control mode */
|
||||
else if(strcmp(argv[1],"mode") == 0)
|
||||
{
|
||||
if(argc > 2) /* set case */
|
||||
{
|
||||
strtolower(argv[2]);
|
||||
if(strcmp(argv[2],"field") == 0)
|
||||
{
|
||||
iMode = FIELD;
|
||||
}
|
||||
else if(strcmp(argv[2],"current") == 0)
|
||||
{
|
||||
iMode = CURRENT;
|
||||
}
|
||||
else
|
||||
{
|
||||
sprintf(pBueffel,"ERROR: %s is no known control mode", argv[2]);
|
||||
SCWrite(pCon,pBueffel,eError);
|
||||
return 0;
|
||||
}
|
||||
/* check permission */
|
||||
if(!SCMatchRights(pCon,usUser))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
/* do it */
|
||||
iRet = BrukerSetMode(self,pCon,iMode);
|
||||
if(iRet)
|
||||
{
|
||||
SCSendOK(pCon);
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
else /* get case */
|
||||
{
|
||||
if(pMe->iMode == FIELD)
|
||||
{
|
||||
sprintf(pBueffel,"%s.mode = field",argv[0]);
|
||||
}
|
||||
else if (pMe->iMode == CURRENT)
|
||||
{
|
||||
sprintf(pBueffel,"%s.mode = current",argv[0]);
|
||||
}
|
||||
else
|
||||
{
|
||||
assert(1); /* programming problem */
|
||||
}
|
||||
SCWrite(pCon,pBueffel,eValue);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
/*-----------field */
|
||||
else if(strcmp(argv[1],"field") == 0)
|
||||
{
|
||||
iRet = BrukerReadField(self,&fVal);
|
||||
if(!iRet)
|
||||
{
|
||||
strcpy(pBueffel,"ERROR: ");
|
||||
self->pDriv->GetError(self->pDriv,&iMode,pBueffel+7,240);
|
||||
SCWrite(pCon,pBueffel,eError);
|
||||
return 0;
|
||||
}
|
||||
sprintf(pBueffel,"%s.field = %f Tesla",argv[0],fVal);
|
||||
SCWrite(pCon,pBueffel,eValue);
|
||||
return 1;
|
||||
}
|
||||
/*----------- current */
|
||||
else if(strcmp(argv[1],"current") == 0)
|
||||
{
|
||||
iRet = BrukerReadCurrent(self,&fVal);
|
||||
if(!iRet)
|
||||
{
|
||||
strcpy(pBueffel,"ERROR: ");
|
||||
self->pDriv->GetError(self->pDriv,&iMode,pBueffel+7,240);
|
||||
SCWrite(pCon,pBueffel,eError);
|
||||
return 0;
|
||||
}
|
||||
sprintf(pBueffel,"%s.current = %f A",argv[0],fVal);
|
||||
SCWrite(pCon,pBueffel,eValue);
|
||||
return 1;
|
||||
}
|
||||
/*--------- list */
|
||||
else if(strcmp(argv[1],"list") == 0)
|
||||
{
|
||||
/* print generals first */
|
||||
EVControlWrapper(pCon,pSics,pData,argc,argv);
|
||||
/* print our add on stuff */
|
||||
iRet = BrukerReadCurrent(self,&fVal);
|
||||
if(!iRet)
|
||||
{
|
||||
strcpy(pBueffel,"ERROR: ");
|
||||
self->pDriv->GetError(self->pDriv,&iMode,pBueffel+7,240);
|
||||
SCWrite(pCon,pBueffel,eError);
|
||||
}
|
||||
else
|
||||
{
|
||||
sprintf(pBueffel,"%s.current = %f A",argv[0],fVal);
|
||||
SCWrite(pCon,pBueffel,eValue);
|
||||
}
|
||||
iRet = BrukerReadField(self,&fVal);
|
||||
if(!iRet)
|
||||
{
|
||||
strcpy(pBueffel,"ERROR: ");
|
||||
self->pDriv->GetError(self->pDriv,&iMode,pBueffel+7,240);
|
||||
SCWrite(pCon,pBueffel,eError);
|
||||
}
|
||||
else
|
||||
{
|
||||
sprintf(pBueffel,"%s.field = %f Tesla",argv[0],fVal);
|
||||
SCWrite(pCon,pBueffel,eValue);
|
||||
}
|
||||
if(pMe->iMode == FIELD)
|
||||
{
|
||||
sprintf(pBueffel,"%s.mode = field",argv[0]);
|
||||
}
|
||||
else if (pMe->iMode == CURRENT)
|
||||
{
|
||||
sprintf(pBueffel,"%s.mode = current",argv[0]);
|
||||
}
|
||||
else
|
||||
{
|
||||
sprintf(pBueffel,"ERROR: Programming error");
|
||||
}
|
||||
SCWrite(pCon,pBueffel,eValue);
|
||||
iRet = BrukerGetPolarity(self,pCon,&iMode);
|
||||
if(iRet)
|
||||
{
|
||||
if(iMode == PPLUS)
|
||||
{
|
||||
sprintf(pBueffel,"%s.polarity = plus",argv[0]);
|
||||
}
|
||||
else if (iMode == PMINUS)
|
||||
{
|
||||
sprintf(pBueffel,"%s.polarity = minus",argv[0]);
|
||||
}
|
||||
else if(iMode == PBUSY)
|
||||
{
|
||||
sprintf(pBueffel,"%s.polarity = busy",argv[0]);
|
||||
}
|
||||
else
|
||||
{
|
||||
sprintf(pBueffel,"ERROR: Programming problem");
|
||||
}
|
||||
SCWrite(pCon,pBueffel,eValue);
|
||||
}
|
||||
else
|
||||
{
|
||||
SCWrite(pCon,"ERROR: cannot read polarity",eError);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
return EVControlWrapper(pCon,pSics,pData,argc,argv);
|
||||
}
|
||||
}
|
||||
return EVControlWrapper(pCon,pSics,pData,argc,argv);
|
||||
}
|
||||
Reference in New Issue
Block a user