static long process(subRecord *prec)
{
long status = 0;
int pact = prec->pact;
if (!pact) {
prec->pact = TRUE;
status = fetch_values(prec);
prec->pact = FALSE;
}
if (status == 0) status = do_sub(prec);
/* Is subroutine asynchronous? */
if (!pact && prec->pact) return 0;
prec->pact = TRUE;
/* Asynchronous function (documented API!) */
if (status == 1) return 0;
recGblGetTimeStamp(prec);
/* check for alarms */
checkAlarms(prec);
/* publish changes */
monitor(prec);
recGblFwdLink(prec);
prec->pact = FALSE;
return 0;
}
static long process(subArrayRecord *prec)
{
struct sadset *pdset = (struct sadset *)(prec->dset);
long status;
unsigned char pact=prec->pact;
if ((pdset==NULL) || (pdset->read_sa==NULL)) {
prec->pact=TRUE;
recGblRecordError(S_dev_missingSup, (void *)prec, "read_sa");
return S_dev_missingSup;
}
if (pact && prec->busy) return 0;
status=readValue(prec); /* read the new value */
if (!pact && prec->pact) return 0;
prec->pact = TRUE;
recGblGetTimeStamp(prec);
prec->udf = !!status; /* 0 or 1 */
if (status)
recGblSetSevr(prec, UDF_ALARM, INVALID_ALARM);
monitor(prec);
/* process the forward scan link record */
recGblFwdLink(prec);
prec->pact=FALSE;
return 0;
}
static long process(mbbiDirectRecord *prec)
{
struct mbbidset *pdset = (struct mbbidset *)(prec->dset);
long status;
unsigned char pact=prec->pact;
if( (pdset==NULL) || (pdset->read_mbbi==NULL) ) {
prec->pact=TRUE;
recGblRecordError(S_dev_missingSup,(void *)prec,"read_mbbi");
return(S_dev_missingSup);
}
status=readValue(prec); /* read the new value */
/* check if device support set pact */
if ( !pact && prec->pact ) return(0);
prec->pact = TRUE;
recGblGetTimeStamp(prec);
if(status==0) { /* convert the value */
epicsUInt32 rval = prec->rval;
if(prec->shft>0) rval >>= prec->shft;
prec->val = (unsigned short)rval;
prec->udf=FALSE;
}
static long process(waveformRecord *prec)
{
struct wfdset *pdset = (struct wfdset *)(prec->dset);
long status;
unsigned char pact=prec->pact;
if ((pdset==NULL) || (pdset->read_wf==NULL)) {
prec->pact=TRUE;
recGblRecordError(S_dev_missingSup, (void *)prec, "read_wf");
return S_dev_missingSup;
}
if (pact && prec->busy) return 0;
status=readValue(prec); /* read the new value */
if (!pact && prec->pact) return 0;
prec->pact = TRUE;
prec->udf = FALSE;
recGblGetTimeStamp(prec);
monitor(prec);
/* process the forward scan link record */
recGblFwdLink(prec);
prec->pact=FALSE;
return 0;
}
static long process(void *rec_p)
{
rfmRecord *precord = (rfmRecord*)rec_p;
rfmdset *pdset = (rfmdset*)precord->dset;
long status = OK;
unsigned char pact = precord->pact;
if((pdset==NULL) || (pdset->read_rfm==NULL)) {
precord->pact = TRUE; /* if DSET is not found, record will be blocked */
recGblRecordError((status=S_dev_missingSup),precord,"read_rfm");
return status;
}
/* pact must not be set ture until read_rfm completes */
status = (*pdset->read_rfm)(precord); /* read status of rfm moule */
/* return if begining of asynch processing */
if(!pact && precord->pact) return status;
precord->pact = TRUE;
recGblGetTimeStamp(precord);
/* check alarm */
alarm(precord);
/* check monitor */
monitor(precord);
/* processing the forward scan link record */
recGblFwdLink(precord);
/* clear PACT field */
precord->pact = FALSE;
return status;
}
static long process(stringinRecord *prec)
{
struct stringindset *pdset = (struct stringindset *)(prec->dset);
long status;
unsigned char pact=prec->pact;
if( (pdset==NULL) || (pdset->read_stringin==NULL) ) {
prec->pact=TRUE;
recGblRecordError(S_dev_missingSup,(void *)prec,"read_stringin");
return(S_dev_missingSup);
}
status=readValue(prec); /* read the new value */
/* check if device support set pact */
if ( !pact && prec->pact ) return(0);
prec->pact = TRUE;
recGblGetTimeStamp(prec);
/* check event list */
monitor(prec);
/* process the forward scan link record */
recGblFwdLink(prec);
prec->pact=FALSE;
return(status);
}
static long process(epidRecord *pepid)
{
struct epidDSET *pdset = (struct epidDSET *)(pepid->dset);
long status;
int pact=pepid->pact;
if (!pact) { /* If this is not a callback from device support */
/* fetch the setpoint */
if(pepid->smsl == menuOmslclosed_loop) {
status = dbGetLink(&(pepid->stpl),DBR_DOUBLE, &(pepid->val),0,0);
if (RTN_SUCCESS(status)) pepid->udf=FALSE;
}
if (pepid->udf == TRUE ) {
#if LT_EPICSBASE(3,15,0,2)
recGblSetSevr(pepid,UDF_ALARM,INVALID_ALARM);
#else
recGblSetSevr(pepid,UDF_ALARM,pepid->udfs);
#endif
return(0);
}
}
status = (*pdset->do_pid)(pepid);
/* See if device support set pact=true, meaning it will call us back */
if (!pact && pepid->pact) return(0);
pepid->pact = TRUE;
recGblGetTimeStamp(pepid);
checkAlarms(pepid);
monitor(pepid);
recGblFwdLink(pepid);
pepid->pact=FALSE;
return(status);
}
/*****************************************************************************
*
* This is called to "Process" the record.
*
* When we process a record for the vs, we write out the new values for any
* field whose value(s) might have changed, then read back the operating status
* from the machine.
*
******************************************************************************/
static long process(void *precord)
{
vsRecord *pvs = (vsRecord *)precord;
vsdset *pdset = (vsdset *)(pvs->dset);
long status;
unsigned char pact = pvs->pact;
if ((pdset == NULL) || (pdset->readWrite_vs == NULL)) {
pvs->pact = TRUE;
recGblRecordError(S_dev_missingSup, (void *) pvs, "readWrite_vs");
return (S_dev_missingSup);
}
/*** call device support for processing ***/
status = (*pdset->readWrite_vs) (pvs);
/*** Device support is in asynchronous mode, let it finish ***/
if (!pact && pvs->pact)
return (0);
pvs->pact = TRUE;
recGblGetTimeStamp(pvs);
/*** check for alarms ***/
checkAlarms(pvs);
/*** check event list ***/
monitor(pvs);
/*** process the forward scan link record ***/
recGblFwdLink(pvs);
pvs->chgc = 0;
pvs->pact = FALSE;
return (status);
}
static long process(void *precord)
{
ifstatRecord *prec = (ifstatRecord *)precord;
ifstatdset *pdset = (ifstatdset *)(prec->dset);
long status;
unsigned char pact=prec->pact;
if( (pdset==NULL) || (pdset->read_ifstat==NULL) ) {
prec->pact=TRUE;
recGblRecordError(S_dev_missingSup,(void *)prec,"read_ifstat");
return(S_dev_missingSup);
}
/* pact must not be set until after calling device support */
status=(*pdset->read_ifstat)(prec);
/* check if device support set pact */
if ( !pact && prec->pact ) return(0);
prec->pact = TRUE;
recGblGetTimeStamp(prec);
/* check for alarms */
checkAlarms(prec);
/* check event list */
monitor(prec);
/* process the forward scan link record */
recGblFwdLink(prec);
prec->pact=FALSE;
return(status);
}
static long process(void *precord)
{
aiRecord *prec = (aiRecord *)precord;
aidset *pdset = (aidset *)(prec->dset);
long status;
unsigned char pact=prec->pact;
if( (pdset==NULL) || (pdset->read_ai==NULL) ) {
prec->pact=TRUE;
recGblRecordError(S_dev_missingSup,(void *)prec,"read_ai");
return(S_dev_missingSup);
}
status=readValue(prec); /* read the new value */
/* check if device support set pact */
if ( !pact && prec->pact ) return(0);
prec->pact = TRUE;
recGblGetTimeStamp(prec);
if (status==0) convert(prec);
else if (status==2) status=0;
/* check for alarms */
checkAlarms(prec);
/* check event list */
monitor(prec);
/* process the forward scan link record */
recGblFwdLink(prec);
prec->init=FALSE;
prec->pact=FALSE;
return(status);
}
static long process(eventRecord *prec)
{
struct eventdset *pdset = (struct eventdset *)(prec->dset);
long status=0;
unsigned char pact=prec->pact;
if((pdset!=NULL) && (pdset->number >= 5) && pdset->read_event )
status=readValue(prec); /* read the new value */
/* check if device support set pact */
if ( !pact && prec->pact ) return(0);
prec->pact = TRUE;
if(prec->val>0) post_event((int)prec->val);
recGblGetTimeStamp(prec);
/* check event list */
monitor(prec);
/* process the forward scan link record */
recGblFwdLink(prec);
prec->pact=FALSE;
return(status);
}
static long process(xRecord *prec)
{
prec->pact = TRUE;
recGblGetTimeStamp(prec);
recGblFwdLink(prec);
prec->pact = FALSE;
return 0;
}
static long process(fanoutRecord *prec)
{
struct link *plink;
unsigned short state;
short i;
unsigned short monitor_mask;
prec->pact = TRUE;
/* fetch link selection */
dbGetLink(&(prec->sell),DBR_USHORT,&(prec->seln),0,0);
switch (prec->selm){
case (fanoutSELM_All):
plink=&(prec->lnk1);
state=prec->seln;
for ( i=0; i<6; i++, state>>=1, plink++) {
if(plink->type!=CONSTANT) dbScanFwdLink(plink);
}
break;
case (fanoutSELM_Specified):
if(prec->seln>6) {
recGblSetSevr(prec,SOFT_ALARM,INVALID_ALARM);
break;
}
if(prec->seln==0) {
break;
}
plink=&(prec->lnk1);
plink += (prec->seln-1); dbScanFwdLink(plink);
break;
case (fanoutSELM_Mask):
if(prec->seln==0) {
break;
}
if(prec->seln>63 ) {
recGblSetSevr(prec,SOFT_ALARM,INVALID_ALARM);
break;
}
plink=&(prec->lnk1);
state=prec->seln;
for ( i=0; i<6; i++, state>>=1, plink++) {
if(state & 1 && plink->type!=CONSTANT) dbScanFwdLink(plink);
}
break;
default:
recGblSetSevr(prec,SOFT_ALARM,INVALID_ALARM);
}
prec->udf=FALSE;
recGblGetTimeStamp(prec);
/* check monitors*/
/* get previous stat and sevr and new stat and sevr*/
monitor_mask = recGblResetAlarms(prec);
/* process the forward scan link record */
recGblFwdLink(prec);
prec->pact=FALSE;
return(0);
}
static long process(stringoutRecord *prec)
{
struct stringoutdset *pdset = (struct stringoutdset *)(prec->dset);
long status=0;
unsigned char pact=prec->pact;
if( (pdset==NULL) || (pdset->write_stringout==NULL) ) {
prec->pact=TRUE;
recGblRecordError(S_dev_missingSup,(void *)prec,"write_stringout");
return(S_dev_missingSup);
}
if (!prec->pact
&& (prec->dol.type != CONSTANT)
&& (prec->omsl == menuOmslclosed_loop)) {
status = dbGetLink(&(prec->dol),
DBR_STRING,prec->val,0,0);
if(prec->dol.type!=CONSTANT && RTN_SUCCESS(status)) prec->udf=FALSE;
}
if(prec->udf == TRUE ){
recGblSetSevr(prec,UDF_ALARM,INVALID_ALARM);
}
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){
strcpy(prec->val,prec->ivov);
}
status=writeValue(prec); /* write the new value */
break;
default :
status=-1;
recGblRecordError(S_db_badField,(void *)prec,
"stringout:process Illegal IVOA field");
}
}
/* check if device support set pact */
if ( !pact && prec->pact ) return(0);
prec->pact = TRUE;
recGblGetTimeStamp(prec);
monitor(prec);
recGblFwdLink(prec);
prec->pact=FALSE;
return(status);
}
static long process(permissiveRecord *prec)
{
prec->pact=TRUE;
prec->udf=FALSE;
recGblGetTimeStamp(prec);
monitor(prec);
recGblFwdLink(prec);
prec->pact=FALSE;
return(0);
}
static long process(compressRecord *prec)
{
long status=0;
long nelements = 0;
int alg = prec->alg;
prec->pact = TRUE;
if(!dbIsLinkConnected(&prec->inp)
|| dbGetNelements(&prec->inp,&nelements)
|| nelements<=0) {
recGblSetSevr(prec,LINK_ALARM,INVALID_ALARM);
} else {
if(!prec->wptr || nelements!=prec->inpn) {
if(prec->wptr) {
free(prec->wptr);
reset(prec);
}
prec->wptr = (double *)dbCalloc(nelements,sizeof(double));
prec->inpn = nelements;
}
status = dbGetLink(&prec->inp,DBF_DOUBLE,prec->wptr,0,&nelements);
if(status || nelements<=0) {
recGblSetSevr(prec,LINK_ALARM,INVALID_ALARM);
status = 0;
} else {
if(alg==compressALG_Average) {
status = array_average(prec,prec->wptr,nelements);
} else if(alg==compressALG_Circular_Buffer) {
(void)put_value(prec,prec->wptr,nelements);
status = 0;
} else if(nelements>1) {
status = compress_array(prec,prec->wptr,nelements);
}else if(nelements==1){
status = compress_scalar(prec,prec->wptr);
}else status=1;
}
}
/* check event list */
if(status!=1) {
prec->udf=FALSE;
recGblGetTimeStamp(prec);
monitor(prec);
/* process the forward scan link record */
recGblFwdLink(prec);
}
prec->pact=FALSE;
return(0);
}
/* ---------------------------------------------------------------------- */
static long dsetRead_devSiSyncTimestamp (struct stringinRecord *psi) {
CONTEXT *p_myContext;
char p_myDateFormat[BUFLEN];
int formattedStringLength;
char p_myWarmstartFilename[BUFLEN];
FILE *p_myFileHandle;
int myLogMark;
dsetLog(3, __FILE__ "[%d] -> %s(%s)\n", __LINE__, __func__, psi->name);
p_myContext = (CONTEXT *)psi->dpvt;
strncpy(p_myDateFormat, p_myContext->p_dateFormat, BUFLEN);
myLogMark=p_myContext->logMark;
recGblGetTimeStamp(psi);
formattedStringLength=
epicsTimeToStrftime(psi->val, BUFLEN, p_myDateFormat, &psi->time);
if (formattedStringLength >= BUFLEN) {
psi->udf = 1;
recGblSetSevr(psi,UDF_ALARM,INVALID_ALARM);
dsetLog(3, __FILE__ "[%d] Error: String is too long!\n", __LINE__);
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
psi->udf = 0;
sprintf(p_myWarmstartFilename, WARMSTART_FILE_PREFIX "/%s",psi->name);
p_myFileHandle=fopen(p_myWarmstartFilename, "w");
if (p_myFileHandle==NULL) {
dsetLog(1, __FILE__ "[%d] Error: %s\n", __LINE__);
dsetLog(1, __FILE__ "[%d] Error: Couldn't create/write %s\n",
__LINE__, p_myWarmstartFilename);
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
fprintf(p_myFileHandle, "%s",psi->val);
fclose(p_myFileHandle);
if (myLogMark!=0) {
fprintf( stdout, "%s\n", psi->val);
}
dsetLog(3, __FILE__ "[%d] <- %s\n", __LINE__, __func__);
return(SUCCESS);
}
static long process(void *precord)
{
ushortRecord *pushort = (ushortRecord *)precord;
pushort->pact = TRUE;
recGblGetTimeStamp(pushort);
/* check for alarms */
checkAlarms(pushort);
/* check event list */
monitor(pushort);
/* process the forward scan link record */
recGblFwdLink(pushort);
pushort->pact=FALSE;
return(0);
}
LOCAL void monitor(ab1771IXRecord *precord)
{
unsigned short monitor_mask;
unsigned short mask;
recordPvt *precordPvt = (recordPvt *)precord->dpvt;
int signal;
channelFields *pcf;
monitor_mask = recGblResetAlarms(precord);
recGblGetTimeStamp(precord);
mask = monitor_mask;
if(strlen(precord->val)==0) setValMsg(precord,0);
if(precordPvt->newValMsg) mask |= DBE_VALUE|DBE_LOG;
if(mask) db_post_events(precord,precord->val,mask);
mask = monitor_mask;
if(precordPvt->newInMsg) mask |= DBE_VALUE|DBE_LOG;
if(mask) {
db_post_events(precord,precord->inpm,mask);
}
mask = monitor_mask;
if(precordPvt->newOutMsg) mask |= DBE_VALUE|DBE_LOG;
if(mask) {
db_post_events(precord,precord->outm,mask);
}
if((precordPvt->newInMsg)
|| (precord->loca && (precordPvt->prevStatus!=precordPvt->status))) {
for(signal=0, pcf = (channelFields *)&precord->sta1;
signal<NUM_CHANS; signal++, pcf++) {
mask = monitor_mask |= DBE_VALUE|DBE_LOG;
if(precordPvt->newInMsg) {
db_post_events(precord,&pcf->raw,mask);
db_post_events(precord,&pcf->sta,mask);
}
if(precordPvt->ioscanpvtInited[signal])
scanIoRequest(precordPvt->ioscanpvt[signal]);
}
monitor_mask |= DBE_VALUE|DBE_LOG;
db_post_events(precord,&precord->cjt,monitor_mask);
}
precordPvt->prevStatus = precordPvt->status;
precordPvt->newValMsg = FALSE;
precordPvt->newInMsg = FALSE;
precordPvt->newOutMsg = FALSE;
return;
}
/*****************************************************************************
*
* Link-group processing function.
*
* if the input link is not a constant
* call dbGetLink() to get the link value
* else
* get the value from the DOV field
* call dbPutLink() to forward the value to destination location
* call processNextLink() to schedule the processing of the next link-group
*
* NOTE:
* dbScanLock is NOT held for prec when this function is called!!
*
******************************************************************************/
static void processCallback(CALLBACK *arg)
{
callbackSeq *pcb;
seqRecord *prec;
double myDouble;
callbackGetUser(pcb,arg);
prec = pcb->pseqRecord;
dbScanLock((struct dbCommon *)prec);
if (seqRecDebug > 5)
printf("processCallback(%s) processing field index %d\n", prec->name, pcb->index+1);
/* Save the old value */
myDouble = pcb->plinks[pcb->index]->dov;
dbGetLink(&(pcb->plinks[pcb->index]->dol), DBR_DOUBLE,
&(pcb->plinks[pcb->index]->dov),0,0);
recGblGetTimeStamp(prec);
/* Dump the value to the destination field */
dbPutLink(&(pcb->plinks[pcb->index]->lnk), DBR_DOUBLE,
&(pcb->plinks[pcb->index]->dov),1);
if (myDouble != pcb->plinks[pcb->index]->dov)
{
if (seqRecDebug > 0)
printf("link %d changed from %f to %f\n", pcb->index, myDouble, pcb->plinks[pcb->index]->dov);
db_post_events(prec, &pcb->plinks[pcb->index]->dov, DBE_VALUE|DBE_LOG);
}
else
{
if (seqRecDebug > 0)
printf("link %d not changed... %f\n", pcb->index, pcb->plinks[pcb->index]->dov);
}
/* Find the 'next' link-seq that is ready for processing. */
pcb->index++;
processNextLink(prec);
dbScanUnlock((struct dbCommon *)prec);
return;
}
static long process(selRecord *prec)
{
prec->pact = TRUE;
if ( RTN_SUCCESS(fetch_values(prec)) ) {
do_sel(prec);
}
recGblGetTimeStamp(prec);
/* check for alarms */
checkAlarms(prec);
/* check event list */
monitor(prec);
/* process the forward scan link record */
recGblFwdLink(prec);
prec->pact=FALSE;
return(0);
}
static long process(mbbiRecord *prec)
{
struct mbbidset *pdset = (struct mbbidset *)(prec->dset);
long status;
unsigned char pact=prec->pact;
if( (pdset==NULL) || (pdset->read_mbbi==NULL) ) {
prec->pact=TRUE;
recGblRecordError(S_dev_missingSup,(void *)prec,"read_mbbi");
return(S_dev_missingSup);
}
status=readValue(prec); /* read the new value */
/* check if device support set pact */
if ( !pact && prec->pact ) return(0);
prec->pact = TRUE;
recGblGetTimeStamp(prec);
if(status==0) { /* convert the value */
epicsUInt32 *pstate_values;
short i;
epicsUInt32 rval = prec->rval;
prec->udf = FALSE;
if(prec->shft>0) rval >>= prec->shft;
if (prec->sdef){
pstate_values = &(prec->zrvl);
prec->val = 65535; /* initalize to unknown state*/
for (i = 0; i < 16; i++){
if (*pstate_values == rval){
prec->val = i;
break;
}
pstate_values++;
}
}else{
/* the raw value is the desired value */
prec->val = (unsigned short)rval;
}
}
/*****************************************************************************
*
* Finish record processing by posting any events and processing forward links.
*
* NOTE:
* dbScanLock is already held for prec before this function is called.
*
******************************************************************************/
static long asyncFinish(seqRecord *prec)
{
unsigned short MonitorMask;
if (seqRecDebug > 5)
printf("asyncFinish(%s) completing processing\n", prec->name);
prec->udf = FALSE;
recGblGetTimeStamp(prec);
MonitorMask = recGblResetAlarms(prec);
if (MonitorMask)
db_post_events(prec, &prec->val, MonitorMask);
/* process the forward scan link record */
recGblFwdLink(prec);
prec->pact = FALSE;
return(0);
}
static long process(aSubRecord *prec)
{
int pact = prec->pact;
long status = 0;
if (!pact) {
prec->pact = TRUE;
status = fetch_values(prec);
prec->pact = FALSE;
}
if (!status) {
status = do_sub(prec);
prec->val = status;
}
if (!pact && prec->pact)
return 0;
prec->pact = TRUE;
/* Push the output link values */
if (!status) {
int i;
for (i = 0; i < NUM_ARGS; i++)
dbPutLink(&(&prec->outa)[i], (&prec->ftva)[i], (&prec->vala)[i],
(&prec->neva)[i]);
}
recGblGetTimeStamp(prec);
monitor(prec);
recGblFwdLink(prec);
prec->pact = FALSE;
return 0;
}
void *ioc_alive_send(void *data)
{
aliveRecord *prec = (aliveRecord *) data;
struct rpvtStruct *prpvt;
// 200 is fine, ioc name length is limited to 100 in init
char buffer[200];
uint32_t message;
epicsTimeStamp now;
char *p;
int len;
prpvt = prec->rpvt;
epicsThreadSleep( 0.1);
while(1)
{
if( prpvt->fault_flag || !prpvt->ready_flag ||
(prec->hrtbt == aliveHRTBT_OFF ) )
{
epicsThreadSleep( (double) prec->hprd);
continue;
}
prec->val++;
p = buffer;
// magic signature, to help weed out probes
message = htonl(prec->hmag);
*((uint32_t *) p) = message;
p += 4;
// protocol version
message = htons(PROTOCOL_VERSION);
*((uint16_t *) p) = message;
p += 2;
// incarnation
message = htonl(prpvt->incarnation);
*((uint32_t *) p) = message;
p += 4;
// current time
epicsTimeGetCurrent(&now);
message = htonl( (uint32_t) now.secPastEpoch);
*((uint32_t *) p) = message;
p += 4;
// heartbeat
message = htonl(prec->val);
*((uint32_t *) p) = message;
p += 4;
// period
message = htons( prec->hprd);
*((uint16_t *) p) = message;
p += 2;
// flags
message = htons( prpvt->flags);
*((uint16_t *) p) = message;
p += 2;
// return port
message = htons( prec->iport);
*((uint16_t *) p) = message;
p += 2;
// user message
message = htonl(prec->msg);
*((uint32_t *) p) = message;
p += 4;
len = sprintf( p, "%s", prpvt->ioc_name);
// include trailing zero
p += (len + 1);
if( sendto( prpvt->socket, buffer, (int) (p - buffer), 0,
(struct sockaddr *) &(prpvt->h_addr),
sizeof(struct sockaddr_in)) == -1)
{
errlogSevPrintf( errlogMajor, "alive record: Can't send UDP packet "
"(sendto errno=%d).\n", errno);
}
recGblGetTimeStamp(prec);
/* check for alarms */
checkAlarms(prec);
/* check event list */
monitor(prec);
epicsThreadSleep( (double) prec->hprd);
}
return NULL;
}
static long process(acalcoutRecord *pcalc)
{
rpvtStruct *prpvt = (rpvtStruct *)pcalc->rpvt;
long i;
double *pnew, *pprev;
if (aCalcoutRecordDebug) printf("acalcoutRecord(%s):process: pact=%d, cact=%d, dlya=%d\n",
pcalc->name, pcalc->pact, pcalc->cact, pcalc->dlya);
/* Make sure. Autosave is capable of setting NUSE to an illegal value. */
if ((pcalc->nuse < 0) || (pcalc->nuse > pcalc->nelm)) {
pcalc->nuse = pcalc->nelm;
db_post_events(pcalc,&pcalc->nuse, DBE_VALUE|DBE_LOG);
}
/* If we're getting processed, we can no longer put off allocating memory */
if (pcalc->aval == NULL) pcalc->aval = (double *)calloc(pcalc->nelm, sizeof(double));
if (pcalc->oav == NULL) pcalc->oav = (double *)calloc(pcalc->nelm, sizeof(double));
if (!pcalc->pact) {
pcalc->pact = TRUE;
/* record scalar-field values so we can tell which ones aCalcPerform wrote to. */
for (i=0, pnew=&pcalc->a, pprev=&pcalc->pa; i<MAX_FIELDS; i++, pnew++, pprev++) {
*pprev = *pnew;
}
/* if some links are CA, check connections */
if (prpvt->caLinkStat != NO_CA_LINKS) checkLinks(pcalc);
if (fetch_values(pcalc)==0) {
long stat;
if (aCalcoutRecordDebug >= 5) printf("acalcoutRecord(%s):process: queueing aCalcPerform\n", pcalc->name);
pcalc->cact = 0;
stat = doCalc(pcalc);
if (stat) printf("%s:process: doCalc failed.\n", pcalc->name);
if (stat == 0 && pcalc->cact == 1) {
pcalc->pact = 1;
/* we'll get processed again when the calculation is done */
return(0);
} else {
if (afterCalc(pcalc) == ASYNC) return(0);
}
}
} else { /* pact == TRUE */
/* Who invoked us ? */
if (pcalc->cact) {
pcalc->cact = 0;
if (afterCalc(pcalc) == ASYNC) return(0);
} else if (pcalc->dlya) {
/* callbackRequestProcessCallbackDelayed() called us */
pcalc->dlya = 0;
db_post_events(pcalc,&pcalc->dlya,DBE_VALUE);
/* Must set pact 0 so that asynchronous device support works */
pcalc->pact = 0;
execOutput(pcalc);
if (pcalc->pact) return(0);
pcalc->pact = TRUE;
} else {
/* We must have been called by asynchronous device support */
writeValue(pcalc);
}
}
/*checkAlarms(pcalc); This is too late; IVOA might have vetoed output */
recGblGetTimeStamp(pcalc);
if (aCalcoutRecordDebug >= 5) {
printf("acalcoutRecord(%s):process:calling monitor \n", pcalc->name);
}
monitor(pcalc);
recGblFwdLink(pcalc);
pcalc->pact = FALSE;
if (aCalcoutRecordDebug >= 5) {
printf("acalcoutRecord(%s):process-done\n", pcalc->name);
}
if (aCalcoutRecordDebug) printf("acalcoutRecord(%s):process: exit, pact==0\n",
pcalc->name);
return(0);
}
static long process(struct timestampRecord *ptimestamp){
#if EPICS_VERSION >= 3 && EPICS_REVISION >= 14
#else
struct tsDetail time_s;
#endif
ptimestamp->udf = FALSE;
ptimestamp->pact = TRUE;
recGblGetTimeStamp(ptimestamp);
ptimestamp->sec = ptimestamp->time.secPastEpoch;
ptimestamp->nsec = ptimestamp->time.nsec;
#if EPICS_VERSION >= 3 && EPICS_REVISION >= 14
switch(ptimestamp->tst) {
case timestampTST_YY_MM_DD_HH_MM_SS:
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%y/%m/%d %H:%M:%S",&ptimestamp->time);
break;
case timestampTST_MM_DD_YY_HH_MM_SS:
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%m/%d/%y %H:%M:%S",&ptimestamp->time);
break;
case timestampTST_MM_DD_HH_MM_SS_YY:
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%b %d %H:%M:%S %y",&ptimestamp->time);
break;
case timestampTST_MM_DD_HH_MM_SS:
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%b %d %H:%M:%S",&ptimestamp->time);
break;
case timestampTST_HH_MM_SS:
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%H:%M:%S",&ptimestamp->time);
break;
case timestampTST_HH_MM:
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%H:%M",&ptimestamp->time);
break;
case timestampTST_DD_MM_YY_HH_MM_SS:
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%d/%m/%y %H:%M:%S",&ptimestamp->time);
break;
case timestampTST_DD_MM_HH_MM_SS_YY:
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%d %b %H:%M:%S %y",&ptimestamp->time);
break;
case timestampTST_VMS:
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%e-%b-%Y %H:%M:%S",&ptimestamp->time);
break;
case timestampTST_MM_DD_YYYY:
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%b %d, %Y %H:%M:%S.%04f",&ptimestamp->time);
break;
case timestampTST_MM_DD_YY:
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%m/%d/%y %H:%M:%S.%04f",&ptimestamp->time);
break;
default : /* YY/MM/DD HH:MM:SS */
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%y/%m/%D %H:%M:%S",&ptimestamp->time);
break;
}
#else
tsStampToLocal(ptimestamp->time, &time_s);
switch(ptimestamp->tst) {
case timestampTST_YY_MM_DD_HH_MM_SS:
sprintf(ptimestamp->val,"%.2d/%.2d/%.2d %.2d:%.2d:%.2d"
,time_s.year,time_s.monthNum+1,time_s.dayMonth+1
,time_s.hours,time_s.minutes,time_s.seconds);
break;
case timestampTST_MM_DD_YY_HH_MM_SS:
sprintf(ptimestamp->val,"%.2d/%.2d/%.2d %.2d:%.2d:%.2d"
,time_s.monthNum+1,time_s.dayMonth+1,time_s.year
,time_s.hours,time_s.minutes,time_s.seconds);
break;
case timestampTST_MM_DD_HH_MM_SS_YY:
sprintf(ptimestamp->val,"%s %.2d %.2d:%.2d:%.2d %.2d"
,MONTH[time_s.monthNum],time_s.dayMonth+1
,time_s.hours,time_s.minutes,time_s.seconds,time_s.year);
break;
case timestampTST_MM_DD_HH_MM_SS:
sprintf(ptimestamp->val,"%s %.2d %.2d:%.2d:%.2d"
,MONTH[time_s.monthNum],time_s.dayMonth+1
,time_s.hours,time_s.minutes,time_s.seconds);
break;
case timestampTST_HH_MM_SS:
sprintf(ptimestamp->val,"%.2d:%.2d:%.2d"
,time_s.hours,time_s.minutes,time_s.seconds);
break;
case timestampTST_HH_MM:
sprintf(ptimestamp->val,"%.2d:%.2d"
,time_s.hours,time_s.minutes);
break;
case timestampTST_DD_MM_YY_HH_MM_SS:
sprintf(ptimestamp->val,"%.2d/%.2d/%.2d %.2d:%.2d:%.2d"
,time_s.dayMonth+1,time_s.monthNum+1,time_s.year
,time_s.hours,time_s.minutes,time_s.seconds);
break;
case timestampTST_DD_MM_HH_MM_SS_YY:
sprintf(ptimestamp->val,"%.2d %s %.2d:%.2d:%.2d %.2d"
,time_s.dayMonth+1,MONTH[time_s.monthNum]
,time_s.hours,time_s.minutes,time_s.seconds,time_s.year);
break;
case timestampTST_VMS:
sprintf(ptimestamp->val,"%.2d-%s-%.4d %.2d:%.2d:%.2d"
,time_s.dayMonth+1,MONTH[time_s.monthNum],time_s.year
,time_s.hours,time_s.minutes,time_s.seconds);
break;
case timestampTST_MM_DD_YYYY:
sprintf(ptimestamp->val,"%s %.2d, %.4d %.2d:%.2d:%.2d"
,MONTH[time_s.monthNum],time_s.dayMonth+1
,time_s.year,time_s.hours,time_s.minutes,time_s.seconds);
break;
case timestampTST_MM_DD_YY:
sprintf(ptimestamp->val,"%.2d/%.2d/%.2d %.2d:%.2d:%.2d"
,time_s.monthNum+1,time_s.dayMonth+1,time_s.year
,time_s.hours,time_s.minutes,time_s.seconds);
break;
default : /* YY/MM/DD HH:MM:SS */
sprintf(ptimestamp->val,"%.2d/%.2d/%.2d %.2d:%.2d:%.2d"
,time_s.year,time_s.monthNum+1,time_s.dayMonth+1
,time_s.hours,time_s.minutes,time_s.seconds);
break;
}
#endif
/* check event list */
monitor(ptimestamp);
/* process the forward scan link record */
recGblFwdLink(ptimestamp);
ptimestamp->pact=FALSE;
return(0);
}
static long process(calcoutRecord *prec)
{
rpvtStruct *prpvt = prec->rpvt;
int doOutput;
if (!prec->pact) {
prec->pact = TRUE;
/* if some links are CA, check connections */
if (prpvt->caLinkStat != NO_CA_LINKS) {
checkLinks(prec);
}
if (fetch_values(prec) == 0) {
if (calcPerform(&prec->a, &prec->val, prec->rpcl)) {
recGblSetSevr(prec, CALC_ALARM, INVALID_ALARM);
} else {
prec->udf = isnan(prec->val);
}
}
checkAlarms(prec);
/* check for output link execution */
switch (prec->oopt) {
case calcoutOOPT_Every_Time:
doOutput = 1;
break;
case calcoutOOPT_On_Change:
doOutput = ! (fabs(prec->pval - prec->val) <= prec->mdel);
break;
case calcoutOOPT_Transition_To_Zero:
doOutput = ((prec->pval != 0.0) && (prec->val == 0.0));
break;
case calcoutOOPT_Transition_To_Non_zero:
doOutput = ((prec->pval == 0.0) && (prec->val != 0.0));
break;
case calcoutOOPT_When_Zero:
doOutput = (prec->val == 0.0);
break;
case calcoutOOPT_When_Non_zero:
doOutput = (prec->val != 0.0);
break;
default:
doOutput = 0;
break;
}
prec->pval = prec->val;
if (doOutput) {
if (prec->odly > 0.0) {
prec->dlya = 1;
recGblGetTimeStamp(prec);
db_post_events(prec, &prec->dlya, DBE_VALUE);
callbackRequestProcessCallbackDelayed(&prpvt->doOutCb,
prec->prio, prec, (double)prec->odly);
return 0;
} else {
prec->pact = FALSE;
execOutput(prec);
if (prec->pact) return 0;
prec->pact = TRUE;
}
}
recGblGetTimeStamp(prec);
} else { /* pact == TRUE */
if (prec->dlya) {
prec->dlya = 0;
recGblGetTimeStamp(prec);
db_post_events(prec, &prec->dlya, DBE_VALUE);
/* Make pact FALSE for asynchronous device support*/
prec->pact = FALSE;
execOutput(prec);
if (prec->pact) return 0;
prec->pact = TRUE;
} else {/*Device Support is asynchronous*/
writeValue(prec);
recGblGetTimeStamp(prec);
}
}
monitor(prec);
recGblFwdLink(prec);
prec->pact = FALSE;
return 0;
}
/*****************************************************************************
*
* This is called to "Process" the record.
*
* When we process a record for the digitel, we write out the new values for any
* field whos'e value(s) might have changed, then read back the operating status
* from the machine.
*
******************************************************************************/
static long process(void *precord)
{
digitelRecord *pdg = (digitelRecord *)precord;
digiteldset *pdset = (digiteldset *) (pdg->dset);
long status;
unsigned char pact = pdg->pact;
long nRequest = 1;
long options = 0;
if (recDigitelDebug >= 25)
printf("recDigitel.c: Process(%s)\n", pdg->name);
if ((pdset == NULL) || (pdset->proc_xact == NULL)) {
pdg->pact = TRUE;
recGblRecordError(S_dev_missingSup, (void *)pdg, "read_digitel");
return (S_dev_missingSup);
}
/*** if not currently active... save initial values for pressure, voltage... ***/
if (!pact) {
pdg->ival = pdg->val;
pdg->ilva = pdg->lval;
pdg->imod = pdg->modr;
pdg->ibak = pdg->bakr;
pdg->icol = pdg->cool;
pdg->isp1 = pdg->set1;
pdg->isp2 = pdg->set2;
pdg->isp3 = pdg->set3;
pdg->iacw = pdg->accw;
pdg->iaci = pdg->acci;
pdg->ipty = pdg->ptyp;
pdg->ibkn = pdg->bkin;
pdg->is1 = pdg->sp1r;
pdg->ih1 = pdg->s1hr;
pdg->im1 = pdg->s1mr;
pdg->ii1 = pdg->s1vr;
pdg->is2 = pdg->sp2r;
pdg->ih2 = pdg->s2hr;
pdg->im2 = pdg->s2mr;
pdg->ii2 = pdg->s2vr;
pdg->is3 = pdg->sp3r;
pdg->ih3 = pdg->s3hr;
pdg->im3 = pdg->s3mr;
pdg->ii3 = pdg->s3vr;
pdg->ib3 = pdg->s3br;
pdg->it3 = pdg->s3tr;
pdg->iton = pdg->tonl;
pdg->icrn = pdg->crnt;
pdg->ivol = pdg->volt;
pdg->ierr = pdg->err;
}
/*** check to see if simulation mode is being called for from the link ***/
status = dbGetLink(&(pdg->siml),
DBR_USHORT, &(pdg->simm), &options, &nRequest);
if (status == 0) {
if (pdg->simm == menuYesNoYES) {
recDigitelsimFlag = 1;
if (recDigitelDebug >= 5)
printf("recDigitel.c: Record being processed in simulation mode\n");
} else
recDigitelsimFlag = 0;
}
/*** if not in simulation mode allow device support to be called ***/
if (!(recDigitelsimFlag)) {
/*** call device support for processing ***/
status = (*pdset->proc_xact) (pdg);
/*** Device support is in asynchronous mode, let it finish ***/
if (!pact && pdg->pact)
return (0);
pdg->pact = TRUE;
recGblGetTimeStamp(pdg);
}
/*** if in simulation mode assign simulated values to fields ***/
else {
/*** simulation *** mode set ***/
/*** provides ability to simulate mode (OPERATE/ STANDBY) status of ***/
/*** pump, if set to 1 (OPERATE) make pump voltage appear to be at ***/
/*** an "on" (6000V) level ***/
status = dbGetLink(&(pdg->slmo),
DBR_USHORT, &(pdg->svmo), &options, &nRequest);
if (status == 0)
pdg->modr = pdg->svmo;
if (pdg->modr == 1)
pdg->volt = 6000;
else
pdg->volt = 0;
/*** simulation *** setpoint 1 set ***/
status = dbGetLink(&(pdg->sls1),
DBR_USHORT, &(pdg->svs1), &options, &nRequest);
if (status == 0)
pdg->set1 = pdg->svs1;
/*** simulation *** setpoint 2 set ***/
status = dbGetLink(&(pdg->sls2),
DBR_USHORT, &(pdg->svs2), &options, &nRequest);
if (status == 0)
pdg->set2 = pdg->svs2;
/*** simulation *** current level ***/
/*** adjust current, and make pressure look like there is a 220 l/s ***/
/*** pump being controlled ***/
status = dbGetLink(&(pdg->slcr),
DBR_DOUBLE, &(pdg->svcr), &options, &nRequest);
if (status == 0)
pdg->crnt = pdg->svcr;
if (pdg->modr == 0)
pdg->crnt = 0;
pdg->val = .005 * (pdg->crnt / 8.0);
if (pdg->val <= 0)
pdg->lval = -10;
else
pdg->lval = log10(pdg->val);
pdg->udf = 0; /* reset udf */
}
/*** check for alarms ***/
checkAlarms(pdg);
/*** check event list ***/
monitor(pdg);
/*** process the forward scan link record ***/
recGblFwdLink(pdg);
pdg->pact = FALSE;
return (status);
}
static long process(struct cvtRecord *pcvt)
{
long status = 0;
pcvt->pact = TRUE;
status = dbGetLink(&pcvt->inil, DBR_UCHAR, &pcvt->init, 0, 0);
pcvt->pact = FALSE;
if (status) {
recGblSetSevr(pcvt, LINK_ALARM, INVALID_ALARM);
goto error;
}
if (checkInit(pcvt)) {
recGblSetSevr(pcvt, SOFT_ALARM, INVALID_ALARM);
recGblResetAlarms(pcvt);
pcvt->pact = TRUE;
return -1;
}
pcvt->pact = TRUE;
status = readInputs(pcvt);
pcvt->pact = FALSE;
if (status) {
goto error;
}
status = convert(pcvt);
error:
checkAlarms(pcvt);
pcvt->pact = TRUE;
if (pcvt->nsev < INVALID_ALARM) {
status = dbPutLink(&pcvt->out, DBR_DOUBLE, &pcvt->val, 1);
}
else {
switch (pcvt->ivoa) {
case (menuIvoaSet_output_to_IVOV):
pcvt->val = pcvt->ivov;
/* note: this falls through to the case below */
case (menuIvoaContinue_normally):
status = dbPutLink(&pcvt->out, DBR_DOUBLE, &pcvt->val, 1);
case (menuIvoaDon_t_drive_outputs):
break;
default:
status = S_db_badField;
errmsg("internal error: Illegal value in IVOA field");
recGblSetSevr(pcvt, SOFT_ALARM, INVALID_ALARM);
recGblResetAlarms(pcvt);
return status;
}
}
recGblGetTimeStamp(pcvt);
monitor(pcvt);
recGblFwdLink(pcvt);
pcvt->pact = FALSE;
return status;
}
