/* ---------------------------------------------------------------------- */
static long dsetWrite_devBoSyncSoft(boRecord *pbo) {
char p_myWarmstartFilename[BUFLEN];
FILE *p_myFileHandle;
long status;
dsetLog(3, __FILE__ "[%d] -> %s(%s)\n", __LINE__, __func__, pbo->name);
/* umask(0000); */
sprintf(p_myWarmstartFilename, WARMSTART_FILE_PREFIX "/%s", pbo->name);
p_myFileHandle=fopen(p_myWarmstartFilename,"w");
if (p_myFileHandle==NULL) {
dsetLog(1, __FILE__ "[%d] Error: %s\n", __LINE__, pbo->name);
dsetLog(1, __FILE__ "[%d] Error: Couldn't open file >%s<\n",
__LINE__, p_myWarmstartFilename);
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
fprintf(p_myFileHandle,"%d",pbo->val);
fclose(p_myFileHandle);
dsetLog(2, __FILE__ "[%d] %s -> %d\n", __LINE__, pbo->name, pbo->val);
status = dbPutLink(&pbo->out,DBR_USHORT,&pbo->val,1);
dsetLog(3, __FILE__ "[%d] <- %s\n", __LINE__, __func__);
return(status);
}
static long write_string(lsoRecord *prec)
{
struct link *plink = &prec->out;
int dtyp = dbGetLinkDBFtype(plink);
long len = prec->len;
long status;
if (prec->pact || dtyp < 0)
return 0;
if (dtyp != DBR_CHAR && dtyp != DBF_UCHAR) {
dtyp = DBR_STRING;
len = 1;
}
if (plink->type != CA_LINK)
return dbPutLink(plink, dtyp, prec->val, len);
status = dbCaPutLinkCallback(plink, dtyp, prec->val, len,
dbCaCallbackProcess, plink);
if (status) {
recGblSetSevr(prec, LINK_ALARM, INVALID_ALARM);
return status;
}
prec->pact = TRUE;
return 0;
}
static long writeValue(stringoutRecord *prec)
{
long status;
struct stringoutdset *pdset = (struct stringoutdset *) (prec->dset);
if (prec->pact == TRUE){
status=(*pdset->write_stringout)(prec);
return(status);
}
status=dbGetLink(&(prec->siml),DBR_USHORT,
&(prec->simm),0,0);
if (status)
return(status);
if (prec->simm == menuYesNoNO){
status=(*pdset->write_stringout)(prec);
return(status);
}
if (prec->simm == menuYesNoYES){
status=dbPutLink(&prec->siol,DBR_STRING,
prec->val,1);
} else {
status=-1;
recGblSetSevr(prec,SOFT_ALARM,INVALID_ALARM);
return(status);
}
recGblSetSevr(prec,SIMM_ALARM,prec->sims);
return(status);
}
static long writeValue(lsoRecord *prec)
{
long status;
lsodset *pdset = (lsodset *) prec->dset;
if (prec->pact)
goto write;
status = dbGetLink(&prec->siml, DBR_USHORT, &prec->simm, 0, 0);
if (status)
return(status);
switch (prec->simm) {
case menuYesNoNO:
write:
status = pdset->write_string(prec);
break;
case menuYesNoYES:
recGblSetSevr(prec, SIMM_ALARM, prec->sims);
status = dbPutLink(&prec->siol,DBR_STRING, prec->val,1);
break;
default:
recGblSetSevr(prec, SOFT_ALARM, INVALID_ALARM);
status = -1;
}
return status;
}
static long write_mbbo(mbboRecord *prec)
{
long status;
status = dbPutLink(&prec->out,DBR_USHORT, &prec->val,1);
return(0);
}
/* ---------------------------------------------------------------------- */
static long dsetWrite_devBoSyncSoft(boRecord *pbo) {
long status;
status = dbPutLink(&pbo->out,DBR_USHORT,&pbo->val,1);
return(status);
}
static long write_aao(aaoRecord *prec)
{
long nRequest = prec->nord;
dbPutLink(prec->simm == menuYesNoYES ? &prec->siol : &prec->out,
prec->ftvl, prec->bptr, nRequest);
return 0;
}
/*****************************************************************************
*
* Link-group processing function.
*
* if the input link is not a constant
* call dbGetLink() to get the link value
* else
* get the value from the DOV field
* call dbPutLink() to forward the value to destination location
* call processNextLink() to schedule the processing of the next link-group
*
* NOTE:
* dbScanLock is NOT held for prec when this function is called!!
*
******************************************************************************/
static void processCallback(CALLBACK *arg)
{
callbackSeq *pcb;
seqRecord *prec;
double myDouble;
callbackGetUser(pcb,arg);
prec = pcb->pseqRecord;
dbScanLock((struct dbCommon *)prec);
if (seqRecDebug > 5)
printf("processCallback(%s) processing field index %d\n", prec->name, pcb->index+1);
/* Save the old value */
myDouble = pcb->plinks[pcb->index]->dov;
dbGetLink(&(pcb->plinks[pcb->index]->dol), DBR_DOUBLE,
&(pcb->plinks[pcb->index]->dov),0,0);
recGblGetTimeStamp(prec);
/* Dump the value to the destination field */
dbPutLink(&(pcb->plinks[pcb->index]->lnk), DBR_DOUBLE,
&(pcb->plinks[pcb->index]->dov),1);
if (myDouble != pcb->plinks[pcb->index]->dov)
{
if (seqRecDebug > 0)
printf("link %d changed from %f to %f\n", pcb->index, myDouble, pcb->plinks[pcb->index]->dov);
db_post_events(prec, &pcb->plinks[pcb->index]->dov, DBE_VALUE|DBE_LOG);
}
else
{
if (seqRecDebug > 0)
printf("link %d not changed... %f\n", pcb->index, pcb->plinks[pcb->index]->dov);
}
/* Find the 'next' link-seq that is ready for processing. */
pcb->index++;
processNextLink(prec);
dbScanUnlock((struct dbCommon *)prec);
return;
}
static long write_bo(boRecord *prec)
{
struct link *plink = &prec->out;
long status;
if(prec->pact) return(0);
if(plink->type!=CA_LINK) {
status = dbPutLink(plink,DBR_USHORT,&prec->val,1);
return(status);
}
status = dbCaPutLinkCallback(plink,DBR_USHORT,&prec->val,1,
dbCaCallbackProcess,plink);
if(status) {
recGblSetSevr(prec,LINK_ALARM,INVALID_ALARM);
return(status);
}
prec->pact = TRUE;
return(0);
}
static long process(aSubRecord *prec)
{
int pact = prec->pact;
long status = 0;
if (!pact) {
prec->pact = TRUE;
status = fetch_values(prec);
prec->pact = FALSE;
}
if (!status) {
status = do_sub(prec);
prec->val = status;
}
if (!pact && prec->pact)
return 0;
prec->pact = TRUE;
/* Push the output link values */
if (!status) {
int i;
for (i = 0; i < NUM_ARGS; i++)
dbPutLink(&(&prec->outa)[i], (&prec->ftva)[i], (&prec->vala)[i],
(&prec->neva)[i]);
}
recGblGetTimeStamp(prec);
monitor(prec);
recGblFwdLink(prec);
prec->pact = FALSE;
return 0;
}
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 long dsetWrite_devBoSyncSoft(aliasBoRecord *psbo)
{
CONTEXT *p_myContext;
int status;
#ifdef WARMSTART_READ_FROM_FILE
char p_myWarmstartFileName[BUFLEN];
FILE *p_myFileHandle;
#endif
#ifdef DEBUG1
printf( __FILE__ "[%d] -> %s(%s)\n", __LINE__, __func__, psbo->name);
#endif
p_myContext = (CONTEXT *)psbo->dpvt;
if (p_myContext->operatingMode==NORMAL_MODE) {
#ifdef DEBUG
printf( __FILE__ "[%d] %s --(%d)-> %s\n",
__LINE__, psbo->name, psbo->val, psbo->out.value.instio.string);
#endif
status = dbPutLink(&psbo->out,DBR_USHORT,&psbo->val,1);
if ((status != SUCCESS) && (status !=DO_NOT_CONVERT)) {
printf( __FILE__ "[%d] Error(%d): Couldn't dbPutLink\n",
__LINE__, status );
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
/* Save value in /var/epics
* Used for warm boot when dol is not set
* and when omsl is not close_loop */
if ( p_myContext->warmstartMethod== WARMSTART_READ_FROM_FILE) {
sprintf(p_myWarmstartFileName, WARMSTART_FILE_PREFIX "/%s", psbo->name);
umask(0000);
p_myFileHandle=fopen(p_myWarmstartFileName,"w");
if (p_myFileHandle==NULL) {
printf( __FILE__ "[%d] Error: Couldn't open file >%s<\n",
__LINE__, p_myWarmstartFileName);
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
fprintf(p_myFileHandle,"%d",psbo->val);
fclose(p_myFileHandle);
}
} else {
switch ( p_myContext->warmstartMethod ) {
case WARMSTART_FETCH_DOL:
if (psbo->nsev >= INVALID_ALARM) {
printf(__FILE__ "[%d] Warning: Problem with link?\n", __LINE__);
printf(__FILE__ "[%d] Warning: Link may not exist\n", __LINE__);
printf(__FILE__ "[%d] Warning: Link may not be initialized yet\n",
__LINE__);
#ifdef DEBUG2
printf( __FILE__ "[%d] Fetching >%s<\n",
__LINE__, psbo->dol.value.pv_link.pvname);
#endif
callbackRequestDelayed(p_myContext->p_callback, SLEEPTIME_CALLBACK);
} else {
#ifdef DEBUG2
printf( __FILE__ "[%d] %s <-(%d|%d)-- %s\n",
__LINE__, psbo->name, psbo->val, psbo->val,
psbo->out.value.instio.string);
#endif
psbo->omsl=menuOmslsupervisory;
p_myContext->operatingMode=NORMAL_MODE;
}
break;
case WARMSTART_READ_FROM_FILE:
sprintf(p_myWarmstartFileName,WARMSTART_FILE_PREFIX "/%s", psbo->name);
p_myFileHandle=fopen(p_myWarmstartFileName,"r");
if (p_myFileHandle==NULL) {
/* File doesn't exist */
/* lopr is reset in init */
#ifdef DEBUG2
printf( __FILE__ "[%d] Warning: No file found!\n", __LINE__);
#endif
} else {
/* File exists */
int myVal;
fscanf(p_myFileHandle,"%d",&myVal);
psbo->val=(epicsEnum16)myVal;
fclose(p_myFileHandle);
}
p_myContext->operatingMode=NORMAL_MODE;
break;
case WARMSTART_NOP:
break;
default:
printf( __FILE__ "[%d] Error: Unknown warmstart method!\n", __LINE__);
sleep(SLEEPTIME_ERROR);
return(ERROR);
} /* end_of_switch */
}
#ifdef DEBUG1
printf( __FILE__ "[%d] <- %s\n", __LINE__, __func__);
#endif
return(SUCCESS);
}
