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

Cleaned up ANSTO code to merge with sinqdev.sics

Browse Source 
This is our new RELEASE-4_0 branch which was taken from ansto/93d9a7c
Conflicts:
	.gitignore
	SICSmain.c
	asynnet.c
	confvirtualmot.c
	counter.c
	devexec.c
	drive.c
	event.h
	exebuf.c
	exeman.c
	histmem.c
	interface.h
	motor.c
	motorlist.c
	motorsec.c
	multicounter.c
	napi.c
	napi.h
	napi4.c
	network.c
	nwatch.c
	nxscript.c
	nxxml.c
	nxxml.h
	ofac.c
	reflist.c
	scan.c
	sicshipadaba.c
	sicsobj.c
	site_ansto/docs/Copyright.txt
	site_ansto/instrument/lyrebird/config/tasmad/sicscommon/nxsupport.tcl
	site_ansto/instrument/lyrebird/config/tasmad/taspub_sics/tasscript.tcl
	statusfile.c
	tasdrive.c
	tasub.c
	tasub.h
	tasublib.c
	tasublib.h
This commit is contained in:
Ferdi Franceschini
2015-04-23 20:49:26 +10:00
parent c650788a2c
commit 10d29d597c
1336 changed files with 9430 additions and 226646 deletions
Download Patch File Download Diff File Expand all files Collapse all files

302
multicounter.c
View File

@@ -37,6 +37,7 @@ typedef struct {
pICountable slaves[MAXSLAVE];
char *transferScript;
int nSlaves;
int checkSlaves;
} MultiCounter, *pMultiCounter;
/*--------------------------------------------------------------------------*/
static void KillMultiDriver(struct __COUNTER *data)
@@ -77,12 +78,9 @@ static int MMCCHalt(void *pData)
/*-------------------------------------------------------------------------*/
static int MMCCStart(void *pData, SConnection * pCon)
{
int i, status, controlMonitor;
int slavePreset, oneYear = 32000000;
int i, status;
pCounter pCount = NULL;
pMultiCounter self = NULL;
char buffer[128];
CounterMode slaveMode;
pCount = (pCounter) pData;
if (pCount != NULL) {
@@ -93,25 +91,12 @@ static int MMCCStart(void *pData, SConnection * pCon)
if (!GetCountLock(pCount->pCountInt, pCon)) {
return HWFault;
}
controlMonitor = GetControlMonitor((pCounter) pCount);
if (pCount->pDriv->eMode == ePreset) {
slaveMode = eTimer;
slavePreset = oneYear;
} else {
slaveMode = pCount->pDriv->eMode;
slavePreset = pCount->pDriv->fPreset;
}
for (i = 0; i < self->nSlaves; i++) {
ReleaseCountLock(self->slaves[i]);
if (i == controlMonitor) {
self->slaves[i]->SetCountParameters(self->slaveData[i],
pCount->pDriv->fPreset,
pCount->pDriv->eMode);
} else {
self->slaves[i]->SetCountParameters(self->slaveData[i],
slavePreset, slaveMode);
}
ReleaseCountLock(self->slaves[i]);
self->slaves[i]->SetCountParameters(self->slaveData[i],
pCount->pDriv->fPreset,
pCount->pDriv->eMode);
status = self->slaves[i]->StartCount(self->slaveData[i], pCon);
if (status != OKOK) {
MMCCHalt(pData);
@@ -122,24 +107,18 @@ static int MMCCStart(void *pData, SConnection * pCon)
pCount->isUpToDate = 0;
pCount->tStart = time(NULL);
InvokeCallBack(pCount->pCall, COUNTSTART, pCon);
self->checkSlaves = 0;
return OKOK;
}
/*-------------------------------------------------------------------------*/
static int MMCCStatus(void *pData, SConnection * pCon)
{
int status, ctrStatus, i, controlMonitor;
pCounter pCountController = NULL, pSlaveCounter = NULL;
int status, i;
pCounter pCount = NULL, pMaster = NULL;;
pMultiCounter self = NULL;
pDummy pDum = NULL;
enum {
eIdle,
eBusy,
ePause,
eNoBeam,
eFault
} statusLevel;
pCount = (pCounter) pData;
if (pCount != NULL) {
@@ -153,63 +132,47 @@ static int MMCCStatus(void *pData, SConnection * pCon)
return HWFault;
}
status = self->slaves[0]->CheckCountStatus(self->slaveData[0], pCon);
pMaster = (pCounter)self->slaveData[0];
pCount->pDriv->fLastCurrent = GetControlValue(pMaster);
controlMonitor = GetControlMonitor((pCounter) pCount);
pCountController = (pCounter) self->slaveData[controlMonitor];
/* counter states = HWIdle, HWBusy, HWPause, HWNoBeam, HWFault */
status = HWIdle;
statusLevel = eIdle;
for (i = 0; i < self->nSlaves; i++) {
pSlaveCounter = (pCounter) self->slaveData[i];
ctrStatus = self->slaves[i]->CheckCountStatus(pSlaveCounter, pCon);
if (statusLevel >= eFault)
continue;
switch (ctrStatus) {
case HWFault:
statusLevel = eFault;
status = HWFault;
break;
case HWNoBeam:
if (statusLevel < eNoBeam)
statusLevel = eNoBeam;
status = HWNoBeam;
break;
case HWPause:
if (statusLevel < ePause)
statusLevel = ePause;
status = HWPause;
break;
default:
if (pCountController->pDriv->eMode == ePreset && i == controlMonitor
&& ctrStatus == HWIdle) {
statusLevel = eBusy; /* Allow transition to HWPause or higher */
status = HWIdle;
} else if (statusLevel < eBusy && ctrStatus != HWIdle) {
/* ffr: We expect !HWIdle means HWBusy, if not the existing code should handle the exception */
statusLevel = eBusy;
status = ctrStatus;
}
if(self->checkSlaves == 0) {
status = self->slaves[0]->CheckCountStatus(self->slaveData[0], pCon);
if (status == HWIdle || status == HWFault) {
/*
stop counting on slaves when finished or when an error
occurred.
*/
MMCCHalt(pData);
ReleaseCountLock(pCount->pCountInt);
self->checkSlaves = 1;
status = HWBusy;
}
}
if (status == HWIdle || status == HWFault) {
pCount->pDriv->fLastCurrent = GetControlValue(self->slaveData[0]);
} else {
/*
stop counting on slaves when finished or when an error
occurred.
* wait for the detectors to report finish too. Otherwise, with the second
* generation HM data may not be fully transferred.
*/
InvokeCallBack(pCount->pCall, COUNTEND, pCon);
MMCCHalt(pCount);
}
for (i = 1; i < MAXSLAVE; i++) {
if (self->slaves[i] != NULL) {
pDum = (pDummy) self->slaveData[i];
if (strcmp(pDum->pDescriptor->name, "HistMem") == 0) {
HistDirty((pHistMem) self->slaveData[i]);
for(i = 1; i < self->nSlaves; i++){
status = self->slaves[i]->CheckCountStatus(self->slaveData[i], pCon);
if(!(status == HWIdle || status == HWFault)){
return status;
}
ReleaseCountLock(self->slaves[i]);
}
/*
Warning: this assumes that slaves 1 - MAXSLAVE are histogram memories.
If this assumption does not hold, change this code to check if this
is really a histogram memory.
*/
for (i = 1; i < self->nSlaves; i++) {
if (self->slaves[i] != NULL) {
pDum = (pDummy)self->slaveData[i];
if (strcmp(pDum->pDescriptor->name, "HistMem") == 0) {
HistDirty((pHistMem) self->slaveData[i]);
}
ReleaseCountLock(self->slaves[i]);
}
}
status = HWIdle;
InvokeCallBack(pCount->pCall, COUNTEND, pCon);
self->checkSlaves = 0;
}
return status;
}
@@ -293,8 +256,7 @@ static void loadCountData(pCounter pCount, const char *data)
pPtr = (char *) data;
pPtr = getNextMMCCNumber(pPtr, pNumber);
// SICS-195 get time from controlling monitor
// pCount->pDriv->fTime = atof(pNumber);
pCount->pDriv->fTime = atof(pNumber);
while (pPtr != NULL && i < MAXCOUNT) {
pPtr = getNextMMCCNumber(pPtr, pNumber);
pCount->pDriv->lCounts[i] = atoi(pNumber);
@@ -308,19 +270,14 @@ static int MMCCTransfer(void *pData, SConnection * pCon)
int i, retVal = OKOK, status;
char pBueffel[132];
pCounter pCount = NULL;
pCounter pCountController = NULL, pCountSlave;
pMultiCounter self = NULL;
int tclStatus;
int controlMonitor;
double avCntRt;
pCount = (pCounter) pData;
if (pCount != NULL) {
self = (pMultiCounter) pCount->pDriv->pData;
}
assert(self);
controlMonitor = GetControlMonitor(pCount);
pCountController = (pCounter) self->slaveData[controlMonitor];
for (i = 0; i < self->nSlaves; i++) {
status = self->slaves[i]->TransferData(self->slaveData[i], pCon);
@@ -329,18 +286,8 @@ static int MMCCTransfer(void *pData, SConnection * pCon)
snprintf(pBueffel,sizeof(pBueffel)-1,
"WARNING: slave histogram %d failed to transfer data", i);
SCWrite(pCon, pBueffel, eWarning);
} else if (pCountController->pDriv->eMode == ePreset) {
if (i != controlMonitor) {
pCountSlave = (pCounter) self->slaveData[i];
avCntRt =
pCountSlave->pDriv->lCounts[0] / pCountSlave->pDriv->fTime;
pCountSlave->pDriv->lCounts[0] =
avCntRt * pCountController->pDriv->fTime;
pCountSlave->pDriv->fTime = pCountController->pDriv->fTime;
}
}
}
pCount->pDriv->fTime = pCountController->pDriv->fTime;
if (self->transferScript != NULL) {
MacroPush(pCon);
tclStatus = Tcl_Eval(InterpGetTcl(pServ->pSics), self->transferScript);
@@ -380,74 +327,74 @@ static void MMCCParameter(void *pData, float fPreset, CounterMode eMode)
static int MultiCounterSet(struct __COUNTER *pCount, char *name,
int iCter, float fVal)
{
pDummy pDum;
int i;
pMultiCounter self = NULL;
pCounter pCter;
pDummy pDum;
int i;
pMultiCounter self = NULL;
pCounter pCter;
self = (pMultiCounter) pCount->pData;
assert(self);
self = (pMultiCounter) pCount->pData;
assert(self);
for (i = 0; i < self->nSlaves; i++) {
pDum = (pDummy)self->slaveData[i];
if(strcmp(pDum->pDescriptor->name, "SingleCounter") == 0){
pCter = (pCounter)self->slaveData[i];
if(pCter->pDriv != NULL){
return pCter->pDriv->Set(pCter->pDriv, name, iCter, fVal);
} else {
return 0;
}
}
}
return 0;
for (i = 0; i < self->nSlaves; i++) {
pDum = (pDummy)self->slaveData[i];
if(strcmp(pDum->pDescriptor->name, "SingleCounter") == 0){
pCter = (pCounter)self->slaveData[i];
if(pCter->pDriv != NULL){
return pCter->pDriv->Set(pCter->pDriv, name, iCter, fVal);
} else {
return 0;
}
}
}
return 0;
}
/*-----------------------------------------------------------------------*/
static int MultiCounterGet(struct __COUNTER *pCount, char *name,
int iCter, float *fVal)
{
pDummy pDum;
int i;
pMultiCounter self = NULL;
pCounter pCter;
pHdb node;
hdbValue v;
pDummy pDum;
int i;
pMultiCounter self = NULL;
pCounter pCter;
pHdb node;
hdbValue v;
self = (pMultiCounter) pCount->pData;
assert(self);
self = (pMultiCounter) pCount->pData;
assert(self);
for (i = 0; i < self->nSlaves; i++) {
pDum = (pDummy)self->slaveData[i];
if(strcmp(pDum->pDescriptor->name, "SingleCounter") == 0){
pCter = (pCounter)self->slaveData[i];
if(pCter->pDriv != NULL){
return pCter->pDriv->Get(pCter->pDriv, name, iCter, fVal);
} else {
return 0;
}
}
}
return 0;
for (i = 0; i < self->nSlaves; i++) {
pDum = (pDummy)self->slaveData[i];
if(strcmp(pDum->pDescriptor->name, "SingleCounter") == 0){
pCter = (pCounter)self->slaveData[i];
if(pCter->pDriv != NULL){
return pCter->pDriv->Get(pCter->pDriv, name, iCter, fVal);
} else {
return 0;
}
}
}
return 0;
}
/*-----------------------------------------------------------------------*/
static int MultiCounterSend(struct __COUNTER *pCount, char *pText,
char *reply, int replylen)
{
pDummy pDum;
int i;
pMultiCounter self = NULL;
pCounter pCter;
pDummy pDum;
int i;
pMultiCounter self = NULL;
pCounter pCter;
self = (pMultiCounter) pCount->pData;
assert(self);
self = (pMultiCounter) pCount->pData;
assert(self);
for (i = 0; i < self->nSlaves; i++) {
pDum = (pDummy)self->slaveData[i];
if(strcmp(pDum->pDescriptor->name, "SingleCounter") == 0){
pCter = (pCounter)self->slaveData[i];
return pCter->pDriv->Send(pCter->pDriv,pText, reply, replylen);
}
}
return 0;
for (i = 0; i < self->nSlaves; i++) {
pDum = (pDummy)self->slaveData[i];
if(strcmp(pDum->pDescriptor->name, "SingleCounter") == 0){
pCter = (pCounter)self->slaveData[i];
return pCter->pDriv->Send(pCter->pDriv,pText, reply, replylen);
}
}
return 0;
}
/*---------------------------------------------------------------------*/
static int MultiCounterError(struct __COUNTER *pDriv, int *iCode,
@@ -539,30 +486,6 @@ int MakeMultiCounter(SConnection * pCon, SicsInterp * pSics,
pDriv->pData = self;
pDriv->KillPrivate = KillMultiDriver;
pDriv->iNoOfMonitors = MAXCOUNT;
/*
now loop through the remaining arguments, thereby entering them into
the slave list.
*/
self->nSlaves = 0;
for (i = 2; i < argc; i++) {
pCom = FindCommand(pSics, argv[i]);
if (!pCom) {
snprintf(pBueffel,sizeof(pBueffel)-1, "ERROR: object %s not found in MakeMultiCounter",
argv[i]);
SCWrite(pCon, pBueffel, eError);
continue;
}
pCount = GetCountableInterface(pCom->pData);
if (!pCount) {
snprintf(pBueffel,sizeof(pBueffel)-1, "ERROR: object %s is NOT countable", argv[i]);
SCWrite(pCon, pBueffel, eError);
continue;
}
self->slaves[self->nSlaves] = pCount;
self->slaveData[self->nSlaves] = pCom->pData;
self->nSlaves++;
}
pDriv->iNoOfMonitors = self->nSlaves;
pNew = CreateCounter(argv[1], pDriv);
if (pNew == NULL) {
SCWrite(pCon, "ERROR: out of memory in MakeMultiCounter", eError);
@@ -585,6 +508,29 @@ int MakeMultiCounter(SConnection * pCon, SicsInterp * pSics,
pNew->pCountInt->TransferData = MMCCTransfer;
pNew->pCountInt->SetCountParameters = MMCCParameter;
/*
now loop through the remaining arguments, thereby entering them into
the slave list.
*/
for (i = 2; i < argc; i++) {
pCom = FindCommand(pSics, argv[i]);
if (!pCom) {
snprintf(pBueffel,sizeof(pBueffel)-1, "ERROR: object %s not found in MakeMultiCounter",
argv[i]);
SCWrite(pCon, pBueffel, eError);
continue;
}
pCount = GetCountableInterface(pCom->pData);
if (!pCount) {
snprintf(pBueffel,sizeof(pBueffel)-1, "ERROR: object %s is NOT countable", argv[i]);
SCWrite(pCon, pBueffel, eError);
continue;
}
self->slaves[self->nSlaves] = pCount;
self->slaveData[self->nSlaves] = pCom->pData;
self->nSlaves++;
}
/*
now install our action command and we are done
*/