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;
}
