epics/pcas
0
0
Fork 0
Code Issues Pull Requests Projects Wiki Activity

Changed to new callback format

Browse Source
This commit is contained in:
Marty Kraimer
1992-03-02 08:05:09 +00:00
parent a032a6be5a
commit ecd1773f5a
10 changed files with 129 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
src/dev/devAiTestAsyn.c
View File

@@ -48,6 +48,7 @@
#include <recSup.h>
#include <devSup.h>
#include <link.h>
#include <dbCommon.h>
#include <aiRecord.h>
/* Create the dset for devAiTestAsyn */
@@ -72,23 +73,21 @@ struct {
/* control block for callback*/
struct callback {
void (*callback)();
int priority;
struct dbCommon *prec;
CALLBACK callback;
struct dbCommon *precord;
WDOG_ID wd_id;
};
void callbackRequest();
static void myCallback(pcallback)
struct callback *pcallback;
{
struct aiRecord *pai=(struct aiRecord *)(pcallback->prec);
struct rset *prset=(struct rset *)(pai->rset);
struct dbCommon *precord=pcallback->precord;
struct rset *prset=(struct rset *)(precord->rset);
dbScanLock((struct dbCommon *)pai);
(*prset->process)(pai);
dbScanUnlock((struct dbCommon *)pai);
dbScanLock(precord);
(*prset->process)(precord);
dbScanUnlock(precord);
}
@@ -103,10 +102,9 @@ static long init_record(pai)
switch (pai->inp.type) {
case (CONSTANT) :
pcallback = (struct callback *)(calloc(1,sizeof(struct callback)));
pai->dpvt = (caddr_t)pcallback;
pcallback->callback = myCallback;
pcallback->priority = priorityLow;
pcallback->prec = (struct dbCommon *)pai;
pai->dpvt = (void *)pcallback;
callbackSetCallback(myCallback,pcallback);
pcallback->precord = (struct dbCommon *)pai;
pcallback->wd_id = wdCreate();
pai->val = pai->inp.value.value;
pai->udf = FALSE;
@@ -137,6 +135,7 @@ static long read_ai(pai)
} else {
wait_time = (int)(pai->disv * vxTicksPerSecond);
if(wait_time<=0) return(0);
callbackSetPriority(pai->prio,pcallback);
printf("%s Starting asynchronous processing\n",pai->name);
wdStart(pcallback->wd_id,wait_time,callbackRequest,(int)pcallback);
return(1);

25
src/dev/devAoTestAsyn.c
View File

@@ -50,6 +50,7 @@
#include <recSup.h>
#include <devSup.h>
#include <link.h>
#include <dbCommon.h>
#include <aoRecord.h>
/* Create the dset for devAoTestAsyn */
@@ -74,22 +75,20 @@ struct {
/* control block for callback*/
struct callback {
void (*callback)();
int priority;
struct dbCommon *prec;
CALLBACK callback;
struct dbCommon *precord;
WDOG_ID wd_id;
};
void callbackRequest();
static void myCallback(pcallback)
struct callback *pcallback;
{
struct aoRecord *pao=(struct aoRecord *)(pcallback->prec);
struct rset *prset=(struct rset *)(pao->rset);
struct dbCommon *precord=pcallback->precord;
struct rset *prset=(struct rset *)(precord->rset);
dbScanLock((struct dbCommon *)pao);
(*prset->process)(pao);
dbScanUnlock((struct dbCommon *)pao);
dbScanLock(precord);
(*prset->process)(precord);
dbScanUnlock(precord);
}
@@ -104,10 +103,9 @@ static long init_record(pao)
switch (pao->out.type) {
case (CONSTANT) :
pcallback = (struct callback *)(calloc(1,sizeof(struct callback)));
pao->dpvt = (caddr_t)pcallback;
pcallback->callback = myCallback;
pcallback->priority = priorityLow;
pcallback->prec = (struct dbCommon *)pao;
pao->dpvt = (void *)pcallback;
callbackSetCallback(myCallback,pcallback);
pcallback->precord = (struct dbCommon *)pao;
pcallback->wd_id = wdCreate();
break;
default :
@@ -136,6 +134,7 @@ static long write_ao(pao)
} else {
wait_time = (int)(pao->disv * vxTicksPerSecond);
if(wait_time<=0) return(0);
callbackSetPriority(pao->prio,pcallback);
printf("%s Starting asynchronous processing\n",pao->name);
wdStart(pcallback->wd_id,wait_time,callbackRequest,(int)pcallback);
return(1);

27
src/dev/devBiTestAsyn.c
View File

@@ -49,6 +49,7 @@
#include <recSup.h>
#include <devSup.h>
#include <link.h>
#include <dbCommon.h>
#include <biRecord.h>
/* Create the dset for devBiTestAsyn */
@@ -73,27 +74,23 @@ struct {
/* control block for callback*/
struct callback {
void (*callback)();
int priority;
struct dbCommon *prec;
CALLBACK callback;
struct dbCommon *precord;
WDOG_ID wd_id;
void (*process)();
};
void callbackRequest();
static void myCallback(pcallback)
struct callback *pcallback;
{
struct biRecord *pbi=(struct biRecord *)(pcallback->prec);
struct rset *prset=(struct rset *)(pbi->rset);
struct dbCommon *precord=pcallback->precord;
struct rset *prset=(struct rset *)(precord->rset);
dbScanLock((struct dbCommon *)pbi);
(*prset->process)(pbi);
dbScanUnlock((struct dbCommon *)pbi);
dbScanLock(precord);
(*prset->process)(precord);
dbScanUnlock(precord);
}
static long init_record(pbi)
struct biRecord *pbi;
@@ -105,10 +102,9 @@ static long init_record(pbi)
switch (pbi->inp.type) {
case (CONSTANT) :
pcallback = (struct callback *)(calloc(1,sizeof(struct callback)));
pbi->dpvt = (caddr_t)pcallback;
pcallback->callback = myCallback;
pcallback->priority = priorityLow;
pcallback->prec = (struct dbCommon *)pbi;
pbi->dpvt = (void *)pcallback;
callbackSetCallback(myCallback,pcallback);
pcallback->precord = (struct dbCommon *)pbi;
pcallback->wd_id = wdCreate();
pbi->val = pbi->inp.value.value;
pbi->udf = FALSE;
@@ -139,6 +135,7 @@ static long read_bi(pbi)
} else {
wait_time = (int)(pbi->disv * vxTicksPerSecond);
if(wait_time<=0) return(0);
callbackSetPriority(pbi->prio,pcallback);
printf("%s Starting asynchronous processing\n",pbi->name);
wdStart(pcallback->wd_id,wait_time,callbackRequest,(int)pcallback);
return(1);

30
src/dev/devBoTestAsyn.c
View File

@@ -51,6 +51,7 @@
#include <recSup.h>
#include <devSup.h>
#include <link.h>
#include <dbCommon.h>
#include <boRecord.h>
/* Create the dset for devBoTestAsyn */
@@ -75,25 +76,22 @@ struct {
/* control block for callback*/
struct callback {
void (*callback)();
int priority;
struct dbCommon *prec;
WDOG_ID wd_id;
CALLBACK callback;
struct dbCommon *precord;
WDOG_ID wd_id;
};
void callbackRequest();
static void myCallback(pcallback)
struct callback *pcallback;
{
struct boRecord *pbo=(struct boRecord *)(pcallback->prec);
struct rset *prset=(struct rset *)(pbo->rset);
struct dbCommon *precord=pcallback->precord;
struct rset *prset=(struct rset *)(precord->rset);
dbScanLock((struct dbCommon *)pbo);
(*prset->process)(pbo);
dbScanUnlock((struct dbCommon *)pbo);
dbScanLock(precord);
(*prset->process)(precord);
dbScanUnlock(precord);
}
static long init_record(pbo)
struct boRecord *pbo;
@@ -105,10 +103,9 @@ static long init_record(pbo)
switch (pbo->out.type) {
case (CONSTANT) :
pcallback = (struct callback *)(calloc(1,sizeof(struct callback)));
pbo->dpvt = (caddr_t)pcallback;
pcallback->callback = myCallback;
pcallback->priority = priorityLow;
pcallback->prec = (struct dbCommon *)pbo;
pbo->dpvt = (void *)pcallback;
callbackSetCallback(myCallback,pcallback);
pcallback->precord = (struct dbCommon *)pbo;
pcallback->wd_id = wdCreate();
break;
default :
@@ -137,6 +134,7 @@ static long write_bo(pbo)
} else {
wait_time = (int)(pbo->disv * vxTicksPerSecond);
if(wait_time<=0) return(0);
callbackSetPriority(pbo->prio,pcallback);
printf("%s Starting asynchronous processing\n",pbo->name);
wdStart(pcallback->wd_id,wait_time,callbackRequest,(int)pcallback);
return(1);

29
src/dev/devHistogramTestAsyn.c
View File

@@ -48,6 +48,7 @@
#include <recSup.h>
#include <devSup.h>
#include <link.h>
#include <dbCommon.h>
#include <histogramRecord.h>
/* Create the dset for devHistogramTestAsyn */
@@ -72,24 +73,20 @@ struct {
/* control block for callback*/
struct callback {
void (*callback)();
int priority;
struct dbCommon *prec;
WDOG_ID wd_id;
CALLBACK callback;
struct dbCommon *precord;
WDOG_ID wd_id;
};
void callbackRequest();
static void myCallback(pcallback)
struct callback *pcallback;
{
struct histogramRecord *phistogram=(struct histogramRecord *)(pcallback->prec);
struct rset *prset=(struct rset *)(phistogram->rset);
struct dbCommon *precord=pcallback->precord;
struct rset *prset=(struct rset *)(precord->rset);
dbScanLock((struct dbCommon *)phistogram);
(*prset->process)(phistogram);
dbScanUnlock((struct dbCommon *)phistogram);
return;
dbScanLock(precord);
(*prset->process)(precord);
dbScanUnlock(precord);
}
static long init_record(phistogram)
@@ -102,10 +99,9 @@ static long init_record(phistogram)
switch (phistogram->svl.type) {
case (CONSTANT) :
pcallback = (struct callback *)(calloc(1,sizeof(struct callback)));
phistogram->dpvt = (caddr_t)pcallback;
pcallback->callback = myCallback;
pcallback->priority = priorityLow;
pcallback->prec = (struct dbCommon *)phistogram;
phistogram->dpvt = (void *)pcallback;
callbackSetCallback(myCallback,pcallback);
pcallback->precord = (struct dbCommon *)phistogram;
pcallback->wd_id = wdCreate();
phistogram->sgnl = phistogram->svl.value.value;
break;
@@ -135,6 +131,7 @@ static long read_histogram(phistogram)
} else {
wait_time = (int)(phistogram->disv * vxTicksPerSecond);
if(wait_time<=0) return(0);
callbackSetPriority(phistogram->prio,pcallback);
printf("%s Starting asynchronous processing\n",phistogram->name);
wdStart(pcallback->wd_id,wait_time,callbackRequest,(int)pcallback);
return(1);

29
src/dev/devMbbiTestAsyn.c
View File

@@ -49,6 +49,7 @@
#include <recSup.h>
#include <devSup.h>
#include <link.h>
#include <dbCommon.h>
#include <mbbiRecord.h>
/* Create the dset for devMbbiTestAsyn */
@@ -73,26 +74,22 @@ struct {
/* control block for callback*/
struct callback {
void (*callback)();
int priority;
struct dbCommon *prec;
WDOG_ID wd_id;
CALLBACK callback;
struct dbCommon *precord;
WDOG_ID wd_id;
};
void callbackRequest();
static void myCallback(pcallback)
struct callback *pcallback;
{
struct mbbiRecord *pmbbi=(struct mbbiRecord *)(pcallback->prec);
struct rset *prset=(struct rset *)(pmbbi->rset);
struct dbCommon *precord=pcallback->precord;
struct rset *prset=(struct rset *)(precord->rset);
dbScanLock((struct dbCommon *)pmbbi);
(*prset->process)(pmbbi);
dbScanUnlock((struct dbCommon *)pmbbi);
dbScanLock(precord);
(*prset->process)(precord);
dbScanUnlock(precord);
}
static long init_record(pmbbi)
struct mbbiRecord *pmbbi;
@@ -104,10 +101,9 @@ static long init_record(pmbbi)
switch (pmbbi->inp.type) {
case (CONSTANT) :
pcallback = (struct callback *)(calloc(1,sizeof(struct callback)));
pmbbi->dpvt = (caddr_t)pcallback;
pcallback->callback = myCallback;
pcallback->priority = priorityLow;
pcallback->prec = (struct dbCommon *)pmbbi;
pmbbi->dpvt = (void *)pcallback;
callbackSetCallback(myCallback,pcallback);
pcallback->precord = (struct dbCommon *)pmbbi;
pcallback->wd_id = wdCreate();
pmbbi->val = pmbbi->inp.value.value;
pmbbi->udf = FALSE;
@@ -138,6 +134,7 @@ static long read_mbbi(pmbbi)
} else {
wait_time = (int)(pmbbi->disv * vxTicksPerSecond);
if(wait_time<=0) return(0);
callbackSetPriority(pmbbi->prio,pcallback);
printf("%s Starting asynchronous processing\n",pmbbi->name);
wdStart(pcallback->wd_id,wait_time,callbackRequest,(int)pcallback);
return(1);

27
src/dev/devMbboTestAsyn.c
View File

@@ -50,6 +50,7 @@
#include <recSup.h>
#include <devSup.h>
#include <link.h>
#include <dbCommon.h>
#include <mbboRecord.h>
/* Create the dset for devMbboTestAsyn */
@@ -74,22 +75,20 @@ struct {
/* control block for callback*/
struct callback {
void (*callback)();
int priority;
struct dbCommon *prec;
WDOG_ID wd_id;
CALLBACK callback;
struct dbCommon *precord;
WDOG_ID wd_id;
};
void callbackRequest();
static void myCallback(pcallback)
struct callback *pcallback;
{
struct mbboRecord *pmbbo=(struct mbboRecord *)(pcallback->prec);
struct rset *prset=(struct rset *)(pmbbo->rset);
struct dbCommon *precord=pcallback->precord;
struct rset *prset=(struct rset *)(precord->rset);
dbScanLock((struct dbCommon *)pmbbo);
(*prset->process)(pmbbo);
dbScanUnlock((struct dbCommon *)pmbbo);
dbScanLock(precord);
(*prset->process)(precord);
dbScanUnlock(precord);
}
@@ -104,10 +103,9 @@ static long init_record(pmbbo)
switch (pmbbo->out.type) {
case (CONSTANT) :
pcallback = (struct callback *)(calloc(1,sizeof(struct callback)));
pmbbo->dpvt = (caddr_t)pcallback;
pcallback->callback = myCallback;
pcallback->priority = priorityLow;
pcallback->prec = (struct dbCommon *)pmbbo;
pmbbo->dpvt = (void *)pcallback;
callbackSetCallback(myCallback,pcallback);
pcallback->precord = (struct dbCommon *)pmbbo;
pcallback->wd_id = wdCreate();
break;
default :
@@ -136,6 +134,7 @@ static long write_mbbo(pmbbo)
} else {
wait_time = (int)(pmbbo->disv * vxTicksPerSecond);
if(wait_time<=0) return(0);
callbackSetPriority(pmbbo->prio,pcallback);
printf("%s Starting asynchronous processing\n",pmbbo->name);
wdStart(pcallback->wd_id,wait_time,callbackRequest,(int)pcallback);
return(1);

29
src/dev/devSiTestAsyn.c
View File

@@ -48,6 +48,7 @@
#include <recSup.h>
#include <devSup.h>
#include <link.h>
#include <dbCommon.h>
#include <stringinRecord.h>
/* Create the dset for devSiTestAsyn */
@@ -72,26 +73,22 @@ struct {
/* control block for callback*/
struct callback {
void (*callback)();
int priority;
struct dbCommon *prec;
WDOG_ID wd_id;
CALLBACK callback;
struct dbCommon *precord;
WDOG_ID wd_id;
};
void callbackRequest();
static void myCallback(pcallback)
struct callback *pcallback;
{
struct stringinRecord *pstringin=(struct stringinRecord *)(pcallback->prec);
struct rset *prset=(struct rset *)(pstringin->rset);
struct dbCommon *precord=pcallback->precord;
struct rset *prset=(struct rset *)(precord->rset);
dbScanLock((struct dbCommon *)pstringin);
(*prset->process)(pstringin);
dbScanUnlock((struct dbCommon *)pstringin);
dbScanLock(precord);
(*prset->process)(precord);
dbScanUnlock(precord);
}
static long init_record(pstringin)
struct stringinRecord *pstringin;
@@ -103,10 +100,9 @@ static long init_record(pstringin)
switch (pstringin->inp.type) {
case (CONSTANT) :
pcallback = (struct callback *)(calloc(1,sizeof(struct callback)));
pstringin->dpvt = (caddr_t)pcallback;
pcallback->callback = myCallback;
pcallback->priority = priorityLow;
pcallback->prec = (struct dbCommon *)pstringin;
pstringin->dpvt = (void *)pcallback;
callbackSetCallback(myCallback,pcallback);
pcallback->precord = (struct dbCommon *)pstringin;
pcallback->wd_id = wdCreate();
if (pstringin->inp.value.value!=0.0) {
sprintf(pstringin->val,"%-14.7g",pstringin->inp.value.value);
@@ -139,6 +135,7 @@ static long read_stringin(pstringin)
} else {
wait_time = (int)(pstringin->disv * vxTicksPerSecond);
if(wait_time<=0) return(0);
callbackSetPriority(pstringin->prio,pcallback);
printf("%s Starting asynchronous processing\n",pstringin->name);
wdStart(pcallback->wd_id,wait_time,callbackRequest,(int)pcallback);
return(1);

28
src/dev/devSoTestAsyn.c
View File

@@ -49,6 +49,7 @@
#include <recSup.h>
#include <devSup.h>
#include <link.h>
#include <dbCommon.h>
#include <stringoutRecord.h>
/* Create the dset for devSoTestAsyn */
@@ -73,25 +74,22 @@ struct {
/* control block for callback*/
struct callback {
void (*callback)();
int priority;
struct dbCommon *prec;
WDOG_ID wd_id;
CALLBACK callback;
struct dbCommon *precord;
WDOG_ID wd_id;
};
void callbackRequest();
static void myCallback(pcallback)
struct callback *pcallback;
{
struct stringoutRecord *pstringout=(struct stringoutRecord *)(pcallback->prec);
struct rset *prset=(struct rset *)(pstringout->rset);
struct dbCommon *precord=pcallback->precord;
struct rset *prset=(struct rset *)(precord->rset);
dbScanLock((struct dbCommon *)pstringout);
(*prset->process)(pstringout);
dbScanUnlock((struct dbCommon *)pstringout);
dbScanLock(precord);
(*prset->process)(precord);
dbScanUnlock(precord);
}
static long init_record(pstringout)
struct stringoutRecord *pstringout;
@@ -103,10 +101,9 @@ static long init_record(pstringout)
switch (pstringout->out.type) {
case (CONSTANT) :
pcallback = (struct callback *)(calloc(1,sizeof(struct callback)));
pstringout->dpvt = (caddr_t)pcallback;
pcallback->callback = myCallback;
pcallback->priority = priorityLow;
pcallback->prec = (struct dbCommon *)pstringout;
pstringout->dpvt = (void *)pcallback;
callbackSetCallback(myCallback,pcallback);
pcallback->precord = (struct dbCommon *)pstringout;
pcallback->wd_id = wdCreate();
break;
default :
@@ -135,6 +132,7 @@ static long write_stringout(pstringout)
} else {
wait_time = (int)(pstringout->disv * vxTicksPerSecond);
if(wait_time<=0) return(0);
callbackSetPriority(pstringout->prio,pcallback);
printf("%s Starting asynchronous processing\n",pstringout->name);
wdStart(pcallback->wd_id,wait_time,callbackRequest,(int)pcallback);
return(1);

28
src/dev/devWfTestAsyn.c
View File

@@ -49,6 +49,7 @@
#include <recSup.h>
#include <devSup.h>
#include <link.h>
#include <dbCommon.h>
#include <waveformRecord.h>
/* Create the dset for devWfTestAsyn */
@@ -73,23 +74,22 @@ struct {
/* control block for callback*/
struct callback {
void (*callback)();
int priority;
struct dbCommon *prec;
WDOG_ID wd_id;
CALLBACK callback;
struct dbCommon *precord;
WDOG_ID wd_id;
};
void callbackRequest();
static void myCallback(pcallback)
struct callback *pcallback;
{
struct waveformRecord *pwf=(struct waveformRecord *)(pcallback->prec);
struct rset *prset=(struct rset *)(pwf->rset);
struct dbCommon *precord=pcallback->precord;
struct rset *prset=(struct rset *)(precord->rset);
dbScanLock((struct dbCommon *)pwf);
(*prset->process)(pwf);
dbScanUnlock((struct dbCommon *)pwf);
dbScanLock(precord);
(*prset->process)(precord);
dbScanUnlock(precord);
}
static long init_record(pwf)
struct waveformRecord *pwf;
{
@@ -100,10 +100,9 @@ static long init_record(pwf)
switch (pwf->inp.type) {
case (CONSTANT) :
pcallback = (struct callback *)(calloc(1,sizeof(struct callback)));
pwf->dpvt = (caddr_t)pcallback;
pcallback->callback = myCallback;
pcallback->priority = priorityLow;
pcallback->prec = (struct dbCommon *)pwf;
pwf->dpvt = (void *)pcallback;
callbackSetCallback(myCallback,pcallback);
pcallback->precord = (struct dbCommon *)pwf;
pcallback->wd_id = wdCreate();
pwf->nord = 0;
break;
@@ -133,6 +132,7 @@ static long read_wf(pwf)
} else {
wait_time = (int)(pwf->disv * vxTicksPerSecond);
if(wait_time<=0) return(0);
callbackSetPriority(pwf->prio,pcallback);
printf("%s Starting asynchronous processing\n",pwf->name);
wdStart(pcallback->wd_id,wait_time,callbackRequest,(int)pcallback);
return(1);