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