455 lines
13 KiB
C
455 lines
13 KiB
C
/*
|
||
* $Id$
|
||
*
|
||
* Author: John Winans
|
||
* Date: 09-21-92
|
||
*
|
||
* Experimental Physics and Industrial Control System (EPICS)
|
||
*
|
||
* Copyright 1991, the Regents of the University of California,
|
||
* and the University of Chicago Board of Governors.
|
||
*
|
||
* This software was produced under U.S. Government contracts:
|
||
* (W-7405-ENG-36) at the Los Alamos National Laboratory,
|
||
* and (W-31-109-ENG-38) at Argonne National Laboratory.
|
||
*
|
||
* Initial development by:
|
||
* The Controls and Automation Group (AT-8)
|
||
* Ground Test Accelerator
|
||
* Accelerator Technology Division
|
||
* Los Alamos National Laboratory
|
||
*
|
||
* Co-developed with
|
||
* The Controls and Computing Group
|
||
* Accelerator Systems Division
|
||
* Advanced Photon Source
|
||
* Argonne National Laboratory
|
||
*
|
||
* Modification Log:
|
||
* -----------------
|
||
* .02 04-19-94 jrw Added value fields and monitors on them
|
||
* .01 09-21-92 jrw created
|
||
*/
|
||
#include <stddef.h>
|
||
#include <stdlib.h>
|
||
#include <stdarg.h>
|
||
#include <stdio.h>
|
||
#include <string.h>
|
||
|
||
#include "dbDefs.h"
|
||
#include "epicsPrint.h"
|
||
#include "osiWatchdog.h"
|
||
#include "osiClock.h"
|
||
#include "alarm.h"
|
||
#include "dbAccess.h"
|
||
#include "dbEvent.h"
|
||
#include "dbFldTypes.h"
|
||
#include "devSup.h"
|
||
#include "errMdef.h"
|
||
#include "recSup.h"
|
||
#include "special.h"
|
||
#include "callback.h"
|
||
|
||
#define GEN_SIZE_OFFSET
|
||
#include "seqRecord.h"
|
||
#undef GEN_SIZE_OFFSET
|
||
|
||
int seqRecDebug = 0;
|
||
|
||
/* Create RSET - Record Support Entry Table*/
|
||
static long init_record(), process(), asyncFinish(), get_precision();
|
||
static void processCallback(), watchDog();
|
||
|
||
struct rset seqRSET={
|
||
RSETNUMBER,
|
||
NULL, /* report */
|
||
NULL, /* initialize */
|
||
init_record, /* init_record */
|
||
process, /* process */
|
||
NULL, /* special */
|
||
NULL, /* get_value */
|
||
NULL, /* cvt_dbaddr */
|
||
NULL, /* get_array_info */
|
||
NULL, /* put_array_info */
|
||
NULL, /* get_units */
|
||
get_precision, /* get_precision */
|
||
NULL, /* get_enum_str */
|
||
NULL, /* get_enum_strs */
|
||
NULL, /* put_enum_str */
|
||
NULL, /* get_graphic_double */
|
||
NULL, /* get_control_double */
|
||
NULL /* get_alarm_double */
|
||
|
||
};
|
||
|
||
/* Total number of link-groups in a sequence record */
|
||
#define NUM_LINKS 10
|
||
#define SELN_BIT_MASK ~(0xffff << NUM_LINKS)
|
||
|
||
/* This is what a link-group looks like in a sequence record */
|
||
struct linkDesc {
|
||
double dly; /* Delay value (in seconds) */
|
||
struct link dol; /* Where to fetch the input value from */
|
||
double dov; /* If dol is CONSTANT, this is the CONSTANT value */
|
||
struct link lnk; /* Where to put the value from dol */
|
||
};
|
||
|
||
/* Callback structure used by the watchdog function to queue link processing */
|
||
struct callbackSeq {
|
||
CALLBACK callBack; /* used for the callback task */
|
||
watchdogId wd_id; /* Watchdog udes for delays */
|
||
struct linkDesc *plinks[NUM_LINKS+1]; /* Pointers to links to process */
|
||
int index;
|
||
};
|
||
|
||
int processNextLink();
|
||
/*****************************************************************************
|
||
*
|
||
* Initialize a sequence record.
|
||
*
|
||
* Allocate the callback request structure (tacked on dpvt.)
|
||
* Initialize watch-dog ID
|
||
* Initialize SELN based on the link-type of SELL
|
||
* If SELL is a CA_LINK, inform CA about it
|
||
* For each constant input link, fill in the DOV field
|
||
*
|
||
******************************************************************************/
|
||
static long
|
||
init_record(pseq, pass)
|
||
struct seqRecord *pseq;
|
||
int pass;
|
||
{
|
||
int index;
|
||
struct linkDesc *plink;
|
||
struct callbackSeq *pcallbackSeq;
|
||
|
||
if (pass==0) return(0);
|
||
|
||
if (seqRecDebug > 5)
|
||
printf("init_record(%s) entered\n", pseq->name);
|
||
|
||
/* Allocate a callback structure for use in processing */
|
||
pseq->dpvt = (void *)malloc(sizeof(struct callbackSeq));
|
||
pcallbackSeq = (struct callbackSeq *)pseq->dpvt;
|
||
pcallbackSeq->callBack.callback = processCallback;
|
||
pcallbackSeq->callBack.user = (void *) pseq;
|
||
pcallbackSeq->wd_id = watchdogCreate();
|
||
|
||
/* Get link selection if sell is a constant and nonzero */
|
||
if (pseq->sell.type==CONSTANT)
|
||
{
|
||
if (seqRecDebug > 5)
|
||
printf("init_record(%s) SELL is a constant\n", pseq->name);
|
||
recGblInitConstantLink(&pseq->sell,DBF_USHORT,&pseq->seln);
|
||
}
|
||
|
||
/* Copy over ALL the input link constants here */
|
||
plink = (struct linkDesc *)(&(pseq->dly1));
|
||
|
||
index = 0;
|
||
while (index < NUM_LINKS)
|
||
{
|
||
|
||
if (plink->dol.type == CONSTANT)
|
||
recGblInitConstantLink(&plink->dol,DBF_DOUBLE,&plink->dov);
|
||
|
||
index++;
|
||
|
||
plink++;
|
||
}
|
||
|
||
return(0);
|
||
}
|
||
/*****************************************************************************
|
||
*
|
||
* Process a sequence record.
|
||
*
|
||
* If is async completion phase
|
||
* call asyncFinish() to finish things up
|
||
* else
|
||
* figure out selection mechanism
|
||
* build the correct mask value using the mode and the selection value
|
||
* build a list of pointers to the selected link-group structures
|
||
* If there are no links to process
|
||
* call asyncFinish() to finish things up
|
||
* else
|
||
* call processNextLink() to schecule a delay for the first link-group
|
||
*
|
||
*
|
||
* NOTE:
|
||
* dbScanLock is already held for pseq before this function is called.
|
||
*
|
||
* We do NOT call processNextLink() if there is nothing to do, this prevents
|
||
* us from calling dbProcess() recursively.
|
||
*
|
||
******************************************************************************/
|
||
static long
|
||
process(pseq)
|
||
struct seqRecord *pseq;
|
||
{
|
||
struct callbackSeq *pcb = (struct callbackSeq *) (pseq->dpvt);
|
||
struct linkDesc *plink;
|
||
unsigned short lmask;
|
||
int tmp;
|
||
|
||
if(seqRecDebug > 10)
|
||
printf("seqRecord: process(%s) pact = %d\n", pseq->name, pseq->pact);
|
||
|
||
if (pseq->pact)
|
||
{ /* In async completion phase */
|
||
asyncFinish((struct dbCommon *)pseq);
|
||
return(0);
|
||
}
|
||
pseq->pact = TRUE;
|
||
|
||
/* Reset the PRIO in case it was changed */
|
||
pcb->callBack.priority = pseq->prio;
|
||
|
||
/*
|
||
* We should not bother supporting seqSELM_All or seqSELM_Specified
|
||
* they can both be supported by simply providing seqSELM_Mask.
|
||
* build the proper mask using these other silly modes if necessary.
|
||
*/
|
||
|
||
if (pseq->selm == seqSELM_All)
|
||
{
|
||
lmask = SELN_BIT_MASK;
|
||
}
|
||
else
|
||
{
|
||
/* Fill in the SELN field */
|
||
if (pseq->sell.type != CONSTANT)
|
||
{
|
||
dbGetLink(&(pseq->sell), DBR_USHORT, &(pseq->seln), 0,0);
|
||
}
|
||
if (pseq->selm == seqSELM_Specified)
|
||
{
|
||
if(pseq->seln>10)
|
||
{ /* Invalid selection number */
|
||
recGblSetSevr(pseq,SOFT_ALARM,INVALID_ALARM);
|
||
return(asyncFinish(pseq));
|
||
}
|
||
if (pseq->seln == 0)
|
||
return(asyncFinish(pseq)); /* Nothing selected */
|
||
|
||
lmask = 1;
|
||
lmask <<= pseq->seln - 1;
|
||
}
|
||
else if (pseq->selm == seqSELM_Mask)
|
||
{
|
||
lmask = (pseq->seln) & SELN_BIT_MASK;
|
||
}
|
||
else
|
||
{ /* Invalid selection option */
|
||
recGblSetSevr(pseq,SOFT_ALARM,INVALID_ALARM);
|
||
return(asyncFinish(pseq));
|
||
}
|
||
}
|
||
/* Figure out which links are going to be processed */
|
||
pcb->index = 0;
|
||
plink = (struct linkDesc *)(&(pseq->dly1));
|
||
tmp = 1;
|
||
while (lmask)
|
||
{
|
||
if (seqRecDebug > 4)
|
||
printf("seqRec-process Checking link %d - lnk %d dol %d\n", tmp,
|
||
plink->lnk.type, plink->dol.type);
|
||
|
||
if ((lmask & 1) && ((plink->lnk.type != CONSTANT)||(plink->dol.type != CONSTANT)))
|
||
{
|
||
if (seqRecDebug > 4)
|
||
printf(" seqRec-process Adding link %d at index %d\n", tmp, pcb->index);
|
||
|
||
pcb->plinks[pcb->index] = plink;
|
||
pcb->index++;
|
||
}
|
||
lmask >>= 1;
|
||
plink++;
|
||
tmp++;
|
||
}
|
||
pcb->plinks[pcb->index] = NULL; /* mark the bottom of the list */
|
||
|
||
if (!pcb->index)
|
||
{ /* There was nothing to do, finish record processing here */
|
||
return(asyncFinish(pseq));
|
||
}
|
||
|
||
pcb->index = 0;
|
||
/* Start doing the first forward link (We have at least one for sure) */
|
||
processNextLink(pseq);
|
||
|
||
return(0);
|
||
}
|
||
/*****************************************************************************
|
||
*
|
||
* Find the next link-group that needs processing.
|
||
*
|
||
* If there are no link-groups left to process
|
||
* call bdProcess() to complete the async record processing.
|
||
* else
|
||
* if the delay is > 0 seconds
|
||
* schedule the watch dog task to wake us up later
|
||
* else
|
||
* invoke the watch-dog wakeup routine now
|
||
*
|
||
*
|
||
* NOTE:
|
||
* dbScanLock is already held for pseq before this function is called.
|
||
*
|
||
******************************************************************************/
|
||
int processNextLink(pseq)
|
||
struct seqRecord *pseq;
|
||
{
|
||
struct callbackSeq *pcb = (struct callbackSeq *) (pseq->dpvt);
|
||
int wdDelay;
|
||
|
||
if (seqRecDebug > 5)
|
||
printf("processNextLink(%s) looking for work to do, index = %d\n", pseq->name, pcb->index);
|
||
|
||
if (pcb->plinks[pcb->index] == NULL)
|
||
{
|
||
/* None left, finish up. */
|
||
(*(struct rset *)(pseq->rset)).process(pseq);
|
||
}
|
||
else
|
||
{
|
||
if (pcb->plinks[pcb->index]->dly > 0.0)
|
||
{
|
||
/* Use the watch-dog as a delay mechanism */
|
||
wdDelay = (int)(pcb->plinks[pcb->index]->dly * clockGetRate());
|
||
watchdogStart(pcb->wd_id, wdDelay,
|
||
(WATCHDOGFUNC)watchDog, (void *)(&(pcb->callBack)));
|
||
}
|
||
else
|
||
{
|
||
/* No delay, do it now. Avoid recursion by using the callback task */
|
||
watchDog((int)(&(pcb->callBack)));
|
||
}
|
||
}
|
||
return(0);
|
||
}
|
||
/*****************************************************************************
|
||
*
|
||
* Finish record processing by posting any events and processing forward links.
|
||
*
|
||
* NOTE:
|
||
* dbScanLock is already held for pseq before this function is called.
|
||
*
|
||
******************************************************************************/
|
||
static long
|
||
asyncFinish(pseq)
|
||
struct seqRecord *pseq;
|
||
{
|
||
unsigned short MonitorMask;
|
||
|
||
if (seqRecDebug > 5)
|
||
printf("asyncFinish(%s) completing processing\n", pseq->name);
|
||
pseq->udf = FALSE;
|
||
|
||
MonitorMask = recGblResetAlarms(pseq);
|
||
|
||
if (MonitorMask)
|
||
db_post_events(pseq, &pseq->val, MonitorMask);
|
||
|
||
/* process the forward scan link record */
|
||
recGblFwdLink(pseq);
|
||
|
||
recGblGetTimeStamp(pseq);
|
||
/* tsLocalTime(&pseq->time); */
|
||
pseq->pact = FALSE;
|
||
|
||
return(0);
|
||
}
|
||
/*****************************************************************************
|
||
*
|
||
* Schedule the process continuation via the callback tasks.
|
||
*
|
||
* This function is called by the watchdog task when it is time to process the
|
||
* "next" link-group in the sequence record.
|
||
*
|
||
******************************************************************************/
|
||
static void
|
||
watchDog(pcallback)
|
||
CALLBACK *pcallback;
|
||
{
|
||
callbackRequest(pcallback);
|
||
return;
|
||
}
|
||
/*****************************************************************************
|
||
*
|
||
* 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 pseq when this function is called!!
|
||
*
|
||
******************************************************************************/
|
||
static void
|
||
processCallback(pCallback)
|
||
CALLBACK *pCallback;
|
||
{
|
||
struct seqRecord *pseq = (struct seqRecord *)(pCallback->user);
|
||
struct callbackSeq *pcb = (struct callbackSeq *) (pseq->dpvt);
|
||
double myDouble;
|
||
|
||
dbScanLock((struct dbCommon *)pseq);
|
||
|
||
if (seqRecDebug > 5)
|
||
printf("processCallback(%s) processing field index %d\n", pseq->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);
|
||
|
||
/* 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(pseq, &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(pseq);
|
||
|
||
dbScanUnlock((struct dbCommon *)pseq);
|
||
return;
|
||
}
|
||
/*****************************************************************************
|
||
*
|
||
* Return the precision value from PREC
|
||
*
|
||
*****************************************************************************/
|
||
static long
|
||
get_precision(paddr, precision)
|
||
struct dbAddr *paddr;
|
||
long *precision;
|
||
{
|
||
struct seqRecord *pseq = (struct seqRecord *) paddr->precord;
|
||
|
||
*precision = pseq->prec;
|
||
|
||
if(paddr->pfield < (void *)&pseq->val)
|
||
return(0); /* Field is NOT in dbCommon */
|
||
|
||
recGblGetPrec(paddr, precision); /* Field is in dbCommon */
|
||
return(0);
|
||
}
|