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); }
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(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); }
void AlarmClock_Tick() { ticks++; if ( is_adjusting ) { // blink current field every half second when adjusting, but not if // the timer is running if ( ticks == TICKS_PER_HALF_SECOND && !show_field_timer ) { hideCurrentField(); // if the timer is running, decrement it } else if ( show_field_timer ) { show_field_timer--; // expired? hide field if ( !show_field_timer ) { hideCurrentField(); } } } if ( ticks == TICKS_PER_SECOND ) { ticks = 0; if ( is_adjusting ) { showCurrentField(); } else { ds1307_datetime dt; DS1307_GetDateTime( &dt ); showTime( &dt ); if ( dt.second == 0x00 && alarm_callback != NULL ) { uint8_t ala = checkAlarms( &dt ); if ( ala != 0xFF ) { ( *alarm_callback )( ala ); } } } } }
/****************************************************************************** * Check if any alarms are pending for any enabled calendar, and display the * pending alarms. * Called by the alarm timer. */ void AlarmDaemon::checkAlarmsSlot() { kdDebug(5901) << "AlarmDaemon::checkAlarmsSlot()" << endl; if(mAlarmTimerSyncing) { // We've synched to the minute boundary. Now set timer to the check interval. mAlarmTimer->changeInterval(DAEMON_CHECK_INTERVAL * 1000); mAlarmTimerSyncing = false; mAlarmTimerSyncCount = 10; // resynch every 10 minutes, in case of glitches } else if(--mAlarmTimerSyncCount <= 0) { int interval = DAEMON_CHECK_INTERVAL + 1 - QTime::currentTime().second(); if(interval < DAEMON_CHECK_INTERVAL - 1) { // Need to re-synch to 1 second past the minute mAlarmTimer->changeInterval(interval * 1000); mAlarmTimerSyncing = true; kdDebug(5900) << "Resynching alarm timer" << endl; } else mAlarmTimerSyncCount = 10; } checkAlarms(); }
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); }
/***************************************************************************** * * 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 void newTempsAvail(void) { static unsigned char pidCycleCount; updateDisplay(); ++pidCycleCount; if ((pidCycleCount % 0x20) == 0) outputRfStatus(); outputCsv(); // We want to report the status before the alarm readout so // receivers can tell what the value was that caused the alarm checkAlarms(); if (g_LogPidInternals) pid.pidStatus(); if ((pidCycleCount % 0x04) == 1) outputAdcStatus(); ledmanager.publish(LEDSTIMULUS_Off, LEDACTION_Off); ledmanager.publish(LEDSTIMULUS_LidOpen, pid.isLidOpen()); ledmanager.publish(LEDSTIMULUS_FanOn, pid.isOutputActive()); ledmanager.publish(LEDSTIMULUS_FanMax, pid.isOutputMaxed()); ledmanager.publish(LEDSTIMULUS_PitTempReached, pid.isPitTempReached()); ledmanager.publish(LEDSTIMULUS_Startup, pid.getPitStartRecover() == PIDSTARTRECOVER_STARTUP); ledmanager.publish(LEDSTIMULUS_Recovery, pid.getPitStartRecover() == PIDSTARTRECOVER_RECOVERY); #ifdef HEATERMETER_RFM12 rfmanager.sendUpdate(pid.getPidOutput()); #endif }
void OutputCalibrationPage::onStartButtonToggle(QAbstractButton *button, QList<quint16> &channels, quint16 value, quint16 safeValue, QSlider *slider) { if (button->isChecked()) { // Start calibration if (checkAlarms()) { enableButtons(false); enableServoSliders(true); m_calibrationUtil->startChannelOutput(channels, safeValue); slider->setValue(value); m_calibrationUtil->setChannelOutputValue(value); } else { button->setChecked(false); } } else { // Stop calibration quint16 channel = channels[0]; if ((button == ui->motorNeutralButton) && !m_actuatorSettings[channel].isReversableMotor) { // Normal motor m_calibrationUtil->startChannelOutput(channels, m_actuatorSettings[channel].channelMin); } else { // Servos and ReversableMotors m_calibrationUtil->startChannelOutput(channels, m_actuatorSettings[channel].channelNeutral); } m_calibrationUtil->stopChannelOutput(); enableServoSliders(false); enableButtons(true); } debugLogChannelValues(); }
static long checkInit(struct cvtRecord *pcvt) { if (!pcvt->init) { return 0; } pcvt->init = 0; switch (pcvt->ista) { case menuCvtInitStateDone: case menuCvtInitStateError: pcvt->ista = menuCvtInitStateInProgress; pcvt->drty |= DRTY_ISTA; if (reinitConversion(pcvt)) { /* this is fatal */ pcvt->ista = menuCvtInitStateError; pcvt->pact = TRUE; return -1; } break; case menuCvtInitStateInProgress: pcvt->ista = menuCvtInitStateAgain; pcvt->drty |= DRTY_ISTA; break; case menuCvtInitStateAgain: break; default: errmsg("internal error: illegal value %d in field ISTA", pcvt->ista); pcvt->pact = TRUE; return -1; } checkAlarms(pcvt); monitor(pcvt); return 0; }
void AlarmDaemon::calendarLoaded(ADCalendar *cal, bool success) { if(success) kdDebug(5900) << "Calendar reloaded" << endl; notifyCalStatus(cal); // notify KAlarm setTimerStatus(); checkAlarms(cal); }
/****************************************************************************** * Start monitoring alarms. */ void AlarmDaemon::startMonitoring() { // Set up the alarm timer mAlarmTimer = new QTimer(this); connect(mAlarmTimer, SIGNAL(timeout()), SLOT(checkAlarmsSlot())); setTimerStatus(); // Start monitoring calendar files. // They are monitored until their client application registers, upon which // monitoring ceases until KAlarm tells the daemon to monitor it. checkAlarms(); }
/********************************************//** * \brief update time, check alarms, clear flag * * \param * \param * \return * ***********************************************/ void RTC_IRQHandler(void) { RTC_IntClear(RTC_IF_COMP0); updateTime(); uint8_t alarm = checkAlarms(); if(alarm) { runAlarm(alarm); // check alarms and run if there are any } checkPomodoro(); }
void SClock::setTime(uint8_t h, uint8_t m) { if(h<24 && m<60) { _hh = h; _mm = m; } checkAlarms(); _edited = 0; redraw(); }
THREAD(AlarmCheck, arg) { NutThreadSetPriority(100); for(;;){ if(checkAlarms() == 1){ setCurrentDisplay(DISPLAY_Alarm, 1000); } NutSleep(1000); } }
void SClock::addSecond() { ++_ss; if(_ss<60) return; _ss = 0; ++_mm; if(_mm<60) { checkAlarms(); return; } _mm = 0; ++_hh; if(_hh) { checkAlarms(); return; } checkAlarms(); _hh = 0; }
void RTC_IRQHandler(void) { if (RTC_GetITStatus(RTC_IT_SEC) != RESET) { /* Clear the RTC Second interrupt */ RTC_ClearITPendingBit(RTC_IT_SEC); updateTime(); checkAlarms(); /* Wait until last write operation on RTC registers has finished */ RTC_WaitForLastTask(); } }
void OutputCalibrationPage::onStartButtonToggle(QAbstractButton *button, quint16 channel, quint16 value, quint16 safeValue, QSlider *slider) { if (button->isChecked()) { if (checkAlarms()) { enableButtons(false); m_calibrationUtil->startChannelOutput(channel, safeValue); slider->setValue(value); m_calibrationUtil->setChannelOutputValue(value); } else { button->setChecked(false); } } else { m_calibrationUtil->stopChannelOutput(); enableButtons(true); } debugLogChannelValues(); }
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); }
//------------------------------------------------------------------ void Clock::advance( double deltaSeconds ) { double dtSeconds = deltaSeconds; if( m_isPaused ) dtSeconds = 0.0; else dtSeconds *= m_timeScale; m_deltaSeconds = dtSeconds; m_elapsedSeconds += m_deltaSeconds; checkAlarms(); for( size_t i = 0; i < m_children.size(); ++i ) { m_children[i]->advance( dtSeconds ); } }
/** * @brief Este callback es llamado asincrónicamente por el stack de ZigBee * para notificar a la aplicación que se recibieron datos, enviados * por otro nodo de la red. * @param source Short Address (NWK) del nodo que envío los datos. * @param command ID del comando asociado con los datos. * @param len Cantidad de bytes del parámetro pData. * @param pData Puntero al inicio de los datos envíados por el nodo. */ void zb_ReceiveDataIndication(uint16 source, uint16 command, uint16 len, uint8 *pData) { // imprime la dirección fuente en el display HalLcdWriteStringValue("RCB", source, 16, 1); // flashea el LED 2 para indicar que se recibió un mensaje HalLedSet(HAL_LED_2, HAL_LED_MODE_FLASH); // deserealiza mensaje recibido msgReport = deserializeMessage(pData); if (msgReport.msgType == MSG_TYPE_REPORT) { HalLcdWriteStringValue("#", msgReport.sequence, 10, 2); // verifica condiciones de alarmas alarmFlags = checkAlarms(&msgReport); // imprime alarma en LCD //HalLcdWriteStringValue("ALARM", alarmFlags, 16, 2); if (alarmFlags != 0) { // crea paquete de respuesta con igual MAC y nº de secuencia struct message_t msgAlarm; msgAlarm.sequence = msgReport.sequence; memcpy(&(msgAlarm.mac), &(msgReport.mac), sizeof(msgReport.mac)); msgAlarm.msgType = MSG_TYPE_ALARM; msgAlarm.lenData = MSG_LEN_DATA_ALARM; // flags en little-endian msgAlarm.data[0] = LO_UINT16(alarmFlags); msgAlarm.data[1] = HI_UINT16(alarmFlags); // serializa mensaje y lo envía serializeMessage(&(msgAlarm), msgBuf); zb_SendDataRequest(source, MESSAGE_CLUSTER, getSizeOfMessage(&(msgAlarm)), msgBuf, 0, AF_TX_OPTIONS_NONE, 0); } // crea evento para enviar el reporte por UART a la PC, añandiendo // los flags osal_start_timerEx(sapi_TaskID, SEND_UART_MSG, 0); } }
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 void initConversionTask(void* parm) { int qstatus; void *sub; struct reinitMsg msg; struct cvtRecord *pcvt; long status; while (TRUE) { qstatus = epicsMessageQueueReceive( initConversionQ, (void*)&msg, REINIT_MSG_SIZE); if (qstatus == -1) { nerrmsg("", "msgQReceive failed"); continue; } pcvt = msg.record; status = initConversion(pcvt->name, msg.bdir, msg.tdir, msg.meth, msg.spec, &sub); dbScanLock((struct dbCommon *)pcvt); if (status && pcvt->ista != menuCvtInitStateAgain) { if (pcvt->ista != menuCvtInitStateError) { pcvt->ista = menuCvtInitStateError; pcvt->drty |= DRTY_ISTA; } } else { switch (pcvt->ista) { case menuCvtInitStateInProgress: case menuCvtInitStateError: pcvt->ista = menuCvtInitStateDone; pcvt->drty |= DRTY_ISTA; /* free old csub if it was a csm_function... */ if (pcvt->meth == menuCvtMethod1DTable || pcvt->meth == menuCvtMethod1DTableInverted || pcvt->meth == menuCvtMethod2DTable) { csm_function *csub = (csm_function *)pcvt->csub; if (csub) { /* check because it might have never been created */ csm_free(csub); } } /* ...and write the new values back into the record */ pcvt->meth = msg.meth; pcvt->drty |= DRTY_METH; strncpy(pcvt->spec, msg.spec, SPEC_SIZE); pcvt->drty |= DRTY_SPEC; strncpy(pcvt->bdir, msg.bdir, BDIR_SIZE); pcvt->drty |= DRTY_BDIR; strncpy(pcvt->tdir, msg.tdir, TDIR_SIZE); pcvt->drty |= DRTY_TDIR; pcvt->csub = sub; break; case menuCvtInitStateAgain: if (!status && sub && ( pcvt->meth == menuCvtMethod1DTable || pcvt->meth == menuCvtMethod1DTableInverted || pcvt->meth == menuCvtMethod2DTable)) { csm_free((csm_function *)sub); } /* even if initConversion(...) above failed, we go here */ if (reinitConversion(pcvt)) { /* this is fatal */ pcvt->ista = menuCvtInitStateError; pcvt->drty |= DRTY_ISTA; pcvt->pact = TRUE; break; } pcvt->ista = menuCvtInitStateInProgress; pcvt->drty |= DRTY_ISTA; break; case menuCvtInitStateDone: errmsg("internal error: unexpected " "value <menuCvtInitStateDone> in field ISTA"); pcvt->pact = TRUE; break; default: errmsg("internal error: ISTA is not a member of menuCvtMethod"); pcvt->pact = TRUE; } } checkAlarms(pcvt); monitor(pcvt); dbScanUnlock((struct dbCommon *)pcvt); } }
static long process(longoutRecord *prec) { struct longoutdset *pdset = (struct longoutdset *)(prec->dset); long status=0; epicsInt32 value; unsigned char pact=prec->pact; if( (pdset==NULL) || (pdset->write_longout==NULL) ) { prec->pact=TRUE; recGblRecordError(S_dev_missingSup,(void *)prec,"write_longout"); return(S_dev_missingSup); } if (!prec->pact) { if((prec->dol.type != CONSTANT) && (prec->omsl == menuOmslclosed_loop)) { status = dbGetLink(&(prec->dol),DBR_LONG, &value,0,0); if (prec->dol.type!=CONSTANT && RTN_SUCCESS(status)) prec->udf=FALSE; } else { value = prec->val; } if (!status) convert(prec,value); } /* check for alarms */ checkAlarms(prec); if (prec->nsev < INVALID_ALARM ) status=writeValue(prec); /* write the new value */ else { switch (prec->ivoa) { case (menuIvoaContinue_normally) : status=writeValue(prec); /* write the new value */ break; case (menuIvoaDon_t_drive_outputs) : break; case (menuIvoaSet_output_to_IVOV) : if(prec->pact == FALSE){ prec->val=prec->ivov; } status=writeValue(prec); /* write the new value */ break; default : status=-1; recGblRecordError(S_db_badField,(void *)prec, "longout:process Illegal IVOA field"); } } /* 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); }
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 afterCalc(acalcoutRecord *pcalc) { rpvtStruct *prpvt = (rpvtStruct *)pcalc->rpvt; short doOutput = 0; long i, j; double **panew; i = acalcGetNumElements( pcalc ); #if MIND_UNUSED_ELEMENTS if (i < pcalc->nelm) { for (; i<pcalc->nelm; i++) pcalc->aval[i] = 0; } #endif /* post array fields that aCalcPerform wrote to. */ for (j=0, panew=&pcalc->aa; j<ARRAY_MAX_FIELDS; j++, panew++) { if (*panew && (pcalc->amask & (1<<j))) { db_post_events(pcalc, *panew, DBE_VALUE|DBE_LOG); } } if (aCalcoutRecordDebug >= 5) { printf("acalcoutRecord(%s):aCalcPerform returns val=%f, aval=[%f %f...]\n", pcalc->name, pcalc->val, pcalc->aval[0], pcalc->aval[1]); } if (pcalc->cstat) recGblSetSevr(pcalc,CALC_ALARM,INVALID_ALARM); else pcalc->udf = FALSE; /* Check VAL against limits */ checkAlarms(pcalc); /* check for output link execution */ switch (pcalc->oopt) { case acalcoutOOPT_Every_Time: doOutput = 1; break; case acalcoutOOPT_On_Change: if (fabs(pcalc->pval - pcalc->val) > pcalc->mdel) doOutput = 1; break; case acalcoutOOPT_Transition_To_Zero: if ((pcalc->pval != 0) && (pcalc->val == 0)) doOutput = 1; break; case acalcoutOOPT_Transition_To_Non_zero: if ((pcalc->pval == 0) && (pcalc->val != 0)) doOutput = 1; break; case acalcoutOOPT_When_Zero: if (!pcalc->val) doOutput = 1; break; case acalcoutOOPT_When_Non_zero: if (pcalc->val) doOutput = 1; break; case acalcoutOOPT_Never: doOutput = 0; break; } pcalc->pval = pcalc->val; if (doOutput) { if (pcalc->odly > 0.0) { pcalc->dlya = 1; db_post_events(pcalc,&pcalc->dlya,DBE_VALUE); callbackRequestProcessCallbackDelayed(&prpvt->doOutCb, pcalc->prio, pcalc, (double)pcalc->odly); if (aCalcoutRecordDebug >= 5) printf("acalcoutRecord(%s):process: exit, wait for delay\n", pcalc->name); return(ASYNC); } else { if (aCalcoutRecordDebug >= 5) printf("acalcoutRecord(%s):calling execOutput\n", pcalc->name); pcalc->pact = FALSE; execOutput(pcalc); if (pcalc->pact) { if (aCalcoutRecordDebug >= 5) printf("acalcoutRecord(%s):process: exit, pact==1\n", pcalc->name); return(ASYNC); } pcalc->pact = TRUE; } } return(SYNC); }
/****************************************************************************** * Check if any alarms are pending for any enabled calendar, and display the * pending alarms. */ void AlarmDaemon::checkAlarms() { kdDebug(5901) << "AlarmDaemon::checkAlarms()" << endl; for(ADCalendar::ConstIterator it = ADCalendar::begin(); it != ADCalendar::end(); ++it) checkAlarms(*it); }
/***************************************************************************** * * 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(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; }
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; }