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

Treat Tcl procs prefixed with imot_, hdb_ and get_ specially.

Browse Source 
hdb_, Parameter will be added to hdb tree.
imot_, Motor interface function, eg run, status.
get_, Tcl code will be evaluated when "mot list" is called.
Add debug info.
This commit is contained in:
Ferdi Franceschini
2013-04-20 18:28:28 +10:00
parent b98ff24528
commit a5c097cedc
4 changed files with 498 additions and 408 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
site_ansto/Makefile
View File

@ -153,6 +153,7 @@ GHTTP_LIBS = $(LIB_HTTP)
OBJ= site_ansto.o anstoutil.o\ OBJ= site_ansto.o anstoutil.o\
ansto_sctdriveadapter.o\ ansto_sctdriveadapter.o\
ansto_tclmotdriv.o\
sctemonadapter.o\ sctemonadapter.o\
motor_asim.o motor_dmc2280.o\ motor_asim.o motor_dmc2280.o\
lh45.o lh45driv.o \ lh45.o lh45driv.o \

868
site_ansto/ansto_tclmotdriv.c
View File

@ -19,9 +19,18 @@
facilitate error handling, a motor parameter errorcode is available to facilitate error handling, a motor parameter errorcode is available to
store errors between invocations. store errors between invocations.
Author: Jing Chen, Nov 2012
copyright: see file COPYRIGHT copyright: see file COPYRIGHT
Author: Mark Koennecke, December 2005
ANSTO MODIFICATIONS:
Jing Chen, Nov 2012:
Support extra parameters as calls to Tcl code.
Ferdi Franceschini April 2013:
Use prefixes imot_, hdb_, and get_ to tell driver how to handle different
types of functions. Added debug info support.
--------------------------------------------------------------------------*/ --------------------------------------------------------------------------*/
#include <stdlib.h> #include <stdlib.h>
@ -32,7 +41,7 @@
#include "modriv.h" #include "modriv.h"
#include "lld.h" #include "lld.h"
#include "stringdict.h" #include "stringdict.h"
#include "tclmotdriv.h" #include "ansto_tclmotdriv.h"
#define FUNCNOTFOUND -11000 #define FUNCNOTFOUND -11000
#define TCLERROR -11001 #define TCLERROR -11001
@ -44,275 +53,310 @@
#define LONG_NAME "long_name" #define LONG_NAME "long_name"
#define ERRORCODE "errorcode" #define ERRORCODE "errorcode"
void logTclCall(TCLDriv *pDriv, char *fn, char *script) {
char msg[512];
/*----------------------------------------------------------------------------*/ snprintf(msg, 511, "tclmot %s.%s -> %s\n", pDriv->motName, fn, script);
static int buildStandardCommandPart(TCLDriv *pDriv, char *command, SICSLogWrite(msg, eLog);
char *tclCommand, int commandLen){
char tclFunc[132];
int status;
status = StringDictGet(pDriv->mappings,command,tclFunc,131);
if(status != 1) {
return 0;
}
//snprintf(tclCommand,commandLen,"%s %s ", tclFunc, pDriv->motName);
snprintf(tclCommand,commandLen,"%s", tclFunc);
return 1;
} }
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
static int GetTclPos(void *self, float *fPos){ static int buildStandardCommandPart(TCLDriv * pDriv, char *command,
TCLDriv *pDriv; char *tclCommand, int commandLen)
int status; {
const char *result = NULL; char tclFunc[132];
int status;
assert(self); status = StringDictGet(pDriv->mappings, command, tclFunc, 131);
pDriv = (TCLDriv *)self; if (status != 1) {
char *tclCommand = (char *)calloc(1024, sizeof(char));
pDriv->errorCode = 0;
if(!buildStandardCommandPart(pDriv,"getpos",tclCommand,1023)){
pDriv->errorCode = FUNCNOTFOUND;
free(tclCommand);
return HWFault;
}
status = Tcl_Eval(pServ->pSics->pTcl,tclCommand);
result = Tcl_GetStringResult(pServ->pSics->pTcl);
free(tclCommand);
if(result == NULL){
pDriv->errorCode = NOTCLRESULT;
return HWFault;
}
if(status != TCL_OK){
pDriv->errorCode = TCLERROR;
strncpy(pDriv->tclError,result,1023);
return HWFault;
}
sscanf(result,"%f",fPos);
return OKOK;
}
/*----------------------------------------------------------------------------*/
static int TclRun(void *self, float fVal) {
TCLDriv *pDriv;
char num[80];
int status;
const char *result = NULL;
assert(self);
pDriv = (TCLDriv *)self;
char *tclCommand = (char *)calloc(1024, sizeof(char));
pDriv->errorCode = 0;
if(!buildStandardCommandPart(pDriv,"run",tclCommand,1023)){
pDriv->errorCode = FUNCNOTFOUND;
free(tclCommand);
return HWFault;
}
snprintf(num,79,"%f",fVal);
strncat(tclCommand,num,1023-strlen(tclCommand));
status = Tcl_Eval(pServ->pSics->pTcl,tclCommand);
result = Tcl_GetStringResult(pServ->pSics->pTcl);
free(tclCommand);
if(result == NULL) {
pDriv->errorCode = NOTCLRESULT;
return HWFault;
}
if(status != TCL_OK){
pDriv->errorCode = TCLERROR;
strncpy(pDriv->tclError,result,1023);
return HWFault;
}
sscanf(result,"%d",&status);
return status;
}
/*-------------------------------------------------------------------------*/
static int evaluateInternalErrors(TCLDriv *pDriv, int *iCode,
char *error, int iErrLen){
switch(pDriv->errorCode){
case FUNCNOTFOUND:
strncpy(error,"Config Error: Tcl function for driver not found",iErrLen);
*iCode = pDriv->errorCode;
return 1;
break;
case TCLERROR:
strncpy(error,pDriv->tclError,iErrLen);
*iCode = pDriv->errorCode;
return 1;
break;
case NOTCLRESULT:
strncpy(error,"Tcl function did not return result",iErrLen);
*iCode = pDriv->errorCode;
return 1;
break;
default:
return 0;
break;
}
return 0; return 0;
}
/*--------------------------------------------------------------------------*/
static void TclGetError(void *self, int *iCode, char *error, int iErrLen){
TCLDriv *pDriv;
int status = 1;
const char *result = NULL;
assert(self);
pDriv = (TCLDriv *)self;
if(evaluateInternalErrors(pDriv,iCode,error,iErrLen) == 1) {
return;
}
char *tclCommand = (char *)calloc(1024, sizeof(char));
if(!buildStandardCommandPart(pDriv,"geterror",tclCommand,1023)){
pDriv->errorCode = FUNCNOTFOUND;
status = 0;
}
if(status != 0){
status = Tcl_Eval(pServ->pSics->pTcl,tclCommand);
result = Tcl_GetStringResult(pServ->pSics->pTcl);
if(result == NULL) {
pDriv->errorCode = NOTCLRESULT;
}
if(status != TCL_OK && result != NULL){
pDriv->errorCode = TCLERROR;
strncpy(pDriv->tclError,result,1023);
}
}
if(evaluateInternalErrors(pDriv,iCode,error,iErrLen) == 1) {
free(tclCommand);
return;
}
free(tclCommand);
strncpy(error,result,iErrLen);
} }
snprintf(tclCommand,commandLen,"%s %s ", tclFunc, pDriv->motName);
//snprintf(tclCommand, commandLen, "%s", tclFunc);
return 1;
}
/*----------------------------------------------------------------------------*/
static int GetTclPos(void *self, float *fPos)
{
TCLDriv *pDriv;
int status;
const char *result = NULL;
assert(self);
pDriv = (TCLDriv *) self;
char *tclCommand = (char *) calloc(1024, sizeof(char));
pDriv->errorCode = 0;
if (!buildStandardCommandPart(pDriv, "getpos", tclCommand, 1023)) {
pDriv->errorCode = FUNCNOTFOUND;
free(tclCommand);
return HWFault;
}
if (pDriv->debug)
logTclCall(pDriv, "getpos", tclCommand);
status = Tcl_Eval(pServ->pSics->pTcl, tclCommand);
result = Tcl_GetStringResult(pServ->pSics->pTcl);
free(tclCommand);
if (result == NULL) {
pDriv->errorCode = NOTCLRESULT;
return HWFault;
}
if (status != TCL_OK) {
pDriv->errorCode = TCLERROR;
strncpy(pDriv->tclError, result, 1023);
return HWFault;
}
sscanf(result, "%f", fPos);
return OKOK;
}
/*----------------------------------------------------------------------------*/
static int TclRun(void *self, float fVal)
{
TCLDriv *pDriv;
char num[80];
int status;
const char *result = NULL;
assert(self);
pDriv = (TCLDriv *) self;
char *tclCommand = (char *) calloc(1024, sizeof(char));
pDriv->errorCode = 0;
if (!buildStandardCommandPart(pDriv, "run", tclCommand, 1023)) {
pDriv->errorCode = FUNCNOTFOUND;
free(tclCommand);
return HWFault;
}
snprintf(num, 79, "%f", fVal);
strncat(tclCommand, num, 1023 - strlen(tclCommand));
if (pDriv->debug)
logTclCall(pDriv, "run", tclCommand);
status = Tcl_Eval(pServ->pSics->pTcl, tclCommand);
result = Tcl_GetStringResult(pServ->pSics->pTcl);
free(tclCommand);
if (result == NULL) {
pDriv->errorCode = NOTCLRESULT;
return HWFault;
}
if (status != TCL_OK) {
pDriv->errorCode = TCLERROR;
strncpy(pDriv->tclError, result, 1023);
return HWFault;
}
sscanf(result, "%d", &status);
return status;
}
/*-------------------------------------------------------------------------*/
static int evaluateInternalErrors(TCLDriv * pDriv, int *iCode,
char *error, int iErrLen)
{
switch (pDriv->errorCode) {
case FUNCNOTFOUND:
strncpy(error, "Config Error: Tcl function for driver not found",
iErrLen);
*iCode = pDriv->errorCode;
return 1;
break;
case TCLERROR:
strncpy(error, pDriv->tclError, iErrLen);
*iCode = pDriv->errorCode;
return 1;
break;
case NOTCLRESULT:
strncpy(error, "Tcl function did not return result", iErrLen);
*iCode = pDriv->errorCode;
return 1;
break;
default:
return 0;
break;
}
return 0;
}
/*--------------------------------------------------------------------------*/
static void TclGetError(void *self, int *iCode, char *error, int iErrLen)
{
TCLDriv *pDriv;
int status = 1;
const char *result = NULL;
assert(self);
pDriv = (TCLDriv *) self;
if (evaluateInternalErrors(pDriv, iCode, error, iErrLen) == 1) {
return;
}
char *tclCommand = (char *) calloc(1024, sizeof(char));
if (!buildStandardCommandPart(pDriv, "geterror", tclCommand, 1023)) {
pDriv->errorCode = FUNCNOTFOUND;
status = 0;
}
if (status != 0) {
if (pDriv->debug)
logTclCall(pDriv, "geterror", tclCommand);
status = Tcl_Eval(pServ->pSics->pTcl, tclCommand);
result = Tcl_GetStringResult(pServ->pSics->pTcl);
if (result == NULL) {
pDriv->errorCode = NOTCLRESULT;
}
if (status != TCL_OK && result != NULL) {
pDriv->errorCode = TCLERROR;
strncpy(pDriv->tclError, result, 1023);
}
}
if (evaluateInternalErrors(pDriv, iCode, error, iErrLen) == 1) {
free(tclCommand);
return;
}
free(tclCommand);
strncpy(error, result, iErrLen);
}
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
static int TclTryAndFixIt(void *self, int iError, float fNew){ static int TclTryAndFixIt(void *self, int iError, float fNew)
TCLDriv *pDriv; {
char num[80]; TCLDriv *pDriv;
int status; char num[80];
const char *result = NULL; int status;
const char *result = NULL;
assert(self); assert(self);
pDriv = (TCLDriv *)self; pDriv = (TCLDriv *) self;
char *tclCommand = (char *)calloc(1024, sizeof(char)); char *tclCommand = (char *) calloc(1024, sizeof(char));
if(!buildStandardCommandPart(pDriv,"fixit",tclCommand,1023)){ if (!buildStandardCommandPart(pDriv, "fixit", tclCommand, 1023)) {
pDriv->errorCode = FUNCNOTFOUND; pDriv->errorCode = FUNCNOTFOUND;
free(tclCommand);
return HWFault;
}
snprintf(num,79,"%d %f",pDriv->errorCode, fNew);
strncat(tclCommand,num,1023-strlen(tclCommand));
status = Tcl_Eval(pServ->pSics->pTcl,tclCommand);
result = Tcl_GetStringResult(pServ->pSics->pTcl);
if(result == NULL) {
pDriv->errorCode = NOTCLRESULT;
free(tclCommand);
return HWFault;
}
if(status != TCL_OK){
pDriv->errorCode = TCLERROR;
strncpy(pDriv->tclError,result,1023);
free(tclCommand);
return HWFault;
}
sscanf(result,"%d",&status);
free(tclCommand); free(tclCommand);
return status; return HWFault;
} }
snprintf(num, 79, "%d %f", pDriv->errorCode, fNew);
strncat(tclCommand, num, 1023 - strlen(tclCommand));
if (pDriv->debug)
logTclCall(pDriv, "fixit", tclCommand);
status = Tcl_Eval(pServ->pSics->pTcl, tclCommand);
result = Tcl_GetStringResult(pServ->pSics->pTcl);
if (result == NULL) {
pDriv->errorCode = NOTCLRESULT;
free(tclCommand);
return HWFault;
}
if (status != TCL_OK) {
pDriv->errorCode = TCLERROR;
strncpy(pDriv->tclError, result, 1023);
free(tclCommand);
return HWFault;
}
sscanf(result, "%d", &status);
free(tclCommand);
return status;
}
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
static int TclHalt(void *self) static int TclHalt(void *self)
{ {
TCLDriv *pDriv; TCLDriv *pDriv;
int status; int status;
const char *result = NULL; const char *result = NULL;
assert(self); assert(self);
pDriv = (TCLDriv *)self; pDriv = (TCLDriv *) self;
pDriv->errorCode = 0; pDriv->errorCode = 0;
char *tclCommand = (char *)calloc(1024, sizeof(char)); char *tclCommand = (char *) calloc(1024, sizeof(char));
if(!buildStandardCommandPart(pDriv,"halt",tclCommand,1023)){ if (!buildStandardCommandPart(pDriv, "halt", tclCommand, 1023)) {
pDriv->errorCode = FUNCNOTFOUND; pDriv->errorCode = FUNCNOTFOUND;
free(tclCommand);
return HWFault;
}
status = Tcl_Eval(pServ->pSics->pTcl,tclCommand);
result = Tcl_GetStringResult(pServ->pSics->pTcl);
if(result == NULL){
pDriv->errorCode = NOTCLRESULT;
free(tclCommand);
return HWFault;
}
if(status != TCL_OK){
pDriv->errorCode = TCLERROR;
strncpy(pDriv->tclError,result,1023);
free(tclCommand);
return HWFault;
}
free(tclCommand); free(tclCommand);
return OKOK; return HWFault;
} }
if (pDriv->debug)
logTclCall(pDriv, "halt", tclCommand);
status = Tcl_Eval(pServ->pSics->pTcl, tclCommand);
result = Tcl_GetStringResult(pServ->pSics->pTcl);
if (result == NULL) {
pDriv->errorCode = NOTCLRESULT;
free(tclCommand);
return HWFault;
}
if (status != TCL_OK) {
pDriv->errorCode = TCLERROR;
strncpy(pDriv->tclError, result, 1023);
free(tclCommand);
return HWFault;
}
free(tclCommand);
return OKOK;
}
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
static int TclGetStatus(void *self) static int TclGetStatus(void *self)
{ {
TCLDriv *pDriv; TCLDriv *pDriv;
int status; int status;
const char *result = NULL; const char *result = NULL;
assert(self); assert(self);
pDriv = (TCLDriv *)self; pDriv = (TCLDriv *) self;
pDriv->errorCode = 0; pDriv->errorCode = 0;
char *tclCommand = (char *)calloc(1024, sizeof(char)); char *tclCommand = (char *) calloc(1024, sizeof(char));
if(!buildStandardCommandPart(pDriv,"status",tclCommand,1023)){ if (!buildStandardCommandPart(pDriv, "status", tclCommand, 1023)) {
pDriv->errorCode = FUNCNOTFOUND; pDriv->errorCode = FUNCNOTFOUND;
free(tclCommand);
return HWFault;
}
status = Tcl_Eval(pServ->pSics->pTcl,tclCommand);
result = Tcl_GetStringResult(pServ->pSics->pTcl);
if(result == NULL){
pDriv->errorCode = NOTCLRESULT;
free(tclCommand);
return HWFault;
}
if(status != TCL_OK){
pDriv->errorCode = TCLERROR;
strncpy(pDriv->tclError,result,1023);
free(tclCommand);
return HWFault;
}
sscanf(result,"%d",&status);
free(tclCommand); free(tclCommand);
return status; return HWFault;
} }
if (pDriv->debug)
logTclCall(pDriv, "status", tclCommand);
status = Tcl_Eval(pServ->pSics->pTcl, tclCommand);
result = Tcl_GetStringResult(pServ->pSics->pTcl);
if (result == NULL) {
pDriv->errorCode = NOTCLRESULT;
free(tclCommand);
return HWFault;
}
if (status != TCL_OK) {
pDriv->errorCode = TCLERROR;
strncpy(pDriv->tclError, result, 1023);
free(tclCommand);
return HWFault;
}
sscanf(result, "%d", &status);
free(tclCommand);
return status;
}
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
static int TclSetPar(void *self, SConnection *pCon, char *name, float newValue){ static int TclSetPar(void *self, SConnection * pCon, char *name,
float newValue)
int status; {
const char *result = NULL; /*TODO Skip functions in driveable interface ie "run" etc. */
int status;
char *result = NULL, pBuffer[512];
TCLDriv *pDriv = (TCLDriv *) self; TCLDriv *pDriv = (TCLDriv *) self;
@ -323,38 +367,48 @@ static int TclSetPar(void *self, SConnection *pCon, char *name, float newValue){
pDriv->fUpper = newValue; pDriv->fUpper = newValue;
return 1; return 1;
} else if (strcmp(name, HARDLOWERLIM) == 0) { } else if (strcmp(name, HARDLOWERLIM) == 0) {
pDriv->fLower = newValue; pDriv->fLower = newValue;
return 1;
} else if (strcmp(name, ERRORCODE) == 0) {
pDriv->errorCode = (int)newValue;
return 1;
} else if (strcmp(name, LONG_NAME) == 0) {
strncpy(pDriv->long_name, &newValue, 255);
return 1; return 1;
} else if (strcmp(name, ERRORCODE) == 0) {
pDriv->errorCode = (int) newValue;
return 1;
} else if (strcmp(name, "debug") == 0) {
pDriv->debug = (int) newValue;
return 1;
/* } else if (strcmp(name, LONG_NAME) == 0) {
strncpy(pDriv->long_name, &newValue, 255);
return 1;*/
} else { } else {
char *tclCommand = (char *)calloc(1024, sizeof(char)); char *tclCommand = (char *) calloc(1024, sizeof(char));
if (StringDictExists(pDriv->mappings, name)) { if (StringDictExists(pDriv->mappings, name)) {
if (!buildStandardCommandPart(pDriv, name, tclCommand, 1023)){ if (!buildStandardCommandPart(pDriv, name, tclCommand, 1023)) {
pDriv->errorCode = FUNCNOTFOUND; pDriv->errorCode = FUNCNOTFOUND;
free(tclCommand); free(tclCommand);
return HWFault; return HWFault;
} }
char *tclCommandPara = (char *)calloc(1024, sizeof(char)); char *tclCommandPara = (char *) calloc(1024, sizeof(char));
sprintf(tclCommandPara, "%s %f", tclCommand, newValue); sprintf(tclCommandPara, "%s %f", tclCommand, newValue);
status = Tcl_Eval(pServ->pSics->pTcl,tclCommandPara);
if (pDriv->debug)
logTclCall(pDriv, name, tclCommand);
status = Tcl_Eval(pServ->pSics->pTcl, tclCommandPara);
result = Tcl_GetStringResult(pServ->pSics->pTcl); result = Tcl_GetStringResult(pServ->pSics->pTcl);
if (result == NULL){ if (result == NULL) {
pDriv->errorCode = NOTCLRESULT; pDriv->errorCode = NOTCLRESULT;
free(tclCommand); free(tclCommand);
free(tclCommandPara);; free(tclCommandPara);;
return HWFault; return HWFault;
} }
if (status != TCL_OK){ if (status != TCL_OK) {
pDriv->errorCode = TCLERROR; pDriv->errorCode = TCLERROR;
strncpy(pDriv->tclError,result,1023); strncpy(pDriv->tclError, result, 1023);
free(tclCommand); free(tclCommand);
free(tclCommandPara);; free(tclCommandPara);;
return HWFault; return HWFault;
} else {
snprintf(pBuffer, 511, "%s.%s = %s", pDriv->motName, name, result);
SCWrite(pCon, pBuffer, eValue);
} }
free(tclCommand); free(tclCommand);
free(tclCommandPara);; free(tclCommandPara);;
@ -368,51 +422,11 @@ static int TclSetPar(void *self, SConnection *pCon, char *name, float newValue){
} }
} }
static int TclListPar(void *self, char *motorname, SConnection *pCon) {
SDE sVal;
int iRet;
char pBueffel[512];
char *funcText[] = {"getpos",
"run",
"status",
"halt",
"geterror",
"fixit",
NULL};
TCLDriv *pDriv = (TCLDriv *)self;
iRet = LLDnodePtr2First(pDriv->mappings->iList);
while(iRet != 0){
LLDnodeDataTo(pDriv->mappings->iList, &sVal);
int count=0, flag=0;
while(funcText[count]!=NULL && flag==0) {
if(strcmp(sVal.name,funcText[count]) == 0)
flag = 1;
count++;
}
if(flag==0) {
int ret;
float value;
ret = TclGetPar(self, sVal.name, &value);
if (ret != OKOK) {
return ret;
} else {
snprintf(pBueffel,511,"%s.%s = %f",motorname,sVal.name,value);
SCWrite(pCon,pBueffel,eValue);
}
}
iRet = LLDnodePtr2Next(pDriv->mappings->iList);
}
return OKOK;
}
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
int TclGetPar(void *self, char *name, float *value) { int TclGetPar(void *self, char *name, float *value)
{
int status; int status;
const char *result = NULL; const char *result = NULL;
TCLDriv *pDriv = (TCLDriv *) self; TCLDriv *pDriv = (TCLDriv *) self;
@ -420,36 +434,42 @@ int TclGetPar(void *self, char *name, float *value) {
assert(self); assert(self);
if (strcmp(name, ERRORCODE) == 0) { if (strcmp(name, ERRORCODE) == 0) {
*value = (float)pDriv->errorCode; *value = (float) pDriv->errorCode;
return OKOK; return OKOK;
} else if (strcmp(name, HARDUPPERLIM) == 0) { } else if (strcmp(name, HARDUPPERLIM) == 0) {
*value = (float)pDriv->fUpper; *value = (float) pDriv->fUpper;
return OKOK; return OKOK;
} else if (strcmp(name, HARDLOWERLIM) == 0) { } else if (strcmp(name, HARDLOWERLIM) == 0) {
*value = (float)pDriv->fLower; *value = (float) pDriv->fLower;
return OKOK;
} else if (strcmp(name, "debug") == 0) {
*value = (float) pDriv->debug;
return OKOK; return OKOK;
} else { } else {
char *tclCommand = (char *)calloc(1024, sizeof(char)); char *tclCommand = (char *) calloc(1024, sizeof(char));
if (StringDictExists(pDriv->mappings, name)) { if (StringDictExists(pDriv->mappings, name)) {
if(!buildStandardCommandPart(pDriv, name, tclCommand, 1023)){ if (!buildStandardCommandPart(pDriv, name, tclCommand, 1023)) {
pDriv->errorCode = FUNCNOTFOUND; pDriv->errorCode = FUNCNOTFOUND;
free(tclCommand); free(tclCommand);
return HWFault; return HWFault;
} }
status = Tcl_Eval(pServ->pSics->pTcl,tclCommand); if (pDriv->debug)
logTclCall(pDriv, name, tclCommand);
status = Tcl_Eval(pServ->pSics->pTcl, tclCommand);
result = Tcl_GetStringResult(pServ->pSics->pTcl); result = Tcl_GetStringResult(pServ->pSics->pTcl);
if(result == NULL){ if (result == NULL) {
pDriv->errorCode = NOTCLRESULT; pDriv->errorCode = NOTCLRESULT;
free(tclCommand); free(tclCommand);
return HWFault; return HWFault;
} }
if(status != TCL_OK){ if (status != TCL_OK) {
pDriv->errorCode = TCLERROR; pDriv->errorCode = TCLERROR;
strncpy(pDriv->tclError,result,1023); strncpy(pDriv->tclError, result, 1023);
free(tclCommand); free(tclCommand);
return HWFault; return HWFault;
} }
sscanf(result,"%f", value); sscanf(result, "%f", value);
free(tclCommand); free(tclCommand);
return OKOK; return OKOK;
} else { } else {
@ -461,114 +481,140 @@ int TclGetPar(void *self, char *name, float *value) {
return OKOK; return OKOK;
} }
} }
/*---------------------------------------------------------------------------*/
void KillTCL(void *pData)
{
TCLDriv *pDriv = (TCLDriv *) pData;
if(pDriv != NULL){ /*
DeleteStringDict(pDriv->mappings); * Functions which include hdb_, imot_, and get_ are treated specially.
} * hdb_, Parameter will be added to hdb tree.
* imot_, Motor interface function, eg run, status.
* get_, Tcl code will be evaluated when "mot list" is called.
* WARNING: Parameters prefixed with hdb_ will be executed when any of the
* parameters in the hdb tree are updated, for instance if the
* softzero is changed.
*/
void TclListPar(void *self, char *motorname, SConnection * pCon)
{
char pBueffel[512];
char motParVal[256];
float value;
const char *motPar=NULL;
TCLDriv *pDriv = (TCLDriv *) self;
int pos = 0, imot;
return;
}
/*-------------------------------------------------------------------------*/
static int assignMappings(TCLDriv *pDriv, SConnection *pCon, char *arrayName){
if (*arrayName==NULL) { snprintf(pBueffel, 511, "%s.debug = %d", motorname, pDriv->debug);
return OKOK; SCWrite(pCon, pBueffel, eValue);
} else { while ( (motPar = StringDictGetNext(pDriv->mappings,motParVal,256)) != NULL ) {
unsigned char ps=0; imot = 0;
char *pch; pBueffel[0] = '\0';
char *funcName = (char *)calloc(1024, sizeof(char)); /* sicshipadaba sets motorname="test" when constructing hdb tree */
if (strcmp(motorname, "test.") == 0 && strstr(motParVal, "hdb_") == NULL)
continue;
pch = strtok(arrayName, "{}"); if (strstr(motParVal, "imot_"))
while (pch != NULL) { imot = 1;
int c=0; if (imot && !pDriv->debug)
while(pch[c]==' ' && c<strlen(pch)) c++; continue;
char *newStr = (char *)calloc(strlen(pch)-c+1, sizeof(char));
if(c==strlen(pch)) { pos = snprintf(pBueffel, 511, "%s.%s", motorname, motPar);
*newStr = NULL; if (pDriv->debug)
} else { pos += snprintf(&pBueffel[pos], 511, "->[%s]", motParVal);
int ind=0;
while(c<strlen(pch)) { if (strstr(motParVal, "get_")) {
newStr[ind] = pch[c]; TclGetPar(self, (char *)motPar, &value);
c++; snprintf(&pBueffel[pos], 511, " = %f", value);
ind++; } else if (imot)
} snprintf(&pBueffel[pos], 511, " (imot)");
} else
if (ps%2==0){ snprintf(&pBueffel[pos], 511, " (command)");
if (*newStr==NULL) {
free(newStr); if (pBueffel[0] != '\0')
free(funcName); SCWrite(pCon, pBueffel, eValue);
return OKOK;
} else {
strcpy(funcName, newStr);
ps++;
}
} else {
StringDictAddPair(pDriv->mappings,funcName, newStr);
ps = 0;
}
free(newStr);
pch = strtok (NULL, "{}");
}
free(funcName);
} }
}
/*---------------------------------------------------------------------------*/
void KillTCL(void *pData)
{
TCLDriv *pDriv = (TCLDriv *) pData;
if (pDriv != NULL) {
DeleteStringDict(pDriv->mappings);
}
return;
}
/*-------------------------------------------------------------------------*/
static int assignMappings(TCLDriv * pDriv, SConnection * pCon,
char *arrayName)
{
const char *funcName = NULL;
char *funcText[] = { "getpos",
"run",
"status",
"halt",
"geterror",
"fixit",
NULL
};
char error[256];
int count = 0;
char **argv;
int i, code, argc;
code = Tcl_SplitList(pServ->pSics->pTcl, arrayName, &argc, &argv);
for (i=0; i < argc; i += 2) {
StringDictAddPair(pDriv->mappings, argv[i], (char *) argv[i+1]);
}
Tcl_Free((char *) argv);
return 1; return 1;
} }
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
MotorDriver *CreateTclMotDriv(SConnection *pCon, int argc, char *argv[]) MotorDriver *CreateTclMotDriv(SConnection * pCon, int argc, char *argv[])
{ {
TCLDriv *pDriv = NULL; TCLDriv *pDriv = NULL;
assert(pCon); assert(pCon);
if(argc < 4) { if (argc < 4) {
SCWrite(pCon,"ERROR: not enough arguments to initilaize Tcl-driver",eError); SCWrite(pCon, "ERROR: not enough arguments to initilaize Tcl-driver",
return NULL; eError);
} return NULL;
pDriv = (TCLDriv *)malloc(sizeof(TCLDriv));
if(!pDriv){
SCWrite(pCon,"Error allocating memory in TclMotor",eError);
return NULL;
}
memset(pDriv,0,sizeof(TCLDriv));
pDriv->mappings = CreateStringDict();
if(pDriv->mappings == NULL){
SCWrite(pCon,"Error allocating memory in TclMotor",eError);
free(pDriv);
return NULL;
}
if(assignMappings(pDriv,pCon,argv[3]) != 1){
DeleteStringDict(pDriv->mappings);
free(pDriv);
return NULL;
}
pDriv->name = strdup("Tcl-Driver");
strncpy(pDriv->motName, argv[1], 131);
pDriv->GetPosition = GetTclPos;
pDriv->RunTo = TclRun;
pDriv->GetStatus = TclGetStatus;
pDriv->GetError = TclGetError;
pDriv->TryAndFixIt = TclTryAndFixIt;
pDriv->SetDriverPar = TclSetPar;
pDriv->GetDriverPar = TclGetPar;
pDriv->ListDriverPar = TclListPar;
pDriv->Halt = TclHalt;
pDriv->KillPrivate = KillTCL;
return (MotorDriver *)pDriv;
} }
pDriv = (TCLDriv *) malloc(sizeof(TCLDriv));
if (!pDriv) {
SCWrite(pCon, "Error allocating memory in TclMotor", eError);
return NULL;
}
memset(pDriv, 0, sizeof(TCLDriv));
pDriv->debug = 0;
pDriv->mappings = CreateStringDict();
if (pDriv->mappings == NULL) {
SCWrite(pCon, "Error allocating memory in TclMotor", eError);
free(pDriv);
return NULL;
}
if (assignMappings(pDriv, pCon, argv[3]) != 1) {
DeleteStringDict(pDriv->mappings);
free(pDriv);
return NULL;
}
pDriv->name = strdup("Tcl-Driver");
strncpy(pDriv->motName, argv[1], 131);
pDriv->GetPosition = GetTclPos;
pDriv->RunTo = TclRun;
pDriv->GetStatus = TclGetStatus;
pDriv->GetError = TclGetError;
pDriv->TryAndFixIt = TclTryAndFixIt;
pDriv->SetDriverPar = TclSetPar;
pDriv->GetDriverPar = TclGetPar;
pDriv->ListDriverPar = TclListPar;
pDriv->Halt = TclHalt;
pDriv->KillPrivate = KillTCL;
return (MotorDriver *) pDriv;
}

43
site_ansto/ansto_tclmotdriv.h Normal file
View File

@ -0,0 +1,43 @@
/*---------------------------------------------------------------------------
This is a motor driver which is implemented in Tcl. This means
this code is only a wrapper which calls Tcl functions to do the
actual work.
copyright: see file COPYRIGHT
Mark Koennecke, December 2005
--------------------------------------------------------------------------*/
#ifndef TCLMOTDRIV
#define TCLMOTDRIV
#include "stringdict.h"
typedef struct ___TclDriv {
/* general motor driver interface
fields. REQUIRED!
*/
float fUpper; /* upper limit */
float fLower; /* lower limit */
char *name;
int (*GetPosition) (void *self, float *fPos);
int (*RunTo) (void *self, float fNewVal);
int (*GetStatus) (void *self);
void (*GetError) (void *self, int *iCode, char *buffer, int iBufLen);
int (*TryAndFixIt) (void *self, int iError, float fNew);
int (*Halt) (void *self);
int (*GetDriverPar) (void *self, char *name, float *value);
int (*SetDriverPar) (void *self, SConnection * pCon,
char *name, float newValue);
void (*ListDriverPar) (void *self, char *motorName, SConnection * pCon);
void (*KillPrivate) (void *self);
/* Tcl specific fields */
pStringDict mappings;
int debug;
int errorCode;
char tclError[1024];
char motName[132];
} TCLDriv;
MotorDriver *CreateTclMotDriv(SConnection * pCon, int argc, char *argv[]);
#endif

2
site_ansto/make_gen_variables
View File

@ -22,7 +22,7 @@ SOBJ = alias.o anticollider.o arrayutil.o ascon.o asyncprotocol.o asyncqueue.o a
sicvar.o sig_die.o simchop.o simev.o simidx.o simindex.o sinfox.o singlebi.o singlediff.o singlenb.o singlebinb.o singletas.o singlex.o splitter.o s_rnge.o statemon.o \ sicvar.o sig_die.o simchop.o simev.o simidx.o simindex.o sinfox.o singlebi.o singlediff.o singlenb.o singlebinb.o singletas.o singlex.o splitter.o s_rnge.o statemon.o \
statistics.o statusfile.o status.o stdscan.o stptok.o stringdict.o strlutil.o strrepl.o \ statistics.o statusfile.o status.o stdscan.o stptok.o stringdict.o strlutil.o strrepl.o \
syncedprot.o synchronize.o tasdrive.o task.o tasscanub.o tasublib.o tasub.o tcldrivable.o \ syncedprot.o synchronize.o tasdrive.o task.o tasscanub.o tasublib.o tasub.o tcldrivable.o \
tclev.o tclintimpl.o tclmotdriv.o telnet.o testprot.o token.o trace.o trigd.o trim.o ubcalc.o \ tclev.o tclintimpl.o telnet.o testprot.o token.o trace.o trigd.o trim.o ubcalc.o \
ubfour.o udpquieck.o uselect.o userscan.o uubuffer.o varlog.o vector.o velosec.o wwildcard.o \ ubfour.o udpquieck.o uselect.o userscan.o uubuffer.o varlog.o vector.o velosec.o wwildcard.o \
xytable.o xytable.o