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

r3816 | jgn | 2012-11-22 15:31:25 +1100 (Thu, 22 Nov 2012) | 1 line

Browse Source
This commit is contained in:
Jing Chen
2012-11-22 15:31:25 +11:00
committed by Douglas Clowes
parent a09333a655
commit 27b9f0aee0
1 changed files with 61 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
site_ansto/ansto_tclmotdriv.c
View File

@ -19,10 +19,11 @@
facilitate error handling, a motor parameter errorcode is available to
store errors between invocations.
copyright: see file COPYRIGHT
Author: Jing Chen, Nov 2012
Mark Koennecke, December 2005
copyright: see file COPYRIGHT
--------------------------------------------------------------------------*/
#include <stdlib.h>
#include <assert.h>
#include <string.h>
@ -63,21 +64,24 @@ static int buildStandardCommandPart(TCLDriv *pDriv, char *command,
/*----------------------------------------------------------------------------*/
static int GetTclPos(void *self, float *fPos){
TCLDriv *pDriv;
char tclCommand[1024];
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;
}
status = Tcl_Eval(pServ->pSics->pTcl,tclCommand);
result = Tcl_GetStringResult(pServ->pSics->pTcl);
free(tclCommand);
if(result == NULL){
pDriv->errorCode = NOTCLRESULT;
return HWFault;
@ -93,7 +97,6 @@ static int buildStandardCommandPart(TCLDriv *pDriv, char *command,
/*----------------------------------------------------------------------------*/
static int TclRun(void *self, float fVal) {
TCLDriv *pDriv;
char tclCommand[1024];
char num[80];
int status;
const char *result = NULL;
@ -101,9 +104,12 @@ static int buildStandardCommandPart(TCLDriv *pDriv, char *command,
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);
@ -111,6 +117,7 @@ static int buildStandardCommandPart(TCLDriv *pDriv, char *command,
status = Tcl_Eval(pServ->pSics->pTcl,tclCommand);
result = Tcl_GetStringResult(pServ->pSics->pTcl);
free(tclCommand);
if(result == NULL) {
pDriv->errorCode = NOTCLRESULT;
return HWFault;
@ -149,9 +156,8 @@ static int evaluateInternalErrors(TCLDriv *pDriv, int *iCode,
return 0;
}
/*--------------------------------------------------------------------------*/
static void TclError(void *self, int *iCode, char *error, int iErrLen){
static void TclGetError(void *self, int *iCode, char *error, int iErrLen){
TCLDriv *pDriv;
char tclCommand[1024];
int status = 1;
const char *result = NULL;
@ -162,6 +168,8 @@ static int evaluateInternalErrors(TCLDriv *pDriv, int *iCode,
return;
}
char *tclCommand = (char *)calloc(1024, sizeof(char));
if(!buildStandardCommandPart(pDriv,"geterror",tclCommand,1023)){
pDriv->errorCode = FUNCNOTFOUND;
status = 0;
@ -180,14 +188,16 @@ static int evaluateInternalErrors(TCLDriv *pDriv, int *iCode,
}
if(evaluateInternalErrors(pDriv,iCode,error,iErrLen) == 1) {
return;
free(tclCommand);
return;
}
free(tclCommand);
strncpy(error,result,iErrLen);
}
/*---------------------------------------------------------------------------*/
static int TclFix(void *self, int iError, float fNew){
static int TclTryAndFixIt(void *self, int iError, float fNew){
TCLDriv *pDriv;
char tclCommand[1024];
char num[80];
int status;
const char *result = NULL;
@ -195,8 +205,11 @@ static int evaluateInternalErrors(TCLDriv *pDriv, int *iCode,
assert(self);
pDriv = (TCLDriv *)self;
char *tclCommand = (char *)calloc(1024, sizeof(char));
if(!buildStandardCommandPart(pDriv,"fixit",tclCommand,1023)){
pDriv->errorCode = FUNCNOTFOUND;
free(tclCommand);
return HWFault;
}
snprintf(num,79,"%d %f",pDriv->errorCode, fNew);
@ -206,21 +219,24 @@ static int evaluateInternalErrors(TCLDriv *pDriv, int *iCode,
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)
{
TCLDriv *pDriv;
char tclCommand[1024];
int status;
const char *result = NULL;
@ -228,8 +244,12 @@ static int evaluateInternalErrors(TCLDriv *pDriv, int *iCode,
pDriv = (TCLDriv *)self;
pDriv->errorCode = 0;
char *tclCommand = (char *)calloc(1024, sizeof(char));
if(!buildStandardCommandPart(pDriv,"halt",tclCommand,1023)){
pDriv->errorCode = FUNCNOTFOUND;
free(tclCommand);
return HWFault;
}
@ -237,20 +257,23 @@ static int evaluateInternalErrors(TCLDriv *pDriv, int *iCode,
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 TclStat(void *self)
static int TclGetStatus(void *self)
{
TCLDriv *pDriv;
char tclCommand[1024];
int status;
const char *result = NULL;
@ -258,8 +281,12 @@ static int evaluateInternalErrors(TCLDriv *pDriv, int *iCode,
pDriv = (TCLDriv *)self;
pDriv->errorCode = 0;
char *tclCommand = (char *)calloc(1024, sizeof(char));
if(!buildStandardCommandPart(pDriv,"status",tclCommand,1023)){
pDriv->errorCode = FUNCNOTFOUND;
free(tclCommand);
return HWFault;
}
@ -267,16 +294,20 @@ static int evaluateInternalErrors(TCLDriv *pDriv, int *iCode,
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){
@ -361,12 +392,20 @@ static int TclListPar(void *self, char *motorname, SConnection *pCon) {
count++;
}
if(flag==0) {
snprintf(pBueffel,511,"%s.%s = %f",motorname,sVal.name,sVal.value);
SCWrite(pCon,pBueffel,eValue);
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;
}
@ -440,7 +479,8 @@ static int assignMappings(TCLDriv *pDriv, SConnection *pCon, char *arrayName){
return OKOK;
} else {
unsigned char ps=0;
char *pch, *funcName;
char *pch;
char *funcName = (char *)calloc(1024, sizeof(char));
pch = strtok(arrayName, "{}");
while (pch != NULL) {
@ -460,20 +500,20 @@ static int assignMappings(TCLDriv *pDriv, SConnection *pCon, char *arrayName){
if (ps%2==0){
if (*newStr==NULL) {
free(newStr);
free(funcName);
return OKOK;
} else {
funcName = (char *)calloc(strlen(pch)-c+1, sizeof(char));
strcpy(funcName, newStr);
ps++;
}
} else {
StringDictAddPair(pDriv->mappings,funcName, newStr);
ps++;
free(funcName);
ps = 0;
}
free(newStr);
pch = strtok (NULL, "{}");
}
free(funcName);
}
return 1;
}
@ -511,9 +551,9 @@ static int assignMappings(TCLDriv *pDriv, SConnection *pCon, char *arrayName){
strncpy(pDriv->motName, argv[1], 131);
pDriv->GetPosition = GetTclPos;
pDriv->RunTo = TclRun;
pDriv->GetStatus = TclStat;
pDriv->GetError = TclError;
pDriv->TryAndFixIt = TclFix;
pDriv->GetStatus = TclGetStatus;
pDriv->GetError = TclGetError;
pDriv->TryAndFixIt = TclTryAndFixIt;
pDriv->SetDriverPar = TclSetPar;
pDriv->GetDriverPar = TclGetPar;
pDriv->ListDriverPar = TclListPar;