linse/sics
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
98cfb3ddda9f2691f53e52650b829f055b5cfac4
sics/nxscript.c
cvs 98cfb3ddda - Implemented defpos for multiple motors 
- Implemented automatic backup on parameter change
- Implemented silent restore
- Cleaned a couple of unused flags from connection object
2003-02-19 08:29:46 +00:00

726 lines
18 KiB
C
Raw Blame History

/*-----------------------------------------------------------------------
N X S C R I P T
This is a class for scripting the contents of NeXus files from
SICS.
copyright: see file COPYRIGHT
Mark Koennecke, February 2003
------------------------------------------------------------------------*/
#include <stdlib.h>
#include <assert.h>
#include <errno.h>
#include <tcl.h>
#include <unistd.h>
#include "fortify.h"
#include "sics.h"
#include "splitter.h"
#include "HistMem.h"
#include "motor.h"
#include "counter.h"
#include "udpquieck.h"
#include "nxdict.h"
#include "nxscript.h"
/*============== a personal data structure ============================*/
typedef struct {
pObjectDescriptor pDes;
NXhandle fileHandle;
NXdict dictHandle;
} NXScript, *pNXScript;
/*======================== Action =======================================*/
static int handleFileOperations(SConnection *pCon, pNXScript self,
int argc, char *argv[]){
int status,i, iVal;
NXaccess access;
char buffer[512];
if(strcmp(argv[1],"close") == 0){
/*
close everything! and send a message to trigger file synchronisation
to the central server
*/
i = 511;
iVal = NX_CHAR;
NXgetattr(self->fileHandle,"file_name",buffer,&i,&iVal);
NXclose(&self->fileHandle);
NXDclose(self->dictHandle,NULL);
self->fileHandle = NULL;
self->dictHandle = NULL;
SendQuieck(QUIECK,buffer);
SCSendOK(pCon);
return 1;
} else if(strcmp(argv[1],"reopen") == 0){
access = NXACC_RDWR;
} else if(strcmp(argv[1],"create4") == 0){
access = NXACC_CREATE4;
} else if(strcmp(argv[1],"create5") == 0){
access = NXACC_CREATE5;
} else {
return 0;
}
if(argc < 4){
SCWrite(pCon,"ERROR: insufficient number of arguments for file operation",
eError);
return 1;
}
/*
be considerate: close files left open
*/
if(self->fileHandle != NULL){
NXclose(&self->fileHandle);
self->fileHandle = NULL;
}
if(self->dictHandle != NULL){
NXDclose(self->dictHandle, NULL);
self->dictHandle = NULL;
}
/*
now initialize ourselves
*/
unlink(argv[2]); /* kill file for overwrite */
status = NXopen(argv[2],access,&self->fileHandle);
if(status != NX_OK){
sprintf(buffer,"ERROR: failed to open %s",argv[2]);
SCWrite(pCon,buffer,eError);
}
status = NXDinitfromfile(argv[3],&self->dictHandle);
if(status != NX_OK){
sprintf(buffer,"ERROR: failed to open dictionary %s",argv[3]);
SCWrite(pCon,buffer,eError);
}
SCSendOK(pCon);
return 1;
}
/*----------------------------------------------------------------------*/
static void putMotor(SConnection *pCon, SicsInterp *pSics, pNXScript self,
int argc, char *argv[]){
int status;
pMotor brumm = NULL;
float fVal;
char buffer[132], dummy[256];
if(argc < 4){
SCWrite(pCon,"ERROR: insufficient number of arguments to putmotor",
eError);
return;
}
/*
find motor
*/
brumm = (pMotor)FindCommandData(pSics,argv[3],"Motor");
if(!brumm){
sprintf(buffer,"ERROR: motor %s not found!", argv[3]);
SCWrite(pCon,buffer,eError);
return;
}
/*
do position
*/
status = MotorGetSoftPosition(brumm, pCon,&fVal);
if(!status){
sprintf(buffer,"ERROR: failed to read position of %s", argv[3]);
SCWrite(pCon,buffer,eError);
return;
}
status = NXDputalias(self->fileHandle,self->dictHandle,argv[2],&fVal);
if(status != NX_OK){
sprintf(buffer,"ERROR: failed to write %s with alias %s",
argv[3],argv[2]);
SCWrite(pCon,buffer,eError);
return;
}
/*
if alias_null is available: write zero point
*/
strcpy(buffer,argv[2]);
strcat(buffer,"_null");
if(NXDget(self->dictHandle,buffer,dummy,255)){
MotorGetPar(brumm,"softzero",&fVal);
status = NXDputalias(self->fileHandle,self->dictHandle,buffer, &fVal);
if(status != NX_OK){
sprintf(buffer,"ERROR: failed to write %s zero with alias %s",
argv[3],argv[2]);
SCWrite(pCon,buffer,eError);
return;
}
}
}
/*---------------------------------------------------------------------*/
static void putCounter(SConnection *pCon, SicsInterp *pSics, pNXScript self,
int argc, char *argv[]){
pCounter cter = NULL;
float fVal;
long counts;
char buffer[256], newAlias[256], dummy[80];
int status, i, icounts;
CounterMode eMode;
if(argc < 4){
SCWrite(pCon,"ERROR: insufficient number of arguments to putcounter",
eError);
return;
}
/*
find counter
*/
cter = (pCounter)FindCommandData(pSics,argv[3],"SingleCounter");
if(!cter){
sprintf(buffer,"ERROR: counter %s not found!", argv[3]);
SCWrite(pCon,buffer,eError);
return;
}
/*
do preset
*/
fVal = GetCounterPreset(cter);
strcpy(newAlias,argv[2]);
strcat(newAlias,"_preset");
status = NXDputalias(self->fileHandle,self->dictHandle,newAlias,&fVal);
if(status != NX_OK){
sprintf(buffer,"ERROR: failed to write preset to %s", newAlias);
SCWrite(pCon,buffer,eError);
}
/*
do countmode
*/
eMode = GetCounterMode(cter);
strcpy(newAlias,argv[2]);
strcat(newAlias,"_mode");
if(eMode == eTimer){
strcpy(dummy,"timer");
} else {
strcpy(dummy,"monitor");
}
status = NXDputalias(self->fileHandle,self->dictHandle,newAlias,dummy);
if(status != NX_OK){
sprintf(buffer,"ERROR: failed to write counter mode to %s", newAlias);
SCWrite(pCon,buffer,eError);
}
/*
do time
*/
fVal = GetCountTime(cter,pCon);
strcpy(newAlias,argv[2]);
strcat(newAlias,"_time");
if(NXDget(self->dictHandle,newAlias,dummy,79)){
status = NXDputalias(self->fileHandle,self->dictHandle,newAlias,&fVal);
if(status != NX_OK){
sprintf(buffer,"ERROR: failed to write count time to %s", newAlias);
SCWrite(pCon,buffer,eError);
}
}
/*
do counter and monitors
*/
for(i = 0; i < 10; i++){
sprintf(newAlias,"%s_%2.2d",argv[2],i);
if(NXDget(self->dictHandle,newAlias,dummy,79)){
counts = GetMonitor(cter,i,pCon);
icounts = (int)counts;
status = NXDputalias(self->fileHandle,self->dictHandle,newAlias,
&icounts);
}
}
return;
}
/*----------------------------------------------------------------------*/
static void putHistogramMemory(SConnection *pCon, SicsInterp *pSics,
pNXScript self,
int argc, char *argv[]){
pHistMem mem = NULL;
int status, start, length, iDim[MAXDIM], rank, i, subset = 0;
HistInt *iData = NULL;
char buffer[256], defString[512], dummy[40];
const float *timeBin;
int timeLength;
if(argc < 4){
SCWrite(pCon,"ERROR: insufficient number of arguments to puthm",
eError);
return;
}
/*
find Histogram Memory
*/
mem = (pHistMem)FindCommandData(pSics,argv[3],"HistMem");
if(!mem){
sprintf(buffer,"ERROR: HistMem %s not found!", argv[3]);
SCWrite(pCon,buffer,eError);
return;
}
/*
default: everything
*/
start = 0;
length = GetHistLength(mem);
/*
check for further arguments specifying a subset
*/
if(argc > 5){
subset = 1;
status = Tcl_GetInt(InterpGetTcl(pSics),argv[4],&start);
if(status != TCL_OK){
sprintf(buffer,"ERROR: failed to convert %s to integer",
argv[4]);
SCWrite(pCon,buffer,eError);
return;
}
status = Tcl_GetInt(InterpGetTcl(pSics),argv[5],&length);
if(status != TCL_OK){
sprintf(buffer,"ERROR: failed to convert %s to integer",
argv[5]);
SCWrite(pCon,buffer,eError);
return;
}
}
/*
now get some memory
*/
iData = (HistInt *)malloc(length*sizeof(HistInt));
if(!iData){
SCWrite(pCon,"ERROR: out of memory for reading histogram memory",
eError);
return;
}
/*
build the definition string
*/
status = NXDget(self->dictHandle,argv[2],buffer,254);
if(!status){
sprintf(buffer,"ERROR: alias %s for histogram memory not found",
argv[2]);
SCWrite(pCon,buffer,eError);
free(iData);
return;
}
if(subset){
strcpy(defString,buffer);
timeBin = GetHistTimeBin(mem,&timeLength);
if(timeLength > 2){
sprintf(dummy,"%d",timeLength);
NXDupdate(self->dictHandle,"timedim",dummy);
}
} else {
strcpy(defString,buffer);
GetHistDim(mem,iDim,&rank);
sprintf(dummy," -rank %d", rank);
strcat(defString,dummy);
strcat(defString," -dim { ");
sprintf(dummy,"%d",iDim[0]);
strcat(defString,dummy);
for(i = 1; i < rank; i++){
sprintf(dummy,", %d",iDim[i]);
strcat(defString,dummy);
}
strcat(defString," } ");
}
/*
read HM
*/
if(subset){
status = GetHistogramDirect(mem,pCon,0,start,length,iData,
length*sizeof(HistInt));
}else{
status = GetHistogram(mem,pCon,0,start,length,iData,
length*sizeof(HistInt));
}
if(!status){
SCWrite(pCon,"ERROR: failed to read histogram memory",eError);
free(iData);
return;
}
/*
finally: write
*/
status = NXDputdef(self->fileHandle, self->dictHandle,defString,iData);
if(status != NX_OK){
sprintf(buffer,"ERROR: failed to write histogram memory data");
SCWrite(pCon,buffer,eError);
}
free(iData);
SCSendOK(pCon);
return;
}
/*-------------------------------------------------------------------*/
static void putTimeBinning(SConnection *pCon, SicsInterp *pSics,
pNXScript self,
int argc, char *argv[]){
pHistMem mem = NULL;
int status, timeLength;
char buffer[256], defString[512], dummy[40];
const float *timeBin;
if(argc < 4){
SCWrite(pCon,"ERROR: insufficient number of arguments to puttimebinning",
eError);
return;
}
/*
find Histogram Memory
*/
mem = (pHistMem)FindCommandData(pSics,argv[3],"HistMem");
if(!mem){
sprintf(buffer,"ERROR: HistMem %s not found!", argv[3]);
SCWrite(pCon,buffer,eError);
return;
}
/*
build definition string
*/
status = NXDget(self->dictHandle,argv[2],buffer,254);
if(!status){
sprintf(buffer,"ERROR: alias %s for time binning not found",
argv[2]);
SCWrite(pCon,buffer,eError);
return;
}
timeBin = GetHistTimeBin(mem,&timeLength);
sprintf(defString,"%s -dim {%d} ",buffer,timeLength);
/*
write
*/
status = NXDputdef(self->fileHandle, self->dictHandle,
defString,(void *)timeBin);
if(status != NX_OK){
sprintf(buffer,"ERROR: failed to write time binning");
SCWrite(pCon,buffer,eError);
}
SCSendOK(pCon);
return;
}
/*----------------------------------------------------------------------*/
static void putArray(SConnection *pCon, SicsInterp *pSics,
pNXScript self,
int argc, char *argv[]){
float *data = NULL;
int length, i, status;
char num[20];
char buffer[256], defString[512], *varData;
Tcl_Interp *tcl = NULL;
double dVal;
if(argc < 5){
SCWrite(pCon,"ERROR: insufficient number of arguments to array",
eError);
return;
}
tcl = InterpGetTcl(pSics);
assert(tcl != NULL);
/*
get array length
*/
status = Tcl_GetInt(tcl,argv[4],&length);
if(status = TCL_OK){
sprintf(buffer,"ERROR: failed to convert %s to integer",argv[4]);
SCWrite(pCon,buffer,eError);
return;
}
/*
allocate
*/
if(length > 0){
data = (float *)malloc(length*sizeof(float));
}
if(data == NULL){
SCWrite(pCon,"ERROR: out of memory or invalid length",eError);
return;
}
memset(data,0,length*sizeof(float));
/*
try getting data
*/
for(i = 0; i < length; i++){
sprintf(num,"%d",i);
varData = Tcl_GetVar2(tcl,argv[3],num,0);
if(varData != NULL){
status = Tcl_GetDouble(tcl,varData,&dVal);
if(status = TCL_OK){
sprintf(buffer,"ERROR: failed to convert %s to double",
varData);
SCWrite(pCon,buffer,eError);
}
data[i] = (float)dVal;
} else {
sprintf(buffer,"WARNING: failed to find array element %d", i);
SCWrite(pCon,buffer,eError);
}
}
/*
build definition string
*/
status = NXDget(self->dictHandle,argv[2],buffer,254);
if(!status){
sprintf(buffer,"ERROR: alias %s for array not found",
argv[2]);
SCWrite(pCon,buffer,eError);
free(data);
return;
}
sprintf(defString,"%s -dim {%d} ",buffer,length);
/*
write it!
*/
status = NXDputdef(self->fileHandle,self->dictHandle,defString,data);
if(status != NX_OK){
sprintf(buffer,"ERROR: failed to write array");
SCWrite(pCon,buffer,eError);
}
free(data);
SCSendOK(pCon);
}
/*----------------------------------------------------------------------*/
static void putGlobal(SConnection *pCon, SicsInterp *pSics,
pNXScript self,
int argc, char *argv[]){
char value[1024];
int status;
if(argc < 4){
SCWrite(pCon,"ERROR: insufficient number of arguments to putglobal",
eError);
return;
}
Arg2Text(argc-3,&argv[3],value,1023);
status = NXputattr(self->fileHandle,argv[2],value,strlen(value),
NX_CHAR);
if(status != NX_OK){
SCWrite(pCon,"ERROR: failed to write attribute",eError);
}
SCSendOK(pCon);
}
/*-----------------------------------------------------------------------*/
static int handlePut(SConnection *pCon, SicsInterp *pSics, pNXScript self,
int argc, char *argv[]){
int status;
char buffer[1024], defString[1024], numBuf[25];
double dVal;
float fVal;
/*============ */
if(strcmp(argv[1],"putfloat") == 0){
if(argc < 4){
SCWrite(pCon,"ERROR: insufficient number of arguments to putfloat",
eError);
return 1;
}
status = Tcl_GetDouble(InterpGetTcl(pSics),argv[3],&dVal);
if(status != TCL_OK){
sprintf(buffer,"ERROR: failed to convert %s to float",
argv[3]);
SCWrite(pCon,buffer,eError);
return 1;
}
fVal = (float)dVal;
status = NXDputalias(self->fileHandle, self->dictHandle,
argv[2],&fVal);
if(status != NX_OK){
sprintf(buffer,"ERROR: failed to write %f to alias %s",
fVal, argv[2]);
SCWrite(pCon,buffer,eError);
}
return 1;
} else if (strcmp(argv[1],"puttext") == 0){
/*====================*/
if(argc < 4){
SCWrite(pCon,"ERROR: insufficient number of arguments to putfloat",
eError);
return 1;
}
Arg2Text(argc-3,&argv[3],buffer,1023);
status = NXDget(self->dictHandle,argv[2],defString,1023);
if(status != NX_OK){
sprintf(buffer,"ERROR: alias %s not found in puttext",
argv[2]);
SCWrite(pCon,buffer,eError);
return 1;
}
if(strlen(defString) < 900){
strcat(defString," -dim {");
sprintf(numBuf,"%d",strlen(buffer)+1);
strcat(defString,numBuf);
strcat(defString," }");
} else {
SCWrite(pCon,"ERROR: out of definition string space in puttext",
eError);
return 1;
}
status = NXDputdef(self->fileHandle,self->dictHandle,
defString,buffer);
if(status != NX_OK){
sprintf(buffer,"ERROR: failed to write alias %s",
argv[2]);
SCWrite(pCon,buffer,eError);
}
return 1;
} else if(strcmp(argv[1],"putmot") == 0){
/*=========== */
putMotor(pCon,pSics,self,argc,argv);
return 1;
} else if(strcmp(argv[1],"putcounter") == 0){
/* ================*/
putCounter(pCon,pSics,self, argc,argv);
return 1;
}else if(strcmp(argv[1],"puthm") == 0){
/*=================*/
putHistogramMemory(pCon,pSics,self,argc, argv);
return 1;
}else if(strcmp(argv[1],"puttimebinning") == 0){
/*=================*/
putTimeBinning(pCon,pSics,self,argc,argv);
}else if(strcmp(argv[1],"putarray") == 0){
/*================*/
putArray(pCon,pSics,self,argc,argv);
}else if(strcmp(argv[1],"putglobal") == 0){
/*===============*/
putGlobal(pCon,pSics,self,argc,argv);
} else {
SCWrite(pCon,"ERROR: put command not recognised",eError);
}
return 0;
}
/*----------------------------------------------------------------------*/
static void makeLink(SConnection *pCon, SicsInterp *pSics,
pNXScript self,
int argc, char *argv[]){
int status;
if(argc < 4){
SCWrite(pCon,"ERROR: insufficient number of arguments to makelink",
eError);
return;
}
status = NXDaliaslink(self->fileHandle, self->dictHandle,
argv[2],argv[3]);
if(status != NX_OK){
SCWrite(pCon,"ERROR: linking failed",eError);
return;
}
SCSendOK(pCon);
}
/*-----------------------------------------------------------------------*/
int NXScriptAction(SConnection *pCon, SicsInterp *pSics, void *pData,
int argc, char *argv[]){
pNXScript self = (pNXScript)pData;
/*
preliminary checks
*/
assert(self);
if(!SCMatchRights(pCon,usUser)){
return 1;
}
if(argc < 2){
SCWrite(pCon,"ERROR: no keyword found",eError);
return 1;
}
strtolower(argv[1]);
if(handleFileOperations(pCon,self,argc,argv)){
return 1;
}
/*
if we are here, we can only continue if files are open
*/
if(self->fileHandle == NULL || self->dictHandle == NULL){
SCWrite(pCon,"ERROR: cannot write, files not open",eError);
return 1;
}
if(strstr(argv[1],"put") != NULL){
handlePut(pCon,pSics,self,argc,argv);
return 1;
}
if(strcmp(argv[1],"makelink") == 0){
makeLink(pCon,pSics,self,argc,argv);
return 1;
}
return 1;
}
/*=============== make it ==============================================*/
static void KillNXScript(void *pData){
pNXScript self = (pNXScript)pData;
if(self == NULL){
return;
}
if(self->pDes){
DeleteDescriptor(self->pDes);
}
if(self->fileHandle){
NXclose(&self->fileHandle);
}
if(self->dictHandle){
NXDclose(self->dictHandle, NULL);
}
free(self);
}
/*----------------------------------------------------------------------*/
int MakeNXScript(SConnection *pCon, SicsInterp *pSics, void *pData,
int argc, char *argv[]){
pNXScript self = NULL;
int status;
self = (pNXScript)malloc(sizeof(NXScript));
if(self == NULL){
SCWrite(pCon,"ERROR: no memory for NXscript creation",eError);
return 0;
}
memset(self,0,sizeof(NXScript));
self->pDes = CreateDescriptor("NXScript");
if(self->pDes == NULL){
SCWrite(pCon,"ERROR: no memory for NXscript creation",eError);
free(self);
return 0;
}
/*
create with with a default name if none specified
*/
if(argc > 1){
status = AddCommand(pSics,argv[1],NXScriptAction,KillNXScript,self);
} else {
status = AddCommand(pSics,"nxscript",NXScriptAction,KillNXScript,self);
}
if(!status){
SCWrite(pCon,"ERROR: duplicate NXScript object not created",eError);
KillNXScript(self);
return 0;
}
return 1;
}
Reference in New Issue View Git Blame Copy Permalink