linse/sics
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

superflous file (now in psi)

Browse Source
This commit is contained in:
zolliker
2004-12-01 12:09:22 +00:00
parent 092eaaaa2f
commit 4f1c724255
1 changed files with 0 additions and 395 deletions
Download Patch File Download Diff File Expand all files Collapse all files

395
eurodriv.c
View File

@ -1,395 +0,0 @@
/*--------------------------------------------------------------------------
E U R O D R I V
This file contains the implementation for the Eurotherm temperature
controller as used at SANS. The Eurotherm is a grossly strange device
which has a very weird command protocoll. The implementation here uses
the EI-Bisynch Protocoll option. This has to be configured in the
Eurotherm on the manual interface!! Also watch out for the unusual RS232-
setting: 7 bits, even parity, 1 stop bit.
Mark Koennecke, May 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"
typedef struct __EVDriver *pEVDriver;
#include "evdriver.i"
#include "psi/hardsup/el734_def.h"
#include "psi/hardsup/el734fix.h"
#include "psi/hardsup/serialsinq.h"
#include "eurodriv.h"
#define INVALIDANSWER -1005
#define INVALIDNUMBER -1006
#define ERRNAK -1007
#define NOSEND -1008
/*-----------------------------------------------------------------------*/
typedef struct {
void *pData;
char *pHost;
int iPort;
int iChannel;
int iLastError;
} EuroDriv, *pEuroDriv;
/*------------------------------------------------------------------------*/
int EuroGetParameter(void **pData, char *pPar,int iLen, float *fVal)
{
char pCommand[20];
char pReply[20];
char *pStart = NULL, *pEnd = NULL;
int iRet,i;
/* configure the serial port */
SerialATerm(pData,"1\x3"); /* ETX */
pCommand[0] = '\x4'; /* EOT */
pCommand[1] = '0'; /* GID*/
pCommand[2] = '0'; /* GID*/
pCommand[3] = '1'; /* UID*/
pCommand[4] = '1'; /* UID*/
pCommand[5] = '1'; /* CHAN */
for(i = 0; i < iLen; i++)
{
pCommand[6+i] = pPar[i];
}
pCommand[6+iLen] = '\x5'; /* ENQ*/
pCommand[7+iLen] = '\0';
/* send */
iRet = SerialWriteRead(pData,pCommand,pReply,19);
if(iRet != 1)
{
return iRet;
}
/* decode reply */
pStart = strstr(pReply,pPar);
if(!pStart)
{
if(strstr(pReply,"?TMO"))
{
return EL734__BAD_TMO;
}
else
{
return INVALIDANSWER;
}
}
iRet = sscanf(pStart+strlen(pPar),"%f",fVal);
if(iRet != 1)
{
return INVALIDNUMBER;
}
return 1;
}
/*------------------------------------------------------------------------*/
int EuroSetParameter(void **pData, char *pPar,int iLen,
char *pFormat, float fVal)
{
char pCommand[30];
char pNum[10];
char *pPtr, *pPtr2;
char pReply[20];
char bcc;
int iRet,i;
/* configure the serial port */
SerialATerm(pData,"1\x06\x15"); /* ACK,NAK */
pCommand[0] = '\x04'; /* EOT */
pCommand[1] = '0'; /* GID*/
pCommand[2] = '0'; /* GID*/
pCommand[3] = '1'; /* UID*/
pCommand[4] = '1'; /* UID*/
pCommand[5] = '\x02';
pCommand[6] = '1'; /* CHAN */
for(i = 0; i < iLen; i++)
{
pCommand[7+i] = pPar[i];
}
pPtr = pCommand + 7 + iLen;
sprintf(pNum,pFormat,fVal);
strcpy(pPtr,pNum);
pPtr += strlen(pNum);
*pPtr = '\x03';
pPtr++;
/* build the checksum */
bcc = pCommand[6];
pPtr2 = &pCommand[7];
while(pPtr2 != pPtr)
{
bcc = bcc ^ *pPtr2;
pPtr2++;
}
*pPtr = bcc;
pPtr++;
*pPtr = '\0';
/* send */
iRet = SerialSend(pData,pCommand);
if(iRet != 1)
{
return iRet;
}
iRet = SerialReceiveWithTerm(pData,pReply,19,&bcc);
/*
printf("%s\n",pReply);
*/
if(iRet != 1)
{
return iRet;
}
if(bcc == '\x15')
{
return ERRNAK;
}
if(strstr(pReply,"?TMO"))
{
return EL734__BAD_TMO;
}
return 1;
}
/*---------------------------------------------------------------------------*/
static int GetEuroPos(pEVDriver self, float *fPos)
{
pEuroDriv pMe = NULL;
int iRet;
assert(self);
pMe = (pEuroDriv)self->pPrivate;
assert(pMe);
iRet = EuroGetParameter(&(pMe->pData),"PV",2,fPos);
if(iRet != 1)
{
pMe->iLastError = iRet;
return 0;
}
return 1;
}
/*----------------------------------------------------------------------------*/
static int EuroRun(pEVDriver self, float fVal)
{
pEuroDriv pMe = NULL;
int iRet;
assert(self);
pMe = (pEuroDriv )self->pPrivate;
assert(pMe);
iRet = EuroSetParameter(&(pMe->pData),"SL",2,"%4.1f",fVal);
if(iRet != 1)
{
pMe->iLastError = iRet;
return 0;
}
return 1;
}
/*--------------------------------------------------------------------------*/
static int EuroError(pEVDriver self, int *iCode, char *error, int iErrLen)
{
pEuroDriv pMe = NULL;
assert(self);
pMe = (pEuroDriv)self->pPrivate;
assert(pMe);
*iCode = pMe->iLastError;
switch(pMe->iLastError)
{
case INVALIDANSWER:
strncpy(error,"Unexpected reply from Eurotherm",iErrLen);
break;
case INVALIDNUMBER:
strncpy(error,"No number in Eurotherm answer",iErrLen);
break;
case ERRNAK:
strncpy(error,"Eurothem did NOT acknowledge command",iErrLen);
break;
case NOSEND:
strncpy(error,
"Eurotherm has a bizarre protocoll, sending things is very STUPID",iErrLen);
break;
default:
SerialError(pMe->iLastError,error,iErrLen);
break;
}
return 1;
}
/*--------------------------------------------------------------------------*/
static int EuroSend(pEVDriver self, char *pCommand, char *pReply, int iLen)
{
pEuroDriv pMe = NULL;
assert(self);
pMe = (pEuroDriv)self->pPrivate;
assert(pMe);
pMe->iLastError = NOSEND;
strncpy(pReply,"ERROR: Eurotherm does not support send functionality",
iLen);
return 0;
}
/*--------------------------------------------------------------------------*/
static int EuroInit(pEVDriver self)
{
pEuroDriv pMe = NULL;
int iRet;
assert(self);
pMe = (pEuroDriv )self->pPrivate;
assert(pMe);
pMe->pData = NULL;
iRet = SerialOpen(&pMe->pData, pMe->pHost, pMe->iPort, pMe->iChannel);
if(iRet != 1)
{
pMe->iLastError = iRet;
return 0;
}
SerialSendTerm(&pMe->pData,"");
return 1;
}
/*--------------------------------------------------------------------------*/
static int EuroClose(pEVDriver self)
{
pEuroDriv pMe = NULL;
int iRet;
assert(self);
pMe = (pEuroDriv )self->pPrivate;
assert(pMe);
SerialClose(&pMe->pData);
return 1;
}
/*---------------------------------------------------------------------------*/
static int EuroFix(pEVDriver self, int iError)
{
pEuroDriv pMe = NULL;
int iRet;
assert(self);
pMe = (pEuroDriv )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:
EuroClose(self);
iRet = EuroInit(self);
if(iRet)
{
return DEVREDO;
}
else
{
return DEVFAULT;
}
break;
/* handable protocoll errors */
case EL734__BAD_TMO:
return DEVREDO;
break;
case ERRNAK:
case NOSEND:
case INVALIDANSWER:
case INVALIDNUMBER:
return DEVFAULT;
default:
return DEVFAULT;
break;
}
return DEVFAULT;
}
/*--------------------------------------------------------------------------*/
static int EuroHalt(pEVDriver *self)
{
assert(self);
return 1;
}
/*------------------------------------------------------------------------*/
void KillEuro(void *pData)
{
pEuroDriv pMe = NULL;
pMe = (pEuroDriv)pData;
assert(pMe);
if(pMe->pHost)
{
free(pMe->pHost);
}
free(pMe);
}
/*------------------------------------------------------------------------*/
pEVDriver CreateEURODriv(int argc, char *argv[])
{
pEVDriver pNew = NULL;
pEuroDriv pSim = NULL;
/* check for arguments */
if(argc < 3)
{
return NULL;
}
pNew = CreateEVDriver(argc,argv);
pSim = (pEuroDriv)malloc(sizeof(EuroDriv));
memset(pSim,0,sizeof(EuroDriv));
if(!pNew || !pSim)
{
return NULL;
}
pNew->pPrivate = pSim;
pNew->KillPrivate = KillEuro;
/* initalise pDILLUDriver */
pSim->iLastError = 0;
pSim->pHost = strdup(argv[0]);
pSim->iPort = atoi(argv[1]);
pSim->iChannel = atoi(argv[2]);
/* initialise function pointers */
pNew->SetValue = EuroRun;
pNew->GetValue = GetEuroPos;
pNew->Send = EuroSend;
pNew->GetError = EuroError;
pNew->TryFixIt = EuroFix;
pNew->Init = EuroInit;
pNew->Close = EuroClose;
return pNew;
}