/* -------------------------------------------------------------------- */ 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); }