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