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

- Added Sycamore protocol and command context to SICS

Browse Source 
- Added sinfo to SICS
- Added driver for TCP/IP Astrium velocity selector
- Added driver for TCP/IP Astrium chopper controller
This commit is contained in:
koennecke
2005-12-22 22:16:13 +00:00
parent 6b224a4520
commit a5f315b56a
22 changed files with 2225 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
amor2t.c
View File

@ -674,7 +674,7 @@
pAmor2T pNew, pAOM = NULL; pAmor2T pNew, pAOM = NULL;
int i, iRet; int i, iRet;
char pBueffel[512]; char pBueffel[512];
char *pMot = NULL; const char *pMot = NULL;
if(argc < 4) if(argc < 4)
{ {
@ -710,7 +710,7 @@
A2TKill(pNew); A2TKill(pNew);
return 0; return 0;
} }
pNew->aEngine[MOTMOM] = FindMotor(pSics,pMot); pNew->aEngine[MOTMOM] = FindMotor(pSics,(char *)pMot);
if(!pNew->aEngine[MOTMOM]) if(!pNew->aEngine[MOTMOM])
{ {
sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot); sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot);
@ -726,7 +726,7 @@
A2TKill(pNew); A2TKill(pNew);
return 0; return 0;
} }
pNew->aEngine[MOTSOM] = FindMotor(pSics,pMot); pNew->aEngine[MOTSOM] = FindMotor(pSics,(char *)pMot);
if(!pNew->aEngine[MOTSOM]) if(!pNew->aEngine[MOTSOM])
{ {
sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot); sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot);
@ -742,7 +742,7 @@
A2TKill(pNew); A2TKill(pNew);
return 0; return 0;
} }
pNew->aEngine[MOTCOZ] = FindMotor(pSics,pMot); pNew->aEngine[MOTCOZ] = FindMotor(pSics,(char *)pMot);
if(!pNew->aEngine[MOTCOZ]) if(!pNew->aEngine[MOTCOZ])
{ {
sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot); sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot);
@ -758,7 +758,7 @@
A2TKill(pNew); A2TKill(pNew);
return 0; return 0;
} }
pNew->aEngine[MOTCOX] = FindMotor(pSics,pMot); pNew->aEngine[MOTCOX] = FindMotor(pSics,(char *)pMot);
if(!pNew->aEngine[MOTCOX]) if(!pNew->aEngine[MOTCOX])
{ {
sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot); sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot);
@ -774,7 +774,7 @@
A2TKill(pNew); A2TKill(pNew);
return 0; return 0;
} }
pNew->aEngine[MOTSTZ] = FindMotor(pSics,pMot); pNew->aEngine[MOTSTZ] = FindMotor(pSics,(char *)pMot);
if(!pNew->aEngine[MOTSTZ]) if(!pNew->aEngine[MOTSTZ])
{ {
sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot); sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot);
@ -790,7 +790,7 @@
A2TKill(pNew); A2TKill(pNew);
return 0; return 0;
} }
pNew->aEngine[MOTSOZ] = FindMotor(pSics,pMot); pNew->aEngine[MOTSOZ] = FindMotor(pSics,(char *)pMot);
if(!pNew->aEngine[MOTSOZ]) if(!pNew->aEngine[MOTSOZ])
{ {
sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot); sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot);
@ -806,7 +806,7 @@
A2TKill(pNew); A2TKill(pNew);
return 0; return 0;
} }
pNew->aEngine[MOTD4B] = FindMotor(pSics,pMot); pNew->aEngine[MOTD4B] = FindMotor(pSics,(char *)pMot);
if(!pNew->aEngine[MOTD4B]) if(!pNew->aEngine[MOTD4B])
{ {
sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot); sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot);
@ -822,7 +822,7 @@
A2TKill(pNew); A2TKill(pNew);
return 0; return 0;
} }
pNew->aEngine[MOTD5B] = FindMotor(pSics,pMot); pNew->aEngine[MOTD5B] = FindMotor(pSics,(char *)pMot);
if(!pNew->aEngine[MOTD5B]) if(!pNew->aEngine[MOTD5B])
{ {
sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot); sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot);
@ -838,7 +838,7 @@
A2TKill(pNew); A2TKill(pNew);
return 0; return 0;
} }
pNew->aEngine[MOTCOM] = FindMotor(pSics,pMot); pNew->aEngine[MOTCOM] = FindMotor(pSics,(char *)pMot);
if(!pNew->aEngine[MOTCOM]) if(!pNew->aEngine[MOTCOM])
{ {
sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot); sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot);
@ -854,7 +854,7 @@
A2TKill(pNew); A2TKill(pNew);
return 0; return 0;
} }
pNew->aEngine[MOTAOZ] = FindMotor(pSics,pMot); pNew->aEngine[MOTAOZ] = FindMotor(pSics,(char *)pMot);
if(!pNew->aEngine[MOTAOZ]) if(!pNew->aEngine[MOTAOZ])
{ {
sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot); sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot);
@ -870,7 +870,7 @@
A2TKill(pNew); A2TKill(pNew);
return 0; return 0;
} }
pNew->aEngine[MOTAOM] = FindMotor(pSics,pMot); pNew->aEngine[MOTAOM] = FindMotor(pSics,(char *)pMot);
if(!pNew->aEngine[MOTAOM]) if(!pNew->aEngine[MOTAOM])
{ {
sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot); sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot);
@ -886,7 +886,7 @@
A2TKill(pNew); A2TKill(pNew);
return 0; return 0;
} }
pNew->aEngine[MOTC3Z] = FindMotor(pSics,pMot); pNew->aEngine[MOTC3Z] = FindMotor(pSics,(char *)pMot);
if(!pNew->aEngine[MOTC3Z]) if(!pNew->aEngine[MOTC3Z])
{ {
sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot); sprintf(pBueffel,"ERROR: motor %s NOT found!", pMot);

40
amorstat.c
View File

@ -50,7 +50,8 @@
static int iTOF = 0; static int iTOF = 0;
static pHistMem pHMHM = NULL; static pHistMem pHMHM = NULL;
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
static int HMCountStartCallback(int iEvent, void *pEvent, void *pUser) static int HMCountStartCallback(int iEvent, void *pEvent, void *pUser,
commandContext cc)
{ {
SConnection *pCon = (SConnection *)pUser; SConnection *pCon = (SConnection *)pUser;
const float *fTime = NULL; const float *fTime = NULL;
@ -75,15 +76,18 @@
iTime[i+1] = htonl((int)((fTime[i]/10.)*65536.)); iTime[i+1] = htonl((int)((fTime[i]/10.)*65536.));
} }
/* send new time binning to all clients */ /* send new time binning to all clients */
SCPushContext2(pCon,cc);
SCWrite(pCon,"TOFClear",eError); SCWrite(pCon,"TOFClear",eError);
SCWriteUUencoded(pCon,"arrowaxis_time",iTime, SCWriteUUencoded(pCon,"arrowaxis_time",iTime,
(iLength+1)*sizeof(int)); (iLength+1)*sizeof(int));
SCPopContext(pCon);
free(iTime); free(iTime);
} }
return 1; return 1;
} }
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
static int ScanStartCallback(int iEvent, void *pEvent, void *pUser) static int ScanStartCallback(int iEvent, void *pEvent, void *pUser,
commandContext cc)
{ {
float *fAxis = NULL; float *fAxis = NULL;
int *iAxis = NULL; int *iAxis = NULL;
@ -116,16 +120,19 @@
iAxis[i+1] = htonl((int)(fAxis[i]*65536.)); iAxis[i+1] = htonl((int)(fAxis[i]*65536.));
} }
/* send new axis to client */ /* send new axis to client */
SCPushContext2(pCon,cc);
SCWrite(pCon,"SCANClear",eError); SCWrite(pCon,"SCANClear",eError);
SCWriteUUencoded(pCon,pBueffel,iAxis, SCWriteUUencoded(pCon,pBueffel,iAxis,
(iLength+1)*sizeof(int)); (iLength+1)*sizeof(int));
SCPopContext(pCon);
free(iAxis); free(iAxis);
free(fAxis); free(fAxis);
} }
return 1; return 1;
} }
/*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/
static int ScanPointCallback(int iEvent, void *pEvent, void *pUser) static int ScanPointCallback(int iEvent, void *pEvent, void *pUser,
commandContext cc)
{ {
long *lData = NULL; long *lData = NULL;
int *iData = NULL; int *iData = NULL;
@ -155,6 +162,7 @@
iData[i+1] = htonl((int)(lData[i])); iData[i+1] = htonl((int)(lData[i]));
} }
/* send counts to client */ /* send counts to client */
SCPushContext2(pCon,cc);
SCWriteUUencoded(pCon,"arrow_spinupup",iData, SCWriteUUencoded(pCon,"arrow_spinupup",iData,
(iLength+1)*sizeof(int)); (iLength+1)*sizeof(int));
/* send counts for other detector */ /* send counts for other detector */
@ -166,6 +174,7 @@
SCWriteUUencoded(pCon,"arrow_spinuplo",iData, SCWriteUUencoded(pCon,"arrow_spinuplo",iData,
(iLength+1)*sizeof(int)); (iLength+1)*sizeof(int));
/* to do: check for polarization and send spinlo */ /* to do: check for polarization and send spinlo */
SCPopContext(pCon);
free(iData); free(iData);
free(lData); free(lData);
} }
@ -201,7 +210,8 @@
return 0; return 0;
} }
/*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/
static int LoadCallback(int iEvent, void *pEvent, void *pUser) static int LoadCallback(int iEvent, void *pEvent, void *pUser,
commandContext cc)
{ {
pAmorStat pAS = NULL; pAmorStat pAS = NULL;
SConnection *pCon = NULL; SConnection *pCon = NULL;
@ -212,7 +222,9 @@
pCon = (SConnection *)pUser; pCon = (SConnection *)pUser;
assert(pAS); assert(pAS);
assert(pCon); assert(pCon);
SCPushContext2(pCon,cc);
SendLoadedData(pAS,pCon); SendLoadedData(pAS,pCon);
SCPopContext(pCon);
} }
return 1; return 1;
} }
@ -378,6 +390,7 @@
long lID; long lID;
pDummy pDum = NULL; pDummy pDum = NULL;
pICallBack pCall = NULL; pICallBack pCall = NULL;
commandContext comCon;
assert(self); assert(self);
assert(pCon); assert(pCon);
@ -386,8 +399,9 @@
iTOF invoke the apropriate callbacks in order to force iTOF invoke the apropriate callbacks in order to force
an initial update. an initial update.
*/ */
comCon = SCGetContext(pCon);
/* file load callback */ /* file load callback */
lID = RegisterCallback(self->pCall, FILELOADED, LoadCallback, lID = RegisterCallback(self->pCall, comCon,FILELOADED, LoadCallback,
pCon, NULL); pCon, NULL);
SCRegister(pCon,pServ->pSics, self->pCall,lID); SCRegister(pCon,pServ->pSics, self->pCall,lID);
SendLoadedData(self,pCon); SendLoadedData(self,pCon);
@ -397,31 +411,31 @@
pCall = pDum->pDescriptor->GetInterface(pDum,CALLBACKINTERFACE); pCall = pDum->pDescriptor->GetInterface(pDum,CALLBACKINTERFACE);
if(pCall) if(pCall)
{ {
lID = RegisterCallback(pCall,SCANSTART,ScanStartCallback, lID = RegisterCallback(pCall,comCon,SCANSTART,ScanStartCallback,
pCon, NULL); pCon, NULL);
SCRegister(pCon,pServ->pSics,pCall,lID); SCRegister(pCon,pServ->pSics,pCall,lID);
lID = RegisterCallback(pCall,SCANPOINT,ScanPointCallback, lID = RegisterCallback(pCall,comCon,SCANPOINT,ScanPointCallback,
pCon, NULL); pCon, NULL);
SCRegister(pCon,pServ->pSics,pCall,lID); SCRegister(pCon,pServ->pSics,pCall,lID);
lID = RegisterCallback(pCall,SCANEND,ScanPointCallback, lID = RegisterCallback(pCall,comCon,SCANEND,ScanPointCallback,
pCon, NULL); pCon, NULL);
SCRegister(pCon,pServ->pSics,pCall,lID); SCRegister(pCon,pServ->pSics,pCall,lID);
if(iTOF == 0) if(iTOF == 0)
{ {
ScanStartCallback(SCANSTART,pDum,pCon); ScanStartCallback(SCANSTART,pDum,pCon,SCGetContext(pCon));
ScanPointCallback(SCANPOINT,pDum,pCon); ScanPointCallback(SCANPOINT,pDum,pCon,SCGetContext(pCon));
} }
} }
pDum = (pDummy)self->pHM; pDum = (pDummy)self->pHM;
pCall = pDum->pDescriptor->GetInterface(pDum,CALLBACKINTERFACE); pCall = pDum->pDescriptor->GetInterface(pDum,CALLBACKINTERFACE);
if(pCall) if(pCall)
{ {
lID = RegisterCallback(pCall,COUNTSTART,HMCountStartCallback, lID = RegisterCallback(pCall,comCon,COUNTSTART,HMCountStartCallback,
pCon, NULL); pCon, NULL);
SCRegister(pCon,pServ->pSics,pCall,lID); SCRegister(pCon,pServ->pSics,pCall,lID);
if(iTOF == 1) if(iTOF == 1)
{ {
HMCountStartCallback(COUNTSTART,pDum,pCon); HMCountStartCallback(COUNTSTART,pDum,pCon,SCGetContext(pCon));
} }
} }
return 1; return 1;
@ -1001,7 +1015,7 @@
} }
else if(strcmp(argv[1],"tofmode") == 0) else if(strcmp(argv[1],"tofmode") == 0)
{ {
HMCountStartCallback(COUNTSTART,NULL,pCon); HMCountStartCallback(COUNTSTART,NULL,pCon,SCGetContext(pCon));
return 1; return 1;
} }
else else

2
dornier2.c
View File

@ -595,7 +595,7 @@ static int DornierStatNew(pVelSelDriv self, int *iCode, float *fCur){
{ {
pVelSelDriv pNew = NULL; pVelSelDriv pNew = NULL;
pDornier pDorn = NULL; pDornier pDorn = NULL;
char *pPtr = NULL; const char *pPtr = NULL;
int iVal, iRet, iPort; int iVal, iRet, iPort;
char pHost[132]; char pHost[132];

4
ecb.c
View File

@ -24,7 +24,7 @@
#define READ_BYTES 3 #define READ_BYTES 3
#define WRITE_BYTES 4 #define WRITE_BYTES 4
#define DMAREAD 5 #define DMAREAD 5
#define ECB_BYTES 65536L #define ECB_BYTES 65535
typedef union /* Used to swap bytes in 'address' and 'byte_count' */ typedef union /* Used to swap bytes in 'address' and 'byte_count' */
{ {
@ -112,7 +112,7 @@ static int ecbPrepareIO(pECB self, int func, unsigned short address,
Swap save, adr, count; Swap save, adr, count;
int status, bytes; int status, bytes;
if(byteCount > ECB_BYTES){ if(byteCount >= ECB_BYTES){
self->lastError = ECBOVERFLOW; self->lastError = ECBOVERFLOW;
return 0; return 0;
} }

45
el734hp.c
View File

@ -392,6 +392,27 @@ static void EL734Error(void *pData, int *iCode, char *error, int errLen){
} }
} }
/*----------------------------------------------------------------------*/ /*----------------------------------------------------------------------*/
static int EL734Halt(void *pData){
pEL734Driv self = NULL;
int status;
char pCommand[50],pReply[80];
self = (pEL734Driv)pData;
assert(self);
snprintf(pCommand,79,"s %d\r",self->iMotor);
status = transactEL734(self->controller,pCommand,strlen(pCommand),
pReply,79);
if(status != 1){
self->errorCode = status;
return 0;
}
if(!checkResponse(self,pReply)){
return 0;
}
return 1;
}
/*----------------------------------------------------------------------*/
static int EL734Fix(void *pData, int iCode, float fValue){ static int EL734Fix(void *pData, int iCode, float fValue){
pEL734Driv self = NULL; pEL734Driv self = NULL;
int status, msr, i, len = 49; int status, msr, i, len = 49;
@ -404,7 +425,10 @@ static int EL734Fix(void *pData, int iCode, float fValue){
case BADADR: case BADADR:
case BADCMD: case BADCMD:
case BADPAR: case BADPAR:
return MOTREDO;
case BADBSY: case BADBSY:
EL734Halt(pData);
SicsWait(1);
return MOTREDO; return MOTREDO;
case TIMEOUT: case TIMEOUT:
for(i = 0; i < 3; i++){ for(i = 0; i < 3; i++){
@ -466,27 +490,6 @@ static int EL734Fix(void *pData, int iCode, float fValue){
} }
return MOTFAIL; return MOTFAIL;
} }
/*----------------------------------------------------------------------*/
static int EL734Halt(void *pData){
pEL734Driv self = NULL;
int status;
char pCommand[50],pReply[80];
self = (pEL734Driv)pData;
assert(self);
snprintf(pCommand,79,"s %d\r",self->iMotor);
status = transactEL734(self->controller,pCommand,strlen(pCommand),
pReply,79);
if(status != 1){
self->errorCode = status;
return 0;
}
if(!checkResponse(self,pReply)){
return 0;
}
return 1;
}
/*--------------------------------------------------------------------*/ /*--------------------------------------------------------------------*/
static int EL734GetPar(void *pData, char *name, static int EL734GetPar(void *pData, char *name,
float *fValue){ float *fValue){

13
fowrite.c
View File

@ -67,7 +67,8 @@
/*------------------ The Countstart Callback Function ----------------------*/ /*------------------ The Countstart Callback Function ----------------------*/
static int Countstartcallback(int iEvent, void *pEventData, void *pUser) static int Countstartcallback(int iEvent, void *pEventData, void *pUser,
commandContext cc)
{ {
pFoWrite self = NULL; pFoWrite self = NULL;
@ -85,7 +86,8 @@
return 1; return 1;
} }
/*------------------ The Countend Callback Function ----------------------*/ /*------------------ The Countend Callback Function ----------------------*/
static int Countendcallback(int iEvent, void *pEventData, void *pUser) static int Countendcallback(int iEvent, void *pEventData, void *pUser,
commandContext cc)
{ {
pFoWrite self = NULL; pFoWrite self = NULL;
@ -941,6 +943,7 @@
pICallBack pCall = NULL; pICallBack pCall = NULL;
pDummy pDum; pDummy pDum;
pHMcontrol pHMC = NULL; pHMcontrol pHMC = NULL;
commandContext comCon;
/* check arguments */ /* check arguments */
if(argc < 4 ) if(argc < 4 )
@ -1026,8 +1029,10 @@
pNew->pCount = (pCounter)pCom->pData; pNew->pCount = (pCounter)pCom->pData;
} }
RegisterCallback(pHMC->pCall,COUNTSTART,Countstartcallback,pNew,NULL); comCon.transID = 0;
RegisterCallback(pHMC->pCall,COUNTEND,Countendcallback,pNew,NULL); strncpy(comCon.deviceID,"internal",SCDEVIDLEN);
RegisterCallback(pHMC->pCall,comCon,COUNTSTART,Countstartcallback,pNew,NULL);
RegisterCallback(pHMC->pCall,comCon,COUNTEND,Countendcallback,pNew,NULL);
/* install command */ /* install command */
AddCommand(pSics,"StoreFocus",FoAction,KillFoWrite,pNew); AddCommand(pSics,"StoreFocus",FoAction,KillFoWrite,pNew);

BIN
libpsi.a
View File

Binary file not shown.

6
make_gen
View File

@ -16,10 +16,10 @@ OBJ=psi.o buffer.o ruli.o dmc.o nxsans.o nextrics.o sps.o pimotor.o \
el755driv.o amorscan.o serial.o scontroller.o t_update.o \ el755driv.o amorscan.o serial.o scontroller.o t_update.o \
t_rlp.o t_conv.o el737hpdriv.o dornier2.o el734hp.o \ t_rlp.o t_conv.o el737hpdriv.o dornier2.o el734hp.o \
el737hpv2driv.o swmotor2.o tricssupport.o amorcomp.o \ el737hpv2driv.o swmotor2.o tricssupport.o amorcomp.o \
$(MZOBJ) amordrive.o amorset.o \ $(MZOBJ) amordrive.o amorset.o tcpdornier.o\
dgrambroadcast.o sinq.o tabledrive.o dgrambroadcast.o sinq.o tabledrive.o tcpdocho.o
MZOBJ=fsm.o logger.o sugar.o pardef.o ease.o strobj.o oxinst.o logreader.o \ MZOBJ=fsm.o logger.o sugar.o pardef.o ease.o strobj.o oxinst.o \
ipsdriv.o ilmdriv.o itcdriv.o ighdriv.o euro2kdriv.o modbus.o ipsdriv.o ilmdriv.o itcdriv.o ighdriv.o euro2kdriv.o modbus.o
libpsi.a: $(OBJ) libpsi.a: $(OBJ)

8
nextrics.c
View File

@ -1339,7 +1339,7 @@ name of hkl object holding crystallographic information
return iRet; return iRet;
} }
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
static int FrameInterest(int iEvent, void *pEvent, void *pUser) static int FrameInterest(int iEvent, void *pEvent, void *pUser, commandContext cc)
{ {
SConnection *pCon = NULL; SConnection *pCon = NULL;
int *iFrame; int *iFrame;
@ -1354,7 +1354,9 @@ name of hkl object holding crystallographic information
iFrame = (int *)pEvent; iFrame = (int *)pEvent;
assert(pCon); assert(pCon);
sprintf(pBueffel,"framenumber = %d",*iFrame); sprintf(pBueffel,"framenumber = %d",*iFrame);
SCPushContext2(pCon,cc);
SCWrite(pCon,pBueffel,eWarning); SCWrite(pCon,pBueffel,eWarning);
SCPopContext(pCon);
return 1; return 1;
} }
/*------------------------------------------------------------------------- /*-------------------------------------------------------------------------
@ -1454,6 +1456,7 @@ name of hkl object holding crystallographic information
char pBueffel[1024]; char pBueffel[1024];
int iRet, iDet, iFrame; int iRet, iDet, iFrame;
long lID; long lID;
commandContext comCon;
self = (pNexTrics)pData; self = (pNexTrics)pData;
assert(self); assert(self);
@ -1470,6 +1473,7 @@ name of hkl object holding crystallographic information
/* install an error handler */ /* install an error handler */
NXMSetError((void *)pCon,SNError); NXMSetError((void *)pCon,SNError);
comCon = SCGetContext(pCon);
strtolower(argv[1]); strtolower(argv[1]);
if(strcmp(argv[1],"start") == 0) if(strcmp(argv[1],"start") == 0)
{ {
@ -1505,7 +1509,7 @@ name of hkl object holding crystallographic information
} }
else if(strcmp(argv[1],"interest") == 0) else if(strcmp(argv[1],"interest") == 0)
{ {
lID = RegisterCallback(self->pCall, NEWFRAME, FrameInterest, lID = RegisterCallback(self->pCall, comCon, NEWFRAME, FrameInterest,
pCon, NULL); pCon, NULL);
SCRegister(pCon,pSics, self->pCall,lID); SCRegister(pCon,pSics, self->pCall,lID);
SCSendOK(pCon); SCSendOK(pCon);

7
pardef.c
View File

@ -239,12 +239,15 @@ int ParLog(void *object) {
return next; return next;
} }
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
static int ParCallBack(int event, void *eventData, void *userData) { static int ParCallBack(int event, void *eventData, void *userData,
commandContext cc) {
char *pBuf = (char *)eventData; char *pBuf = (char *)eventData;
SConnection *con = (SConnection *)userData; SConnection *con = (SConnection *)userData;
if (event == VALUECHANGE) { if (event == VALUECHANGE) {
SCPushContext2(con,cc);
SCWrite(con,pBuf,eValue); SCWrite(con,pBuf,eValue);
SCPopContext(con);
return 1; return 1;
} }
return 1; return 1;
@ -356,7 +359,7 @@ static int ParExecute(SConnection *con, SicsInterp *sics, void *object, int argc
o->pCall = CreateCallBackInterface(); o->pCall = CreateCallBackInterface();
} }
assert(o->pCall); assert(o->pCall);
id = RegisterCallback(o->pCall, VALUECHANGE, ParCallBack, con, NULL); id = RegisterCallback(o->pCall, SCGetContext(con),VALUECHANGE, ParCallBack, con, NULL);
SCRegister(con, pServ->pSics, o->pCall, id); SCRegister(con, pServ->pSics, o->pCall, id);
SCSendOK(con); SCSendOK(con);
return 1; return 1;

2
pimotor.c
View File

@ -297,7 +297,7 @@
pC804Driv pNew = NULL; pC804Driv pNew = NULL;
int iRet, iVal, iTmo; int iRet, iVal, iTmo;
double dVal; double dVal;
char *pPar = NULL; const char *pPar = NULL;
char pCommand[20], pReply[40]; char pCommand[20], pReply[40];
/* allocate space: the final frontier */ /* allocate space: the final frontier */

2
pipiezo.c
View File

@ -284,7 +284,7 @@
pPiPiezo pNew = NULL; pPiPiezo pNew = NULL;
int iRet, iVal, iTmo; int iRet, iVal, iTmo;
double dVal; double dVal;
char *pPar = NULL; const char *pPar = NULL;
char pCommand[20], pReply[40]; char pCommand[20], pReply[40];
/* allocate space: the final frontier */ /* allocate space: the final frontier */

13
polterwrite.c
View File

@ -53,7 +53,8 @@ typedef struct {
static void PoldiUpdate(pPolterdi self, SConnection *pCon); static void PoldiUpdate(pPolterdi self, SConnection *pCon);
/*------------------ The Countstart Callback Function ----------------------*/ /*------------------ The Countstart Callback Function ----------------------*/
static int Countstartcallback(int iEvent, void *pEventData, void *pUser) static int Countstartcallback(int iEvent, void *pEventData, void *pUser,
commandContext cc)
{ {
pPolterdi self = NULL; pPolterdi self = NULL;
@ -71,7 +72,8 @@ typedef struct {
return 1; return 1;
} }
/*------------------ The Countend Callback Function ----------------------*/ /*------------------ The Countend Callback Function ----------------------*/
static int Countendcallback(int iEvent, void *pEventData, void *pUser) static int Countendcallback(int iEvent, void *pEventData, void *pUser,
commandContext cc)
{ {
pPolterdi self = NULL; pPolterdi self = NULL;
@ -665,6 +667,7 @@ int PolterInstall(SConnection *pCon, SicsInterp *pSics,
pICallBack pCall = NULL; pICallBack pCall = NULL;
pDummy pDum; pDummy pDum;
pHistMem pHist = NULL; pHistMem pHist = NULL;
commandContext comCon;
/* configure fortify */ /* configure fortify */
/* /*
@ -711,8 +714,10 @@ int PolterInstall(SConnection *pCon, SicsInterp *pSics,
KillPolterdi(pNew); KillPolterdi(pNew);
return 0; return 0;
} }
RegisterCallback(pCall,COUNTSTART,Countstartcallback,pNew,NULL); comCon.transID = 0;
RegisterCallback(pCall,COUNTEND,Countendcallback,pNew,NULL); strncpy(comCon.deviceID,"internal",SCDEVIDLEN);
RegisterCallback(pCall,comCon,COUNTSTART,Countstartcallback,pNew,NULL);
RegisterCallback(pCall,comCon,COUNTEND,Countendcallback,pNew,NULL);
AddCommand(pSics,"storedata",PolterAction,KillPolterdi,pNew); AddCommand(pSics,"storedata",PolterAction,KillPolterdi,pNew);
return 1; return 1;

20
psi.c
View File

@ -55,6 +55,12 @@
#include "tabledrive.h" #include "tabledrive.h"
#include "amorset.h" #include "amorset.h"
/*
from tcpdornier.c
*/
extern int VelSelTcpFactory(SConnection *pCon, SicsInterp *pSics, void *pData,
int argc, char *argv[]);
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
void SiteInit(void) { void SiteInit(void) {
@ -62,8 +68,7 @@ void SiteInit(void) {
/* insert here initialization routines ... */ /* insert here initialization routines ... */
INIT(LogReaderInit); INIT(IlmStartup);
INIT(IlmStartup);
INIT(IpsStartup); INIT(IpsStartup);
INIT(ItcStartup); INIT(ItcStartup);
INIT(IghStartup); INIT(IghStartup);
@ -102,6 +107,7 @@ static void AddPsiCommands(SicsInterp *pInter){
AddCommand(pInter,"MakeSinq",SinqFactory,NULL,NULL); AddCommand(pInter,"MakeSinq",SinqFactory,NULL,NULL);
AddCommand(pInter,"MakeTableDrive",TableDriveFactory,NULL,NULL); AddCommand(pInter,"MakeTableDrive",TableDriveFactory,NULL,NULL);
AddCommand(pInter,"MakeAmorSet",AmorSetFactory,NULL,NULL); AddCommand(pInter,"MakeAmorSet",AmorSetFactory,NULL,NULL);
AddCommand(pInter,"MakeTCPSelector",VelSelTcpFactory,NULL,NULL);
/* /*
AddCommand(pInter,"MakeDifrac",MakeDifrac,NULL,NULL); AddCommand(pInter,"MakeDifrac",MakeDifrac,NULL,NULL);
*/ */
@ -121,6 +127,7 @@ static void RemovePsiCommands(SicsInterp *pSics){
RemoveCommand(pSics,"MakeAmor2T"); RemoveCommand(pSics,"MakeAmor2T");
RemoveCommand(pSics,"MakeStoreAmor"); RemoveCommand(pSics,"MakeStoreAmor");
RemoveCommand(pSics,"MakeAmorStatus"); RemoveCommand(pSics,"MakeAmorStatus");
RemoveCommand(pSics,"MakeTCPSelector");
/* /*
RemoveCommand(pSics,"MakeDifrac"); RemoveCommand(pSics,"MakeDifrac");
*/ */
@ -273,6 +280,8 @@ static pVelSelDriv CreatePsiVelSelDriv(char *name, char *array,
extern pCodri MakeDoChoDriver(char *pHost, int iPort, int iChannel, extern pCodri MakeDoChoDriver(char *pHost, int iPort, int iChannel,
int iSingle); int iSingle);
extern pCodri MakeCookerDriver(char *pHost, int iPort, int iChannel); extern pCodri MakeCookerDriver(char *pHost, int iPort, int iChannel);
extern pCodri MakeTcpDoChoDriver(char *tclArray, SConnection *pCon);
/*-------------------------------------------------------------------*/ /*-------------------------------------------------------------------*/
static pCodri CreatePsiController(SConnection *pCon,int argc, char *argv[]){ static pCodri CreatePsiController(SConnection *pCon,int argc, char *argv[]){
pCodri pNew = NULL; pCodri pNew = NULL;
@ -312,6 +321,13 @@ static pCodri CreatePsiController(SConnection *pCon,int argc, char *argv[]){
} }
} }
pNew = MakeDoChoDriver(argv[1],iPort,iChannel,iSingle); pNew = MakeDoChoDriver(argv[1],iPort,iChannel,iSingle);
} else if(strcmp(argv[0],"tcpdocho") == 0){
if(argc < 2){
SCWrite(pCon,"ERROR: insufficient number of argumets for creating TcpDoCho",
eError);
return NULL;
}
return MakeTcpDoChoDriver(argv[1], pCon);
}else if(strcmp(argv[0],"sanscook") == 0) { }else if(strcmp(argv[0],"sanscook") == 0) {
if(argc < 4){ if(argc < 4){
SCWrite(pCon, SCWrite(pCon,

8
scontroller.c
View File

@ -43,7 +43,7 @@ EXTERN void SerialMurder(ClientData pData)
} }
/*------------------ a forward declaration -----------------------------*/ /*------------------ a forward declaration -----------------------------*/
EXTERN int SurielSend(ClientData clientData, Tcl_Interp *interp, EXTERN int SurielSend(ClientData clientData, Tcl_Interp *interp,
int argc, char *argv[]); int argc, const char *argv[]);
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
Controller is the main entry point for this stuff. It connects to a motor Controller is the main entry point for this stuff. It connects to a motor
@ -143,7 +143,7 @@ int Controller(ClientData clientData, Tcl_Interp *interp,
----------------------------------------------------------------------------*/ ----------------------------------------------------------------------------*/
EXTERN int SurielSend(ClientData clientData, Tcl_Interp *interp, EXTERN int SurielSend(ClientData clientData, Tcl_Interp *interp,
int argc, char *argv[]) int argc, const char *argv[])
{ {
char pBueffel[256]; char pBueffel[256];
char pAnswer[256]; char pAnswer[256];
@ -183,7 +183,7 @@ EXTERN int SurielSend(ClientData clientData, Tcl_Interp *interp,
Tcl_AppendResult(interp, "Expected parameter after -tmo",NULL); Tcl_AppendResult(interp, "Expected parameter after -tmo",NULL);
return TCL_ERROR; return TCL_ERROR;
} }
iRet = SerialSendTerm(&(pData),argv[2]); iRet = SerialSendTerm(&(pData),(char *)argv[2]);
if(iRet != 1) if(iRet != 1)
{ {
Tcl_AppendResult(interp,"To many characters for terminator",NULL); Tcl_AppendResult(interp,"To many characters for terminator",NULL);
@ -198,7 +198,7 @@ EXTERN int SurielSend(ClientData clientData, Tcl_Interp *interp,
Tcl_AppendResult(interp, "Expected parameter after -tmo",NULL); Tcl_AppendResult(interp, "Expected parameter after -tmo",NULL);
return TCL_ERROR; return TCL_ERROR;
} }
iRet = SerialATerm(&(pData),argv[2]); iRet = SerialATerm(&(pData),(char *)argv[2]);
if(!iRet) if(!iRet)
{ {
Tcl_AppendResult(interp,"To many characters for terminator",NULL); Tcl_AppendResult(interp,"To many characters for terminator",NULL);

2
serial.c
View File

@ -12,7 +12,7 @@
#include "sics.h" #include "sics.h"
extern int Controller(ClientData pData, Tcl_Interp *pInter, extern int Controller(ClientData pData, Tcl_Interp *pInter,
int argc, char *argv[]); int argc, const char *argv[]);
int SerialInit(SConnection *pCon,SicsInterp *pSics, void *pData, int SerialInit(SConnection *pCon,SicsInterp *pSics, void *pData,
int argc, char *argv[]) int argc, char *argv[])

18
tasinit.c
View File

@ -261,7 +261,8 @@ static int TasSaveStatus(void *self, char *name, FILE *fd)
used on the variables which switch the counter box into the appropriate used on the variables which switch the counter box into the appropriate
mode. mode.
-----------------------------------------------------------------------*/ -----------------------------------------------------------------------*/
static int MonitorCallback(int iEvent, void *pEvent, void *pUser) static int MonitorCallback(int iEvent, void *pEvent, void *pUser,
commandContext cc)
{ {
pTASdata self = (pTASdata)pUser; pTASdata self = (pTASdata)pUser;
assert(self); assert(self);
@ -274,7 +275,8 @@ static int MonitorCallback(int iEvent, void *pEvent, void *pUser)
return 1; return 1;
} }
/*---------------------------------------------------------------------*/ /*---------------------------------------------------------------------*/
static int TimerCallback(int iEvent, void *pEvent, void *pUser) static int TimerCallback(int iEvent, void *pEvent, void *pUser,
commandContext cc)
{ {
pTASdata self = (pTASdata)pUser; pTASdata self = (pTASdata)pUser;
assert(self); assert(self);
@ -309,7 +311,8 @@ static int RecalcAction(SConnection *pCon, SicsInterp *pSics, void *pData,
to allow for the analyzer shielding to settle down. This is done to allow for the analyzer shielding to settle down. This is done
through this callback function through this callback function
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int A6WaitCallback(int iEvent, void *pEventData, void *pUserData) static int A6WaitCallback(int iEvent, void *pEventData, void *pUserData,
commandContext cc)
{ {
if(iEvent == MOTEND) if(iEvent == MOTEND)
{ {
@ -340,6 +343,7 @@ int TASFactory(SConnection *pCon, SicsInterp *pSics, void *pData,
pSicsVariable pVar = NULL; pSicsVariable pVar = NULL;
CommandList *pCom = NULL; CommandList *pCom = NULL;
pMotor pMot = NULL; pMotor pMot = NULL;
commandContext comCon;
/* check arguments*/ /* check arguments*/
if(argc < 2) if(argc < 2)
@ -404,14 +408,16 @@ int TASFactory(SConnection *pCon, SicsInterp *pSics, void *pData,
the variables should have been accessed earlier on. the variables should have been accessed earlier on.
*/ */
pVar = FindVariable(pSics,"MN"); pVar = FindVariable(pSics,"MN");
comCon.transID = 0;
strncpy(comCon.deviceID,"internal",SCDEVIDLEN);
if(pVar) if(pVar)
{ {
RegisterCallback(pVar->pCall,VALUECHANGE,MonitorCallback,pNew,NULL); RegisterCallback(pVar->pCall,comCon,VALUECHANGE,MonitorCallback,pNew,NULL);
} }
pVar = FindVariable(pSics,"TI"); pVar = FindVariable(pSics,"TI");
if(pVar) if(pVar)
{ {
RegisterCallback(pVar->pCall,VALUECHANGE,TimerCallback,pNew,NULL); RegisterCallback(pVar->pCall,comCon,VALUECHANGE,TimerCallback,pNew,NULL);
} }
/* /*
@ -420,7 +426,7 @@ int TASFactory(SConnection *pCon, SicsInterp *pSics, void *pData,
pMot = FindMotor(pSics,"a6"); pMot = FindMotor(pSics,"a6");
if(pMot != NULL) if(pMot != NULL)
{ {
RegisterCallback(pMot->pCall,MOTEND,A6WaitCallback,NULL,NULL); RegisterCallback(pMot->pCall,comCon,MOTEND,A6WaitCallback,NULL,NULL);
} }

2
tasscan.c
View File

@ -599,7 +599,7 @@ static int TASScanPoint(pScanData self, int iPoint)
static void fixPowder(unsigned char tasTargetMask[20]){ static void fixPowder(unsigned char tasTargetMask[20]){
char *pPtr = NULL; char *pPtr = NULL;
pPtr = Tcl_GetVar(pServ->pSics->pTcl,"powder",TCL_GLOBAL_ONLY); pPtr = (char *)Tcl_GetVar(pServ->pSics->pTcl,"powder",TCL_GLOBAL_ONLY);
if(pPtr){ if(pPtr){
if(strstr(pPtr,"1") != NULL){ if(strstr(pPtr,"1") != NULL){
tasTargetMask[2] = 0; tasTargetMask[2] = 0;

929
tcpdocho.c Normal file
View File

@ -0,0 +1,929 @@
/*--------------------------------------------------------------
This is a driver for the newer Astrium == Dornier chopper
systems which use a TCP/IP server for communication.
This driver has to take care of some ugliness:
- As of december 2005, the communication is in unicode!
To go from ASCII to unicode and back one has to
add a 0x00 before each character or to remove it.
- The controller is slow in responding and the controller
must be watched in the environment monitor. This is taken
care of by a special SICS task which updates the status
regularly and returning cached values anytime else.
Inititial Implementation: Mark Koennecke, December 2005
------------------------------------------------------------*/
#include <stdlib.h>
#include <assert.h>
#include <time.h>
#include <fortify.h>
#include <sics.h>
#include <stringdict.h>
#include <rs232controller.h>
#include <codri.h>
#include <stptok.h>
#include <commandlog.h>
/*========================================================================
Our private data structure
========================================================================*/
#define ASYNMODE 0
#define SYNCMODE 1
typedef struct{
prs232 controller;
int iRefreshIntervall;
time_t nextRefresh;
long lTask;
pStringDict parameters;
int lastError;
int numChoppers;
int mode;
int timeout;
char user[132];
char pword[132];
int stop;
int busy;
char *config;
}TcpDoCho, *pTcpDoCho;
/*-----------------------------------------------------------------------
Error codes:
-----------------------------------------------------------------------*/
#define WRONGMODE -8301
#define BADCONVERSION -8302
#define FAILEDCOMMAND -8303
#define BADWRITE -8304
#define BADRESPONSE -8306
#define UNDRIVABLE -8307
#define BADPAR -8308
#define ESTOP -8309
extern char *trim(char *str);
#define ABS(x) (x < 0 ? -(x) : (x))
#define SPEEDTOL 2
#define PHASETOL .5
/*=============== support functions ===================================*/
static int asciiToUnicode(char *input, char **output){
int len, i;
char *result = NULL;
len = strlen(input);
result = (char *)malloc(2*len*sizeof(char));
if(result == NULL){
return 0;
}
memset(result,0,2*len*sizeof(char));
for(i = 0; i < len; i++){
result[i*2] = input[i];
}
*output = result;
return 2*len;
}
/*-------------------------------------------------------------------*/
static int unicodeToAscii(char *input, int len, char **output){
int i, alen;
char *result = NULL;
alen = len/2;
result = (char *)malloc((alen+1)*sizeof(char));
if(result == NULL){
return 0;
}
memset(result,0,(alen+1)*sizeof(char));
for(i = 0; i < alen; i++){
result[i] = input[i*2];
}
*output = result;
return alen;
}
/*----------------------------------------------------------------*/
static int tcpDoChoSend(pTcpDoCho self, char *command, int choNum,
char *value){
char buffer[1024];
char *converted;
int sendlen, status;
/*
format and send command
*/
self->lastError = 0;
if(choNum < 0){
snprintf(buffer,1023,"#SOS#%s \r\n",command);
} else if(value != NULL){
snprintf(buffer,1023,"#SOS#%s%1.1d: %s\r\n",command, choNum,
value);
} else {
snprintf(buffer,1023,"#SOS#%s%1.1d:\r\n",command, choNum);
}
sendlen = asciiToUnicode(buffer,&converted);
if(sendlen == 0){
self->lastError = BADCONVERSION;
return 0;
}
status = send(self->controller->pSock->sockid,converted,sendlen,0);
free(converted);
if(status < 0){
self->lastError = BADWRITE;
return 0;
}
return 1;
}
/*----------------------------------------------------------------*/
static int statusComplete(char *statusMessage){
char *pPtr = NULL;
/*
currently the status message has no terminator. I try to find
the last component of the message which happens to be TIME and
the last # after that
*/
pPtr = strstr(statusMessage,"TIME");
if(pPtr != NULL){
pPtr = strstr(pPtr+6,"#");
if(pPtr != NULL){
return 1;
} else {
return 0;
}
} else {
return 0;
}
}
/*---------------------------------------------------------------*/
static int readChopperNum(char *entry){
int num;
char *pPtr = NULL;
pPtr = strstr(entry,"CH");
if(pPtr == NULL){
return -1;
}
sscanf(pPtr+3,"%d",&num);
return num;
}
/*---------------------------------------------------------------*/
static void addEntry(pTcpDoCho self, int choNum, char *entry){
char name[80], value[80], *pPtr = NULL;
char num[5];
memset(name,0,80);
memset(value,0,80);
snprintf(num,5,"_%1.1d",choNum);
pPtr = strstr(entry,"=");
if(pPtr != NULL){
strncpy(name,entry,pPtr -entry);
strncat(trim(name),num,80-strlen(trim(name)));
strcpy(value,pPtr+1);
if(StringDictExists(self->parameters,name)){
StringDictUpdate(self->parameters,name,trim(value));
} else {
StringDictAddPair(self->parameters,name,trim(value));
}
}
}
/*----------------------------------------------------------------*/
static int parseStatus(pTcpDoCho self, char *statusMessage){
int choNum;
char entry[80], *pPtr;
pPtr = statusMessage;
/* skip over SOS */
pPtr = stptok(pPtr,entry,79,"#");
pPtr = stptok(pPtr,entry,79,"#");
pPtr = stptok(pPtr,entry,79,"#");
choNum = readChopperNum(entry);
if(choNum < 0){
self->lastError = BADRESPONSE;
return 0;
}
while((pPtr = stptok(pPtr,entry,79,"#")) != NULL){
addEntry(self,choNum,entry);
memset(entry,0,80);
}
return 1;
}
/*-----------------------------------------------------------------*/
static int tcpDoChoReceive(pTcpDoCho self){
char buffer[1024];
int len, bytesRead, bytesConverted, bufferStart, status;
char *converted = NULL;
time_t endTime;
endTime = time(NULL) + self->timeout;
bufferStart = 0;
bytesRead = 0;
memset(buffer,0,1024*sizeof(char));
while(time(NULL) < endTime){
if(availableRS232(self->controller)){
bytesRead += recv(self->controller->pSock->sockid,buffer+bufferStart,
1024 - bytesRead,0);
if(bytesRead < 0){
self->lastError = BADREAD;
return 0;
}
bytesConverted = unicodeToAscii(buffer,bytesRead,&converted);
if(bytesConverted == 0){
self->lastError = BADCONVERSION;
return 0;
}
if(strstr(converted,"State") != NULL){
if(statusComplete(converted) == 0) {
continue;
} else {
status = parseStatus(self,converted);
free(converted);
return status;
}
}
if(strstr(converted,"ACCEPT") != NULL){
free(converted);
return 1;
} else if(strstr(converted,"NCCEPT") != NULL){
free(converted);
self->lastError = FAILEDCOMMAND;
return 0;
} else {
self->lastError = BADRESPONSE;
return 0;
}
} else {
SicsWait(1);
}
}
self->lastError = TIMEOUT;
return 0;
}
/*-----------------------------------------------------------------*/
static int tcpDoChoCommand(pTcpDoCho self, char *command, int choNum,
char *value){
int status;
status = tcpDoChoSend(self,command,choNum,value);
if(status == 0){
return 0;
}
return tcpDoChoReceive(self);
}
/*---------------------------------------------------------------*/
static int TcpDoChoConnect(pTcpDoCho self){
int status, sendLen, readLen;
char *converted = NULL;
char buffer[256];
status = initRS232(self->controller);
if(status != 1){
self->lastError = status;
return 0;
}
setRS232Timeout(self->controller,5);
readLen = 255;
readRS232(self->controller,(void *)buffer,&readLen);
unicodeToAscii(buffer,readLen,&converted);
free(converted);
/*
user name
*/
snprintf(buffer,255,"user:%s\r\n",self->user);
sendLen = asciiToUnicode(buffer,&converted);
if(sendLen == 0){
self->lastError = BADCONVERSION;
return 0;
}
status = send(self->controller->pSock->sockid,converted,sendLen,0);
free(converted);
if(status < 0){
self->lastError = BADSEND;
return 0;
}
readLen = 255;
readRS232(self->controller,(void *)buffer,&readLen);
unicodeToAscii(buffer,readLen,&converted);
free(converted);
/*
password
*/
snprintf(buffer,255,"password:%s\r\n",self->pword);
sendLen = asciiToUnicode(buffer,&converted);
if(sendLen == 0){
self->lastError = BADCONVERSION;
return 0;
}
status = send(self->controller->pSock->sockid,converted,sendLen,0);
free(converted);
if(status < 0){
self->lastError = BADSEND;
return 0;
}
readLen = 255;
readRS232(self->controller,(void *)buffer,&readLen);
unicodeToAscii(buffer,readLen,&converted);
free(converted);
/*
TODO: responses should be checked to test for a valid login.
I do not know at this time how the controller reacts upon a
bad login.
*/
return 1;
}
/*==================== actual driver implementation code ==================*/
static int TcpChopperTask(void *pData){
pCodri self = NULL;
pTcpDoCho pPriv = NULL;
int status, code, i;
char buffer[80];
char error[512];
self = (pCodri)pData;
assert(self);
pPriv = (pTcpDoCho)self->pPrivate;
assert(pPriv);
if(pPriv->stop == 1){
return 0;
}
if(time(NULL) > pPriv->nextRefresh){
if(pPriv->lastError != 0){
self->GetError(self,&code,buffer,79);
snprintf(error,511,"WARNING: chopper tries to fix: %s",buffer);
WriteToCommandLog("Chopper-task:>>", error);
status = self->TryFixIt(self,code);
if(status == CHFAIL){
pPriv->nextRefresh = time(NULL) + pPriv->iRefreshIntervall;
return 1;
}
} else {
pPriv->busy = 1;
for(i = 0; i < pPriv->numChoppers; i++){
status = tcpDoChoCommand(pPriv,"STATE ", i+1,NULL);
if(status != 1){
/*
force error correction
*/
return 1;
}
}
pPriv->nextRefresh = time(NULL) + pPriv->iRefreshIntervall;
pPriv->busy = 0;
}
}
return 1;
}
/*------------------------------------------------------------------------------*/
static int TcpDoChoKill(pCodri self){
pTcpDoCho pPriv = NULL;
pPriv = (pTcpDoCho)self->pPrivate;
if(!pPriv)
return 1;
if(pPriv->controller != NULL){
KillRS232(pPriv->controller);
}
if(pPriv->parameters != NULL){
DeleteStringDict(pPriv->parameters);
}
if(pPriv->config != NULL){
free(pPriv->config);
}
free(pPriv);
return 1;
}
/*-------------------------------------------------------------------*/
static int TcpDoChoConfigure(pCodri pDriv){
pTcpDoCho self = NULL;
int status;
char *pPtr = NULL;
char command[80];
assert(pDriv != NULL);
self = (pTcpDoCho)pDriv->pPrivate;
assert(self != NULL);
if(self->config != NULL){
pPtr = self->config;
while( (pPtr = stptok(pPtr,command,79,"\n")) != NULL){
status = tcpDoChoCommand(self,command,-1,NULL);
if(status != 1){
return 0;
}
}
}
return 1;
}
/*---------------------------------------------------------------------*/
static int TcpDoChoInit(pCodri pDriv){
pTcpDoCho self = NULL;
int status;
assert(pDriv != NULL);
self = (pTcpDoCho)pDriv->pPrivate;
assert(self != NULL);
self->lastError = 0;
self->stop = 0;
self->nextRefresh = 0;
status = TcpDoChoConnect(self);
if(status != 1){
return 0;
}
status = TcpDoChoConfigure(pDriv);
if(status != 1){
return 0;
}
/* start the update task */
if(self->lTask == 0){
self->lTask = TaskRegister(pServ->pTasker,
TcpChopperTask,
NULL,
NULL,
pDriv,
1);
}
return 1;
}
/*-------------------------------------------------------------------*/
static void waitForBusy(pTcpDoCho self){
time_t endTime;
endTime = time(NULL) + 10 *60; /* max 10 min */
while(time(NULL) < endTime){
if(self->busy == 1){
SicsWait(3);
} else {
return;
}
}
WriteToCommandLog("Chopper-task>> ","WARNING: timeout on busy flag, flag forced");
self->busy = 0;
}
/*----------------------------------------------------------------------*/
static int TcpDoChoClose(pCodri pDriv){
pTcpDoCho self = NULL;
int status;
assert(pDriv != NULL);
self = (pTcpDoCho)pDriv->pPrivate;
assert(self != NULL);
self->stop = 1;
if(self->controller != NULL){
KillRS232(self->controller);
self->controller = NULL;
}
return 1;
}
/*----------------------------------------------------------------------*/
static int dissectName(char *name, char par[80], int *num){
char *pPtr = NULL;
pPtr = strrchr(name,(int)'_');
if(pPtr == NULL){
return 0;
}
memset(par,0,80*sizeof(char));
strncpy(par,name,pPtr - name);
if(sscanf(pPtr+1,"%d",num) != 1){
return 0;
}
return 1;
}
/*----------------------------------------------------------------------*/
static int TcpDoChoSetPar2(pCodri pDriv, char *parname, char *value){
pTcpDoCho self = NULL;
int status, choNum;
char par[80], buffer[80], state[80];
assert(pDriv != NULL);
self = (pTcpDoCho)pDriv->pPrivate;
assert(self != NULL);
/*
force status requests right after setting something in order
to make the stored status represent the new target values
*/
if(dissectName(parname,par,&choNum)){
/*
check for emergency stop
*/
snprintf(buffer,79,"State_%1.1d",choNum);
memset(state,0,80*sizeof(char));
StringDictGet(self->parameters,buffer,state,79);
if(strstr(state,"E-Stop") != NULL){
self->lastError = ESTOP;
return 0;
}
if(strcmp(par,"speed") == 0){
waitForBusy(self);
status = tcpDoChoCommand(self,"SPEED ",choNum,trim(value));
tcpDoChoCommand(self,"STATE ",choNum,NULL);
if(status != 1){
return 0;
} else {
return 1;
}
} else if(strcmp(par,"phase") == 0){
waitForBusy(self);
status = tcpDoChoCommand(self,"PHASE ",choNum,trim(value));
tcpDoChoCommand(self,"STATE ",choNum,NULL);
if(status != 1){
return 0;
} else {
return 1;
}
}
}
self->lastError = UNDRIVABLE;
return 0;
}
/*-----------------------------------------------------------------------*/
static int TcpDoChoHalt(pCodri pDriv){
pTcpDoCho self = NULL;
int status;
assert(pDriv != NULL);
self = (pTcpDoCho)pDriv->pPrivate;
assert(self != NULL);
waitForBusy(self);
tcpDoChoCommand(self,"ESTOP :",-1,NULL);
return 1;
}
/*-----------------------------------------------------------------------*/
static int TcpDoChoSetPar(pCodri pDriv, char *parname, float fValue){
pTcpDoCho self = NULL;
int status, choNum;
char value[80];
char par[80];
assert(pDriv != NULL);
self = (pTcpDoCho)pDriv->pPrivate;
assert(self != NULL);
if(dissectName(parname,par,&choNum)){
if(strcmp(par,"speed") == 0){
snprintf(value,79,"%5.1f", fValue);
return TcpDoChoSetPar2(pDriv,parname,value);
} else if(strcmp(par,"phase") == 0){
snprintf(value,79,"%6.2f",fValue);
return TcpDoChoSetPar2(pDriv,parname,value);
}
}
if(strcmp(parname,"updateintervall") == 0){
sprintf(value,"%d",(int)fValue);
StringDictUpdate(self->parameters,"updateintervall",value);
self->iRefreshIntervall = (int)fValue;
return 1;
} else {
snprintf(value,79,"%f",fValue);
return TcpDoChoSetPar2(pDriv,parname,value);
}
}
/*---------------------------------------------------------------------*/
static int TcpDoChoGetPar(pCodri pDriv, char *parname,
char *pBuffer, int iBuflen){
pTcpDoCho self = NULL;
int status = 0, choNum;
char par[80], buffer[80];
float val;
assert(pDriv != NULL);
self = (pTcpDoCho)pDriv->pPrivate;
assert(self != NULL);
memset(par,0,80);
dissectName(parname,par,&choNum);
if(strcmp(par,"speed") == 0){
snprintf(buffer,80,"ASPEED_%1.1d", choNum);
status = StringDictGet(self->parameters,buffer,pBuffer,iBuflen);
} else if(strcmp(par,"phase") == 0){
snprintf(buffer,80,"APHASE_%1.1d", choNum);
status = StringDictGet(self->parameters,buffer,pBuffer,iBuflen);
} else {
status = StringDictGet(self->parameters,parname,pBuffer,iBuflen);
}
return status;
}
/*----------------------------------------------------------------------*/
static int TcpDoChoCheckPar(pCodri pDriv, char *parname){
pTcpDoCho self = NULL;
int status = 0, choNum;
float val, soll, delta;
char value[80], csoll[80], par[80], buffer[80], state[80];
assert(pDriv != NULL);
self = (pTcpDoCho)pDriv->pPrivate;
assert(self != NULL);
/*
check for flags first
*/
if(self->busy){
return HWBusy;
}
if(self->lastError != 0) {
return HWFault;
}
/*
updateintervall is always Idle
*/
if(strcmp(parname,"updateintervall") == 0){
return HWIdle;
}
/*
check for emergency stop
*/
snprintf(buffer,79,"State_%1.1d",choNum);
memset(state,0,80*sizeof(char));
StringDictGet(self->parameters,buffer,state,79);
if(strstr(state,"E-Stop") != NULL){
self->lastError = HWFault;
return 0;
}
memset(par,0,80);
dissectName(parname,par,&choNum);
if(strcmp(par,"speed") == 0){
snprintf(buffer,79,"RSPEED_%1.1d", choNum);
StringDictGet(self->parameters,buffer,csoll,79);
sscanf(csoll,"%f",&soll);
snprintf(buffer,79,"ASPEED_%1.1d", choNum);
StringDictGet(self->parameters,buffer,value,79);
sscanf(value,"%f",&val);
delta = ABS(soll - val);
if(delta > SPEEDTOL){
return HWBusy;
} else {
return HWIdle;
}
} else if(strcmp(par,"phase") == 0){
snprintf(buffer,79,"RPHASE_%1.1d", choNum);
StringDictGet(self->parameters,buffer,csoll,79);
sscanf(value,"%f",&soll);
snprintf(buffer,79,"APHASE_%1.1d", choNum);
StringDictGet(self->parameters,buffer,value,79);
sscanf(value,"%f",&val);
delta = ABS(soll - val);
if(delta > PHASETOL){
return HWBusy;
} else {
return HWIdle;
}
}
self->lastError = BADPAR;
return HWFault;
}
/*---------------------------------------------------------------------------*/
static int TcpDoChoError(pCodri pDriv, int *iCode, char *pError, int iLen){
pTcpDoCho self = NULL;
int status = 0;
float val, soll, delta;
char value[80];
assert(pDriv != NULL);
self = (pTcpDoCho)pDriv->pPrivate;
assert(self != NULL);
*iCode = self->lastError;
switch(self->lastError){
case WRONGMODE:
strncpy(pError,"Chopper in wrong mode",iLen);
break;
case BADCONVERSION:
strncpy(pError,"Bad ASCII to unicode conversion",iLen);
break;
case FAILEDCOMMAND:
strncpy(pError,"Command not accepted",iLen);
break;
case BADWRITE:
strncpy(pError,"Failed to write to chopper controller",iLen);
break;
case BADRESPONSE:
strncpy(pError,"Chopper controller send invalid command",iLen);
break;
case UNDRIVABLE:
strncpy(pError,"Parameter cannot be changed",iLen);
break;
case BADPAR:
strncpy(pError,"No such parameter",iLen);
break;
case ESTOP:
strncpy(pError,"Emergency stop is engaged",iLen);
break;
default:
getRS232Error(self->lastError,pError,iLen);
break;
}
return 1;
}
/*---------------------------------------------------------------------*/
static int TcpDoChoFix(pCodri pDriv, int iCode){
pTcpDoCho self = NULL;
int status = 0;
float val, soll, delta;
char value[80];
assert(pDriv != NULL);
self = (pTcpDoCho)pDriv->pPrivate;
assert(self != NULL);
self->lastError = 0;
switch(iCode){
case BADCONVERSION:
case BADRESPONSE:
return CHREDO;
break;
case WRONGMODE:
case FAILEDCOMMAND:
case UNDRIVABLE:
case BADPAR:
case ESTOP:
return CHFAIL;
break;
default:
closeRS232(self->controller);
status = TcpDoChoConnect(self);
if(status == 1){
return CHREDO;
} else {
return CHFAIL;
}
break;
}
return CHFAIL;
}
/*-------------------------------------------------------------------*/
pCodri MakeTcpDoChoDriver(char *tclArray, SConnection *pCon){
pCodri pNew = NULL;
pTcpDoCho self = NULL;
const char *pPtr = NULL;
char buffer[132];
int port, i, count;
Tcl_DString pars;
char *parnames[] = {"State",
"ASPEED",
"RSPEED",
"APHASE",
"RPHASE",
"AVETO",
"DIR",
"MONIT",
"FLOWR",
"WTEMP",
"MTEMP",
"MVIBR",
"MVACU",
"speed",
"phase",
NULL,
};
/*
allocate memory
*/
pNew = (pCodri)malloc(sizeof(Codri));
self = (pTcpDoCho)malloc(sizeof(TcpDoCho));
if(!pNew || !self){
return NULL;
}
memset(pNew,0,sizeof(Codri));
memset(self,0,sizeof(TcpDoCho));
/* port and host name */
pPtr = Tcl_GetVar2(pServ->pSics->pTcl,tclArray,"port",TCL_GLOBAL_ONLY);
if(!pPtr){
SCWrite(pCon,"ERROR: port not found in configuration array for TCP Dornier Chopper",
eError);
free(pNew);
free(self);
return NULL;
}
sscanf(pPtr,"%d",&port);
pPtr = Tcl_GetVar2(pServ->pSics->pTcl,tclArray,"host",TCL_GLOBAL_ONLY);
if(!pPtr){
SCWrite(pCon,"ERROR: host not found in configuration array for TCP Dornier Chopper",
eError);
free(pNew);
free(self);
return NULL;
}
memset(buffer,0,132);
strncpy(buffer,pPtr, 131);
self->controller = createRS232(buffer,port);
/* number of choppers */
pPtr = Tcl_GetVar2(pServ->pSics->pTcl,tclArray,"nchopper",TCL_GLOBAL_ONLY);
if(!pPtr){
SCWrite(pCon,"ERROR: nchopper not found in configuration array for TCP Dornier Chopper",
eError);
free(pNew);
free(self);
return NULL;
}
sscanf(pPtr,"%d",&port);
if(port < 0 || port > 8){
SCWrite(pCon,"ERROR: number of choppers not in range 1 - 8",eError);
free(pNew);
free(self);
}
self->numChoppers = port;
/* timeout */
pPtr = Tcl_GetVar2(pServ->pSics->pTcl,tclArray,"timeout",TCL_GLOBAL_ONLY);
if(!pPtr){
SCWrite(pCon,"ERROR: timeout not found in configuration array for TCP Dornier Chopper",
eError);
free(pNew);
free(self);
return NULL;
}
sscanf(pPtr,"%d",&port);
self->timeout = port;
/* username and password */
pPtr = Tcl_GetVar2(pServ->pSics->pTcl,tclArray,"user",TCL_GLOBAL_ONLY);
if(!pPtr){
SCWrite(pCon,"ERROR: user not found in configuration array for TCP Dornier Chopper",
eError);
free(pNew);
free(self);
return NULL;
}
strncpy(self->user,pPtr, 131);
pPtr = Tcl_GetVar2(pServ->pSics->pTcl,tclArray,"password",TCL_GLOBAL_ONLY);
if(!pPtr){
SCWrite(pCon,"ERROR: password not found in configuration array for TCP Dornier Chopper",
eError);
free(pNew);
free(self);
return NULL;
}
strncpy(self->pword,pPtr, 131);
/*
chopper configuration
*/
pPtr = Tcl_GetVar2(pServ->pSics->pTcl,tclArray,"config",TCL_GLOBAL_ONLY);
if(pPtr != NULL){
self->config = strdup(pPtr);
}
/* initialize some more */
self->parameters = CreateStringDict();
if(self->parameters == NULL || self->controller == NULL){
SCWrite(pCon,"ERROR: out of memory in MakeTcpDoCho",eError);
free(pNew);
free(self);
return NULL;
}
self->iRefreshIntervall = 60;
pNew->Init = TcpDoChoInit;
pNew->Close = TcpDoChoClose;
pNew->Delete = TcpDoChoKill;
pNew->SetPar = TcpDoChoSetPar;
pNew->SetPar2 = TcpDoChoSetPar2;
pNew->GetPar = TcpDoChoGetPar;
pNew->CheckPar = TcpDoChoCheckPar;
pNew->GetError = TcpDoChoError;
pNew->TryFixIt = TcpDoChoFix;
pNew->Halt = TcpDoChoHalt;
StringDictAddPair(self->parameters,"updateintervall","60");
pNew->pPrivate = self;
/*
create parameter list
*/
Tcl_DStringInit(&pars);
count = 0;
Tcl_DStringAppend(&pars,"updateintervall",15);
while(parnames[count] != NULL){
for(i = 0; i < self->numChoppers; i++){
snprintf(buffer,131,",%s_%1.1d", parnames[count], i + 1);
Tcl_DStringAppend(&pars,buffer,strlen(buffer));
}
count++;
}
pNew->pParList = strdup(Tcl_DStringValue(&pars));
Tcl_DStringFree(&pars);
return pNew;
}

1146
tcpdornier.c Normal file
View File

File diff suppressed because it is too large Load Diff

10
tricssupport.c
View File

@ -55,7 +55,8 @@ static void KillTricsSupport(void *pData){
} }
} }
/*=====================================================================*/ /*=====================================================================*/
static int FrameSupInterest(int iEvent, void *pEvent, void *pUser){ static int FrameSupInterest(int iEvent, void *pEvent, void *pUser,
commandContext cc){
SConnection *pCon = NULL; SConnection *pCon = NULL;
int *iFrame; int *iFrame;
char pBueffel[512]; char pBueffel[512];
@ -68,7 +69,9 @@ static int FrameSupInterest(int iEvent, void *pEvent, void *pUser){
iFrame = (int *)pEvent; iFrame = (int *)pEvent;
assert(pCon); assert(pCon);
sprintf(pBueffel,"framenumber = %d",*iFrame); sprintf(pBueffel,"framenumber = %d",*iFrame);
SCPushContext2(pCon,cc);
SCWrite(pCon,pBueffel,eWarning); SCWrite(pCon,pBueffel,eWarning);
SCPopContext(pCon);
return 1; return 1;
} }
/*====================================================================== /*======================================================================
@ -182,8 +185,9 @@ int TricsSupportAction(SConnection *pCon, SicsInterp *pSics, void *pData,
return 1; return 1;
} }
else if(strcmp(argv[1],"interest") == 0){ else if(strcmp(argv[1],"interest") == 0){
lID = RegisterCallback(self->pCall, NEWFRAME, FrameSupInterest, lID = RegisterCallback(self->pCall, SCGetContext(pCon),
pCon, NULL); NEWFRAME, FrameSupInterest,
pCon, NULL);
SCRegister(pCon,pSics, self->pCall,lID); SCRegister(pCon,pSics, self->pCall,lID);
SCSendOK(pCon); SCSendOK(pCon);
return 1; return 1;

8
velodornier.c
View File

@ -69,7 +69,7 @@ typedef struct __VelSelDriv *pVelSelDriv;
#define VSACCEL -7 #define VSACCEL -7
#define VSFAIL -2 #define VSFAIL -2
typedef enum {eStart, eRegel, eHalted} eVeloMode; typedef enum {vStart, eRegel, eHalted} eVeloMode;
#define RPMALIFE 3090 #define RPMALIFE 3090
/*----------------------------- The private data structure ---------------*/ /*----------------------------- The private data structure ---------------*/
@ -165,7 +165,7 @@ typedef enum {eStart, eRegel, eHalted} eVeloMode;
case eHalted: case eHalted:
strcpy(pCommand,"SST"); strcpy(pCommand,"SST");
pDorn->fTarget = fVal; pDorn->fTarget = fVal;
pDorn->eVelo = eStart; pDorn->eVelo = vStart;
pDorn->t_End = time(NULL) + 1800; /* start time + 30 min */ pDorn->t_End = time(NULL) + 1800; /* start time + 30 min */
break; break;
case eRegel: case eRegel:
@ -323,7 +323,7 @@ typedef enum {eStart, eRegel, eHalted} eVeloMode;
/* some serious logic because of multi - modes */ /* some serious logic because of multi - modes */
switch(pDorn->eVelo) switch(pDorn->eVelo)
{ {
case eStart: case vStart:
*iCode = ROTSTART; *iCode = ROTSTART;
*fCur = 0.; *fCur = 0.;
if(sStatus.cur_rpm >= RPMALIFE) if(sStatus.cur_rpm >= RPMALIFE)
@ -577,7 +577,7 @@ typedef enum {eStart, eRegel, eHalted} eVeloMode;
{ {
pVelSelDriv pNew = NULL; pVelSelDriv pNew = NULL;
pDornier pDorn = NULL; pDornier pDorn = NULL;
char *pPtr = NULL; const char *pPtr = NULL;
int iVal, iRet; int iVal, iRet;
/* the most likely error is the parameters specified are wrong! /* the most likely error is the parameters specified are wrong!