/* -------------------------------------------------------------------- */
static long dsetRead_devMbbiDirectAsyncGpib(mbbiDirectRecord *p_mbbiDirect) {
CONTEXT *p_myContext;
char p_readBuffer[BUFLEN];
dsetLog(3, __FILE__ "[%d] -> %s(%s)\n",
__LINE__, __func__, p_mbbiDirect->name);
dsetLog(7, __FILE__ "[%d] nobt = %d, shft = %d\n",
__LINE__, p_mbbiDirect->nobt, p_mbbiDirect->shft);
dsetLog(7, __FILE__ "[%d] mask =%ld, rval = %ld\n",
__LINE__, p_mbbiDirect->mask, p_mbbiDirect->rval);
dsetLog(7, __FILE__ "[%d] val = %d\n",
__LINE__, p_mbbiDirect->val);
p_myContext=p_mbbiDirect->dpvt;
if (p_mbbiDirect->pact==TRUE) {
if (gpibSetLock(p_myContext->gpibBoardAddress,LOCK,p_mbbiDirect->name)){
dsetLog(7, __FILE__ "[%d] %s -- gpibSetLock\n", __LINE__, __func__);
dsetLog(7, __FILE__ "[%d] lockOwner = %s\n",
__LINE__, gpibGetLockOwner(p_myContext->gpibBoardAddress));
dsetLog(7, __FILE__ "[%d] Rescheduling operation in %d sec\n",
__LINE__, SLEEPTIME_CALLBACK);
callbackRequestDelayed(p_myContext->p_callback,SLEEPTIME_CALLBACK);
return(SUCCESS);
} else {
/* has lock and p_mbbiDirect->pact=TRUE */
gpibWrite(p_myContext->gpibDeviceHandle,
p_myContext->p_gpibCommand);
gpibRead(p_myContext->gpibDeviceHandle,p_readBuffer,BUFLEN);
gpibSetLock(p_myContext->gpibBoardAddress, UNLOCK, p_mbbiDirect->name);
p_mbbiDirect->rval=atoi(p_readBuffer);
dsetLog(7, __FILE__ "[%d] gpibWrite >%s<\n",
__LINE__, p_myContext->p_gpibCommand);
dsetLog(7, __FILE__ "[%d] gpibRead >%s<\n", __LINE__, p_readBuffer);
dsetLog(2, __FILE__ "[%d] %ld (shft=%d) -> %s\n",
__LINE__, p_mbbiDirect->rval, p_mbbiDirect->shft,
p_mbbiDirect->name);
dsetLog(3, __FILE__ "[%d] <- %s\n", __LINE__, __func__ );
return(SHFT_RVAL_TO_GET_VAL);
}
} /* end_if_(p_mbbiDirect->pact==TRUE) */
/* At this point p_mbbiDirect->pact==FALSE */
p_mbbiDirect->pact=TRUE;
callbackRequestDelayed(p_myContext->p_callback, SLEEPTIME_CALLBACK);
dsetLog(7, __FILE__ "[%d] Callback was scheduled in %d sec\n",
__LINE__, SLEEPTIME_CALLBACK);
dsetLog(3, __FILE__ "[%d] <- %s\n", __LINE__, __func__ );
return(SUCCESS);
}
/*****************************************************************************
*
* Find the next link-group that needs processing.
*
* If there are no link-groups left to process
* call bdProcess() to complete the async record processing.
* else
* if the delay is > 0 seconds
* schedule the watch dog task to wake us up later
* else
* invoke the watch-dog wakeup routine now
*
*
* NOTE:
* dbScanLock is already held for prec before this function is called.
*
******************************************************************************/
static int processNextLink(seqRecord *prec)
{
callbackSeq *pcb = (callbackSeq *) (prec->dpvt);
if (seqRecDebug > 5)
printf("processNextLink(%s) looking for work to do, index = %d\n", prec->name, pcb->index);
if (pcb->plinks[pcb->index] == NULL)
{
/* None left, finish up. */
(*(struct rset *)(prec->rset)).process(prec);
}
else
{
if (pcb->plinks[pcb->index]->dly > 0.0)
{
callbackRequestDelayed( &pcb->callback,pcb->plinks[pcb->index]->dly);
}
else
{
/* No delay, do it now. Avoid recursion by using the callback task */
callbackRequest(&pcb->callback);
}
}
return(0);
}
static void myCallback(CALLBACK *pCallback)
{
myPvt *pmyPvt;
epicsTimeStamp now;
double delay, error;
epicsTimeGetCurrent(&now);
callbackGetUser(pmyPvt, pCallback);
if (pmyPvt->pass++ == 0) {
delay = 0.0;
error = epicsTimeDiffInSeconds(&now, &pmyPvt->start);
pmyPvt->start = now;
callbackRequestDelayed(&pmyPvt->cb2, pmyPvt->delay);
} else if (pmyPvt->pass == 2) {
double diff = epicsTimeDiffInSeconds(&now, &pmyPvt->start);
delay = pmyPvt->delay;
error = fabs(delay - diff);
} else {
testFail("pass = %d for delay = %f", pmyPvt->pass, pmyPvt->delay);
return;
}
testOk(error < 0.05, "delay %f seconds, callback time error %f",
delay, error);
}
static long dsetRead_devSiAsyncGpib(stringinRecord *psi)
{
CONTEXT *p_myContext;
char p_readBuffer[BUFLEN];
int backoff;
#ifdef DEBUG1
printf( __FILE__ "[%d] -> %s(%s)\n", __LINE__, __func__, psi->name );
#endif
p_myContext = (CONTEXT *)psi->dpvt;
if ((backoff=gpibSetLock(p_myContext->gpibBoardAddress, LOCK, psi->name))) {
#ifdef DEBUG2
printf( __FILE__ "[%d] Warning: Couldn't get lock!\n", __LINE__);
printf( __FILE__ "[%d] lockOwner = %s\n",
__LINE__,gpibGetLockOwner(p_myContext->gpibBoardAddress));
#endif
psi->pact = TRUE;
callbackRequestDelayed(p_myContext->p_callback, SLEEPTIME_CALLBACK);
return(SUCCESS);
}
#ifdef DEBUG2
printf( __FILE__ "[%d] %s: Got lock!\n", __LINE__, psi->name);
#endif
gpibWrite(p_myContext->gpibDeviceHandle, p_myContext->p_command);
usleep(USLEEPTIME_GPIBWRITE);
gpibRead(p_myContext->gpibDeviceHandle, p_readBuffer, BUFLEN);
usleep(USLEEPTIME_GPIBREAD);
if (gpibSetLock(p_myContext->gpibBoardAddress, UNLOCK, psi->name)) {
printf( __FILE__ "[%d] Error: Couldn't unlock GPIB\n", __LINE__);
return(ERROR);
}
strcpy(psi->val, p_readBuffer);
psi->udf = FALSE;
#ifdef DEBUG2
printf( __FILE__ "[%d] buffer returned: >%s<\n", __LINE__, p_readBuffer);
printf( __FILE__ "[%d] new value is %s\n", __LINE__, psi->val);
#endif
#ifdef DEBUG1
printf( __FILE__ "[%d] <- %s\n", __LINE__, __func__);
#endif
return(SUCCESS);
}
static asynStatus queueIt(devPvt *pdevPvt)
{
asynStatus status;
dbCommon *precord = pdevPvt->precord;
asynUser *pasynUser = pdevPvt->pasynUser;
status = pasynManager->blockProcessCallback(pasynUser,pdevPvt->blockAll);
if(status!=asynSuccess) {
asynPrint(pasynUser, ASYN_TRACE_ERROR,
"%s blockProcessCallback failed %s\n",
precord->name,pasynUser->errorMessage);
return status;
}
callbackRequestDelayed(&pdevPvt->callback,pdevPvt->queueDelay);
return status;
}
static long read_ai(aiRecord *pao)
{
struct prngState* priv=pao->dpvt;
if( ! pao->pact ){
/* start async operation */
pao->pact=TRUE;
callbackSetUser(pao,&priv->cb);
callbackRequestDelayed(&priv->cb,0.1);
return 0;
}else{
/* complete operation */
pao->pact=FALSE;
return 0;
}
}
static void checkLinks(calcoutRecord *prec)
{
DBLINK *plink;
rpvtStruct *prpvt = prec->rpvt;
int i;
int stat;
int caLink = 0;
int caLinkNc = 0;
epicsEnum16 *plinkValid;
if (calcoutRecDebug) printf("checkLinks() for %p\n", prec);
plink = &prec->inpa;
plinkValid = &prec->inav;
for (i = 0; i<CALCPERFORM_NARGS+1; i++, plink++, plinkValid++) {
if (plink->type == CA_LINK) {
caLink = 1;
stat = dbCaIsLinkConnected(plink);
if (!stat && (*plinkValid == calcoutINAV_EXT_NC)) {
caLinkNc = 1;
}
else if (!stat && (*plinkValid == calcoutINAV_EXT)) {
*plinkValid = calcoutINAV_EXT_NC;
db_post_events(prec, plinkValid, DBE_VALUE);
caLinkNc = 1;
}
else if (stat && (*plinkValid == calcoutINAV_EXT_NC)) {
*plinkValid = calcoutINAV_EXT;
db_post_events(prec, plinkValid, DBE_VALUE);
}
}
}
if (caLinkNc)
prpvt->caLinkStat = CA_LINKS_NOT_OK;
else if (caLink)
prpvt->caLinkStat = CA_LINKS_ALL_OK;
else
prpvt->caLinkStat = NO_CA_LINKS;
if (!prpvt->cbScheduled && caLinkNc) {
/* Schedule another CALLBACK */
prpvt->cbScheduled = 1;
callbackRequestDelayed(&prpvt->checkLinkCb, .5);
}
}
static void myCallback(CALLBACK *pCallback)
{
myPvt *pmyPvt;
callbackGetUser(pmyPvt, pCallback);
pmyPvt->pass++;
if (pmyPvt->pass == 1) {
epicsTimeGetCurrent(&pmyPvt->pass1Time);
callbackRequestDelayed(&pmyPvt->cb2, pmyPvt->delay);
} else if (pmyPvt->pass == 2) {
epicsTimeGetCurrent(&pmyPvt->pass2Time);
} else {
pmyPvt->resultFail = 1;
return;
}
}
static void checkLinksCallback(CALLBACK *pcallback)
{
acalcoutRecord *pcalc;
rpvtStruct *prpvt;
callbackGetUser(pcalc, pcallback);
prpvt = (rpvtStruct *)pcalc->rpvt;
if (!interruptAccept) {
/* Can't call dbScanLock yet. Schedule another CALLBACK */
prpvt->wd_id_1_LOCK = 1; /* make sure */
callbackRequestDelayed(&prpvt->checkLinkCb,.5);
} else {
dbScanLock((struct dbCommon *)pcalc);
prpvt->wd_id_1_LOCK = 0;
checkLinks(pcalc);
dbScanUnlock((struct dbCommon *)pcalc);
}
}
static void ntpsetup(CALLBACK *)
{
// We don't set IPC_CREAT, but instead wait for NTPD to start and initialize
// as it wants
int mode = ntpShm.segid <=1 ? 0600 : 0666;
int shmid = shmget((key_t)(NTPD_SEG0+ntpShm.segid), sizeof(shmSegment), mode);
if(shmid==-1) {
if(errno==ENOENT) {
if(!ntpShm.notify_nomap) {
fprintf(stderr, "Can't find shared memory segment. Either NTPD hasn't started,"
" or is not configured correctly. Will retry later.");
ntpShm.notify_nomap = 1;
}
callbackRequestDelayed(&ntpShm.ntpcb, RETRY_TIME);
} else {
perror("ntpshmsetup: shmget");
}
return;
}
ntpShm.seg = (shmSegment*)shmat(shmid, 0, 0);
if(ntpShm.seg==(shmSegment*)-1) {
perror("ntpshmsetup: shmat");
return;
}
ntpShm.seg->mode = 1;
ntpShm.seg->valid = 0;
SYNC();
ntpShm.seg->leap = 0; //TODO: what does this do?
ntpShm.seg->precision = -19; // pow(2,-19) ~= 1e-6 sec
ntpShm.seg->nsamples = 3; //TODO: what does this do?
SYNC();
try {
ntpShm.evr->eventNotifyAdd(ntpShm.event, &ntpshmupdate, 0);
} catch(std::exception& e) {
fprintf(stderr, "Error registering for 1Hz event: %s\n", e.what());
}
}
static void myCallbackFunc(CALLBACK *arg)
{
myCallback *pcallback;
boRecord *prec;
callbackGetUser(pcallback,arg);
prec=(boRecord *)pcallback->precord;
dbScanLock((struct dbCommon *)prec);
if(prec->pact) {
if((prec->val==1) && (prec->high>0)){
myCallback *pcallback;
pcallback = (myCallback *)(prec->rpvt);
callbackSetPriority(prec->prio, &pcallback->callback);
callbackRequestDelayed(&pcallback->callback,(double)prec->high);
}
} else {
prec->val = 0;
dbProcess((struct dbCommon *)prec);
}
dbScanUnlock((struct dbCommon *)prec);
}
/*----------------------------------------------------------------------*/
static long dsetWrite_devMbboAsyncSerial(mbboRecord *pmbbo) {
CONTEXT *p_myContext;
CALLBACK *p_myCallback;
char p_writeBuffer[BUFLEN];
int mySerialPortNumber;
char p_myCommand[BUFLEN]="";
int myOperatingMode;
dsetLog(3, __FILE__ "[%d] -> %s(%s)\n", __LINE__, __func__,pmbbo->name);
p_myContext = (CONTEXT *)pmbbo->dpvt;
mySerialPortNumber=p_myContext->serialPortNumber;
strncpy(p_myCommand,p_myContext->p_command,BUFLEN);
myOperatingMode=p_myContext->operatingMode;
p_myCallback=p_myContext->p_callback;
#ifdef WARMSTART
if ((pmbbo->nsev >= INVALID_ALARM) && (pmbbo->omsl==menuOmslclosed_loop)) {
/* PV_LINK's value is invalid or not available yet !*/
dsetLog(7, __FILE__ "[%d] Fetching >%s<\n",
__LINE__, pmbbo->dol.value.instio.string);
pmbbo->pact=TRUE;
callbackRequestDelayed(p_myCallback, SLEEPTIME_CALLBACK);
return(SUCCESS);
}
if ( myOperatingMode==WARMSTART_MODE) {
myOperatingMode=NORMAL_MODE;
p_myContext->operatingMode=myOperatingMode;
pmbbo->omsl=menuOmslsupervisory;
} else {
#endif
/* Get the lock or callback */
if (lockSerialPort2(mySerialPortNumber,LOCK, pmbbo->name)<=ERROR) {
dsetLog(7, __FILE__ "[%d] Warning: Couldn't lock %s\n",
__LINE__, getSerialPortName2(mySerialPortNumber));
dsetLog(7, __FILE__ "[%d] lockOwner is %s\n",
__LINE__, getSerialPortLockOwner2(mySerialPortNumber));
pmbbo->pact=TRUE;
callbackRequestDelayed(p_myCallback,SLEEPTIME_CALLBACK);
return(SUCCESS);
}
dsetLog(7, __FILE__ "[%d] p_myCommand = >%s<\n", __LINE__, p_myCommand);
sprintf(p_writeBuffer,p_myCommand,pmbbo->val);
strcat(p_writeBuffer,TERMINATOR);
dsetLog(7, __FILE__ "[%d] Writing >%s< for %s on %s\n",
__LINE__, p_writeBuffer,
pmbbo->name, getSerialPortName2(mySerialPortNumber));
if (writeSerialPort2(mySerialPortNumber, p_writeBuffer)<= ERROR) {
dsetLog(1, __FILE__ "[%d] Error: Couldn't write >%s< to %s\n",
__LINE__, p_writeBuffer, pmbbo->name);
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
usleep(USLEEPTIME_WRITE);
if (lockSerialPort2(mySerialPortNumber, UNLOCK, pmbbo->name) <=ERROR) {
dsetLog(1, __FILE__ "[%d] Error: Couldn't unlock %s\n",
__LINE__, getSerialPortName2(mySerialPortNumber));
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
pmbbo->udf = FALSE;
#ifdef WARMSTART
}
#endif
dsetLog(3, __FILE__ "[%d] <- %s\n", __LINE__, __func__);
return(SUCCESS);
}
/* this routine completes in 3 passes:
* 1. ask for the temperature
* 2. get the answer
* 3. delay before handing off to the next request
*/
static long dsetRead_devAiAsyncGpib(aiRecord *pai) {
CONTEXT *p_myContext;
char p_writeBuffer[BUFLEN];
char p_readBuffer[256];
int backoff;
dsetLog(3, __FILE__ "[%d] -> %s (%s)\n", __LINE__, __func__, pai->name );
p_myContext = (CONTEXT *)pai->dpvt;
if (pai->pact==FALSE) {
pai->pact = TRUE;
/* try to establish a lock on the port */
if ((backoff=gpibSetLock(p_myContext->gpibBoardAddress, LOCK, pai->name))) {
callbackRequestDelayed(p_myContext->pcallback, SLEEPTIME_CALLBACK);
dsetLog(7, __FILE__ "[%d] <- %s\n", __LINE__, __func__);
return(DO_NOT_CONVERT);
}
}
/* check the lock just in case */
if (gpibSetLock(p_myContext->gpibBoardAddress, LOCK, pai->name)) {
printf(__FILE__ "[%d] Error: Couldn't lock gpib(%d) for %s\n",
__LINE__, p_myContext->gpibBoardAddress, pai->name);
pai->pact = FALSE;
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
/* construct request for the temperature */
memset(p_writeBuffer,0,BUFLEN);
strcat(p_writeBuffer,p_myContext->p_gpibCommand);
strcat(p_writeBuffer, TERMINATOR);
dsetLog(7, __FILE__ "[%d] Writing >%s< on gpib(%d)\n",
__LINE__, p_writeBuffer, p_myContext->gpibBoardAddress);
if (gpibWrite(p_myContext->gpibDeviceHandle, p_writeBuffer) <= ERROR) {
dsetLog(1, __FILE__ "[%d] Error: Couldn't write >%s< to %s\n",
__LINE__, p_writeBuffer,pai->name);
/* release lock */
if (gpibSetLock(p_myContext->gpibBoardAddress, UNLOCK, pai->name)) {
dsetLog(1, __FILE__ "[%d] Error: Couldn't unlock gpib(%d)\n",
__LINE__, p_myContext->gpibBoardAddress);
}
pai->pact = FALSE;
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
usleep(USLEEPTIME_GPIBWRITE);
if (gpibRead(p_myContext->gpibDeviceHandle, p_readBuffer,256) <= ERROR) {
dsetLog(1, __FILE__ "[%d] Error: Couldn't read gpib(%d) for %s\n",
__LINE__, p_myContext->gpibBoardAddress, pai->name);
if (gpibSetLock(p_myContext->gpibBoardAddress, UNLOCK, pai->name)) {
dsetLog(1, __FILE__ "[%d] Error: Couldn't unlock gpib(%d)\n",
__LINE__, p_myContext->gpibBoardAddress);
}
pai->pact = FALSE;
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
usleep(USLEEPTIME_GPIBREAD);
if (strlen(p_readBuffer)==0 || strncmp(p_readBuffer, "999999", 6)==0)
pai->val = -999;
else
/* Convert to Celsius ?!?!? */
pai->val = (atof(p_readBuffer)-32.0)/1.8;
dsetLog(7, __FILE__ "[%d] Read >%s< from gpib.\n", __LINE__, p_readBuffer);
dsetLog(7, __FILE__ "[%d] val = '%f' rval = '%d'\n",
__LINE__,pai->val,pai->rval);
if (gpibSetLock(p_myContext->gpibBoardAddress,UNLOCK,pai->name)<=ERROR){
dsetLog(1, __FILE__ "[%d] Error: Couldn't unlock gpib(%d)\n",
__LINE__, p_myContext->gpibBoardAddress);
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
pai->pact = FALSE;
pai->udf = FALSE;
dsetLog(3, __FILE__ "[%d] <- %s\n", __LINE__, __func__ );
return(DO_NOT_CONVERT);
}
void callbackRequestProcessCallbackDelayed(CALLBACK *pcallback,
int Priority, void *pRec, double seconds)
{
callbackSetProcess(pcallback, Priority, pRec);
callbackRequestDelayed(pcallback, seconds);
}
/*----------------------------------------------------------------------*/
static long dsetRead_devAiAsyncSerial(aiRecord *pai) {
CONTEXT *p_myContext;
char p_writeBuffer[BUFLEN];
char p_readBuffer[BUFLEN];
int myPortNumber;
char p_myCommand[BUFLEN];
dsetLog(3, __FILE__ "[%d] -> %s(%s)\n", __LINE__, __func__,pai->name);
pai->pact=TRUE;
p_myContext = (CONTEXT *)pai->dpvt;
myPortNumber=p_myContext->portNumber;
strcpy(p_myCommand,p_myContext->p_command);
/* Get the lock or callback */
if (lockSerialPort2(myPortNumber,LOCK, pai->name)<=ERROR) {
dsetLog(7, __FILE__ "[%d] Warning: %s\n", __LINE__, pai->name);
dsetLog(7, __FILE__ "[%d] Warning: Couldn't lock %s\n",
__LINE__, getSerialPortName2(myPortNumber));
dsetLog(7, __FILE__ "[%d] Warning: lockOwner is %s\n",
__LINE__, getSerialPortLockOwner2(myPortNumber));
callbackRequestDelayed(p_myContext->p_callback,SLEEPTIME_CALLBACK);
return(DO_NOT_CONVERT);
}
#ifdef CLEAR_SR630_BUFFER
do {
if (readSerialPort2(myPortNumber, p_readBuffer,BUFLEN)<=ERROR) {
dsetLog(1, __FILE__ "[%d] Error: Couldn't Read %s\n",
__LINE__, getSerialPortName2(myPortNumber));
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
usleep(USLEEPTIME_READ);
} while (strlen(p_readBuffer)!=0);
#endif
strcpy(p_writeBuffer,p_myCommand);
strcat(p_writeBuffer,TERMINATOR);
dsetLog(7, __FILE__ "[%d] Writing >%s< for %s on %s\n",
__LINE__, p_writeBuffer,
pai->name, getSerialPortName2(myPortNumber));
#ifdef CLEAR_SR630_BUFFER
do {
#endif
if (writeSerialPort2(myPortNumber, p_writeBuffer)<= ERROR) {
dsetLog(7, __FILE__ "[%d] Error: Couldn't write >%s< to %s\n",
__LINE__, p_writeBuffer, pai->name);
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
usleep(USLEEPTIME_WRITE);
if (readSerialPort2(myPortNumber, p_readBuffer,BUFLEN)<=ERROR) {
dsetLog(1, __FILE__ "[%d] Error: Couldn't Read %s\n",
__LINE__, getSerialPortName2(myPortNumber));
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
usleep(USLEEPTIME_READ);
#ifdef CLEAR_SR630_BUFFER
} while (strlen(p_readBuffer)==0);
#endif
dsetLog(7, __FILE__ "[%d] %s read >%s<\n", __LINE__, pai->name, p_readBuffer);
if (lockSerialPort2(myPortNumber, UNLOCK, pai->name) <=ERROR) {
dsetLog(1, __FILE__ "[%d] Error: %s\n", __LINE__, pai->name);
dsetLog(1, __FILE__ "[%d] Error: Couldn't unlock %s\n",
__LINE__, getSerialPortName2(myPortNumber));
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
if (strlen(p_readBuffer)>0) {
pai->val=atof(p_readBuffer);
}
dsetLog(2, __FILE__ "[%d] %f -> %s\n", __LINE__, pai->val, pai->name);
pai->pact = FALSE;
pai->udf = FALSE;
dsetLog(3, __FILE__ "[%d] <- %s\n", __LINE__, __func__);
return(DO_NOT_CONVERT);
}
static long special(dbAddr *paddr, int after)
{
acalcoutRecord *pcalc = (acalcoutRecord *)(paddr->precord);
rpvtStruct *prpvt = (struct rpvtStruct *)pcalc->rpvt;
dbAddr Addr;
dbAddr *pAddr = &Addr;
short error_number;
int fieldIndex = dbGetFieldIndex(paddr);
int lnkIndex;
DBLINK *plink;
double *pvalue;
unsigned short *plinkValid;
if (!after) return(0);
switch (fieldIndex) {
case acalcoutRecordCALC:
pcalc->clcv = aCalcPostfix(pcalc->calc, pcalc->rpcl, &error_number);
if (pcalc->clcv) {
recGblRecordError(S_db_badField,(void *)pcalc,
"acalcout: special(): Illegal CALC field");
if (aCalcoutRecordDebug >= 10)
printf("acalcPostfix returns: %d\n", error_number);
}
db_post_events(pcalc,&pcalc->clcv,DBE_VALUE);
return(0);
break;
case acalcoutRecordOCAL:
pcalc->oclv = aCalcPostfix(pcalc->ocal, pcalc->orpc, &error_number);
if (pcalc->oclv) {
recGblRecordError(S_db_badField,(void *)pcalc,
"acalcout: special(): Illegal OCAL field");
if (aCalcoutRecordDebug >= 10)
printf("acalcPostfix returns: %d\n", error_number);
}
db_post_events(pcalc,&pcalc->oclv,DBE_VALUE);
return(0);
break;
case acalcoutRecordNUSE:
if ((pcalc->nuse < 0) || (pcalc->nuse > pcalc->nelm)) {
pcalc->nuse = pcalc->nelm;
db_post_events(pcalc,&pcalc->nuse,DBE_VALUE);
return(-1);
}
return(0);
break;
case(acalcoutRecordINPA):
case(acalcoutRecordINPB):
case(acalcoutRecordINPC):
case(acalcoutRecordINPD):
case(acalcoutRecordINPE):
case(acalcoutRecordINPF):
case(acalcoutRecordINPG):
case(acalcoutRecordINPH):
case(acalcoutRecordINPI):
case(acalcoutRecordINPJ):
case(acalcoutRecordINPK):
case(acalcoutRecordINPL):
case(acalcoutRecordINAA):
case(acalcoutRecordINBB):
case(acalcoutRecordINCC):
case(acalcoutRecordINDD):
case(acalcoutRecordINEE):
case(acalcoutRecordINFF):
case(acalcoutRecordINGG):
case(acalcoutRecordINHH):
case(acalcoutRecordINII):
case(acalcoutRecordINJJ):
case(acalcoutRecordINKK):
case(acalcoutRecordINLL):
case(acalcoutRecordOUT):
lnkIndex = fieldIndex - acalcoutRecordINPA;
plink = &pcalc->inpa + lnkIndex;
pvalue = &pcalc->a + lnkIndex;
plinkValid = &pcalc->inav + lnkIndex;
if (plink->type == CONSTANT) {
if (fieldIndex <= acalcoutRecordINPL) {
recGblInitConstantLink(plink,DBF_DOUBLE,pvalue);
db_post_events(pcalc,pvalue,DBE_VALUE);
}
*plinkValid = acalcoutINAV_CON;
if (fieldIndex == acalcoutRecordOUT)
prpvt->outlink_field_type = DBF_NOACCESS;
} else if (!dbNameToAddr(plink->value.pv_link.pvname, pAddr)) {
/* PV resides on this ioc */
*plinkValid = acalcoutINAV_LOC;
if (fieldIndex == acalcoutRecordOUT) {
prpvt->outlink_field_type = pAddr->field_type;
if ((pAddr->field_type >= DBF_INLINK) && (pAddr->field_type <= DBF_FWDLINK)) {
if (!(plink->value.pv_link.pvlMask & pvlOptCA)) {
printf("aCalcoutRecord(%s):special:non-CA link to link field\n",
plink->value.pv_link.pvname);
}
}
if (pcalc->wait && !(plink->value.pv_link.pvlMask & pvlOptCA)) {
printf("aCalcoutRecord(%s):special: Can't wait with non-CA link attribute\n",
plink->value.pv_link.pvname);
}
}
} else {
/* pv is not on this ioc. Callback later for connection stat */
*plinkValid = acalcoutINAV_EXT_NC;
/* DO_CALLBACK, if not already scheduled */
if (!prpvt->wd_id_1_LOCK) {
callbackRequestDelayed(&prpvt->checkLinkCb,.5);
prpvt->wd_id_1_LOCK = 1;
prpvt->caLinkStat = CA_LINKS_NOT_OK;
}
if (fieldIndex == acalcoutRecordOUT)
prpvt->outlink_field_type = DBF_NOACCESS; /* don't know */
}
db_post_events(pcalc,plinkValid,DBE_VALUE);
return(0);
break;
default:
recGblDbaddrError(S_db_badChoice,paddr,"calc: special");
return(S_db_badChoice);
}
return(0);
}
static long init_record(acalcoutRecord *pcalc, int pass)
{
DBLINK *plink;
int i;
double *pvalue;
unsigned short *plinkValid;
short error_number;
acalcoutDSET *pacalcoutDSET;
dbAddr Addr;
dbAddr *pAddr = &Addr;
rpvtStruct *prpvt;
if (pass==0) {
pcalc->vers = VERSION;
pcalc->rpvt = (void *)calloc(1, sizeof(struct rpvtStruct));
if ((pcalc->nuse < 0) || (pcalc->nuse > pcalc->nelm)) {
pcalc->nuse = pcalc->nelm;
db_post_events(pcalc,&pcalc->nuse,DBE_VALUE|DBE_LOG);
}
return(0);
}
if (!(pacalcoutDSET = (acalcoutDSET *)pcalc->dset)) {
recGblRecordError(S_dev_noDSET,(void *)pcalc,"acalcout:init_record");
return(S_dev_noDSET);
}
/* must have write defined */
if ((pacalcoutDSET->number < 5) || (pacalcoutDSET->write == NULL)) {
recGblRecordError(S_dev_missingSup,(void *)pcalc,"acalcout:init_record");
return(S_dev_missingSup);
}
prpvt = (rpvtStruct *)pcalc->rpvt;
plink = &pcalc->inpa;
pvalue = &pcalc->a;
plinkValid = &pcalc->inav;
for (i=0; i<(MAX_FIELDS+ARRAY_MAX_FIELDS+1); i++, plink++, pvalue++, plinkValid++) {
if (plink->type == CONSTANT) {
/* Don't InitConstantLink the array links or the output link. */
if (i < MAX_FIELDS) {
recGblInitConstantLink(plink,DBF_DOUBLE,pvalue);
db_post_events(pcalc,pvalue,DBE_VALUE);
}
*plinkValid = acalcoutINAV_CON;
if (plink == &pcalc->out)
prpvt->outlink_field_type = DBF_NOACCESS;
} else if (!dbNameToAddr(plink->value.pv_link.pvname, pAddr)) {
/* the PV we're linked to resides on this ioc */
*plinkValid = acalcoutINAV_LOC;
if (plink == &pcalc->out) {
prpvt->outlink_field_type = pAddr->field_type;
if ((pAddr->field_type >= DBF_INLINK) && (pAddr->field_type <= DBF_FWDLINK)) {
if (!(plink->value.pv_link.pvlMask & pvlOptCA)) {
printf("aCalcoutRecord(%s):init_record:non-CA link to link field\n",
plink->value.pv_link.pvname);
}
}
if (pcalc->wait && !(plink->value.pv_link.pvlMask & pvlOptCA)) {
printf("aCalcoutRecord(%s):init_record: Can't wait with non-CA link attribute\n",
plink->value.pv_link.pvname);
}
}
} else {
/* pv is not on this ioc. Callback later for connection stat */
*plinkValid = acalcoutINAV_EXT_NC;
prpvt->caLinkStat = CA_LINKS_NOT_OK;
if (plink == &pcalc->out)
prpvt->outlink_field_type = DBF_NOACCESS; /* don't know field type */
}
db_post_events(pcalc,plinkValid,DBE_VALUE);
}
pcalc->clcv = aCalcPostfix(pcalc->calc,pcalc->rpcl,&error_number);
if (pcalc->clcv) {
recGblRecordError(S_db_badField,(void *)pcalc,
"acalcout: init_record: Illegal CALC field");
if (aCalcoutRecordDebug >= 10)
printf("acalcPostfix returns: %d\n", error_number);
}
db_post_events(pcalc,&pcalc->clcv,DBE_VALUE);
pcalc->oclv = aCalcPostfix(pcalc->ocal, pcalc->orpc,&error_number);
if (pcalc->oclv) {
recGblRecordError(S_db_badField,(void *)pcalc,
"acalcout: init_record: Illegal OCAL field");
if (aCalcoutRecordDebug >= 10)
printf("acalcPostfix returns: %d\n", error_number);
}
db_post_events(pcalc,&pcalc->oclv,DBE_VALUE);
callbackSetCallback(checkLinksCallback, &prpvt->checkLinkCb);
callbackSetPriority(0, &prpvt->checkLinkCb);
callbackSetUser(pcalc, &prpvt->checkLinkCb);
prpvt->wd_id_1_LOCK = 0;
if (prpvt->caLinkStat == CA_LINKS_NOT_OK) {
callbackRequestDelayed(&prpvt->checkLinkCb,1.0);
prpvt->wd_id_1_LOCK = 1;
}
if (pacalcoutDSET->init_record ) {
return (*pacalcoutDSET->init_record)(pcalc);
}
return(0);
}
static void checkLinks(acalcoutRecord *pcalc)
{
DBLINK *plink;
rpvtStruct *prpvt = (rpvtStruct *)pcalc->rpvt;
int i;
int isCaLink = 0;
int isCaLinkNc = 0;
unsigned short *plinkValid;
dbAddr Addr;
dbAddr *pAddr = &Addr;
if (aCalcoutRecordDebug >= 10) printf("checkLinks() for %p\n", (void *)pcalc);
plink = &pcalc->inpa;
plinkValid = &pcalc->inav;
for (i=0; i<MAX_FIELDS+ARRAY_MAX_FIELDS+1; i++, plink++, plinkValid++) {
if (plink->type == CA_LINK) {
isCaLink = 1;
if (dbCaIsLinkConnected(plink)) {
if (*plinkValid == acalcoutINAV_EXT_NC) {
*plinkValid = acalcoutINAV_EXT;
db_post_events(pcalc,plinkValid,DBE_VALUE);
}
/* If this is the outlink, get the type of field it's connected to. If it's connected
* to a link field, and the outlink is not a CA link, complain, because this won't work.
* Also, if .WAIT, then the link must be a CA link.
*/
if (plink == &pcalc->out) {
prpvt->outlink_field_type = dbCaGetLinkDBFtype(plink);
if (aCalcoutRecordDebug >= 10)
printf("acalcout:checkLinks: outlink type = %d\n",
prpvt->outlink_field_type);
if (!dbNameToAddr(plink->value.pv_link.pvname, pAddr)) {
if ((pAddr->field_type >= DBF_INLINK) &&
(pAddr->field_type <= DBF_FWDLINK)) {
if (!(plink->value.pv_link.pvlMask & pvlOptCA)) {
printf("aCalcoutRecord(%s):checkLinks:non-CA link to link field\n",
plink->value.pv_link.pvname);
}
}
}
if (pcalc->wait && !(plink->value.pv_link.pvlMask & pvlOptCA)) {
printf("aCalcoutRecord(%s):checkLinks: Can't wait with non-CA link attribute\n",
plink->value.pv_link.pvname);
}
}
} else {
if (*plinkValid == acalcoutINAV_EXT_NC) {
isCaLinkNc = 1;
}
else if (*plinkValid == acalcoutINAV_EXT) {
*plinkValid = acalcoutINAV_EXT_NC;
db_post_events(pcalc,plinkValid,DBE_VALUE);
isCaLinkNc = 1;
}
if (plink == &pcalc->out)
prpvt->outlink_field_type = DBF_NOACCESS; /* don't know type */
}
}
}
if (isCaLinkNc)
prpvt->caLinkStat = CA_LINKS_NOT_OK;
else if (isCaLink)
prpvt->caLinkStat = CA_LINKS_ALL_OK;
else
prpvt->caLinkStat = NO_CA_LINKS;
if (!prpvt->wd_id_1_LOCK && isCaLinkNc) {
/* Schedule another CALLBACK */
prpvt->wd_id_1_LOCK = 1;
callbackRequestDelayed(&prpvt->checkLinkCb,.5);
}
}
/*----------------------------------------------------------------------*/
static long dsetRead_devAiAsyncEthernet(aiRecord *pai) {
CONTEXT *p_myContext;
int mySocket;
int myServicePortNumber;
char p_writeBuffer[BUFLEN];
char p_readBuffer[BUFLEN];
char p_myCommand[BUFLEN];
char p_myServerName[BUFLEN];
dsetLog(3, __FILE__ "[%d] -> %s(%s)\n", __LINE__, __func__,pai->name);
pai->pact=TRUE;
p_myContext = (CONTEXT *)pai->dpvt;
myServicePortNumber=p_myContext->servicePortNumber;
strncpy(p_myServerName,p_myContext->p_serverName,BUFLEN);
strncpy(p_myCommand,p_myContext->p_command,BUFLEN);
memset(p_writeBuffer,0,BUFLEN);
strncpy(p_writeBuffer,p_myCommand,BUFLEN);
strcat(p_writeBuffer, TERMINATOR);
dsetLog(7, __FILE__ "[%d] Opening socket\n", __LINE__);
mySocket=openSocket(p_myServerName, myServicePortNumber);
if (mySocket <=ERROR) {
dsetLog(1, __FILE__ "[%d] Warning: %s(%d)\n",
__LINE__, pai->name, mySocket);
dsetLog(1, __FILE__ "[%d] Warning: Couldn't connect to server\n",
__LINE__);
dsetLog(1, __FILE__ "[%d] Warning: Check IP and server port number\n",
__LINE__);
callbackRequestDelayed(p_myContext->p_callback,SLEEPTIME_CALLBACK);
return(DO_NOT_CONVERT);
}
dsetLog(7, __FILE__ "[%d] Writing on socket (%d)\n", __LINE__, mySocket);
if (writeSocket(mySocket, p_writeBuffer) <= ERROR) {
printf( __FILE__ "[%d] Error: %s\n", __LINE__, pai->name);
printf( __FILE__ "[%d] Error: Couldn't write on socket (%d)\n",
__LINE__, mySocket);
closeSocket(mySocket);
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
usleep(USLEEPTIME_WRITE);
dsetLog(7, __FILE__ "[%d] Reading from socket (%d)\n", __LINE__, mySocket);
dsetLog(7, __FILE__ "[%d] Tip: Is device turned on?\n", __LINE__);
dsetLog(7, __FILE__ "[%d] Tip: Is serial cable connected?\n", __LINE__);
memset(p_readBuffer,0,BUFLEN);
if (readSocket(mySocket, p_readBuffer, BUFLEN) <= ERROR) {
printf( __FILE__ "[%d] Error: %s\n", __LINE__, pai->name);
printf( __FILE__ "[%d] Error: Couldn't read socket (%d)\n",
__LINE__, mySocket);
closeSocket(mySocket);
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
usleep(USLEEPTIME_READ);
dsetLog(7, __FILE__ "[%d] Closing socket (%d)\n", __LINE__,mySocket);
if (closeSocket(mySocket) <= ERROR) {
printf( __FILE__ "[%d] Error: %s\n", __LINE__, pai->name);
printf( __FILE__ "[%d] Error: Couldn't close socket(%d)\n",
__LINE__, mySocket);
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
dsetLog(7, __FILE__ "[%d] %s read >%s<\n", __LINE__, pai->name, p_readBuffer);
if (strncmp(p_readBuffer, OPEN, strlen(OPEN))==0) {
dsetLog(1, __FILE__ "[%d] Warning: %s\n", __LINE__, pai->name);
dsetLog(1, __FILE__ "[%d] Warning: Channel is open\n", __LINE__);
dsetLog(1, __FILE__ "[%d] Warning: Disabling PV scan\n", __LINE__);
sleep(SLEEPTIME_WARNING);
return(SUCCESS);
}
if (strlen(p_readBuffer)>0) {
pai->val=atof(p_readBuffer);
}
dsetLog(2, __FILE__ "[%d] %f -> %s\n", __LINE__, pai->val, pai->name);
pai->dpvt=(void *)p_myContext;
pai->pact = FALSE;
pai->udf = FALSE;
dsetLog(3, __FILE__ "[%d] <- %s\n", __LINE__, __func__);
return(DO_NOT_CONVERT);
}
/*--------------------------------------------------------------------*/
static long dsetWrite_devBoSyncSoft(aliasBoRecord *psbo)
{
CONTEXT *p_myContext;
int status;
#ifdef WARMSTART_READ_FROM_FILE
char p_myWarmstartFileName[BUFLEN];
FILE *p_myFileHandle;
#endif
#ifdef DEBUG1
printf( __FILE__ "[%d] -> %s(%s)\n", __LINE__, __func__, psbo->name);
#endif
p_myContext = (CONTEXT *)psbo->dpvt;
if (p_myContext->operatingMode==NORMAL_MODE) {
#ifdef DEBUG
printf( __FILE__ "[%d] %s --(%d)-> %s\n",
__LINE__, psbo->name, psbo->val, psbo->out.value.instio.string);
#endif
status = dbPutLink(&psbo->out,DBR_USHORT,&psbo->val,1);
if ((status != SUCCESS) && (status !=DO_NOT_CONVERT)) {
printf( __FILE__ "[%d] Error(%d): Couldn't dbPutLink\n",
__LINE__, status );
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
/* Save value in /var/epics
* Used for warm boot when dol is not set
* and when omsl is not close_loop */
if ( p_myContext->warmstartMethod== WARMSTART_READ_FROM_FILE) {
sprintf(p_myWarmstartFileName, WARMSTART_FILE_PREFIX "/%s", psbo->name);
umask(0000);
p_myFileHandle=fopen(p_myWarmstartFileName,"w");
if (p_myFileHandle==NULL) {
printf( __FILE__ "[%d] Error: Couldn't open file >%s<\n",
__LINE__, p_myWarmstartFileName);
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
fprintf(p_myFileHandle,"%d",psbo->val);
fclose(p_myFileHandle);
}
} else {
switch ( p_myContext->warmstartMethod ) {
case WARMSTART_FETCH_DOL:
if (psbo->nsev >= INVALID_ALARM) {
printf(__FILE__ "[%d] Warning: Problem with link?\n", __LINE__);
printf(__FILE__ "[%d] Warning: Link may not exist\n", __LINE__);
printf(__FILE__ "[%d] Warning: Link may not be initialized yet\n",
__LINE__);
#ifdef DEBUG2
printf( __FILE__ "[%d] Fetching >%s<\n",
__LINE__, psbo->dol.value.pv_link.pvname);
#endif
callbackRequestDelayed(p_myContext->p_callback, SLEEPTIME_CALLBACK);
} else {
#ifdef DEBUG2
printf( __FILE__ "[%d] %s <-(%d|%d)-- %s\n",
__LINE__, psbo->name, psbo->val, psbo->val,
psbo->out.value.instio.string);
#endif
psbo->omsl=menuOmslsupervisory;
p_myContext->operatingMode=NORMAL_MODE;
}
break;
case WARMSTART_READ_FROM_FILE:
sprintf(p_myWarmstartFileName,WARMSTART_FILE_PREFIX "/%s", psbo->name);
p_myFileHandle=fopen(p_myWarmstartFileName,"r");
if (p_myFileHandle==NULL) {
/* File doesn't exist */
/* lopr is reset in init */
#ifdef DEBUG2
printf( __FILE__ "[%d] Warning: No file found!\n", __LINE__);
#endif
} else {
/* File exists */
int myVal;
fscanf(p_myFileHandle,"%d",&myVal);
psbo->val=(epicsEnum16)myVal;
fclose(p_myFileHandle);
}
p_myContext->operatingMode=NORMAL_MODE;
break;
case WARMSTART_NOP:
break;
default:
printf( __FILE__ "[%d] Error: Unknown warmstart method!\n", __LINE__);
sleep(SLEEPTIME_ERROR);
return(ERROR);
} /* end_of_switch */
}
#ifdef DEBUG1
printf( __FILE__ "[%d] <- %s\n", __LINE__, __func__);
#endif
return(SUCCESS);
}
static long special(DBADDR *paddr, int after)
{
calcoutRecord *prec = (calcoutRecord *)paddr->precord;
rpvtStruct *prpvt = prec->rpvt;
DBADDR dbaddr;
DBADDR *pAddr = &dbaddr;
short error_number;
int fieldIndex = dbGetFieldIndex(paddr);
int lnkIndex;
DBLINK *plink;
double *pvalue;
epicsEnum16 *plinkValid;
if (!after) return 0;
switch(fieldIndex) {
case(calcoutRecordCALC):
prec->clcv = postfix(prec->calc, prec->rpcl, &error_number);
if (prec->clcv){
recGblRecordError(S_db_badField, (void *)prec,
"calcout: special(): Illegal CALC field");
errlogPrintf("%s.CALC: %s in expression \"%s\"\n",
prec->name, calcErrorStr(error_number), prec->calc);
}
db_post_events(prec, &prec->clcv, DBE_VALUE);
return 0;
case(calcoutRecordOCAL):
prec->oclv = postfix(prec->ocal, prec->orpc, &error_number);
if (prec->dopt == calcoutDOPT_Use_OVAL && prec->oclv){
recGblRecordError(S_db_badField, (void *)prec,
"calcout: special(): Illegal OCAL field");
errlogPrintf("%s.OCAL: %s in expression \"%s\"\n",
prec->name, calcErrorStr(error_number), prec->ocal);
}
db_post_events(prec, &prec->oclv, DBE_VALUE);
return 0;
case(calcoutRecordINPA):
case(calcoutRecordINPB):
case(calcoutRecordINPC):
case(calcoutRecordINPD):
case(calcoutRecordINPE):
case(calcoutRecordINPF):
case(calcoutRecordINPG):
case(calcoutRecordINPH):
case(calcoutRecordINPI):
case(calcoutRecordINPJ):
case(calcoutRecordINPK):
case(calcoutRecordINPL):
case(calcoutRecordOUT):
lnkIndex = fieldIndex - calcoutRecordINPA;
plink = &prec->inpa + lnkIndex;
pvalue = &prec->a + lnkIndex;
plinkValid = &prec->inav + lnkIndex;
if (plink->type == CONSTANT) {
if (fieldIndex != calcoutRecordOUT) {
recGblInitConstantLink(plink, DBF_DOUBLE, pvalue);
db_post_events(prec, pvalue, DBE_VALUE);
}
*plinkValid = calcoutINAV_CON;
} else if (!dbNameToAddr(plink->value.pv_link.pvname, pAddr)) {
/* if the PV resides on this ioc */
*plinkValid = calcoutINAV_LOC;
} else {
/* pv is not on this ioc. Callback later for connection stat */
*plinkValid = calcoutINAV_EXT_NC;
/* DO_CALLBACK, if not already scheduled */
if (!prpvt->cbScheduled) {
callbackRequestDelayed(&prpvt->checkLinkCb, .5);
prpvt->cbScheduled = 1;
prpvt->caLinkStat = CA_LINKS_NOT_OK;
}
}
db_post_events(prec, plinkValid, DBE_VALUE);
return 0;
case(calcoutRecordOEVT):
prec->epvt = eventNameToHandle(prec->oevt);
return 0;
default:
recGblDbaddrError(S_db_badChoice, paddr, "calc: special");
return(S_db_badChoice);
}
}
static long process(boRecord *prec)
{
struct bodset *pdset = (struct bodset *)(prec->dset);
long status=0;
unsigned char pact=prec->pact;
if( (pdset==NULL) || (pdset->write_bo==NULL) ) {
prec->pact=TRUE;
recGblRecordError(S_dev_missingSup,(void *)prec,"write_bo");
return(S_dev_missingSup);
}
if (!prec->pact) {
if ((prec->dol.type != CONSTANT) && (prec->omsl == menuOmslclosed_loop)){
unsigned short val;
prec->pact = TRUE;
status=dbGetLink(&prec->dol,DBR_USHORT, &val,0,0);
prec->pact = FALSE;
if(status==0){
prec->val = val;
prec->udf = FALSE;
}else {
recGblSetSevr(prec,LINK_ALARM,INVALID_ALARM);
}
}
/* convert val to rval */
if ( prec->mask != 0 ) {
if(prec->val==0) prec->rval = 0;
else prec->rval = prec->mask;
} else prec->rval = (epicsUInt32)prec->val;
}
/* check for alarms */
checkAlarms(prec);
if (prec->nsev < INVALID_ALARM )
status=writeValue(prec); /* write the new value */
else {
switch (prec->ivoa) {
case (menuIvoaContinue_normally) :
status=writeValue(prec); /* write the new value */
break;
case (menuIvoaDon_t_drive_outputs) :
break;
case (menuIvoaSet_output_to_IVOV) :
if(prec->pact == FALSE){
/* convert val to rval */
prec->val=prec->ivov;
if ( prec->mask != 0 ) {
if(prec->val==0) prec->rval = 0;
else prec->rval = prec->mask;
} else prec->rval = (epicsUInt32)prec->val;
}
status=writeValue(prec); /* write the new value */
break;
default :
status=-1;
recGblRecordError(S_db_badField,(void *)prec,
"bo:process Illegal IVOA field");
}
}
/* check if device support set pact */
if ( !pact && prec->pact ) return(0);
prec->pact = TRUE;
recGblGetTimeStamp(prec);
if((prec->val==1) && (prec->high>0)){
myCallback *pcallback;
pcallback = (myCallback *)(prec->rpvt);
callbackSetPriority(prec->prio, &pcallback->callback);
callbackRequestDelayed(&pcallback->callback,(double)prec->high);
}
/* check event list */
monitor(prec);
/* process the forward scan link record */
recGblFwdLink(prec);
prec->pact=FALSE;
return(status);
}
static long dsetWrite_devAoAsyncGpib(aoRecord *pao)
{
CONTEXT *p_myContext;
char p_writeBuffer[BUFLEN];
int backoff;
#ifdef DEBUG1
printf( __FILE__ "[%d] -> %s\n", __LINE__ , __func__ );
#endif
p_myContext = (CONTEXT *)pao->dpvt;
#ifdef WARMSTART
if ((pao->nsev >= INVALID_ALARM) && (pao->omsl==menuOmslclosed_loop)) {
/* PV_LINK's value is invalid */
#ifdef DEBUG2
printf( __FILE__ "[%d] %s: Fetch >%s<\n", __LINE__, pao->name, pao->dol);
#endif
callbackRequestDelayed(p_myContext->p_callback, SLEEPTIME_CALLBACK);
return(SUCCESS);
} else {
#ifdef DEBUG2
printf(__FILE__ "[%d] Warning: Getting out of WARMSTART mode\n", __LINE__);
#endif
pao->omsl=menuOmslsupervisory;
}
#endif
if ((backoff=gpibSetLock(p_myContext->gpibBoardAddress, LOCK, pao->name))) {
#ifdef DEBUG2
printf( __FILE__ "[%d] Warning: Couldn't get lock!\n", __LINE__);
printf( __FILE__ "[%d] lockOwner = %s\n",
__LINE__,gpibGetLockOwner(p_myContext->gpibBoardAddress));
#endif
pao->pact = TRUE;
callbackRequestDelayed(p_myContext->p_callback,SLEEPTIME_CALLBACK);
return(SUCCESS);
}
#ifdef DEBUG2
printf( __FILE__ "[%d] %s: Got lock!\n", __LINE__, pao->name);
#endif
/* print and write command */
sprintf(p_writeBuffer, p_myContext->p_command, pao->val);
#ifdef DEBUG
printf( __FILE__ "[%d] Writing >%s< on %s\n",
__LINE__, p_writeBuffer, pao->name);
#endif
gpibWrite(p_myContext->gpibDeviceHandle, p_writeBuffer);
usleep(USLEEPTIME_WRITE);
if (gpibSetLock(p_myContext->gpibBoardAddress, UNLOCK, pao->name)) {
printf( __FILE__ "[%d] Error: Unable to unlock GPIB for write_ao\n",
__LINE__ );
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
return(SUCCESS);
}
static long dsetWrite_devMbboAsyncGpib(mbboRecord *pmbbo)
{
CONTEXT *p_myContext;
char p_writeBuffer[BUFLEN];
int backoff;
char p_myCommand[BUFLEN]="";
#ifdef DEBUG1
printf( __FILE__ "[%d] -> %s(%s)\n", __LINE__, __func__, pmbbo->name );
#endif
p_myContext = (CONTEXT *)pmbbo->dpvt;
#ifdef WARMSTART
if((pmbbo->nsev >= INVALID_ALARM) && (pmbbo->omsl==menuOmslclosed_loop)) {
#ifdef DEBUG2
printf(__FILE__ "[%d] %s: Fetch >%s<\n", __LINE__, pmbbo->name, pmbbo->dol);
#endif
callbackRequestDelayed(p_myContext->p_callback, SLEEPTIME_CALLBACK);
return(SUCCESS);
} else {
#ifdef DEBUG2
printf( __FILE__ "[%d] Warning: Getting out of WARMSTART mode\n", __LINE__);
#endif
pmbbo->omsl=menuOmslsupervisory;
}
#endif
if ((backoff=gpibSetLock(p_myContext->gpibBoardAddress, LOCK, pmbbo->name))) {
#ifdef DEBUG
printf( __FILE__ "[%d] Warning: Unable to get lock\n", __LINE__);
#endif
pmbbo->pact = TRUE;
callbackRequestDelayed(p_myContext->p_callback,SLEEPTIME_CALLBACK);
return(SUCCESS);
}
if (getCommand(pmbbo,p_myCommand)<= ERROR ) {
printf( __FILE__ "[%d] Error: Couldn't find the command\n", __LINE__ );
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
#ifdef DEBUG2
printf( __FILE__ "[%d] p_myCommand = >%s<\n", __LINE__, p_myCommand);
#endif
strcpy(p_writeBuffer,p_myCommand);
#ifdef DEBUG
printf( __FILE__ "[%d] Writing >%s< on %s\n",
__LINE__, p_writeBuffer, pmbbo->name);
#endif
gpibWrite(p_myContext->gpibDeviceHandle, p_writeBuffer);
usleep(USLEEPTIME_WRITE);
if (gpibSetLock(p_myContext->gpibBoardAddress, UNLOCK, pmbbo->name)) {
printf( __FILE__ "[%d] Error: Couldn't unlock GPIB\n", __LINE__ );
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
#ifdef DEBUG1
printf( __FILE__ "[%d] <- %s\n", __LINE__, __func__);
#endif
return(SUCCESS);
}
/* ---------------------------------------------------------------------- */
static long dsetRead_devAiAsyncGpib(aiRecord *pai) {
char p_readBuffer[BUFLEN]; /* The read buffer */
int gpibBoardAddress; /* Gpib board number */
char *p_gpibCommand; /* Command to send to device for reading*/
int gpibDeviceHandle; /* Handle to identify a gpib connection */
CALLBACK *p_myCallback;
CONTEXT *p_myContext;
dsetLog(3, __FILE__ "[%d] -> %s(%s)\n", __LINE__, __func__, pai->name);
p_myContext=(CONTEXT *)pai->dpvt;
gpibBoardAddress=p_myContext->gpibBoardAddress;
p_gpibCommand=p_myContext->p_gpibCommand;
p_myCallback=p_myContext->p_callback;
gpibDeviceHandle=p_myContext->gpibDeviceHandle;
dsetLog(7, __FILE__ "[%d] gpibDeviceHandle= %d\n",
__LINE__ , gpibDeviceHandle);
if (pai->pact==TRUE) {
/* Make sure that no other device is */
/* communicating on the gpib */
/* Check has lock of GPIB or take it if */
/* available */
dsetLog(7, __FILE__ "[%d] %s -- gpibSetLock\n", __LINE__, __func__ );
dsetLog(7, __FILE__ "[%d] lockOwner = %s\n",
__LINE__, gpibGetLockOwner(gpibBoardAddress));
if (gpibSetLock(gpibBoardAddress, LOCK, pai->name)) {
dsetLog(7, __FILE__ "[%d] Another device (%s) control the lock\n",
__LINE__, gpibGetLockOwner(gpibBoardAddress));
dsetLog(7, __FILE__ "[%d] Rescheduling ...\n", __LINE__);
/* Mark this device as busy. */
pai->pact=TRUE;
/* Reschedule a callback */
callbackRequestDelayed(p_myCallback,SLEEPTIME_CALLBACK);
} /* end_if */
/* Send request to instrument */
dsetLog(7, __FILE__ "[%d] lockOwner = %s\n",
__LINE__, gpibGetLockOwner(gpibBoardAddress));
dsetLog(7, __FILE__ "[%d] gpibWrite >%s<\n", __LINE__, p_gpibCommand);
gpibWrite(gpibDeviceHandle,p_gpibCommand);
/* Read instrument's reply (if any) */
gpibRead(gpibDeviceHandle,p_readBuffer,BUFLEN);
/* Release lock on GPIB so that other */
/* device on GPIB can talk */
gpibSetLock(gpibBoardAddress,UNLOCK,pai->name);
/* Store the value in deviceRecord */
/* NOTE: if buffer is empty (no response*/
/* from the device) then pai->val */
/* will be equal to zero. */
/* sscanf(p_readBuffer,"%lf",&pai->val); */
pai->val=atof(p_readBuffer);
/* Value stored is meaningful/defined */
pai->udf = FALSE;
/* A few debugging messages... */
dsetLog(7, __FILE__ "[%d] gpibRead >%s< (p_readBuffer)\n",
__LINE__, p_readBuffer);
dsetLog(2, __FILE__ "[%d] %f -> %s\n", __LINE__, pai->val, pai->name);
dsetLog(3, __FILE__ "[%d] <- %s \n", __LINE__, __func__ );
return(DO_NOT_CONVERT);
} /* end_if */
/* pai->pact is NULL */
/* So now start asynchronous processing */
dsetLog(7, __FILE__ "[%d] New read request for : %s\n",__LINE__, pai->name);
dsetLog(7, __FILE__ "[%d] Schedule callback fct in [%d sec]\n"
, __LINE__, SLEEPTIME_CALLBACK);
/* The deviceRecord is now busy */
pai->pact=TRUE;
/* Run the callback fct in disv seconds */
callbackRequestDelayed(p_myCallback, SLEEPTIME_CALLBACK);
dsetLog(3, __FILE__ "[%d] <- %s\n", __LINE__, __func__ );
return(DO_NOT_CONVERT);
}
/*----------------------------------------------------------------------*/
static long dsetWrite_devMbboAsyncGpib(mbboRecord *pmbbo) {
char p_writeBuffer[BUFLEN];
int myGpibBoardAddress;
int myGpibDeviceHandle;
CONTEXT *p_myContext;
CALLBACK *p_myCallback;
dsetLog(3,__FILE__ "[%d] -> %s(%s)\n", __LINE__, __func__,pmbbo->name);
pmbbo->pact = TRUE;
p_myContext = (CONTEXT *)pmbbo->dpvt;
myGpibBoardAddress=p_myContext->gpibBoardAddress;
myGpibDeviceHandle=p_myContext->gpibDeviceHandle;
p_myCallback=p_myContext->p_callback;
if (gpibSetLock(myGpibBoardAddress,LOCK,pmbbo->name)!=SUCCESS) {
dsetLog(7,__FILE__ "[%d] Warning: Couldn't lock GPIB(%s)\n",
__LINE__, pmbbo->name );
dsetLog(7,__FILE__ "[%d] Warning: lockOwner = %s\n",
__LINE__, gpibGetLockOwner(myGpibBoardAddress));
callbackRequestDelayed(p_myCallback,SLEEPTIME_CALLBACK);
return(DO_NOT_CONVERT);
}
strcpy(p_writeBuffer,PREFIX_CMD);
switch(pmbbo->val) {
case 0:
strcat(p_writeBuffer,pmbbo->zrst);
break;
case 1:
strcat(p_writeBuffer,pmbbo->onst);
break;
case 2:
strcat(p_writeBuffer,pmbbo->twst);
break;
case 3:
strcat(p_writeBuffer,pmbbo->thst);
break;
case 4:
strcat(p_writeBuffer,pmbbo->frst);
break;
case 5:
strcat(p_writeBuffer,pmbbo->fvst);
break;
case 6:
strcat(p_writeBuffer,pmbbo->sxst);
break;
case 7:
strcat(p_writeBuffer,pmbbo->svst);
break;
case 8:
strcat(p_writeBuffer,pmbbo->eist);
break;
default:
dsetLog(1, __FILE__ "[%d] Error: pmbbo->val is invalid\n",
__LINE__, pmbbo->name);
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
strcat(p_writeBuffer,SUFFIX_CMD);
dsetLog(7,__FILE__ "[%d] Writing >%s<\n", __LINE__, p_writeBuffer);
gpibWrite(myGpibDeviceHandle,p_writeBuffer);
usleep(USLEEPTIME_WRITE);
if (gpibSetLock(myGpibBoardAddress,UNLOCK,pmbbo->name)!=SUCCESS) {
dsetLog(1,__FILE__ "[%d] Error: Couldn't unlock GPIB(%s)\n",
__LINE__, pmbbo->name );
dsetLog(1,__FILE__ "[%d] Error: lockOwner = %s\n",
__LINE__, gpibGetLockOwner(myGpibBoardAddress));
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
pmbbo->pact= FALSE;
dsetLog(3, __FILE__ "[%d] <- %s\n", __LINE__, __func__);
return(SUCCESS);
}
/*----------------------------------------------------------------------*/
static long dsetRead_devAiAsyncSerial(aiRecord *pai) {
CONTEXT *p_myContext;
char p_writeBuffer[BUFLEN];
char p_readBuffer[BUFLEN];
int myPortNumber;
char p_myCommand[BUFLEN];
#ifdef DEBUG1
printf( __FILE__ "[%d] -> %s\n", __LINE__, __func__);
#endif
p_myContext = (CONTEXT *)pai->dpvt;
myPortNumber=p_myContext->portNumber;
strcpy(p_myCommand,p_myContext->p_command);
/* Get the lock or callback */
if (lockSerialPort2(myPortNumber,LOCK, pai->name)<=ERROR) {
#ifdef DEBUG2
printf( __FILE__ "[%d] Error: Couldn't lock %s\n",
__LINE__, getSerialPortName2(myPortNumber));
printf( __FILE__ "[%d] lockOwner is %s\n",
__LINE__, getSerialPortLockOwner2(myPortNumber));
#endif
pai->pact=TRUE;
callbackRequestDelayed(p_myContext->p_callback,SLEEPTIME_CALLBACK);
return(NO_CONVERSION);
} /* end_of_if */
/* construct request for the pressure */
/* strcat(p_writeBuffer,"P");
sprintf(str,"%d",p_myContext->secondaryAddress); */
strcpy(p_writeBuffer,p_myCommand);
strcat(p_writeBuffer,TERMINATOR);
#ifdef DEBUG2
printf( __FILE__ "[%d] Writing >%s< for %s on %s\n",
__LINE__, p_writeBuffer,
pai->name, getSerialPortName2(myPortNumber));
#endif
if (writeSerialPort2(myPortNumber, p_writeBuffer)<= ERROR) {
printf( __FILE__ "[%d] Error: Couldn't write >%s< to %s\n",
__LINE__, p_writeBuffer, pai->name);
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
usleep(USLEEPTIME_WRITE);
if (readSerialPort2(myPortNumber, p_readBuffer,BUFLEN)<=ERROR) {
printf( __FILE__ "[%d] Error: Couldn't Read %s\n",
__LINE__, getSerialPortName2(myPortNumber));
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
#ifdef DEBUG2
printf( __FILE__ "[%d] %s read >%s<\n", __LINE__, pai->name, p_readBuffer);
#endif
usleep(USLEEPTIME_READ);
if (lockSerialPort2(myPortNumber, UNLOCK, pai->name) <=ERROR) {
printf( __FILE__ "[%d] Error: Couldn't unlock %s\n",
__LINE__, getSerialPortName2(myPortNumber));
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
if ( (strncmp(p_readBuffer,"HV_OFF!",7)==0)
|| (strncmp(p_readBuffer,"WAIT",4)==0)
|| (strncmp(p_readBuffer,"CONTROL!",8)==0)
|| (strncmp(p_readBuffer,"PROTECT!",8)==0)
|| (strncmp(p_readBuffer,"NOGAUGE!",8)==0)) {
printf( __FILE__ "[%d] Error: Check the probe\n", __LINE__);
printf( __FILE__ "[%d] Error: Check the hardware\n", __LINE__);
pai->udf = TRUE;
} else {
pai->val = atof(p_readBuffer);
pai->udf = FALSE;
}
pai->pact = FALSE;
#ifdef DEBUG2
printf( __FILE__ "[%d] <- %s\n", __LINE__, __func__);
#endif
return(NO_CONVERSION);
}
