diff --git a/documentation/RELEASE_NOTES.html b/documentation/RELEASE_NOTES.html index c9f4340ba..872b63d32 100644 --- a/documentation/RELEASE_NOTES.html +++ b/documentation/RELEASE_NOTES.html @@ -12,6 +12,37 @@

Changes between 3.14.9 and 3.14.10

+

Array Subroutine Record added (aSub)

+ +

A heavily modified version of Andy Foster's genSub record type has been +added, called the aSub (Array Subroutine) record type. The new name is so that +genSub records can continue to be used in IOCs that need those features that +have changed or been removed in creating the aSub record type. The main +differences between genSub and aSub are:

+ + +

epicsTimeEventDeviceTime support for soft channel input records

The Soft Channel device support for all input record types now supports the diff --git a/src/makeBaseApp/top/exampleApp/Db/dbSubExample.db b/src/makeBaseApp/top/exampleApp/Db/dbSubExample.db index 96b86387d..cf94d09e6 100644 --- a/src/makeBaseApp/top/exampleApp/Db/dbSubExample.db +++ b/src/makeBaseApp/top/exampleApp/Db/dbSubExample.db @@ -3,3 +3,11 @@ record(sub,"$(user):subExample") field(INAM,"mySubInit") field(SNAM,"mySubProcess") } +record(aSub,"$(user):aSubExample") +{ + field(INAM,"myAsubInit") + field(SNAM,"myAsubProcess") + field(FTA,"DOUBLE") + field(NOA,"10") + field(INPA,"$(user):compressExample CPP") +} diff --git a/src/makeBaseApp/top/exampleApp/src/dbSubExample.c b/src/makeBaseApp/top/exampleApp/src/dbSubExample.c index 9a5776d8c..1cc748b12 100644 --- a/src/makeBaseApp/top/exampleApp/src/dbSubExample.c +++ b/src/makeBaseApp/top/exampleApp/src/dbSubExample.c @@ -3,18 +3,17 @@ #include #include #include +#include #include int mySubDebug; -typedef long (*processMethod)(subRecord *precord); - -static long mySubInit(subRecord *precord,processMethod process) +static long mySubInit(subRecord *precord) { if (mySubDebug) - printf("Record %s called mySubInit(%p, %p)\n", - precord->name, (void*) precord, (void*) process); - return(0); + printf("Record %s called mySubInit(%p)\n", + precord->name, (void*) precord); + return 0; } static long mySubProcess(subRecord *precord) @@ -22,7 +21,23 @@ static long mySubProcess(subRecord *precord) if (mySubDebug) printf("Record %s called mySubProcess(%p)\n", precord->name, (void*) precord); - return(0); + return 0; +} + +static long myAsubInit(aSubRecord *precord) +{ + if (mySubDebug) + printf("Record %s called myAsubInit(%p)\n", + precord->name, (void*) precord); + return 0; +} + +static long myAsubProcess(aSubRecord *precord) +{ + if (mySubDebug) + printf("Record %s called myAsubProcess(%p)\n", + precord->name, (void*) precord); + return 0; } /* Register these symbols for use by IOC code: */ @@ -30,3 +45,5 @@ static long mySubProcess(subRecord *precord) epicsExportAddress(int, mySubDebug); epicsRegisterFunction(mySubInit); epicsRegisterFunction(mySubProcess); +epicsRegisterFunction(myAsubInit); +epicsRegisterFunction(myAsubProcess); diff --git a/src/makeBaseApp/top/exampleApp/src/dbSubExample.dbd b/src/makeBaseApp/top/exampleApp/src/dbSubExample.dbd index a907fb708..5f6e40ac7 100644 --- a/src/makeBaseApp/top/exampleApp/src/dbSubExample.dbd +++ b/src/makeBaseApp/top/exampleApp/src/dbSubExample.dbd @@ -1,3 +1,5 @@ variable(mySubDebug) function(mySubInit) function(mySubProcess) +function(myAsubInit) +function(myAsubProcess) diff --git a/src/misc/base.dbd b/src/misc/base.dbd index 6cf62fd72..03408dbed 100644 --- a/src/misc/base.dbd +++ b/src/misc/base.dbd @@ -10,6 +10,7 @@ include "menuConvert.dbd" # Record types include "aiRecord.dbd" include "aoRecord.dbd" +include "aSubRecord.dbd" include "biRecord.dbd" include "boRecord.dbd" include "calcRecord.dbd" diff --git a/src/rec/Makefile b/src/rec/Makefile index 3e7cdfa50..0d4b78aa8 100644 --- a/src/rec/Makefile +++ b/src/rec/Makefile @@ -14,6 +14,7 @@ DBDINC += aaiRecord DBDINC += aaoRecord DBDINC += aiRecord DBDINC += aoRecord +DBDINC += aSubRecord DBDINC += biRecord DBDINC += boRecord DBDINC += calcRecord @@ -43,6 +44,7 @@ LIBSRCS += aaiRecord.c LIBSRCS += aaoRecord.c LIBSRCS += aiRecord.c LIBSRCS += aoRecord.c +LIBSRCS += aSubRecord.c LIBSRCS += biRecord.c LIBSRCS += boRecord.c LIBSRCS += calcRecord.c diff --git a/src/rec/aSubRecord.c b/src/rec/aSubRecord.c new file mode 100644 index 000000000..be0bee0e3 --- /dev/null +++ b/src/rec/aSubRecord.c @@ -0,0 +1,501 @@ +/*************************************************************************\ +* Copyright (c) 2008 UChicago Argonne LLC, as Operator of Argonne +* National Laboratory. +* EPICS BASE is distributed subject to a Software License Agreement found +* in file LICENSE that is included with this distribution. +\*************************************************************************/ +/* $Id$ + * + * Record Support Routines for the Array Subroutine Record type, + * derived from Andy Foster's genSub record, with some features + * removed and asynchronous support added. + * + * Original Author: Andy Foster + * Revised by: Andrew Johnson + * + */ + +#include +#include +#include + +#include "alarm.h" +#include "cantProceed.h" +#include "dbDefs.h" +#include "dbEvent.h" +#include "dbAccess.h" +#include "dbFldTypes.h" +#include "dbStaticLib.h" +#include "errMdef.h" +#include "recSup.h" +#include "devSup.h" +#include "special.h" +#include "registryFunction.h" +#include "epicsExport.h" +#include "recGbl.h" + +#define GEN_SIZE_OFFSET +#include "aSubRecord.h" +#undef GEN_SIZE_OFFSET + + +typedef long (*GENFUNCPTR)(struct aSubRecord *); + +/* Create RSET - Record Support Entry Table*/ + +#define report NULL +#define initialize NULL +static long init_record(aSubRecord *, int); +static long process(aSubRecord *); +static long special(DBADDR *, int); +static long get_value(aSubRecord *, struct valueDes *); +static long cvt_dbaddr(DBADDR *); +static long get_array_info(DBADDR *, long *, long *); +static long put_array_info(DBADDR *, long ); +#define get_units NULL +static long get_precision(DBADDR *, long *); +#define get_enum_str NULL +#define get_enum_strs NULL +#define put_enum_str NULL +#define get_graphic_double NULL +#define get_control_double NULL +#define get_alarm_double NULL + +rset aSubRSET = { + RSETNUMBER, + report, + initialize, + init_record, + process, + special, + get_value, + cvt_dbaddr, + get_array_info, + put_array_info, + get_units, + get_precision, + get_enum_str, + get_enum_strs, + put_enum_str, + get_graphic_double, + get_control_double, + get_alarm_double +}; +epicsExportAddress(rset, aSubRSET); + +static long initFields(epicsEnum16 *pft, epicsUInt32 *pno, epicsUInt32 *pne, + const char **fldnames, void **pval, void **povl); +static long fetch_values(aSubRecord *prec); +static void monitor(aSubRecord *); +static long do_sub(aSubRecord *); + +#define NUM_ARGS 21 +#define MAX_ARRAY_SIZE 10000000 + +/* These are the names of the Input fields */ +static const char *Ifldnames[] = { + "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", + "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U" +}; + +/* These are the names of the Output fields */ +static const char *Ofldnames[] = { + "VALA", "VALB", "VALC", "VALD", "VALE", "VALF", "VALG", + "VALH", "VALI", "VALJ", "VALK", "VALL", "VALM", "VALN", + "VALO", "VALP", "VALQ", "VALR", "VALS", "VALT", "VALU" +}; + + +static long init_record(aSubRecord *prec, int pass) +{ + GENFUNCPTR pfunc; + long status; + int i; + + status = 0; + if (pass == 0) { + /* Allocate memory for arrays */ + initFields(&prec->fta, &prec->noa, &prec->nea, Ifldnames, + &prec->a, NULL); + initFields(&prec->ftva, &prec->nova, &prec->neva, Ofldnames, + &prec->vala, &prec->ovla); + return 0; + } + + /* Initialize the Subroutine Name Link */ + switch (prec->subl.type) { + case CONSTANT: + recGblInitConstantLink(&prec->subl, DBF_STRING, prec->snam); + break; + + case PV_LINK: + case DB_LINK: + case CA_LINK: + break; + + default: + recGblRecordError(S_db_badField, (void *)prec, + "aSubRecord(init_record) Bad SUBL link type"); + return S_db_badField; + } + + /* Initialize Input Links */ + for (i = 0; i < NUM_ARGS; i++) { + struct link *plink = &(&prec->inpa)[i]; + switch (plink->type) { + case CONSTANT: + if ((&prec->noa)[i] < 2) { + if (recGblInitConstantLink(plink, (&prec->fta)[i], (&prec->a)[i])) { + prec->udf = FALSE; + } else + prec->udf = TRUE; + } + break; + + case PV_LINK: + case CA_LINK: + case DB_LINK: + break; + + default: + recGblRecordError(S_db_badField, (void *)prec, + "aSubRecord(init_record) Illegal INPUT LINK"); + status = S_db_badField; + break; + } + } + + if (status) + return status; + + /* Initialize Output Links */ + for (i = 0; i < NUM_ARGS; i++) { + switch ((&prec->outa)[i].type) { + case CONSTANT: + case PV_LINK: + case CA_LINK: + case DB_LINK: + break; + + default: + recGblRecordError(S_db_badField, (void *)prec, + "aSubRecord(init_record) Illegal OUTPUT LINK"); + status = S_db_badField; + } + } + if (status) + return status; + + /* Call the user initialization routine if there is one */ + if (prec->inam[0] != 0) { + pfunc = (GENFUNCPTR)registryFunctionFind(prec->inam); + if (pfunc) { + pfunc(prec); + } else { + recGblRecordError(S_db_BadSub, (void *)prec, + "aSubRecord::init_record - INAM subr not found"); + return S_db_BadSub; + } + } + + if (prec->lflg == aSubLFLG_IGNORE && + prec->snam[0] != 0) { + pfunc = (GENFUNCPTR)registryFunctionFind(prec->snam); + if (pfunc) + prec->sadr = pfunc; + else { + recGblRecordError(S_db_BadSub, (void *)prec, + "aSubRecord::init_record - SNAM subr not found"); + return S_db_BadSub; + } + } + return 0; +} + + +static long initFields(epicsEnum16 *pft, epicsUInt32 *pno, epicsUInt32 *pne, + const char **fldnames, void **pval, void **povl) +{ + int i; + long status = 0; + + for (i = 0; i < NUM_ARGS; i++, pft++, pno++, pne++, pval++) { + epicsUInt32 num; + epicsUInt32 flen; + + if (*pft > DBF_ENUM) + *pft = DBF_CHAR; + + if (*pno == 0) + *pno = 1; + + flen = dbValueSize(*pft); + num = *pno * flen; + + if (num > MAX_ARRAY_SIZE) { + epicsPrintf("Link %s - Array too large! %d Bytes\n", fldnames[i], num); + *pno = num = 0; + status = S_db_errArg; + } else + *pval = (char *)callocMustSucceed(*pno, flen, + "aSubRecord::init_record"); + + *pne = *pno; + + if (povl) { + if (num) + *povl = (char *)callocMustSucceed(*pno, flen, + "aSubRecord::init_record"); + povl++; + } + } + return status; +} + + +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 fetch_values(aSubRecord *prec) +{ + long status; + int i; + + if (prec->lflg == aSubLFLG_READ) { + /* Get the Subroutine Name and look it up if changed */ + status = dbGetLink(&prec->subl, DBR_STRING, prec->snam, 0, 0); + if (status) + return status; + + if (prec->snam[0] != 0 && + strcmp(prec->snam, prec->onam)) { + GENFUNCPTR pfunc = (GENFUNCPTR)registryFunctionFind(prec->snam); + + if (!pfunc) + return S_db_BadSub; + + prec->sadr = pfunc; + strcpy(prec->onam, prec->snam); + } + } + + /* Get the input link values */ + for (i = 0; i < NUM_ARGS; i++) { + long nRequest = (&prec->noa)[i]; + status = dbGetLink(&(&prec->inpa)[i], (&prec->fta)[i], (&prec->a)[i], 0, + &nRequest); + if (nRequest > 0) + (&prec->nea)[i] = nRequest; + if (status) + return status; + } + return 0; +} + +static long get_precision(DBADDR *paddr, long *precision) +{ + aSubRecord *prec = (aSubRecord *)paddr->precord; + int fieldIndex = dbGetFieldIndex(paddr); + + if (fieldIndex == aSubRecordVAL) { + *precision = prec->prec; + return 0; + } + recGblGetPrec(paddr, precision); + return 0; +} + + +static long get_value(aSubRecord *prec, struct valueDes *pvdes) +{ + pvdes->no_elements = 1; + pvdes->pvalue = (void *)(&prec->val); + pvdes->field_type = DBF_LONG; + return 0; +} + + +static void monitor(aSubRecord *prec) +{ + int i; + unsigned short monitor_mask; + + monitor_mask = recGblResetAlarms(prec) | DBE_VALUE | DBE_LOG; + + /* Post events for VAL field */ + if (prec->val != prec->oval) { + db_post_events(prec, &prec->val, monitor_mask); + prec->oval = prec->val; + } + + /* Event posting on VAL arrays depends on the setting of prec->eflg */ + switch (prec->eflg) { + case aSubEFLG_NEVER: + break; + case aSubEFLG_ON_CHANGE: + for (i = 0; i < NUM_ARGS; i++) { + epicsUInt32 alen = dbValueSize((&prec->ftva)[i]) * (&prec->neva)[i]; + void *povl = (&prec->ovla)[i]; + void *pval = (&prec->vala)[i]; + if (memcmp(povl, pval, alen)) { + memcpy(povl, pval, alen); + db_post_events(prec, pval, monitor_mask); + } + } + break; + case aSubEFLG_ALWAYS: + for (i = 0; i < NUM_ARGS; i++) + db_post_events(prec, (&prec->vala)[i], monitor_mask); + break; + } + return; +} + + +static long do_sub(aSubRecord *prec) +{ + GENFUNCPTR pfunc = prec->sadr; + long status; + + if (prec->snam[0] == 0) + return 0; + + if (pfunc == NULL) { + recGblSetSevr(prec, BAD_SUB_ALARM, INVALID_ALARM); + return S_db_BadSub; + } + status = pfunc(prec); + if (status < 0) + recGblSetSevr(prec, SOFT_ALARM, prec->brsv); + else + prec->udf = FALSE; + + return status; +} + + +static long cvt_dbaddr(DBADDR *paddr) +{ + aSubRecord *prec = (aSubRecord *)paddr->precord; + int fieldIndex = dbGetFieldIndex(paddr); + + if (fieldIndex >= aSubRecordA && + fieldIndex <= aSubRecordU) { + int offset = fieldIndex - aSubRecordA; + paddr->pfield = (&prec->a )[offset]; + paddr->no_elements = (&prec->noa)[offset]; + paddr->field_type = (&prec->fta)[offset]; + } + else if (fieldIndex >= aSubRecordVALA && + fieldIndex <= aSubRecordVALU) { + int offset = fieldIndex - aSubRecordVALA; + paddr->pfield = (&prec->vala)[offset]; + paddr->no_elements = (&prec->nova)[offset]; + paddr->field_type = (&prec->ftva)[offset]; + } + else { + errlogPrintf("aSubRecord::cvt_dbaddr called for %s.%s\n", + prec->name, ((dbFldDes *)paddr->pfldDes)->name); + return 0; + } + paddr->dbr_field_type = paddr->field_type; + paddr->field_size = dbValueSize(paddr->field_type); + return 0; +} + + +static long get_array_info(DBADDR *paddr, long *no_elements, long *offset) +{ + aSubRecord *prec = (aSubRecord *)paddr->precord; + int fieldIndex = dbGetFieldIndex(paddr); + + if (fieldIndex >= aSubRecordA && + fieldIndex <= aSubRecordU) { + *no_elements = (&prec->nea)[fieldIndex - aSubRecordA]; + } + else if (fieldIndex >= aSubRecordVALA && + fieldIndex <= aSubRecordVALU) { + *no_elements = (&prec->neva)[fieldIndex - aSubRecordVALA]; + } + else { + errlogPrintf("aSubRecord::get_array_info called for %s.%s\n", + prec->name, ((dbFldDes *)paddr->pfldDes)->name); + } + *offset = 0; + + return 0; +} + + +static long put_array_info(DBADDR *paddr, long nNew) +{ + aSubRecord *prec = (aSubRecord *)paddr->precord; + int fieldIndex = dbGetFieldIndex(paddr); + + if (fieldIndex >= aSubRecordA && + fieldIndex <= aSubRecordU) { + (&prec->nea)[fieldIndex - aSubRecordA] = nNew; + } + else if (fieldIndex >= aSubRecordVALA && + fieldIndex <= aSubRecordVALU) { + (&prec->neva)[fieldIndex - aSubRecordVALA] = nNew; + } + else { + errlogPrintf("aSubRecord::put_array_info called for %s.%s\n", + prec->name, ((dbFldDes *)paddr->pfldDes)->name); + } + return 0; +} + + +static long special(DBADDR *paddr, int after) +{ + aSubRecord *prec = (aSubRecord *)paddr->precord; + + if (after && + prec->lflg == aSubLFLG_IGNORE) { + if (prec->snam[0] == 0) + return 0; + + prec->sadr = (GENFUNCPTR)registryFunctionFind(prec->snam); + if (!prec->sadr) { + recGblRecordError(S_db_BadSub, (void *)prec, prec->snam); + return S_db_BadSub; + } + } + return 0; +} diff --git a/src/rec/aSubRecord.dbd b/src/rec/aSubRecord.dbd new file mode 100644 index 000000000..a860ae966 --- /dev/null +++ b/src/rec/aSubRecord.dbd @@ -0,0 +1,1637 @@ +menu(aSubLFLG) { + choice(aSubLFLG_IGNORE,"IGNORE") + choice(aSubLFLG_READ,"READ") +} + +menu(aSubEFLG) { + choice(aSubEFLG_NEVER,"NEVER") + choice(aSubEFLG_ON_CHANGE,"ON CHANGE") + choice(aSubEFLG_ALWAYS,"ALWAYS") +} + +recordtype(aSub) { + include "dbCommon.dbd" + field(VAL,DBF_LONG) { + prompt("Subr. return value") + asl(ASL0) + } + field(OVAL,DBF_LONG) { + prompt("Old return value") + special(SPC_NOMOD) + interest(3) + } + field(INAM,DBF_STRING) { + prompt("Initialize Subr. Name") + promptgroup(GUI_SUB) + special(SPC_NOMOD) + interest(1) + size(41) + } + field(LFLG,DBF_MENU) { + prompt("Subr. Input Enable") + promptgroup(GUI_SUB) + interest(1) + menu(aSubLFLG) + } + field(SUBL,DBF_INLINK) { + prompt("Subroutine Name Link") + promptgroup(GUI_SUB) + special(SPC_NOMOD) + interest(1) + } + field(SNAM,DBF_STRING) { + prompt("Process Subr. Name") + promptgroup(GUI_SUB) + special(SPC_MOD) + interest(1) + size(41) + } + field(ONAM,DBF_STRING) { + prompt("Old Subr. Name") + promptgroup(GUI_SUB) + special(SPC_NOMOD) + interest(3) + size(41) + } + %struct aSubRecord; + field(SADR,DBF_NOACCESS) { + prompt("Subroutine Address") + special(SPC_NOMOD) + interest(2) + extra("long (*sadr)(struct aSubRecord *)") + } + field(BRSV,DBF_MENU) { + prompt("Bad Return Severity") + promptgroup(GUI_SUB) + pp(TRUE) + interest(1) + menu(menuAlarmSevr) + } + field(PREC,DBF_SHORT) { + prompt("Display Precision") + promptgroup(GUI_DISPLAY) + interest(1) + } + field(EFLG,DBF_MENU) { + prompt("Output Event Flag") + promptgroup(GUI_OUTPUT) + interest(1) + menu(aSubEFLG) + initial("1") + } + field(INPA,DBF_INLINK) { + prompt("Input Link A") + promptgroup(GUI_INPUTS) + interest(1) + } + field(INPB,DBF_INLINK) { + prompt("Input Link B") + promptgroup(GUI_INPUTS) + interest(1) + } + field(INPC,DBF_INLINK) { + prompt("Input Link C") + promptgroup(GUI_INPUTS) + interest(1) + } + field(INPD,DBF_INLINK) { + prompt("Input Link D") + promptgroup(GUI_INPUTS) + interest(1) + } + field(INPE,DBF_INLINK) { + prompt("Input Link E") + promptgroup(GUI_INPUTS) + interest(1) + } + field(INPF,DBF_INLINK) { + prompt("Input Link F") + promptgroup(GUI_INPUTS) + interest(1) + } + field(INPG,DBF_INLINK) { + prompt("Input Link G") + promptgroup(GUI_INPUTS) + interest(1) + } + field(INPH,DBF_INLINK) { + prompt("Input Link H") + promptgroup(GUI_INPUTS) + interest(1) + } + field(INPI,DBF_INLINK) { + prompt("Input Link I") + promptgroup(GUI_INPUTS) + interest(1) + } + field(INPJ,DBF_INLINK) { + prompt("Input Link J") + promptgroup(GUI_INPUTS) + interest(1) + } + field(INPK,DBF_INLINK) { + prompt("Input Link K") + promptgroup(GUI_INPUTS) + interest(1) + } + field(INPL,DBF_INLINK) { + prompt("Input Link L") + promptgroup(GUI_INPUTS) + interest(1) + } + field(INPM,DBF_INLINK) { + prompt("Input Link M") + promptgroup(GUI_INPUTS) + interest(1) + } + field(INPN,DBF_INLINK) { + prompt("Input Link N") + promptgroup(GUI_INPUTS) + interest(1) + } + field(INPO,DBF_INLINK) { + prompt("Input Link O") + promptgroup(GUI_INPUTS) + interest(1) + } + field(INPP,DBF_INLINK) { + prompt("Input Link P") + promptgroup(GUI_INPUTS) + interest(1) + } + field(INPQ,DBF_INLINK) { + prompt("Input Link Q") + promptgroup(GUI_INPUTS) + interest(1) + } + field(INPR,DBF_INLINK) { + prompt("Input Link R") + promptgroup(GUI_INPUTS) + interest(1) + } + field(INPS,DBF_INLINK) { + prompt("Input Link S") + promptgroup(GUI_INPUTS) + interest(1) + } + field(INPT,DBF_INLINK) { + prompt("Input Link T") + promptgroup(GUI_INPUTS) + interest(1) + } + field(INPU,DBF_INLINK) { + prompt("Input Link U") + promptgroup(GUI_INPUTS) + interest(1) + } + field(A,DBF_NOACCESS) { + prompt("Input value A") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *a") + } + field(B,DBF_NOACCESS) { + prompt("Input value B") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *b") + } + field(C,DBF_NOACCESS) { + prompt("Input value C") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *c") + } + field(D,DBF_NOACCESS) { + prompt("Input value D") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *d") + } + field(E,DBF_NOACCESS) { + prompt("Input value E") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *e") + } + field(F,DBF_NOACCESS) { + prompt("Input value F") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *f") + } + field(G,DBF_NOACCESS) { + prompt("Input value G") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *g") + } + field(H,DBF_NOACCESS) { + prompt("Input value H") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *h") + } + field(I,DBF_NOACCESS) { + prompt("Input value I") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *i") + } + field(J,DBF_NOACCESS) { + prompt("Input value J") + asl(ASL0) + special(SPC_DBADDR) + pp(TRUE) + interest(2) + extra("void *j") + } + field(K,DBF_NOACCESS) { + prompt("Input value K") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *k") + } + field(L,DBF_NOACCESS) { + prompt("Input value L") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *l") + } + field(M,DBF_NOACCESS) { + prompt("Input value M") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *m") + } + field(N,DBF_NOACCESS) { + prompt("Input value N") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *n") + } + field(O,DBF_NOACCESS) { + prompt("Input value O") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *o") + } + field(P,DBF_NOACCESS) { + prompt("Input value P") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *p") + } + field(Q,DBF_NOACCESS) { + prompt("Input value Q") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *q") + } + field(R,DBF_NOACCESS) { + prompt("Input value R") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *r") + } + field(S,DBF_NOACCESS) { + prompt("Input value S") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *s") + } + field(T,DBF_NOACCESS) { + prompt("Input value T") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *t") + } + field(U,DBF_NOACCESS) { + prompt("Input value U") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *u") + } + field(FTA,DBF_MENU) { + prompt("Type of A") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTB,DBF_MENU) { + prompt("Type of B") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTC,DBF_MENU) { + prompt("Type of C") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTD,DBF_MENU) { + prompt("Type of D") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTE,DBF_MENU) { + prompt("Type of E") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTF,DBF_MENU) { + prompt("Type of F") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTG,DBF_MENU) { + prompt("Type of G") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTH,DBF_MENU) { + prompt("Type of H") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTI,DBF_MENU) { + prompt("Type of I") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTJ,DBF_MENU) { + prompt("Type of J") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTK,DBF_MENU) { + prompt("Type of K") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTL,DBF_MENU) { + prompt("Type of L") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTM,DBF_MENU) { + prompt("Type of M") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTN,DBF_MENU) { + prompt("Type of N") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTO,DBF_MENU) { + prompt("Type of O") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTP,DBF_MENU) { + prompt("Type of P") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTQ,DBF_MENU) { + prompt("Type of Q") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTR,DBF_MENU) { + prompt("Type of R") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTS,DBF_MENU) { + prompt("Type of S") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTT,DBF_MENU) { + prompt("Type of T") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTU,DBF_MENU) { + prompt("Type of U") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(NOA,DBF_ULONG) { + prompt("Max. elements in A") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOB,DBF_ULONG) { + prompt("Max. elements in B") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOC,DBF_ULONG) { + prompt("Max. elements in C") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOD,DBF_ULONG) { + prompt("Max. elements in D") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOE,DBF_ULONG) { + prompt("Max. elements in E") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOF,DBF_ULONG) { + prompt("Max. elements in F") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOG,DBF_ULONG) { + prompt("Max. elements in G") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOH,DBF_ULONG) { + prompt("Max. elements in H") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOI,DBF_ULONG) { + prompt("Max. elements in I") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOJ,DBF_ULONG) { + prompt("Max. elements in J") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOK,DBF_ULONG) { + prompt("Max. elements in K") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOL,DBF_ULONG) { + prompt("Max. elements in L") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOM,DBF_ULONG) { + prompt("Max. elements in M") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NON,DBF_ULONG) { + prompt("Max. elements in N") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOO,DBF_ULONG) { + prompt("Max. elements in O") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOP,DBF_ULONG) { + prompt("Max. elements in P") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOQ,DBF_ULONG) { + prompt("Max. elements in Q") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOR,DBF_ULONG) { + prompt("Max. elements in R") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOS,DBF_ULONG) { + prompt("Max. elements in S") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOT,DBF_ULONG) { + prompt("Max. elements in T") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOU,DBF_ULONG) { + prompt("Max. elements in U") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NEA,DBF_ULONG) { + prompt("Num. elements in A") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEB,DBF_ULONG) { + prompt("Num. elements in B") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEC,DBF_ULONG) { + prompt("Num. elements in C") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NED,DBF_ULONG) { + prompt("Num. elements in D") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEE,DBF_ULONG) { + prompt("Num. elements in E") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEF,DBF_ULONG) { + prompt("Num. elements in F") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEG,DBF_ULONG) { + prompt("Num. elements in G") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEH,DBF_ULONG) { + prompt("Num. elements in H") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEI,DBF_ULONG) { + prompt("Num. elements in I") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEJ,DBF_ULONG) { + prompt("Num. elements in J") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEK,DBF_ULONG) { + prompt("Num. elements in K") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEL,DBF_ULONG) { + prompt("Num. elements in L") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEM,DBF_ULONG) { + prompt("Num. elements in M") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEN,DBF_ULONG) { + prompt("Num. elements in N") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEO,DBF_ULONG) { + prompt("Num. elements in O") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEP,DBF_ULONG) { + prompt("Num. elements in P") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEQ,DBF_ULONG) { + prompt("Num. elements in Q") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NER,DBF_ULONG) { + prompt("Num. elements in R") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NES,DBF_ULONG) { + prompt("Num. elements in S") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NET,DBF_ULONG) { + prompt("Num. elements in T") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEU,DBF_ULONG) { + prompt("Num. elements in U") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(OUTA,DBF_OUTLINK) { + prompt("Output Link A") + promptgroup(GUI_OUTPUT) + interest(1) + } + field(OUTB,DBF_OUTLINK) { + prompt("Output Link B") + promptgroup(GUI_OUTPUT) + interest(1) + } + field(OUTC,DBF_OUTLINK) { + prompt("Output Link C") + promptgroup(GUI_OUTPUT) + interest(1) + } + field(OUTD,DBF_OUTLINK) { + prompt("Output Link D") + promptgroup(GUI_OUTPUT) + interest(1) + } + field(OUTE,DBF_OUTLINK) { + prompt("Output Link E") + promptgroup(GUI_OUTPUT) + interest(1) + } + field(OUTF,DBF_OUTLINK) { + prompt("Output Link F") + promptgroup(GUI_OUTPUT) + interest(1) + } + field(OUTG,DBF_OUTLINK) { + prompt("Output Link G") + promptgroup(GUI_OUTPUT) + interest(1) + } + field(OUTH,DBF_OUTLINK) { + prompt("Output Link H") + promptgroup(GUI_OUTPUT) + interest(1) + } + field(OUTI,DBF_OUTLINK) { + prompt("Output Link I") + promptgroup(GUI_OUTPUT) + interest(1) + } + field(OUTJ,DBF_OUTLINK) { + prompt("Output Link J") + promptgroup(GUI_OUTPUT) + interest(1) + } + field(OUTK,DBF_OUTLINK) { + prompt("Output Link K") + promptgroup(GUI_OUTPUT) + interest(1) + } + field(OUTL,DBF_OUTLINK) { + prompt("Output Link L") + promptgroup(GUI_OUTPUT) + interest(1) + } + field(OUTM,DBF_OUTLINK) { + prompt("Output Link M") + promptgroup(GUI_OUTPUT) + interest(1) + } + field(OUTN,DBF_OUTLINK) { + prompt("Output Link N") + promptgroup(GUI_OUTPUT) + interest(1) + } + field(OUTO,DBF_OUTLINK) { + prompt("Output Link O") + promptgroup(GUI_OUTPUT) + interest(1) + } + field(OUTP,DBF_OUTLINK) { + prompt("Output Link P") + promptgroup(GUI_OUTPUT) + interest(1) + } + field(OUTQ,DBF_OUTLINK) { + prompt("Output Link Q") + promptgroup(GUI_OUTPUT) + interest(1) + } + field(OUTR,DBF_OUTLINK) { + prompt("Output Link R") + promptgroup(GUI_OUTPUT) + interest(1) + } + field(OUTS,DBF_OUTLINK) { + prompt("Output Link S") + promptgroup(GUI_OUTPUT) + interest(1) + } + field(OUTT,DBF_OUTLINK) { + prompt("Output Link T") + promptgroup(GUI_OUTPUT) + interest(1) + } + field(OUTU,DBF_OUTLINK) { + prompt("Output Link U") + promptgroup(GUI_OUTPUT) + interest(1) + } + field(VALA,DBF_NOACCESS) { + prompt("Output value A") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *vala") + } + field(VALB,DBF_NOACCESS) { + prompt("Output value B") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *valb") + } + field(VALC,DBF_NOACCESS) { + prompt("Output value C") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *valc") + } + field(VALD,DBF_NOACCESS) { + prompt("Output value D") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *vald") + } + field(VALE,DBF_NOACCESS) { + prompt("Output value E") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *vale") + } + field(VALF,DBF_NOACCESS) { + prompt("Output value F") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *valf") + } + field(VALG,DBF_NOACCESS) { + prompt("Output value G") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *valg") + } + field(VALH,DBF_NOACCESS) { + prompt("Output value H") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *valh") + } + field(VALI,DBF_NOACCESS) { + prompt("Output value I") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *vali") + } + field(VALJ,DBF_NOACCESS) { + prompt("Output value J") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *valj") + } + field(VALK,DBF_NOACCESS) { + prompt("Output value K") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *valk") + } + field(VALL,DBF_NOACCESS) { + prompt("Output value L") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *vall") + } + field(VALM,DBF_NOACCESS) { + prompt("Output value M") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *valm") + } + field(VALN,DBF_NOACCESS) { + prompt("Output value N") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *valn") + } + field(VALO,DBF_NOACCESS) { + prompt("Output value O") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *valo") + } + field(VALP,DBF_NOACCESS) { + prompt("Output value P") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *valp") + } + field(VALQ,DBF_NOACCESS) { + prompt("Output value Q") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *valq") + } + field(VALR,DBF_NOACCESS) { + prompt("Output value R") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *valr") + } + field(VALS,DBF_NOACCESS) { + prompt("Output value S") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *vals") + } + field(VALT,DBF_NOACCESS) { + prompt("Output value T") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *valt") + } + field(VALU,DBF_NOACCESS) { + prompt("Output value U") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *valu") + } + field(OVLA,DBF_NOACCESS) { + prompt("Old Output A") + asl(ASL0) + special(SPC_NOMOD) + interest(4) extra("void *ovla") + } + field(OVLB,DBF_NOACCESS) { + prompt("Old Output B") + asl(ASL0) + special(SPC_NOMOD) + interest(4) extra("void *ovlb") + } + field(OVLC,DBF_NOACCESS) { + prompt("Old Output C") + asl(ASL0) + special(SPC_NOMOD) + interest(4) extra("void *ovlc") + } + field(OVLD,DBF_NOACCESS) { + prompt("Old Output D") + asl(ASL0) + special(SPC_NOMOD) + interest(4) extra("void *ovld") + } + field(OVLE,DBF_NOACCESS) { + prompt("Old Output E") + asl(ASL0) + special(SPC_NOMOD) + interest(4) extra("void *ovle") + } + field(OVLF,DBF_NOACCESS) { + prompt("Old Output F") + asl(ASL0) + special(SPC_NOMOD) + interest(4) extra("void *ovlf") + } + field(OVLG,DBF_NOACCESS) { + prompt("Old Output G") + asl(ASL0) + special(SPC_NOMOD) + interest(4) extra("void *ovlg") + } + field(OVLH,DBF_NOACCESS) { + prompt("Old Output H") + asl(ASL0) + special(SPC_NOMOD) + interest(4) extra("void *ovlh") + } + field(OVLI,DBF_NOACCESS) { + prompt("Old Output I") + asl(ASL0) + special(SPC_NOMOD) + interest(4) extra("void *ovli") + } + field(OVLJ,DBF_NOACCESS) { + prompt("Old Output J") + asl(ASL0) + special(SPC_NOMOD) + interest(4) extra("void *ovlj") + } + field(OVLK,DBF_NOACCESS) { + prompt("Old Output K") + asl(ASL0) + special(SPC_NOMOD) + interest(4) extra("void *ovlk") + } + field(OVLL,DBF_NOACCESS) { + prompt("Old Output L") + asl(ASL0) + special(SPC_NOMOD) + interest(4) extra("void *ovll") + } + field(OVLM,DBF_NOACCESS) { + prompt("Old Output M") + asl(ASL0) + special(SPC_NOMOD) + interest(4) extra("void *ovlm") + } + field(OVLN,DBF_NOACCESS) { + prompt("Old Output N") + asl(ASL0) + special(SPC_NOMOD) + interest(4) extra("void *ovln") + } + field(OVLO,DBF_NOACCESS) { + prompt("Old Output O") + asl(ASL0) + special(SPC_NOMOD) + interest(4) extra("void *ovlo") + } + field(OVLP,DBF_NOACCESS) { + prompt("Old Output P") + asl(ASL0) + special(SPC_NOMOD) + interest(4) extra("void *ovlp") + } + field(OVLQ,DBF_NOACCESS) { + prompt("Old Output Q") + asl(ASL0) + special(SPC_NOMOD) + interest(4) extra("void *ovlq") + } + field(OVLR,DBF_NOACCESS) { + prompt("Old Output R") + asl(ASL0) + special(SPC_NOMOD) + interest(4) extra("void *ovlr") + } + field(OVLS,DBF_NOACCESS) { + prompt("Old Output S") + asl(ASL0) + special(SPC_NOMOD) + interest(4) extra("void *ovls") + } + field(OVLT,DBF_NOACCESS) { + prompt("Old Output T") + asl(ASL0) + special(SPC_NOMOD) + interest(4) extra("void *ovlt") + } + field(OVLU,DBF_NOACCESS) { + prompt("Old Output U") + asl(ASL0) + special(SPC_NOMOD) + interest(4) extra("void *ovlu") + } + field(FTVA,DBF_MENU) { + prompt("Type of VALA") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTVB,DBF_MENU) { + prompt("Type of VALB") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTVC,DBF_MENU) { + prompt("Type of VALC") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTVD,DBF_MENU) { + prompt("Type of VALD") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTVE,DBF_MENU) { + prompt("Type of VALE") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTVF,DBF_MENU) { + prompt("Type of VALF") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTVG,DBF_MENU) { + prompt("Type of VALG") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTVH,DBF_MENU) { + prompt("Type of VALH") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTVI,DBF_MENU) { + prompt("Type of VALI") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTVJ,DBF_MENU) { + prompt("Type of VALJ") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTVK,DBF_MENU) { + prompt("Type of VALK") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTVL,DBF_MENU) { + prompt("Type of VALL") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTVM,DBF_MENU) { + prompt("Type of VALM") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTVN,DBF_MENU) { + prompt("Type of VALN") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTVO,DBF_MENU) { + prompt("Type of VALO") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTVP,DBF_MENU) { + prompt("Type of VALP") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTVQ,DBF_MENU) { + prompt("Type of VALQ") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTVR,DBF_MENU) { + prompt("Type of VALR") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTVS,DBF_MENU) { + prompt("Type of VALS") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTVT,DBF_MENU) { + prompt("Type of VALT") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(FTVU,DBF_MENU) { + prompt("Type of VALU") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("DOUBLE") + menu(menuFtype) + } + field(NOVA,DBF_ULONG) { + prompt("Max. elements in VALA") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOVB,DBF_ULONG) { + prompt("Max. elements in VALB") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOVC,DBF_ULONG) { + prompt("Max. elements in VALC") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOVD,DBF_ULONG) { + prompt("Max. elements in VALD") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOVE,DBF_ULONG) { + prompt("Max. elements in VALE") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOVF,DBF_ULONG) { + prompt("Max. elements in VALF") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOVG,DBF_ULONG) { + prompt("Max. elements in VALG") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOVH,DBF_ULONG) { + prompt("Max. elements in VAlH") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOVI,DBF_ULONG) { + prompt("Max. elements in VALI") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOVJ,DBF_ULONG) { + prompt("Max. elements in VALJ") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOVK,DBF_ULONG) { + prompt("Max. elements in VALK") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOVL,DBF_ULONG) { + prompt("Max. elements in VALL") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOVM,DBF_ULONG) { + prompt("Max. elements in VALM") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOVN,DBF_ULONG) { + prompt("Max. elements in VALN") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOVO,DBF_ULONG) { + prompt("Max. elements in VALO") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOVP,DBF_ULONG) { + prompt("Max. elements in VALP") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOVQ,DBF_ULONG) { + prompt("Max. elements in VALQ") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOVR,DBF_ULONG) { + prompt("Max. elements in VALR") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOVS,DBF_ULONG) { + prompt("Max. elements in VALS") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOVT,DBF_ULONG) { + prompt("Max. elements in VALT") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NOVU,DBF_ULONG) { + prompt("Max. elements in VALU") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(1) + initial("1") + } + field(NEVA,DBF_ULONG) { + prompt("Num. elements in VALA") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEVB,DBF_ULONG) { + prompt("Num. elements in VALB") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEVC,DBF_ULONG) { + prompt("Num. elements in VALC") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEVD,DBF_ULONG) { + prompt("Num. elements in VALD") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEVE,DBF_ULONG) { + prompt("Num. elements in VALE") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEVF,DBF_ULONG) { + prompt("Num. elements in VALF") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEVG,DBF_ULONG) { + prompt("Num. elements in VALG") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEVH,DBF_ULONG) { + prompt("Num. elements in VAlH") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEVI,DBF_ULONG) { + prompt("Num. elements in VALI") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEVJ,DBF_ULONG) { + prompt("Num. elements in VALJ") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEVK,DBF_ULONG) { + prompt("Num. elements in VALK") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEVL,DBF_ULONG) { + prompt("Num. elements in VALL") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEVM,DBF_ULONG) { + prompt("Num. elements in VALM") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEVN,DBF_ULONG) { + prompt("Num. elements in VALN") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEVO,DBF_ULONG) { + prompt("Num. elements in VALO") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEVP,DBF_ULONG) { + prompt("Num. elements in VALP") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEVQ,DBF_ULONG) { + prompt("Num. elements in VALQ") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEVR,DBF_ULONG) { + prompt("Num. elements in VALR") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEVS,DBF_ULONG) { + prompt("Num. elements in VALS") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEVT,DBF_ULONG) { + prompt("Num. elements in VALT") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } + field(NEVU,DBF_ULONG) { + prompt("Num. elements in VALU") + promptgroup(GUI_WAVE) + special(SPC_NOMOD) + interest(3) + initial("1") + } +}