static void monitor(boRecord *prec) { unsigned short monitor_mask; monitor_mask = recGblResetAlarms(prec); /* check for value change */ if (prec->mlst != prec->val){ /* post events for value change and archive change */ monitor_mask |= (DBE_VALUE | DBE_LOG); /* update last value monitored */ prec->mlst = prec->val; } /* send out monitors connected to the value field */ if (monitor_mask){ db_post_events(prec,&prec->val,monitor_mask); } if(prec->oraw!=prec->rval) { db_post_events(prec,&prec->rval, monitor_mask|DBE_VALUE|DBE_LOG); prec->oraw = prec->rval; } if(prec->orbv!=prec->rbv) { db_post_events(prec,&prec->rbv, monitor_mask|DBE_VALUE|DBE_LOG); prec->orbv = prec->rbv; } return; }
static void monitor(subRecord *prec) { unsigned monitor_mask; double *pnew; double *pold; int i; /* get alarm mask */ monitor_mask = recGblResetAlarms(prec); /* check for value change */ recGblCheckDeadband(&prec->mlst, prec->val, prec->mdel, &monitor_mask, DBE_VALUE); /* check for archive change */ recGblCheckDeadband(&prec->alst, prec->val, prec->adel, &monitor_mask, DBE_ARCHIVE); /* send out monitors connected to the value field */ if (monitor_mask) { db_post_events(prec, &prec->val, monitor_mask); } /* check all input fields for changes */ for (i = 0, pnew = &prec->a, pold = &prec->la; i < INP_ARG_MAX; i++, pnew++, pold++) { if (*pnew != *pold) { db_post_events(prec, pnew, monitor_mask | DBE_VALUE | DBE_LOG); *pold = *pnew; } } return; }
static void monitor(aSubRecord *prec) { int i; unsigned short monitor_mask; monitor_mask = recGblResetAlarms(prec) | DBE_VALUE | DBE_LOG; /* Post events for VAL field */ if (prec->val != prec->oval) { db_post_events(prec, &prec->val, monitor_mask); prec->oval = prec->val; } /* Event posting on VAL arrays depends on the setting of prec->eflg */ switch (prec->eflg) { case aSubEFLG_NEVER: break; case aSubEFLG_ON_CHANGE: for (i = 0; i < NUM_ARGS; i++) { epicsUInt32 alen = dbValueSize((&prec->ftva)[i]) * (&prec->neva)[i]; void *povl = (&prec->ovla)[i]; void *pval = (&prec->vala)[i]; if (memcmp(povl, pval, alen)) { memcpy(povl, pval, alen); db_post_events(prec, pval, monitor_mask); } } break; case aSubEFLG_ALWAYS: for (i = 0; i < NUM_ARGS; i++) db_post_events(prec, (&prec->vala)[i], monitor_mask); break; } return; }
static void monitor(ifstatRecord *prec) { unsigned short monitor_mask; double delta; monitor_mask = recGblResetAlarms(prec); /* check for value change */ delta = prec->mlst - prec->val; if(delta<0.0) delta = -delta; if (delta > prec->mdel) { /* post events for value change */ monitor_mask |= DBE_VALUE; /* update last value monitored */ prec->mlst = prec->val; } /* check for archive change */ delta = prec->alst - prec->val; if(delta<0.0) delta = -delta; if (delta > prec->adel) { /* post events on value field for archive change */ monitor_mask |= DBE_LOG; /* update last archive value monitored */ prec->alst = prec->val; } /* send out monitors connected to the value field */ if (monitor_mask){ db_post_events(prec,&prec->val,monitor_mask); } return; }
static void monitor(calcoutRecord *prec) { unsigned monitor_mask; double *pnew; double *pprev; int i; monitor_mask = recGblResetAlarms(prec); /* check for value change */ recGblCheckDeadband(&prec->mlst, prec->val, prec->mdel, &monitor_mask, DBE_VALUE); /* check for archive change */ recGblCheckDeadband(&prec->alst, prec->val, prec->adel, &monitor_mask, DBE_ARCHIVE); /* send out monitors connected to the value field */ if (monitor_mask){ db_post_events(prec, &prec->val, monitor_mask); } /* check all input fields for changes*/ for (i = 0, pnew = &prec->a, pprev = &prec->la; i<CALCPERFORM_NARGS; i++, pnew++, pprev++) { if ((*pnew != *pprev) || (monitor_mask&DBE_ALARM)) { db_post_events(prec, pnew, monitor_mask|DBE_VALUE|DBE_LOG); *pprev = *pnew; } } /* Check OVAL field */ if (prec->povl != prec->oval) { db_post_events(prec, &prec->oval, monitor_mask|DBE_VALUE|DBE_LOG); prec->povl = prec->oval; } return; }
static void interruptCallback(void *drvPvt, asynUser *pasynUser, epicsInt32 value) { devBusyPvt *pPvt = (devBusyPvt *)drvPvt; busyRecord *pr = (busyRecord *)pPvt->pr; unsigned short monitor_mask; dbScanLock((dbCommon *)pr); asynPrint(pPvt->pasynUser, ASYN_TRACEIO_DEVICE, "%s devAsynBusy::interruptCallback new value=%d\n", pr->name, value); /* If the current value of the record is 1 and the new value is 0 then post monitors * and call recGblFwdLink * Ignore the callback if pr->pact=1 because a write operation is in progress. */ if ((pr->pact == 0) && (pr->val == 1) && (value == 0)) { /* If the current value of the record is 1 and the new value is 0 then post monitors * and call recGblFwdLink */ asynPrint(pPvt->pasynUser, ASYN_TRACEIO_DEVICE, "%s devAsynBusy::interruptCallback 1 to 0 transition, posting monitors and calling recGblFwdLink\n", pr->name); pr->val = value; monitor_mask = recGblResetAlarms(pr); /* post events for value change and archive change */ monitor_mask |= (DBE_VALUE | DBE_LOG); /* update last value monitored */ pr->mlst = pr->val; /* send out monitors connected to the value field */ if (monitor_mask){ db_post_events(pr,&pr->val,monitor_mask); } recGblFwdLink(pr); } dbScanUnlock((dbCommon *)pr); }
static void monitor(eventRecord *prec) { unsigned short monitor_mask; /* get previous stat and sevr and new stat and sevr*/ monitor_mask = recGblResetAlarms(prec); db_post_events(prec,&prec->val,monitor_mask|DBE_VALUE); return; }
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 void monitor(aliveRecord *prec) { unsigned short monitor_mask; monitor_mask = recGblResetAlarms(prec); monitor_mask |= DBE_VALUE|DBE_LOG; db_post_events(prec,&prec->val,monitor_mask); return; }
static void monitor_field(aliveRecord *prec, void *field) { unsigned short monitor_mask; monitor_mask = recGblResetAlarms(prec); monitor_mask |= DBE_VALUE; db_post_events(prec,field,monitor_mask); return; }
static void monitor(struct cvtRecord *pcvt) { unsigned short monitor_mask; double delta; monitor_mask = recGblResetAlarms(pcvt); /* check for value change */ delta = pcvt->mlst - pcvt->val; if (delta < 0.0) delta = -delta; if (delta > pcvt->mdel) { /* post events for value change */ monitor_mask |= DBE_VALUE; /* update last value monitored */ pcvt->mlst = pcvt->val; } /* check for archive change */ delta = pcvt->alst - pcvt->val; if (delta < 0.0) delta = -delta; if (delta > pcvt->adel) { /* post events on value field for archive change */ monitor_mask |= DBE_LOG; /* update last archive value monitored */ pcvt->alst = pcvt->val; } /* send out monitors connected to the value field */ if (monitor_mask) { db_post_events(pcvt, &pcvt->val, monitor_mask); } if (pcvt->drty & DRTY_METH) { db_post_events(pcvt, &pcvt->meth, DBE_VALUE|DBE_LOG); } if (pcvt->drty & DRTY_SPEC) { db_post_events(pcvt, &pcvt->spec, DBE_VALUE|DBE_LOG); } if (pcvt->drty & DRTY_BDIR) { db_post_events(pcvt, &pcvt->bdir, DBE_VALUE|DBE_LOG); } if (pcvt->drty & DRTY_TDIR) { db_post_events(pcvt, &pcvt->tdir, DBE_VALUE|DBE_LOG); } if (pcvt->drty & DRTY_ISTA) { db_post_events(pcvt, &pcvt->ista, DBE_VALUE|DBE_LOG|DBE_ALARM); } if (pcvt->drty & DRTY_X) { db_post_events(pcvt, &pcvt->x, DBE_VALUE|DBE_LOG); } if (pcvt->drty & DRTY_Y) { db_post_events(pcvt, &pcvt->y, DBE_VALUE|DBE_LOG); } pcvt->drty = DRTY_NONE; return; }
static void monitor(compressRecord *prec) { unsigned short alarm_mask = recGblResetAlarms(prec); unsigned short monitor_mask = alarm_mask | DBE_LOG | DBE_VALUE; if (alarm_mask || prec->nuse != prec->ouse) { db_post_events(prec, &prec->nuse, monitor_mask); prec->ouse = prec->nuse; } db_post_events(prec, prec->bptr, monitor_mask); }
static void monitor(subArrayRecord *prec) { unsigned short monitor_mask; monitor_mask = recGblResetAlarms(prec); monitor_mask |= (DBE_LOG|DBE_VALUE); db_post_events(prec, prec->bptr, monitor_mask); return; }
static void monitor(selRecord *prec) { unsigned short monitor_mask; double delta; double *pnew; double *pprev; int i; monitor_mask = recGblResetAlarms(prec); /* check for value change */ delta = prec->mlst - prec->val; if(delta<0.0) delta = -delta; if (!(delta <= prec->mdel)) { /* Handles MDEL == NAN */ /* post events for value change */ monitor_mask |= DBE_VALUE; /* update last value monitored */ prec->mlst = prec->val; } /* check for archive change */ delta = prec->alst - prec->val; if(delta<0.0) delta = -delta; if (!(delta <= prec->adel)) { /* Handles ADEL == NAN */ /* post events on value field for archive change */ monitor_mask |= DBE_LOG; /* update last archive value monitored */ prec->alst = prec->val; } /* send out monitors connected to the value field */ if (monitor_mask) db_post_events(prec, &prec->val, monitor_mask); monitor_mask |= DBE_VALUE|DBE_LOG; /* trigger monitors of the SELN field */ if (prec->nlst != prec->seln) { prec->nlst = prec->seln; db_post_events(prec, &prec->seln, monitor_mask); } /* check all input fields for changes, even if VAL hasn't changed */ for(i=0, pnew=&prec->a, pprev=&prec->la; i<SEL_MAX; i++, pnew++, pprev++) { if(*pnew != *pprev) { db_post_events(prec, pnew, monitor_mask); *pprev = *pnew; } } return; }
static void monitor(aoRecord *prec) { unsigned short monitor_mask; double delta; monitor_mask = recGblResetAlarms(prec); /* check for value change */ delta = prec->mlst - prec->val; if(delta<0.0) delta = -delta; if (!(delta <= prec->mdel)) { /* Handles MDEL == NAN */ /* post events for value change */ monitor_mask |= DBE_VALUE; /* update last value monitored */ prec->mlst = prec->val; } /* check for archive change */ delta = prec->alst - prec->val; if(delta<0.0) delta = -delta; if (!(delta <= prec->adel)) { /* Handles ADEL == NAN */ /* post events on value field for archive change */ monitor_mask |= DBE_LOG; /* update last archive value monitored */ prec->alst = prec->val; } /* send out monitors connected to the value field */ if (monitor_mask){ db_post_events(prec,&prec->val,monitor_mask); } if(prec->omod) monitor_mask |= (DBE_VALUE|DBE_LOG); if(monitor_mask) { prec->omod = FALSE; db_post_events(prec,&prec->oval,monitor_mask); if(prec->oraw != prec->rval) { db_post_events(prec,&prec->rval, monitor_mask|DBE_VALUE|DBE_LOG); prec->oraw = prec->rval; } if(prec->orbv != prec->rbv) { db_post_events(prec,&prec->rbv, monitor_mask|DBE_VALUE|DBE_LOG); prec->orbv = prec->rbv; } } return; }
static long readData(dbCommon *record, format_t *format) { calcoutRecord *co = (calcoutRecord *)record; unsigned short monitor_mask; switch (format->type) { case DBF_DOUBLE: { if (streamScanf(record, format, &co->val) == ERROR) return ERROR; break; } case DBF_ULONG: case DBF_LONG: case DBF_ENUM: { long lval; if (streamScanf(record, format, &lval) == ERROR) return ERROR; if (format->type == DBF_LONG) co->val = lval; else co->val = (unsigned long)lval; break; } default: return ERROR; } if (record->pact) return OK; /* In @init handler, no processing, enforce monitor updates. */ monitor_mask = recGblResetAlarms(record); if (!(fabs(co->mlst - co->val) <= co->mdel)) { monitor_mask |= DBE_VALUE; co->mlst = co->val; } if (!(fabs(co->mlst - co->val) <= co->adel)) { monitor_mask |= DBE_LOG; co->alst = co->val; } if (monitor_mask){ db_post_events(record, &co->val, monitor_mask); } return OK; }
static void monitor(stringoutRecord *prec) { int monitor_mask = recGblResetAlarms(prec); if (strncmp(prec->oval, prec->val, sizeof(prec->val))) { monitor_mask |= DBE_VALUE | DBE_LOG; strncpy(prec->oval, prec->val, sizeof(prec->val)); } if (prec->mpst == stringoutPOST_Always) monitor_mask |= DBE_VALUE; if (prec->apst == stringoutPOST_Always) monitor_mask |= DBE_LOG; if (monitor_mask) db_post_events(prec, prec->val, monitor_mask); }
static void monitor(stringoutRecord *prec) { unsigned short monitor_mask; monitor_mask = recGblResetAlarms(prec); if(strcmp(prec->oval,prec->val)) { monitor_mask |= DBE_VALUE|DBE_LOG; strcpy(prec->oval,prec->val); } if (prec->mpst == stringoutPOST_Always) monitor_mask |= DBE_VALUE; if (prec->apst == stringoutPOST_Always) monitor_mask |= DBE_LOG; if(monitor_mask) db_post_events(prec,&(prec->val[0]),monitor_mask); return; }
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; }
static void monitor(subRecord *prec) { unsigned monitor_mask; double delta; double *pnew; double *pold; int i; /* get alarm mask */ monitor_mask = recGblResetAlarms(prec); /* check for value change */ delta = prec->val - prec->mlst; if (delta < 0.0) delta = -delta; if (!(delta <= prec->mdel)) { /* Handles MDEL == NAN */ /* post events for value change */ monitor_mask |= DBE_VALUE; /* update last value monitored */ prec->mlst = prec->val; } /* check for archive change */ delta = prec->val - prec->alst; if (delta < 0.0) delta = -delta; if (!(delta <= prec->adel)) { /* Handles ADEL == NAN */ /* post events on value field for archive change */ monitor_mask |= DBE_LOG; /* update last archive value monitored */ prec->alst = prec->val; } /* send out monitors connected to the value field */ if (monitor_mask) { db_post_events(prec, &prec->val, monitor_mask); } /* check all input fields for changes */ for (i = 0, pnew = &prec->a, pold = &prec->la; i < INP_ARG_MAX; i++, pnew++, pold++) { if (*pnew != *pold) { db_post_events(prec, pnew, monitor_mask | DBE_VALUE | DBE_LOG); *pold = *pnew; } } return; }
/***************************************************************************** * * 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 void monitor(lsoRecord *prec) { epicsUInt16 events = recGblResetAlarms(prec); if (prec->len != prec->olen || memcmp(prec->oval, prec->val, prec->len)) { events |= DBE_VALUE | DBE_LOG; memcpy(prec->oval, prec->val, prec->len); } if (prec->len != prec->olen) { prec->olen = prec->len; db_post_events(prec, &prec->len, DBE_VALUE | DBE_LOG); } if (prec->mpst == menuPost_Always) events |= DBE_VALUE; if (prec->apst == menuPost_Always) events |= DBE_LOG; if (events) db_post_events(prec, prec->val, events); }
static long monitor(rfmRecord *precord) { long status = OK; unsigned short monitor_mask; monitor_mask = recGblResetAlarms(precord); monitor_mask |= (DBE_VALUE|DBE_LOG); MONITOR_RFMFIELD(precord, precord->led, precord->oled, monitor_mask); /* led on fron panel */ MONITOR_RFMFIELD(precord, precord->csr, precord->ocsr, monitor_mask); /* local control and status register */ MONITOR_RFMFIELD(precord, precord->isr, precord->oisr, monitor_mask); /* local interrupt status register */ MONITOR_RFMFIELD(precord, precord->ier, precord->oier, monitor_mask); /* local interrupt enable register */ MONITOR_RFMFIELD(precord, precord->ict, precord->oict, monitor_mask); /* interupt counter */ MONITOR_RFMFIELD(precord, precord->ic1, precord->oic1, monitor_mask); /* network interrupt1 counter */ MONITOR_RFMFIELD(precord, precord->ic2, precord->oic2, monitor_mask); /* network interrupt2 counter */ MONITOR_RFMFIELD(precord, precord->ic3, precord->oic3, monitor_mask); /* network interrupt3 counter */ MONITOR_RFMFIELD(precord, precord->ic4, precord->oic4, monitor_mask); /* network interrupt4 counter */ MONITOR_RFMFIELD(precord, precord->rfb, precord->orfb, monitor_mask); /* ring buffer free bytes */ MONITOR_RFMFIELD(precord, precord->rfe, precord->orfe, monitor_mask); /* ring buffer free events */ MONITOR_RFMFIELD(precord, precord->sct, precord->osct, monitor_mask); /* scan counter */ MONITOR_RFMFIELD(precord, precord->ifg, precord->oifg, monitor_mask); /* INIT flag */ return status; }
static void monitor(permissiveRecord *prec) { unsigned short monitor_mask; unsigned short val,oval,wflg,oflg; monitor_mask = recGblResetAlarms(prec); /* get val,oval,wflg,oflg*/ val=prec->val; oval=prec->oval; wflg=prec->wflg; oflg=prec->oflg; /*set oval and oflg*/ prec->oval = val; prec->oflg = wflg; if(oval != val) { db_post_events(prec,&prec->val, monitor_mask|DBE_VALUE|DBE_LOG); } if(oflg != wflg) { db_post_events(prec,&prec->wflg, monitor_mask|DBE_VALUE|DBE_LOG); } return; }
static void monitor(longoutRecord *prec) { unsigned short monitor_mask = recGblResetAlarms(prec); if (prec->mdel < 0 || DELTA(prec->mlst, prec->val) > (epicsUInt32) prec->mdel) { /* post events for value change */ monitor_mask |= DBE_VALUE; /* update last value monitored */ prec->mlst = prec->val; } if (prec->adel < 0 || DELTA(prec->alst, prec->val) > (epicsUInt32) prec->adel) { /* post events for archive value change */ monitor_mask |= DBE_LOG; /* update last archive value monitored */ prec->alst = prec->val; } /* send out monitors connected to the value field */ if (monitor_mask) db_post_events(prec, &prec->val, monitor_mask); }
static void monitor(waveformRecord *prec) { unsigned short monitor_mask = 0; unsigned int hash = 0; monitor_mask = recGblResetAlarms(prec); if (prec->mpst == waveformPOST_Always) monitor_mask |= DBE_VALUE; if (prec->apst == waveformPOST_Always) monitor_mask |= DBE_LOG; /* Calculate hash if we are interested in OnChange events. */ if ((prec->mpst == waveformPOST_OnChange) || (prec->apst == waveformPOST_OnChange)) { hash = epicsMemHash((char *)prec->bptr, prec->nord * dbValueSize(prec->ftvl), 0); /* Only post OnChange values if the hash is different. */ if (hash != prec->hash) { if (prec->mpst == waveformPOST_OnChange) monitor_mask |= DBE_VALUE; if (prec->apst == waveformPOST_OnChange) monitor_mask |= DBE_LOG; /* Store hash for next process. */ prec->hash = hash; /* Post HASH. */ db_post_events(prec, &prec->hash, DBE_VALUE); } } if (monitor_mask) { db_post_events(prec, prec->bptr, monitor_mask); } }
/***************************************************************************** * * Post any change-of-state events. Note that the alarm status is applied * to all the fields in the record. * ******************************************************************************/ static void monitor(vsRecord * pvs) { unsigned short monitor_mask; int alrm_chg_flg; alrm_chg_flg = 0; monitor_mask = 0; monitor_mask = alrm_chg_flg = recGblResetAlarms(pvs); monitor_mask |= (DBE_VALUE | DBE_LOG); /*** check for value change ***/ if ((pvs->pval != pvs->val) || (alrm_chg_flg)) { db_post_events(pvs, &pvs->val, monitor_mask); pvs->pval = pvs->val; } if ((pvs->ppre != pvs->pres) || (alrm_chg_flg)) { db_post_events(pvs, &pvs->pres, monitor_mask); pvs->ppre = pvs->pres; } /********** SET VALUES **********/ if ((pvs->chgc & IG1_FIELD) || (pvs->pi1s != pvs->ig1s)) { db_post_events(pvs, &pvs->ig1s, monitor_mask); pvs->pi1s = pvs->ig1s; } if ((pvs->chgc & IG2_FIELD) || (pvs->pi2s != pvs->ig2s)) { db_post_events(pvs, &pvs->ig2s, monitor_mask); pvs->pi2s = pvs->ig2s; } if ((pvs->chgc & DGS_FIELD) || (pvs->pdss != pvs->dgss)) { db_post_events(pvs, &pvs->dgss, monitor_mask); pvs->pdss = pvs->dgss; } if ((pvs->chgc & SP1_FIELD) || (pvs->ps1s != pvs->sp1s)) { db_post_events(pvs, &pvs->sp1s, monitor_mask); pvs->ps1s = pvs->sp1s; } if ((pvs->chgc & SP2_FIELD) || (pvs->ps2s != pvs->sp2s)) { db_post_events(pvs, &pvs->sp2s, monitor_mask); pvs->ps2s = pvs->sp2s; } if ((pvs->chgc & SP3_FIELD) || (pvs->ps3s != pvs->sp3s)) { db_post_events(pvs, &pvs->sp3s, monitor_mask); pvs->ps3s = pvs->sp3s; } if ((pvs->chgc & SP4_FIELD) || (pvs->ps4s != pvs->sp4s)) { db_post_events(pvs, &pvs->sp4s, monitor_mask); pvs->ps4s = pvs->sp4s; } /********** READBACK VALUES **********/ if ((pvs->pig1 != pvs->ig1r) || (alrm_chg_flg)) { db_post_events(pvs, &pvs->ig1r, monitor_mask); pvs->pig1 = pvs->ig1r; } if ((pvs->pig2 != pvs->ig2r) || (alrm_chg_flg)) { db_post_events(pvs, &pvs->ig2r, monitor_mask); pvs->pig2 = pvs->ig2r; } if ((pvs->pdgs != pvs->dgsr) || (alrm_chg_flg)) { db_post_events(pvs, &pvs->dgsr, monitor_mask); pvs->pdgs = pvs->dgsr; } if ((pvs->pflt != pvs->fltr) || (alrm_chg_flg)) { db_post_events(pvs, &pvs->fltr, monitor_mask); pvs->pflt = pvs->fltr; } if ((pvs->psp1 != pvs->sp1) || (alrm_chg_flg)) { db_post_events(pvs, &pvs->sp1, monitor_mask); pvs->psp1 = pvs->sp1; } if ((pvs->psp2 != pvs->sp2) || (alrm_chg_flg)) { db_post_events(pvs, &pvs->sp2, monitor_mask); pvs->psp2 = pvs->sp2; } if ((pvs->psp3 != pvs->sp3) || (alrm_chg_flg)) { db_post_events(pvs, &pvs->sp3, monitor_mask); pvs->psp3 = pvs->sp3; } if ((pvs->psp4 != pvs->sp4) || (alrm_chg_flg)) { db_post_events(pvs, &pvs->sp4, monitor_mask); pvs->psp4 = pvs->sp4; } if ((pvs->psp5 != pvs->sp5) || (alrm_chg_flg)) { db_post_events(pvs, &pvs->sp5, monitor_mask); pvs->psp5 = pvs->sp5; } if ((pvs->psp6 != pvs->sp6) || (alrm_chg_flg)) { db_post_events(pvs, &pvs->sp6, monitor_mask); pvs->psp6 = pvs->sp6; } if ((pvs->ps1r != pvs->sp1r) || (alrm_chg_flg)) { db_post_events(pvs, &pvs->sp1r, monitor_mask); pvs->ps1r = pvs->sp1r; } if ((pvs->ps2r != pvs->sp2r) || (alrm_chg_flg)) { db_post_events(pvs, &pvs->sp2r, monitor_mask); pvs->ps2r = pvs->sp2r; } if ((pvs->ps3r != pvs->sp3r) || (alrm_chg_flg)) { db_post_events(pvs, &pvs->sp3r, monitor_mask); pvs->ps3r = pvs->sp3r; } if ((pvs->ps4r != pvs->sp4r) || (alrm_chg_flg)) { db_post_events(pvs, &pvs->sp4r, monitor_mask); pvs->ps4r = pvs->sp4r; } if ((pvs->plpe != pvs->lprs) || (alrm_chg_flg)) { db_post_events(pvs, &pvs->lprs, monitor_mask); pvs->plpe = pvs->lprs; } if ((pvs->pcga != pvs->cgap) || (alrm_chg_flg)) { db_post_events(pvs, &pvs->cgap, monitor_mask); pvs->pcga = pvs->cgap; } if ((pvs->plca != pvs->lcap) || (alrm_chg_flg)) { db_post_events(pvs, &pvs->lcap, monitor_mask); pvs->plca = pvs->lcap; } if ((pvs->pcgb != pvs->cgbp) || (alrm_chg_flg)) { db_post_events(pvs, &pvs->cgbp, monitor_mask); pvs->pcgb = pvs->cgbp; } if ((pvs->plcb != pvs->lcbp) || (alrm_chg_flg)) { db_post_events(pvs, &pvs->lcbp, monitor_mask); pvs->plcb = pvs->lcbp; } return; }
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; }
static void monitor(acalcoutRecord *pcalc) { unsigned short monitor_mask; double delta; double *pnew, *pprev; double **panew; int i, diff; long numElements; if (aCalcoutRecordDebug >= 10) printf("acalcoutRecord(%s):monitor:entry\n", pcalc->name); monitor_mask = recGblResetAlarms(pcalc); /* check for value change */ delta = pcalc->mlst - pcalc->val; if (delta < 0.0) delta = -delta; if (delta > pcalc->mdel) { /* post events for value change */ monitor_mask |= DBE_VALUE; /* update last value monitored */ pcalc->mlst = pcalc->val; } /* check for archive change */ delta = pcalc->alst - pcalc->val; if (delta < 0.0) delta = -delta; if (delta > pcalc->adel) { /* post events on value field for archive change */ monitor_mask |= DBE_LOG; /* update last archive value monitored */ pcalc->alst = pcalc->val; } /* send out monitors connected to the value field */ if (monitor_mask) db_post_events(pcalc,&pcalc->val,monitor_mask); /* If we haven't allocated previous-value fields, do it now. */ if (pcalc->pavl == NULL) pcalc->pavl = (double *)calloc(pcalc->nelm, sizeof(double)); if (pcalc->poav == NULL) pcalc->poav = (double *)calloc(pcalc->nelm, sizeof(double)); #if MIND_UNUSED_ELEMENTS numElements = pcalc->nelm; #else numElements = acalcGetNumElements( pcalc ); #endif for (i=0, diff=0; i<numElements; i++) { if (pcalc->aval[i] != pcalc->pavl[i]) {diff = 1;break;} } if (diff) { if (aCalcoutRecordDebug >= 1) printf("acalcoutRecord(%s):posting .AVAL\n", pcalc->name); db_post_events(pcalc, pcalc->aval, monitor_mask|DBE_VALUE|DBE_LOG); for (i=0; i<numElements; i++) pcalc->pavl[i] = pcalc->aval[i]; } for (i=0, diff=0; i<numElements; i++) { if (pcalc->oav[i] != pcalc->poav[i]) {diff = 1;break;} } if (diff) { db_post_events(pcalc, pcalc->oav, monitor_mask|DBE_VALUE|DBE_LOG); for (i=0; i<numElements; i++) pcalc->poav[i] = pcalc->oav[i]; } /* check all input fields for changes */ for (i=0, pnew=&pcalc->a, pprev=&pcalc->pa; i<MAX_FIELDS; i++, pnew++, pprev++) { if ((*pnew != *pprev) || (monitor_mask&DBE_ALARM)) { db_post_events(pcalc,pnew,monitor_mask|DBE_VALUE|DBE_LOG); *pprev = *pnew; } } for (i=0, panew=&pcalc->aa; i<ARRAY_MAX_FIELDS; i++, panew++) { if (*panew && (pcalc->newm & (1<<i))) { db_post_events(pcalc, *panew, monitor_mask|DBE_VALUE|DBE_LOG); } } pcalc->newm = 0; /* Check OVAL field */ if (pcalc->povl != pcalc->oval) { db_post_events(pcalc, &pcalc->oval, monitor_mask|DBE_VALUE|DBE_LOG); pcalc->povl = pcalc->oval; } return; }
/***************************************************************************** * * Post any change-of-state events. Note that the alarm status is applied * to all the fields in the record. * ******************************************************************************/ static void monitor(digitelRecord *pdg) { unsigned short monitor_mask; int alrm_chg_flg; alrm_chg_flg = 0; monitor_mask = 0; if (recDigitelDebug >= 25) printf("recDigitel.c: monitor()\n"); monitor_mask = alrm_chg_flg = recGblResetAlarms(pdg); monitor_mask |= (DBE_VALUE | DBE_LOG); /*** check for value change ***/ if ((pdg->ival != pdg->val) || (alrm_chg_flg)) db_post_events(pdg, &pdg->val, monitor_mask); if ((pdg->ilva != pdg->lval) || (alrm_chg_flg)) db_post_events(pdg, &pdg->lval, monitor_mask); if ((pdg->imod != pdg->modr) || (alrm_chg_flg)) db_post_events(pdg, &pdg->modr, monitor_mask); if ((pdg->ibak != pdg->bakr) || (alrm_chg_flg)) db_post_events(pdg, &pdg->bakr, monitor_mask); if ((pdg->icol != pdg->cool) || (alrm_chg_flg)) db_post_events(pdg, &pdg->cool, monitor_mask); if ((pdg->ibkn != pdg->bkin) || (alrm_chg_flg)) db_post_events(pdg, &pdg->bkin, monitor_mask); if ((pdg->isp1 != pdg->set1) || (alrm_chg_flg)) db_post_events(pdg, &pdg->set1, monitor_mask); if ((pdg->isp2 != pdg->set2) || (alrm_chg_flg)) db_post_events(pdg, &pdg->set2, monitor_mask); if ((pdg->isp3 != pdg->set3) || (alrm_chg_flg)) db_post_events(pdg, &pdg->set3, monitor_mask); if ((pdg->iacw != pdg->accw) || (alrm_chg_flg)) db_post_events(pdg, &pdg->accw, monitor_mask); if ((pdg->iaci != pdg->acci) || (alrm_chg_flg)) db_post_events(pdg, &pdg->acci, monitor_mask); if ((pdg->ipty != pdg->ptyp) || (alrm_chg_flg)) db_post_events(pdg, &pdg->ptyp, monitor_mask); if ((pdg->is1 != pdg->sp1r) || (alrm_chg_flg)) db_post_events(pdg, &pdg->sp1r, monitor_mask); if ((pdg->ih1 != pdg->s1hr) || (alrm_chg_flg)) db_post_events(pdg, &pdg->s1hr, monitor_mask); if ((pdg->im1 != pdg->s1mr) || (alrm_chg_flg)) db_post_events(pdg, &pdg->s1mr, monitor_mask); if ((pdg->ii1 != pdg->s1vr) || (alrm_chg_flg)) db_post_events(pdg, &pdg->s1vr, monitor_mask); if ((pdg->is2 != pdg->sp2r) || (alrm_chg_flg)) db_post_events(pdg, &pdg->sp2r, monitor_mask); if ((pdg->ih2 != pdg->s2hr) || (alrm_chg_flg)) db_post_events(pdg, &pdg->s2hr, monitor_mask); if ((pdg->im2 != pdg->s2mr) || (alrm_chg_flg)) db_post_events(pdg, &pdg->s2mr, monitor_mask); if ((pdg->ii2 != pdg->s2vr) || (alrm_chg_flg)) db_post_events(pdg, &pdg->s2vr, monitor_mask); if ((pdg->is3 != pdg->sp3r) || (alrm_chg_flg)) db_post_events(pdg, &pdg->sp3r, monitor_mask); if ((pdg->ih3 != pdg->s3hr) || (alrm_chg_flg)) db_post_events(pdg, &pdg->s3hr, monitor_mask); if ((pdg->im3 != pdg->s3mr) || (alrm_chg_flg)) db_post_events(pdg, &pdg->s3mr, monitor_mask); if ((pdg->ii3 != pdg->s3vr) || (alrm_chg_flg)) db_post_events(pdg, &pdg->s3vr, monitor_mask); if ((pdg->ib3 != pdg->s3br) || (alrm_chg_flg)) db_post_events(pdg, &pdg->s3br, monitor_mask); if ((pdg->it3 != pdg->s3tr) || (alrm_chg_flg)) db_post_events(pdg, &pdg->s3tr, monitor_mask); if ((pdg->iton != pdg->tonl) || (alrm_chg_flg)) db_post_events(pdg, &pdg->tonl, monitor_mask); if ((pdg->icrn != pdg->crnt) || (alrm_chg_flg)) db_post_events(pdg, &pdg->crnt, monitor_mask); if ((pdg->ivol != pdg->volt) || (alrm_chg_flg)) db_post_events(pdg, &pdg->volt, monitor_mask); if ((pdg->ierr != pdg->err) || (alrm_chg_flg)) db_post_events(pdg, &pdg->err, monitor_mask); return; }